@atomiqlabs/lp-lib 10.3.11 → 11.0.1

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./info/InfoHandler";
 export * from "./prices/CoinGeckoSwapPrice";
 export * from "./prices/BinanceSwapPrice";
+export * from "./prices/OKXSwapPrice";
 export * from "./storage/IIntermediaryStorage";
 export * from "./storagemanager/StorageManager";
 export * from "./storagemanager/IntermediaryStorageManager";
@@ -22,7 +23,6 @@ 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";
@@ -31,3 +31,5 @@ export * from "./utils/paramcoders/ParamEncoder";
 export * from "./utils/paramcoders/SchemaVerifier";
 export * from "./utils/paramcoders/server/ServerParamDecoder";
 export * from "./utils/paramcoders/server/ServerParamEncoder";
+export * from "./wallets/IBitcoinWallet";
+export * from "./wallets/ILightningWallet";

package/dist/index.js

@@ -14,12 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const bitcoin = require("bitcoinjs-lib");
-const tinySecpk256Interface = require("@bitcoinerlab/secp256k1");
-bitcoin.initEccLib(tinySecpk256Interface);
 __exportStar(require("./info/InfoHandler"), exports);
 __exportStar(require("./prices/CoinGeckoSwapPrice"), exports);
 __exportStar(require("./prices/BinanceSwapPrice"), exports);
+__exportStar(require("./prices/OKXSwapPrice"), exports);
 __exportStar(require("./storage/IIntermediaryStorage"), exports);
 __exportStar(require("./storagemanager/StorageManager"), exports);
 __exportStar(require("./storagemanager/IntermediaryStorageManager"), exports);
@@ -41,7 +39,6 @@ __exportStar(require("./swaps/SwapHandlerSwap"), exports);
 __exportStar(require("./plugins/PluginManager"), exports);
 __exportStar(require("./plugins/IPlugin"), exports);
 __exportStar(require("./fees/IBtcFeeEstimator"), exports);
-__exportStar(require("./fees/OneDollarFeeEstimator"), exports);
 __exportStar(require("./utils/paramcoders/IParamReader"), exports);
 __exportStar(require("./utils/paramcoders/IParamWriter"), exports);
 __exportStar(require("./utils/paramcoders/LegacyParamEncoder"), exports);
@@ -50,3 +47,5 @@ __exportStar(require("./utils/paramcoders/ParamEncoder"), exports);
 __exportStar(require("./utils/paramcoders/SchemaVerifier"), exports);
 __exportStar(require("./utils/paramcoders/server/ServerParamDecoder"), exports);
 __exportStar(require("./utils/paramcoders/server/ServerParamEncoder"), exports);
+__exportStar(require("./wallets/IBitcoinWallet"), exports);
+__exportStar(require("./wallets/ILightningWallet"), exports);

package/dist/plugins/IPlugin.d.ts

@@ -1,10 +1,11 @@
 import { BitcoinRpc } 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";
