@atomiqlabs/sdk 7.0.12 → 8.0.7

package/dist/types/lnurl/LNURLPay.d.ts

@@ -0,0 +1,54 @@
+/**
+ * LNURL-pay request parameters
+ * @category Bitcoin
+ */
+export type LNURLPayParams = {
+    tag: "payRequest";
+    callback: string;
+    domain: string;
+    minSendable: number;
+    maxSendable: number;
+    metadata: string;
+    decodedMetadata: string[][];
+    commentAllowed: number;
+};
+/**
+ * LNURL-pay parameters with URL
+ * @category Bitcoin
+ */
+export type LNURLPayParamsWithUrl = LNURLPayParams & {
+    url: string;
+};
+/**
+ * LNURL-pay specification
+ * @category Bitcoin
+ */
+export type LNURLPay = {
+    type: "pay";
+    min: bigint;
+    max: bigint;
+    commentMaxLength: number;
+    shortDescription?: string;
+    longDescription?: string;
+    icon?: string;
+    params: LNURLPayParamsWithUrl;
+};
+/**
+ * Type guard for LNURL-pay parameters
+ * @category Bitcoin
+ */
+export declare function isLNURLPayParams(obj: any): obj is LNURLPayParams;
+/**
+ * Type guard for LNURL-pay
+ * @category Bitcoin
+ */
+export declare function isLNURLPay(value: any): value is LNURLPay;
+/**
+ * Decoded LNURL-pay success action
+ * @category Bitcoin
+ */
+export type LNURLDecodedSuccessAction = {
+    description: string;
+    text?: string;
+    url?: string;
+};

package/dist/types/lnurl/LNURLPay.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLNURLPay = exports.isLNURLPayParams = void 0;
+/**
+ * Type guard for LNURL-pay parameters
+ * @category Bitcoin
+ */
+function isLNURLPayParams(obj) {
+    return obj.tag === "payRequest";
+}
+exports.isLNURLPayParams = isLNURLPayParams;
+/**
+ * Type guard for LNURL-pay
+ * @category Bitcoin
+ */
+function isLNURLPay(value) {
+    return (typeof value === "object" &&
+        value != null &&
+        value.type === "pay" &&
+        typeof (value.min) === "bigint" &&
+        typeof (value.max) === "bigint" &&
+        typeof value.commentMaxLength === "number" &&
+        (value.shortDescription === undefined || typeof value.shortDescription === "string") &&
+        (value.longDescription === undefined || typeof value.longDescription === "string") &&
+        (value.icon === undefined || typeof value.icon === "string") &&
+        isLNURLPayParams(value.params));
+}
+exports.isLNURLPay = isLNURLPay;

package/dist/types/lnurl/LNURLWithdraw.d.ts

@@ -0,0 +1,42 @@
+/**
+ * LNURL-withdraw request parameters
+ * @category Bitcoin
+ */
+export type LNURLWithdrawParams = {
+    tag: "withdrawRequest";
+    k1: string;
+    callback: string;
+    domain: string;
+    minWithdrawable: number;
+    maxWithdrawable: number;
+    defaultDescription: string;
+    balanceCheck?: string;
+    payLink?: string;
+};
+/**
+ * LNURL-withdraw parameters with URL
+ * @category Bitcoin
+ */
+export type LNURLWithdrawParamsWithUrl = LNURLWithdrawParams & {
+    url: string;
+};
+/**
+ * LNURL-withdraw specification
+ * @category Bitcoin
+ */
+export type LNURLWithdraw = {
+    type: "withdraw";
+    min: bigint;
+    max: bigint;
+    params: LNURLWithdrawParamsWithUrl;
+};
+/**
+ * Type guard for LNURL-withdraw
+ * @category Bitcoin
+ */
+export declare function isLNURLWithdraw(value: any): value is LNURLWithdraw;
+/**
+ * Type guard for LNURL-withdraw parameters
+ * @category Bitcoin
+ */
+export declare function isLNURLWithdrawParams(obj: any): obj is LNURLWithdrawParams;

