@atomiqlabs/sdk 8.9.1 → 8.9.2

package/src/utils/RetryUtils.ts

@@ -1,78 +1,78 @@
-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
- * @param failureLogLevel
- * @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,
-    failureLogLevel: "debug" | "info" | "warn" | "error" = "warn"
-): 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[failureLogLevel]("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;
-}
+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
+ * @param failureLogLevel
+ * @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,
+    failureLogLevel: "debug" | "info" | "warn" | "error" = "warn"
+): 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[failureLogLevel]("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

@@ -1,100 +1,100 @@
-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, it is important
- *  to pass the chain type generic, since different chains support different swap protocols
- *  for some directions.
- *
- * @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;
-}
-
-/**
- * Helper information about various swap protocol and their features:
- * - `requiresInputWallet`: Whether a swap requires a connected wallet on the input chain able to sign
- *  arbitrary transaction
- * - `requiresOutputWallet`: Whether a swap requires a connected wallet on the output chain able to sign
- *  arbitrary transactions
- * - `supportsGasDrop`: Whether a swap supports the "gas drop" feature, allowing to user to receive a small
- *  amount of native token as part of the swap when swapping to smart chains
- *
- * @category Core
- */
-export const SwapProtocolInfo = {
-    [SwapType.TO_BTC]: {
-        requiresInputWallet: true,
-        requiresOutputWallet: false,
-        supportsGasDrop: false
-    },
-    [SwapType.TO_BTCLN]: {
-        requiresInputWallet: true,
-        requiresOutputWallet: false,
-        supportsGasDrop: false
-    },
-    [SwapType.FROM_BTC]: {
-        requiresInputWallet: false,
-        requiresOutputWallet: true,
-        supportsGasDrop: false
-    },
-    [SwapType.FROM_BTCLN]: {
-        requiresInputWallet: false,
-        requiresOutputWallet: true,
-        supportsGasDrop: false
-    },
-    [SwapType.SPV_VAULT_FROM_BTC]: {
-        requiresInputWallet: true,
-        requiresOutputWallet: false,
-        supportsGasDrop: true
-    },
-    [SwapType.FROM_BTCLN_AUTO]: {
-        requiresInputWallet: false,
-        requiresOutputWallet: false,
-        supportsGasDrop: true
-    },
-    [SwapType.TRUSTED_FROM_BTC]: {
-        requiresInputWallet: false,
-        requiresOutputWallet: false,
-        supportsGasDrop: false
-    },
-    [SwapType.TRUSTED_FROM_BTCLN]: {
-        requiresInputWallet: false,
-        requiresOutputWallet: false,
-        supportsGasDrop: false
-    }
-} as const satisfies Record<SwapType, {
-    requiresInputWallet: boolean,
-    requiresOutputWallet: boolean,
-    supportsGasDrop: boolean
+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, it is important
+ *  to pass the chain type generic, since different chains support different swap protocols
+ *  for some directions.
+ *
+ * @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;
+}
+
+/**
+ * Helper information about various swap protocol and their features:
+ * - `requiresInputWallet`: Whether a swap requires a connected wallet on the input chain able to sign
+ *  arbitrary transaction
+ * - `requiresOutputWallet`: Whether a swap requires a connected wallet on the output chain able to sign
+ *  arbitrary transactions
+ * - `supportsGasDrop`: Whether a swap supports the "gas drop" feature, allowing to user to receive a small
+ *  amount of native token as part of the swap when swapping to smart chains
+ *
+ * @category Core
+ */
+export const SwapProtocolInfo = {
+    [SwapType.TO_BTC]: {
+        requiresInputWallet: true,
+        requiresOutputWallet: false,
+        supportsGasDrop: false
+    },
+    [SwapType.TO_BTCLN]: {
+        requiresInputWallet: true,
+        requiresOutputWallet: false,
+        supportsGasDrop: false
+    },
+    [SwapType.FROM_BTC]: {
+        requiresInputWallet: false,
+        requiresOutputWallet: true,
+        supportsGasDrop: false
+    },
+    [SwapType.FROM_BTCLN]: {
+        requiresInputWallet: false,
+        requiresOutputWallet: true,
+        supportsGasDrop: false
+    },
+    [SwapType.SPV_VAULT_FROM_BTC]: {
+        requiresInputWallet: true,
+        requiresOutputWallet: false,
+        supportsGasDrop: true
+    },
+    [SwapType.FROM_BTCLN_AUTO]: {
+        requiresInputWallet: false,
+        requiresOutputWallet: false,
+        supportsGasDrop: true
+    },
+    [SwapType.TRUSTED_FROM_BTC]: {
+        requiresInputWallet: false,
+        requiresOutputWallet: false,
+        supportsGasDrop: false
+    },
+    [SwapType.TRUSTED_FROM_BTCLN]: {
+        requiresInputWallet: false,
+        requiresOutputWallet: false,
+        supportsGasDrop: false
+    }
+} as const satisfies Record<SwapType, {
+    requiresInputWallet: boolean,
+    requiresOutputWallet: boolean,
+    supportsGasDrop: boolean
 }>;

package/src/utils/TimeoutUtils.ts

@@ -1,50 +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;
+/**
+ * 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

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

package/src/utils/TypeUtils.ts

@@ -1,9 +1,9 @@
-export type AllOptional<T> = {
-    [K in keyof T]?: T[K];
-};
-
-export type AllRequired<T> = {
-    [K in keyof T]-?: T[K];
-};
-
+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;