@atomiqlabs/sdk 8.6.6 → 8.6.8

package/dist/prices/abstract/ICachedSwapPrice.d.ts

@@ -1,28 +1,28 @@
-import { ISwapPrice } from "./ISwapPrice";
-import { ChainIds, MultiChain } from "../../swapper/Swapper";
-export declare abstract class ICachedSwapPrice<T extends MultiChain> extends ISwapPrice<T> {
-    cache: {
-        [chainIdentifier in keyof T]?: {
-            [tokenAddress: string]: {
-                price: Promise<bigint>;
-                expiry: number;
-            };
-        };
-    };
-    usdCache?: {
-        price: Promise<number>;
-        expiry: number;
-    };
-    cacheTimeout: number;
-    protected constructor(maxAllowedFeeDiffPPM: bigint, cacheTimeout?: number);
-    protected abstract fetchPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint>;
-    protected abstract fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
-    protected getPrice<C extends ChainIds<T>>(chainIdentifier: C, tokenAddress: string, abortSignal?: AbortSignal): Promise<bigint>;
-    /**
-     * Returns BTC price in USD (sats/USD)
-     *
-     * @param abortSignal
-     * @throws {Error} if token is not found
-     */
-    protected getUsdPrice(abortSignal?: AbortSignal): Promise<number>;
-}
+import { ISwapPrice } from "./ISwapPrice";
+import { ChainIds, MultiChain } from "../../swapper/Swapper";
+export declare abstract class ICachedSwapPrice<T extends MultiChain> extends ISwapPrice<T> {
+    cache: {
+        [chainIdentifier in keyof T]?: {
+            [tokenAddress: string]: {
+                price: Promise<bigint>;
+                expiry: number;
+            };
+        };
+    };
+    usdCache?: {
+        price: Promise<number>;
+        expiry: number;
+    };
+    cacheTimeout: number;
+    protected constructor(maxAllowedFeeDiffPPM: bigint, cacheTimeout?: number);
+    protected abstract fetchPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint>;
+    protected abstract fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+    protected getPrice<C extends ChainIds<T>>(chainIdentifier: C, tokenAddress: string, abortSignal?: AbortSignal): Promise<bigint>;
+    /**
+     * Returns BTC price in USD (sats/USD)
+     *
+     * @param abortSignal
+     * @throws {Error} if token is not found
+     */
+    protected getUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+}

package/dist/prices/abstract/ICachedSwapPrice.js