package/dist/types/lnurl/LNURLWithdraw.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLNURLWithdrawParams = exports.isLNURLWithdraw = void 0;
+/**
+ * Type guard for LNURL-withdraw
+ * @category Bitcoin
+ */
+function isLNURLWithdraw(value) {
+    return (typeof value === "object" &&
+        value != null &&
+        value.type === "withdraw" &&
+        typeof (value.min) === "bigint" &&
+        typeof (value.max) === "bigint" &&
+        isLNURLWithdrawParams(value.params));
+}
+exports.isLNURLWithdraw = isLNURLWithdraw;
+/**
+ * Type guard for LNURL-withdraw parameters
+ * @category Bitcoin
+ */
+function isLNURLWithdrawParams(obj) {
+    return obj.tag === "withdrawRequest";
+}
+exports.isLNURLWithdrawParams = isLNURLWithdrawParams;

package/dist/utils/AutomaticClockDriftCorrection.d.ts

@@ -0,0 +1 @@
+export declare function correctClock(): Promise<void>;

package/dist/utils/AutomaticClockDriftCorrection.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.correctClock = void 0;
+const TimeoutUtils_1 = require("./TimeoutUtils");
+const headerUrls = ["https://api.atomiq.exchange/"];
+async function getHeaderTimestamp(url) {
+    const timeStart = performance.now();
+    const resp = await fetch(url, { method: "HEAD", signal: (0, TimeoutUtils_1.timeoutSignal)(3000) });
+    const timeDelta = performance.now() - timeStart;
+    const dateHeaderValue = resp.headers.get("Date");
+    if (dateHeaderValue == null)
+        throw new Error("Date header not returned!");
+    return { delta: timeDelta, timestamp: new Date(dateHeaderValue).getTime() };
+}
+async function getBinanceTimestamp() {
+    const timeStart = performance.now();
+    const resp = await fetch("https://api.binance.com/api/v3/time", { signal: (0, TimeoutUtils_1.timeoutSignal)(3000) });
+    const timeDelta = performance.now() - timeStart;
+    const obj = await resp.json();
+    if (obj == null || obj.serverTime == null)
+        throw new Error("Timestamp not returned!");
+    return { delta: timeDelta, timestamp: Math.floor(obj.serverTime) };
+}
+async function getOKXTimestamp() {
+    const timeStart = performance.now();
+    const resp = await fetch("https://www.okx.com/api/v5/public/time", { signal: (0, TimeoutUtils_1.timeoutSignal)(3000) });
+    const timeDelta = performance.now() - timeStart;
+    const obj = await resp.json();
+    if (obj == null || obj.data == null || obj.data[0] == null || obj.data[0].ts == null)
+        throw new Error("Timestamp not returned!");
+    return { delta: timeDelta, timestamp: Math.floor(obj.data[0].ts) };
+}
+async function getAisenseApiTimestamp() {
+    const timeStart = performance.now();
+    const resp = await fetch("https://aisenseapi.com/services/v1/timestamp", { signal: (0, TimeoutUtils_1.timeoutSignal)(3000) });
+    const timeDelta = performance.now() - timeStart;
+    const obj = await resp.json();
+    if (obj == null || obj.timestamp == null)
+        throw new Error("Timestamp not returned!");
+    return { delta: timeDelta, timestamp: Math.floor(obj.timestamp * 1000) };
+}
+async function correctClock() {
+    const dateNow = Date._now ?? Date.now;
+    const dateStart = performance.now();
+    try {
+        let result = await Promise.any([
+            ...headerUrls.map(url => getHeaderTimestamp(url)),
+            getAisenseApiTimestamp(),
+            getBinanceTimestamp(),
+            getOKXTimestamp()
+        ]);
+        const desiredTime = result.timestamp - (result.delta / 2);
+        if (Math.abs(Date.now() - desiredTime) < 2000) {
+            console.log("AutomaticClockDriftCorrection: correctClock(): Time drift too small, not adjusting!");
+            return;
+        }
+        const timeDrift = dateStart - desiredTime;
+        console.log(`AutomaticClockDriftCorrection: correctClock(): Time correction perf.now: ${dateStart}, server: ${desiredTime}, time diff: ${timeDrift}`);
+        Date._now = dateNow;
+        Date.now = () => {
+            return Math.floor(performance.now() - timeDrift);
+        };
+    }
+    catch (e) {
+        if (e instanceof AggregateError)
+            e.message = "Cannot sync time! All servers responded negatively!";
+        throw e;
+    }
+}
+exports.correctClock = correctClock;

