@atomiqlabs/sdk 7.0.12 → 8.0.7

package/dist/prices/SwapPriceWithChain.d.ts

@@ -0,0 +1,70 @@
+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 declare class SwapPriceWithChain<T extends MultiChain, ChainIdentifier extends ChainIds<T>> {
+    swapPrice: ISwapPrice<T>;
+    chainIdentifier: ChainIdentifier;
+    maxAllowedFeeDifferencePPM: bigint;
+    constructor(swapPrice: ISwapPrice<T>, chainIdentifier: ChainIdentifier);
+    /**
+     * 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
+     */
+    isValidAmountSend(amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, paidToken: bigint, token: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint): Promise<PriceInfoType>;
+    /**
+     * 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
+     */
+    isValidAmountReceive(amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, receiveToken: bigint, token: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint): Promise<PriceInfoType>;
+    preFetchPrice(token: string, abortSignal?: AbortSignal): Promise<bigint>;
+    preFetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+    /**
+     * 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
+     */
+    getFromBtcSwapAmount(fromAmount: bigint, toToken: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint): Promise<bigint>;
+    /**
+     * 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
+     */
+    getToBtcSwapAmount(fromAmount: bigint, fromToken: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint): Promise<bigint>;
+    /**
+     * Returns whether the token should be ignored and pricing for it not calculated
+     *
+     * @param tokenAddress
+     * @throws {Error} if token is not found
+     */
+    shouldIgnore(tokenAddress: string): boolean;
+    getBtcUsdValue(btcSats: bigint, abortSignal?: AbortSignal, preFetchedPrice?: number): Promise<number>;
+    getTokenUsdValue(tokenAmount: bigint, token: string, abortSignal?: AbortSignal, preFetchedPrice?: number): Promise<number>;
+    getUsdValue(amount: bigint, token: Token<ChainIdentifier>, abortSignal?: AbortSignal, preFetchedUsdPrice?: number): Promise<number>;
+}

