@atomiqlabs/sdk 7.0.12 → 8.0.7

package/dist/prices/abstract/ISwapPrice.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISwapPrice = void 0;
+/**
+ * Abstract base class for swap pricing implementations
+ * @category Pricing and LPs
+ */
+class ISwapPrice {
+    constructor(maxAllowedFeeDifferencePPM) {
+        this.maxAllowedFeeDifferencePPM = maxAllowedFeeDifferencePPM;
+    }
+    getDecimalsThrowing(chainIdentifier, token) {
+        const decimals = this.getDecimals(chainIdentifier, token);
+        if (decimals == null)
+            throw new Error(`Cannot get decimal count for token ${chainIdentifier}:${token}!`);
+        return decimals;
+    }
+    /**
+     * Recomputes pricing info without fetching the current price
+     *
+     * @param chainIdentifier
+     * @param amountSats
+     * @param satsBaseFee
+     * @param feePPM
+     * @param paidToken
+     * @param token
+     */
+    recomputePriceInfoSend(chainIdentifier, amountSats, satsBaseFee, feePPM, paidToken, token) {
+        const totalSats = (amountSats * (1000000n + feePPM) / 1000000n)
+            + satsBaseFee;
+        const totalUSats = totalSats * 1000000n;
+        const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, token))) / paidToken;
+        return {
+            isValid: true,
+            differencePPM: 0n,
+            satsBaseFee,
+            feePPM,
+            realPriceUSatPerToken: this.shouldIgnore(chainIdentifier, token) ? undefined : swapPriceUSatPerToken,
+            swapPriceUSatPerToken
+        };
+    }
+    /**
+     * 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
+     */
+    async isValidAmountSend(chainIdentifier, amountSats, satsBaseFee, feePPM, paidToken, token, abortSignal, preFetchedPrice) {
+        const totalSats = (amountSats * (1000000n + feePPM) / 1000000n)
+            + satsBaseFee;
+        const totalUSats = totalSats * 1000000n;
+        const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, token))) / paidToken;
+        if (this.shouldIgnore(chainIdentifier, token))
+            return {
+                isValid: true,
+                differencePPM: 0n,
+                satsBaseFee,
+                feePPM,
+                realPriceUSatPerToken: undefined,
+                swapPriceUSatPerToken
+            };
+        const calculatedAmtInToken = await this.getFromBtcSwapAmount(chainIdentifier, totalSats, token, abortSignal, preFetchedPrice);
+        const realPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, token))) / calculatedAmtInToken;
+        const difference = paidToken - calculatedAmtInToken; //Will be >0 if we need to pay more than we should've
+        const differencePPM = difference * 1000000n / calculatedAmtInToken;
+        return {
+            isValid: differencePPM <= this.maxAllowedFeeDifferencePPM,
+            differencePPM,
+            satsBaseFee,
+            feePPM,
+            realPriceUSatPerToken,
+            swapPriceUSatPerToken
+        };
+    }
+    /**
+     * Recomputes pricing info without fetching the current price
+     *
+     * @param chainIdentifier
+     * @param amountSats
+     * @param satsBaseFee
+     * @param feePPM
+     * @param receiveToken
+     * @param token
+     */
+    recomputePriceInfoReceive(chainIdentifier, amountSats, satsBaseFee, feePPM, receiveToken, token) {
+        const totalSats = (amountSats * (1000000n - feePPM) / 1000000n)
+            - satsBaseFee;
+        const totalUSats = totalSats * 1000000n;
+        const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, token))) / receiveToken;
+        return {
+            isValid: true,
+            differencePPM: 0n,
+            satsBaseFee,
+            feePPM,
+            realPriceUSatPerToken: this.shouldIgnore(chainIdentifier, token) ? undefined : swapPriceUSatPerToken,
+            swapPriceUSatPerToken
+        };
+    }
+    /**
+     * 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
+     */
+    async isValidAmountReceive(chainIdentifier, amountSats, satsBaseFee, feePPM, receiveToken, token, abortSignal, preFetchedPrice) {
+        const totalSats = (amountSats * (1000000n - feePPM) / 1000000n)
+            - satsBaseFee;
+        const totalUSats = totalSats * 1000000n;
+        const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, token))) / receiveToken;
+        if (this.shouldIgnore(chainIdentifier, token))
+            return {
+                isValid: true,
+                differencePPM: 0n,
+                satsBaseFee,
+                feePPM,
+                realPriceUSatPerToken: undefined,
+                swapPriceUSatPerToken
+            };
+        const calculatedAmtInToken = await this.getFromBtcSwapAmount(chainIdentifier, totalSats, token, abortSignal, preFetchedPrice);
+        const realPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, token))) / calculatedAmtInToken;
+        const difference = calculatedAmtInToken - receiveToken; //Will be >0 if we receive less than we should've
+        const differencePPM = difference * 100000n / calculatedAmtInToken;
+        return {
+            isValid: differencePPM <= this.maxAllowedFeeDifferencePPM,
+            differencePPM,
+            satsBaseFee,
+            feePPM,
+            realPriceUSatPerToken,
+            swapPriceUSatPerToken
+        };
+    }
+    preFetchPrice(chainIdentifier, token, abortSignal) {
+        return this.getPrice(chainIdentifier, token, abortSignal);
+    }
+    preFetchUsdPrice(abortSignal) {
+        return this.getUsdPrice(abortSignal);
+    }
+    /**
+     * 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
+     */
+    async getFromBtcSwapAmount(chainIdentifier, fromAmount, toToken, abortSignal, preFetchedPrice) {
+        if (this.getDecimals(chainIdentifier, toToken.toString()) == null)
+            throw new Error("Token not found!");
+        const price = preFetchedPrice || await this.getPrice(chainIdentifier, toToken, abortSignal);
+        return fromAmount
+            * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, toToken.toString())))
+            * (1000000n) //To usat
+            / (price);
+    }
+    /**
+     * 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
+     */
+    async getToBtcSwapAmount(chainIdentifier, fromAmount, fromToken, abortSignal, preFetchedPrice) {
+        if (this.getDecimals(chainIdentifier, fromToken.toString()) == null)
+            throw new Error("Token not found");
+        const price = preFetchedPrice || await this.getPrice(chainIdentifier, fromToken, abortSignal);
+        return fromAmount
+            * price
+            / 1000000n
+            / (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, fromToken.toString())));
+    }
+    /**
+     * 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(chainIdentifier, tokenAddress) {
+        const coin = this.getDecimals(chainIdentifier, tokenAddress.toString());
+        if (coin == null)
+            throw new Error("Token not found");
+        return coin === -1;
+    }
+    async getBtcUsdValue(btcSats, abortSignal, preFetchedPrice) {
+        return Number(btcSats) * (preFetchedPrice || await this.getUsdPrice(abortSignal));
+    }
+    async getTokenUsdValue(chainId, tokenAmount, token, abortSignal, preFetchedPrice) {
+        const [btcAmount, usdPrice] = await Promise.all([
+            this.getToBtcSwapAmount(chainId, tokenAmount, token, abortSignal),
+            preFetchedPrice == null ? this.preFetchUsdPrice(abortSignal) : Promise.resolve(preFetchedPrice)
+        ]);
+        return Number(btcAmount) * usdPrice;
+    }
+    getUsdValue(amount, token, abortSignal, preFetchedUsdPrice) {
+        if (token.chain === "BTC") {
+            return this.getBtcUsdValue(amount, abortSignal, preFetchedUsdPrice);
+        }
+        else {
+            return this.getTokenUsdValue(token.chainId, amount, token.address, abortSignal, preFetchedUsdPrice);
+        }
+    }
+}
+exports.ISwapPrice = ISwapPrice;

package/dist/prices/providers/BinancePriceProvider.d.ts

@@ -0,0 +1,16 @@
+import { CtorCoinTypes } from "../abstract/IPriceProvider";
+import { ExchangePriceProvider } from "./abstract/ExchangePriceProvider";
+import { MultiChain } from "../../swapper/Swapper";
+export type BinanceResponse = {
+    symbol: string;
+    price: string;
+};
+/**
+ * Price provider using Binance exchange API
+ * @category Pricing and LPs
+ */
+export declare class BinancePriceProvider<T extends MultiChain> extends ExchangePriceProvider<T> {
+    constructor(coinsMap: CtorCoinTypes<T>, url?: string, httpRequestTimeout?: number);
+    protected fetchPair(pair: string, abortSignal?: AbortSignal): Promise<number>;
+    protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+}