package/dist/utils/BitcoinUtils.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { BTC_NETWORK } from "@scure/btc-signer/utils";
+import { Buffer } from "buffer";
+import { Transaction } from "@scure/btc-signer";
+import { CoinselectAddressTypes } from "../bitcoin/coinselect2";
+export declare function toOutputScript(network: BTC_NETWORK, address: string): Buffer;
+export declare function toCoinselectAddressType(outputScript: Uint8Array): CoinselectAddressTypes;
+/**
+ * General parsers for PSBTs, can parse hex or base64 encoded PSBTs
+ * @param _psbt
+ */
+export declare function parsePsbtTransaction(_psbt: Transaction | string): Transaction;

package/dist/utils/BitcoinUtils.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePsbtTransaction = exports.toCoinselectAddressType = exports.toOutputScript = void 0;
+const utils_1 = require("@scure/btc-signer/utils");
+const buffer_1 = require("buffer");
+const btc_signer_1 = require("@scure/btc-signer");
+function toOutputScript(network, address) {
+    const outputScript = (0, btc_signer_1.Address)(network).decode(address);
+    switch (outputScript.type) {
+        case "pkh":
+        case "sh":
+        case "wpkh":
+        case "wsh":
+            return buffer_1.Buffer.from(btc_signer_1.OutScript.encode({
+                type: outputScript.type,
+                hash: outputScript.hash
+            }));
+        case "tr":
+            try {
+                return buffer_1.Buffer.from(btc_signer_1.OutScript.encode({
+                    type: "tr",
+                    pubkey: outputScript.pubkey
+                }));
+            }
+            catch (e) {
+                let msg = "";
+                if (e.name != null)
+                    msg += ": " + e.name;
+                if (e.message != null)
+                    msg += ": " + e.message;
+                if (typeof (e) === "string")
+                    msg += ": " + e;
+                msg += ", isBytes: " + (0, utils_1.isBytes)(outputScript.pubkey);
+                try {
+                    (0, utils_1.validatePubkey)(outputScript.pubkey, utils_1.PubT.schnorr);
+                    msg += ", validatePubkey: success";
+                }
+                catch (e) {
+                    msg += ", validatePubkeyError: ";
+                    if (e.name != null)
+                        msg += ": " + e.name;
+                    if (e.message != null)
+                        msg += ": " + e.message;
+                    if (typeof (e) === "string")
+                        msg += ": " + e;
+                }
+                throw new Error(msg);
+            }
+    }
+    throw new Error(`Unrecognized output script type: ${outputScript.type}`);
+}
+exports.toOutputScript = toOutputScript;
+function toCoinselectAddressType(outputScript) {
+    const data = btc_signer_1.OutScript.decode(outputScript);
+    switch (data.type) {
+        case "pkh":
+            return "p2pkh";
+        case "sh":
+            return "p2sh-p2wpkh";
+        case "wpkh":
+            return "p2wpkh";
+        case "wsh":
+            return "p2wsh";
+        case "tr":
+            return "p2tr";
+    }
+    throw new Error("Unrecognized address type!");
+}
+exports.toCoinselectAddressType = toCoinselectAddressType;
+/**
+ * General parsers for PSBTs, can parse hex or base64 encoded PSBTs
+ * @param _psbt
+ */
+function parsePsbtTransaction(_psbt) {
+    if (typeof (_psbt) === "string") {
+        let rawPsbt;
+        if (/^(?:[0-9a-fA-F]{2})+$/.test(_psbt)) {
+            //Hex
+            rawPsbt = buffer_1.Buffer.from(_psbt, "hex");
+        }
+        else if (/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(_psbt)) {
+            //Base64
+            rawPsbt = buffer_1.Buffer.from(_psbt, "base64");
+        }
+        else {
+            throw new Error("Provided psbt string not base64 nor hex encoded!");
+        }
+        return btc_signer_1.Transaction.fromPSBT(rawPsbt, {
+            allowUnknownOutputs: true,
+            allowUnknownInputs: true,
+            allowLegacyWitnessUtxo: true,
+        });
+    }
+    else {
+        return _psbt;
+    }
+}
+exports.parsePsbtTransaction = parsePsbtTransaction;

