@atomiqlabs/sdk 7.0.12 → 8.0.7

package/src/prices/abstract/ISwapPrice.ts

@@ -0,0 +1,328 @@
+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 abstract class ISwapPrice<T extends MultiChain = MultiChain> {
+
+    maxAllowedFeeDifferencePPM: bigint;
+
+    protected constructor(maxAllowedFeeDifferencePPM: bigint) {
+        this.maxAllowedFeeDifferencePPM = maxAllowedFeeDifferencePPM;
+    }
+
+    /**
+     * 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 {
+        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
+     */
+    public recomputePriceInfoSend<C extends ChainIds<T>>(
+        chainIdentifier: C,
+        amountSats: bigint,
+        satsBaseFee: bigint,
+        feePPM: bigint,
+        paidToken: bigint,
+        token: string
+    ): PriceInfoType {
+        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
+     */
+    public async isValidAmountSend<C extends ChainIds<T>>(
+        chainIdentifier: C,
+        amountSats: bigint,
+        satsBaseFee: bigint,
+        feePPM: bigint,
+        paidToken: bigint,
+        token: string,
+        abortSignal?: AbortSignal,
+        preFetchedPrice?: bigint | null
+    ): Promise<PriceInfoType> {
+        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
+     */
+    public recomputePriceInfoReceive<C extends ChainIds<T>>(
+        chainIdentifier: C,
+        amountSats: bigint,
+        satsBaseFee: bigint,
+        feePPM: bigint,
+        receiveToken: bigint,
+        token: string,
+    ): PriceInfoType {
+        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
+     */
+    public async isValidAmountReceive<C extends ChainIds<T>>(
+        chainIdentifier: C,
+        amountSats: bigint,
+        satsBaseFee: bigint,
+        feePPM: bigint,
+        receiveToken: bigint,
+        token: string,
+        abortSignal?: AbortSignal,
+        preFetchedPrice?: bigint | null
+    ): Promise<PriceInfoType> {
+        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
+        };
+    }
+
+    public preFetchPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint> {
+        return this.getPrice(chainIdentifier, token, abortSignal);
+    }
+
+    public preFetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
+        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
+     */
+    public async getFromBtcSwapAmount<C extends ChainIds<T>>(
+        chainIdentifier: C,
+        fromAmount: bigint,
+        toToken: string,
+        abortSignal?: AbortSignal,
+        preFetchedPrice?: bigint | null
+    ): Promise<bigint> {
+        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
+     */
+    public async getToBtcSwapAmount<C extends ChainIds<T>>(
+        chainIdentifier: C,
+        fromAmount: bigint,
+        fromToken: string,
+        abortSignal?: AbortSignal,
+        preFetchedPrice?: bigint
+    ): Promise<bigint> {
+        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
+     */
+    public shouldIgnore<C extends ChainIds<T>>(chainIdentifier: C, tokenAddress: string): boolean {
+        const coin = this.getDecimals(chainIdentifier, tokenAddress.toString());
+        if(coin==null) throw new Error("Token not found");
+        return coin===-1;
+    }
+
+    public async getBtcUsdValue(
+        btcSats: bigint,
+        abortSignal?: AbortSignal,
+        preFetchedPrice?: number
+    ): Promise<number> {
+        return Number(btcSats)*(preFetchedPrice || await this.getUsdPrice(abortSignal));
+    }
+
+    public async getTokenUsdValue<C extends ChainIds<T>>(
+        chainId: C,
+        tokenAmount: bigint,
+        token: string,
+        abortSignal?: AbortSignal,
+        preFetchedPrice?: number
+    ): Promise<number> {
+        const [btcAmount, usdPrice] = await Promise.all([
+            this.getToBtcSwapAmount(chainId, tokenAmount, token, abortSignal),
+            preFetchedPrice==null ? this.preFetchUsdPrice(abortSignal) : Promise.resolve(preFetchedPrice)
+        ]);
+        return Number(btcAmount)*usdPrice;
+    }
+
+    public getUsdValue<C extends ChainIds<T>>(
+        amount: bigint,
+        token: Token<C>,
+        abortSignal?: AbortSignal,
+        preFetchedUsdPrice?: number
+    ): Promise<number> {
+        if(token.chain==="BTC") {
+            return this.getBtcUsdValue(amount, abortSignal, preFetchedUsdPrice);
+        } else {
+            return this.getTokenUsdValue(token.chainId, amount, token.address, abortSignal, preFetchedUsdPrice);
+        }
+    }
+
+}

package/src/prices/providers/BinancePriceProvider.ts

@@ -0,0 +1,41 @@
+import {CtorCoinTypes} from "../abstract/IPriceProvider";
+import {ExchangePriceProvider} from "./abstract/ExchangePriceProvider";
+import {MultiChain} from "../../swapper/Swapper";
+import {httpGet} from "../../http/HttpUtils";
+
+export type BinanceResponse = {
+    symbol: string;
+    price: string;
+};
+
+/**
+ * Price provider using Binance exchange API
+ * @category Pricing and LPs
+ */
+export class BinancePriceProvider<T extends MultiChain> extends ExchangePriceProvider<T> {
+
+    constructor(coinsMap: CtorCoinTypes<T>, url: string = "https://api.binance.com/api/v3", httpRequestTimeout?: number) {
+        super(coinsMap, url, httpRequestTimeout);
+    }
+
+    protected async fetchPair(pair: string, abortSignal?: AbortSignal) {
+        const response = await httpGet<BinanceResponse>(
+            this.url+"/ticker/price?symbol="+pair,
+            this.httpRequestTimeout,
+            abortSignal
+        );
+
+        return parseFloat(response.price);
+    }
+
+    protected async fetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
+        const response = await httpGet<BinanceResponse>(
+            this.url+"/ticker/price?symbol=BTCUSDC",
+            this.httpRequestTimeout,
+            abortSignal
+        );
+
+        return parseFloat(response.price)/100000000;
+    }
+
+}

package/src/prices/providers/CoinGeckoPriceProvider.ts

@@ -0,0 +1,40 @@
+import {CoinType, CtorCoinTypes} from "../abstract/IPriceProvider";
+import {HttpPriceProvider} from "./abstract/HttpPriceProvider";
+import {MultiChain} from "../../swapper/Swapper";
+import {httpGet} from "../../http/HttpUtils";
+
+export type CoinGeckoResponse<Currency extends string> = {
+    [coinId: string]: {[c in Currency]: number}
+};
+
+/**
+ * Price provider using CoinGecko API
+ * @category Pricing and LPs
+ */
+export class CoinGeckoPriceProvider<T extends MultiChain> extends HttpPriceProvider<T> {
+
+    constructor(coinsMap: CtorCoinTypes<T>, url: string = "https://api.coingecko.com/api/v3", httpRequestTimeout?: number) {
+        super(coinsMap, url, httpRequestTimeout);
+    }
+
+    protected async fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint> {
+        let response = await httpGet<CoinGeckoResponse<"sats">>(
+            this.url+"/simple/price?ids="+token.coinId+"&vs_currencies=sats&precision=6",
+            this.httpRequestTimeout,
+            abortSignal
+        );
+
+        return BigInt(response[token.coinId].sats*1000000);
+    }
+
+    protected async fetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
+        let response = await httpGet<CoinGeckoResponse<"usd">>(
+            this.url+"/simple/price?ids=bitcoin&vs_currencies=usd&precision=9",
+            this.httpRequestTimeout,
+            abortSignal
+        );
+
+        return response["bitcoin"].usd/100000000;
+    }
+
+}

package/src/prices/providers/CoinPaprikaPriceProvider.ts

@@ -0,0 +1,44 @@
+import {CoinType, CtorCoinTypes} from "../abstract/IPriceProvider";
+import {HttpPriceProvider} from "./abstract/HttpPriceProvider";
+import {MultiChain} from "../../swapper/Swapper";
+import {httpGet} from "../../http/HttpUtils";
+
+export type CoinPaprikaResponse<Currency extends string> = {
+    quotes: {
+        [curr in Currency]: {
+            price: number
+        }
+    }
+};
+
+/**
+ * Price provider using CoinPaprika API
+ * @category Pricing and LPs
+ */
+export class CoinPaprikaPriceProvider<T extends MultiChain> extends HttpPriceProvider<T> {
+
+    constructor(coinsMap: CtorCoinTypes<T>, url: string = "https://api.coinpaprika.com/v1", httpRequestTimeout?: number) {
+        super(coinsMap, url, httpRequestTimeout);
+    }
+
+    async fetchPrice(token: CoinType, abortSignal?: AbortSignal) {
+        const response = await httpGet<CoinPaprikaResponse<"BTC">>(
+            this.url+"/tickers/"+token.coinId+"?quotes=BTC",
+            this.httpRequestTimeout,
+            abortSignal
+        );
+
+        return BigInt(Math.floor(response.quotes.BTC.price*100000000000000));
+    }
+
+    protected async fetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
+        const response = await httpGet<CoinPaprikaResponse<"USD">>(
+            this.url+"/tickers/btc-bitcoin?quotes=USD",
+            this.httpRequestTimeout,
+            abortSignal
+        );
+
+        return response.quotes.USD.price/100000000;
+    }
+
+}

package/src/prices/providers/CustomPriceProvider.ts

@@ -0,0 +1,29 @@
+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 class CustomPriceProvider<T extends MultiChain> extends IPriceProvider<T> {
+
+    readonly getUsdPriceFn: CustomPriceFunction;
+
+    constructor(coinsMap: CtorCoinTypes<T>, getUsdPriceFn: CustomPriceFunction) {
+        super(coinsMap);
+        this.getUsdPriceFn = getUsdPriceFn;
+    }
+
+    protected async fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint> {
+        const [btcPrice, tokenPrice] = await this.getUsdPriceFn(["BTC",token.coinId], abortSignal);
+        const priceInBtc = tokenPrice / btcPrice;
+        return BigInt(Math.floor(priceInBtc*100_000_000*1_000_000));
+    }
+
+    protected async fetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
+        const [btcPrice] = await this.getUsdPriceFn(["BTC"], abortSignal);
+        return btcPrice / 100_000_000;
+    }
+
+}