@@ -1,62 +1,62 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ICachedSwapPrice = void 0;
-const ISwapPrice_1 = require("./ISwapPrice");
-const DEFAULT_CACHE_DURATION = 10000;
-class ICachedSwapPrice extends ISwapPrice_1.ISwapPrice {
-    constructor(maxAllowedFeeDiffPPM, cacheTimeout) {
-        super(maxAllowedFeeDiffPPM);
-        this.cache = {};
-        this.cacheTimeout = cacheTimeout || DEFAULT_CACHE_DURATION;
-    }
-    getPrice(chainIdentifier, tokenAddress, abortSignal) {
-        const token = tokenAddress.toString();
-        const chainCache = this.cache[chainIdentifier];
-        if (chainCache != null) {
-            const cachedValue = chainCache[token];
-            if (cachedValue != null && cachedValue.expiry > Date.now()) {
-                //Cache still fresh
-                return cachedValue.price.catch(e => this.fetchPrice(chainIdentifier, token, abortSignal));
-            }
-        }
-        //Refresh cache
-        const thisFetch = this.fetchPrice(chainIdentifier, token);
-        this.cache[chainIdentifier] ??= {};
-        this.cache[chainIdentifier][token] = {
-            price: thisFetch,
-            expiry: Date.now() + this.cacheTimeout
-        };
-        thisFetch.catch(e => {
-            if (this.cache?.[chainIdentifier]?.[token].price === thisFetch)
-                delete this.cache[token];
-            throw e;
-        });
-        return thisFetch;
-    }
-    /**
-     * Returns BTC price in USD (sats/USD)
-     *
-     * @param abortSignal
-     * @throws {Error} if token is not found
-     */
-    getUsdPrice(abortSignal) {
-        if (this.usdCache != null && this.usdCache.expiry > Date.now()) {
-            //Cache still fresh
-            return this.usdCache.price.catch(e => this.fetchUsdPrice(abortSignal));
-        }
-        //Refresh cache
-        const thisFetch = this.fetchUsdPrice();
-        this.usdCache = {
-            price: thisFetch,
-            expiry: Date.now() + this.cacheTimeout
-        };
-        thisFetch.catch(e => {
-            if (this.usdCache != null &&
-                this.usdCache.price === thisFetch)
-                delete this.usdCache;
-            throw e;
-        });
-        return thisFetch;
-    }
-}
-exports.ICachedSwapPrice = ICachedSwapPrice;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ICachedSwapPrice = void 0;
+const ISwapPrice_1 = require("./ISwapPrice");
+const DEFAULT_CACHE_DURATION = 10000;
+class ICachedSwapPrice extends ISwapPrice_1.ISwapPrice {
+    constructor(maxAllowedFeeDiffPPM, cacheTimeout) {
+        super(maxAllowedFeeDiffPPM);
+        this.cache = {};
+        this.cacheTimeout = cacheTimeout || DEFAULT_CACHE_DURATION;
+    }
+    getPrice(chainIdentifier, tokenAddress, abortSignal) {
+        const token = tokenAddress.toString();
+        const chainCache = this.cache[chainIdentifier];
+        if (chainCache != null) {
+            const cachedValue = chainCache[token];
+            if (cachedValue != null && cachedValue.expiry > Date.now()) {
+                //Cache still fresh
+                return cachedValue.price.catch(e => this.fetchPrice(chainIdentifier, token, abortSignal));
+            }
+        }
+        //Refresh cache
+        const thisFetch = this.fetchPrice(chainIdentifier, token);
+        this.cache[chainIdentifier] ??= {};
+        this.cache[chainIdentifier][token] = {
+            price: thisFetch,
+            expiry: Date.now() + this.cacheTimeout
+        };
+        thisFetch.catch(e => {
+            if (this.cache?.[chainIdentifier]?.[token].price === thisFetch)
+                delete this.cache[token];
+            throw e;
+        });
+        return thisFetch;
+    }
+    /**
+     * Returns BTC price in USD (sats/USD)
+     *
+     * @param abortSignal
+     * @throws {Error} if token is not found
+     */
+    getUsdPrice(abortSignal) {
+        if (this.usdCache != null && this.usdCache.expiry > Date.now()) {
+            //Cache still fresh
+            return this.usdCache.price.catch(e => this.fetchUsdPrice(abortSignal));
+        }
+        //Refresh cache
+        const thisFetch = this.fetchUsdPrice();
+        this.usdCache = {
+            price: thisFetch,
+            expiry: Date.now() + this.cacheTimeout
+        };
+        thisFetch.catch(e => {
+            if (this.usdCache != null &&
+                this.usdCache.price === thisFetch)
+                delete this.usdCache;
+            throw e;
+        });
+        return thisFetch;
+    }
+}
+exports.ICachedSwapPrice = ICachedSwapPrice;

package/dist/prices/abstract/IPriceProvider.d.ts