package/dist/prices/providers/BinancePriceProvider.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinancePriceProvider = void 0;
+const ExchangePriceProvider_1 = require("./abstract/ExchangePriceProvider");
+const HttpUtils_1 = require("../../http/HttpUtils");
+/**
+ * Price provider using Binance exchange API
+ * @category Pricing and LPs
+ */
+class BinancePriceProvider extends ExchangePriceProvider_1.ExchangePriceProvider {
+    constructor(coinsMap, url = "https://api.binance.com/api/v3", httpRequestTimeout) {
+        super(coinsMap, url, httpRequestTimeout);
+    }
+    async fetchPair(pair, abortSignal) {
+        const response = await (0, HttpUtils_1.httpGet)(this.url + "/ticker/price?symbol=" + pair, this.httpRequestTimeout, abortSignal);
+        return parseFloat(response.price);
+    }
+    async fetchUsdPrice(abortSignal) {
+        const response = await (0, HttpUtils_1.httpGet)(this.url + "/ticker/price?symbol=BTCUSDC", this.httpRequestTimeout, abortSignal);
+        return parseFloat(response.price) / 100000000;
+    }
+}
+exports.BinancePriceProvider = BinancePriceProvider;

package/dist/prices/providers/CoinGeckoPriceProvider.d.ts

