@atomiqlabs/lp-lib 11.0.4 → 12.0.0-beta.0

package/dist/plugins/PluginManager.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginManager = void 0;
 const IPlugin_1 = require("./IPlugin");
@@ -27,219 +18,200 @@ class PluginManager {
     static unregisterPlugin(name) {
         return PluginManager.plugins.delete(name);
     }
-    static enable(chainsData, bitcoinRpc, bitcoinWallet, lightningWallet, swapPricing, tokens, directory) {
-        return __awaiter(this, void 0, void 0, function* () {
+    static async enable(chainsData, bitcoinRpc, bitcoinWallet, lightningWallet, swapPricing, tokens, directory) {
+        try {
+            fs.mkdirSync(directory);
+        }
+        catch (e) { }
+        for (let [name, plugin] of PluginManager.plugins.entries()) {
             try {
-                fs.mkdirSync(directory);
-            }
-            catch (e) { }
-            for (let [name, plugin] of PluginManager.plugins.entries()) {
                 try {
-                    try {
-                        fs.mkdirSync(directory + "/" + name);
-                    }
-                    catch (e) { }
-                    yield plugin.onEnable(chainsData, bitcoinRpc, bitcoinWallet, lightningWallet, swapPricing, tokens, directory + "/" + name);
-                }
-                catch (e) {
-                    pluginLogger.error(plugin, "enable(): plugin enable error", e);
+                    fs.mkdirSync(directory + "/" + name);
                 }
+                catch (e) { }
+                await plugin.onEnable(chainsData, bitcoinRpc, bitcoinWallet, lightningWallet, swapPricing, tokens, directory + "/" + name);
+            }
+            catch (e) {
+                pluginLogger.error(plugin, "enable(): plugin enable error", e);
             }
-        });
+        }
     }
-    static disable() {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let plugin of PluginManager.plugins.values()) {
-                try {
-                    yield plugin.onDisable();
-                }
-                catch (e) {
-                    pluginLogger.error(plugin, "disable(): plugin disable error", e);
-                }
+    static async disable() {
+        for (let plugin of PluginManager.plugins.values()) {
+            try {
+                await plugin.onDisable();
+            }
+            catch (e) {
+                pluginLogger.error(plugin, "disable(): plugin disable error", e);
             }
-        });
+        }
     }
-    static serviceInitialize(handler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let plugin of PluginManager.plugins.values()) {
-                try {
-                    yield plugin.onServiceInitialize(handler);
-                }
-                catch (e) {
-                    pluginLogger.error(plugin, "serviceInitialize(): plugin error", e);
-                }
+    static async serviceInitialize(handler) {
+        for (let plugin of PluginManager.plugins.values()) {
+            try {
+                await plugin.onServiceInitialize(handler);
+            }
+            catch (e) {
+                pluginLogger.error(plugin, "serviceInitialize(): plugin error", e);
             }
-        });
+        }
     }
-    static onHttpServerStarted(httpServer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let plugin of PluginManager.plugins.values()) {
-                try {
-                    if (plugin.onHttpServerStarted != null)
-                        yield plugin.onHttpServerStarted(httpServer);
-                }
-                catch (e) {
-                    pluginLogger.error(plugin, "onHttpServerStarted(): plugin error", e);
-                }
+    static async onHttpServerStarted(httpServer) {
+        for (let plugin of PluginManager.plugins.values()) {
+            try {
+                if (plugin.onHttpServerStarted != null)
+                    await plugin.onHttpServerStarted(httpServer);
             }
-        });
+            catch (e) {
+                pluginLogger.error(plugin, "onHttpServerStarted(): plugin error", e);
+            }
+        }
     }
-    static swapStateChange(swap, oldState) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let plugin of PluginManager.plugins.values()) {
-                try {
-                    if (plugin.onSwapStateChange != null)
-                        yield plugin.onSwapStateChange(swap);
-                }
-                catch (e) {
-                    pluginLogger.error(plugin, "swapStateChange(): plugin error", e);
-                }
+    static async swapStateChange(swap, oldState) {
+        for (let plugin of PluginManager.plugins.values()) {
+            try {
+                if (plugin.onSwapStateChange != null)
+                    await plugin.onSwapStateChange(swap);
+            }
+            catch (e) {
+                pluginLogger.error(plugin, "swapStateChange(): plugin error", e);
             }
-        });
+        }
     }
