@xlink-network/xlink-sdk
Version:
482 lines (472 loc) • 14.2 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/bitcoinUtils/selectUTXOs.ts
var selectUTXOs_exports = {};
__export(selectUTXOs_exports, {
reselectSpendableUTXOsFactory: () => reselectSpendableUTXOsFactory,
reselectSpendableUTXOsWithSafePadFactory: () => reselectSpendableUTXOsWithSafePadFactory,
selectUTXOs: () => selectUTXOs
});
module.exports = __toCommonJS(selectUTXOs_exports);
// src/utils/arrayHelpers.ts
function hasAny(ary) {
return ary.length > 0;
}
function last(ary) {
return ary[ary.length - 1];
}
var _concat = [].concat;
var _reduce = [].reduce;
function reduce(fn, initialValue, inputArray) {
return _reduce.call(inputArray, fn, initialValue);
}
function sortBy(iteratee, ary) {
const _iteratee = Array.isArray(iteratee) ? iteratee : [iteratee];
return ary.map((value, index, ary2) => ({
value,
index,
criteria: _iteratee.map((f) => f(value, index, ary2))
})).sort((left, right) => compareMultiple(left, right)).map((v) => v.value);
}
function compareMultiple(obj, oth) {
const objCriteria = obj.criteria;
const othCriteria = oth.criteria;
const length = objCriteria.length;
let index = -1;
while (++index < length) {
const objCri = objCriteria[index];
const othCri = othCriteria[index];
let result = 0;
if (typeof objCri === typeof othCri) {
result = Number(objCri - othCri);
} else {
result = Number(objCri) - Number(othCri);
}
if (result) return result;
}
return obj.index - oth.index;
}
// src/utils/bigintHelpers.ts
var MAX_BIGINT = BigInt(Number.MAX_VALUE);
function sum(nums) {
return nums.reduce((acc, val) => acc + val, 0n);
}
// src/bitcoinUtils/bitcoinHelpers.ts
var btc = __toESM(require("@scure/btc-signer"));
var import_btc_signer = require("@scure/btc-signer");
// src/utils/BigNumber.ts
var import_big = require("big.js");
import_big.Big.PE = 21;
import_big.Big.NE = -21;
var toBig = (num) => {
if (num instanceof import_big.Big) {
return num;
}
return new import_big.Big(num);
};
var fromBig = (num) => {
return num;
};
var BigNumber;
((BigNumber2) => {
({ roundUp: BigNumber2.roundUp, roundDown: BigNumber2.roundDown, roundHalfUp: BigNumber2.roundHalfUp, roundHalfEven: BigNumber2.roundHalfEven } = import_big.Big);
let defaultRoundingMode = BigNumber2.roundHalfUp;
BigNumber2.setDefaultRoundingMode = (roundingMode) => {
defaultRoundingMode = roundingMode;
};
BigNumber2.isBigNumber = (num) => {
return num instanceof import_big.Big;
};
BigNumber2.safeFrom = (value) => {
try {
return (0, BigNumber2.from)(value);
} catch (e) {
return void 0;
}
};
BigNumber2.from = (value) => {
return fromBig(toBig(value));
};
BigNumber2.toString = (value) => {
return toBig(value).toString();
};
BigNumber2.toNumber = (value) => {
return toBig(value).toNumber();
};
BigNumber2.toBigInt = curry2(
(options, value) => {
return BigInt(
(0, BigNumber2.toFixed)(
{
precision: 0,
roundingMode: options.roundingMode ?? defaultRoundingMode
},
toBig(value)
)
);
}
);
BigNumber2.toFixed = curry2(
(options, value) => {
return toBig(value).toFixed(
options.precision,
options.roundingMode ?? defaultRoundingMode
);
}
);
BigNumber2.toExponential = curry2(
(options, value) => {
return toBig(value).toExponential(
options.precision,
options.roundingMode ?? defaultRoundingMode
);
}
);
BigNumber2.isNegative = (value) => {
return toBig(value).lt(0);
};
BigNumber2.isGtZero = (value) => {
return toBig(value).gt(0);
};
BigNumber2.isZero = (value) => {
return toBig(value).eq(0);
};
BigNumber2.isEq = curry2(
(value, a) => {
return toBig(value).eq(toBig(a));
}
);
BigNumber2.isGt = curry2(
(value, a) => {
return toBig(value).gt(toBig(a));
}
);
BigNumber2.isGte = curry2(
(value, a) => {
return toBig(value).gte(toBig(a));
}
);
BigNumber2.isLt = curry2(
(value, a) => {
return toBig(value).lt(toBig(a));
}
);
BigNumber2.isLte = curry2(
(value, a) => {
return toBig(value).lte(toBig(a));
}
);
BigNumber2.setPrecision = curry2(
(options, value) => {
return fromBig(
toBig(
toBig(value).toPrecision(
options.precision,
options.roundingMode ?? defaultRoundingMode
)
)
);
}
);
BigNumber2.getPrecision = (value) => {
return toBig(value).c.length - (toBig(value).e + 1);
};
BigNumber2.getIntegerLength = (value) => {
return toBig(value).e + 1;
};
BigNumber2.leftMoveDecimals = curry2(
(distance, value) => (0, BigNumber2.moveDecimals)({ distance }, value)
);
BigNumber2.rightMoveDecimals = curry2(
(distance, value) => (0, BigNumber2.moveDecimals)({ distance: -distance }, value)
);
BigNumber2.moveDecimals = curry2(
(options, value) => {
if (options.distance > 0) {
return fromBig(toBig(value).div(10 ** options.distance));
}
if (options.distance < 0) {
return fromBig(toBig(value).mul(10 ** -options.distance));
}
return (0, BigNumber2.from)(value);
}
);
BigNumber2.getDecimalPart = curry2(
(options, value) => {
const formatted = (0, BigNumber2.toFixed)(
{
precision: Math.min((0, BigNumber2.getPrecision)(value), options.precision),
roundingMode: BigNumber2.roundDown
},
value
);
const [, decimals] = formatted.split(".");
if (decimals == null) return void 0;
return decimals;
}
);
BigNumber2.abs = (value) => {
return fromBig(toBig(value).abs());
};
BigNumber2.neg = (value) => {
return fromBig(toBig(value).neg());
};
BigNumber2.sqrt = (value) => {
return fromBig(toBig(value).sqrt());
};
BigNumber2.add = curry2(
(value, a) => {
return fromBig(toBig(value).add(toBig(a)));
}
);
BigNumber2.minus = curry2(
(value, a) => {
return fromBig(toBig(value).minus(toBig(a)));
}
);
BigNumber2.mul = curry2(
(value, a) => {
return fromBig(toBig(value).mul(toBig(a)));
}
);
BigNumber2.cumulativeMul = curry2(
(value, as) => {
return reduce(
(acc, currentRate) => [
...acc,
BigNumber2.mul(last(acc), currentRate)
],
[(0, BigNumber2.from)(value)],
as
);
}
);
BigNumber2.div = curry2(
(value, a) => {
return fromBig(toBig(value).div(toBig(a)));
}
);
BigNumber2.pow = curry2((value, a) => {
return fromBig(toBig(value).pow(a));
});
BigNumber2.round = curry2(
(options, value) => {
return fromBig(
toBig(value).round(
options.precision,
options.roundingMode ?? defaultRoundingMode
)
);
}
);
BigNumber2.toPrecision = curry2(
(options, value) => {
return toBig(value).toPrecision(
options.precision,
options.roundingMode ?? defaultRoundingMode
);
}
);
BigNumber2.ascend = curry2(
(a, b) => (0, BigNumber2.isLt)(a, b) ? -1 : (0, BigNumber2.isGt)(a, b) ? 1 : 0
);
BigNumber2.descend = curry2(
(a, b) => (0, BigNumber2.isLt)(a, b) ? 1 : (0, BigNumber2.isGt)(a, b) ? -1 : 0
);
BigNumber2.sort = (comparator, numbers) => {
const _numbers = numbers.map((a) => fromBig(toBig(a)));
_numbers.sort(comparator);
return _numbers;
};
BigNumber2.max = (numbers) => {
return (0, BigNumber2.from)((0, BigNumber2.sort)(BigNumber2.descend, numbers)[0]);
};
BigNumber2.min = (numbers) => {
return (0, BigNumber2.from)((0, BigNumber2.sort)(BigNumber2.ascend, numbers)[0]);
};
BigNumber2.clamp = (range, n) => {
const [min2, max2] = range;
if ((0, BigNumber2.isGte)(n, max2)) return max2;
if ((0, BigNumber2.isLte)(n, min2)) return min2;
return n;
};
BigNumber2.sum = (numbers) => {
return numbers.map((n) => fromBig(toBig(n))).reduce((acc, n) => (0, BigNumber2.add)(acc, n), BigNumber2.ZERO);
};
BigNumber2.ZERO = BigNumber2.from(0);
BigNumber2.ONE = BigNumber2.from(1);
})(BigNumber || (BigNumber = {}));
function curry2(fn) {
return function(a, b) {
if (arguments.length > 1) {
return fn(a, b);
}
return (b2) => fn(a, b2);
};
}
// src/bitcoinUtils/bitcoinHelpers.ts
function sumUTXO(utxos) {
return sum(utxos.map((utxo) => utxo.amount));
}
function isSameUTXO(utxo1, utxo2) {
return utxo1.txId === utxo2.txId && utxo1.index === utxo2.index;
}
// src/utils/errors.ts
var XLinkSDKErrorBase = class extends Error {
constructor(...args) {
super(...args);
this.name = "XLinkSDKErrorBase";
}
};
// src/utils/hexHelpers.ts
function decodeHex(hex) {
let hexString = hex.startsWith("0x") ? hex.slice(2) : hex;
if (hexString.length % 2) hexString = `0${hexString}`;
const length = hexString.length / 2;
const bytes = new Uint8Array(length);
for (let index = 0, j = 0; index < length; index++) {
const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
if (nibbleLeft === void 0 || nibbleRight === void 0) {
throw new XLinkSDKErrorBase(
`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`
);
}
bytes[index] = nibbleLeft * 16 + nibbleRight;
}
return bytes;
}
var charCodeMap = {
zero: 48,
nine: 57,
A: 65,
F: 70,
a: 97,
f: 102
};
function charCodeToBase16(char) {
if (char >= charCodeMap.zero && char <= charCodeMap.nine)
return char - charCodeMap.zero;
if (char >= charCodeMap.A && char <= charCodeMap.F)
return char - (charCodeMap.A - 10);
if (char >= charCodeMap.a && char <= charCodeMap.f)
return char - (charCodeMap.a - 10);
return void 0;
}
var hexes = Array.from(
{ length: 256 },
(_v, i) => i.toString(16).padStart(2, "0")
);
// src/utils/typeHelpers.ts
function isNotNull(input) {
return input != null;
}
function assertExclude(asserting, excluding) {
return;
}
((assertExclude2) => {
assertExclude2.i = () => null;
})(assertExclude || (assertExclude = {}));
// src/bitcoinUtils/selectUTXOs.ts
var reselectSpendableUTXOsFactory = (availableUTXOs, getUTXOSpendable) => {
return async (satsToSend, pinnedUTXOs, _lastTimeSelectedUTXOs) => {
const lastTimeSelectedUTXOs = await Promise.all(
_lastTimeSelectedUTXOs.map(getUTXOSpendable)
).then((utxos) => utxos.filter(isNotNull));
const otherAvailableUTXOs = await Promise.all(
availableUTXOs.filter(
(availableUTXO) => !lastTimeSelectedUTXOs.find(
(selectedUTXO) => isSameUTXO(availableUTXO, selectedUTXO)
)
).map(getUTXOSpendable)
).then((utxos) => utxos.filter(isNotNull));
return selectUTXOs(satsToSend, lastTimeSelectedUTXOs, otherAvailableUTXOs);
};
};
var reselectSpendableUTXOsWithSafePadFactory = (availableUTXOs, getUTXOSpendable) => {
const reselect = reselectSpendableUTXOsFactory(
availableUTXOs,
getUTXOSpendable
);
return async (satsToSend, pinnedUTXOs, lastTimeSelectedUTXOs) => {
const utxos = await reselect(satsToSend, pinnedUTXOs, lastTimeSelectedUTXOs);
const selectedAmount = sumUTXO(utxos);
const difference = satsToSend - selectedAmount;
if (difference > 0n) {
return utxos.concat({
addressType: "p2pkh",
txId: "0000000000000000000000000000000000000000000000000000000000000000",
index: 0,
amount: MAX_BIGINT,
/**
* OutScript.encode({
* type: 'pkh',
* hash: hash160(secp256k1.getPublicKey(
* hex.decode('0000000000000000000000000000000000000000000000000000000000000001'),
* false,
* ))
* })
*/
scriptPubKey: decodeHex(
"76a91491b24bf9f5288532960ac687abb035127b1d28a588ac"
),
isPublicKeyCompressed: false
});
}
return utxos;
};
};
function selectUTXOs(satsToSend, selectedUTXOs, otherAvailableUTXOs) {
const inputs = [];
let sumValue = 0n;
otherAvailableUTXOs = otherAvailableUTXOs.slice();
if (hasAny(selectedUTXOs)) {
inputs.push(...selectedUTXOs);
sumValue = sum([sumValue, ...selectedUTXOs.map((o) => o.amount)]);
}
otherAvailableUTXOs = sortBy(
[(o) => -o.amount, (o) => o.blockHeight],
otherAvailableUTXOs
);
for (const utxo of otherAvailableUTXOs) {
inputs.push(utxo);
sumValue = sumValue + utxo.amount;
if (sumValue >= satsToSend) {
break;
}
}
return inputs;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
reselectSpendableUTXOsFactory,
reselectSpendableUTXOsWithSafePadFactory,
selectUTXOs
});
//# sourceMappingURL=selectUTXOs.js.map