@@ -0,0 +1,17 @@
+import { CoinType, CtorCoinTypes } from "../abstract/IPriceProvider";
+import { HttpPriceProvider } from "./abstract/HttpPriceProvider";
+import { MultiChain } from "../../swapper/Swapper";
+export type CoinGeckoResponse<Currency extends string> = {
+    [coinId: string]: {
+        [c in Currency]: number;
+    };
+};
+/**
+ * Price provider using CoinGecko API
+ * @category Pricing and LPs
+ */
+export declare class CoinGeckoPriceProvider<T extends MultiChain> extends HttpPriceProvider<T> {
+    constructor(coinsMap: CtorCoinTypes<T>, url?: string, httpRequestTimeout?: number);
+    protected fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint>;
+    protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+}

package/dist/prices/providers/CoinGeckoPriceProvider.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoinGeckoPriceProvider = void 0;
+const HttpPriceProvider_1 = require("./abstract/HttpPriceProvider");
+const HttpUtils_1 = require("../../http/HttpUtils");
+/**
+ * Price provider using CoinGecko API
+ * @category Pricing and LPs
+ */
+class CoinGeckoPriceProvider extends HttpPriceProvider_1.HttpPriceProvider {
+    constructor(coinsMap, url = "https://api.coingecko.com/api/v3", httpRequestTimeout) {
+        super(coinsMap, url, httpRequestTimeout);
+    }
+    async fetchPrice(token, abortSignal) {
+        let response = await (0, HttpUtils_1.httpGet)(this.url + "/simple/price?ids=" + token.coinId + "&vs_currencies=sats&precision=6", this.httpRequestTimeout, abortSignal);
+        return BigInt(response[token.coinId].sats * 1000000);
+    }
+    async fetchUsdPrice(abortSignal) {
+        let response = await (0, HttpUtils_1.httpGet)(this.url + "/simple/price?ids=bitcoin&vs_currencies=usd&precision=9", this.httpRequestTimeout, abortSignal);
+        return response["bitcoin"].usd / 100000000;
+    }
+}
+exports.CoinGeckoPriceProvider = CoinGeckoPriceProvider;

package/dist/prices/providers/CoinPaprikaPriceProvider.d.ts

@@ -0,0 +1,19 @@
+import { CoinType, CtorCoinTypes } from "../abstract/IPriceProvider";
+import { HttpPriceProvider } from "./abstract/HttpPriceProvider";
+import { MultiChain } from "../../swapper/Swapper";
+export type CoinPaprikaResponse<Currency extends string> = {
+    quotes: {
+        [curr in Currency]: {
+            price: number;
+        };
+    };
+};
+/**
+ * Price provider using CoinPaprika API
+ * @category Pricing and LPs
+ */
+export declare class CoinPaprikaPriceProvider<T extends MultiChain> extends HttpPriceProvider<T> {
+    constructor(coinsMap: CtorCoinTypes<T>, url?: string, httpRequestTimeout?: number);
+    fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint>;
+    protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+}