-    static swapCreate(swap) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let plugin of PluginManager.plugins.values()) {
-                try {
-                    if (plugin.onSwapCreate != null)
-                        yield plugin.onSwapCreate(swap);
-                }
-                catch (e) {
-                    pluginLogger.error(plugin, "swapCreate(): plugin error", e);
-                }
+    static async swapCreate(swap) {
+        for (let plugin of PluginManager.plugins.values()) {
+            try {
+                if (plugin.onSwapCreate != null)
+                    await plugin.onSwapCreate(swap);
             }
-        });
+            catch (e) {
+                pluginLogger.error(plugin, "swapCreate(): plugin error", e);
+            }
+        }
     }
-    static swapRemove(swap) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let plugin of PluginManager.plugins.values()) {
-                try {
-                    if (plugin.onSwapRemove != null)
-                        yield plugin.onSwapRemove(swap);
-                }
-                catch (e) {
-                    pluginLogger.error(plugin, "swapRemove(): plugin error", e);
-                }
+    static async swapRemove(swap) {
+        for (let plugin of PluginManager.plugins.values()) {
+            try {
+                if (plugin.onSwapRemove != null)
+                    await plugin.onSwapRemove(swap);
+            }
+            catch (e) {
+                pluginLogger.error(plugin, "swapRemove(): plugin error", e);
             }
-        });
+        }
     }
-    static onHandlePostFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees, pricePrefetchPromise) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let plugin of PluginManager.plugins.values()) {
-                try {
-                    if (plugin.onHandlePostFromBtcQuote != null) {
-                        const result = yield plugin.onHandlePostFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees, pricePrefetchPromise);
-                        if (result != null) {
-                            if ((0, IPlugin_1.isQuoteSetFees)(result))
-                                return result;
-                            if ((0, IPlugin_1.isQuoteThrow)(result))
-                                return result;
-                            if ((0, IPlugin_1.isQuoteAmountTooHigh)(result))
-                                return result;
-                            if ((0, IPlugin_1.isQuoteAmountTooLow)(result))
-                                return result;
-                            if ((0, IPlugin_1.isPluginQuote)(result)) {
-                                if (result.amount.input === requestedAmount.input)
-                                    throw new Error("Invalid quoting response returned, when input is set, output must be returned, and vice-versa!");
-                                return result;
-                            }
+    static async onHandlePostFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees, pricePrefetchPromise) {
+        for (let plugin of PluginManager.plugins.values()) {
+            try {
+                if (plugin.onHandlePostFromBtcQuote != null) {
+                    const result = await plugin.onHandlePostFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees, pricePrefetchPromise);
+                    if (result != null) {
+                        if ((0, IPlugin_1.isQuoteSetFees)(result))
+                            return result;
+                        if ((0, IPlugin_1.isQuoteThrow)(result))
+                            return result;
+                        if ((0, IPlugin_1.isQuoteAmountTooHigh)(result))
+                            return result;
+                        if ((0, IPlugin_1.isQuoteAmountTooLow)(result))
+                            return result;
+                        if ((0, IPlugin_1.isPluginQuote)(result)) {
+                            if (result.amount.input === requestedAmount.input)
+                                throw new Error("Invalid quoting response returned, when input is set, output must be returned, and vice-versa!");
+                            return result;
                         }
                     }
                 }
-                catch (e) {
-                    pluginLogger.error(plugin, "onSwapRequestToBtcLn(): plugin error", e);
-                }
             }
-            return null;
-        });
+            catch (e) {
+                pluginLogger.error(plugin, "onSwapRequestToBtcLn(): plugin error", e);
+            }
+        }
+        return null;
     }
-    static onHandlePreFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let plugin of PluginManager.plugins.values()) {
-                try {
-                    if (plugin.onHandlePreFromBtcQuote != null) {
-                        const result = yield plugin.onHandlePreFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees);
-                        if (result != null) {
-                            if ((0, IPlugin_1.isQuoteSetFees)(result))
-                                return result;
-                            if ((0, IPlugin_1.isQuoteThrow)(result))
-                                return result;
-                            if ((0, IPlugin_1.isQuoteAmountTooHigh)(result))
-                                return result;
-                            if ((0, IPlugin_1.isQuoteAmountTooLow)(result))
-                                return result;
-                        }
+    static async onHandlePreFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees) {
+        for (let plugin of PluginManager.plugins.values()) {
+            try {
+                if (plugin.onHandlePreFromBtcQuote != null) {
+                    const result = await plugin.onHandlePreFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees);
+                    if (result != null) {
+                        if ((0, IPlugin_1.isQuoteSetFees)(result))
+                            return result;
+                        if ((0, IPlugin_1.isQuoteThrow)(result))
+                            return result;
+                        if ((0, IPlugin_1.isQuoteAmountTooHigh)(result))
+                            return result;
+                        if ((0, IPlugin_1.isQuoteAmountTooLow)(result))
+                            return result;
                     }
                 }
-                catch (e) {
-                    pluginLogger.error(plugin, "onSwapRequestToBtcLn(): plugin error", e);
-                }
             }
-            return null;
-        });
+            catch (e) {
+                pluginLogger.error(plugin, "onSwapRequestToBtcLn(): plugin error", e);
+            }
+        }
+        return null;
     }
