@atomiqlabs/lp-lib 10.3.11

package/src/fees/OneDollarFeeEstimator.ts

@@ -0,0 +1,95 @@
+import {IBtcFeeEstimator} from "./IBtcFeeEstimator";
+import {getLogger} from "../utils/Utils";
+const dynamicImport = new Function('specifier', 'return import(specifier)');
+const importPromise = dynamicImport('one-dollar-fee-estimator-failover');
+
+const logger = getLogger("OneDollarFeeEstimator: ")
+
+export class OneDollarFeeEstimator implements IBtcFeeEstimator {
+
+    estimator: any;
+
+    receivedFee: [number, number, number, number];
+    iterations: number = 0;
+
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+
+    addFee: number;
+    feeMultiplier: number;
+
+    startFeeEstimator() {
+        logger.info("startFeeEstimator(): starting fee estimator worker");
+
+        importPromise.then(({FeeEstimator}) => {
+            this.estimator = new FeeEstimator({
+                mode: 'bundles', // 'txs' | 'bundles' - optional, default 'txs'
+                refresh: 30, // optional, default 30 - interval in seconds, setting too low can cause unexpected errors
+                rpcOptions: {
+                    host: this.host,
+                    port: this.port,
+                    username: this.username,
+                    password: this.password
+                }
+            });
+
+            this.estimator.on('error', (err) => {
+                logger.error("on(error): fee estimator error", err);
+                if(err.message.startsWith("FeeEstimator worker stopped")) {
+                    logger.info("on(error): restarting fee estimator worker");
+                    this.receivedFee = null;
+                    this.iterations = 0;
+                    this.startFeeEstimator();
+                }
+            });
+
+            // receive live fee rate updates from the FeeEstimator
+            this.estimator.on('fees', (fees) => {
+                this.receivedFee = fees;
+                this.iterations++;
+            });
+        });
+    }
+
+    constructor(
+        host: string,
+        port: number,
+        username: string,
+        password: string,
+        addFee?: number,
+        feeMultiplier?: number
+    ) {
+        this.host = host;
+        this.port = port;
+        this.username = username;
+        this.password = password;
+        this.addFee = addFee;
+        this.feeMultiplier = feeMultiplier;
+        this.startFeeEstimator();
+
+        process.on('exit', () => {
+            logger.info("process(exit): process exiting, stopping estimator");
+            if(this.estimator!=null) this.estimator.stop();
+        });
+
+        process.on('SIGINT', () => {
+            logger.info("process(SIGINT): process exiting, stopping estimator");
+            if(this.estimator!=null) this.estimator.stop();
+            process.exit();
+        });
+    }
+
+    getFee(): number {
+        let fee = this.receivedFee[3];
+        if(this.feeMultiplier!=null) fee *= this.feeMultiplier;
+        if(this.addFee!=null) fee += this.addFee;
+        return fee;
+    }
+
+    estimateFee(): Promise<number | null> {
+        return Promise.resolve(this.iterations<=1 ? null : this.getFee());
+    }
+
+}

package/src/index.ts