+import { IBitcoinWallet } from "../wallets/IBitcoinWallet";
+import { ILightningWallet } from "../wallets/ILightningWallet";
 export type QuoteThrow = {
     type: "throw";
     message: string;
@@ -55,7 +56,7 @@ export interface IPlugin {
     name: string;
     author: string;
     description: string;
-    onEnable(chainsData: MultichainData, bitcoinRpc: BitcoinRpc<any>, lnd: AuthenticatedLnd, swapPricing: ISwapPrice, tokens: {
+    onEnable(chainsData: MultichainData, bitcoinRpc: BitcoinRpc<any>, bitcoinWallet: IBitcoinWallet, lightningWallet: ILightningWallet, swapPricing: ISwapPrice, tokens: {
         [ticker: string]: {
             [chainId: string]: {
                 address: string;

package/dist/plugins/PluginManager.d.ts

@@ -2,9 +2,10 @@ import { BitcoinRpc, SwapData } from "@atomiqlabs/base";
 import { IPlugin, 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 { FromBtcLnTrustedRequestType } from "../swaps/frombtcln_trusted/FromBtcLnTrusted";
+import { IBitcoinWallet } from "../wallets/IBitcoinWallet";
+import { ILightningWallet } from "../wallets/ILightningWallet";
 export type FailSwapResponse = {
     type: "fail";
     code?: number;
@@ -26,7 +27,7 @@ export declare class PluginManager {
     static plugins: Map<string, IPlugin>;
     static registerPlugin(name: string, plugin: IPlugin): void;
     static unregisterPlugin(name: string): boolean;
-    static enable<T extends SwapData>(chainsData: MultichainData, bitcoinRpc: BitcoinRpc<any>, lnd: AuthenticatedLnd, swapPricing: ISwapPrice, tokens: {
+    static enable<T extends SwapData>(chainsData: MultichainData, bitcoinRpc: BitcoinRpc<any>, bitcoinWallet: IBitcoinWallet, lightningWallet: ILightningWallet, swapPricing: ISwapPrice, tokens: {
         [ticker: string]: {
             [chainId: string]: {
                 address: string;

package/dist/plugins/PluginManager.js

@@ -27,7 +27,7 @@ class PluginManager {
     static unregisterPlugin(name) {
         return PluginManager.plugins.delete(name);
     }
-    static enable(chainsData, bitcoinRpc, lnd, swapPricing, tokens, directory) {
+    static enable(chainsData, bitcoinRpc, bitcoinWallet, lightningWallet, swapPricing, tokens, directory) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 fs.mkdirSync(directory);
@@ -39,7 +39,7 @@ class PluginManager {
                         fs.mkdirSync(directory + "/" + name);
                     }
                     catch (e) { }
-                    yield plugin.onEnable(chainsData, bitcoinRpc, lnd, swapPricing, tokens, directory + "/" + name);
+                    yield plugin.onEnable(chainsData, bitcoinRpc, bitcoinWallet, lightningWallet, swapPricing, tokens, directory + "/" + name);
                 }
                 catch (e) {
                     pluginLogger.error(plugin, "enable(): plugin enable error", e);

package/dist/prices/OKXSwapPrice.d.ts

@@ -0,0 +1,27 @@
+import * as BN from "bn.js";
+import { ISwapPrice } from "../swaps/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: OKXPriceData);
+    fetchPrice(pair: string): Promise<number>;
+    getPrice(tokenData: {
+        pair: string;
+    }): Promise<BN>;
+}

package/dist/prices/OKXSwapPrice.js

@@ -0,0 +1,106 @@
+"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.OKXSwapPrice = void 0;
+const BN = require("bn.js");
+const ISwapPrice_1 = require("../swaps/ISwapPrice");
+const CACHE_DURATION = 15000;
+class OKXSwapPrice extends ISwapPrice_1.ISwapPrice {
+    constructor(url, coins) {
+        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.cache = {};
+        this.url = url || "https://www.okx.com/api/v5";
+    }
+    fetchPrice(pair) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(this.url + "/market/index-tickers?instId=" + 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.data[0].idxPx);
+        });
+    }
+    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));
+            }
+            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;
+                        }
+                    }
+                }
+                yield Promise.all(promises);
+                this.cache[pair] = {
+                    price: resultPrice,
+                    expiry: Date.now() + CACHE_DURATION
+                };
+            }
+            return new BN(Math.floor(this.cache[pair].price * 100000000000000));
+        });
+    }
+}
+exports.OKXSwapPrice = OKXSwapPrice;

package/dist/swaps/FromBtcBaseSwap.d.ts

@@ -2,11 +2,15 @@ import { SwapData } from "@atomiqlabs/base";
 import { SwapHandlerSwap } from "./SwapHandlerSwap";
 import * as BN from "bn.js";
 export declare abstract class FromBtcBaseSwap<T extends SwapData, S = any> extends SwapHandlerSwap<T, S> {
+    amount: BN;
+    protected constructor(chainIdentifier: string, amount: BN, swapFee: BN, swapFeeInToken: BN);
+    protected constructor(obj: any);
     getInputAmount(): BN;
-    abstract getTotalInputAmount(): BN;
+    getTotalInputAmount(): BN;
     getOutputAmount(): BN;
     getSwapFee(): {
         inInputToken: BN;
         inOutputToken: BN;
     };
+    serialize(): any;
 }

package/dist/swaps/FromBtcBaseSwap.js

@@ -2,15 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcBaseSwap = void 0;
 const SwapHandlerSwap_1 = require("./SwapHandlerSwap");
+const BN = require("bn.js");
+const Utils_1 = require("../utils/Utils");
 class FromBtcBaseSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
+    constructor(obj, amount, swapFee, swapFeeInToken) {
+        super(obj, swapFee, swapFeeInToken);
+        if (typeof (obj) === "string" && BN.isBN(amount) && BN.isBN(swapFee) && BN.isBN(swapFeeInToken)) {
+            this.amount = amount;
+        }
+        else {
+            this.amount = (0, Utils_1.deserializeBN)(obj.amount);
+        }
+    }
+    ;
     getInputAmount() {
         return this.getTotalInputAmount().sub(this.getSwapFee().inInputToken);
     }
+    getTotalInputAmount() {
+        return this.amount;
+    }
     getOutputAmount() {
         return this.data.getAmount();
     }
     getSwapFee() {
         return { inInputToken: this.swapFee, inOutputToken: this.swapFeeInToken };
     }
+    serialize() {
+        const partialSerialized = super.serialize();
+        partialSerialized.amount = (0, Utils_1.serializeBN)(this.amount);
+        return partialSerialized;
+    }
 }
 exports.FromBtcBaseSwap = FromBtcBaseSwap;

package/dist/swaps/FromBtcBaseSwapHandler.d.ts

@@ -114,5 +114,6 @@ export declare abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<S
         prefix: string;
         timeout: string;
         signature: string;
+        feeRate: string;
     }>;
 }

package/dist/swaps/FromBtcBaseSwapHandler.js

@@ -287,7 +287,7 @@ class FromBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
             this.logger.debug("getFromBtcSignatureData(): using fee rate from client: ", feeRate);
             const sigData = yield swapContract.getInitSignature(signer, swapObject, this.config.authorizationTimeout, prefetchedSignData, feeRate);
             abortSignal.throwIfAborted();
-            return sigData;
+            return Object.assign(Object.assign({}, sigData), { feeRate });
         });
     }
 }

