@atomiqlabs/lp-lib 16.0.11 → 16.1.1

package/src/prices/BinanceSwapPrice.ts

@@ -1,113 +1,101 @@
-import {ISwapPrice} from "./ISwapPrice";
-
-const CACHE_DURATION = 15000;
-
-export type BinancePriceData = {
-    [pair: string]: {
-        [chainId: string]: {
-            address: string,
-            decimals: number
-        }
-    }
-};
-
-export class BinanceSwapPrice extends ISwapPrice<{ pair: string, decimals: number }> {
-
-    url: string;
-    cache: {
-        [pair: string]: {
-            price: number,
-            expiry: number
-        }
-    } = {};
-
-    constructor(url: string, coins: BinancePriceData) {
-        const coinsMap = {};
-        for(let pair in coins) {
-            const chains = coins[pair];
-            for(let chainId in chains) {
-                const tokenData = chains[chainId];
-                if(coinsMap[chainId]==null) coinsMap[chainId] = {};
-                coinsMap[chainId][tokenData.address] = {
-                    pair,
-                    decimals: tokenData.decimals
-                }
-            }
-        }
-        super(coinsMap);
-        this.url = url || "https://api.binance.com/api/v3";
-    }
-
-    async fetchPrice(pair: string) {
-        const response: Response = await fetch(this.url + "/ticker/price?symbol=" + pair, {
-            method: "GET"
-        });
-
-        if (response.status !== 200) {
-            let resp: string;
-            try {
-                resp = await response.text();
-            } catch (e) {
-                throw new Error(response.statusText);
-            }
-            throw new Error(resp);
-        }
-
-        let jsonBody: any = await response.json();
-
-        return parseFloat(jsonBody.price);
-    }
-
-    async getPrice(tokenData: {pair: string}): Promise<bigint> {
-        const pair = tokenData.pair;
-        if(pair.startsWith("$fixed-")) {
-            const amt: number = 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));
-    }
-}
+import {ISwapPrice, ISwapPriceCoinsMap} from "./ISwapPrice";
+
+const CACHE_DURATION = 15000;
+
+export type BinancePriceData = {
+    [pair: string]: {
+        [chainId: string]: {
+            address: string,
+            decimals: number
+        }
+    }
+};
+
+export 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}>) {
+        super(coins);
+        this.url = url || "https://api.binance.com/api/v3";
+    }
+
+    async fetchPrice(pair: string) {
+        const response: Response = await fetch(this.url + "/ticker/price?symbol=" + pair, {
+            method: "GET"
+        });
+
+        if (response.status !== 200) {
+            let resp: string;
+            try {
+                resp = await response.text();
+            } catch (e) {
+                throw new Error(response.statusText);
+            }
+            throw new Error(resp);
+        }
+
+        let jsonBody: any = await response.json();
+
+        return parseFloat(jsonBody.price);
+    }
+
+    async getPrice(tokenData: {pair: string}): Promise<bigint> {
+        const pair = tokenData.pair;
+        if(pair.startsWith("$fixed-")) {
+            const amt: number = 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));
+    }
+}

package/src/prices/CoinGeckoSwapPrice.ts

@@ -1,87 +1,75 @@
-import {ISwapPrice} from "./ISwapPrice";
-
-const CACHE_DURATION = 15000;
-
-export type CoinGeckoPriceData = {
-    [coinId: string]: {
-        [chainId: string]: {
-            address: string,
-            decimals: number
-        }
-    }
-};
-
-export class CoinGeckoSwapPrice extends ISwapPrice<{coinId: string, decimals: number}> {
-
-    url: string;
-    cache: {
-        [coinId: string]: {
-            price: bigint,
-            expiry: number
-        }
-    } = {};
-
-    constructor(url: string, coins: CoinGeckoPriceData) {
-        const coinsMap = {};
-        for(let coinId in coins) {
-            const chains = coins[coinId];
-            for(let chainId in chains) {
-                const tokenData = chains[chainId];
-                if(coinsMap[chainId]==null) coinsMap[chainId] = {};
-                coinsMap[chainId][tokenData.address] = {
-                    coinId,
-                    decimals: tokenData.decimals
-                };
-            }
-        }
-        super(coinsMap);
-        this.url = url || "https://api.coingecko.com/api/v3";
-    }
-
-    /**
-     * Returns coin price in mSat
-     *
-     * @param coin
-     */
-    async getPrice(coin: {coinId: string}): Promise<bigint> {
-        const coinId = coin.coinId;
-        if(coinId.startsWith("$fixed-")) {
-            const amt: number = 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: 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: string;
-            try {
-                resp = await response.text();
-            } catch (e) {
-                throw new Error(response.statusText);
-            }
-            throw new Error(resp);
-        }
-
-        let jsonBody: any = await response.json();
-
-        const amt: number = jsonBody[coinId].sats;
-
-        const result = BigInt(Math.floor(amt*1000));
-
-        this.cache[coinId] = {
-            price: result,
-            expiry: Date.now()+CACHE_DURATION
-        };
-
-        return result;
-    }
-
-}
+import {ISwapPrice, ISwapPriceCoinsMap} from "./ISwapPrice";
+
+const CACHE_DURATION = 15000;
+
+export type CoinGeckoPriceData = {
+    [coinId: string]: {
+        [chainId: string]: {
+            address: string,
+            decimals: number
+        }
+    }
+};
+
+export 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}>) {
+        super(coins);
+        this.url = url || "https://api.coingecko.com/api/v3";
+    }
+
+    /**
+     * Returns coin price in mSat
+     *
+     * @param coin
+     */
+    async getPrice(coin: {coinId: string}): Promise<bigint> {
+        const coinId = coin.coinId;
+        if(coinId.startsWith("$fixed-")) {
+            const amt: number = 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: 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: string;
+            try {
+                resp = await response.text();
+            } catch (e) {
+                throw new Error(response.statusText);
+            }
+            throw new Error(resp);
+        }
+
+        let jsonBody: any = await response.json();
+
+        const amt: number = jsonBody[coinId].sats;
+
+        const result = BigInt(Math.floor(amt*1000));
+
+        this.cache[coinId] = {
+            price: result,
+            expiry: Date.now()+CACHE_DURATION
+        };
+
+        return result;
+    }
+
+}

