@atomiqlabs/sdk 7.0.12 → 8.0.8

package/src/prices/RedundantSwapPrice.ts

@@ -0,0 +1,245 @@
+import {IPriceProvider} from "./abstract/IPriceProvider";
+import {BinancePriceProvider} from "./providers/BinancePriceProvider";
+import {OKXPriceProvider} from "./providers/OKXPriceProvider";
+import {CoinGeckoPriceProvider} from "./providers/CoinGeckoPriceProvider";
+import {CoinPaprikaPriceProvider} from "./providers/CoinPaprikaPriceProvider";
+import {promiseAny} from "../utils/Utils";
+import {ICachedSwapPrice} from "./abstract/ICachedSwapPrice";
+import {RequestError} from "../errors/RequestError";
+import {ChainIds, MultiChain} from "../swapper/Swapper";
+import {KrakenPriceProvider} from "./providers/KrakenPriceProvider";
+import {getLogger} from "../utils/Logger";
+import {tryWithRetries} from "../utils/RetryUtils";
+
+/**
+ * Asset configuration for redundant swap pricing
+ * @category Pricing and LPs
+ */
+export type RedundantSwapPriceAssets<T extends MultiChain> = {
+    binancePair?: string,
+    okxPair?: string,
+    coinGeckoCoinId?: string,
+    coinPaprikaCoinId?: string,
+    krakenPair?: string,
+    chains: {
+        [chainIdentifier in keyof T]?: {
+            address: string,
+            decimals: number
+        }
+    }
+}[];
+
+export type CtorCoinDecimals<T extends MultiChain> = {
+    chains: {
+        [chainIdentifier in keyof T]?: {
+            address: string,
+            decimals: number
+        }
+    }
+}[];
+
+type CoinDecimals<T extends MultiChain> = {
+    [chainIdentifier in keyof T]?: {
+        [tokenAddress: string]: number
+    }
+};
+
+const logger = getLogger("RedundantSwapPrice: ");
+
+/**
+ * Swap price API using multiple price sources, handles errors on the APIs and automatically switches between them, such
+ *  that there always is a functional API
+ * @category Pricing and LPs
+ */
+export class RedundantSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T> {
+
+    static createFromTokenMap<T extends MultiChain>(maxAllowedFeeDiffPPM: bigint, assets: RedundantSwapPriceAssets<T>, cacheTimeout?: number): RedundantSwapPrice<T> {
+        const priceApis = [
+            new BinancePriceProvider(assets.map(coinData => {
+                return {
+                    coinId: coinData.binancePair,
+                    chains: coinData.chains
+                };
+            })),
+            new OKXPriceProvider(assets.map(coinData => {
+                return {
+                    coinId: coinData.okxPair,
+                    chains: coinData.chains
+                };
+            })),
+            new CoinGeckoPriceProvider(assets.map(coinData => {
+                return {
+                    coinId: coinData.coinGeckoCoinId,
+                    chains: coinData.chains
+                };
+            })),
+            new CoinPaprikaPriceProvider(assets.map(coinData => {
+                return {
+                    coinId: coinData.coinPaprikaCoinId,
+                    chains: coinData.chains
+                };
+            })),
+            new KrakenPriceProvider(assets.map(coinData => {
+                return {
+                    coinId: coinData.krakenPair,
+                    chains: coinData.chains
+                };
+            }))
+        ];
+
+        return new RedundantSwapPrice(maxAllowedFeeDiffPPM, assets, priceApis, cacheTimeout);
+    }
+
+    coinsDecimals: CoinDecimals<T> = {};
+    priceApis: {
+        priceApi: IPriceProvider<T>,
+        operational?: boolean
+    }[];
+
+    constructor(maxAllowedFeeDiffPPM: bigint, coinsDecimals: CtorCoinDecimals<T>, priceApis: IPriceProvider<T>[], cacheTimeout?: number) {
+        super(maxAllowedFeeDiffPPM, cacheTimeout);
+        for(let coinData of coinsDecimals) {
+            for(let chainId in coinData.chains) {
+                const {address, decimals} = coinData.chains[chainId]!;
+                this.coinsDecimals[chainId] ??= {};
+                (this.coinsDecimals[chainId] as any)[address.toString()] = decimals;
+            }
+        }
+        this.priceApis = priceApis.map(api => {
+            return {
+                priceApi: api
+            }
+        });
+    }
+
+    /**
+     * Returns price api that should be operational
+     *
+     * @private
+     */
+    private getOperationalPriceApi(): {priceApi: IPriceProvider<T>, operational?: boolean} | undefined {
+        return this.priceApis.find(e => e.operational===true);
+    }
+
+    /**
+     * Returns price apis that are maybe operational, in case none is considered operational returns all of the price
+     *  apis such that they can be tested again whether they are operational
+     *
+     * @private
+     */
+    private getMaybeOperationalPriceApis(): {priceApi: IPriceProvider<T>, operational?: boolean}[] {
+        let operational = this.priceApis.filter(e => e.operational===true || e.operational===undefined);
+        if(operational.length===0) {
+            this.priceApis.forEach(e => e.operational=undefined);
+            operational = this.priceApis;
+        }
+        return operational;
+    }
+
+    /**
+     * Fetches price in parallel from multiple maybe operational price APIs
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param abortSignal
+     * @private
+     */
+    private async fetchPriceFromMaybeOperationalPriceApis<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal) {
+        try {
+            return await promiseAny<bigint>(this.getMaybeOperationalPriceApis().map(
+                obj => (async () => {
+                    try {
+                        const price = await obj.priceApi.getPrice(chainIdentifier, token, abortSignal);
+                        logger.debug("fetchPrice(): Price from "+obj.priceApi.constructor.name+": ", price.toString(10));
+                        obj.operational = true;
+                        return price;
+                    } catch (e) {
+                        if(abortSignal!=null) abortSignal.throwIfAborted();
+                        obj.operational = false;
+                        throw e;
+                    }
+                })()
+            ))
+        } catch (_e: any) {
+            const e = _e as any[];
+            if(abortSignal!=null) abortSignal.throwIfAborted();
+            throw e.find(err => !(err instanceof RequestError)) || e[0];
+        }
+    }
+
+    /**
+     * Fetches the prices, first tries to use the operational price API (if any) and if that fails it falls back
+     *  to using maybe operational price APIs
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param abortSignal
+     * @private
+     */
+    protected fetchPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint> {
+        return tryWithRetries(async () => {
+            const operationalPriceApi = this.getOperationalPriceApi();
+            if (operationalPriceApi != null) {
+                try {
+                    return await operationalPriceApi.priceApi.getPrice(chainIdentifier, token, abortSignal);
+                } catch (err) {
+                    if (abortSignal != null)
+                        abortSignal.throwIfAborted();
+                    operationalPriceApi.operational = false;
+                    return await this.fetchPriceFromMaybeOperationalPriceApis(chainIdentifier, token, abortSignal);
+                }
+            }
+            return await this.fetchPriceFromMaybeOperationalPriceApis(chainIdentifier, token, abortSignal);
+        }, undefined, RequestError, abortSignal);
+    }
+
+    protected getDecimals<C extends ChainIds<T>>(chainIdentifier: C, token: string): number | null {
+        if(this.coinsDecimals[chainIdentifier]==null) return null;
+        return this.coinsDecimals[chainIdentifier]?.[token.toString()] ?? null;
+    }
+
+
+    /**
+     * Fetches BTC price in USD in parallel from multiple maybe operational price APIs
+     *
+     * @param abortSignal
+     * @private
+     */
+    private async fetchUsdPriceFromMaybeOperationalPriceApis(abortSignal?: AbortSignal): Promise<number> {
+        try {
+            return await promiseAny<number>(this.getMaybeOperationalPriceApis().map(
+                obj => (async () => {
+                    try {
+                        const price = await obj.priceApi.getUsdPrice(abortSignal);
+                        logger.debug("fetchPrice(): USD price from "+obj.priceApi.constructor.name+": ", price.toString(10));
+                        obj.operational = true;
+                        return price;
+                    } catch (e) {
+                        if(abortSignal!=null) abortSignal.throwIfAborted();
+                        obj.operational = false;
+                        throw e;
+                    }
+                })()
+            ))
+        } catch (_e: any) {
+            const e = _e as any[];
+            if(abortSignal!=null) abortSignal.throwIfAborted();
+            throw e.find(err => !(err instanceof RequestError)) || e[0];
+        }
+    }
+
+    protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
+        return tryWithRetries(() => {
+            const operationalPriceApi = this.getOperationalPriceApi();
+            if(operationalPriceApi!=null) {
+                return operationalPriceApi.priceApi.getUsdPrice(abortSignal).catch(err => {
+                    if(abortSignal!=null) abortSignal.throwIfAborted();
+                    operationalPriceApi.operational = false;
+                    return this.fetchUsdPriceFromMaybeOperationalPriceApis(abortSignal);
+                });
+            }
+            return this.fetchUsdPriceFromMaybeOperationalPriceApis(abortSignal);
+        }, undefined, RequestError, abortSignal);
+    }
+
+}

package/src/prices/SingleSwapPrice.ts

@@ -0,0 +1,47 @@
+import {IPriceProvider} from "./abstract/IPriceProvider";
+import {ICachedSwapPrice} from "./abstract/ICachedSwapPrice";
+import {ChainIds, MultiChain} from "../swapper/Swapper";
+
+/**
+ * Swap price API using single price source
+ * @category Pricing and LPs
+ */
+export class SingleSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T> {
+
+    priceProvider: IPriceProvider<T>;
+
+    constructor(maxAllowedFeeDiffPPM: bigint, priceProvider: IPriceProvider<T>, cacheTimeout?: number) {
+        super(maxAllowedFeeDiffPPM, cacheTimeout);
+        this.priceProvider = priceProvider;
+    }
+
+    /**
+     * Fetch price in uSats (micro sats) for a given token against BTC
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param abortSignal
+     * @protected
+     * @returns token price in uSats (micro sats)
+     */
+    protected fetchPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint> {
+        return this.priceProvider.getPrice(chainIdentifier, token, 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
+     */
+    protected getDecimals<C extends ChainIds<T>>(chainIdentifier: C, token: string): number | null {
+        return this.priceProvider.getDecimals(chainIdentifier, token.toString());
+    }
+
+    protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
+        return this.priceProvider.getUsdPrice(abortSignal);
+    }
+
+}

package/src/prices/SwapPriceWithChain.ts

@@ -0,0 +1,157 @@
+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 and LPs
+ */
+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 token
+     * @param abortSignal
+     * @param preFetchedPrice Already pre-fetched price
+     */
+    public async isValidAmountSend(
+        amountSats: bigint,
+        satsBaseFee: bigint,
+        feePPM: bigint,
+        paidToken: bigint,
+        token: string,
+        abortSignal?: AbortSignal,
+        preFetchedPrice?: bigint
+    ): Promise<PriceInfoType> {
+        return this.swapPrice.isValidAmountSend<ChainIdentifier>(
+            this.chainIdentifier, amountSats, satsBaseFee, feePPM, paidToken, token, 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 token
+     * @param abortSignal
+     * @param preFetchedPrice Already pre-fetched price
+     */
+    public async isValidAmountReceive(
+        amountSats: bigint,
+        satsBaseFee: bigint,
+        feePPM: bigint,
+        receiveToken: bigint,
+        token: string,
+        abortSignal?: AbortSignal,
+        preFetchedPrice?: bigint
+    ): Promise<PriceInfoType> {
+        return this.swapPrice.isValidAmountReceive<ChainIdentifier>(
+            this.chainIdentifier, amountSats, satsBaseFee, feePPM, receiveToken, token, abortSignal, preFetchedPrice
+        );
+    }
+
+    public preFetchPrice(token: string, abortSignal?: AbortSignal): Promise<bigint> {
+        return this.swapPrice.preFetchPrice<ChainIdentifier>(this.chainIdentifier, token, abortSignal);
+    }
+
+    public preFetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
+        return this.swapPrice.preFetchUsdPrice(abortSignal);
+    }
+
+    /**
+     * Returns amount of {toToken} that are equivalent to {fromAmount} satoshis
+     *
+     * @param fromAmount        Amount of satoshis
+     * @param toToken           Token
+     * @param abortSignal
+     * @param preFetchedPrice
+     * @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
+     * @param abortSignal
+     * @param preFetchedPrice Pre-fetched swap price if available
+     * @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
+     * @throws {Error} if token is not found
+     */
+    public shouldIgnore(tokenAddress: string): boolean {
+        return this.swapPrice.shouldIgnore<ChainIdentifier>(this.chainIdentifier, tokenAddress);
+    }
+
+    public async getBtcUsdValue(
+        btcSats: bigint,
+        abortSignal?: AbortSignal,
+        preFetchedPrice?: number
+    ): Promise<number> {
+        return this.swapPrice.getBtcUsdValue(btcSats, abortSignal, preFetchedPrice);
+    }
+
+    public async getTokenUsdValue(
+        tokenAmount: bigint,
+        token: string,
+        abortSignal?: AbortSignal,
+        preFetchedPrice?: number
+    ): Promise<number> {
+        return this.swapPrice.getTokenUsdValue(this.chainIdentifier, tokenAmount, token, abortSignal, preFetchedPrice);
+    }
+
+    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

@@ -0,0 +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;
+    }
+
+}

package/src/prices/abstract/IPriceProvider.ts

@@ -0,0 +1,128 @@
+import {ChainIds, MultiChain} from "../../swapper/Swapper";
+
+/**
+ * Coin type definition for price providers
+ * @category Pricing and LPs
+ */
+export type CoinType = {
+    coinId: string;
+    decimals: number;
+};
+
+/**
+ * Constructor coin types for price providers
+ * @category Pricing and LPs
+ */
+export type CtorCoinTypes<T extends MultiChain> = {
+    coinId?: string,
+    chains: {
+        [chainId in keyof T]?: {
+            address: string,
+            decimals: number,
+        }
+    }
+}[]
+
+/**
+ * Coin types mapping by chain
+ * @category Pricing and LPs
+ */
+export type CoinTypes<T extends MultiChain> = {
+    [chainId in keyof T]?: {
+        [address: string]: CoinType
+    }
+}
+
+/**
+ * Abstract base class for price provider implementations
+ * @category Pricing and LPs
+ */
+export abstract class IPriceProvider<T extends MultiChain> {
+
+    coinsMap: CoinTypes<T> = {};
+
+    protected constructor(coins: CtorCoinTypes<T>) {
+        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] as any)[address.toString()] = {
+                    coinId: coinData.coinId,
+                    decimals
+                };
+            }
+        }
+    }
+
+    /**
+     * 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> {
+        let tokenAddress: string = 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: number = 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?: AbortSignal): Promise<number> {
+        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<C extends ChainIds<T>>(chainIdentifier: C, token: string): number {
+        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;
+    }
+
+}