package/dist/swaps/FromBtcLnBaseSwapHandler.d.ts

@@ -2,7 +2,13 @@ import { SwapHandlerSwap } from "./SwapHandlerSwap";
 import { SwapData } from "@atomiqlabs/base";
 import { FromBtcBaseSwapHandler } from "./FromBtcBaseSwapHandler";
 import * as BN from "bn.js";
+import { ILightningWallet, LightningNetworkChannel } from "../wallets/ILightningWallet";
+import { IIntermediaryStorage } from "../storage/IIntermediaryStorage";
+import { MultichainData } from "./SwapHandler";
+import { ISwapPrice } from "./ISwapPrice";
 export declare abstract class FromBtcLnBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S>, S> extends FromBtcBaseSwapHandler<V, S> {
+    readonly lightning: ILightningWallet;
+    constructor(storageDirectory: IIntermediaryStorage<V>, path: string, chains: MultichainData, lightning: ILightningWallet, swapPricing: ISwapPrice);
     /**
      * Checks if we have enough inbound liquidity to be able to receive an LN payment (without MPP)
      *
@@ -11,15 +17,11 @@ export declare abstract class FromBtcLnBaseSwapHandler<V extends SwapHandlerSwap
      * @param signal
      * @throws {DefinedRuntimeError} will throw an error if there isn't enough inbound liquidity to receive the LN payment
      */
-    protected checkInboundLiquidity(amountBD: BN, channelsPrefetch: Promise<{
-        channels: any[];
-    }>, signal: AbortSignal): Promise<void>;
+    protected checkInboundLiquidity(amountBD: BN, channelsPrefetch: Promise<LightningNetworkChannel[]>, signal: AbortSignal): Promise<void>;
     /**
      * Starts LN channels pre-fetch
      *
      * @param abortController
      */
-    protected getChannelsPrefetch(abortController: AbortController): Promise<{
-        channels: any[];
-    }>;
+    protected getChannelsPrefetch(abortController: AbortController): Promise<LightningNetworkChannel[]>;
 }