package/dist/prices/providers/CoinPaprikaPriceProvider.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoinPaprikaPriceProvider = void 0;
+const HttpPriceProvider_1 = require("./abstract/HttpPriceProvider");
+const HttpUtils_1 = require("../../http/HttpUtils");
+/**
+ * Price provider using CoinPaprika API
+ * @category Pricing and LPs
+ */
+class CoinPaprikaPriceProvider extends HttpPriceProvider_1.HttpPriceProvider {
+    constructor(coinsMap, url = "https://api.coinpaprika.com/v1", httpRequestTimeout) {
+        super(coinsMap, url, httpRequestTimeout);
+    }
+    async fetchPrice(token, abortSignal) {
+        const response = await (0, HttpUtils_1.httpGet)(this.url + "/tickers/" + token.coinId + "?quotes=BTC", this.httpRequestTimeout, abortSignal);
+        return BigInt(Math.floor(response.quotes.BTC.price * 100000000000000));
+    }
+    async fetchUsdPrice(abortSignal) {
+        const response = await (0, HttpUtils_1.httpGet)(this.url + "/tickers/btc-bitcoin?quotes=USD", this.httpRequestTimeout, abortSignal);
+        return response.quotes.USD.price / 100000000;
+    }
+}
+exports.CoinPaprikaPriceProvider = CoinPaprikaPriceProvider;

package/dist/prices/providers/CustomPriceProvider.d.ts

@@ -0,0 +1,13 @@
+import { CoinType, CtorCoinTypes, IPriceProvider } from "../abstract/IPriceProvider";
+import { MultiChain } from "../../swapper/Swapper";
+import { CustomPriceFunction } from "../../types/CustomPriceFunction";
+/**
+ * Price provider using custom pricing function
+ * @category Pricing and LPs
+ */
+export declare class CustomPriceProvider<T extends MultiChain> extends IPriceProvider<T> {
+    readonly getUsdPriceFn: CustomPriceFunction;
+    constructor(coinsMap: CtorCoinTypes<T>, getUsdPriceFn: CustomPriceFunction);
+    protected fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint>;
+    protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+}

package/dist/prices/providers/CustomPriceProvider.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomPriceProvider = void 0;
+const IPriceProvider_1 = require("../abstract/IPriceProvider");
+/**
+ * Price provider using custom pricing function
+ * @category Pricing and LPs
+ */
+class CustomPriceProvider extends IPriceProvider_1.IPriceProvider {
+    constructor(coinsMap, getUsdPriceFn) {
+        super(coinsMap);
+        this.getUsdPriceFn = getUsdPriceFn;
+    }
+    async fetchPrice(token, abortSignal) {
+        const [btcPrice, tokenPrice] = await this.getUsdPriceFn(["BTC", token.coinId], abortSignal);
+        const priceInBtc = tokenPrice / btcPrice;
+        return BigInt(Math.floor(priceInBtc * 100000000 * 1000000));
+    }
+    async fetchUsdPrice(abortSignal) {
+        const [btcPrice] = await this.getUsdPriceFn(["BTC"], abortSignal);
+        return btcPrice / 100000000;
+    }
+}
+exports.CustomPriceProvider = CustomPriceProvider;

package/dist/prices/providers/KrakenPriceProvider.d.ts

@@ -0,0 +1,29 @@
+import { CoinType, CtorCoinTypes } from "../abstract/IPriceProvider";
+import { ExchangePriceProvider } from "./abstract/ExchangePriceProvider";
+import { MultiChain } from "../../swapper/Swapper";
+export type KrakenResponse = {
+    error: string[];
+    result: {
+        [ticker: string]: {
+            a: [string, string, string];
+            b: [string, string, string];
+            c: [string, string];
+            v: [string, string];
+            p: [string, string];
+            t: [number, number];
+            l: [string, string];
+            h: [string, string];
+            o: string;
+        };
+    };
+};
+/**
+ * Price provider using Kraken exchange API
+ * @category Pricing and LPs
+ */
+export declare class KrakenPriceProvider<T extends MultiChain> extends ExchangePriceProvider<T> {
+    constructor(coinsMap: CtorCoinTypes<T>, url?: string, httpRequestTimeout?: number);
+    protected fetchPair(pair: string, abortSignal?: AbortSignal): Promise<number>;
+    protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+    protected fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint>;
+}

