@atomiqlabs/lp-lib 10.3.11 → 11.0.0

package/dist/swaps/frombtc_trusted/FromBtcTrustedSwap.d.ts

@@ -1,9 +1,10 @@
-import { SwapData } from "@atomiqlabs/base";
+import { BtcTx, SwapData } from "@atomiqlabs/base";
 import { FromBtcBaseSwap } from "../FromBtcBaseSwap";
 import * as BN from "bn.js";
 export declare enum FromBtcTrustedSwapState {
-    DOUBLE_SPENT = -3,
-    REFUNDED = -2,
+    DOUBLE_SPENT = -4,
+    REFUNDED = -3,
+    REFUNDABLE = -2,
     EXPIRED = -1,
     CREATED = 0,
     RECEIVED = 1,
@@ -13,19 +14,21 @@ export declare enum FromBtcTrustedSwapState {
     FINISHED = 5
 }
 export declare class FromBtcTrustedSwap<T extends SwapData = SwapData> extends FromBtcBaseSwap<T, FromBtcTrustedSwapState> {
+    readonly sequence: BN;
     readonly btcAddress: string;
-    readonly inputSats: BN;
     readonly dstAddress: string;
     readonly outputTokens: BN;
     readonly createdHeight: number;
     readonly expiresAt: number;
     readonly recommendedFee: number;
-    readonly refundAddress: string;
+    refundAddress: string;
     adjustedInput: BN;
     adjustedOutput: BN;
     doubleSpent: boolean;
     scRawTx: string;
-    rawTx: string;
+    btcTx: BtcTx;
+    txFee: number;
+    txSize: number;
     txId: string;
     vout: number;
     burnTxId: string;

package/dist/swaps/frombtc_trusted/FromBtcTrustedSwap.js

@@ -7,8 +7,9 @@ const Utils_1 = require("../../utils/Utils");
 const crypto_1 = require("crypto");
 var FromBtcTrustedSwapState;
 (function (FromBtcTrustedSwapState) {
-    FromBtcTrustedSwapState[FromBtcTrustedSwapState["DOUBLE_SPENT"] = -3] = "DOUBLE_SPENT";
-    FromBtcTrustedSwapState[FromBtcTrustedSwapState["REFUNDED"] = -2] = "REFUNDED";
+    FromBtcTrustedSwapState[FromBtcTrustedSwapState["DOUBLE_SPENT"] = -4] = "DOUBLE_SPENT";
+    FromBtcTrustedSwapState[FromBtcTrustedSwapState["REFUNDED"] = -3] = "REFUNDED";
+    FromBtcTrustedSwapState[FromBtcTrustedSwapState["REFUNDABLE"] = -2] = "REFUNDABLE";
     FromBtcTrustedSwapState[FromBtcTrustedSwapState["EXPIRED"] = -1] = "EXPIRED";
     FromBtcTrustedSwapState[FromBtcTrustedSwapState["CREATED"] = 0] = "CREATED";
     FromBtcTrustedSwapState[FromBtcTrustedSwapState["RECEIVED"] = 1] = "RECEIVED";
@@ -20,11 +21,11 @@ var FromBtcTrustedSwapState;
 class FromBtcTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
     constructor(objOrChainIdentifier, swapFee, swapFeeInToken, btcAddress, inputSats, dstAddress, outputTokens, createdHeight, expiresAt, recommendedFee, refundAddress) {
         if (typeof (objOrChainIdentifier) === "string") {
-            super(objOrChainIdentifier, swapFee, swapFeeInToken);
+            super(objOrChainIdentifier, inputSats, swapFee, swapFeeInToken);
             this.state = FromBtcTrustedSwapState.CREATED;
             this.doubleSpent = false;
+            this.sequence = new BN((0, crypto_1.randomBytes)(8));
             this.btcAddress = btcAddress;
-            this.inputSats = inputSats;
             this.dstAddress = dstAddress;
             this.outputTokens = outputTokens;
             this.createdHeight = createdHeight;
@@ -35,7 +36,7 @@ class FromBtcTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
         else {
             super(objOrChainIdentifier);
             this.btcAddress = objOrChainIdentifier.btcAddress;
-            this.inputSats = (0, Utils_1.deserializeBN)(objOrChainIdentifier.inputSats);
+            this.sequence = (0, Utils_1.deserializeBN)(objOrChainIdentifier.sequence);
             this.dstAddress = objOrChainIdentifier.dstAddress;
             this.outputTokens = (0, Utils_1.deserializeBN)(objOrChainIdentifier.outputTokens);
             this.adjustedInput = (0, Utils_1.deserializeBN)(objOrChainIdentifier.adjustedInput);
@@ -46,7 +47,9 @@ class FromBtcTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
             this.refundAddress = objOrChainIdentifier.refundAddress;
             this.doubleSpent = objOrChainIdentifier.doubleSpent;
             this.scRawTx = objOrChainIdentifier.scRawTx;
-            this.rawTx = objOrChainIdentifier.rawTx;
+            this.btcTx = objOrChainIdentifier.btcTx;
+            this.txFee = objOrChainIdentifier.txFee;
+            this.txSize = objOrChainIdentifier.txSize;
             this.txId = objOrChainIdentifier.txId;
             this.vout = objOrChainIdentifier.vout;
             this.burnTxId = objOrChainIdentifier.burnTxId;
@@ -56,7 +59,7 @@ class FromBtcTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
     serialize() {
         const partialSerialized = super.serialize();
         partialSerialized.btcAddress = this.btcAddress;
-        partialSerialized.inputSats = (0, Utils_1.serializeBN)(this.inputSats);
+        partialSerialized.sequence = (0, Utils_1.serializeBN)(this.sequence);
         partialSerialized.dstAddress = this.dstAddress;
         partialSerialized.outputTokens = (0, Utils_1.serializeBN)(this.outputTokens);
         partialSerialized.adjustedInput = (0, Utils_1.serializeBN)(this.adjustedInput);
@@ -67,7 +70,9 @@ class FromBtcTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
         partialSerialized.refundAddress = this.refundAddress;
         partialSerialized.doubleSpent = this.doubleSpent;
         partialSerialized.scRawTx = this.scRawTx;
-        partialSerialized.rawTx = this.rawTx;
+        partialSerialized.btcTx = this.btcTx;
+        partialSerialized.txFee = this.txFee;
+        partialSerialized.txSize = this.txSize;
         partialSerialized.txId = this.txId;
         partialSerialized.vout = this.vout;
         partialSerialized.burnTxId = this.burnTxId;
@@ -78,13 +83,13 @@ class FromBtcTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
         return (0, crypto_1.createHash)("sha256").update(this.btcAddress).digest().toString("hex");
     }
     getSequence() {
-        return new BN(0);
+        return this.sequence;
     }
     getOutputAmount() {
         return this.adjustedOutput || this.outputTokens;
     }
     getTotalInputAmount() {
-        return this.adjustedInput || this.inputSats;
+        return this.adjustedInput || this.amount;
     }
     isFailed() {
         return this.state === FromBtcTrustedSwapState.EXPIRED || this.state === FromBtcTrustedSwapState.REFUNDED || this.state === FromBtcTrustedSwapState.DOUBLE_SPENT;

package/dist/swaps/frombtcln_abstract/FromBtcLnAbs.d.ts

@@ -4,10 +4,10 @@ import { FromBtcLnSwapAbs, FromBtcLnSwapState } from "./FromBtcLnSwapAbs";
 import { MultichainData, SwapHandlerType } from "../SwapHandler";
 import { ISwapPrice } from "../ISwapPrice";
 import { ClaimEvent, InitializeEvent, RefundEvent, SwapData } from "@atomiqlabs/base";
-import { AuthenticatedLnd } from "lightning";
 import { IIntermediaryStorage } from "../../storage/IIntermediaryStorage";
 import { FromBtcBaseConfig } from "../FromBtcBaseSwapHandler";
 import { FromBtcLnBaseSwapHandler } from "../FromBtcLnBaseSwapHandler";
+import { ILightningWallet } from "../../wallets/ILightningWallet";
 export type FromBtcLnConfig = FromBtcBaseConfig & {
     invoiceTimeoutSeconds?: number;
     minCltv: BN;
@@ -27,7 +27,7 @@ export type FromBtcLnRequestType = {
 export declare class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, FromBtcLnSwapState> {
     readonly type = SwapHandlerType.FROM_BTCLN;
     readonly config: FromBtcLnConfig;
-    constructor(storageDirectory: IIntermediaryStorage<FromBtcLnSwapAbs>, path: string, chains: MultichainData, lnd: AuthenticatedLnd, swapPricing: ISwapPrice, config: FromBtcLnConfig);
+    constructor(storageDirectory: IIntermediaryStorage<FromBtcLnSwapAbs>, path: string, chains: MultichainData, lightning: ILightningWallet, swapPricing: ISwapPrice, config: FromBtcLnConfig);
     protected processPastSwap(swap: FromBtcLnSwapAbs): Promise<"REFUND" | "SETTLE" | "CANCEL" | null>;
     protected refundSwaps(refundSwaps: FromBtcLnSwapAbs[]): Promise<void>;
     protected cancelInvoices(swaps: FromBtcLnSwapAbs[]): Promise<void>;

package/dist/swaps/frombtcln_abstract/FromBtcLnAbs.js

@@ -11,9 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcLnAbs = void 0;
 const BN = require("bn.js");
-const lncli = require("ln-service");
 const crypto_1 = require("crypto");
-const bolt11 = require("@atomiqlabs/bolt11");
 const FromBtcLnSwapAbs_1 = require("./FromBtcLnSwapAbs");
 const SwapHandler_1 = require("../SwapHandler");
 const base_1 = require("@atomiqlabs/base");
@@ -26,26 +24,23 @@ const FromBtcLnBaseSwapHandler_1 = require("../FromBtcLnBaseSwapHandler");
  * Swap handler handling from BTCLN swaps using submarine swaps
  */
 class FromBtcLnAbs extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
-    constructor(storageDirectory, path, chains, lnd, swapPricing, config) {
-        super(storageDirectory, path, chains, lnd, swapPricing);
+    constructor(storageDirectory, path, chains, lightning, swapPricing, config) {
+        super(storageDirectory, path, chains, lightning, swapPricing);
         this.type = SwapHandler_1.SwapHandlerType.FROM_BTCLN;
         this.config = config;
         this.config.invoiceTimeoutSeconds = this.config.invoiceTimeoutSeconds || 90;
     }
     processPastSwap(swap) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { swapContract } = this.getChain(swap.chainIdentifier);
+            const { swapContract, signer } = this.getChain(swap.chainIdentifier);
             if (swap.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.CREATED) {
                 //Check if already paid
-                const parsedPR = bolt11.decode(swap.pr);
-                const invoice = yield lncli.getInvoice({
-                    id: parsedPR.tagsObject.payment_hash,
-                    lnd: this.LND
-                });
-                const isBeingPaid = invoice.is_held;
+                const parsedPR = yield this.lightning.parsePaymentRequest(swap.pr);
+                const invoice = yield this.lightning.getInvoice(parsedPR.id);
+                const isBeingPaid = invoice.status === "held";
                 if (!isBeingPaid) {
                     //Not paid
-                    const isInvoiceExpired = parsedPR.timeExpireDate < Date.now() / 1000;
+                    const isInvoiceExpired = parsedPR.expiryEpochMillis < Date.now();
                     if (!isInvoiceExpired)
                         return null;
                     this.swapLogger.info(swap, "processPastSwap(state=CREATED): swap LN invoice expired, cancelling, invoice: " + swap.pr);
@@ -68,7 +63,6 @@ class FromBtcLnAbs extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
                 return null;
             }
             if (swap.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.RECEIVED) {
-                const parsedPR = bolt11.decode(swap.pr);
                 const isAuthorizationExpired = yield swapContract.isInitAuthorizationExpired(swap.data, swap);
                 if (isAuthorizationExpired) {
                     const isCommited = yield swapContract.isCommited(swap.data);
@@ -83,10 +77,7 @@ class FromBtcLnAbs extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
                 }
             }
             if (swap.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.RECEIVED || swap.state === FromBtcLnSwapAbs_1.FromBtcLnSwapState.COMMITED) {
-                const expiryTime = swap.data.getExpiry();
-                const currentTime = new BN(Math.floor(Date.now() / 1000) - this.config.maxSkew);
-                const isExpired = expiryTime != null && expiryTime.lt(currentTime);
-                if (!isExpired)
+                if (!swapContract.isExpired(signer.getAddress(), swap.data))
                     return null;
                 const isCommited = yield swapContract.isCommited(swap.data);
                 if (isCommited) {
@@ -123,10 +114,7 @@ class FromBtcLnAbs extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
                 //Refund
                 const paymentHash = swap.data.getHash();
                 try {
-                    yield lncli.cancelHodlInvoice({
-                        lnd: this.LND,
-                        id: paymentHash
-                    });
+                    yield this.lightning.cancelHodlInvoice(paymentHash);
                     this.swapLogger.info(swap, "cancelInvoices(): invoice cancelled!");
                     yield this.removeSwapData(swap);
                 }
@@ -140,10 +128,7 @@ class FromBtcLnAbs extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
         return __awaiter(this, void 0, void 0, function* () {
             for (let swap of swaps) {
                 try {
-                    yield lncli.settleHodlInvoice({
-                        lnd: this.LND,
-                        secret: swap.secret
-                    });
+                    yield this.lightning.settleHodlInvoice(swap.secret);
                     if (swap.metadata != null)
                         swap.metadata.times.htlcSettled = Date.now();
                     yield this.removeSwapData(swap, FromBtcLnSwapAbs_1.FromBtcLnSwapState.SETTLED);
@@ -237,10 +222,7 @@ class FromBtcLnAbs extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
                 savedSwap.metadata.times.claimTxReceived = Date.now();
             this.swapLogger.info(savedSwap, "SC: ClaimEvent: swap HTLC successfully claimed by the client, invoice: " + savedSwap.pr);
             try {
-                yield lncli.settleHodlInvoice({
-                    lnd: this.LND,
-                    secret: secretHex
-                });
+                yield this.lightning.settleHodlInvoice(secretHex);
                 this.swapLogger.info(savedSwap, "SC: ClaimEvent: invoice settled, secret: " + secretHex);
                 savedSwap.secret = secretHex;
                 if (savedSwap.metadata != null)
@@ -268,10 +250,7 @@ class FromBtcLnAbs extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
             savedSwap.txIds.refund = (_a = event.meta) === null || _a === void 0 ? void 0 : _a.txId;
             this.swapLogger.info(savedSwap, "SC: RefundEvent: swap refunded to us, invoice: " + savedSwap.pr);
             try {
-                yield lncli.cancelHodlInvoice({
-                    lnd: this.LND,
-                    id: event.paymentHash
-                });
+                yield this.lightning.cancelHodlInvoice(event.paymentHash);
                 this.swapLogger.info(savedSwap, "SC: RefundEvent: invoice cancelled");
                 yield this.removeSwapData(savedSwap, FromBtcLnSwapAbs_1.FromBtcLnSwapState.REFUNDED);
             }
@@ -367,7 +346,7 @@ class FromBtcLnAbs extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
      * @param abortController
      */
     getBlockheightPrefetch(abortController) {
-        return lncli.getHeight({ lnd: this.LND }).then(res => res.current_block_height).catch(e => {
+        return this.lightning.getBlockheight().catch(e => {
             this.logger.error("getBlockheightPrefetch(): error", e);
             abortController.abort(e);
             return null;
@@ -379,8 +358,8 @@ class FromBtcLnAbs extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
      * @param responseStream
      */
     sendPublicKeyAsync(responseStream) {
-        lncli.getWalletInfo({ lnd: this.LND }).then(resp => responseStream.writeParams({
-            lnPublicKey: resp.public_key
+        this.lightning.getIdentityPublicKey().then(publicKey => responseStream.writeParams({
+            lnPublicKey: publicKey
         })).catch(e => {
             this.logger.error("sendPublicKeyAsync(): error", e);
         });
@@ -439,10 +418,7 @@ class FromBtcLnAbs extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
                 return;
             yield invoiceData.setState(FromBtcLnSwapAbs_1.FromBtcLnSwapState.CANCELED);
             const paymentHash = invoiceData.data.getHash();
-            yield lncli.cancelHodlInvoice({
-                id: paymentHash,
-                lnd: this.LND
-            });
+            yield this.lightning.cancelHodlInvoice(paymentHash);
             yield this.removeSwapData(invoiceData);
             this.swapLogger.info(invoiceData, "cancelSwapAndInvoice(): swap removed & invoice cancelled, invoice: ", invoiceData.pr);
         });
@@ -462,10 +438,7 @@ class FromBtcLnAbs extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
      */
     checkInvoiceStatus(paymentHash) {
         return __awaiter(this, void 0, void 0, function* () {
-            const invoice = yield lncli.getInvoice({
-                id: paymentHash,
-                lnd: this.LND
-            });
+            const invoice = yield this.lightning.getInvoice(paymentHash);
             if (invoice == null)
                 throw {
                     _httpStatus: 200,
@@ -490,27 +463,28 @@ class FromBtcLnAbs extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
                     code: 10001,
                     msg: "Invoice expired/canceled"
                 };
-            const isBeingPaid = invoice.is_held;
-            if (!isBeingPaid) {
-                if (invoice.is_canceled)
+            switch (invoice.status) {
+                case "canceled":
                     throw {
                         _httpStatus: 200,
                         code: 10001,
                         msg: "Invoice expired/canceled"
                     };
-                if (invoice.is_confirmed)
+                case "confirmed":
                     throw {
                         _httpStatus: 200,
                         code: 10002,
                         msg: "Invoice already paid"
                     };
-                throw {
-                    _httpStatus: 200,
-                    code: 10003,
-                    msg: "Invoice yet unpaid"
-                };
+                case "unpaid":
+                    throw {
+                        _httpStatus: 200,
+                        code: 10003,
+                        msg: "Invoice yet unpaid"
+                    };
+                default:
+                    return invoice;
             }
-            return invoice;
         });
     }
     startRestServer(restServer) {
@@ -587,19 +561,18 @@ class FromBtcLnAbs extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
             //Create swap
             const hodlInvoiceObj = {
                 description: chainIdentifier + "-" + parsedBody.address,
-                cltv_delta: this.config.minCltv.add(new BN(5)).toString(10),
-                expires_at: new Date(Date.now() + (this.config.invoiceTimeoutSeconds * 1000)).toISOString(),
+                cltvDelta: this.config.minCltv.add(new BN(5)).toNumber(),
+                expiresAt: Date.now() + (this.config.invoiceTimeoutSeconds * 1000),
                 id: parsedBody.paymentHash,
-                tokens: amountBD.toString(10),
-                description_hash: parsedBody.descriptionHash
+                mtokens: amountBD.mul(new BN(1000)),
+                descriptionHash: parsedBody.descriptionHash
             };
-            metadata.invoiceRequest = Object.assign({}, hodlInvoiceObj);
-            hodlInvoiceObj.lnd = this.LND;
-            const hodlInvoice = yield lncli.createHodlInvoice(hodlInvoiceObj);
+            metadata.invoiceRequest = hodlInvoiceObj;
+            const hodlInvoice = yield this.lightning.createHodlInvoice(hodlInvoiceObj);
             abortController.signal.throwIfAborted();
             metadata.times.invoiceCreated = Date.now();
             metadata.invoiceResponse = Object.assign({}, hodlInvoice);
-            const createdSwap = new FromBtcLnSwapAbs_1.FromBtcLnSwapAbs(chainIdentifier, hodlInvoice.request, swapFee, swapFeeInToken);
+            const createdSwap = new FromBtcLnSwapAbs_1.FromBtcLnSwapAbs(chainIdentifier, hodlInvoice.request, hodlInvoice.mtokens, swapFee, swapFeeInToken);
             //Pre-compute the security deposit
             const expiryTimeout = this.config.minCltv.mul(this.config.bitcoinBlocktime.div(this.config.safetyFactor)).sub(this.config.gracePeriod);
             const totalSecurityDeposit = yield this.getSecurityDeposit(chainIdentifier, amountBD, swapFee, expiryTimeout, baseSDPromise, securityDepositPricePrefetchPromise, abortController.signal, metadata);
@@ -718,6 +691,13 @@ class FromBtcLnAbs extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
     init() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.storageManager.loadData(FromBtcLnSwapAbs_1.FromBtcLnSwapAbs);
+            //Check if all swaps contain a valid amount
+            for (let swap of yield this.storageManager.query([])) {
+                if (swap.amount == null) {
+                    const parsedPR = yield this.lightning.parsePaymentRequest(swap.pr);
+                    swap.amount = parsedPR.mtokens.add(new BN(999)).div(new BN(1000));
+                }
+            }
             this.subscribeToEvents();
             yield PluginManager_1.PluginManager.serviceInitialize(this);
         });

package/dist/swaps/frombtcln_abstract/FromBtcLnSwapAbs.d.ts

@@ -13,17 +13,12 @@ export declare enum FromBtcLnSwapState {
 export declare class FromBtcLnSwapAbs<T extends SwapData = SwapData> extends FromBtcBaseSwap<T, FromBtcLnSwapState> {
     readonly pr: string;
     nonce: number;
-    prefix: string;
-    timeout: string;
-    signature: string;
-    feeRate: string;
     secret: string;
-    constructor(chainIdentifier: string, pr: string, swapFee: BN, swapFeeInToken: BN);
+    constructor(chainIdentifier: string, pr: string, amountMtokens: BN, swapFee: BN, swapFeeInToken: BN);
     constructor(obj: any);
     serialize(): any;
     getSequence(): BN;
     isInitiated(): boolean;
     isFailed(): boolean;
     isSuccess(): boolean;
-    getTotalInputAmount(): BN;
 }

package/dist/swaps/frombtcln_abstract/FromBtcLnSwapAbs.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcLnSwapAbs = exports.FromBtcLnSwapState = void 0;
 const BN = require("bn.js");
 const __1 = require("../..");
-const bolt11 = require("@atomiqlabs/bolt11");
 const FromBtcBaseSwap_1 = require("../FromBtcBaseSwap");
 var FromBtcLnSwapState;
 (function (FromBtcLnSwapState) {
@@ -16,9 +15,9 @@ var FromBtcLnSwapState;
     FromBtcLnSwapState[FromBtcLnSwapState["SETTLED"] = 4] = "SETTLED";
 })(FromBtcLnSwapState = exports.FromBtcLnSwapState || (exports.FromBtcLnSwapState = {}));
 class FromBtcLnSwapAbs extends FromBtcBaseSwap_1.FromBtcBaseSwap {
-    constructor(chainIdOrObj, pr, swapFee, swapFeeInToken) {
+    constructor(chainIdOrObj, pr, amountMtokens, swapFee, swapFeeInToken) {
         if (typeof (chainIdOrObj) === "string") {
-            super(chainIdOrObj, swapFee, swapFeeInToken);
+            super(chainIdOrObj, amountMtokens.add(new BN(999)).div(new BN(1000)), swapFee, swapFeeInToken);
             this.state = FromBtcLnSwapState.CREATED;
             this.pr = pr;
         }
@@ -27,10 +26,6 @@ class FromBtcLnSwapAbs extends FromBtcBaseSwap_1.FromBtcBaseSwap {
             this.pr = chainIdOrObj.pr;
             this.secret = chainIdOrObj.secret;
             this.nonce = chainIdOrObj.nonce;
-            this.prefix = chainIdOrObj.prefix;
-            this.timeout = chainIdOrObj.timeout;
-            this.signature = chainIdOrObj.signature;
-            this.feeRate = chainIdOrObj.feeRate;
         }
         this.type = __1.SwapHandlerType.FROM_BTCLN;
     }
@@ -39,10 +34,6 @@ class FromBtcLnSwapAbs extends FromBtcBaseSwap_1.FromBtcBaseSwap {
         partialSerialized.pr = this.pr;
         partialSerialized.secret = this.secret;
         partialSerialized.nonce = this.nonce;
-        partialSerialized.prefix = this.prefix;
-        partialSerialized.timeout = this.timeout;
-        partialSerialized.signature = this.signature;
-        partialSerialized.feeRate = this.feeRate;
         return partialSerialized;
     }
     getSequence() {
@@ -57,8 +48,5 @@ class FromBtcLnSwapAbs extends FromBtcBaseSwap_1.FromBtcBaseSwap {
     isSuccess() {
         return this.state === FromBtcLnSwapState.SETTLED;
     }
-    getTotalInputAmount() {
-        return new BN(bolt11.decode(this.pr).millisatoshis).add(new BN(999)).div(new BN(1000));
-    }
 }
 exports.FromBtcLnSwapAbs = FromBtcLnSwapAbs;

package/dist/swaps/frombtcln_trusted/FromBtcLnTrusted.d.ts

@@ -1,15 +1,13 @@
-/// <reference types="node" />
 import * as BN from "bn.js";
 import { Express } from "express";
 import { ClaimEvent, InitializeEvent, RefundEvent, SwapData } from "@atomiqlabs/base";
-import { AuthenticatedLnd } from "lightning";
 import { FromBtcLnTrustedSwap, FromBtcLnTrustedSwapState } from "./FromBtcLnTrustedSwap";
 import { FromBtcBaseConfig } from "../FromBtcBaseSwapHandler";
 import { ISwapPrice } from "../ISwapPrice";
 import { MultichainData, SwapHandlerType } from "../SwapHandler";
 import { IIntermediaryStorage } from "../../storage/IIntermediaryStorage";
 import { FromBtcLnBaseSwapHandler } from "../FromBtcLnBaseSwapHandler";
-import EventEmitter from "node:events";
+import { ILightningWallet } from "../../wallets/ILightningWallet";
 export type SwapForGasServerConfig = FromBtcBaseConfig & {
     minCltv: BN;
     invoiceTimeoutSeconds?: number;
@@ -24,10 +22,10 @@ export type FromBtcLnTrustedRequestType = {
  */
 export declare class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedSwap, FromBtcLnTrustedSwapState> {
     readonly type: SwapHandlerType;
-    activeSubscriptions: Map<string, EventEmitter>;
+    activeSubscriptions: Map<string, AbortController>;
     processedTxIds: Map<string, string>;
     readonly config: SwapForGasServerConfig;
-    constructor(storageDirectory: IIntermediaryStorage<FromBtcLnTrustedSwap>, path: string, chains: MultichainData, lnd: AuthenticatedLnd, swapPricing: ISwapPrice, config: SwapForGasServerConfig);
+    constructor(storageDirectory: IIntermediaryStorage<FromBtcLnTrustedSwap>, path: string, chains: MultichainData, lightning: ILightningWallet, swapPricing: ISwapPrice, config: SwapForGasServerConfig);
     /**
      * Unsubscribe from the pending lightning network invoice
      *