package/dist/swaps/FromBtcLnBaseSwapHandler.js

@@ -11,9 +11,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcLnBaseSwapHandler = void 0;
 const FromBtcBaseSwapHandler_1 = require("./FromBtcBaseSwapHandler");
-const BN = require("bn.js");
-const lncli = require("ln-service");
 class FromBtcLnBaseSwapHandler extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
+    constructor(storageDirectory, path, chains, lightning, swapPricing) {
+        super(storageDirectory, path, chains, swapPricing);
+        this.lightning = lightning;
+    }
     /**
      * Checks if we have enough inbound liquidity to be able to receive an LN payment (without MPP)
      *
@@ -27,8 +29,8 @@ class FromBtcLnBaseSwapHandler extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapH
             const channelsResponse = yield channelsPrefetch;
             signal.throwIfAborted();
             let hasEnoughInboundLiquidity = false;
-            channelsResponse.channels.forEach(channel => {
-                if (new BN(channel.remote_balance).gte(amountBD))
+            channelsResponse.forEach(channel => {
+                if (channel.remoteBalance.gte(amountBD))
                     hasEnoughInboundLiquidity = true;
             });
             if (!hasEnoughInboundLiquidity) {
@@ -45,7 +47,7 @@ class FromBtcLnBaseSwapHandler extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapH
      * @param abortController
      */
     getChannelsPrefetch(abortController) {
-        return lncli.getChannels({ is_active: true, lnd: this.LND }).catch(e => {
+        return this.lightning.getChannels(true).catch(e => {
             this.logger.error("getChannelsPrefetch(): error", e);
             abortController.abort(e);
             return null;

package/dist/swaps/SwapHandler.d.ts

@@ -1,7 +1,6 @@
 import { Express, Request } from "express";
 import { ISwapPrice } from "./ISwapPrice";
 import { ChainType, ClaimEvent, InitializeEvent, RefundEvent, SwapData, SwapEvent } from "@atomiqlabs/base";
-import { AuthenticatedLnd } from "lightning";
 import { SwapHandlerSwap } from "./SwapHandlerSwap";
 import { IIntermediaryStorage } from "../storage/IIntermediaryStorage";
 import * as BN from "bn.js";
@@ -33,7 +32,6 @@ export type SwapBaseConfig = {
     feePPM: BN;
     max: BN;
     min: BN;
-    maxSkew: number;
     safetyFactor: BN;
     swapCheckInterval: number;
 };
@@ -70,7 +68,6 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S>
         [chainId: string]: Set<string>;
     };
     readonly swapPricing: ISwapPrice;
-    readonly LND: AuthenticatedLnd;
     abstract config: SwapBaseConfig;
     logger: {
         debug: (msg: string, ...args: any) => void;
@@ -84,7 +81,7 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S>
         warn: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
         error: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
     };
-    protected constructor(storageDirectory: IIntermediaryStorage<V>, path: string, chainsData: MultichainData, lnd: AuthenticatedLnd, swapPricing: ISwapPrice);
+    protected constructor(storageDirectory: IIntermediaryStorage<V>, path: string, chainsData: MultichainData, swapPricing: ISwapPrice);
     protected getDefaultChain(): ChainData;
     protected getChain(identifier: string): ChainData;
     protected abstract processPastSwaps(): Promise<void>;

package/dist/swaps/SwapHandler.js

@@ -28,7 +28,7 @@ var SwapHandlerType;
  * An abstract class defining a singular swap service
  */
 class SwapHandler {
-    constructor(storageDirectory, path, chainsData, lnd, swapPricing) {
+    constructor(storageDirectory, path, chainsData, swapPricing) {
         this.logger = {
             debug: (msg, ...args) => console.debug("SwapHandler(" + this.type + "): " + msg, ...args),
             info: (msg, ...args) => console.info("SwapHandler(" + this.type + "): " + msg, ...args),
@@ -46,7 +46,6 @@ class SwapHandler {
         if (this.chains.chains[this.chains.default] == null)
             throw new Error("Invalid default chain specified");
         this.path = path;
-        this.LND = lnd;
         this.swapPricing = swapPricing;
         this.allowedTokens = {};
         for (let chainId in chainsData.chains) {

package/dist/swaps/SwapHandlerSwap.d.ts

@@ -20,6 +20,10 @@ export declare abstract class SwapHandlerSwap<T extends SwapData = SwapData, S =
     };
     readonly swapFee: BN;
     readonly swapFeeInToken: BN;
+    prefix: string;
+    timeout: string;
+    signature: string;
+    feeRate: string;
     protected constructor(chainIdentifier: string, swapFee: BN, swapFeeInToken: BN);
     protected constructor(obj: any);
     serialize(): any;

package/dist/swaps/SwapHandlerSwap.js

@@ -23,6 +23,10 @@ class SwapHandlerSwap extends base_1.Lockable {
             this.state = obj.state;
             this.swapFee = (0, Utils_1.deserializeBN)(obj.swapFee);
             this.swapFeeInToken = (0, Utils_1.deserializeBN)(obj.swapFeeInToken);
+            this.prefix = obj.prefix;
+            this.timeout = obj.timeout;
+            this.signature = obj.signature;
+            this.feeRate = obj.feeRate;
         }
     }
     serialize() {
@@ -33,7 +37,11 @@ class SwapHandlerSwap extends base_1.Lockable {
             metadata: this.metadata,
             txIds: this.txIds,
             swapFee: (0, Utils_1.serializeBN)(this.swapFee),
-            swapFeeInToken: (0, Utils_1.serializeBN)(this.swapFeeInToken)
+            swapFeeInToken: (0, Utils_1.serializeBN)(this.swapFeeInToken),
+            prefix: this.prefix,
+            timeout: this.timeout,
+            signature: this.signature,
+            feeRate: this.feeRate
         };
     }
     /**

package/dist/swaps/ToBtcBaseSwap.d.ts

@@ -2,11 +2,12 @@ import { SwapHandlerSwap } from "./SwapHandlerSwap";
 import { SwapData } from "@atomiqlabs/base";
 import * as BN from "bn.js";
 export declare abstract class ToBtcBaseSwap<T extends SwapData = SwapData, S = any> extends SwapHandlerSwap<T, S> {
+    amount: BN;
     quotedNetworkFee: BN;
     readonly quotedNetworkFeeInToken: BN;
     realNetworkFee: BN;
     realNetworkFeeInToken: BN;
-    protected constructor(chainIdentifier: string, swapFee: BN, swapFeeInToken: BN, quotedNetworkFee: BN, quotedNetworkFeeInToken: BN);
+    protected constructor(chainIdentifier: string, amount: BN, swapFee: BN, swapFeeInToken: BN, quotedNetworkFee: BN, quotedNetworkFeeInToken: BN);
     protected constructor(obj: any);
     serialize(): any;
     setRealNetworkFee(networkFeeInBtc: BN): void;
@@ -32,4 +33,5 @@ export declare abstract class ToBtcBaseSwap<T extends SwapData = SwapData, S = a
         inInputToken: BN;
         inOutputToken: BN;
     };
+    getOutputAmount(): BN;
 }

package/dist/swaps/ToBtcBaseSwap.js

@@ -5,15 +5,17 @@ const SwapHandlerSwap_1 = require("./SwapHandlerSwap");
 const BN = require("bn.js");
 const Utils_1 = require("../utils/Utils");
 class ToBtcBaseSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
-    constructor(obj, swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken) {
-        if (typeof (obj) === "string" && BN.isBN(swapFee) && BN.isBN(swapFeeInToken) && BN.isBN(quotedNetworkFee) && BN.isBN(quotedNetworkFeeInToken)) {
+    constructor(obj, amount, swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken) {
+        if (typeof (obj) === "string" && BN.isBN(amount) && BN.isBN(swapFee) && BN.isBN(swapFeeInToken) && BN.isBN(quotedNetworkFee) && BN.isBN(quotedNetworkFeeInToken)) {
             super(obj, swapFee, swapFeeInToken);
+            this.amount = amount;
             this.quotedNetworkFee = quotedNetworkFee;
             this.quotedNetworkFeeInToken = quotedNetworkFeeInToken;
             return;
         }
         else {
             super(obj);
+            this.amount = (0, Utils_1.deserializeBN)(obj.amount);
             this.quotedNetworkFee = (0, Utils_1.deserializeBN)(obj.quotedNetworkFee);
             this.quotedNetworkFeeInToken = (0, Utils_1.deserializeBN)(obj.quotedNetworkFeeInToken);
             this.realNetworkFee = (0, Utils_1.deserializeBN)(obj.realNetworkFee);
@@ -22,6 +24,7 @@ class ToBtcBaseSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
     }
     serialize() {
         const obj = super.serialize();
+        obj.amount = (0, Utils_1.serializeBN)(this.amount);
         obj.quotedNetworkFee = (0, Utils_1.serializeBN)(this.quotedNetworkFee);
         obj.quotedNetworkFeeInToken = (0, Utils_1.serializeBN)(this.quotedNetworkFeeInToken);
         obj.realNetworkFee = (0, Utils_1.serializeBN)(this.realNetworkFee);
@@ -57,5 +60,8 @@ class ToBtcBaseSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
     getRealNetworkFee() {
         return { inInputToken: this.realNetworkFeeInToken, inOutputToken: this.realNetworkFee };
     }
+    getOutputAmount() {
+        return this.amount;
+    }
 }
 exports.ToBtcBaseSwap = ToBtcBaseSwap;

package/dist/swaps/ToBtcBaseSwapHandler.d.ts

@@ -90,5 +90,6 @@ export declare abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<Swa
         prefix: string;
         timeout: string;
         signature: string;
+        feeRate: string;
     }>;
 }

package/dist/swaps/ToBtcBaseSwapHandler.js

@@ -226,7 +226,7 @@ class ToBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
             const { swapContract, signer } = this.getChain(chainIdentifier);
             const sigData = yield swapContract.getInitSignature(signer, swapObject, this.config.authorizationTimeout, prefetchedSignData, feeRate);
             abortSignal.throwIfAborted();
-            return sigData;
+            return Object.assign(Object.assign({}, sigData), { feeRate });
         });
     }
 }

package/dist/swaps/frombtc_abstract/FromBtcAbs.d.ts

@@ -4,12 +4,10 @@ import { FromBtcSwapAbs, FromBtcSwapState } from "./FromBtcSwapAbs";
 import { MultichainData, SwapHandlerType } from "../SwapHandler";
 import { ISwapPrice } from "../ISwapPrice";
 import { ClaimEvent, InitializeEvent, RefundEvent, SwapData } from "@atomiqlabs/base";
-import { AuthenticatedLnd } from "lightning";
-import * as bitcoin from "bitcoinjs-lib";
 import { IIntermediaryStorage } from "../../storage/IIntermediaryStorage";
 import { FromBtcBaseConfig, FromBtcBaseSwapHandler } from "../FromBtcBaseSwapHandler";
+import { IBitcoinWallet } from "../../wallets/IBitcoinWallet";
 export type FromBtcConfig = FromBtcBaseConfig & {
-    bitcoinNetwork: bitcoin.networks.Network;
     confirmations: number;
     swapCsvDelta: number;
 };
@@ -28,13 +26,13 @@ export declare class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, F
     readonly config: FromBtcConfig & {
         swapTsCsvDelta: BN;
     };
-    constructor(storageDirectory: IIntermediaryStorage<FromBtcSwapAbs>, path: string, chains: MultichainData, lnd: AuthenticatedLnd, swapPricing: ISwapPrice, config: FromBtcConfig);
+    readonly bitcoin: IBitcoinWallet;
+    constructor(storageDirectory: IIntermediaryStorage<FromBtcSwapAbs>, path: string, chains: MultichainData, bitcoin: IBitcoinWallet, swapPricing: ISwapPrice, config: FromBtcConfig);
     /**
      * Returns the TXO hash of the specific address and amount - sha256(u64le(amount) + outputScript(address))
      *
      * @param address
      * @param amount
-     * @param bitcoinNetwork
      */
     private getTxoHash;
     /**