@atomiqlabs/sdk 7.0.12 → 8.0.7

package/src/utils/AutomaticClockDriftCorrection.ts

@@ -0,0 +1,71 @@
+import {timeoutSignal} from "./TimeoutUtils";
+
+const headerUrls = ["https://api.atomiq.exchange/"];
+
+type TimeReturnType = {delta: number, timestamp: number};
+
+async function getHeaderTimestamp(url: string): Promise<TimeReturnType> {
+    const timeStart = performance.now();
+    const resp = await fetch(url, {method: "HEAD", signal: 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(): Promise<TimeReturnType> {
+    const timeStart = performance.now();
+    const resp = await fetch("https://api.binance.com/api/v3/time", {signal: timeoutSignal(3000)});
+    const timeDelta = performance.now() - timeStart;
+    const obj: {serverTime: number} = 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(): Promise<TimeReturnType> {
+    const timeStart = performance.now();
+    const resp = await fetch("https://www.okx.com/api/v5/public/time", {signal: timeoutSignal(3000)});
+    const timeDelta = performance.now() - timeStart;
+    const obj: {code: number, msg: string, data: [{ts: number}]} = 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(): Promise<TimeReturnType> {
+    const timeStart = performance.now();
+    const resp = await fetch("https://aisenseapi.com/services/v1/timestamp", {signal: 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)};
+}
+
+export async function correctClock() {
+    const dateNow: () => number = (Date as any)._now ?? Date.now;
+    const dateStart = performance.now();
+
+    try {
+        let result: TimeReturnType = 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 as any)._now = dateNow;
+        (Date as any).now = () => {
+            return Math.floor(performance.now() - timeDrift);
+        };
+    } catch (e: any) {
+        if(e instanceof AggregateError) e.message = "Cannot sync time! All servers responded negatively!";
+        throw e;
+    }
+}

package/src/utils/BitcoinUtils.ts

@@ -0,0 +1,86 @@
+import {BTC_NETWORK, isBytes, PubT, validatePubkey} from "@scure/btc-signer/utils";
+import {Buffer} from "buffer";
+import {Address, OutScript, Transaction} from "@scure/btc-signer";
+import {CoinselectAddressTypes} from "../bitcoin/coinselect2";
+
+export function toOutputScript(network: BTC_NETWORK, address: string): Buffer {
+    const outputScript = Address(network).decode(address);
+    switch(outputScript.type) {
+        case "pkh":
+        case "sh":
+        case "wpkh":
+        case "wsh":
+            return Buffer.from(OutScript.encode({
+                type: outputScript.type,
+                hash: outputScript.hash
+            }));
+        case "tr":
+            try {
+                return Buffer.from(OutScript.encode({
+                    type: "tr",
+                    pubkey: outputScript.pubkey
+                }));
+            } catch (e: any) {
+                let msg = "";
+                if(e.name!=null) msg += ": "+e.name;
+                if(e.message!=null) msg += ": "+e.message;
+                if(typeof(e)==="string") msg += ": "+e;
+                msg += ", isBytes: "+isBytes(outputScript.pubkey);
+                try {
+                    validatePubkey(outputScript.pubkey, PubT.schnorr)
+                    msg += ", validatePubkey: success";
+                } catch (e: any) {
+                    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}`);
+}
+
+export function toCoinselectAddressType(outputScript: Uint8Array): CoinselectAddressTypes {
+    const data = 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!");
+}
+
+/**
+ * General parsers for PSBTs, can parse hex or base64 encoded PSBTs
+ * @param _psbt
+ */
+export function parsePsbtTransaction(_psbt: Transaction | string): Transaction {
+    if (typeof (_psbt) === "string") {
+        let rawPsbt: Buffer;
+        if (/^(?:[0-9a-fA-F]{2})+$/.test(_psbt)) {
+            //Hex
+            rawPsbt = 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.from(_psbt, "base64");
+        } else {
+            throw new Error("Provided psbt string not base64 nor hex encoded!");
+        }
+        return Transaction.fromPSBT(rawPsbt, {
+            allowUnknownOutputs: true,
+            allowUnknownInputs: true,
+            allowLegacyWitnessUtxo: true,
+        });
+    } else {
+        return _psbt;
+    }
+}
+

package/src/utils/BitcoinWalletUtils.ts

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

package/src/utils/Logger.ts

@@ -0,0 +1,15 @@
+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 function getLogger(prefix: string): LoggerType {
+    return {
+        debug: (msg, ...args) => (global as any).atomiqLogLevel >= 3 && console.debug(prefix + msg, ...args),
+        info: (msg, ...args) => (global as any).atomiqLogLevel >= 2 && console.info(prefix + msg, ...args),
+        warn: (msg, ...args) => ((global as any).atomiqLogLevel == null || (global as any).atomiqLogLevel >= 1) && console.warn(prefix + msg, ...args),
+        error: (msg, ...args) => ((global as any).atomiqLogLevel == null || (global as any).atomiqLogLevel >= 0) && console.error(prefix + msg, ...args)
+    };
+}

package/src/utils/RetryUtils.ts

@@ -0,0 +1,71 @@
+import {timeoutPromise} from "./TimeoutUtils";
+import {getLogger} from "./Logger";
+
+const logger = getLogger("RetryUtils: ");
+
+type Constructor<T = any> = new (...args: any[]) => T;
+
+function isConstructor(fn: any): fn is Constructor {
+    return (
+        typeof fn === 'function' &&
+        fn.prototype != null &&
+        fn.prototype.constructor === fn
+    );
+}
+
+function isConstructorArray(fnArr: any): fnArr is Constructor[] {
+    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: any, errorAllowed: ((e: any) => boolean) | Constructor<Error> | Constructor<Error>[]) {
+    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
+ */
+export async 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> {
+    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 timeoutPromise(retryPolicy.exponential ? retryPolicy.delay * Math.pow(2, i) : retryPolicy.delay, abortSignal);
+        }
+    }
+
+    throw err;
+}

package/src/utils/SwapUtils.ts

@@ -0,0 +1,38 @@
+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 function isSwapType<T extends ChainType, S extends SwapType>(swap: ISwap<T>, swapType: S): swap is SwapTypeMapping<T>[S] {
+    if(swap==null) return false;
+    if(swap.getType()===SwapType.SPV_VAULT_FROM_BTC && swapType===SwapType.FROM_BTC) return true;
+    if(swap.getType()===SwapType.FROM_BTCLN_AUTO && swapType===SwapType.FROM_BTCLN) return true;
+    return swap.getType()===swapType;
+}

package/src/utils/TimeoutUtils.ts

@@ -0,0 +1,50 @@
+/**
+ * Returns a promise that resolves after given amount seconds
+ *
+ * @param timeout how many milliseconds to wait for
+ * @param abortSignal
+ * @category Utilities
+ */
+export function timeoutPromise(timeout: number, abortSignal?: AbortSignal): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+        if (abortSignal != null && abortSignal.aborted) {
+            reject(abortSignal.reason);
+            return;
+        }
+
+        let abortSignalListener: () => void;
+        let timeoutHandle: any | null = 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);
+            });
+        }
+    });
+}
+
+/**
+ * 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 function timeoutSignal(timeout: number, abortReason?: any, abortSignal?: AbortSignal): 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;
+}

package/src/utils/TokenUtils.ts

@@ -0,0 +1,25 @@
+import {Token} from "../types/Token";
+
+import {fromDecimal, toDecimal} from "./Utils";
+
+/**
+ * Converts a raw bigint amount to a human-readable string with decimals
+ * @category Utilities
+ */
+export function toHumanReadableString(amount: bigint, currencySpec: Token): string {
+    if(amount==null) return "";
+    return toDecimal(amount, currencySpec.decimals, undefined, currencySpec.displayDecimals);
+}
+
+/**
+ * Parses a human-readable decimal string to a raw bigint amount
+ * @category Utilities
+ */
+export function fromHumanReadableString(amount: string, currencySpec: Token): bigint | null {
+    if(amount==="" || amount==null) return null;
+    try {
+        return fromDecimal(amount, currencySpec.decimals);
+    } catch (e) {
+        return null;
+    }
+}

package/src/utils/TypeUtils.ts

@@ -0,0 +1,9 @@
+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/src/utils/Utils.ts

@@ -0,0 +1,182 @@
+import {Buffer} from "buffer";
+import {randomBytes as randomBytesNoble} from "@noble/hashes/utils";
+import {sha256} from "@noble/hashes/sha2";
+import {BigIntBufferUtils} from "@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
+ */
+export function throwIfUndefined<T>(promise: Promise<T | undefined>, msg?: string): Promise<T> {
+    return promise.then(val => {
+        if(val==undefined) throw new Error(msg ?? "Promise value is undefined!");
+        return val;
+    })
+}
+
+/**
+ * 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 function promiseAny<T>(promises: Promise<T>[]): Promise<T> {
+    return new Promise<T>((resolve: ((val: T) => void) | null, 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);
+                }
+            })
+        })
+    });
+}
+
+/**
+ * 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 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]} {
+    const resp: {[key in keyof InputObject]?: OutputObject[key]} = {};
+    for(let key in obj) {
+        resp[key] = translator(obj[key], key);
+    }
+    return resp as {[key in keyof InputObject]: OutputObject[key]};
+}
+
+/**
+ * Maps the entries from the map to the array using the translator function
+ *
+ * @param map
+ * @param translator
+ */
+export function mapToArray<K, V, Output>(map: Map<K, V>, translator: (key: K, value: V) => Output): Output[] {
+    const arr: Output[] = Array(map.size);
+    let pointer = 0;
+    for(let entry of map.entries()) {
+        arr[pointer++] = translator(entry[0], entry[1]);
+    }
+    return arr;
+}
+
+/**
+ * Creates a new abort controller that will abort if the passed abort signal aborts
+ *
+ * @param abortSignal
+ */
+export function extendAbortController(abortSignal?: AbortSignal) {
+    const _abortController = new AbortController();
+    if(abortSignal!=null) {
+        abortSignal.throwIfAborted();
+        abortSignal.onabort = () => _abortController.abort(abortSignal.reason);
+    }
+    return _abortController;
+}
+
+export function bigIntMin(a: bigint, b: bigint): bigint;
+export function bigIntMin(a?: bigint, b?: bigint): bigint | undefined;
+export function bigIntMin(a?: bigint, b?: bigint): bigint | undefined {
+    if(a==null) return b;
+    if(b==null) return a;
+    return a > b ? b : a;
+}
+
+export function bigIntMax(a: bigint, b: bigint): bigint;
+export function bigIntMax(a?: bigint, b?: bigint): bigint | undefined;
+export function bigIntMax(a?: bigint, b?: bigint): bigint | undefined {
+    if(a==null) return b;
+    if(b==null) return a;
+    return b > a ? b : a;
+}
+
+export function bigIntCompare(a: bigint, b: bigint): -1 | 0 | 1 {
+    return a > b ? 1 : a===b ? 0 : -1;
+}
+
+export function toBigInt(value: string): bigint;
+export function toBigInt(value: undefined): undefined;
+export function toBigInt(value: string | undefined): bigint | undefined {
+    if(value==null) return undefined;
+    return BigInt(value);
+}
+
+export function randomBytes(bytesLength: number): Buffer {
+    return Buffer.from(randomBytesNoble(bytesLength));
+}
+
+export function getTxoHash(outputScriptHex: string, value: number) {
+    return Buffer.from(sha256(Buffer.concat([
+        BigIntBufferUtils.toBuffer(BigInt(value), "le", 8),
+        Buffer.from(outputScriptHex, "hex")
+    ])));
+}
+
+export function fromDecimal(amount: string, decimalCount: number) {
+    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));
+        }
+    }
+
+}
+
+export function toDecimal(amount: bigint, decimalCount: number, cut?: boolean, displayDecimals?: number) {
+    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);
+}

package/dist/SwapperFactory.d.ts

@@ -1,52 +0,0 @@
-import { ChainData, BitcoinNetwork, BitcoinRpc, BaseTokenType, ChainType, StorageObject, IStorageManager, Messenger } from "@atomiqlabs/base";
-import { BtcToken, CustomPriceFunction, MempoolApi, MempoolBitcoinRpc, SCToken, Swapper, SwapperOptions } from "@atomiqlabs/sdk-lib";
-type ChainInitializer<O, C extends ChainType, T extends BaseTokenType> = {
-    chainId: ChainType["ChainId"];
-    chainType: ChainType;
-    initializer: (options: O, bitcoinRelay: BitcoinRpc<any>, network: BitcoinNetwork, storageCtor: <T extends StorageObject>(name: string) => IStorageManager<T>) => ChainData<C>;
-    tokens: T;
-    options: O;
-};
-type TokensDict<T extends ChainInitializer<any, any, any>> = {
-    [K in T["chainId"]]: {
-        [val in keyof T["tokens"]]: SCToken<K>;
-    };
-};
-type GetAllTokens<T extends readonly ChainInitializer<any, any, any>[]> = (T extends readonly [infer First extends ChainInitializer<any, any, any>, ...infer Rest extends ChainInitializer<any, any, any>[]] ? TokensDict<First> & GetAllTokens<Rest> : unknown);
-export type TokenResolverDict<T extends ChainInitializer<any, any, any>> = {
-    [K in T["chainId"]]: {
-        getToken: (address: string) => SCToken<K>;
-    };
-};
-type GetAllTokenResolvers<T extends readonly ChainInitializer<any, any, any>[]> = (T extends readonly [infer First extends ChainInitializer<any, any, any>, ...infer Rest extends ChainInitializer<any, any, any>[]] ? TokenResolverDict<First> & GetAllTokenResolvers<Rest> : unknown);
-type OptionsDict<T extends ChainInitializer<any, any, any>> = {
-    [K in T["chainId"]]: T["options"];
-};
-type GetAllOptions<T extends readonly ChainInitializer<any, any, any>[]> = (T extends readonly [infer First extends ChainInitializer<any, any, any>, ...infer Rest extends ChainInitializer<any, any, any>[]] ? OptionsDict<First> & GetAllOptions<Rest> : unknown);
-type ChainTypeDict<T extends ChainInitializer<any, any, any>> = {
-    [K in T["chainId"]]: T["chainType"];
-};
-type ToMultichain<T extends readonly ChainInitializer<any, any, any>[]> = (T extends readonly [infer First extends ChainInitializer<any, any, any>, ...infer Rest extends ChainInitializer<any, any, any>[]] ? ChainTypeDict<First> & ToMultichain<Rest> : {});
-export type MultichainSwapperOptions<T extends readonly ChainInitializer<any, any, any>[]> = SwapperOptions & {
-    chains: GetAllOptions<T>;
-} & {
-    chainStorageCtor?: <T extends StorageObject>(name: string) => IStorageManager<T>;
-    pricingFeeDifferencePPM?: bigint;
-    mempoolApi?: MempoolApi | MempoolBitcoinRpc | string | string[];
-    messenger?: Messenger;
-    getPriceFn?: CustomPriceFunction;
-};
-export declare class SwapperFactory<T extends readonly ChainInitializer<any, any, any>[]> {
-    readonly initializers: T;
-    Tokens: GetAllTokens<T> & {
-        BITCOIN: {
-            BTC: BtcToken<false>;
-            BTCLN: BtcToken<true>;
-        };
-    };
-    TokenResolver: GetAllTokenResolvers<T>;
-    constructor(initializers: T);
-    newSwapper(options: MultichainSwapperOptions<T>): Swapper<ToMultichain<T>>;
-    newSwapperInitialized(options: MultichainSwapperOptions<T>): Promise<Swapper<ToMultichain<T>>>;
-}
-export {};

package/dist/Utils.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.timeoutSignal = exports.fromHumanReadableString = exports.toHumanReadableString = void 0;
-const sdk_lib_1 = require("@atomiqlabs/sdk-lib");
-function toHumanReadableString(amount, currencySpec) {
-    if (amount == null)
-        return null;
-    return (0, sdk_lib_1.toDecimal)(amount, currencySpec.decimals, undefined, currencySpec.displayDecimals);
-}
-exports.toHumanReadableString = toHumanReadableString;
-function fromHumanReadableString(amount, currencySpec) {
-    if (amount === "" || amount == null)
-        return null;
-    return (0, sdk_lib_1.fromDecimal)(amount, currencySpec.decimals);
-}
-exports.fromHumanReadableString = fromHumanReadableString;
-/**
- * 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
- */
-function timeoutSignal(timeout, abortReason, abortSignal) {
-    if (timeout == null)
-        return abortSignal;
-    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;