package/dist/prices/providers/KrakenPriceProvider.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KrakenPriceProvider = void 0;
+const ExchangePriceProvider_1 = require("./abstract/ExchangePriceProvider");
+const HttpUtils_1 = require("../../http/HttpUtils");
+/**
+ * Price provider using Kraken exchange API
+ * @category Pricing and LPs
+ */
+class KrakenPriceProvider extends ExchangePriceProvider_1.ExchangePriceProvider {
+    constructor(coinsMap, url = "https://api.kraken.com/0", httpRequestTimeout) {
+        super(coinsMap, url, httpRequestTimeout);
+    }
+    async fetchPair(pair, abortSignal) {
+        const response = await (0, HttpUtils_1.httpGet)(this.url + "/public/Ticker?pair=" + pair, this.httpRequestTimeout, abortSignal);
+        return parseFloat(response.result[pair].c[0]);
+    }
+    async fetchUsdPrice(abortSignal) {
+        const response = await (0, HttpUtils_1.httpGet)(this.url + "/public/Ticker?pair=XBTUSDC", this.httpRequestTimeout, abortSignal);
+        return parseFloat(response.result["XBTUSDC"].c[0]) / 100000000;
+    }
+    async fetchPrice(token, abortSignal) {
+        const pairs = token.coinId.split(";");
+        const response = await (0, HttpUtils_1.httpGet)(this.url + "/public/Ticker?pair=" + pairs.map(val => val.startsWith("!") ? val.substring(1) : val).join(","), this.httpRequestTimeout, abortSignal);
+        const prices = pairs.map(pair => {
+            let invert = pair.startsWith("!");
+            if (invert)
+                pair = pair.substring(1);
+            const value = parseFloat(response.result[pair].c[0]);
+            return invert ? 1 / value : value;
+        });
+        const price = prices.reduce((previousValue, currentValue) => previousValue * currentValue, 1);
+        return BigInt(Math.floor(price * 100000000000000));
+    }
+}
+exports.KrakenPriceProvider = KrakenPriceProvider;

package/dist/prices/providers/OKXPriceProvider.d.ts

@@ -0,0 +1,28 @@
+import { CtorCoinTypes } from "../abstract/IPriceProvider";
+import { ExchangePriceProvider } from "./abstract/ExchangePriceProvider";
+import { MultiChain } from "../../swapper/Swapper";
+export type OKXResponse = {
+    code: string;
+    msg: string;
+    data: [
+        {
+            instId: string;
+            idxPx: string;
+            high24h: string;
+            sodUtc0: string;
+            open24h: string;
+            low24h: string;
+            sodUtc8: string;
+            ts: string;
+        }
+    ];
+};
+/**
+ * Price provider using OKX exchange API
+ * @category Pricing and LPs
+ */
+export declare class OKXPriceProvider<T extends MultiChain> extends ExchangePriceProvider<T> {
+    constructor(coinsMap: CtorCoinTypes<T>, url?: string, httpRequestTimeout?: number);
+    fetchPair(pair: string, abortSignal?: AbortSignal): Promise<number>;
+    protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+}

package/dist/prices/providers/OKXPriceProvider.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OKXPriceProvider = void 0;
+const ExchangePriceProvider_1 = require("./abstract/ExchangePriceProvider");
+const HttpUtils_1 = require("../../http/HttpUtils");
+/**
+ * Price provider using OKX exchange API
+ * @category Pricing and LPs
+ */
+class OKXPriceProvider extends ExchangePriceProvider_1.ExchangePriceProvider {
+    constructor(coinsMap, url = "https://www.okx.com/api/v5", httpRequestTimeout) {
+        super(coinsMap, url, httpRequestTimeout);
+    }
+    async fetchPair(pair, abortSignal) {
+        const response = await (0, HttpUtils_1.httpGet)(this.url + "/market/index-tickers?instId=" + pair, this.httpRequestTimeout, abortSignal);
+        return parseFloat(response.data[0].idxPx);
+    }
+    async fetchUsdPrice(abortSignal) {
+        const response = await (0, HttpUtils_1.httpGet)(this.url + "/market/index-tickers?instId=BTC-USD", this.httpRequestTimeout, abortSignal);
+        return parseFloat(response.data[0].idxPx) / 100000000;
+    }
+}
+exports.OKXPriceProvider = OKXPriceProvider;

package/dist/prices/providers/abstract/ExchangePriceProvider.d.ts

@@ -0,0 +1,14 @@
+import { HttpPriceProvider } from "./HttpPriceProvider";
+import { CoinType } from "../../abstract/IPriceProvider";
+import { MultiChain } from "../../../swapper/Swapper";
+export declare abstract class ExchangePriceProvider<T extends MultiChain> extends HttpPriceProvider<T> {
+    /**
+     * Fetches the price on the specific exchange pair
+     *
+     * @param pair
+     * @param abortSignal
+     * @protected
+     */
+    protected abstract fetchPair(pair: string, abortSignal?: AbortSignal): Promise<number>;
+    protected fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint>;
+}

