@atomiqlabs/lp-lib 10.3.11

package/src/plugins/PluginManager.ts

@@ -0,0 +1,310 @@
+import {BitcoinRpc, SwapData} from "@atomiqlabs/base";
+import {
+    IPlugin, isPluginQuote, isQuoteAmountTooHigh, isQuoteAmountTooLow, isQuoteSetFees,
+    isQuoteThrow, isToBtcPluginQuote, PluginQuote,
+    QuoteAmountTooHigh,
+    QuoteAmountTooLow,
+    QuoteSetFees,
+    QuoteThrow, ToBtcPluginQuote
+} from "./IPlugin";
+import {
+    FromBtcLnRequestType,
+    FromBtcRequestType,
+    ISwapPrice, MultichainData, RequestData,
+    SwapHandler,
+    ToBtcLnRequestType,
+    ToBtcRequestType
+} from "..";
+import {SwapHandlerSwap} from "../swaps/SwapHandlerSwap";
+import {AuthenticatedLnd} from "lightning";
+import * as BN from "bn.js";
+import * as fs from "fs";
+import {getLogger} from "../utils/Utils";
+import {FromBtcLnTrustedRequestType} from "../swaps/frombtcln_trusted/FromBtcLnTrusted";
+
+export type FailSwapResponse = {
+    type: "fail",
+    code?: number,
+    msg?: string
+};
+
+export type FeeSwapResponse = {
+    type: "fee",
+    baseFee: BN,
+    feePPM: BN
+};
+
+export type AmountAndFeeSwapResponse = {
+    type: "amountAndFee",
+    baseFee?: BN,
+    feePPM?: BN,
+    amount: BN
+};
+
+export type SwapResponse = FailSwapResponse | FeeSwapResponse | AmountAndFeeSwapResponse;
+
+const logger = getLogger("PluginManager: ");
+const pluginLogger = {
+    debug: (plugin: IPlugin, msg, ...args) => logger.debug(plugin.name+": "+msg, ...args),
+    info: (plugin: IPlugin, msg, ...args) => logger.info(plugin.name+": "+msg, ...args),
+    warn: (plugin: IPlugin, msg, ...args) => logger.warn(plugin.name+": "+msg, ...args),
+    error: (plugin: IPlugin, msg, ...args) => logger.error(plugin.name+": "+msg, ...args)
+};
+
+export class PluginManager {
+
+    static plugins: Map<string, IPlugin> = new Map();
+
+    static registerPlugin(name: string, plugin: IPlugin) {
+        PluginManager.plugins.set(name, plugin);
+    }
+
+    static unregisterPlugin(name: string): boolean {
+        return PluginManager.plugins.delete(name);
+    }
+
+    static async enable<T extends SwapData>(
+        chainsData: MultichainData,
+
+        bitcoinRpc: BitcoinRpc<any>,
+        lnd: AuthenticatedLnd,
+
+        swapPricing: ISwapPrice,
+        tokens: {
+            [ticker: string]: {
+                [chainId: string]: {
+                    address: string,
+                    decimals: number
+                }
+            }
+        },
+
+        directory: string
+    ): Promise<void> {
+        try {
+            fs.mkdirSync(directory);
+        } catch (e) {}
+        for(let [name, plugin] of PluginManager.plugins.entries()) {
+            try {
+                try {
+                    fs.mkdirSync(directory+"/"+name);
+                } catch (e) {}
+                await plugin.onEnable(
+                    chainsData,
+                    bitcoinRpc,
+                    lnd,
+                    swapPricing,
+                    tokens,
+                    directory+"/"+name
+                );
+            } catch (e) {
+                pluginLogger.error(plugin, "enable(): plugin enable 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 async serviceInitialize(handler: SwapHandler<any>) {
+        for(let plugin of PluginManager.plugins.values()) {
+            try {
+                await plugin.onServiceInitialize(handler);
+            } catch (e) {
+                pluginLogger.error(plugin, "serviceInitialize(): plugin error", e);
+            }
+        }
+    }
+
+    static async onHttpServerStarted(httpServer: any): Promise<void> {
+        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 async swapStateChange<T extends SwapData>(swap: SwapHandlerSwap<T>, oldState?: any) {
+        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 async swapCreate<T extends SwapData>(swap: SwapHandlerSwap<T>) {
+        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 async swapRemove<T extends SwapData>(swap: SwapHandlerSwap<T>) {
+        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 async onHandlePostFromBtcQuote(
+        request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>,
+        requestedAmount: {input: boolean, amount: BN},
+        chainIdentifier: string,
+        token: string,
+        constraints: {minInBtc: BN, maxInBtc: BN},
+        fees: {baseFeeInBtc: BN, feePPM: BN},
+        pricePrefetchPromise?: Promise<BN> | null
+    ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | PluginQuote> {
+        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(isQuoteSetFees(result)) return result;
+                        if(isQuoteThrow(result)) return result;
+                        if(isQuoteAmountTooHigh(result)) return result;
+                        if(isQuoteAmountTooLow(result)) return result;
+                        if(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;
+    }
+
+    static async onHandlePreFromBtcQuote(
+        request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>,
+        requestedAmount: {input: boolean, amount: BN},
+        chainIdentifier: string,
+        token: string,
+        constraints: {minInBtc: BN, maxInBtc: BN},
+        fees: {baseFeeInBtc: BN, feePPM: BN}
+    ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh> {
+        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(isQuoteSetFees(result)) return result;
+                        if(isQuoteThrow(result)) return result;
+                        if(isQuoteAmountTooHigh(result)) return result;
+                        if(isQuoteAmountTooLow(result)) return result;
+                    }
+                }
+            } catch (e) {
+                pluginLogger.error(plugin, "onSwapRequestToBtcLn(): plugin error", e);
+            }
+        }
+        return null;
+    }
+
+    static async onHandlePostToBtcQuote<T extends {networkFee: BN}>(
+        request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
+        requestedAmount: {input: boolean, amount: BN},
+        chainIdentifier: string,
+        token: string,
+        constraints: {minInBtc: BN, maxInBtc: BN},
+        fees: {baseFeeInBtc: BN, feePPM: BN, networkFeeGetter: (amount: BN) => Promise<T>},
+        pricePrefetchPromise?: Promise<BN> | null
+    ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | (ToBtcPluginQuote & {networkFeeData: T})> {
+        for(let plugin of PluginManager.plugins.values()) {
+            try {
+                if(plugin.onHandlePostToBtcQuote!=null) {
+                    let networkFeeData: T;
+                    const result = await plugin.onHandlePostToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, {
+                        baseFeeInBtc: fees.baseFeeInBtc,
+                        feePPM: fees.feePPM,
+                        networkFeeGetter: async (amount: BN) => {
+                            networkFeeData = await fees.networkFeeGetter(amount);
+                            return networkFeeData.networkFee;
+                        }
+                    }, pricePrefetchPromise);
+                    if(result!=null) {
+                        if(isQuoteSetFees(result)) return result;
+                        if(isQuoteThrow(result)) return result;
+                        if(isQuoteAmountTooHigh(result)) return result;
+                        if(isQuoteAmountTooLow(result)) return result;
+                        if(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;
+    }
+
+    static async onHandlePreToBtcQuote(
+        request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
+        requestedAmount: {input: boolean, amount: BN},
+        chainIdentifier: string,
+        token: string,
+        constraints: {minInBtc: BN, maxInBtc: BN},
+        fees: {baseFeeInBtc: BN, feePPM: BN}
+    ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh> {
+        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(isQuoteSetFees(result)) return result;
+                        if(isQuoteThrow(result)) return result;
+                        if(isQuoteAmountTooHigh(result)) return result;
+                        if(isQuoteAmountTooLow(result)) return result;
+                    }
+                }
+            } catch (e) {
+                pluginLogger.error(plugin, "onSwapRequestToBtcLn(): plugin error", e);
+            }
+        }
+        return null;
+    }
+
+    static getWhitelistedTxIds(): Set<string> {
+        const whitelist: Set<string> = new Set<string>();
+
+        for(let plugin of PluginManager.plugins.values()) {
+            try {
+                if(plugin.getWhitelistedTxIds!=null) {
+                    const result: string[] = plugin.getWhitelistedTxIds();
+                    if(result!=null) {
+                        result.forEach(e => whitelist.add(e));
+                    }
+                }
+            } catch (e) {
+                pluginLogger.error(plugin, "getWhitelistedTxIds(): plugin error", e);
+            }
+        }
+
+        return whitelist;
+    }
+
+}

package/src/prices/BinanceSwapPrice.ts

@@ -0,0 +1,114 @@
+import * as BN from "bn.js";
+import {ISwapPrice} from "../swaps/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<BN> {
+        const pair = tokenData.pair;
+        if(pair.startsWith("$fixed-")) {
+            const amt: number = parseFloat(pair.substring(7));
+            return new BN(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 new BN(Math.floor(this.cache[pair].price*100000000000000));
+    }
+}

package/src/prices/CoinGeckoSwapPrice.ts

@@ -0,0 +1,88 @@
+import * as BN from "bn.js";
+import {ISwapPrice} from "../swaps/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: BN,
+            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<BN> {
+        const coinId = coin.coinId;
+        if(coinId.startsWith("$fixed-")) {
+            const amt: number = parseFloat(coinId.substring(7));
+            return new BN(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 = new BN(amt*1000);
+
+        this.cache[coinId] = {
+            price: result,
+            expiry: Date.now()+CACHE_DURATION
+        };
+
+        return result;
+    }
+
+}

package/src/storage/IIntermediaryStorage.ts

@@ -0,0 +1,21 @@
+import {StorageObject} from "@atomiqlabs/base";
+import * as BN from "bn.js";
+
+export type StorageQueryParam = {
+    key: string,
+    value?: any,
+    values?: any[]
+}
+
+export interface IIntermediaryStorage<T extends StorageObject> {
+
+    init(): Promise<void>;
+
+    query(params: StorageQueryParam[]): Promise<T[]>;
+
+    getData(hash: string, sequence: BN | null): Promise<T>;
+    saveData(hash: string, sequence: BN | null, object: T): Promise<void>;
+    removeData(hash: string, sequence: BN | null): Promise<void>;
+    loadData(type: new(data: any) => T): Promise<void>;
+
+}

package/src/storagemanager/IntermediaryStorageManager.ts

@@ -0,0 +1,101 @@
+import {StorageObject} from "@atomiqlabs/base";
+import * as fs from "fs/promises";
+import {IIntermediaryStorage, StorageQueryParam} from "../storage/IIntermediaryStorage";
+import * as BN from "bn.js";
+
+export class IntermediaryStorageManager<T extends StorageObject> implements IIntermediaryStorage<T> {
+
+    private readonly directory: string;
+    private type: new(data: any) => T;
+    private data: {
+        [key: string]: T
+    } = {};
+
+    constructor(directory: string) {
+        this.directory = directory;
+    }
+
+    async init(): Promise<void> {
+        try {
+            await fs.mkdir(this.directory)
+        } catch (e) {}
+    }
+
+    query(params: StorageQueryParam[]): Promise<T[]> {
+        return Promise.resolve(Object.keys(this.data).map((val) => this.data[val]).filter((val) => {
+            for(let param of params) {
+                if(param.value!=null) {
+                    if(typeof param.value === "object") {
+                        if(param.value.eq!=null && !param.value.eq(val[param.key])) return false;
+                        if(param.value.equals!=null && !param.value.equals(val[param.key])) return false;
+                    } else {
+                        if(param.value!==val[param.key]) return false;
+                    }
+                } else if(param.values!=null) {
+                    let hasSome = false;
+                    for(let expectedValue of param.values) {
+                        if(typeof expectedValue === "object") {
+                            if(expectedValue.eq!=null && !expectedValue.eq(val[param.key])) hasSome = true;
+                            if(expectedValue.equals!=null && !expectedValue.equals(val[param.key])) hasSome = true;
+                        } else {
+                            if(expectedValue===val[param.key]) hasSome = true;
+                        }
+                    }
+                    if(!hasSome) return false;
+                }
+            }
+            return true;
+        }));
+    }
+
+    getData(paymentHash: string, sequence: BN | null): Promise<T> {
+        return Promise.resolve(this.data[paymentHash+"_"+(sequence || new BN(0)).toString("hex", 8)]);
+    }
+
+    async saveData(hash: string, sequence: BN | null, object: T): Promise<void> {
+
+        const _sequence = (sequence || new BN(0)).toString("hex", 8);
+
+        try {
+            await fs.mkdir(this.directory)
+        } catch (e) {}
+
+        this.data[hash+"_"+_sequence] = object;
+
+        const cpy = object.serialize();
+
+        await fs.writeFile(this.directory+"/"+hash+"_"+_sequence+".json", JSON.stringify(cpy));
+
+    }
+
+    async removeData(hash: string, sequence: BN | null): Promise<void> {
+        const identifier = hash+"_"+(sequence || new BN(0)).toString("hex", 8);
+        try {
+            if(this.data[identifier]!=null) delete this.data[identifier];
+            await fs.rm(this.directory+"/"+identifier+".json");
+        } catch (e) {
+            console.error(e);
+        }
+    }
+
+    async loadData(type: new(data: any) => T): Promise<void> {
+        this.type = type;
+
+        let files: string[];
+        try {
+            files = await fs.readdir(this.directory);
+        } catch (e) {
+            console.error(e);
+            return;
+        }
+
+        for(let file of files) {
+            const indentifier = file.split(".")[0];
+            const result = await fs.readFile(this.directory+"/"+file);
+            const obj = JSON.parse(result.toString());
+            const parsed = new type(obj);
+            this.data[indentifier] = parsed;
+        }
+    }
+
+}

package/src/storagemanager/StorageManager.ts

@@ -0,0 +1,68 @@
+import {StorageObject, IStorageManager} from "@atomiqlabs/base";
+import * as fs from "fs/promises";
+
+export class StorageManager<T extends StorageObject> implements IStorageManager<T> {
+
+    private readonly directory: string;
+    data: {
+        [key: string]: T
+    } = {};
+
+    constructor(directory: string) {
+        this.directory = directory;
+    }
+
+    async init(): Promise<void> {
+        try {
+            await fs.mkdir(this.directory)
+        } catch (e) {}
+    }
+
+    async saveData(hash: string, object: T): Promise<void> {
+
+        try {
+            await fs.mkdir(this.directory)
+        } catch (e) {}
+
+        this.data[hash] = object;
+
+        const cpy = object.serialize();
+
+        await fs.writeFile(this.directory+"/"+hash+".json", JSON.stringify(cpy));
+
+    }
+
+    async removeData(hash: string): Promise<void> {
+        const paymentHash = hash;
+        try {
+            if(this.data[paymentHash]!=null) delete this.data[paymentHash];
+            await fs.rm(this.directory+"/"+paymentHash+".json");
+        } catch (e) {
+            console.error(e);
+        }
+    }
+
+    async loadData(type: new(data: any) => T): Promise<T[]> {
+        let files;
+        try {
+            files = await fs.readdir(this.directory);
+        } catch (e) {
+            console.error(e);
+            return [];
+        }
+
+        const arr = [];
+
+        for(let file of files) {
+            const paymentHash = file.split(".")[0];
+            const result = await fs.readFile(this.directory+"/"+file);
+            const obj = JSON.parse(result.toString());
+            const parsed = new type(obj);
+            arr.push(parsed);
+            this.data[paymentHash] = parsed;
+        }
+
+        return arr;
+    }
+
+}