@atomiqlabs/lp-lib 11.0.5 → 12.0.0-beta.0

package/src/swaps/frombtcln_abstract/FromBtcLnAbs.ts

@@ -1,10 +1,10 @@
-import * as BN from "bn.js";
 import {Express, Request, Response} from "express";
-import {createHash} from "crypto";
+import {createHash, randomBytes} from "crypto";
 import {FromBtcLnSwapAbs, FromBtcLnSwapState} from "./FromBtcLnSwapAbs";
 import {MultichainData, SwapHandlerType} from "../SwapHandler";
 import {ISwapPrice} from "../ISwapPrice";
 import {
+    BigIntBufferUtils,
     ChainSwapType,
     ClaimEvent,
     InitializeEvent,
@@ -29,14 +29,14 @@ import {
 
 export type FromBtcLnConfig = FromBtcBaseConfig & {
     invoiceTimeoutSeconds?: number,
-    minCltv: BN,
-    gracePeriod: BN
+    minCltv: bigint,
+    gracePeriod: bigint
 }
 
 export type FromBtcLnRequestType = {
     address: string,
     paymentHash: string,
-    amount: BN,
+    amount: bigint,
     token: string,
     descriptionHash?: string,
     exactOut?: boolean
@@ -46,8 +46,8 @@ export type FromBtcLnRequestType = {
  * Swap handler handling from BTCLN swaps using submarine swaps
  */
 export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, FromBtcLnSwapState> {
-
     readonly type = SwapHandlerType.FROM_BTCLN;
+    readonly swapType = ChainSwapType.HTLC;
 
     readonly config: FromBtcLnConfig;
 
@@ -112,12 +112,12 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
 
                 this.swapLogger.info(swap, "processPastSwap(state=RECEIVED): swap committed (detected from processPastSwap), invoice: "+swap.pr);
                 await swap.setState(FromBtcLnSwapState.COMMITED);
-                await this.storageManager.saveData(swap.data.getHash(), null, swap);
+                await this.saveSwapData(swap);
             }
         }
 
         if(swap.state===FromBtcLnSwapState.RECEIVED || swap.state===FromBtcLnSwapState.COMMITED) {
-            if(!swapContract.isExpired(signer.getAddress(), swap.data)) return null;
+            if(!await swapContract.isExpired(signer.getAddress(), swap.data)) return null;
 
             const isCommited = await swapContract.isCommited(swap.data);
             if(isCommited) {
@@ -151,7 +151,7 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
     protected async cancelInvoices(swaps: FromBtcLnSwapAbs[]) {
         for(let swap of swaps) {
             //Refund
-            const paymentHash = swap.data.getHash();
+            const paymentHash = swap.lnPaymentHash;
             try {
                 await this.lightning.cancelHodlInvoice(paymentHash);
                 this.swapLogger.info(swap, "cancelInvoices(): invoice cancelled!");
@@ -198,7 +198,7 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
             }
         ]);
 
-        for(let swap of queriedData) {
+        for(let {obj: swap} of queriedData) {
             switch(await this.processPastSwap(swap)) {
                 case "CANCEL":
                     cancelInvoices.push(swap);
@@ -217,45 +217,24 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
         await this.settleInvoices(settleInvoices);
     }
 
-    protected async processInitializeEvent(chainIdentifier: string, event: InitializeEvent<SwapData>): Promise<void> {
-        //Only process HTLC requests
-        if (event.swapType !== ChainSwapType.HTLC) return;
-
-        const swapData = await event.swapData();
-
-        const {swapContract, signer} = this.getChain(chainIdentifier);
-        if (!swapData.isOfferer(signer.getAddress())) return;
-        if (swapData.isPayIn()) return;
-
-        const paymentHash = event.paymentHash;
-
-        const savedSwap = await this.storageManager.getData(paymentHash, null);
-        if (savedSwap==null || savedSwap.chainIdentifier!==chainIdentifier) return;
-
+    protected async processInitializeEvent(chainIdentifier: string, savedSwap: FromBtcLnSwapAbs, event: InitializeEvent<SwapData>): Promise<void> {
         this.swapLogger.info(savedSwap, "SC: InitializeEvent: HTLC initialized by the client, invoice: "+savedSwap.pr);
 
-        savedSwap.txIds.init = (event as any).meta?.txId;
-        if(savedSwap.metadata!=null) savedSwap.metadata.times.initTxReceived = Date.now();
         if(savedSwap.state===FromBtcLnSwapState.RECEIVED) {
             await savedSwap.setState(FromBtcLnSwapState.COMMITED);
-            savedSwap.data = swapData;
-            await this.storageManager.saveData(paymentHash, null, savedSwap);
+            await this.saveSwapData(savedSwap);
         }
     }
 
-    protected async processClaimEvent(chainIdentifier: string, event: ClaimEvent<SwapData>): Promise<void> {
+    protected async processClaimEvent(chainIdentifier: string, savedSwap: FromBtcLnSwapAbs, event: ClaimEvent<SwapData>): Promise<void> {
         //Claim
         //This is the important part, we need to catch the claim TX, else we may lose money
-        const secret: Buffer = Buffer.from(event.secret, "hex");
+        const secret: Buffer = Buffer.from(event.result, "hex");
         const paymentHash: Buffer = createHash("sha256").update(secret).digest();
         const secretHex = secret.toString("hex");
         const paymentHashHex = paymentHash.toString("hex");
 
-        const savedSwap = await this.storageManager.getData(paymentHashHex, null);
-        if (savedSwap==null || savedSwap.chainIdentifier!==chainIdentifier) return;
-
-        savedSwap.txIds.claim = (event as any).meta?.txId;
-        if(savedSwap.metadata!=null) savedSwap.metadata.times.claimTxReceived = Date.now();
+        if (savedSwap.lnPaymentHash!==paymentHashHex) return;
 
         this.swapLogger.info(savedSwap, "SC: ClaimEvent: swap HTLC successfully claimed by the client, invoice: "+savedSwap.pr);
 
@@ -269,32 +248,23 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
             this.swapLogger.error(savedSwap, "SC: ClaimEvent: cannot settle invoice", e);
             savedSwap.secret = secretHex;
             await savedSwap.setState(FromBtcLnSwapState.CLAIMED);
-            await this.storageManager.saveData(paymentHashHex, null, savedSwap);
+            await this.saveSwapData(savedSwap);
         }
 
     }
 
-    protected async processRefundEvent(chainIdentifier: string, event: RefundEvent<SwapData>): Promise<void> {
-        //Refund
-        //Try to get the hash from the refundMap
-        if (event.paymentHash == null) return;
-
-        const savedSwap = await this.storageManager.getData(event.paymentHash, null);
-        if (savedSwap==null || savedSwap.chainIdentifier!==chainIdentifier) return;
-
-        savedSwap.txIds.refund = (event as any).meta?.txId;
-
+    protected async processRefundEvent(chainIdentifier: string, savedSwap: FromBtcLnSwapAbs, event: RefundEvent<SwapData>): Promise<void> {
         this.swapLogger.info(savedSwap, "SC: RefundEvent: swap refunded to us, invoice: "+savedSwap.pr);
 
         try {
-            await this.lightning.cancelHodlInvoice(event.paymentHash);
+            await this.lightning.cancelHodlInvoice(savedSwap.lnPaymentHash);
             this.swapLogger.info(savedSwap, "SC: RefundEvent: invoice cancelled");
             await this.removeSwapData(savedSwap, FromBtcLnSwapState.REFUNDED);
         } catch (e) {
             this.swapLogger.error(savedSwap, "SC: RefundEvent: cannot cancel invoice", e);
             await savedSwap.setState(FromBtcLnSwapState.CANCELED);
             // await PluginManager.swapStateChange(savedSwap);
-            await this.storageManager.saveData(event.paymentHash, null, savedSwap);
+            await this.saveSwapData(savedSwap);
         }
     }
 
@@ -309,21 +279,21 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
         this.swapLogger.debug(invoiceData, "htlcReceived(): invoice: ", invoice);
         if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcReceived = Date.now();
 
-        const useToken = invoiceData.data.getToken();
-        const sendAmount: BN = invoiceData.data.getAmount();
+        const useToken = invoiceData.token;
+        const escrowAmount: bigint = invoiceData.totalTokens;
 
         //Create abort controller for parallel fetches
         const abortController = new AbortController();
 
         //Pre-fetch data
-        const balancePrefetch: Promise<BN> = this.getBalancePrefetch(invoiceData.chainIdentifier, useToken, abortController);
+        const balancePrefetch: Promise<bigint> = this.getBalancePrefetch(invoiceData.chainIdentifier, useToken, abortController);
         const blockheightPrefetch = this.getBlockheightPrefetch(abortController);
         const signDataPrefetchPromise: Promise<any> = this.getSignDataPrefetch(invoiceData.chainIdentifier, abortController);
 
-        let expiryTimeout: BN;
+        let expiryTimeout: bigint;
         try {
             //Check if we have enough liquidity to proceed
-            await this.checkBalance(sendAmount, balancePrefetch, abortController.signal);
+            await this.checkBalance(escrowAmount, balancePrefetch, abortController.signal);
             if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcBalanceChecked = Date.now();
 
             //Check if HTLC expiry is long enough
@@ -342,18 +312,17 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
         const payInvoiceObject: SwapData = await swapContract.createSwapData(
             ChainSwapType.HTLC,
             signer.getAddress(),
-            invoiceData.data.getClaimer(),
+            invoiceData.claimer,
             useToken,
-            sendAmount,
-            invoice.id,
-            new BN(0),
-            new BN(Math.floor(Date.now() / 1000)).add(expiryTimeout),
-            new BN(0),
-            0,
+            escrowAmount,
+            invoiceData.claimHash,
+            0n,
+            BigInt(Math.floor(Date.now() / 1000)) + expiryTimeout,
             false,
             true,
-            invoiceData.data.getSecurityDeposit(),
-            new BN(0)
+            invoiceData.securityDeposit,
+            0n,
+            invoiceData.depositToken
         );
         abortController.signal.throwIfAborted();
         if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcSwapCreated = Date.now();
@@ -362,7 +331,7 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
         const sigData = await swapContract.getInitSignature(
             signer,
             payInvoiceObject,
-            this.config.authorizationTimeout,
+            this.getInitAuthorizationTimeout(invoiceData.chainIdentifier),
             signDataPrefetchPromise==null ? null : await signDataPrefetchPromise,
             invoiceData.feeRate
         );
@@ -379,7 +348,7 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
             //Setting the state variable is done outside the promise, so is done synchronously
             await invoiceData.setState(FromBtcLnSwapState.RECEIVED);
 
-            await this.storageManager.saveData(invoice.id, null, invoiceData);
+            await this.saveSwapData(invoiceData);
             return;
         }
     }
@@ -450,14 +419,14 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
      * @throws {DefinedRuntimeError} Will throw if HTLC expires too soon and therefore cannot be processed
      * @returns expiry timeout in seconds
      */
-    private async checkHtlcExpiry(invoice: LightningNetworkInvoice, blockheightPrefetch: Promise<number>, signal: AbortSignal): Promise<BN> {
+    private async checkHtlcExpiry(invoice: LightningNetworkInvoice, blockheightPrefetch: Promise<number>, signal: AbortSignal): Promise<bigint> {
         const timeout: number = this.getInvoicePaymentsTimeout(invoice);
         const current_block_height = await blockheightPrefetch;
         signal.throwIfAborted();
 
-        const blockDelta = new BN(timeout - current_block_height);
+        const blockDelta = BigInt(timeout - current_block_height);
 
-        const htlcExpiresTooSoon = blockDelta.lt(this.config.minCltv);
+        const htlcExpiresTooSoon = blockDelta < this.config.minCltv;
         if(htlcExpiresTooSoon) {
             throw {
                 code: 20002,
@@ -469,7 +438,7 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
             };
         }
 
-        return this.config.minCltv.mul(this.config.bitcoinBlocktime.div(this.config.safetyFactor)).sub(this.config.gracePeriod);
+        return (this.config.minCltv * this.config.bitcoinBlocktime / this.config.safetyFactor) - this.config.gracePeriod;
     }
 
     /**
@@ -480,29 +449,27 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
     private async cancelSwapAndInvoice(invoiceData: FromBtcLnSwapAbs): Promise<void> {
         if(invoiceData.state!==FromBtcLnSwapState.CREATED) return;
         await invoiceData.setState(FromBtcLnSwapState.CANCELED);
-        const paymentHash = invoiceData.data.getHash();
-        await this.lightning.cancelHodlInvoice(paymentHash);
+        await this.lightning.cancelHodlInvoice(invoiceData.lnPaymentHash);
         await this.removeSwapData(invoiceData);
         this.swapLogger.info(invoiceData, "cancelSwapAndInvoice(): swap removed & invoice cancelled, invoice: ", invoiceData.pr);
     };
 
     private getDummySwapData(chainIdentifier: string, useToken: string, address: string, paymentHash: string) {
         const {swapContract, signer} = this.getChain(chainIdentifier);
+        const dummyAmount = BigInt(Math.floor(Math.random() * 0x1000000));
         return swapContract.createSwapData(
             ChainSwapType.HTLC,
             signer.getAddress(),
             address,
             useToken,
-            null,
-            paymentHash,
-            new BN(0),
-            null,
-            null,
-            0,
+            dummyAmount,
+            swapContract.getHashForHtlc(Buffer.from(paymentHash, "hex")).toString("hex"),
+            BigIntBufferUtils.fromBuffer(randomBytes(8)),
+            BigInt(Math.floor(Date.now()/1000)),
             false,
             true,
-            null,
-            new BN(0)
+            BigInt(Math.floor(Math.random() * 0x10000)),
+            0n
         );
     }
 
@@ -576,9 +543,12 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
 
             const chainIdentifier = req.query.chain as string ?? this.chains.default;
             const {swapContract, signer} = this.getChain(chainIdentifier);
+            const depositToken = req.query.depositToken as string ?? swapContract.getNativeCurrencyAddress();
+            this.checkAllowedDepositToken(chainIdentifier, depositToken);
 
             metadata.times.requestReceived = Date.now();
 
+
             /**
              * address: string              solana address of the recipient
              * paymentHash: string          payment hash of the to-be-created invoice
@@ -598,7 +568,7 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
                             typeof(val)==="string" &&
                             val.length===64 &&
                             HEX_REGEX.test(val) ? val: null,
-                amount: FieldTypeEnum.BN,
+                amount: FieldTypeEnum.BigInt,
                 token: (val: string) => val!=null &&
                         typeof(val)==="string" &&
                         this.isTokenSupported(chainIdentifier, val) ? val : null,
@@ -630,13 +600,21 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
             const abortController = this.getAbortController(responseStream);
 
             //Pre-fetch data
-            const {pricePrefetchPromise, securityDepositPricePrefetchPromise} = this.getFromBtcPricePrefetches(chainIdentifier, useToken, abortController);
-            const balancePrefetch: Promise<BN> = this.getBalancePrefetch(chainIdentifier, useToken, abortController);
+            const {
+                pricePrefetchPromise,
+                gasTokenPricePrefetchPromise,
+                depositTokenPricePrefetchPromise
+            } = this.getFromBtcPricePrefetches(chainIdentifier, useToken, depositToken, abortController);
+            const balancePrefetch: Promise<bigint> = this.getBalancePrefetch(chainIdentifier, useToken, abortController);
             const channelsPrefetch: Promise<LightningNetworkChannel[]> = this.getChannelsPrefetch(abortController);
 
             const dummySwapData = await this.getDummySwapData(chainIdentifier, useToken, parsedBody.address, parsedBody.paymentHash);
             abortController.signal.throwIfAborted();
-            const baseSDPromise: Promise<BN> = this.getBaseSecurityDepositPrefetch(chainIdentifier, dummySwapData, abortController);
+            const baseSDPromise: Promise<bigint> = this.getBaseSecurityDepositPrefetch(
+                chainIdentifier, dummySwapData, depositToken,
+                gasTokenPricePrefetchPromise, depositTokenPricePrefetchPromise,
+                abortController
+            );
 
             //Asynchronously send the node's public key to the client
             this.sendPublicKeyAsync(responseStream);
@@ -658,10 +636,10 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
             //Create swap
             const hodlInvoiceObj: HodlInvoiceInit = {
                 description: chainIdentifier+"-"+parsedBody.address,
-                cltvDelta: this.config.minCltv.add(new BN(5)).toNumber(),
+                cltvDelta:  Number(this.config.minCltv) + 5,
                 expiresAt: Date.now()+(this.config.invoiceTimeoutSeconds*1000),
                 id: parsedBody.paymentHash,
-                mtokens: amountBD.mul(new BN(1000)),
+                mtokens: amountBD * 1000n,
                 descriptionHash: parsedBody.descriptionHash
             };
             metadata.invoiceRequest = hodlInvoiceObj;
@@ -671,41 +649,29 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
             metadata.times.invoiceCreated = Date.now();
             metadata.invoiceResponse = {...hodlInvoice};
 
-            const createdSwap = new 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 expiryTimeout = (this.config.minCltv * this.config.bitcoinBlocktime / this.config.safetyFactor) - this.config.gracePeriod;
             const totalSecurityDeposit = await this.getSecurityDeposit(
                 chainIdentifier, amountBD, swapFee, expiryTimeout,
-                baseSDPromise, securityDepositPricePrefetchPromise,
+                baseSDPromise, depositToken, depositTokenPricePrefetchPromise,
                 abortController.signal, metadata
             );
             metadata.times.securityDepositCalculated = Date.now();
 
-            //Create swap data
-            createdSwap.data = await swapContract.createSwapData(
-                ChainSwapType.HTLC,
-                signer.getAddress(),
+            const createdSwap = new FromBtcLnSwapAbs(
+                chainIdentifier,
+                hodlInvoice.request,
+                parsedBody.paymentHash,
+                hodlInvoice.mtokens,
+                swapFee,
+                swapFeeInToken,
                 parsedBody.address,
                 useToken,
                 totalInToken,
-                parsedBody.paymentHash,
-                new BN(0),
-                null,
-                null,
-                0,
-                false,
-                true,
+                swapContract.getHashForHtlc(Buffer.from(parsedBody.paymentHash, "hex")).toString("hex"),
                 totalSecurityDeposit,
-                new BN(0)
+                depositToken
             );
-            abortController.signal.throwIfAborted();
             metadata.times.swapCreated = Date.now();
 
             createdSwap.metadata = metadata;
@@ -713,12 +679,12 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
             //Save the desired fee rate for the signature
             const feeRateObj = await req.paramReader.getParams({
                 feeRate: FieldTypeEnum.String
-            }).catch(e => null);
+            }).catch(() => null);
             abortController.signal.throwIfAborted();
             createdSwap.feeRate = feeRateObj?.feeRate!=null && typeof(feeRateObj.feeRate)==="string" ? feeRateObj.feeRate : null;
 
             await PluginManager.swapCreate(createdSwap);
-            await this.storageManager.saveData(parsedBody.paymentHash, null, createdSwap);
+            await this.saveSwapData(createdSwap);
 
             this.swapLogger.info(createdSwap, "REST: /createInvoice: Created swap invoice: "+hodlInvoice.request+" amount: "+amountBD.toString(10));
 
@@ -816,8 +782,7 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
                 msg: "Success",
                 data: {
                     address: signer.getAddress(),
-                    data: swap.serialize().data,
-                    nonce: swap.nonce,
+                    data: swap.data.serialize(),
                     prefix: swap.prefix,
                     timeout: swap.timeout,
                     signature: swap.signature
@@ -832,12 +797,12 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
     }
 
     async init() {
-        await this.storageManager.loadData(FromBtcLnSwapAbs);
+        await this.loadData(FromBtcLnSwapAbs);
         //Check if all swaps contain a valid amount
-        for(let swap of await this.storageManager.query([])) {
+        for(let {obj: swap} of await this.storageManager.query([])) {
             if(swap.amount==null) {
                 const parsedPR = await this.lightning.parsePaymentRequest(swap.pr);
-                swap.amount = parsedPR.mtokens.add(new BN(999)).div(new BN(1000));
+                swap.amount = (parsedPR.mtokens + 999n) / 1000n;
             }
         }
         this.subscribeToEvents();
@@ -846,7 +811,7 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
 
     getInfoData(): any {
         return {
-            minCltv: this.config.minCltv.toNumber()
+            minCltv: Number(this.config.minCltv)
         };
     }
 

package/src/swaps/frombtcln_abstract/FromBtcLnSwapAbs.ts

@@ -1,7 +1,7 @@
-import * as BN from "bn.js";
 import {SwapData} from "@atomiqlabs/base";
 import {SwapHandlerType} from "../..";
 import {FromBtcBaseSwap} from "../FromBtcBaseSwap";
+import {deserializeBN, serializeBN} from "../../utils/Utils";
 
 export enum FromBtcLnSwapState {
     REFUNDED = -2,
@@ -16,24 +16,78 @@ export enum FromBtcLnSwapState {
 export class FromBtcLnSwapAbs<T extends SwapData = SwapData> extends FromBtcBaseSwap<T, FromBtcLnSwapState> {
 
     readonly pr: string;
+    lnPaymentHash: string;
 
-    nonce: number;
+    readonly claimer: string;
+    readonly token: string;
+    readonly totalTokens: bigint;
+    readonly claimHash: string;
+    readonly securityDeposit: bigint;
+    readonly depositToken: string;
 
     secret: string;
 
-    constructor(chainIdentifier: string, pr: string, amountMtokens: BN, swapFee: BN, swapFeeInToken: BN);
+    constructor(
+        chainIdentifier: string,
+        pr: string,
+        lnPaymentHash: string,
+        amountMtokens: bigint,
+        swapFee: bigint,
+        swapFeeInToken: bigint,
+        claimer: string,
+        token: string,
+        totalTokens: bigint,
+        claimHash: string,
+        securityDeposit: bigint,
+        depositToken: string
+    );
     constructor(obj: any);
 
-    constructor(chainIdOrObj: string | any, pr?: string, amountMtokens?: BN, swapFee?: BN, swapFeeInToken?: BN) {
+    constructor(
+        chainIdOrObj: string | any,
+        pr?: string,
+        lnPaymentHash?: string,
+        amountMtokens?: bigint,
+        swapFee?: bigint,
+        swapFeeInToken?: bigint,
+        claimer?: string,
+        token?: string,
+        totalTokens?: bigint,
+        claimHash?: string,
+        securityDeposit?: bigint,
+        depositToken?: string
+    ) {
         if(typeof(chainIdOrObj)==="string") {
-            super(chainIdOrObj, amountMtokens.add(new BN(999)).div(new BN(1000)), swapFee, swapFeeInToken);
+            super(chainIdOrObj, (amountMtokens + 999n) / 1000n, swapFee, swapFeeInToken);
             this.state = FromBtcLnSwapState.CREATED;
             this.pr = pr;
+            this.lnPaymentHash = lnPaymentHash;
+            this.claimer = claimer;
+            this.token = token;
+            this.totalTokens = totalTokens;
+            this.claimHash = claimHash;
+            this.securityDeposit = securityDeposit;
+            this.depositToken = depositToken;
         } else {
             super(chainIdOrObj);
             this.pr = chainIdOrObj.pr;
+            this.lnPaymentHash = chainIdOrObj.lnPaymentHash;
+            this.claimer = chainIdOrObj.claimer;
+            this.token = chainIdOrObj.token;
+            this.totalTokens = deserializeBN(chainIdOrObj.totalTokens);
+            this.claimHash = chainIdOrObj.claimHash;
+            this.securityDeposit = deserializeBN(chainIdOrObj.securityDeposit);
             this.secret = chainIdOrObj.secret;
-            this.nonce = chainIdOrObj.nonce;
+            this.depositToken = chainIdOrObj.depositToken;
+
+            //Compatibility
+            if(this.state===FromBtcLnSwapState.CREATED && this.data!=null) {
+                this.claimer = this.data.getClaimer();
+                this.token = this.data.getToken();
+                this.totalTokens = this.data.getAmount();
+                this.claimHash = this.data.getClaimHash();
+                this.securityDeposit = this.data.getSecurityDeposit();
+            }
         }
         this.type = SwapHandlerType.FROM_BTCLN;
     }
@@ -42,12 +96,22 @@ export class FromBtcLnSwapAbs<T extends SwapData = SwapData> extends FromBtcBase
         const partialSerialized = super.serialize();
         partialSerialized.pr = this.pr;
         partialSerialized.secret = this.secret;
-        partialSerialized.nonce = this.nonce;
+        partialSerialized.lnPaymentHash = this.lnPaymentHash;
+        partialSerialized.claimer = this.claimer;
+        partialSerialized.token = this.token;
+        partialSerialized.totalTokens = serializeBN(this.totalTokens);
+        partialSerialized.claimHash = this.claimHash;
+        partialSerialized.securityDeposit = serializeBN(this.securityDeposit);
+        partialSerialized.depositToken = this.depositToken;
         return partialSerialized;
     }
 
-    getSequence(): BN {
-        return null;
+    getIdentifierHash(): string {
+        return this.lnPaymentHash;
+    }
+
+    getSequence(): bigint {
+        return 0n;
     }
 
     isInitiated(): boolean {