@atomiqlabs/lp-lib 10.3.11 → 11.0.0

package/dist/index.d.ts

@@ -22,7 +22,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 +30,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,9 +14,6 @@ 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);
@@ -41,7 +38,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 +46,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/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;
     /**

package/dist/swaps/frombtc_abstract/FromBtcAbs.js

@@ -11,11 +11,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcAbs = void 0;
 const BN = require("bn.js");
-const lncli = require("ln-service");
 const FromBtcSwapAbs_1 = require("./FromBtcSwapAbs");
 const SwapHandler_1 = require("../SwapHandler");
 const base_1 = require("@atomiqlabs/base");
-const bitcoin = require("bitcoinjs-lib");
 const crypto_1 = require("crypto");
 const Utils_1 = require("../../utils/Utils");
 const PluginManager_1 = require("../../plugins/PluginManager");
@@ -26,22 +24,20 @@ const FromBtcBaseSwapHandler_1 = require("../FromBtcBaseSwapHandler");
  * Swap handler handling from BTC swaps using PTLCs (proof-time locked contracts) and btc relay (on-chain bitcoin SPV)
  */
 class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
-    constructor(storageDirectory, path, chains, lnd, swapPricing, config) {
-        super(storageDirectory, path, chains, lnd, swapPricing);
+    constructor(storageDirectory, path, chains, bitcoin, swapPricing, config) {
+        super(storageDirectory, path, chains, swapPricing);
         this.type = SwapHandler_1.SwapHandlerType.FROM_BTC;
-        const anyConfig = config;
-        anyConfig.swapTsCsvDelta = new BN(config.swapCsvDelta).mul(config.bitcoinBlocktime.div(config.safetyFactor));
-        this.config = anyConfig;
+        this.bitcoin = bitcoin;
+        this.config = Object.assign(Object.assign({}, config), { swapTsCsvDelta: new BN(config.swapCsvDelta).mul(config.bitcoinBlocktime.div(config.safetyFactor)) });
     }
     /**
      * Returns the TXO hash of the specific address and amount - sha256(u64le(amount) + outputScript(address))
      *
      * @param address
      * @param amount
-     * @param bitcoinNetwork
      */
-    getTxoHash(address, amount, bitcoinNetwork) {
-        const parsedOutputScript = bitcoin.address.toOutputScript(address, bitcoinNetwork);
+    getTxoHash(address, amount) {
+        const parsedOutputScript = this.bitcoin.toOutputScript(address);
         return (0, crypto_1.createHash)("sha256").update(Buffer.concat([
             Buffer.from(amount.toArray("le", 8)),
             parsedOutputScript
@@ -55,7 +51,7 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
      * @param amount
      */
     getHash(chainIdentifier, address, amount) {
-        const parsedOutputScript = bitcoin.address.toOutputScript(address, this.config.bitcoinNetwork);
+        const parsedOutputScript = this.bitcoin.toOutputScript(address);
         const { swapContract } = this.getChain(chainIdentifier);
         return swapContract.getHashForOnchain(parsedOutputScript, amount, new BN(0));
     }
@@ -68,13 +64,10 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
      */
     processPastSwap(swap) {
         return __awaiter(this, void 0, void 0, function* () {
-            //Current time, minus maximum chain time skew
-            const currentTime = new BN(Math.floor(Date.now() / 1000) - this.config.maxSkew);
-            const { swapContract } = this.getChain(swap.chainIdentifier);
+            const { swapContract, signer } = this.getChain(swap.chainIdentifier);
             //Once authorization expires in CREATED state, the user can no more commit it on-chain
             if (swap.state === FromBtcSwapAbs_1.FromBtcSwapState.CREATED) {
-                const isExpired = swap.authorizationExpiry.lt(currentTime);
-                if (!isExpired)
+                if (!(yield swapContract.isInitAuthorizationExpired(swap.data, swap)))
                     return false;
                 const isCommited = yield swapContract.isCommited(swap.data);
                 if (isCommited) {
@@ -84,14 +77,13 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
                     return false;
                 }
                 this.swapLogger.info(swap, "processPastSwap(state=CREATED): removing past swap due to authorization expiry, address: " + swap.address);
+                yield this.bitcoin.addUnusedAddress(swap.address);
                 yield this.removeSwapData(swap, FromBtcSwapAbs_1.FromBtcSwapState.CANCELED);
                 return false;
             }
-            const expiryTime = swap.data.getExpiry();
             //Check if commited swap expired by now
             if (swap.state === FromBtcSwapAbs_1.FromBtcSwapState.COMMITED) {
-                const isExpired = expiryTime.lt(currentTime);
-                if (!isExpired)
+                if (!swapContract.isExpired(signer.getAddress(), swap.data))
                     return false;
                 const isCommited = yield swapContract.isCommited(swap.data);
                 if (isCommited) {
@@ -201,6 +193,7 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
                 return;
             savedSwap.txIds.refund = (_a = event.meta) === null || _a === void 0 ? void 0 : _a.txId;
             this.swapLogger.info(event, "SC: RefundEvent: swap refunded, address: " + savedSwap.address);
+            yield this.bitcoin.addUnusedAddress(savedSwap.address);
             yield this.removeSwapData(savedSwap, FromBtcSwapAbs_1.FromBtcSwapState.REFUNDED);
         });
     }
@@ -316,10 +309,7 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             yield this.checkBalance(totalInToken, balancePrefetch, abortController.signal);
             metadata.times.balanceChecked = Date.now();
             //Create swap receive bitcoin address
-            const { address: receiveAddress } = yield lncli.createChainAddress({
-                lnd: this.LND,
-                format: "p2wpkh"
-            });
+            const receiveAddress = yield this.bitcoin.getAddress();
             abortController.signal.throwIfAborted();
             metadata.times.addressCreated = Date.now();
             const paymentHash = this.getHash(chainIdentifier, receiveAddress, amountBD);
@@ -334,7 +324,7 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             metadata.times.claimerBountyCalculated = Date.now();
             //Create swap data
             const data = yield swapContract.createSwapData(base_1.ChainSwapType.CHAIN, signer.getAddress(), parsedBody.address, useToken, totalInToken, paymentHash.toString("hex"), parsedBody.sequence, expiry, new BN(0), this.config.confirmations, false, true, totalSecurityDeposit, totalClaimerBounty);
-            data.setTxoHash(this.getTxoHash(receiveAddress, amountBD, this.config.bitcoinNetwork).toString("hex"));
+            data.setTxoHash(this.getTxoHash(receiveAddress, amountBD).toString("hex"));
             abortController.signal.throwIfAborted();
             metadata.times.swapCreated = Date.now();
             //Sign the swap
@@ -343,7 +333,10 @@ class FromBtcAbs extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             const createdSwap = new FromBtcSwapAbs_1.FromBtcSwapAbs(chainIdentifier, receiveAddress, amountBD, swapFee, swapFeeInToken);
             createdSwap.data = data;
             createdSwap.metadata = metadata;
-            createdSwap.authorizationExpiry = new BN(sigData.timeout);
+            createdSwap.prefix = sigData.prefix;
+            createdSwap.timeout = sigData.timeout;
+            createdSwap.signature = sigData.signature;
+            createdSwap.feeRate = sigData.feeRate;
             yield PluginManager_1.PluginManager.swapCreate(createdSwap);
             yield this.storageManager.saveData(createdSwap.data.getHash(), createdSwap.data.getSequence(), createdSwap);
             this.swapLogger.info(createdSwap, "REST: /getAddress: Created swap address: " + receiveAddress + " amount: " + amountBD.toString(10));

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

@@ -1,6 +1,5 @@
 /// <reference types="node" />
 import * as BN from "bn.js";
-import * as bitcoin from "bitcoinjs-lib";
 import { SwapData } from "@atomiqlabs/base";
 import { FromBtcBaseSwap } from "../FromBtcBaseSwap";
 export declare enum FromBtcSwapState {
@@ -12,13 +11,11 @@ export declare enum FromBtcSwapState {
 }
 export declare class FromBtcSwapAbs<T extends SwapData = SwapData> extends FromBtcBaseSwap<T, FromBtcSwapState> {
     readonly address: string;
-    readonly amount: BN;
-    authorizationExpiry: BN;
     txId: string;
     constructor(chainIdentifier: string, address: string, amount: BN, swapFee: BN, swapFeeInToken: BN);
     constructor(obj: any);
     serialize(): any;
-    getTxoHash(bitcoinNetwork: bitcoin.networks.Network): Buffer;
+    getTxoHash(): Buffer;
     isInitiated(): boolean;
     isFailed(): boolean;
     isSuccess(): boolean;

package/dist/swaps/frombtc_abstract/FromBtcSwapAbs.js

@@ -1,11 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcSwapAbs = exports.FromBtcSwapState = void 0;
-const BN = require("bn.js");
-const bitcoin = require("bitcoinjs-lib");
-const crypto_1 = require("crypto");
 const SwapHandler_1 = require("../SwapHandler");
-const Utils_1 = require("../../utils/Utils");
 const FromBtcBaseSwap_1 = require("../FromBtcBaseSwap");
 var FromBtcSwapState;
 (function (FromBtcSwapState) {
@@ -18,16 +14,13 @@ var FromBtcSwapState;
 class FromBtcSwapAbs extends FromBtcBaseSwap_1.FromBtcBaseSwap {
     constructor(prOrObj, address, amount, swapFee, swapFeeInToken) {
         if (typeof (prOrObj) === "string") {
-            super(prOrObj, swapFee, swapFeeInToken);
+            super(prOrObj, amount, swapFee, swapFeeInToken);
             this.state = FromBtcSwapState.CREATED;
             this.address = address;
-            this.amount = amount;
         }
         else {
             super(prOrObj);
             this.address = prOrObj.address;
-            this.amount = new BN(prOrObj.amount);
-            this.authorizationExpiry = (0, Utils_1.deserializeBN)(prOrObj.authorizationExpiry);
             this.txId = prOrObj.txId;
         }
         this.type = SwapHandler_1.SwapHandlerType.FROM_BTC;
@@ -35,17 +28,11 @@ class FromBtcSwapAbs extends FromBtcBaseSwap_1.FromBtcBaseSwap {
     serialize() {
         const partialSerialized = super.serialize();
         partialSerialized.address = this.address;
-        partialSerialized.amount = this.amount.toString(10);
-        partialSerialized.authorizationExpiry = (0, Utils_1.serializeBN)(this.authorizationExpiry);
         partialSerialized.txId = this.txId;
         return partialSerialized;
     }
-    getTxoHash(bitcoinNetwork) {
-        const parsedOutputScript = bitcoin.address.toOutputScript(this.address, bitcoinNetwork);
-        return (0, crypto_1.createHash)("sha256").update(Buffer.concat([
-            Buffer.from(this.amount.toArray("le", 8)),
-            parsedOutputScript
-        ])).digest();
+    getTxoHash() {
+        return Buffer.from(this.data.getTxoHash(), "hex");
     }
     isInitiated() {
         return this.state !== FromBtcSwapState.CREATED;