package/dist/utils/BitcoinWalletUtils.d.ts

@@ -0,0 +1,7 @@
+import { IBitcoinWallet } from "../bitcoin/wallet/IBitcoinWallet";
+import { BitcoinRpcWithAddressIndex } from "../bitcoin/BitcoinRpcWithAddressIndex";
+import { BTC_NETWORK } from "@scure/btc-signer/utils";
+export declare function toBitcoinWallet(_bitcoinWallet: IBitcoinWallet | {
+    address: string;
+    publicKey: string;
+}, btcRpc: BitcoinRpcWithAddressIndex<any>, bitcoinNetwork: BTC_NETWORK): IBitcoinWallet;

package/dist/utils/BitcoinWalletUtils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBitcoinWallet = void 0;
+const IBitcoinWallet_1 = require("../bitcoin/wallet/IBitcoinWallet");
+const SingleAddressBitcoinWallet_1 = require("../bitcoin/wallet/SingleAddressBitcoinWallet");
+function toBitcoinWallet(_bitcoinWallet, btcRpc, bitcoinNetwork) {
+    if ((0, IBitcoinWallet_1.isIBitcoinWallet)(_bitcoinWallet)) {
+        return _bitcoinWallet;
+    }
+    else {
+        return new SingleAddressBitcoinWallet_1.SingleAddressBitcoinWallet(btcRpc, bitcoinNetwork, _bitcoinWallet);
+    }
+}
+exports.toBitcoinWallet = toBitcoinWallet;

package/dist/utils/Logger.d.ts

@@ -0,0 +1,7 @@
+export type LoggerType = {
+    debug: (msg: string, ...args: any[]) => void;
+    info: (msg: string, ...args: any[]) => void;
+    warn: (msg: string, ...args: any[]) => void;
+    error: (msg: string, ...args: any[]) => void;
+};
+export declare function getLogger(prefix: string): LoggerType;

package/dist/utils/Logger.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = void 0;
+function getLogger(prefix) {
+    return {
+        debug: (msg, ...args) => global.atomiqLogLevel >= 3 && console.debug(prefix + msg, ...args),
+        info: (msg, ...args) => global.atomiqLogLevel >= 2 && console.info(prefix + msg, ...args),
+        warn: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 1) && console.warn(prefix + msg, ...args),
+        error: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 0) && console.error(prefix + msg, ...args)
+    };
+}
+exports.getLogger = getLogger;

package/dist/utils/RetryUtils.d.ts