@@ -0,0 +1,46 @@
+import * as bitcoin from "bitcoinjs-lib";
+import * as tinySecpk256Interface from "@bitcoinerlab/secp256k1";
+bitcoin.initEccLib(tinySecpk256Interface);
+
+export * from "./info/InfoHandler";
+
+export * from "./prices/CoinGeckoSwapPrice";
+export * from "./prices/BinanceSwapPrice";
+
+export * from "./storage/IIntermediaryStorage";
+
+export * from "./storagemanager/StorageManager";
+export * from "./storagemanager/IntermediaryStorageManager";
+
+export * from "./swaps/frombtc_abstract/FromBtcAbs";
+export * from "./swaps/frombtc_abstract/FromBtcSwapAbs";
+export * from "./swaps/frombtcln_abstract/FromBtcLnAbs";
+export * from "./swaps/frombtcln_abstract/FromBtcLnSwapAbs";
+export * from "./swaps/tobtc_abstract/ToBtcAbs";
+export * from "./swaps/tobtc_abstract/ToBtcSwapAbs";
+export * from "./swaps/tobtcln_abstract/ToBtcLnAbs";
+export * from "./swaps/tobtcln_abstract/ToBtcLnSwapAbs";
+
+export * from "./swaps/frombtc_trusted/FromBtcTrusted";
+export * from "./swaps/frombtc_trusted/FromBtcTrustedSwap";
+export * from "./swaps/frombtcln_trusted/FromBtcLnTrusted";
+export * from "./swaps/frombtcln_trusted/FromBtcLnTrustedSwap";
+
+export * from "./swaps/ISwapPrice";
+export * from "./swaps/SwapHandler";
+export * from "./swaps/SwapHandlerSwap";
+
+export * from "./plugins/PluginManager";
+export * from "./plugins/IPlugin";
+
+export * from "./fees/IBtcFeeEstimator";
+export * from "./fees/OneDollarFeeEstimator";
+
+export * from "./utils/paramcoders/IParamReader";
+export * from "./utils/paramcoders/IParamWriter";
+export * from "./utils/paramcoders/LegacyParamEncoder";
+export * from "./utils/paramcoders/ParamDecoder";
+export * from "./utils/paramcoders/ParamEncoder";
+export * from "./utils/paramcoders/SchemaVerifier";
+export * from "./utils/paramcoders/server/ServerParamDecoder";
+export * from "./utils/paramcoders/server/ServerParamEncoder";

package/src/info/InfoHandler.ts

@@ -0,0 +1,106 @@
+import {Express} from "express";
+import {MultichainData, SwapHandler, SwapHandlerInfoType, SwapHandlerType} from "../swaps/SwapHandler";
+import * as express from "express";
+
+const HEX_REGEX = /[0-9a-f]+/i;
+
+type InfoHandlerResponseEnvelope = {
+    nonce: string,
+    services: {
+        [key in SwapHandlerType]?: SwapHandlerInfoType
+    }
+};
+
+type InfoHandlerResponse = {
+    envelope: string,
+    address: string,
+    signature: string,
+    chains: {
+        [chainIdentifier: string]: {
+            address: string,
+            signature: string
+        }
+    }
+}
+
+/**
+ * Handles info requests to POST /info returning information about fees, swap params, etc.
+ */
+export class InfoHandler {
+
+    readonly chainData: MultichainData;
+    readonly path: string;
+
+    readonly swapHandlers: SwapHandler[];
+
+    constructor(chainData: MultichainData, path: string, swapHandlers: SwapHandler[]) {
+        this.chainData = chainData;
+        this.path = path;
+        this.swapHandlers = swapHandlers;
+    }
+
+    /**
+     * Adds a listener to POST /info
+     *
+     * @param restServer
+     */
+    startRestServer(restServer: Express) {
+
+        restServer.use(this.path+"/info", express.json());
+        restServer.post(this.path+"/info", async (req, res) => {
+            if (
+                req.body == null ||
+
+                req.body.nonce == null ||
+                typeof(req.body.nonce) !== "string" ||
+                req.body.nonce.length>64 ||
+                !HEX_REGEX.test(req.body.nonce)
+            ) {
+                res.status(400).json({
+                    msg: "Invalid request body (nonce)"
+                });
+                return;
+            }
+
+            const env: InfoHandlerResponseEnvelope = {
+                nonce: req.body.nonce,
+                services: {}
+            };
+
+            for(let swapHandler of this.swapHandlers) {
+                env.services[swapHandler.type] = swapHandler.getInfo();
+            }
+
+            const envelope = JSON.stringify(env);
+            const envelopeBuffer = Buffer.from(envelope);
+
+            const chains: {
+                [chainIdentifier: string]: {
+                    address: string,
+                    signature: string
+                }
+            } = {};
+            for(let chainIdentifier in this.chainData.chains) {
+                const singleChain = this.chainData.chains[chainIdentifier];
+                chains[chainIdentifier] = {
+                    address: singleChain.signer.getAddress(),
+                    signature: await singleChain.swapContract.getDataSignature(singleChain.signer, envelopeBuffer)
+                };
+            }
+
+            const defaults = chains[this.chainData.default];
+
+            const response: InfoHandlerResponse = {
+                envelope,
+                address: defaults.address,
+                signature: defaults.signature,
+                chains
+            };
+
+            res.status(200).json(response);
+        });
+
+    }
+
+
+}

package/src/plugins/IPlugin.ts