-    static onHandlePostToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees, pricePrefetchPromise) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let plugin of PluginManager.plugins.values()) {
-                try {
-                    if (plugin.onHandlePostToBtcQuote != null) {
-                        let networkFeeData;
-                        const result = yield plugin.onHandlePostToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, {
-                            baseFeeInBtc: fees.baseFeeInBtc,
-                            feePPM: fees.feePPM,
-                            networkFeeGetter: (amount) => __awaiter(this, void 0, void 0, function* () {
-                                networkFeeData = yield fees.networkFeeGetter(amount);
-                                return networkFeeData.networkFee;
-                            })
-                        }, pricePrefetchPromise);
-                        if (result != null) {
-                            if ((0, IPlugin_1.isQuoteSetFees)(result))
-                                return result;
-                            if ((0, IPlugin_1.isQuoteThrow)(result))
-                                return result;
-                            if ((0, IPlugin_1.isQuoteAmountTooHigh)(result))
-                                return result;
-                            if ((0, IPlugin_1.isQuoteAmountTooLow)(result))
-                                return result;
-                            if ((0, IPlugin_1.isToBtcPluginQuote)(result)) {
-                                if (result.amount.input === requestedAmount.input)
-                                    throw new Error("Invalid quoting response returned, when input is set, output must be returned, and vice-versa!");
-                                return Object.assign(Object.assign({}, result), { networkFeeData: networkFeeData });
-                            }
+    static async onHandlePostToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees, pricePrefetchPromise) {
+        for (let plugin of PluginManager.plugins.values()) {
+            try {
+                if (plugin.onHandlePostToBtcQuote != null) {
+                    let networkFeeData;
+                    const result = await plugin.onHandlePostToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, {
+                        baseFeeInBtc: fees.baseFeeInBtc,
+                        feePPM: fees.feePPM,
+                        networkFeeGetter: async (amount) => {
+                            networkFeeData = await fees.networkFeeGetter(amount);
+                            return networkFeeData.networkFee;
+                        }
+                    }, pricePrefetchPromise);
+                    if (result != null) {
+                        if ((0, IPlugin_1.isQuoteSetFees)(result))
+                            return result;
+                        if ((0, IPlugin_1.isQuoteThrow)(result))
+                            return result;
+                        if ((0, IPlugin_1.isQuoteAmountTooHigh)(result))
+                            return result;
+                        if ((0, IPlugin_1.isQuoteAmountTooLow)(result))
+                            return result;
+                        if ((0, IPlugin_1.isToBtcPluginQuote)(result)) {
+                            if (result.amount.input === requestedAmount.input)
+                                throw new Error("Invalid quoting response returned, when input is set, output must be returned, and vice-versa!");
+                            return {
+                                ...result,
+                                networkFeeData: networkFeeData
+                            };
                         }
                     }
                 }
-                catch (e) {
-                    pluginLogger.error(plugin, "onSwapRequestToBtcLn(): plugin error", e);
-                }
             }
-            return null;
-        });
+            catch (e) {
+                pluginLogger.error(plugin, "onSwapRequestToBtcLn(): plugin error", e);
+            }
+        }
+        return null;
     }