@@ -0,0 +1,21 @@
+type Constructor<T = any> = new (...args: any[]) => T;
+/**
+ * Runs the passed function multiple times if it fails
+ *
+ * @param func A callback for executing the action
+ * @param func.retryCount Count of the current retry, starting from 0 for original request and increasing
+ * @param retryPolicy Retry policy
+ * @param retryPolicy.maxRetries How many retries to attempt in total
+ * @param retryPolicy.delay How long should the delay be
+ * @param retryPolicy.exponential Whether to use exponentially increasing delays
+ * @param errorAllowed A callback for determining whether a given error is allowed, and we should therefore not retry
+ * @param abortSignal
+ * @returns Result of the action executing callback
+ * @category Utilities
+ */
+export declare function tryWithRetries<T>(func: (retryCount: number) => Promise<T>, retryPolicy?: {
+    maxRetries?: number;
+    delay?: number;
+    exponential?: boolean;
+}, errorAllowed?: ((e: any) => boolean) | Constructor<Error> | Constructor<Error>[], abortSignal?: AbortSignal): Promise<T>;
+export {};

package/dist/utils/RetryUtils.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryWithRetries = void 0;
+const TimeoutUtils_1 = require("./TimeoutUtils");
+const Logger_1 = require("./Logger");
+const logger = (0, Logger_1.getLogger)("RetryUtils: ");
+function isConstructor(fn) {
+    return (typeof fn === 'function' &&
+        fn.prototype != null &&
+        fn.prototype.constructor === fn);
+}
+function isConstructorArray(fnArr) {
+    return Array.isArray(fnArr) && fnArr.every(isConstructor);
+}
+/**
+ * Checks whether the passed error is allowed to pass through
+ *
+ * @param e Error in question
+ * @param errorAllowed Allowed errors as defined as a callback function, specific error type, or an array of error types
+ */
+function checkError(e, errorAllowed) {
+    if (isConstructorArray(errorAllowed))
+        return errorAllowed.find(error => e instanceof error) != null;
+    if (isConstructor(errorAllowed))
+        return e instanceof errorAllowed;
+    return errorAllowed(e);
+}
+/**
+ * Runs the passed function multiple times if it fails
+ *
+ * @param func A callback for executing the action
+ * @param func.retryCount Count of the current retry, starting from 0 for original request and increasing
+ * @param retryPolicy Retry policy
+ * @param retryPolicy.maxRetries How many retries to attempt in total
+ * @param retryPolicy.delay How long should the delay be
+ * @param retryPolicy.exponential Whether to use exponentially increasing delays
+ * @param errorAllowed A callback for determining whether a given error is allowed, and we should therefore not retry
+ * @param abortSignal
+ * @returns Result of the action executing callback
+ * @category Utilities
+ */
+async function tryWithRetries(func, retryPolicy, errorAllowed, abortSignal) {
+    retryPolicy = retryPolicy || {};
+    retryPolicy.maxRetries = retryPolicy.maxRetries || 5;
+    retryPolicy.delay = retryPolicy.delay || 500;
+    retryPolicy.exponential = retryPolicy.exponential == null ? true : retryPolicy.exponential;
+    let err = null;
+    for (let i = 0; i < retryPolicy.maxRetries; i++) {
+        try {
+            return await func(i);
+        }
+        catch (e) {
+            if (errorAllowed != null && checkError(e, errorAllowed))
+                throw e;
+            err = e;
+            logger.warn("tryWithRetries(): Error on try number: " + i, e);
+        }
+        if (abortSignal != null && abortSignal.aborted)
+            throw (abortSignal.reason || new Error("Aborted"));
+        if (i !== retryPolicy.maxRetries - 1) {
+            await (0, TimeoutUtils_1.timeoutPromise)(retryPolicy.exponential ? retryPolicy.delay * Math.pow(2, i) : retryPolicy.delay, abortSignal);
+        }
+    }
+    throw err;
+}
+exports.tryWithRetries = tryWithRetries;

package/dist/utils/SwapUtils.d.ts

