@atomiqlabs/sdk 7.0.12 → 8.0.8

package/dist/utils/Utils.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Buffer } from "buffer";
+/**
+ * Returns a promise that rejects if the passed promise resolves to `undefined` or `null`
+ *
+ * @param promise Promise to check resolve value of
+ * @param msg Optional message to pass to the thrown `Error`
+ * @category Utilities
+ */
+export declare function throwIfUndefined<T>(promise: Promise<T | undefined>, msg?: string): Promise<T>;
+/**
+ * Returns a promise that resolves when any of the passed promises resolves, and rejects if all the underlying
+ *  promises fail with an array of errors returned by the respective promises
+ *
+ * @param promises A list of promises
+ * @category Utilities
+ */
+export declare function promiseAny<T>(promises: Promise<T>[]): Promise<T>;
+/**
+ * Maps a JS object to another JS object based on the translation function, the translation function is called for every
+ *  property (value/key) of the old object and returns the new value of for this property
+ *
+ * @param obj
+ * @param translator
+ */
+export declare function objectMap<InputObject extends {
+    [key in string]: any;
+}, OutputObject extends {
+    [key in keyof InputObject]: any;
+}>(obj: InputObject, translator: <InputKey extends Extract<keyof InputObject, string>>(value: InputObject[InputKey], key: InputKey) => OutputObject[InputKey]): {
+    [key in keyof InputObject]: OutputObject[key];
+};
+/**
+ * Maps the entries from the map to the array using the translator function
+ *
+ * @param map
+ * @param translator
+ */
+export declare function mapToArray<K, V, Output>(map: Map<K, V>, translator: (key: K, value: V) => Output): Output[];
+/**
+ * Creates a new abort controller that will abort if the passed abort signal aborts
+ *
+ * @param abortSignal
+ */
+export declare function extendAbortController(abortSignal?: AbortSignal): AbortController;
+export declare function bigIntMin(a: bigint, b: bigint): bigint;
+export declare function bigIntMin(a?: bigint, b?: bigint): bigint | undefined;
+export declare function bigIntMax(a: bigint, b: bigint): bigint;
+export declare function bigIntMax(a?: bigint, b?: bigint): bigint | undefined;
+export declare function bigIntCompare(a: bigint, b: bigint): -1 | 0 | 1;
+export declare function toBigInt(value: string): bigint;
+export declare function toBigInt(value: undefined): undefined;
+export declare function randomBytes(bytesLength: number): Buffer;
+export declare function getTxoHash(outputScriptHex: string, value: number): Buffer;
+export declare function fromDecimal(amount: string, decimalCount: number): bigint;
+export declare function toDecimal(amount: bigint, decimalCount: number, cut?: boolean, displayDecimals?: number): string;