package/src/prices/providers/KrakenPriceProvider.ts

@@ -0,0 +1,74 @@
+import {CoinType, CtorCoinTypes} from "../abstract/IPriceProvider";
+import {ExchangePriceProvider} from "./abstract/ExchangePriceProvider";
+import {MultiChain} from "../../swapper/Swapper";
+import {httpGet} from "../../http/HttpUtils";
+
+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 class KrakenPriceProvider<T extends MultiChain> extends ExchangePriceProvider<T> {
+
+    constructor(coinsMap: CtorCoinTypes<T>, url: string = "https://api.kraken.com/0", httpRequestTimeout?: number) {
+        super(coinsMap, url, httpRequestTimeout);
+    }
+
+    protected async fetchPair(pair: string, abortSignal?: AbortSignal) {
+        const response = await httpGet<KrakenResponse>(
+            this.url+"/public/Ticker?pair="+pair,
+            this.httpRequestTimeout,
+            abortSignal
+        );
+
+        return parseFloat(response.result[pair].c[0]);
+    }
+
+    protected async fetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
+        const response = await httpGet<KrakenResponse>(
+            this.url+"/public/Ticker?pair=XBTUSDC",
+            this.httpRequestTimeout,
+            abortSignal
+        );
+
+        return parseFloat(response.result["XBTUSDC"].c[0])/100000000;
+    }
+
+    protected async fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint> {
+        const pairs: string[] = token.coinId.split(";");
+
+        const response = await httpGet<KrakenResponse>(
+            this.url+"/public/Ticker?pair="+pairs.map(val => val.startsWith("!") ? val.substring(1) : val).join(","),
+            this.httpRequestTimeout,
+            abortSignal
+        );
+
+        const prices: number[] = 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));
+    }
+
+}

package/src/prices/providers/OKXPriceProvider.ts

@@ -0,0 +1,53 @@
+import {CtorCoinTypes} from "../abstract/IPriceProvider";
+import {ExchangePriceProvider} from "./abstract/ExchangePriceProvider";
+import {MultiChain} from "../../swapper/Swapper";
+import {httpGet} from "../../http/HttpUtils";
+
+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 class OKXPriceProvider<T extends MultiChain> extends ExchangePriceProvider<T> {
+
+    constructor(coinsMap: CtorCoinTypes<T>, url: string = "https://www.okx.com/api/v5", httpRequestTimeout?: number) {
+        super(coinsMap, url, httpRequestTimeout);
+    }
+
+    async fetchPair(pair: string, abortSignal?: AbortSignal) {
+        const response = await httpGet<OKXResponse>(
+            this.url+"/market/index-tickers?instId="+pair,
+            this.httpRequestTimeout,
+            abortSignal
+        );
+
+        return parseFloat(response.data[0].idxPx);
+    }
+
+    protected async fetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
+        const response = await httpGet<OKXResponse>(
+            this.url+"/market/index-tickers?instId=BTC-USD",
+            this.httpRequestTimeout,
+            abortSignal
+        );
+
+        return parseFloat(response.data[0].idxPx)/100000000;
+    }
+
+}

package/src/prices/providers/abstract/ExchangePriceProvider.ts

@@ -0,0 +1,29 @@
+import {HttpPriceProvider} from "./HttpPriceProvider";
+import {CoinType} from "../../abstract/IPriceProvider";
+import {MultiChain} from "../../../swapper/Swapper";
+
+export 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 async fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint> {
+        const pairs: string[] = token.coinId.split(";");
+        const prices: number[] = 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));
+    }
+
+}

package/src/prices/providers/abstract/HttpPriceProvider.ts

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