package/dist/prices/SwapPriceWithChain.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapPriceWithChain = void 0;
+/**
+ * Chain-specific wrapper for swap pricing
+ * @category Pricing and LPs
+ */
+class SwapPriceWithChain {
+    constructor(swapPrice, 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
+     */
+    async isValidAmountSend(amountSats, satsBaseFee, feePPM, paidToken, token, abortSignal, preFetchedPrice) {
+        return this.swapPrice.isValidAmountSend(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
+     */
+    async isValidAmountReceive(amountSats, satsBaseFee, feePPM, receiveToken, token, abortSignal, preFetchedPrice) {
+        return this.swapPrice.isValidAmountReceive(this.chainIdentifier, amountSats, satsBaseFee, feePPM, receiveToken, token, abortSignal, preFetchedPrice);
+    }
+    preFetchPrice(token, abortSignal) {
+        return this.swapPrice.preFetchPrice(this.chainIdentifier, token, abortSignal);
+    }
+    preFetchUsdPrice(abortSignal) {
+        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
+     */
+    async getFromBtcSwapAmount(fromAmount, toToken, abortSignal, preFetchedPrice) {
+        return this.swapPrice.getFromBtcSwapAmount(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
+     */
+    async getToBtcSwapAmount(fromAmount, fromToken, abortSignal, preFetchedPrice) {
+        return this.swapPrice.getToBtcSwapAmount(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
+     */
+    shouldIgnore(tokenAddress) {
+        return this.swapPrice.shouldIgnore(this.chainIdentifier, tokenAddress);
+    }
+    async getBtcUsdValue(btcSats, abortSignal, preFetchedPrice) {
+        return this.swapPrice.getBtcUsdValue(btcSats, abortSignal, preFetchedPrice);
+    }
+    async getTokenUsdValue(tokenAmount, token, abortSignal, preFetchedPrice) {
+        return this.swapPrice.getTokenUsdValue(this.chainIdentifier, tokenAmount, token, abortSignal, preFetchedPrice);
+    }
+    getUsdValue(amount, token, abortSignal, preFetchedUsdPrice) {
+        return this.swapPrice.getUsdValue(amount, token, abortSignal, preFetchedUsdPrice);
+    }
+}
+exports.SwapPriceWithChain = SwapPriceWithChain;

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

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

package/dist/prices/abstract/ICachedSwapPrice.js

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

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

@@ -0,0 +1,81 @@
+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 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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPriceProvider = void 0;
+/**
+ * Abstract base class for price provider implementations
+ * @category Pricing and LPs
+ */
+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;

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

@@ -0,0 +1,117 @@
+import { ChainIds, MultiChain } from "../../swapper/Swapper";
+import { Token } from "../../types/Token";
+import { PriceInfoType } from "../../types/PriceInfoType";
+/**
+ * Abstract base class for swap pricing implementations
+ * @category Pricing and LPs
+ */
+export declare abstract class ISwapPrice<T extends MultiChain = MultiChain> {
+    maxAllowedFeeDifferencePPM: bigint;
+    protected constructor(maxAllowedFeeDifferencePPM: bigint);
+    /**
+     * Gets the decimal places for a given token, returns -1 if token should be ignored & null if token is not found
+     * @param chainIdentifier
+     * @param token
+     * @protected
+     */
+    protected abstract getDecimals<C extends ChainIds<T>>(chainIdentifier: C, token: string): number | null;
+    /**
+     * Returns the price of the token in BTC uSats (microSats)
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param abortSignal
+     * @protected
+     */
+    protected abstract getPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint>;
+    /**
+     * Returns the price of bitcoin in USD, (sats/USD)
+     *
+     * @param abortSignal
+     * @protected
+     */
+    protected abstract getUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+    protected getDecimalsThrowing<C extends ChainIds<T>>(chainIdentifier: C, token: string): number;
+    /**
+     * Recomputes pricing info without fetching the current price
+     *
+     * @param chainIdentifier
+     * @param amountSats
+     * @param satsBaseFee
+     * @param feePPM
+     * @param paidToken
+     * @param token
+     */
+    recomputePriceInfoSend<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, paidToken: bigint, token: string): PriceInfoType;
+    /**
+     * Checks whether the swap amounts are valid given the current market rate for a given pair
+     *
+     * @param chainIdentifier
+     * @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
+     */
+    isValidAmountSend<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, paidToken: bigint, token: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint | null): Promise<PriceInfoType>;
+    /**
+     * Recomputes pricing info without fetching the current price
+     *
+     * @param chainIdentifier
+     * @param amountSats
+     * @param satsBaseFee
+     * @param feePPM
+     * @param receiveToken
+     * @param token
+     */
+    recomputePriceInfoReceive<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, receiveToken: bigint, token: string): PriceInfoType;
+    /**
+     * Checks whether the swap amounts are valid given the current market rate for a given pair
+     *
+     * @param chainIdentifier
+     * @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
+     */
+    isValidAmountReceive<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, receiveToken: bigint, token: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint | null): Promise<PriceInfoType>;
+    preFetchPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint>;
+    preFetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+    /**
+     * Returns amount of {toToken} that are equivalent to {fromAmount} satoshis
+     *
+     * @param chainIdentifier
+     * @param fromAmount        Amount of satoshis
+     * @param toToken           Token
+     * @param abortSignal
+     * @param preFetchedPrice
+     * @throws {Error} when token is not found
+     */
+    getFromBtcSwapAmount<C extends ChainIds<T>>(chainIdentifier: C, fromAmount: bigint, toToken: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint | null): Promise<bigint>;
+    /**
+     * Returns amount of satoshis that are equivalent to {fromAmount} of {fromToken}
+     *
+     * @param chainIdentifier
+     * @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
+     */
+    getToBtcSwapAmount<C extends ChainIds<T>>(chainIdentifier: C, fromAmount: bigint, fromToken: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint): Promise<bigint>;
+    /**
+     * Returns whether the token should be ignored and pricing for it not calculated
+     * @param chainIdentifier
+     * @param tokenAddress
+     * @throws {Error} if token is not found
+     */
+    shouldIgnore<C extends ChainIds<T>>(chainIdentifier: C, tokenAddress: string): boolean;
+    getBtcUsdValue(btcSats: bigint, abortSignal?: AbortSignal, preFetchedPrice?: number): Promise<number>;
+    getTokenUsdValue<C extends ChainIds<T>>(chainId: C, tokenAmount: bigint, token: string, abortSignal?: AbortSignal, preFetchedPrice?: number): Promise<number>;
+    getUsdValue<C extends ChainIds<T>>(amount: bigint, token: Token<C>, abortSignal?: AbortSignal, preFetchedUsdPrice?: number): Promise<number>;
+}