package/dist/utils/Utils.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDecimal = exports.fromDecimal = exports.getTxoHash = exports.randomBytes = exports.toBigInt = exports.bigIntCompare = exports.bigIntMax = exports.bigIntMin = exports.extendAbortController = exports.mapToArray = exports.objectMap = exports.promiseAny = exports.throwIfUndefined = void 0;
+const buffer_1 = require("buffer");
+const utils_1 = require("@noble/hashes/utils");
+const sha2_1 = require("@noble/hashes/sha2");
+const base_1 = require("@atomiqlabs/base");
+/**
+ * Returns a promise that rejects if the passed promise resolves to `undefined` or `null`
+ *
+ * @param promise Promise to check resolve value of
+ * @param msg Optional message to pass to the thrown `Error`
+ * @category Utilities
+ */
+function throwIfUndefined(promise, msg) {
+    return promise.then(val => {
+        if (val == undefined)
+            throw new Error(msg ?? "Promise value is undefined!");
+        return val;
+    });
+}
+exports.throwIfUndefined = throwIfUndefined;
+/**
+ * Returns a promise that resolves when any of the passed promises resolves, and rejects if all the underlying
+ *  promises fail with an array of errors returned by the respective promises
+ *
+ * @param promises A list of promises
+ * @category Utilities
+ */
+function promiseAny(promises) {
+    return new Promise((resolve, reject) => {
+        let numRejected = 0;
+        const rejectReasons = Array(promises.length);
+        promises.forEach((promise, index) => {
+            promise.then((val) => {
+                if (resolve != null)
+                    resolve(val);
+                resolve = null;
+            }).catch(err => {
+                rejectReasons[index] = err;
+                numRejected++;
+                if (numRejected === promises.length) {
+                    reject(rejectReasons);
+                }
+            });
+        });
+    });
+}
+exports.promiseAny = promiseAny;
+/**
+ * Maps a JS object to another JS object based on the translation function, the translation function is called for every
+ *  property (value/key) of the old object and returns the new value of for this property
+ *
+ * @param obj
+ * @param translator
+ */
+function objectMap(obj, translator) {
+    const resp = {};
+    for (let key in obj) {
+        resp[key] = translator(obj[key], key);
+    }
+    return resp;
+}
+exports.objectMap = objectMap;
+/**
+ * Maps the entries from the map to the array using the translator function
+ *
+ * @param map
+ * @param translator
+ */
+function mapToArray(map, translator) {
+    const arr = Array(map.size);
+    let pointer = 0;
+    for (let entry of map.entries()) {
+        arr[pointer++] = translator(entry[0], entry[1]);
+    }
+    return arr;
+}
+exports.mapToArray = mapToArray;
+/**
+ * Creates a new abort controller that will abort if the passed abort signal aborts
+ *
+ * @param abortSignal
+ */
+function extendAbortController(abortSignal) {
+    const _abortController = new AbortController();
+    if (abortSignal != null) {
+        abortSignal.throwIfAborted();
+        abortSignal.onabort = () => _abortController.abort(abortSignal.reason);
+    }
+    return _abortController;
+}
+exports.extendAbortController = extendAbortController;
+function bigIntMin(a, b) {
+    if (a == null)
+        return b;
+    if (b == null)
+        return a;
+    return a > b ? b : a;
+}
+exports.bigIntMin = bigIntMin;
+function bigIntMax(a, b) {
+    if (a == null)
+        return b;
+    if (b == null)
+        return a;
+    return b > a ? b : a;
+}
+exports.bigIntMax = bigIntMax;
+function bigIntCompare(a, b) {
+    return a > b ? 1 : a === b ? 0 : -1;
+}
+exports.bigIntCompare = bigIntCompare;
+function toBigInt(value) {
+    if (value == null)
+        return undefined;
+    return BigInt(value);
+}
+exports.toBigInt = toBigInt;
+function randomBytes(bytesLength) {
+    return buffer_1.Buffer.from((0, utils_1.randomBytes)(bytesLength));
+}
+exports.randomBytes = randomBytes;
+function getTxoHash(outputScriptHex, value) {
+    return buffer_1.Buffer.from((0, sha2_1.sha256)(buffer_1.Buffer.concat([
+        base_1.BigIntBufferUtils.toBuffer(BigInt(value), "le", 8),
+        buffer_1.Buffer.from(outputScriptHex, "hex")
+    ])));
+}
+exports.getTxoHash = getTxoHash;
+function fromDecimal(amount, decimalCount) {
+    if (amount.includes(".")) {
+        const [before, after] = amount.split(".");
+        if (decimalCount < 0) {
+            return BigInt(before.substring(0, before.length + decimalCount));
+        }
+        if (after.length > decimalCount) {
+            //Cut the last digits
+            return BigInt((before === "0" ? "" : before) + after.substring(0, decimalCount));
+        }
+        return BigInt((before === "0" ? "" : before) + after.padEnd(decimalCount, "0"));
+    }
+    else {
+        if (decimalCount < 0) {
+            return BigInt(amount.substring(0, amount.length + decimalCount));
+        }
+        else {
+            return BigInt(amount + "0".repeat(decimalCount));
+        }
+    }
+}
+exports.fromDecimal = fromDecimal;
+function toDecimal(amount, decimalCount, cut, displayDecimals) {
+    if (decimalCount <= 0) {
+        return amount.toString(10) + "0".repeat(-decimalCount);
+    }
+    const amountStr = amount.toString(10).padStart(decimalCount + 1, "0");
+    const splitPoint = amountStr.length - decimalCount;
+    const decimalPart = amountStr.substring(splitPoint, amountStr.length);
+    let cutTo = decimalPart.length;
+    if (cut && cutTo > 0) {
+        for (let i = decimalPart.length - 1; i--; i >= 0) {
+            if (decimalPart.charAt(i) === "0") {
+                cutTo = i;
+            }
+            else
+                break;
+        }
+        if (cutTo === 0)
+            cutTo = 1;
+    }
+    if (displayDecimals === 0)
+        return amountStr.substring(0, splitPoint);
+    if (displayDecimals != null && cutTo > displayDecimals)
+        cutTo = displayDecimals;
+    return amountStr.substring(0, splitPoint) + "." + decimalPart.substring(0, cutTo);
+}
+exports.toDecimal = toDecimal;

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@atomiqlabs/sdk",
-  "version": "7.0.12",
+  "version": "8.0.8",
   "description": "atomiq labs SDK for cross-chain swaps between smart chains and bitcoin",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build:ts4": "npx -p typescript@4.9 tsc --noEmit",