package/dist/prices/providers/abstract/ExchangePriceProvider.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExchangePriceProvider = void 0;
+const HttpPriceProvider_1 = require("./HttpPriceProvider");
+class ExchangePriceProvider extends HttpPriceProvider_1.HttpPriceProvider {
+    async fetchPrice(token, abortSignal) {
+        const pairs = token.coinId.split(";");
+        const prices = await Promise.all(pairs.map(pair => {
+            let invert = pair.startsWith("!");
+            if (invert)
+                pair = pair.substring(1);
+            return this.fetchPair(pair, abortSignal).then(value => invert ? 1 / value : value);
+        }));
+        const price = prices.reduce((previousValue, currentValue) => previousValue * currentValue, 1);
+        return BigInt(Math.floor(price * 100000000000000));
+    }
+}
+exports.ExchangePriceProvider = ExchangePriceProvider;

package/dist/prices/providers/abstract/HttpPriceProvider.d.ts

@@ -0,0 +1,7 @@
+import { CtorCoinTypes, IPriceProvider } from "../../abstract/IPriceProvider";
+import { MultiChain } from "../../../swapper/Swapper";
+export declare abstract class HttpPriceProvider<T extends MultiChain> extends IPriceProvider<T> {
+    url: string;
+    httpRequestTimeout?: number;
+    protected constructor(coinsMap: CtorCoinTypes<T>, url: string, httpRequestTimeout?: number);
+}

package/dist/prices/providers/abstract/HttpPriceProvider.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpPriceProvider = void 0;
+const IPriceProvider_1 = require("../../abstract/IPriceProvider");
+class HttpPriceProvider extends IPriceProvider_1.IPriceProvider {
+    constructor(coinsMap, url, httpRequestTimeout) {
+        super(coinsMap);
+        this.url = url;
+        this.httpRequestTimeout = httpRequestTimeout;
+    }
+}
+exports.HttpPriceProvider = HttpPriceProvider;

package/dist/storage/IUnifiedStorage.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Query parameters for storage operations
+ * @category Storage
+ */
+export type QueryParams = {
+    key: string;
+    value: any | any[];
+};
+/**
+ * Base type for stored objects
+ * @category Storage
+ */
+export type UnifiedStoredObject = {
+    id: string;
+} & any;
+/**
+ * Defines simple indexes (for queries that use a single key)
+ * @category Storage
+ */
+export type UnifiedStorageIndexes = readonly {
+    key: string;
+    type: "number" | "string" | "boolean";
+    unique: boolean;
+    nullable: boolean;
+}[];
+/**
+ * Defines composite indexes (for queries that use multiple keys)
+ * @category Storage
+ */
+export type UnifiedStorageCompositeIndexes = readonly {
+    keys: readonly string[];
+    unique: boolean;
+}[];
+/**
+ * Interface for unified storage implementations
+ * @category Storage
+ */
+export interface IUnifiedStorage<I extends UnifiedStorageIndexes, C extends UnifiedStorageCompositeIndexes> {
+    /**
+     * Initializes the storage with given indexes and composite indexes
+     * @param indexes
+     * @param compositeIndexes
+     */
+    init(indexes: I, compositeIndexes: C): Promise<void>;
+    /**
+     * Params are specified in the following way:
+     *  - [[condition1, condition2]] - returns all rows where condition1 AND condition2 is met
+     *  - [[condition1], [condition2]] - returns all rows where condition1 OR condition2 is met
+     *  - [[condition1, condition2], [condition3]] - returns all rows where (condition1 AND condition2) OR condition3 is met
+     * @param params
+     */
+    query(params: Array<Array<QueryParams>>): Promise<Array<UnifiedStoredObject>>;
+    /**
+     * Saves an object to storage, updating indexes as needed
+     * @param value - Object to save (must have an id property)
+     */
+    save(value: UnifiedStoredObject): Promise<void>;
+    /**
+     * Saves multiple objects to storage in a batch operation
+     * @param value - Array of objects to save
+     */
+    saveAll(value: UnifiedStoredObject[]): Promise<void>;
+    /**
+     * Removes an object from storage
+     * @param value - Object to remove (must have an id property)
+     */
+    remove(value: UnifiedStoredObject): Promise<void>;
+    /**
+     * Removes multiple objects from storage in a batch operation
+     * @param value - Array of objects to remove
+     */
+    removeAll(value: UnifiedStoredObject[]): Promise<void>;
+}

package/dist/storage/IUnifiedStorage.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });