@atomiqlabs/lp-lib 17.5.1 → 17.5.2

package/dist/prices/BinanceSwapPrice.d.ts

@@ -1,29 +1,29 @@
-import { ISwapPrice, ISwapPriceCoinsMap } from "./ISwapPrice";
-export type BinancePriceData = {
-    [pair: string]: {
-        [chainId: string]: {
-            address: string;
-            decimals: number;
-        };
-    };
-};
-export declare class BinanceSwapPrice extends ISwapPrice<{
-    pair: string;
-    decimals: number;
-}> {
-    url: string;
-    cache: {
-        [pair: string]: {
-            price: number;
-            expiry: number;
-        };
-    };
-    constructor(url: string, coins: ISwapPriceCoinsMap<{
-        pair: string;
-        decimals: number;
-    }>);
-    fetchPrice(pair: string): Promise<number>;
-    getPrice(tokenData: {
-        pair: string;
-    }): Promise<bigint>;
-}
+import { ISwapPrice, ISwapPriceCoinsMap } from "./ISwapPrice";
+export type BinancePriceData = {
+    [pair: string]: {
+        [chainId: string]: {
+            address: string;
+            decimals: number;
+        };
+    };
+};
+export declare class BinanceSwapPrice extends ISwapPrice<{
+    pair: string;
+    decimals: number;
+}> {
+    url: string;
+    cache: {
+        [pair: string]: {
+            price: number;
+            expiry: number;
+        };
+    };
+    constructor(url: string, coins: ISwapPriceCoinsMap<{
+        pair: string;
+        decimals: number;
+    }>);
+    fetchPrice(pair: string): Promise<number>;
+    getPrice(tokenData: {
+        pair: string;
+    }): Promise<bigint>;
+}

package/dist/prices/BinanceSwapPrice.js

@@ -1,79 +1,79 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BinanceSwapPrice = void 0;
-const ISwapPrice_1 = require("./ISwapPrice");
-const CACHE_DURATION = 15000;
-class BinanceSwapPrice extends ISwapPrice_1.ISwapPrice {
-    constructor(url, coins) {
-        super(coins);
-        this.cache = {};
-        this.url = url || "https://api.binance.com/api/v3";
-    }
-    async fetchPrice(pair) {
-        const response = await fetch(this.url + "/ticker/price?symbol=" + pair, {
-            method: "GET"
-        });
-        if (response.status !== 200) {
-            let resp;
-            try {
-                resp = await response.text();
-            }
-            catch (e) {
-                throw new Error(response.statusText);
-            }
-            throw new Error(resp);
-        }
-        let jsonBody = await response.json();
-        return parseFloat(jsonBody.price);
-    }
-    async getPrice(tokenData) {
-        const pair = tokenData.pair;
-        if (pair.startsWith("$fixed-")) {
-            const amt = parseFloat(pair.substring(7));
-            return BigInt(Math.floor(amt * 1000000));
-        }
-        const arr = pair.split(";");
-        const promises = [];
-        const cachedValue = this.cache[pair];
-        if (cachedValue == null || cachedValue.expiry < Date.now()) {
-            let resultPrice = 1;
-            for (let pair of arr) {
-                let invert = false;
-                if (pair.startsWith("!")) {
-                    invert = true;
-                    pair = pair.substring(1);
-                }
-                const cachedValue = this.cache[pair];
-                if (cachedValue == null || cachedValue.expiry < Date.now()) {
-                    promises.push(this.fetchPrice(pair).then(price => {
-                        this.cache[pair] = {
-                            price,
-                            expiry: Date.now() + CACHE_DURATION
-                        };
-                        if (invert) {
-                            resultPrice /= price;
-                        }
-                        else {
-                            resultPrice *= price;
-                        }
-                    }));
-                }
-                else {
-                    if (invert) {
-                        resultPrice /= cachedValue.price;
-                    }
-                    else {
-                        resultPrice *= cachedValue.price;
-                    }
-                }
-            }
-            await Promise.all(promises);
-            this.cache[pair] = {
-                price: resultPrice,
-                expiry: Date.now() + CACHE_DURATION
-            };
-        }
-        return BigInt(Math.floor(this.cache[pair].price * 100000000000000));
-    }
-}
-exports.BinanceSwapPrice = BinanceSwapPrice;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinanceSwapPrice = void 0;
+const ISwapPrice_1 = require("./ISwapPrice");
+const CACHE_DURATION = 15000;
+class BinanceSwapPrice extends ISwapPrice_1.ISwapPrice {
+    constructor(url, coins) {
+        super(coins);
+        this.cache = {};
+        this.url = url || "https://api.binance.com/api/v3";
+    }
+    async fetchPrice(pair) {
+        const response = await fetch(this.url + "/ticker/price?symbol=" + pair, {
+            method: "GET"
+        });
+        if (response.status !== 200) {
+            let resp;
+            try {
+                resp = await response.text();
+            }
+            catch (e) {
+                throw new Error(response.statusText);
+            }
+            throw new Error(resp);
+        }
+        let jsonBody = await response.json();
+        return parseFloat(jsonBody.price);
+    }
+    async getPrice(tokenData) {
+        const pair = tokenData.pair;
+        if (pair.startsWith("$fixed-")) {
+            const amt = parseFloat(pair.substring(7));
+            return BigInt(Math.floor(amt * 1000000));
+        }
+        const arr = pair.split(";");
+        const promises = [];
+        const cachedValue = this.cache[pair];
+        if (cachedValue == null || cachedValue.expiry < Date.now()) {
+            let resultPrice = 1;
+            for (let pair of arr) {
+                let invert = false;
+                if (pair.startsWith("!")) {
+                    invert = true;
+                    pair = pair.substring(1);
+                }
+                const cachedValue = this.cache[pair];
+                if (cachedValue == null || cachedValue.expiry < Date.now()) {
+                    promises.push(this.fetchPrice(pair).then(price => {
+                        this.cache[pair] = {
+                            price,
+                            expiry: Date.now() + CACHE_DURATION
+                        };
+                        if (invert) {
+                            resultPrice /= price;
+                        }
+                        else {
+                            resultPrice *= price;
+                        }
+                    }));
+                }
+                else {
+                    if (invert) {
+                        resultPrice /= cachedValue.price;
+                    }
+                    else {
+                        resultPrice *= cachedValue.price;
+                    }
+                }
+            }
+            await Promise.all(promises);
+            this.cache[pair] = {
+                price: resultPrice,
+                expiry: Date.now() + CACHE_DURATION
+            };
+        }
+        return BigInt(Math.floor(this.cache[pair].price * 100000000000000));
+    }
+}
+exports.BinanceSwapPrice = BinanceSwapPrice;

package/dist/prices/CoinGeckoSwapPrice.d.ts

@@ -1,33 +1,33 @@
-import { ISwapPrice, ISwapPriceCoinsMap } from "./ISwapPrice";
-export type CoinGeckoPriceData = {
-    [coinId: string]: {
-        [chainId: string]: {
-            address: string;
-            decimals: number;
-        };
-    };
-};
-export declare class CoinGeckoSwapPrice extends ISwapPrice<{
-    coinId: string;
-    decimals: number;
-}> {
-    url: string;
-    cache: {
-        [coinId: string]: {
-            price: bigint;
-            expiry: number;
-        };
-    };
-    constructor(url: string, coins: ISwapPriceCoinsMap<{
-        coinId: string;
-        decimals: number;
-    }>);
-    /**
-     * Returns coin price in mSat
-     *
-     * @param coin
-     */
-    getPrice(coin: {
-        coinId: string;
-    }): Promise<bigint>;
-}
+import { ISwapPrice, ISwapPriceCoinsMap } from "./ISwapPrice";
+export type CoinGeckoPriceData = {
+    [coinId: string]: {
+        [chainId: string]: {
+            address: string;
+            decimals: number;
+        };
+    };
+};
+export declare class CoinGeckoSwapPrice extends ISwapPrice<{
+    coinId: string;
+    decimals: number;
+}> {
+    url: string;
+    cache: {
+        [coinId: string]: {
+            price: bigint;
+            expiry: number;
+        };
+    };
+    constructor(url: string, coins: ISwapPriceCoinsMap<{
+        coinId: string;
+        decimals: number;
+    }>);
+    /**
+     * Returns coin price in uSat (sats-per-token * 1_000_000)
+     *
+     * @param coin
+     */
+    getPrice(coin: {
+        coinId: string;
+    }): Promise<bigint>;
+}

package/dist/prices/CoinGeckoSwapPrice.js

@@ -1,51 +1,51 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoinGeckoSwapPrice = void 0;
-const ISwapPrice_1 = require("./ISwapPrice");
-const CACHE_DURATION = 15000;
-class CoinGeckoSwapPrice extends ISwapPrice_1.ISwapPrice {
-    constructor(url, coins) {
-        super(coins);
-        this.cache = {};
-        this.url = url || "https://api.coingecko.com/api/v3";
-    }
-    /**
-     * Returns coin price in mSat
-     *
-     * @param coin
-     */
-    async getPrice(coin) {
-        const coinId = coin.coinId;
-        if (coinId.startsWith("$fixed-")) {
-            const amt = parseFloat(coinId.substring(7));
-            return BigInt(Math.floor(amt * 1000));
-        }
-        const cachedValue = this.cache[coinId];
-        if (cachedValue != null && cachedValue.expiry > Date.now()) {
-            return cachedValue.price;
-        }
-        const response = await fetch(this.url + "/simple/price?ids=" + coinId + "&vs_currencies=sats&precision=3", {
-            method: "GET",
-            headers: { 'Content-Type': 'application/json' }
-        });
-        if (response.status !== 200) {
-            let resp;
-            try {
-                resp = await response.text();
-            }
-            catch (e) {
-                throw new Error(response.statusText);
-            }
-            throw new Error(resp);
-        }
-        let jsonBody = await response.json();
-        const amt = jsonBody[coinId].sats;
-        const result = BigInt(Math.floor(amt * 1000));
-        this.cache[coinId] = {
-            price: result,
-            expiry: Date.now() + CACHE_DURATION
-        };
-        return result;
-    }
-}
-exports.CoinGeckoSwapPrice = CoinGeckoSwapPrice;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoinGeckoSwapPrice = void 0;
+const ISwapPrice_1 = require("./ISwapPrice");
+const CACHE_DURATION = 15000;
+class CoinGeckoSwapPrice extends ISwapPrice_1.ISwapPrice {
+    constructor(url, coins) {
+        super(coins);
+        this.cache = {};
+        this.url = url || "https://api.coingecko.com/api/v3";
+    }
+    /**
+     * Returns coin price in uSat (sats-per-token * 1_000_000)
+     *
+     * @param coin
+     */
+    async getPrice(coin) {
+        const coinId = coin.coinId;
+        if (coinId.startsWith("$fixed-")) {
+            const amt = parseFloat(coinId.substring(7));
+            return BigInt(Math.floor(amt * 1000000));
+        }
+        const cachedValue = this.cache[coinId];
+        if (cachedValue != null && cachedValue.expiry > Date.now()) {
+            return cachedValue.price;
+        }
+        const response = await fetch(this.url + "/simple/price?ids=" + coinId + "&vs_currencies=sats&precision=3", {
+            method: "GET",
+            headers: { 'Content-Type': 'application/json' }
+        });
+        if (response.status !== 200) {
+            let resp;
+            try {
+                resp = await response.text();
+            }
+            catch (e) {
+                throw new Error(response.statusText);
+            }
+            throw new Error(resp);
+        }
+        let jsonBody = await response.json();
+        const amt = jsonBody[coinId].sats;
+        const result = BigInt(Math.floor(amt * 1000000));
+        this.cache[coinId] = {
+            price: result,
+            expiry: Date.now() + CACHE_DURATION
+        };
+        return result;
+    }
+}
+exports.CoinGeckoSwapPrice = CoinGeckoSwapPrice;

package/dist/prices/ISwapPrice.d.ts

@@ -1,43 +1,43 @@
-export type ISwapPriceCoinsMap<T extends {
-    decimals: number;
-}> = {
-    [chainId: string]: {
-        [address: string]: T;
-    };
-};
-export declare abstract class ISwapPrice<T extends {
-    decimals: number;
-} = {
-    decimals: number;
-}> {
-    protected coinsMap: ISwapPriceCoinsMap<T>;
-    protected constructor(coinsMap: ISwapPriceCoinsMap<T>);
-    /**
-     * Returns coin price in mSat
-     *
-     * @param tokenData
-     */
-    protected abstract getPrice(tokenData: T): Promise<bigint>;
-    getTokenData(tokenAddress: string, chainId: string): T;
-    preFetchPrice(token: string, chainId: string): Promise<bigint>;
-    /**
-     * Returns amount of satoshis that are equivalent to {fromAmount} of {fromToken}
-     *
-     * @param fromAmount Amount of the token
-     * @param fromToken Token
-     * @param tokenChainIdentification Chain of the token
-     * @param roundUp Whether result should be rounded up
-     * @param preFetch Price pre-fetch promise returned from preFetchPrice()
-     */
-    getToBtcSwapAmount(fromAmount: bigint, fromToken: string, tokenChainIdentification: string, roundUp?: boolean, preFetch?: Promise<bigint>): Promise<bigint>;
-    /**
-     * Returns amount of {toToken} that are equivalent to {fromAmount} satoshis
-     *
-     * @param fromAmount Amount of satoshis
-     * @param toToken Token
-     * @param tokenChainIdentification Chain of the token
-     * @param roundUp Whether result should be rounded up
-     * @param preFetch Price pre-fetch promise returned from preFetchPrice()
-     */
-    getFromBtcSwapAmount(fromAmount: bigint, toToken: string, tokenChainIdentification: string, roundUp?: boolean, preFetch?: Promise<bigint>): Promise<bigint>;
-}
+export type ISwapPriceCoinsMap<T extends {
+    decimals: number;
+}> = {
+    [chainId: string]: {
+        [address: string]: T;
+    };
+};
+export declare abstract class ISwapPrice<T extends {
+    decimals: number;
+} = {
+    decimals: number;
+}> {
+    protected coinsMap: ISwapPriceCoinsMap<T>;
+    protected constructor(coinsMap: ISwapPriceCoinsMap<T>);
+    /**
+     * Returns coin price in uSat (sats-per-token * 1_000_000)
+     *
+     * @param tokenData
+     */
+    protected abstract getPrice(tokenData: T): Promise<bigint>;
+    getTokenData(tokenAddress: string, chainId: string): T;
+    preFetchPrice(token: string, chainId: string): Promise<bigint>;
+    /**
+     * Returns amount of satoshis that are equivalent to {fromAmount} of {fromToken}
+     *
+     * @param fromAmount Amount of the token
+     * @param fromToken Token
+     * @param tokenChainIdentification Chain of the token
+     * @param roundUp Whether result should be rounded up
+     * @param preFetch Price pre-fetch promise returned from preFetchPrice()
+     */
+    getToBtcSwapAmount(fromAmount: bigint, fromToken: string, tokenChainIdentification: string, roundUp?: boolean, preFetch?: Promise<bigint>): Promise<bigint>;
+    /**
+     * Returns amount of {toToken} that are equivalent to {fromAmount} satoshis
+     *
+     * @param fromAmount Amount of satoshis
+     * @param toToken Token
+     * @param tokenChainIdentification Chain of the token
+     * @param roundUp Whether result should be rounded up
+     * @param preFetch Price pre-fetch promise returned from preFetchPrice()
+     */
+    getFromBtcSwapAmount(fromAmount: bigint, toToken: string, tokenChainIdentification: string, roundUp?: boolean, preFetch?: Promise<bigint>): Promise<bigint>;
+}

package/dist/prices/ISwapPrice.js

@@ -1,55 +1,55 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ISwapPrice = void 0;
-class ISwapPrice {
-    constructor(coinsMap) {
-        this.coinsMap = coinsMap;
-    }
-    getTokenData(tokenAddress, chainId) {
-        const chainTokens = this.coinsMap[chainId];
-        if (chainTokens == null)
-            throw new Error("Chain not found");
-        const tokenAddr = tokenAddress.toString();
-        const coin = chainTokens[tokenAddr];
-        if (coin == null)
-            throw new Error("Token not found");
-        return coin;
-    }
-    preFetchPrice(token, chainId) {
-        const coin = this.getTokenData(token, chainId);
-        return this.getPrice(coin);
-    }
-    /**
-     * Returns amount of satoshis that are equivalent to {fromAmount} of {fromToken}
-     *
-     * @param fromAmount Amount of the token
-     * @param fromToken Token
-     * @param tokenChainIdentification Chain of the token
-     * @param roundUp Whether result should be rounded up
-     * @param preFetch Price pre-fetch promise returned from preFetchPrice()
-     */
-    async getToBtcSwapAmount(fromAmount, fromToken, tokenChainIdentification, roundUp, preFetch) {
-        if (fromAmount === 0n)
-            return 0n;
-        const coin = this.getTokenData(fromToken, tokenChainIdentification);
-        const price = (preFetch == null ? null : await preFetch) || await this.getPrice(coin);
-        return ((fromAmount * price / (10n ** BigInt(coin.decimals))) + (roundUp ? 999999n : 0n)) / 1000000n;
-    }
-    /**
-     * Returns amount of {toToken} that are equivalent to {fromAmount} satoshis
-     *
-     * @param fromAmount Amount of satoshis
-     * @param toToken Token
-     * @param tokenChainIdentification Chain of the token
-     * @param roundUp Whether result should be rounded up
-     * @param preFetch Price pre-fetch promise returned from preFetchPrice()
-     */
-    async getFromBtcSwapAmount(fromAmount, toToken, tokenChainIdentification, roundUp, preFetch) {
-        if (fromAmount === 0n)
-            return 0n;
-        const coin = this.getTokenData(toToken, tokenChainIdentification);
-        const price = (preFetch == null ? null : await preFetch) || await this.getPrice(coin);
-        return ((fromAmount * (10n ** BigInt(coin.decimals)) * 1000000n) + (roundUp ? price - 1n : 0n)) / price;
-    }
-}
-exports.ISwapPrice = ISwapPrice;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISwapPrice = void 0;
+class ISwapPrice {
+    constructor(coinsMap) {
+        this.coinsMap = coinsMap;
+    }
+    getTokenData(tokenAddress, chainId) {
+        const chainTokens = this.coinsMap[chainId];
+        if (chainTokens == null)
+            throw new Error("Chain not found");
+        const tokenAddr = tokenAddress.toString();
+        const coin = chainTokens[tokenAddr];
+        if (coin == null)
+            throw new Error("Token not found");
+        return coin;
+    }
+    preFetchPrice(token, chainId) {
+        const coin = this.getTokenData(token, chainId);
+        return this.getPrice(coin);
+    }
+    /**
+     * Returns amount of satoshis that are equivalent to {fromAmount} of {fromToken}
+     *
+     * @param fromAmount Amount of the token
+     * @param fromToken Token
+     * @param tokenChainIdentification Chain of the token
+     * @param roundUp Whether result should be rounded up
+     * @param preFetch Price pre-fetch promise returned from preFetchPrice()
+     */
+    async getToBtcSwapAmount(fromAmount, fromToken, tokenChainIdentification, roundUp, preFetch) {
+        if (fromAmount === 0n)
+            return 0n;
+        const coin = this.getTokenData(fromToken, tokenChainIdentification);
+        const price = (preFetch == null ? null : await preFetch) || await this.getPrice(coin);
+        return ((fromAmount * price / (10n ** BigInt(coin.decimals))) + (roundUp ? 999999n : 0n)) / 1000000n;
+    }
+    /**
+     * Returns amount of {toToken} that are equivalent to {fromAmount} satoshis
+     *
+     * @param fromAmount Amount of satoshis
+     * @param toToken Token
+     * @param tokenChainIdentification Chain of the token
+     * @param roundUp Whether result should be rounded up
+     * @param preFetch Price pre-fetch promise returned from preFetchPrice()
+     */
+    async getFromBtcSwapAmount(fromAmount, toToken, tokenChainIdentification, roundUp, preFetch) {
+        if (fromAmount === 0n)
+            return 0n;
+        const coin = this.getTokenData(toToken, tokenChainIdentification);
+        const price = (preFetch == null ? null : await preFetch) || await this.getPrice(coin);
+        return ((fromAmount * (10n ** BigInt(coin.decimals)) * 1000000n) + (roundUp ? price - 1n : 0n)) / price;
+    }
+}
+exports.ISwapPrice = ISwapPrice;

package/dist/prices/OKXSwapPrice.d.ts

@@ -1,29 +1,29 @@
-import { ISwapPrice, ISwapPriceCoinsMap } from "./ISwapPrice";
-export type OKXPriceData = {
-    [pair: string]: {
-        [chainId: string]: {
-            address: string;
-            decimals: number;
-        };
-    };
-};
-export declare class OKXSwapPrice extends ISwapPrice<{
-    pair: string;
-    decimals: number;
-}> {
-    url: string;
-    cache: {
-        [pair: string]: {
-            price: number;
-            expiry: number;
-        };
-    };
-    constructor(url: string, coins: ISwapPriceCoinsMap<{
-        pair: string;
-        decimals: number;
-    }>);
-    fetchPrice(pair: string): Promise<number>;
-    getPrice(tokenData: {
-        pair: string;
-    }): Promise<bigint>;
-}
+import { ISwapPrice, ISwapPriceCoinsMap } from "./ISwapPrice";
+export type OKXPriceData = {
+    [pair: string]: {
+        [chainId: string]: {
+            address: string;
+            decimals: number;
+        };
+    };
+};
+export declare class OKXSwapPrice extends ISwapPrice<{
+    pair: string;
+    decimals: number;
+}> {
+    url: string;
+    cache: {
+        [pair: string]: {
+            price: number;
+            expiry: number;
+        };
+    };
+    constructor(url: string, coins: ISwapPriceCoinsMap<{
+        pair: string;
+        decimals: number;
+    }>);
+    fetchPrice(pair: string): Promise<number>;
+    getPrice(tokenData: {
+        pair: string;
+    }): Promise<bigint>;
+}