@atomiqlabs/sdk 7.0.12 → 8.0.8

package/dist/lnurl/LNURL.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LNURL = exports.isLNURLPaySuccessAction = void 0;
+const RequestError_1 = require("../errors/RequestError");
+const bolt11_1 = require("@atomiqlabs/bolt11");
+const UserError_1 = require("../errors/UserError");
+const base_1 = require("@scure/base");
+const aes_1 = require("@noble/ciphers/aes");
+const buffer_1 = require("buffer");
+const sha2_1 = require("@noble/hashes/sha2");
+const HttpUtils_1 = require("../http/HttpUtils");
+const LNURLWithdraw_1 = require("../types/lnurl/LNURLWithdraw");
+const LNURLPay_1 = require("../types/lnurl/LNURLPay");
+const RetryUtils_1 = require("../utils/RetryUtils");
+function isLNURLError(obj) {
+    return obj.status === "ERROR" &&
+        (obj.reason == null || typeof obj.reason === "string");
+}
+function isLNURLPayResult(obj, domain) {
+    return typeof obj.pr === "string" &&
+        (obj.routes == null || Array.isArray(obj.routes)) &&
+        (obj.disposable === null || obj.disposable === undefined || typeof obj.disposable === "boolean") &&
+        (obj.successAction == null || isLNURLPaySuccessAction(obj.successAction, domain));
+}
+function isLNURLPaySuccessAction(obj, domain) {
+    if (obj == null || typeof obj !== 'object' || typeof obj.tag !== 'string')
+        return false;
+    switch (obj.tag) {
+        case "message":
+            return obj.message != null && obj.message.length <= 144;
+        case "url":
+            return obj.description != null && obj.description.length <= 144 &&
+                obj.url != null &&
+                (domain == null || new URL(obj.url).hostname === domain);
+        case "aes":
+            return obj.description != null && obj.description.length <= 144 &&
+                obj.ciphertext != null && obj.ciphertext.length <= 4096 && BASE64_REGEX.test(obj.ciphertext) &&
+                obj.iv != null && obj.iv.length <= 24 && BASE64_REGEX.test(obj.iv);
+        default:
+            //Unsupported action
+            return false;
+    }
+}
+exports.isLNURLPaySuccessAction = isLNURLPaySuccessAction;
+const BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const MAIL_REGEX = /(?:[A-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[A-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[A-z0-9](?:[A-z0-9-]*[A-z0-9])?\.)+[A-z0-9](?:[A-z0-9-]*[A-z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[A-z0-9-]*[A-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/;
+/**
+ * LNURL encoding/decoding and callback handling
+ * @category Bitcoin
+ */
+class LNURL {
+    static findBech32LNURL(str) {
+        const arr = /,*?((lnurl)([0-9]{1,}[a-z0-9]+){1})/.exec(str.toLowerCase());
+        if (arr == null)
+            return null;
+        return arr[1];
+    }
+    static isBech32LNURL(str) {
+        return this.findBech32LNURL(str) != null;
+    }
+    /**
+     * Checks whether a provided string is bare (non bech32 encoded) lnurl
+     * @param str
+     * @private
+     */
+    static isBareLNURL(str) {
+        try {
+            return str.startsWith("lnurlw://") || str.startsWith("lnurlp://");
+        }
+        catch (e) { }
+        return false;
+    }
+    /**
+     * Checks if the provided string is a lightning network address (e.g. satoshi@nakamoto.com)
+     * @param str
+     * @private
+     */
+    static isLightningAddress(str) {
+        return MAIL_REGEX.test(str);
+    }
+    /**
+     * Checks whether a given string is a LNURL or lightning address
+     * @param str
+     */
+    static isLNURL(str) {
+        return LNURL.isBech32LNURL(str) || LNURL.isLightningAddress(str) || LNURL.isBareLNURL(str);
+    }
+    /**
+     * Extracts the URL that needs to be request from LNURL or lightning address
+     * @param str
+     * @private
+     * @returns An URL to send the request to, or null if it cannot be parsed
+     */
+    static extractCallUrl(str) {
+        if (MAIL_REGEX.test(str)) {
+            //lightning e-mail like address
+            const arr = str.split("@");
+            const username = arr[0];
+            const domain = arr[1];
+            let scheme = "https";
+            if (domain.endsWith(".onion")) {
+                scheme = "http";
+            }
+            return scheme + "://" + domain + "/.well-known/lnurlp/" + username;
+        }
+        else if (LNURL.isBareLNURL(str)) {
+            //non-bech32m encoded lnurl
+            const data = str.substring("lnurlw://".length);
+            const httpUrl = new URL("http://" + data);
+            let scheme = "https";
+            if (httpUrl.hostname.endsWith(".onion")) {
+                scheme = "http";
+            }
+            return scheme + "://" + data;
+        }
+        else {
+            const lnurl = LNURL.findBech32LNURL(str);
+            if (lnurl != null) {
+                let { prefix: hrp, words: dataPart } = base_1.bech32.decode(lnurl, 2000);
+                let requestByteArray = base_1.bech32.fromWords(dataPart);
+                return buffer_1.Buffer.from(requestByteArray).toString();
+            }
+        }
+        return null;
+    }
+    /**
+     * Sends a request to obtain data about a specific LNURL or lightning address
+     *
+     * @param str A lnurl or lightning address
+     * @param shouldRetry Whether we should retry in case of network failure
+     * @param timeout Request timeout in milliseconds
+     * @param abortSignal
+     */
+    static async getLNURL(str, shouldRetry = true, timeout, abortSignal) {
+        if (shouldRetry == null)
+            shouldRetry = true;
+        const url = LNURL.extractCallUrl(str);
+        if (url == null)
+            return null;
+        const sendRequest = () => (0, HttpUtils_1.httpGet)(url, timeout, abortSignal, true);
+        let response = shouldRetry ?
+            await (0, RetryUtils_1.tryWithRetries)(sendRequest, undefined, RequestError_1.RequestError, abortSignal) :
+            await sendRequest();
+        if (isLNURLError(response))
+            return null;
+        if (response.tag === "payRequest")
+            try {
+                response.decodedMetadata = JSON.parse(response.metadata);
+            }
+            catch (err) {
+                response.decodedMetadata = [];
+            }
+        if (!(0, LNURLPay_1.isLNURLPayParams)(response) && !(0, LNURLWithdraw_1.isLNURLWithdrawParams)(response))
+            return null;
+        return {
+            ...response,
+            url: str
+        };
+    }
+    /**
+     * Sends a request to obtain data about a specific LNURL or lightning address
+     *
+     * @param str A lnurl or lightning address
+     * @param shouldRetry Whether we should retry in case of network failure
+     * @param timeout Request timeout in milliseconds
+     * @param abortSignal
+     */
+    static async getLNURLType(str, shouldRetry, timeout, abortSignal) {
+        let res = await LNURL.getLNURL(str, shouldRetry, timeout, abortSignal);
+        if (res.tag === "payRequest") {
+            const payRequest = res;
+            let shortDescription = undefined;
+            let longDescription = undefined;
+            let icon = undefined;
+            payRequest.decodedMetadata.forEach(data => {
+                switch (data[0]) {
+                    case "text/plain":
+                        shortDescription = data[1];
+                        break;
+                    case "text/long-desc":
+                        longDescription = data[1];
+                        break;
+                    case "image/png;base64":
+                        icon = "data:" + data[0] + "," + data[1];
+                        break;
+                    case "image/jpeg;base64":
+                        icon = "data:" + data[0] + "," + data[1];
+                        break;
+                }
+            });
+            return {
+                type: "pay",
+                min: BigInt(payRequest.minSendable) / 1000n,
+                max: BigInt(payRequest.maxSendable) / 1000n,
+                commentMaxLength: payRequest.commentAllowed || 0,
+                shortDescription,
+                longDescription,
+                icon,
+                params: payRequest
+            };
+        }
+        if (res.tag === "withdrawRequest") {
+            const payRequest = res;
+            return {
+                type: "withdraw",
+                min: BigInt(payRequest.minWithdrawable) / 1000n,
+                max: BigInt(payRequest.maxWithdrawable) / 1000n,
+                params: payRequest
+            };
+        }
+        return null;
+    }
+    /**
+     * Uses a LNURL-pay request by obtaining a lightning network invoice from it
+     *
+     * @param payRequest LNURL params as returned from the getLNURL call
+     * @param amount Amount of sats (BTC) to pay
+     * @param comment Optional comment for the payment request
+     * @param timeout Request timeout in milliseconds
+     * @param abortSignal
+     * @throws {RequestError} If the response is non-200, status: ERROR, or invalid format
+     */
+    static async useLNURLPay(payRequest, amount, comment, timeout, abortSignal) {
+        const params = ["amount=" + (amount * 1000n).toString(10)];
+        if (comment != null) {
+            params.push("comment=" + encodeURIComponent(comment));
+        }
+        const queryParams = (payRequest.callback.includes("?") ? "&" : "?") + params.join("&");
+        const response = await (0, RetryUtils_1.tryWithRetries)(() => (0, HttpUtils_1.httpGet)(payRequest.callback + queryParams, timeout, abortSignal, true), undefined, RequestError_1.RequestError, abortSignal);
+        if (isLNURLError(response))
+            throw new RequestError_1.RequestError("LNURL callback error: " + response.reason, 200);
+        if (!isLNURLPayResult(response))
+            throw new RequestError_1.RequestError("Invalid LNURL response!", 200);
+        const parsedPR = (0, bolt11_1.decode)(response.pr);
+        const descHash = buffer_1.Buffer.from((0, sha2_1.sha256)(payRequest.metadata)).toString("hex");
+        if (parsedPR.tagsObject.purpose_commit_hash !== descHash)
+            throw new RequestError_1.RequestError("Invalid invoice received (description hash)!", 200);
+        const msats = parsedPR.millisatoshis;
+        if (msats == null)
+            throw new RequestError_1.RequestError("Invalid invoice received (amount msats not defined)", 200);
+        const invoiceMSats = BigInt(msats);
+        if (invoiceMSats !== (amount * 1000n))
+            throw new RequestError_1.RequestError("Invalid invoice received (amount)!", 200);
+        return {
+            invoice: response.pr,
+            parsedInvoice: parsedPR,
+            successAction: response.successAction ?? undefined
+        };
+    }
+    /**
+     * Submits the bolt11 lightning invoice to the lnurl withdraw url
+     *
+     * @param withdrawRequest Withdraw request to use
+     * @param withdrawRequest.k1 K1 parameter
+     * @param withdrawRequest.callback A URL to call
+     * @param lnpr bolt11 lightning network invoice to submit to the withdrawal endpoint
+     * @throws {RequestError} If the response is non-200 or status: ERROR
+     */
+    static async postInvoiceToLNURLWithdraw(withdrawRequest, lnpr) {
+        const params = [
+            "pr=" + lnpr,
+            "k1=" + withdrawRequest.k1
+        ];
+        const queryParams = (withdrawRequest.callback.includes("?") ? "&" : "?") + params.join("&");
+        const response = await (0, RetryUtils_1.tryWithRetries)(() => (0, HttpUtils_1.httpGet)(withdrawRequest.callback + queryParams, undefined, undefined, true), undefined, RequestError_1.RequestError);
+        if (isLNURLError(response))
+            throw new RequestError_1.RequestError("LNURL callback error: " + response.reason, 200);
+    }
+    /**
+     * Uses a LNURL-withdraw request by submitting a lightning network invoice to it
+     *
+     * @param withdrawRequest Withdrawal request as returned from getLNURL call
+     * @param lnpr bolt11 lightning network invoice to submit to the withdrawal endpoint
+     * @throws {UserError} In case the provided bolt11 lightning invoice has an amount that is out of bounds for
+     *  the specified LNURL-withdraw request
+     */
+    static async useLNURLWithdraw(withdrawRequest, lnpr) {
+        const min = BigInt(withdrawRequest.minWithdrawable) / 1000n;
+        const max = BigInt(withdrawRequest.maxWithdrawable) / 1000n;
+        const parsedPR = (0, bolt11_1.decode)(lnpr);
+        const msats = parsedPR.millisatoshis;
+        if (msats == null)
+            throw new UserError_1.UserError("Invoice without msats value field!");
+        const amount = (BigInt(msats) + 999n) / 1000n;
+        if (amount < min)
+            throw new UserError_1.UserError("Invoice amount less than minimum LNURL-withdraw limit");
+        if (amount > max)
+            throw new UserError_1.UserError("Invoice amount more than maximum LNURL-withdraw limit");
+        return await LNURL.postInvoiceToLNURLWithdraw(withdrawRequest, lnpr);
+    }
+    static decodeSuccessAction(successAction, secret) {
+        if (secret == null)
+            return null;
+        if (successAction == null)
+            return null;
+        if (successAction.tag === "message" && successAction.message != null) {
+            return {
+                description: successAction.message
+            };
+        }
+        if (successAction.tag === "url" && successAction.description != null && successAction.url != null) {
+            return {
+                description: successAction.description,
+                url: successAction.url
+            };
+        }
+        if (successAction.tag === "aes" && successAction.iv != null && successAction.ciphertext != null && successAction.description != null) {
+            const CBC = (0, aes_1.cbc)(buffer_1.Buffer.from(secret, "hex"), buffer_1.Buffer.from(successAction.iv, "hex"));
+            let plaintext = CBC.decrypt(buffer_1.Buffer.from(successAction.ciphertext, "base64"));
+            // remove padding
+            const size = plaintext.length;
+            const pad = plaintext[size - 1];
+            return {
+                description: successAction.description,
+                text: buffer_1.Buffer.from(plaintext).toString("utf8", 0, size - pad)
+            };
+        }
+        return null;
+    }
+}
+exports.LNURL = LNURL;

package/dist/prices/RedundantSwapPrice.d.ts

@@ -0,0 +1,89 @@
+import { IPriceProvider } from "./abstract/IPriceProvider";
+import { ICachedSwapPrice } from "./abstract/ICachedSwapPrice";
+import { ChainIds, MultiChain } from "../swapper/Swapper";
+/**
+ * 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;
+    };
+};
+/**
+ * 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 declare class RedundantSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T> {
+    static createFromTokenMap<T extends MultiChain>(maxAllowedFeeDiffPPM: bigint, assets: RedundantSwapPriceAssets<T>, cacheTimeout?: number): RedundantSwapPrice<T>;
+    coinsDecimals: CoinDecimals<T>;
+    priceApis: {
+        priceApi: IPriceProvider<T>;
+        operational?: boolean;
+    }[];
+    constructor(maxAllowedFeeDiffPPM: bigint, coinsDecimals: CtorCoinDecimals<T>, priceApis: IPriceProvider<T>[], cacheTimeout?: number);
+    /**
+     * Returns price api that should be operational
+     *
+     * @private
+     */
+    private getOperationalPriceApi;
+    /**
+     * 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;
+    /**
+     * Fetches price in parallel from multiple maybe operational price APIs
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param abortSignal
+     * @private
+     */
+    private fetchPriceFromMaybeOperationalPriceApis;
+    /**
+     * 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>;
+    protected getDecimals<C extends ChainIds<T>>(chainIdentifier: C, token: string): number | null;
+    /**
+     * Fetches BTC price in USD in parallel from multiple maybe operational price APIs
+     *
+     * @param abortSignal
+     * @private
+     */
+    private fetchUsdPriceFromMaybeOperationalPriceApis;
+    protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+}
+export {};

package/dist/prices/RedundantSwapPrice.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedundantSwapPrice = void 0;
+const BinancePriceProvider_1 = require("./providers/BinancePriceProvider");
+const OKXPriceProvider_1 = require("./providers/OKXPriceProvider");
+const CoinGeckoPriceProvider_1 = require("./providers/CoinGeckoPriceProvider");
+const CoinPaprikaPriceProvider_1 = require("./providers/CoinPaprikaPriceProvider");
+const Utils_1 = require("../utils/Utils");
+const ICachedSwapPrice_1 = require("./abstract/ICachedSwapPrice");
+const RequestError_1 = require("../errors/RequestError");
+const KrakenPriceProvider_1 = require("./providers/KrakenPriceProvider");
+const Logger_1 = require("../utils/Logger");
+const RetryUtils_1 = require("../utils/RetryUtils");
+const logger = (0, Logger_1.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
+ */
+class RedundantSwapPrice extends ICachedSwapPrice_1.ICachedSwapPrice {
+    static createFromTokenMap(maxAllowedFeeDiffPPM, assets, cacheTimeout) {
+        const priceApis = [
+            new BinancePriceProvider_1.BinancePriceProvider(assets.map(coinData => {
+                return {
+                    coinId: coinData.binancePair,
+                    chains: coinData.chains
+                };
+            })),
+            new OKXPriceProvider_1.OKXPriceProvider(assets.map(coinData => {
+                return {
+                    coinId: coinData.okxPair,
+                    chains: coinData.chains
+                };
+            })),
+            new CoinGeckoPriceProvider_1.CoinGeckoPriceProvider(assets.map(coinData => {
+                return {
+                    coinId: coinData.coinGeckoCoinId,
+                    chains: coinData.chains
+                };
+            })),
+            new CoinPaprikaPriceProvider_1.CoinPaprikaPriceProvider(assets.map(coinData => {
+                return {
+                    coinId: coinData.coinPaprikaCoinId,
+                    chains: coinData.chains
+                };
+            })),
+            new KrakenPriceProvider_1.KrakenPriceProvider(assets.map(coinData => {
+                return {
+                    coinId: coinData.krakenPair,
+                    chains: coinData.chains
+                };
+            }))
+        ];
+        return new RedundantSwapPrice(maxAllowedFeeDiffPPM, assets, priceApis, cacheTimeout);
+    }
+    constructor(maxAllowedFeeDiffPPM, coinsDecimals, priceApis, cacheTimeout) {
+        super(maxAllowedFeeDiffPPM, cacheTimeout);
+        this.coinsDecimals = {};
+        for (let coinData of coinsDecimals) {
+            for (let chainId in coinData.chains) {
+                const { address, decimals } = coinData.chains[chainId];
+                this.coinsDecimals[chainId] ??= {};
+                this.coinsDecimals[chainId][address.toString()] = decimals;
+            }
+        }
+        this.priceApis = priceApis.map(api => {
+            return {
+                priceApi: api
+            };
+        });
+    }
+    /**
+     * Returns price api that should be operational
+     *
+     * @private
+     */
+    getOperationalPriceApi() {
+        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
+     */
+    getMaybeOperationalPriceApis() {
+        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
+     */
+    async fetchPriceFromMaybeOperationalPriceApis(chainIdentifier, token, abortSignal) {
+        try {
+            return await (0, Utils_1.promiseAny)(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) {
+            const e = _e;
+            if (abortSignal != null)
+                abortSignal.throwIfAborted();
+            throw e.find(err => !(err instanceof RequestError_1.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
+     */
+    fetchPrice(chainIdentifier, token, abortSignal) {
+        return (0, RetryUtils_1.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_1.RequestError, abortSignal);
+    }
+    getDecimals(chainIdentifier, token) {
+        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
+     */
+    async fetchUsdPriceFromMaybeOperationalPriceApis(abortSignal) {
+        try {
+            return await (0, Utils_1.promiseAny)(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) {
+            const e = _e;
+            if (abortSignal != null)
+                abortSignal.throwIfAborted();
+            throw e.find(err => !(err instanceof RequestError_1.RequestError)) || e[0];
+        }
+    }
+    fetchUsdPrice(abortSignal) {
+        return (0, RetryUtils_1.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_1.RequestError, abortSignal);
+    }
+}
+exports.RedundantSwapPrice = RedundantSwapPrice;

package/dist/prices/SingleSwapPrice.d.ts

@@ -0,0 +1,31 @@
+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 declare class SingleSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T> {
+    priceProvider: IPriceProvider<T>;
+    constructor(maxAllowedFeeDiffPPM: bigint, priceProvider: IPriceProvider<T>, cacheTimeout?: number);
+    /**
+     * 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>;
+    /**
+     * 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;
+    protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+}

package/dist/prices/SingleSwapPrice.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleSwapPrice = void 0;
+const ICachedSwapPrice_1 = require("./abstract/ICachedSwapPrice");
+/**
+ * Swap price API using single price source
+ * @category Pricing and LPs
+ */
+class SingleSwapPrice extends ICachedSwapPrice_1.ICachedSwapPrice {
+    constructor(maxAllowedFeeDiffPPM, priceProvider, cacheTimeout) {
+        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)
+     */
+    fetchPrice(chainIdentifier, token, abortSignal) {
+        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
+     */
+    getDecimals(chainIdentifier, token) {
+        return this.priceProvider.getDecimals(chainIdentifier, token.toString());
+    }
+    fetchUsdPrice(abortSignal) {
+        return this.priceProvider.getUsdPrice(abortSignal);
+    }
+}
+exports.SingleSwapPrice = SingleSwapPrice;