@@ -0,0 +1,155 @@
+import {BitcoinRpc, SwapData} from "@atomiqlabs/base";
+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 {Command} from "@atomiqlabs/server-base";
+import {FromBtcLnTrustedRequestType} from "../swaps/frombtcln_trusted/FromBtcLnTrusted";
+
+export type QuoteThrow = {
+    type: "throw",
+    message: string
+}
+
+export function isQuoteThrow(obj: any): obj is QuoteThrow {
+    return obj.type==="throw" && typeof(obj.message)==="string";
+}
+
+export type QuoteSetFees = {
+    type: "fees"
+    baseFee?: BN,
+    feePPM?: BN
+};
+
+export function isQuoteSetFees(obj: any): obj is QuoteSetFees {
+    return obj.type==="fees" &&
+        (obj.baseFee==null || BN.isBN(obj.baseFee)) &&
+        (obj.feePPM==null || BN.isBN(obj.feePPM));
+}
+
+export type QuoteAmountTooLow = {
+    type: "low",
+    data: { min: BN, max: BN }
+}
+
+export function isQuoteAmountTooLow(obj: any): obj is QuoteAmountTooLow {
+    return obj.type==="low" && typeof(obj.data)==="object" && BN.isBN(obj.data.min) && BN.isBN(obj.data.max);
+}
+
+export type QuoteAmountTooHigh = {
+    type: "high",
+    data: { min: BN, max: BN }
+}
+
+export function isQuoteAmountTooHigh(obj: any): obj is QuoteAmountTooHigh {
+    return obj.type==="high" && typeof(obj.data)==="object" && BN.isBN(obj.data.min) && BN.isBN(obj.data.max);
+}
+
+export type PluginQuote = {
+    type: "success",
+    amount: {input: boolean, amount: BN},
+    swapFee: { inInputTokens: BN, inOutputTokens: BN }
+};
+
+export function isPluginQuote(obj: any): obj is PluginQuote {
+    return obj.type==="success" &&
+        typeof(obj.amount)==="object" && typeof(obj.amount.input)==="boolean" && BN.isBN(obj.amount.amount) &&
+        typeof(obj.swapFee)==="object" && BN.isBN(obj.swapFee.inInputTokens) && BN.isBN(obj.swapFee.inOutputTokens);
+}
+
+export type ToBtcPluginQuote = PluginQuote & {
+    networkFee: { inInputTokens: BN, inOutputTokens: BN }
+}
+
+export function isToBtcPluginQuote(obj: any): obj is ToBtcPluginQuote {
+    return typeof(obj.networkFee)==="object" && BN.isBN(obj.networkFee.inInputTokens) && BN.isBN(obj.networkFee.inOutputTokens) &&
+        isPluginQuote(obj);
+}
+
+export interface IPlugin {
+
+    name: string;
+    author: string;
+    description: string;
+
+    //Needs to be called by implementation
+    onEnable(
+        chainsData: MultichainData,
+
+        bitcoinRpc: BitcoinRpc<any>,
+        lnd: AuthenticatedLnd,
+
+        swapPricing: ISwapPrice,
+        tokens: {
+            [ticker: string]: {
+                [chainId: string]: {
+                    address: string,
+                    decimals: number
+                }
+            }
+        },
+
+        directory: string
+    ): Promise<void>;
+    onDisable(): Promise<void>;
+
+    //Called in the library
+    onServiceInitialize(service: SwapHandler<any>): Promise<void>;
+
+    onHttpServerStarted?(expressServer: any): Promise<void>;
+
+    onSwapStateChange?(swap: SwapHandlerSwap): Promise<void>;
+    onSwapCreate?(swap: SwapHandlerSwap): Promise<void>;
+    onSwapRemove?(swap: SwapHandlerSwap): Promise<void>;
+
+    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>;
+    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>;
+
+    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>;
+    onHandlePostToBtcQuote?(
+        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<BN>},
+        pricePrefetchPromise?: Promise<BN> | null
+    ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | ToBtcPluginQuote>;
+
+    /**
+     * Returns whitelisted bitcoin txIds that are OK to spend even with 0-confs
+     */
+    getWhitelistedTxIds?(): string[];
+
+    getCommands?(): Command<any>[];
+
+}