package/src/prices/ISwapPrice.ts

@@ -1,88 +1,88 @@
-export type ISwapPriceCoinsMap<T extends {decimals: number}> = {
-    [chainId: string]: {
-        [address: string]: T
-    }
-};
-
-export abstract class ISwapPrice<T extends {decimals: number} = {decimals: number}> {
-
-    protected coinsMap: ISwapPriceCoinsMap<T>;
-
-    protected constructor(coinsMap: ISwapPriceCoinsMap<T>) {
-        this.coinsMap = coinsMap;
-    }
-
-    /**
-     * Returns coin price in mSat
-     *
-     * @param tokenData
-     */
-    protected abstract getPrice(tokenData: T): Promise<bigint>;
-
-    getTokenData(tokenAddress: string, chainId: string): T {
-        const chainTokens = this.coinsMap[chainId];
-        if(chainTokens==null) throw new Error("Chain not found");
-
-        const tokenAddr: string = tokenAddress.toString();
-        const coin: T = chainTokens[tokenAddr];
-        if(coin==null) throw new Error("Token not found");
-
-        return coin;
-    }
-
-    preFetchPrice(token: string, chainId: string): Promise<bigint> {
-        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:bigint,
-        fromToken: string,
-        tokenChainIdentification: string,
-        roundUp?: boolean,
-        preFetch?: Promise<bigint>
-    ): Promise<bigint> {
-        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: bigint,
-        toToken: string,
-        tokenChainIdentification: string,
-        roundUp?: boolean,
-        preFetch?: Promise<bigint>
-    ): Promise<bigint> {
-        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;
-    }
-
-}
+export type ISwapPriceCoinsMap<T extends {decimals: number}> = {
+    [chainId: string]: {
+        [address: string]: T
+    }
+};
+
+export abstract class ISwapPrice<T extends {decimals: number} = {decimals: number}> {
+
+    protected coinsMap: ISwapPriceCoinsMap<T>;
+
+    protected constructor(coinsMap: ISwapPriceCoinsMap<T>) {
+        this.coinsMap = coinsMap;
+    }
+
+    /**
+     * Returns coin price in mSat
+     *
+     * @param tokenData
+     */
+    protected abstract getPrice(tokenData: T): Promise<bigint>;
+
+    getTokenData(tokenAddress: string, chainId: string): T {
+        const chainTokens = this.coinsMap[chainId];
+        if(chainTokens==null) throw new Error("Chain not found");
+
+        const tokenAddr: string = tokenAddress.toString();
+        const coin: T = chainTokens[tokenAddr];
+        if(coin==null) throw new Error("Token not found");
+
+        return coin;
+    }
+
+    preFetchPrice(token: string, chainId: string): Promise<bigint> {
+        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:bigint,
+        fromToken: string,
+        tokenChainIdentification: string,
+        roundUp?: boolean,
+        preFetch?: Promise<bigint>
+    ): Promise<bigint> {
+        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: bigint,
+        toToken: string,
+        tokenChainIdentification: string,
+        roundUp?: boolean,
+        preFetch?: Promise<bigint>
+    ): Promise<bigint> {
+        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;
+    }
+
+}