+    "build:ts5": "npx -p typescript@5.9 tsc --noEmit"
   },
   "files": [
     "/dist",
@@ -21,12 +23,18 @@
   "author": "adambor",
   "license": "ISC",
   "dependencies": {
-    "@atomiqlabs/base": "^12.0.4",
-    "@atomiqlabs/messenger-nostr": "^1.0.1",
-    "@atomiqlabs/sdk-lib": "^16.2.7"
+    "@atomiqlabs/base": "^13.0.4",
+    "@atomiqlabs/bolt11": "1.6.1",
+    "@atomiqlabs/messenger-nostr": "^2.0.0",
+    "@noble/ciphers": "^1.2.1",
+    "@noble/hashes": "^1.7.1",
+    "@scure/base": "^1.2.4",
+    "@scure/btc-signer": "1.7.0",
+    "buffer": "6.0.3",
+    "events": "3.3.0"
   },
   "devDependencies": {
     "@types/node": "22.13.5",
-    "typescript": "4.9.5"
+    "typescript": ">=4"
   }
 }

package/src/SmartChainAssets.ts

@@ -1,4 +1,8 @@
 
+/**
+ * Asset definitions for supported smart chain tokens with pricing information
+ * @category Tokens
+ */
 export const SmartChainAssets = {
     _TESTNET_WBTC_VESU: {
         pricing: {
@@ -32,11 +36,11 @@ export const SmartChainAssets = {
     },
     TBTC: {
         pricing: {
-            binancePair: null,
-            okxPair: null,
+            binancePair: undefined,
+            okxPair: undefined,
             coinGeckoCoinId: "tbtc",
             coinPaprikaCoinId: "tbtc-tbtc",
-            krakenPair: null
+            krakenPair: undefined
         },
         name: "Threshold BTC (tBTC)"
     },
@@ -155,4 +159,8 @@ export const SmartChainAssets = {
     }
 } as const;
 
+/**
+ * Type representing valid smart chain asset ticker symbols
+ * @category Tokens
+ */
 export type SmartChainAssetTickers = keyof typeof SmartChainAssets;

package/src/bitcoin/BitcoinRpcWithAddressIndex.ts

@@ -0,0 +1,87 @@
+import {BitcoinRpc, BtcBlock, BtcTx} from "@atomiqlabs/base";
+import {Buffer} from "buffer";
+
+export type BtcTxWithBlockheight = BtcTx & {
+    blockheight?: number,
+    inputAddresses?: string[]
+};
+
+export type BtcAddressUtxo = {
+    txid: string,
+    vout: number,
+    confirmed: boolean,
+    block_height: number,
+    block_hash: string,
+    block_time: number
+    value: bigint
+};
+
+export interface BitcoinRpcWithAddressIndex<T extends BtcBlock> extends BitcoinRpc<T> {
+
+    getFeeRate(): Promise<number>;
+    getAddressBalances(address: string): Promise<{
+        confirmedBalance: bigint,
+        unconfirmedBalance: bigint
+    }>;
+    getAddressUTXOs(address: string): Promise<BtcAddressUtxo[]>;
+    getCPFPData(txId: string): Promise<{
+        effectiveFeePerVsize: number,
+        adjustedVsize: number
+    }>;
+    getTransaction(txId: string): Promise<BtcTxWithBlockheight | null>;
+    waitForTransaction(
+        txId: string,
+        requiredConfirmations: number,
+        stateUpdateCbk: (btcTx?: BtcTxWithBlockheight, txEtaMS?: number) => void,
+        abortSignal?: AbortSignal,
+        intervalSeconds?: number
+    ): Promise<BtcTxWithBlockheight>;
+
+    /**
+     * Returns an estimate after which time the tx will confirm with the required amount of confirmations,
+     *  confirmationDelay of -1 means the transaction won't confirm in the near future
+     *
+     * @param tx
+     * @param requiredConfirmations
+     * @private
+     *
+     * @returns estimated confirmation delay, -1 if the transaction won't confirm in the near future, null if the
+     *  transaction was replaced or was confirmed in the meantime
+     */
+    getConfirmationDelay(tx: BtcTx, requiredConfirmations: number): Promise<number | null>
+
+    /**
+     * Checks if an address received the transaction with the required txoHash, returns info about that
+     *  specific transaction if found, or null if not found
+     *
+     * @param address Address that should receive the transaction
+     * @param txoHash Required output txoHash
+     */
+    checkAddressTxos(address: string, txoHash: Buffer): Promise<{
+        tx: Omit<BtcTxWithBlockheight, "hex" | "raw">,
+        vout: number
+    } | null>;
+
+    /**
+     * Waits till the address receives a transaction containing a specific txoHash
+     *
+     * @param address Address that should receive the transaction
+     * @param txoHash Required output txoHash
+     * @param requiredConfirmations Required confirmations of the transaction
+     * @param stateUpdateCbk Callback for transaction state updates
+     * @param abortSignal Abort signal
+     * @param intervalSeconds How often to check new transaction
+     */
+    waitForAddressTxo(
+        address: string,
+        txoHash: Buffer,
+        requiredConfirmations: number,
+        stateUpdateCbk: (btcTx?: Omit<BtcTxWithBlockheight, "hex" | "raw">, vout?: number, txEtaMS?: number) => void,
+        abortSignal?: AbortSignal,
+        intervalSeconds?: number
+    ): Promise<{
+        tx: Omit<BtcTxWithBlockheight, "hex" | "raw">,
+        vout: number
+    }>;
+
+}

package/src/bitcoin/LightningNetworkApi.ts

@@ -0,0 +1,16 @@
+
+export type LNNodeLiquidity = {
+    publicKey: string,
+    capacity: bigint,
+    numChannels: number
+};
+
+export interface LightningNetworkApi {
+
+    /**
+     * Returns the lightning network's node liquidity as identified by an identity public key
+     * @param pubkey
+     */
+    getLNNodeLiquidity(pubkey: string): Promise<LNNodeLiquidity | null>
+
+}

package/src/bitcoin/coinselect2/accumulative.ts

@@ -0,0 +1,68 @@
+import {CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, utils} from "./utils";
+
+import {getLogger} from "../../utils/Logger";
+
+const logger = getLogger("CoinSelect: ");
+
+// add inputs until we reach or surpass the target value (or deplete)
+// worst-case: O(n)
+export function accumulative (
+    utxos: CoinselectTxInput[],
+    outputs: CoinselectTxOutput[],
+    feeRate: number,
+    type: CoinselectAddressTypes,
+    requiredInputs?: CoinselectTxInput[]
+): {
+    inputs?: CoinselectTxInput[],
+    outputs?: CoinselectTxOutput[],
+    fee: number
+} {
+    if (!isFinite(utils.uintOrNaN(feeRate))) throw new Error("Invalid feeRate passed!");
+
+    const inputs = requiredInputs==null ? [] : [...requiredInputs];
+    let bytesAccum = utils.transactionBytes(inputs, outputs, type);
+    let fee = feeRate * bytesAccum;
+    let cpfpAddFee = 0;
+    let inAccum = utils.sumOrNaN(inputs);
+    const outAccum = utils.sumOrNaN(outputs);
+
+    logger.debug("accumulative(): total output: ",outAccum);
+
+    for (let i = 0; i < utxos.length; ++i) {
+        const utxo = utxos[i];
+        const utxoBytes = utils.inputBytes(utxo);
+        const utxoFee = feeRate * utxoBytes;
+        const utxoValue = utils.uintOrNaN(utxo.value);
+
+        let cpfpFee = 0;
+        if(utxo.cpfp!=null && utxo.cpfp.txEffectiveFeeRate<feeRate) cpfpFee = Math.ceil(utxo.cpfp.txVsize * (feeRate - utxo.cpfp.txEffectiveFeeRate));
+
+        // skip detrimental input
+        if (utxoFee + cpfpFee > utxo.value) {
+            logger.debug("accumulative("+i+"): Skipping detrimental output, cpfpFee: "+cpfpFee+" utxoFee: "+utxoFee+" value: "+utxo.value);
+            if (i === utxos.length - 1) return { fee: (feeRate * (bytesAccum + utxoBytes)) + cpfpAddFee + cpfpFee };
+            continue
+        }
+
+        bytesAccum += utxoBytes;
+        inAccum += utxoValue;
+        cpfpAddFee += cpfpFee;
+        inputs.push(utxo);
+
+        fee = Math.ceil((feeRate * bytesAccum) + cpfpAddFee);
+
+        logger.debug("accumulative("+i+"): total fee: ", fee);
+        logger.debug("accumulative("+i+"): input value: ", inAccum);
+        logger.debug("accumulative("+i+"): cpfpAddFee: ", cpfpAddFee);
+
+        // go again?
+        if (inAccum < outAccum + fee) continue;
+
+        logger.debug("accumulative("+i+"): Finalizing transaction, inputs: ", inputs);
+        logger.debug("accumulative("+i+"): Finalizing transaction, outputs: ", outputs);
+        logger.debug("accumulative("+i+"): Finalizing transaction, feeRate: ", feeRate);
+        return utils.finalize(inputs, outputs, feeRate, type, cpfpAddFee);
+    }
+
+    return { fee };
+}

package/src/bitcoin/coinselect2/blackjack.ts

@@ -0,0 +1,49 @@
+import {CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, utils} from "./utils";
+
+// add inputs until we reach or surpass the target value (or deplete)
+// worst-case: O(n)
+export function blackjack (
+    utxos: CoinselectTxInput[],
+    outputs: CoinselectTxOutput[],
+    feeRate: number,
+    type: CoinselectAddressTypes,
+    requiredInputs?: CoinselectTxInput[]
+): {
+    inputs?: CoinselectTxInput[],
+    outputs?: CoinselectTxOutput[],
+    fee: number
+} {
+    if (!isFinite(utils.uintOrNaN(feeRate))) throw new Error("Invalid feeRate passed!");
+
+    const inputs = requiredInputs==null ? [] : [...requiredInputs];
+    let bytesAccum = utils.transactionBytes(inputs, outputs, type);
+    let inAccum = utils.sumOrNaN(inputs);
+    let cpfpAddFee = 0;
+    const outAccum = utils.sumOrNaN(outputs);
+    const threshold = utils.dustThreshold({type});
+
+    for (let i = 0; i < utxos.length; ++i) {
+        const input = utxos[i];
+        const inputBytes = utils.inputBytes(input);
+        let cpfpFee = 0;
+        if(input.cpfp!=null && input.cpfp.txEffectiveFeeRate<feeRate) cpfpFee = Math.ceil(input.cpfp.txVsize * (feeRate - input.cpfp.txEffectiveFeeRate));
+
+        const fee = Math.ceil((feeRate * (bytesAccum + inputBytes)) + cpfpAddFee + cpfpFee);
+        const inputValue = utils.uintOrNaN(input.value);
+
+        // would it waste value?
+        if ((inAccum + inputValue) > (outAccum + fee + threshold)) continue;
+
+        bytesAccum += inputBytes;
+        inAccum += inputValue;
+        cpfpAddFee += cpfpFee;
+        inputs.push(input);
+
+        // go again?
+        if (inAccum < outAccum + fee) continue;
+
+        return utils.finalize(inputs, outputs, feeRate, type, cpfpAddFee);
+    }
+
+    return { fee: (feeRate * bytesAccum) + cpfpAddFee };
+}

package/src/bitcoin/coinselect2/index.ts

@@ -0,0 +1,92 @@
+import {accumulative} from "./accumulative"
+import {blackjack} from "./blackjack"
+import {CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, DUST_THRESHOLDS, utils} from "./utils"
+
+// order by descending value, minus the inputs approximate fee
+function utxoScore (x: CoinselectTxInput, feeRate: number) {
+    let valueAfterFee = x.value - (feeRate * utils.inputBytes(x))
+    if(x.cpfp!=null && x.cpfp.txEffectiveFeeRate<feeRate) valueAfterFee -= x.cpfp.txVsize*(feeRate - x.cpfp.txEffectiveFeeRate);
+    return valueAfterFee;
+}
+
+export {CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, DUST_THRESHOLDS};
+
+export function coinSelect (
+    utxos: CoinselectTxInput[],
+    outputs: CoinselectTxOutput[],
+    feeRate: number,
+    type: CoinselectAddressTypes,
+    requiredInputs?: CoinselectTxInput[]
+): {
+    inputs?: CoinselectTxInput[],
+    outputs?: CoinselectTxOutput[],
+    fee: number
+} {
+    // order by descending value, minus the inputs approximate fee
+    utxos = utxos.sort((a, b) => {
+        // if(a.cpfp!=null && b.cpfp==null) return 1;
+        // if(a.cpfp==null && b.cpfp!=null) return -1;
+        return utxoScore(b, feeRate) - utxoScore(a, feeRate);
+    });
+
+    // attempt to use the blackjack strategy first (no change output)
+    const base = blackjack(utxos, outputs, feeRate, type, requiredInputs);
+    if (base.inputs) return base;
+
+    // else, try the accumulative strategy
+    return accumulative(utxos, outputs, feeRate, type, requiredInputs);
+}
+
+export function maxSendable (
+    utxos: CoinselectTxInput[],
+    output: {script: Buffer, type: CoinselectAddressTypes},
+    feeRate: number,
+    requiredInputs?: CoinselectTxInput[],
+    additionalOutputs?: {script: Buffer, value: number}[],
+): {
+    value: number,
+    fee: number
+} {
+    if (!isFinite(utils.uintOrNaN(feeRate))) throw new Error("Invalid feeRate passed!");
+
+    const outputs = additionalOutputs ?? [];
+    const inputs = requiredInputs ?? [];
+    let bytesAccum = utils.transactionBytes(inputs, (outputs as {script: Buffer}[]).concat([output]));
+    let cpfpAddFee = 0;
+    let inAccum = utils.sumOrNaN(inputs);
+    let outAccum = utils.sumOrNaN(outputs);
+
+    for (let i = 0; i < utxos.length; ++i) {
+        const utxo = utxos[i];
+        const utxoBytes = utils.inputBytes(utxo);
+        const utxoFee = feeRate * utxoBytes;
+        let cpfpFee = 0;
+        if(utxo.cpfp!=null && utxo.cpfp.txEffectiveFeeRate<feeRate) cpfpFee = utxo.cpfp.txVsize*(feeRate - utxo.cpfp.txEffectiveFeeRate);
+        const utxoValue = utils.uintOrNaN(utxo.value);
+
+        // skip detrimental input
+        if (utxoFee + cpfpFee > utxo.value) {
+            continue;
+        }
+
+        bytesAccum += utxoBytes;
+        inAccum += utxoValue;
+        cpfpAddFee += cpfpFee;
+        inputs.push(utxo);
+    }
+
+    const fee = (feeRate * bytesAccum) + cpfpAddFee;
+    const outputValue = inAccum - fee - outAccum;
+
+    const dustThreshold = DUST_THRESHOLDS[output.type];
+
+    if(outputValue<dustThreshold) return {
+        fee,
+        value: 0
+    };
+
+    return {
+        fee,
+        value: outputValue
+    };
+}