-    static onHandlePreToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let plugin of PluginManager.plugins.values()) {
-                try {
-                    if (plugin.onHandlePreToBtcQuote != null) {
-                        const result = yield plugin.onHandlePreToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees);
-                        if (result != null) {
-                            if ((0, IPlugin_1.isQuoteSetFees)(result))
-                                return result;
-                            if ((0, IPlugin_1.isQuoteThrow)(result))
-                                return result;
-                            if ((0, IPlugin_1.isQuoteAmountTooHigh)(result))
-                                return result;
-                            if ((0, IPlugin_1.isQuoteAmountTooLow)(result))
-                                return result;
-                        }
+    static async onHandlePreToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees) {
+        for (let plugin of PluginManager.plugins.values()) {
+            try {
+                if (plugin.onHandlePreToBtcQuote != null) {
+                    const result = await plugin.onHandlePreToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees);
+                    if (result != null) {
+                        if ((0, IPlugin_1.isQuoteSetFees)(result))
+                            return result;
+                        if ((0, IPlugin_1.isQuoteThrow)(result))
+                            return result;
+                        if ((0, IPlugin_1.isQuoteAmountTooHigh)(result))
+                            return result;
+                        if ((0, IPlugin_1.isQuoteAmountTooLow)(result))
+                            return result;
                     }
                 }
-                catch (e) {
-                    pluginLogger.error(plugin, "onSwapRequestToBtcLn(): plugin error", e);
-                }
             }
-            return null;
-        });
+            catch (e) {
+                pluginLogger.error(plugin, "onSwapRequestToBtcLn(): plugin error", e);
+            }
+        }
+        return null;
     }
     static getWhitelistedTxIds() {
         const whitelist = new Set();

package/dist/prices/BinanceSwapPrice.d.ts

@@ -1,4 +1,3 @@
-import * as BN from "bn.js";
 import { ISwapPrice } from "../swaps/ISwapPrice";
 export type BinancePriceData = {
     [pair: string]: {
@@ -23,5 +22,5 @@ export declare class BinanceSwapPrice extends ISwapPrice<{
     fetchPrice(pair: string): Promise<number>;
     getPrice(tokenData: {
         pair: string;
-    }): Promise<BN>;
+    }): Promise<bigint>;
 }

package/dist/prices/BinanceSwapPrice.js

@@ -1,16 +1,6 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinanceSwapPrice = void 0;
-const BN = require("bn.js");
 const ISwapPrice_1 = require("../swaps/ISwapPrice");
 const CACHE_DURATION = 15000;
 class BinanceSwapPrice extends ISwapPrice_1.ISwapPrice {
@@ -32,75 +22,71 @@ class BinanceSwapPrice extends ISwapPrice_1.ISwapPrice {
         this.cache = {};
         this.url = url || "https://api.binance.com/api/v3";
     }
-    fetchPrice(pair) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield fetch(this.url + "/ticker/price?symbol=" + pair, {
-                method: "GET"
-            });
-            if (response.status !== 200) {
-                let resp;
-                try {
-                    resp = yield response.text();
-                }
-                catch (e) {
-                    throw new Error(response.statusText);
-                }
-                throw new Error(resp);
-            }
-            let jsonBody = yield response.json();
-            return parseFloat(jsonBody.price);
+    async fetchPrice(pair) {
+        const response = await fetch(this.url + "/ticker/price?symbol=" + pair, {
+            method: "GET"
         });
-    }
-    getPrice(tokenData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pair = tokenData.pair;
-            if (pair.startsWith("$fixed-")) {
-                const amt = parseFloat(pair.substring(7));
-                return new BN(Math.floor(amt * 1000000));
+        if (response.status !== 200) {
+            let resp;
+            try {
+                resp = await response.text();
             }
-            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 {
+            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 /= cachedValue.price;
+                            resultPrice /= price;
                         }
                         else {
-                            resultPrice *= cachedValue.price;
+                            resultPrice *= price;
                         }
+                    }));
+                }
+                else {
+                    if (invert) {
+                        resultPrice /= cachedValue.price;
+                    }
+                    else {
+                        resultPrice *= cachedValue.price;
                     }
                 }
-                yield Promise.all(promises);
-                this.cache[pair] = {
-                    price: resultPrice,
-                    expiry: Date.now() + CACHE_DURATION
-                };
             }
-            return new BN(Math.floor(this.cache[pair].price * 100000000000000));
-        });
+            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,4 +1,3 @@
-import * as BN from "bn.js";
 import { ISwapPrice } from "../swaps/ISwapPrice";
 export type CoinGeckoPriceData = {
     [coinId: string]: {
@@ -15,7 +14,7 @@ export declare class CoinGeckoSwapPrice extends ISwapPrice<{
     url: string;
     cache: {
         [coinId: string]: {
-            price: BN;
+            price: bigint;
             expiry: number;
         };
     };
@@ -27,5 +26,5 @@ export declare class CoinGeckoSwapPrice extends ISwapPrice<{
      */
     getPrice(coin: {
         coinId: string;
-    }): Promise<BN>;
+    }): Promise<bigint>;
 }