@@ -0,0 +1,31 @@
+import { ChainType } from "@atomiqlabs/base";
+import { SwapType } from "../enums/SwapType";
+import { SupportsSwapType } from "../swapper/Swapper";
+import { SpvFromBTCSwap } from "../swaps/spv_swaps/SpvFromBTCSwap";
+import { FromBTCSwap } from "../swaps/escrow_swaps/frombtc/onchain/FromBTCSwap";
+import { FromBTCLNSwap } from "../swaps/escrow_swaps/frombtc/ln/FromBTCLNSwap";
+import { ToBTCSwap } from "../swaps/escrow_swaps/tobtc/onchain/ToBTCSwap";
+import { FromBTCLNAutoSwap } from "../swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoSwap";
+import { ToBTCLNSwap } from "../swaps/escrow_swaps/tobtc/ln/ToBTCLNSwap";
+import { OnchainForGasSwap } from "../swaps/trusted/onchain/OnchainForGasSwap";
+import { LnForGasSwap } from "../swaps/trusted/ln/LnForGasSwap";
+import { ISwap } from "../swaps/ISwap";
+/**
+ * Type mapping from SwapType enum to specific swap class implementations
+ * @category Utilities
+ */
+export type SwapTypeMapping<T extends ChainType> = {
+    [SwapType.FROM_BTC]: SupportsSwapType<T, SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCSwap<T> : FromBTCSwap<T>;
+    [SwapType.FROM_BTCLN]: SupportsSwapType<T, SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoSwap<T> : FromBTCLNSwap<T>;
+    [SwapType.TO_BTC]: ToBTCSwap<T>;
+    [SwapType.TO_BTCLN]: ToBTCLNSwap<T>;
+    [SwapType.TRUSTED_FROM_BTC]: OnchainForGasSwap<T>;
+    [SwapType.TRUSTED_FROM_BTCLN]: LnForGasSwap<T>;
+    [SwapType.SPV_VAULT_FROM_BTC]: SpvFromBTCSwap<T>;
+    [SwapType.FROM_BTCLN_AUTO]: FromBTCLNAutoSwap<T>;
+};
+/**
+ * Type guard to check if a swap is of a specific swap type
+ * @category Utilities
+ */
+export declare function isSwapType<T extends ChainType, S extends SwapType>(swap: ISwap<T>, swapType: S): swap is SwapTypeMapping<T>[S];

package/dist/utils/SwapUtils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSwapType = void 0;
+const SwapType_1 = require("../enums/SwapType");
+/**
+ * Type guard to check if a swap is of a specific swap type
+ * @category Utilities
+ */
+function isSwapType(swap, swapType) {
+    if (swap == null)
+        return false;
+    if (swap.getType() === SwapType_1.SwapType.SPV_VAULT_FROM_BTC && swapType === SwapType_1.SwapType.FROM_BTC)
+        return true;
+    if (swap.getType() === SwapType_1.SwapType.FROM_BTCLN_AUTO && swapType === SwapType_1.SwapType.FROM_BTCLN)
+        return true;
+    return swap.getType() === swapType;
+}
+exports.isSwapType = isSwapType;

package/dist/{Utils.d.ts → utils/TimeoutUtils.d.ts}

