@atomiqlabs/sdk 8.9.1 → 8.9.2

package/src/prices/SwapPriceWithChain.ts

@@ -1,194 +1,194 @@
-import {ISwapPrice} from "./abstract/ISwapPrice";
-import {ChainIds, MultiChain} from "../swapper/Swapper";
-
-import {Token} from "../types/Token";
-import {PriceInfoType} from "../types/PriceInfoType";
-
-/**
- * Chain-specific wrapper for swap pricing
- *
- * @category Pricing
- */
-export class SwapPriceWithChain<T extends MultiChain, ChainIdentifier extends ChainIds<T>> {
-
-    swapPrice: ISwapPrice<T>;
-    chainIdentifier: ChainIdentifier;
-    maxAllowedFeeDifferencePPM: bigint;
-
-    constructor(swapPrice: ISwapPrice<T>, chainIdentifier: ChainIdentifier) {
-        this.swapPrice = swapPrice;
-        this.chainIdentifier = chainIdentifier;
-        this.maxAllowedFeeDifferencePPM = swapPrice.maxAllowedFeeDifferencePPM;
-    }
-
-    /**
-     * Checks whether the swap amounts are valid given the current market rate for a given pair
-     *
-     * @param amountSats Amount of sats (BTC) to be received from the swap
-     * @param satsBaseFee Base fee in sats (BTC) as reported by the intermediary
-     * @param feePPM PPM fee rate as reported by the intermediary
-     * @param paidToken Amount of token to be paid to the swap
-     * @param tokenAddress Token address to be paid
-     * @param abortSignal Abort signal
-     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
-     */
-    public async isValidAmountSend(
-        amountSats: bigint,
-        satsBaseFee: bigint,
-        feePPM: bigint,
-        paidToken: bigint,
-        tokenAddress: string,
-        abortSignal?: AbortSignal,
-        preFetchedPrice?: bigint
-    ): Promise<PriceInfoType> {
-        return this.swapPrice.isValidAmountSend<ChainIdentifier>(
-            this.chainIdentifier, amountSats, satsBaseFee, feePPM, paidToken, tokenAddress, abortSignal, preFetchedPrice
-        );
-    }
-
-    /**
-     * Checks whether the swap amounts are valid given the current market rate for a given pair
-     *
-     * @param amountSats Amount of sats (BTC) to be paid to the swap
-     * @param satsBaseFee Base fee in sats (BTC) as reported by the intermediary
-     * @param feePPM PPM fee rate as reported by the intermediary
-     * @param receiveToken Amount of token to be received from the swap
-     * @param tokenAddress Token address to be received
-     * @param abortSignal Abort signal
-     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
-     */
-    public async isValidAmountReceive(
-        amountSats: bigint,
-        satsBaseFee: bigint,
-        feePPM: bigint,
-        receiveToken: bigint,
-        tokenAddress: string,
-        abortSignal?: AbortSignal,
-        preFetchedPrice?: bigint
-    ): Promise<PriceInfoType> {
-        return this.swapPrice.isValidAmountReceive<ChainIdentifier>(
-            this.chainIdentifier, amountSats, satsBaseFee, feePPM, receiveToken, tokenAddress, abortSignal, preFetchedPrice
-        );
-    }
-
-    /**
-     * Pre-fetches the pricing data for a given token, such that further calls to {@link isValidAmountReceive} or
-     *  {@link isValidAmountSend} are quicker and don't need to wait for the price fetch
-     *
-     * @param tokenAddress Token address
-     * @param abortSignal Abort signal
-     */
-    public preFetchPrice(tokenAddress: string, abortSignal?: AbortSignal): Promise<bigint> {
-        return this.swapPrice.preFetchPrice<ChainIdentifier>(this.chainIdentifier, tokenAddress, abortSignal);
-    }
-
-    /**
-     * Pre-fetches the Bitcoin USD price data, such that further calls to {@link getBtcUsdValue},
-     *  {@link getTokenUsdValue} or {@link getUsdValue} are quicker and don't need to wait for the price fetch
-     *
-     * @param abortSignal
-     */
-    public preFetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
-        return this.swapPrice.preFetchUsdPrice(abortSignal);
-    }
-
-    /**
-     * Returns amount of `toToken` that is equivalent to `fromAmount` satoshis
-     *
-     * @param fromAmount Amount of satoshis
-     * @param toToken Token address
-     * @param abortSignal
-     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
-     * @throws {Error} when token is not found
-     */
-    public async getFromBtcSwapAmount(
-        fromAmount: bigint,
-        toToken: string,
-        abortSignal?: AbortSignal,
-        preFetchedPrice?: bigint
-    ): Promise<bigint> {
-        return this.swapPrice.getFromBtcSwapAmount<ChainIdentifier>(
-            this.chainIdentifier, fromAmount, toToken, abortSignal, preFetchedPrice
-        );
-    }
-
-    /**
-     * Returns amount of satoshis that are equivalent to `fromAmount` of `fromToken`
-     *
-     * @param fromAmount Amount of the token
-     * @param fromToken Token address
-     * @param abortSignal
-     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
-     * @throws {Error} when token is not found
-     */
-    public async getToBtcSwapAmount(
-        fromAmount: bigint,
-        fromToken: string,
-        abortSignal?: AbortSignal,
-        preFetchedPrice?: bigint
-    ): Promise<bigint> {
-        return this.swapPrice.getToBtcSwapAmount<ChainIdentifier>(
-            this.chainIdentifier, fromAmount, fromToken, abortSignal, preFetchedPrice
-        );
-    }
-
-    /**
-     * Returns whether the token should be ignored and pricing for it not calculated
-     *
-     * @param tokenAddress Token address
-     * @throws {Error} if token is not found
-     */
-    public shouldIgnore(tokenAddress: string): boolean {
-        return this.swapPrice.shouldIgnore<ChainIdentifier>(this.chainIdentifier, tokenAddress);
-    }
-
-    /**
-     * Returns the USD value of the bitcoin amount
-     *
-     * @param btcSats Bitcoin amount in satoshis
-     * @param abortSignal
-     * @param preFetchedUsdPrice An optional price pre-fetched with {@link preFetchUsdPrice}
-     */
-    public async getBtcUsdValue(
-        btcSats: bigint,
-        abortSignal?: AbortSignal,
-        preFetchedUsdPrice?: number
-    ): Promise<number> {
-        return this.swapPrice.getBtcUsdValue(btcSats, abortSignal, preFetchedUsdPrice);
-    }
-
-    /**
-     * Returns the USD value of the smart chain token amount
-     *
-     * @param tokenAmount Amount of the token in base units
-     * @param tokenAddress Token address
-     * @param abortSignal
-     * @param preFetchedUsdPrice An optional price pre-fetched with {@link preFetchUsdPrice}
-     */
-    public async getTokenUsdValue(
-        tokenAmount: bigint,
-        tokenAddress: string,
-        abortSignal?: AbortSignal,
-        preFetchedUsdPrice?: number
-    ): Promise<number> {
-        return this.swapPrice.getTokenUsdValue(this.chainIdentifier, tokenAmount, tokenAddress, abortSignal, preFetchedUsdPrice);
-    }
-
-    /**
-     * Returns the USD value of the token amount
-     *
-     * @param amount Amount in base units of the token
-     * @param token Token to fetch the usd price for
-     * @param abortSignal
-     * @param preFetchedUsdPrice An optional price pre-fetched with {@link preFetchUsdPrice}
-     */
-    public getUsdValue(
-        amount: bigint,
-        token: Token<ChainIdentifier>,
-        abortSignal?: AbortSignal,
-        preFetchedUsdPrice?: number
-    ): Promise<number> {
-        return this.swapPrice.getUsdValue(amount, token, abortSignal, preFetchedUsdPrice);
-    }
-
-}
+import {ISwapPrice} from "./abstract/ISwapPrice";
+import {ChainIds, MultiChain} from "../swapper/Swapper";
+
+import {Token} from "../types/Token";
+import {PriceInfoType} from "../types/PriceInfoType";
+
+/**
+ * Chain-specific wrapper for swap pricing
+ *
+ * @category Pricing
+ */
+export class SwapPriceWithChain<T extends MultiChain, ChainIdentifier extends ChainIds<T>> {
+
+    swapPrice: ISwapPrice<T>;
+    chainIdentifier: ChainIdentifier;
+    maxAllowedFeeDifferencePPM: bigint;
+
+    constructor(swapPrice: ISwapPrice<T>, chainIdentifier: ChainIdentifier) {
+        this.swapPrice = swapPrice;
+        this.chainIdentifier = chainIdentifier;
+        this.maxAllowedFeeDifferencePPM = swapPrice.maxAllowedFeeDifferencePPM;
+    }
+
+    /**
+     * Checks whether the swap amounts are valid given the current market rate for a given pair
+     *
+     * @param amountSats Amount of sats (BTC) to be received from the swap
+     * @param satsBaseFee Base fee in sats (BTC) as reported by the intermediary
+     * @param feePPM PPM fee rate as reported by the intermediary
+     * @param paidToken Amount of token to be paid to the swap
+     * @param tokenAddress Token address to be paid
+     * @param abortSignal Abort signal
+     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     */
+    public async isValidAmountSend(
+        amountSats: bigint,
+        satsBaseFee: bigint,
+        feePPM: bigint,
+        paidToken: bigint,
+        tokenAddress: string,
+        abortSignal?: AbortSignal,
+        preFetchedPrice?: bigint
+    ): Promise<PriceInfoType> {
+        return this.swapPrice.isValidAmountSend<ChainIdentifier>(
+            this.chainIdentifier, amountSats, satsBaseFee, feePPM, paidToken, tokenAddress, abortSignal, preFetchedPrice
+        );
+    }
+
+    /**
+     * Checks whether the swap amounts are valid given the current market rate for a given pair
+     *
+     * @param amountSats Amount of sats (BTC) to be paid to the swap
+     * @param satsBaseFee Base fee in sats (BTC) as reported by the intermediary
+     * @param feePPM PPM fee rate as reported by the intermediary
+     * @param receiveToken Amount of token to be received from the swap
+     * @param tokenAddress Token address to be received
+     * @param abortSignal Abort signal
+     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     */
+    public async isValidAmountReceive(
+        amountSats: bigint,
+        satsBaseFee: bigint,
+        feePPM: bigint,
+        receiveToken: bigint,
+        tokenAddress: string,
+        abortSignal?: AbortSignal,
+        preFetchedPrice?: bigint
+    ): Promise<PriceInfoType> {
+        return this.swapPrice.isValidAmountReceive<ChainIdentifier>(
+            this.chainIdentifier, amountSats, satsBaseFee, feePPM, receiveToken, tokenAddress, abortSignal, preFetchedPrice
+        );
+    }
+
+    /**
+     * Pre-fetches the pricing data for a given token, such that further calls to {@link isValidAmountReceive} or
+     *  {@link isValidAmountSend} are quicker and don't need to wait for the price fetch
+     *
+     * @param tokenAddress Token address
+     * @param abortSignal Abort signal
+     */
+    public preFetchPrice(tokenAddress: string, abortSignal?: AbortSignal): Promise<bigint> {
+        return this.swapPrice.preFetchPrice<ChainIdentifier>(this.chainIdentifier, tokenAddress, abortSignal);
+    }
+
+    /**
+     * Pre-fetches the Bitcoin USD price data, such that further calls to {@link getBtcUsdValue},
+     *  {@link getTokenUsdValue} or {@link getUsdValue} are quicker and don't need to wait for the price fetch
+     *
+     * @param abortSignal
+     */
+    public preFetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
+        return this.swapPrice.preFetchUsdPrice(abortSignal);
+    }
+
+    /**
+     * Returns amount of `toToken` that is equivalent to `fromAmount` satoshis
+     *
+     * @param fromAmount Amount of satoshis
+     * @param toToken Token address
+     * @param abortSignal
+     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     * @throws {Error} when token is not found
+     */
+    public async getFromBtcSwapAmount(
+        fromAmount: bigint,
+        toToken: string,
+        abortSignal?: AbortSignal,
+        preFetchedPrice?: bigint
+    ): Promise<bigint> {
+        return this.swapPrice.getFromBtcSwapAmount<ChainIdentifier>(
+            this.chainIdentifier, fromAmount, toToken, abortSignal, preFetchedPrice
+        );
+    }
+
+    /**
+     * Returns amount of satoshis that are equivalent to `fromAmount` of `fromToken`
+     *
+     * @param fromAmount Amount of the token
+     * @param fromToken Token address
+     * @param abortSignal
+     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     * @throws {Error} when token is not found
+     */
+    public async getToBtcSwapAmount(
+        fromAmount: bigint,
+        fromToken: string,
+        abortSignal?: AbortSignal,
+        preFetchedPrice?: bigint
+    ): Promise<bigint> {
+        return this.swapPrice.getToBtcSwapAmount<ChainIdentifier>(
+            this.chainIdentifier, fromAmount, fromToken, abortSignal, preFetchedPrice
+        );
+    }
+
+    /**
+     * Returns whether the token should be ignored and pricing for it not calculated
+     *
+     * @param tokenAddress Token address
+     * @throws {Error} if token is not found
+     */
+    public shouldIgnore(tokenAddress: string): boolean {
+        return this.swapPrice.shouldIgnore<ChainIdentifier>(this.chainIdentifier, tokenAddress);
+    }
+
+    /**
+     * Returns the USD value of the bitcoin amount
+     *
+     * @param btcSats Bitcoin amount in satoshis
+     * @param abortSignal
+     * @param preFetchedUsdPrice An optional price pre-fetched with {@link preFetchUsdPrice}
+     */
+    public async getBtcUsdValue(
+        btcSats: bigint,
+        abortSignal?: AbortSignal,
+        preFetchedUsdPrice?: number
+    ): Promise<number> {
+        return this.swapPrice.getBtcUsdValue(btcSats, abortSignal, preFetchedUsdPrice);
+    }
+
+    /**
+     * Returns the USD value of the smart chain token amount
+     *
+     * @param tokenAmount Amount of the token in base units
+     * @param tokenAddress Token address
+     * @param abortSignal
+     * @param preFetchedUsdPrice An optional price pre-fetched with {@link preFetchUsdPrice}
+     */
+    public async getTokenUsdValue(
+        tokenAmount: bigint,
+        tokenAddress: string,
+        abortSignal?: AbortSignal,
+        preFetchedUsdPrice?: number
+    ): Promise<number> {
+        return this.swapPrice.getTokenUsdValue(this.chainIdentifier, tokenAmount, tokenAddress, abortSignal, preFetchedUsdPrice);
+    }
+
+    /**
+     * Returns the USD value of the token amount
+     *
+     * @param amount Amount in base units of the token
+     * @param token Token to fetch the usd price for
+     * @param abortSignal
+     * @param preFetchedUsdPrice An optional price pre-fetched with {@link preFetchUsdPrice}
+     */
+    public getUsdValue(
+        amount: bigint,
+        token: Token<ChainIdentifier>,
+        abortSignal?: AbortSignal,
+        preFetchedUsdPrice?: number
+    ): Promise<number> {
+        return this.swapPrice.getUsdValue(amount, token, abortSignal, preFetchedUsdPrice);
+    }
+
+}

package/src/prices/abstract/ICachedSwapPrice.ts

@@ -1,86 +1,86 @@
-import {ISwapPrice} from "./ISwapPrice";
-import {ChainIds, MultiChain} from "../../swapper/Swapper";
-
-const DEFAULT_CACHE_DURATION = 10000;
-
-export 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) {
-        super(maxAllowedFeeDiffPPM);
-        this.cacheTimeout = cacheTimeout || DEFAULT_CACHE_DURATION;
-    }
-
-    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> {
-        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] as any)[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
-     */
-    protected getUsdPrice(abortSignal?: AbortSignal): Promise<number> {
-        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;
-    }
-
+import {ISwapPrice} from "./ISwapPrice";
+import {ChainIds, MultiChain} from "../../swapper/Swapper";
+
+const DEFAULT_CACHE_DURATION = 10000;
+
+export 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) {
+        super(maxAllowedFeeDiffPPM);
+        this.cacheTimeout = cacheTimeout || DEFAULT_CACHE_DURATION;
+    }
+
+    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> {
+        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] as any)[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
+     */
+    protected getUsdPrice(abortSignal?: AbortSignal): Promise<number> {
+        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;
+    }
+
 }