@@ -1,81 +1,81 @@
-import { ChainIds, MultiChain } from "../../swapper/Swapper";
-/**
- * Coin type definition for price providers
- * @category Pricing
- */
-export type CoinType = {
-    coinId: string;
-    decimals: number;
-};
-/**
- * Constructor coin types for price providers
- * @category Pricing
- */
-export type CtorCoinTypes<T extends MultiChain> = {
-    coinId?: string;
-    chains: {
-        [chainId in keyof T]?: {
-            address: string;
-            decimals: number;
-        };
-    };
-}[];
-/**
- * Coin types mapping by chain
- * @category Pricing
- */
-export type CoinTypes<T extends MultiChain> = {
-    [chainId in keyof T]?: {
-        [address: string]: CoinType;
-    };
-};
-/**
- * Abstract base class for price provider implementations
- * @category Pricing
- */
-export declare abstract class IPriceProvider<T extends MultiChain> {
-    coinsMap: CoinTypes<T>;
-    protected constructor(coins: CtorCoinTypes<T>);
-    /**
-     * Fetches the price for a given token against BTC
-     *
-     * @param token
-     * @param abortSignal
-     * @protected
-     * @returns Price per token in uSats (micro sats)
-     */
-    protected abstract fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint>;
-    /**
-     * Fetches the USD price of BTC
-     *
-     * @param abortSignal
-     * @protected
-     */
-    protected abstract fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
-    /**
-     * Returns coin price in uSat (microSat)
-     *
-     * @param chainIdentifier
-     * @param token
-     * @param abortSignal
-     * @throws {Error} if token is not found
-     */
-    getPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint>;
-    /**
-     * Returns coin price in uSat (microSat)
-     *
-     * @param abortSignal
-     * @throws {Error} if token is not found
-     */
-    getUsdPrice(abortSignal?: AbortSignal): Promise<number>;
-    /**
-     * Returns the decimal places of the specified token, or -1 if token should be ignored, returns null if
-     *  token is not found
-     *
-     * @param chainIdentifier
-     * @param token
-     * @protected
-     * @throws {Error} If token is not found
-     */
-    getDecimals<C extends ChainIds<T>>(chainIdentifier: C, token: string): number;
-}
+import { ChainIds, MultiChain } from "../../swapper/Swapper";
+/**
+ * Coin type definition for price providers
+ * @category Pricing
+ */
+export type CoinType = {
+    coinId: string;
+    decimals: number;
+};
+/**
+ * Constructor coin types for price providers
+ * @category Pricing
+ */
+export type CtorCoinTypes<T extends MultiChain> = {
+    coinId?: string;
+    chains: {
+        [chainId in keyof T]?: {
+            address: string;
+            decimals: number;
+        };
+    };
+}[];
+/**
+ * Coin types mapping by chain
+ * @category Pricing
+ */
+export type CoinTypes<T extends MultiChain> = {
+    [chainId in keyof T]?: {
+        [address: string]: CoinType;
+    };
+};
+/**
+ * Abstract base class for price provider implementations
+ * @category Pricing
+ */
+export declare abstract class IPriceProvider<T extends MultiChain> {
+    coinsMap: CoinTypes<T>;
+    protected constructor(coins: CtorCoinTypes<T>);
+    /**
+     * Fetches the price for a given token against BTC
+     *
+     * @param token
+     * @param abortSignal
+     * @protected
+     * @returns Price per token in uSats (micro sats)
+     */
+    protected abstract fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint>;
+    /**
+     * Fetches the USD price of BTC
+     *
+     * @param abortSignal
+     * @protected
+     */
+    protected abstract fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+    /**
+     * Returns coin price in uSat (microSat)
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param abortSignal
+     * @throws {Error} if token is not found
+     */
+    getPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint>;
+    /**
+     * Returns coin price in uSat (microSat)
+     *
+     * @param abortSignal
+     * @throws {Error} if token is not found
+     */
+    getUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+    /**
+     * Returns the decimal places of the specified token, or -1 if token should be ignored, returns null if
+     *  token is not found
+     *
+     * @param chainIdentifier
+     * @param token
+     * @protected
+     * @throws {Error} If token is not found
+     */
+    getDecimals<C extends ChainIds<T>>(chainIdentifier: C, token: string): number;
+}

package/dist/prices/abstract/IPriceProvider.js

@@ -1,74 +1,74 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IPriceProvider = void 0;
-/**
- * Abstract base class for price provider implementations
- * @category Pricing
- */
-class IPriceProvider {
-    constructor(coins) {
-        this.coinsMap = {};
-        for (let coinData of coins) {
-            if (coinData.coinId == null)
-                continue;
-            for (let chainId in coinData.chains) {
-                const { address, decimals } = coinData.chains[chainId];
-                this.coinsMap[chainId] ??= {};
-                this.coinsMap[chainId][address.toString()] = {
-                    coinId: coinData.coinId,
-                    decimals
-                };
-            }
-        }
-    }
-    /**
-     * Returns coin price in uSat (microSat)
-     *
-     * @param chainIdentifier
-     * @param token
-     * @param abortSignal
-     * @throws {Error} if token is not found
-     */
-    getPrice(chainIdentifier, token, abortSignal) {
-        let tokenAddress = token.toString();
-        const chainTokens = this.coinsMap[chainIdentifier];
-        if (chainTokens == null)
-            throw new Error("Chain not found");
-        const coin = chainTokens[tokenAddress];
-        if (coin == null)
-            throw new Error("Token not found");
-        if (coin.coinId.startsWith("$fixed-")) {
-            const amt = parseFloat(coin.coinId.substring(7));
-            return Promise.resolve(BigInt(Math.floor(amt * 1000000).toString(10)));
-        }
-        return this.fetchPrice(coin, abortSignal);
-    }
-    /**
-     * Returns coin price in uSat (microSat)
-     *
-     * @param abortSignal
-     * @throws {Error} if token is not found
-     */
-    getUsdPrice(abortSignal) {
-        return this.fetchUsdPrice(abortSignal);
-    }
-    /**
-     * Returns the decimal places of the specified token, or -1 if token should be ignored, returns null if
-     *  token is not found
-     *
-     * @param chainIdentifier
-     * @param token
-     * @protected
-     * @throws {Error} If token is not found
-     */
-    getDecimals(chainIdentifier, token) {
-        const chainTokens = this.coinsMap[chainIdentifier];
-        if (chainTokens == null)
-            throw new Error("Chain not found");
-        const coin = chainTokens[token.toString()];
-        if (coin == null)
-            throw new Error("Token not found");
-        return coin.coinId === "$ignore" ? -1 : coin.decimals;
-    }
-}
-exports.IPriceProvider = IPriceProvider;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPriceProvider = void 0;
+/**
+ * Abstract base class for price provider implementations
+ * @category Pricing
+ */
+class IPriceProvider {
+    constructor(coins) {
+        this.coinsMap = {};
+        for (let coinData of coins) {
+            if (coinData.coinId == null)
+                continue;
+            for (let chainId in coinData.chains) {
+                const { address, decimals } = coinData.chains[chainId];
+                this.coinsMap[chainId] ??= {};
+                this.coinsMap[chainId][address.toString()] = {
+                    coinId: coinData.coinId,
+                    decimals
+                };
+            }
+        }
+    }
+    /**
+     * Returns coin price in uSat (microSat)
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param abortSignal
+     * @throws {Error} if token is not found
+     */
+    getPrice(chainIdentifier, token, abortSignal) {
+        let tokenAddress = token.toString();
+        const chainTokens = this.coinsMap[chainIdentifier];
+        if (chainTokens == null)
+            throw new Error("Chain not found");
+        const coin = chainTokens[tokenAddress];
+        if (coin == null)
+            throw new Error("Token not found");
+        if (coin.coinId.startsWith("$fixed-")) {
+            const amt = parseFloat(coin.coinId.substring(7));
+            return Promise.resolve(BigInt(Math.floor(amt * 1000000).toString(10)));
+        }
+        return this.fetchPrice(coin, abortSignal);
+    }
+    /**
+     * Returns coin price in uSat (microSat)
+     *
+     * @param abortSignal
+     * @throws {Error} if token is not found
+     */
+    getUsdPrice(abortSignal) {
+        return this.fetchUsdPrice(abortSignal);
+    }
+    /**
+     * Returns the decimal places of the specified token, or -1 if token should be ignored, returns null if
+     *  token is not found
+     *
+     * @param chainIdentifier
+     * @param token
+     * @protected
+     * @throws {Error} If token is not found
+     */
+    getDecimals(chainIdentifier, token) {
+        const chainTokens = this.coinsMap[chainIdentifier];
+        if (chainTokens == null)
+            throw new Error("Chain not found");
+        const coin = chainTokens[token.toString()];
+        if (coin == null)
+            throw new Error("Token not found");
+        return coin.coinId === "$ignore" ? -1 : coin.decimals;
+    }
+}
+exports.IPriceProvider = IPriceProvider;