@@ -1,11 +1,17 @@
-import { Token } from "@atomiqlabs/sdk-lib";
-export declare function toHumanReadableString(amount: bigint, currencySpec: Token): string;
-export declare function fromHumanReadableString(amount: string, currencySpec: Token): bigint;
+/**
+ * Returns a promise that resolves after given amount seconds
+ *
+ * @param timeout how many milliseconds to wait for
+ * @param abortSignal
+ * @category Utilities
+ */
+export declare function timeoutPromise(timeout: number, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Returns an abort signal that aborts after a specified timeout in milliseconds
  *
  * @param timeout Milliseconds to wait
  * @param abortReason Abort with this abort reason
  * @param abortSignal Abort signal to extend
+ * @category Utilities
  */
 export declare function timeoutSignal(timeout: number, abortReason?: any, abortSignal?: AbortSignal): AbortSignal;

package/dist/utils/TimeoutUtils.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeoutSignal = exports.timeoutPromise = void 0;
+/**
+ * Returns a promise that resolves after given amount seconds
+ *
+ * @param timeout how many milliseconds to wait for
+ * @param abortSignal
+ * @category Utilities
+ */
+function timeoutPromise(timeout, abortSignal) {
+    return new Promise((resolve, reject) => {
+        if (abortSignal != null && abortSignal.aborted) {
+            reject(abortSignal.reason);
+            return;
+        }
+        let abortSignalListener;
+        let timeoutHandle = setTimeout(() => {
+            if (abortSignalListener != null && abortSignal != null)
+                abortSignal.removeEventListener("abort", abortSignalListener);
+            resolve();
+        }, timeout);
+        if (abortSignal != null) {
+            abortSignal.addEventListener("abort", abortSignalListener = () => {
+                if (timeoutHandle != null)
+                    clearTimeout(timeoutHandle);
+                timeoutHandle = null;
+                reject(abortSignal.reason);
+            });
+        }
+    });
+}
+exports.timeoutPromise = timeoutPromise;
+/**
+ * Returns an abort signal that aborts after a specified timeout in milliseconds
+ *
+ * @param timeout Milliseconds to wait
+ * @param abortReason Abort with this abort reason
+ * @param abortSignal Abort signal to extend
+ * @category Utilities
+ */
+function timeoutSignal(timeout, abortReason, abortSignal) {
+    if (timeout == null)
+        throw new Error("Timeout seconds cannot be null!");
+    const abortController = new AbortController();
+    const timeoutHandle = setTimeout(() => abortController.abort(abortReason || new Error("Timed out")), timeout);
+    if (abortSignal != null) {
+        abortSignal.addEventListener("abort", () => {
+            clearTimeout(timeoutHandle);
+            abortController.abort(abortSignal.reason);
+        });
+    }
+    return abortController.signal;
+}
+exports.timeoutSignal = timeoutSignal;

package/dist/utils/TokenUtils.d.ts

@@ -0,0 +1,11 @@
+import { Token } from "../types/Token";
+/**
+ * Converts a raw bigint amount to a human-readable string with decimals
+ * @category Utilities
+ */
+export declare function toHumanReadableString(amount: bigint, currencySpec: Token): string;
+/**
+ * Parses a human-readable decimal string to a raw bigint amount
+ * @category Utilities
+ */
+export declare function fromHumanReadableString(amount: string, currencySpec: Token): bigint | null;

package/dist/utils/TokenUtils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromHumanReadableString = exports.toHumanReadableString = void 0;
+const Utils_1 = require("./Utils");
+/**
+ * Converts a raw bigint amount to a human-readable string with decimals
+ * @category Utilities
+ */
+function toHumanReadableString(amount, currencySpec) {
+    if (amount == null)
+        return "";
+    return (0, Utils_1.toDecimal)(amount, currencySpec.decimals, undefined, currencySpec.displayDecimals);
+}
+exports.toHumanReadableString = toHumanReadableString;
+/**
+ * Parses a human-readable decimal string to a raw bigint amount
+ * @category Utilities
+ */
+function fromHumanReadableString(amount, currencySpec) {
+    if (amount === "" || amount == null)
+        return null;
+    try {
+        return (0, Utils_1.fromDecimal)(amount, currencySpec.decimals);
+    }
+    catch (e) {
+        return null;
+    }
+}
+exports.fromHumanReadableString = fromHumanReadableString;

package/dist/utils/TypeUtils.d.ts

@@ -0,0 +1,7 @@
+export type AllOptional<T> = {
+    [K in keyof T]?: T[K];
+};
+export type AllRequired<T> = {
+    [K in keyof T]-?: T[K];
+};
+export type NotNever<T> = [T] extends [never] ? false : true;

package/dist/utils/TypeUtils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });