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

package/src/swaps/tobtcln_abstract/ToBtcLnAbs.ts

@@ -1,9 +1,16 @@
-import * as BN from "bn.js";
 import {Express, Request, Response} from "express";
 import {ToBtcLnSwapAbs, ToBtcLnSwapState} from "./ToBtcLnSwapAbs";
 import {MultichainData, SwapHandlerType} from "../SwapHandler";
 import {ISwapPrice} from "../ISwapPrice";
-import {ChainSwapType, ClaimEvent, InitializeEvent, RefundEvent, SwapCommitStatus, SwapData} from "@atomiqlabs/base";
+import {
+    BigIntBufferUtils,
+    ChainSwapType,
+    ClaimEvent,
+    InitializeEvent,
+    RefundEvent,
+    SwapCommitStatus,
+    SwapData
+} from "@atomiqlabs/base";
 import {expressHandlerWrapper, HEX_REGEX, isDefinedRuntimeError} from "../../utils/Utils";
 import {PluginManager} from "../../plugins/PluginManager";
 import {IIntermediaryStorage} from "../../storage/IIntermediaryStorage";
@@ -23,15 +30,15 @@ import {
 } from "../../wallets/ILightningWallet";
 
 export type ToBtcLnConfig = ToBtcBaseConfig & {
-    routingFeeMultiplier: BN,
+    routingFeeMultiplier: bigint,
 
-    minSendCltv: BN,
+    minSendCltv: bigint,
 
     allowProbeFailedSwaps: boolean,
     allowShortExpiry: boolean,
 
-    minLnRoutingFeePPM?: BN,
-    minLnBaseFee?: BN,
+    minLnRoutingFeePPM?: bigint,
+    minLnBaseFee?: bigint,
 
     exactInExpiry?: number
 };
@@ -41,18 +48,18 @@ type ExactInAuthorization = {
     reqId: string,
     expiry: number,
 
-    amount: BN,
+    amount: bigint,
     initialInvoice: ParsedPaymentRequest,
 
-    quotedNetworkFeeInToken: BN,
-    swapFeeInToken: BN,
-    total: BN,
+    quotedNetworkFeeInToken: bigint,
+    swapFeeInToken: bigint,
+    total: bigint,
     confidence: number,
-    quotedNetworkFee: BN,
-    swapFee: BN,
+    quotedNetworkFee: bigint,
+    swapFee: bigint,
 
     token: string,
-    swapExpiry: BN,
+    swapExpiry: bigint,
     offerer: string,
 
     preFetchSignData: any,
@@ -67,12 +74,12 @@ type ExactInAuthorization = {
 
 export type ToBtcLnRequestType = {
     pr: string,
-    maxFee: BN,
-    expiryTimestamp: BN,
+    maxFee: bigint,
+    expiryTimestamp: bigint,
     token: string,
     offerer: string,
     exactIn?: boolean,
-    amount?: BN
+    amount?: bigint
 };
 
 /**
@@ -83,13 +90,14 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
 
     activeSubscriptions: Set<string> = new Set<string>();
     lightningLiquidityCache: {
-        liquidity: BN,
+        liquidity: bigint,
         timestamp: number
     };
 
     readonly type = SwapHandlerType.TO_BTCLN;
+    readonly swapType = ChainSwapType.HTLC;
 
-    readonly config: ToBtcLnConfig & {minTsSendCltv: BN};
+    readonly config: ToBtcLnConfig & {minTsSendCltv: bigint};
 
     readonly exactInAuths: {
         [reqId: string]: ExactInAuthorization
@@ -108,10 +116,10 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
         super(storageDirectory, path, chainData, swapPricing);
         this.lightning = lightning;
         const anyConfig = config as any;
-        anyConfig.minTsSendCltv = config.gracePeriod.add(config.bitcoinBlocktime.mul(config.minSendCltv).mul(config.safetyFactor));
+        anyConfig.minTsSendCltv = config.gracePeriod + (config.bitcoinBlocktime * config.minSendCltv * config.safetyFactor);
         this.config = anyConfig;
-        this.config.minLnRoutingFeePPM = this.config.minLnRoutingFeePPM || new BN(1000);
-        this.config.minLnBaseFee = this.config.minLnBaseFee || new BN(5);
+        this.config.minLnRoutingFeePPM = this.config.minLnRoutingFeePPM || 1000n;
+        this.config.minLnBaseFee = this.config.minLnBaseFee || 5n;
         this.config.exactInExpiry = this.config.exactInExpiry || 10*1000;
     }
 
@@ -145,7 +153,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                 } else {
                     this.swapLogger.info(swap, "processPastSwap(state=SAVED): swap committed (detected from processPastSwap), invoice: "+swap.pr);
                     await swap.setState(ToBtcLnSwapState.COMMITED);
-                    await this.storageManager.saveData(swap.data.getHash(), swap.getSequence(), swap);
+                    await this.saveSwapData(swap);
                 }
             }
             //Cancel the swaps where lightning invoice is expired
@@ -166,7 +174,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
         if (swap.state === ToBtcLnSwapState.NON_PAYABLE) {
             //Remove expired swaps (as these can already be unilaterally refunded by the client), so we don't need
             // to be able to cooperatively refund them
-            if(swapContract.isExpired(signer.getAddress(), swap.data)) {
+            if(await swapContract.isExpired(signer.getAddress(), swap.data)) {
                 this.swapLogger.info(swap, "processPastSwap(state=NON_PAYABLE): swap expired, removing swap data, invoice: "+swap.pr);
                 await this.removeSwapData(swap);
             }
@@ -191,7 +199,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
             }
         ]);
 
-        for(let swap of queriedData) {
+        for(let {obj: swap} of queriedData) {
             await this.processPastSwap(swap);
         }
     }
@@ -241,17 +249,17 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
             case "failed":
                 this.swapLogger.info(swap, "processPaymentResult(): invoice payment failed, cancelling swap, invoice: "+swap.pr);
                 await swap.setState(ToBtcLnSwapState.NON_PAYABLE);
-                await this.storageManager.saveData(swap.data.getHash(), swap.data.getSequence(), swap);
+                await this.saveSwapData(swap);
                 return;
 
             case "confirmed":
                 const {swapContract, signer} = this.getChain(swap.chainIdentifier);
 
                 swap.secret = lnPaymentStatus.secret;
-                swap.setRealNetworkFee(lnPaymentStatus.feeMtokens.div(new BN(1000)));
+                swap.setRealNetworkFee(lnPaymentStatus.feeMtokens / 1000n);
                 this.swapLogger.info(swap, "processPaymentResult(): invoice paid, secret: "+swap.secret+" realRoutingFee: "+swap.realNetworkFee.toString(10)+" invoice: "+swap.pr);
                 await swap.setState(ToBtcLnSwapState.PAID);
-                await this.storageManager.saveData(swap.data.getHash(), swap.data.getSequence(), swap);
+                await this.saveSwapData(swap);
 
                 //Check if escrow state exists
                 const isCommited = await swapContract.isCommited(swap.data);
@@ -286,7 +294,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
      * @param invoiceData
      */
     private subscribeToPayment(invoiceData: ToBtcLnSwapAbs): boolean {
-        const paymentHash = invoiceData.data.getHash();
+        const paymentHash = invoiceData.lnPaymentHash;
         if(this.activeSubscriptions.has(paymentHash)) return false;
 
         this.lightning.waitForPayment(paymentHash).then(result => {
@@ -302,11 +310,11 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
 
     private async sendLightningPayment(swap: ToBtcLnSwapAbs): Promise<void> {
         const decodedPR = await this.lightning.parsePaymentRequest(swap.pr);
-        const expiryTimestamp: BN = swap.data.getExpiry();
-        const currentTimestamp: BN = new BN(Math.floor(Date.now()/1000));
+        const expiryTimestamp: bigint = swap.data.getExpiry();
+        const currentTimestamp: bigint = BigInt(Math.floor(Date.now()/1000));
 
         //Run checks
-        const hasEnoughTimeToPay = expiryTimestamp.sub(currentTimestamp).gte(this.config.minTsSendCltv);
+        const hasEnoughTimeToPay = (expiryTimestamp - currentTimestamp) >= this.config.minTsSendCltv;
         if(!hasEnoughTimeToPay) throw {
             code: 90005,
             msg: "Not enough time to reliably pay the invoice"
@@ -320,7 +328,8 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
 
         //Compute max cltv delta
         const maxFee = swap.quotedNetworkFee;
-        const maxUsableCLTVdelta = expiryTimestamp.sub(currentTimestamp).sub(this.config.gracePeriod).div(this.config.bitcoinBlocktime.mul(this.config.safetyFactor));
+        const maxUsableCLTVdelta = (expiryTimestamp - currentTimestamp - this.config.gracePeriod)
+            / (this.config.bitcoinBlocktime * this.config.safetyFactor);
 
         //Initiate payment
         this.swapLogger.info(swap, "sendLightningPayment(): paying lightning network invoice,"+
@@ -333,8 +342,8 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
         try {
             await this.lightning.pay({
                 request: swap.pr,
-                maxFeeMtokens: maxFee.mul(new BN(1000)),
-                maxTimeoutHeight: blockHeight+maxUsableCLTVdelta.toNumber()
+                maxFeeMtokens: maxFee * 1000n,
+                maxTimeoutHeight: blockHeight+Number(maxUsableCLTVdelta)
             })
         } catch (e) {
             throw {
@@ -356,7 +365,8 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
     private async processInitialized(swap: ToBtcLnSwapAbs) {
         //Check if payment was already made
         if(swap.state===ToBtcLnSwapState.COMMITED) {
-            let lnPaymentStatus = await this.lightning.getPayment(swap.getHash());
+            if(swap.metadata!=null) swap.metadata.times.payPaymentChecked = Date.now();
+            let lnPaymentStatus = await this.lightning.getPayment(swap.lnPaymentHash);
             if(lnPaymentStatus!=null) {
                 if(lnPaymentStatus.status==="pending") {
                     //Payment still ongoing, process the result
@@ -375,7 +385,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
 
         if(swap.state===ToBtcLnSwapState.SAVED) {
             await swap.setState(ToBtcLnSwapState.COMMITED);
-            await this.storageManager.saveData(swap.data.getHash(), swap.data.getSequence(), swap);
+            await this.saveSwapData(swap);
             try {
                 await this.sendLightningPayment(swap);
             } catch (e) {
@@ -383,7 +393,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                 if(isDefinedRuntimeError(e)) {
                     if(swap.metadata!=null) swap.metadata.payError = e;
                     await swap.setState(ToBtcLnSwapState.NON_PAYABLE);
-                    await this.storageManager.saveData(swap.data.getHash(), swap.data.getSequence(), swap);
+                    await this.saveSwapData(swap);
                     return;
                 } else throw e;
             }
@@ -392,17 +402,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
         }
     }
 
-    protected async processInitializeEvent(chainIdentifier: string, event: InitializeEvent<SwapData>): Promise<void> {
-        if(event.swapType!==ChainSwapType.HTLC) return;
-
-        const paymentHash = event.paymentHash;
-
-        const swap = await this.storageManager.getData(paymentHash, event.sequence);
-        if(swap==null || swap.chainIdentifier!==chainIdentifier) return;
-
-        swap.txIds.init = (event as any).meta?.txId;
-        if(swap.metadata!=null) swap.metadata.times.txReceived = Date.now();
-
+    protected async processInitializeEvent(chainIdentifier: string, swap: ToBtcLnSwapAbs, event: InitializeEvent<SwapData>): Promise<void> {
         this.swapLogger.info(swap, "SC: InitializeEvent: swap initialized by the client, invoice: "+swap.pr);
 
         //Only process swaps in SAVED state
@@ -410,27 +410,13 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
         await this.processInitialized(swap);
     }
 
-    protected async processClaimEvent(chainIdentifier: string, event: ClaimEvent<SwapData>): Promise<void> {
-        const paymentHash = event.paymentHash;
-
-        const swap = await this.storageManager.getData(paymentHash, event.sequence);
-        if(swap==null || swap.chainIdentifier!==chainIdentifier) return;
-
-        swap.txIds.claim = (event as any).meta?.txId;
-
-        this.swapLogger.info(swap, "SC: ClaimEvent: swap claimed to us, secret: "+event.secret+" invoice: "+swap.pr);
+    protected async processClaimEvent(chainIdentifier: string, swap: ToBtcLnSwapAbs, event: ClaimEvent<SwapData>): Promise<void> {
+        this.swapLogger.info(swap, "SC: ClaimEvent: swap claimed to us, secret: "+event.result+" invoice: "+swap.pr);
 
         await this.removeSwapData(swap, ToBtcLnSwapState.CLAIMED);
     }
 
-    protected async processRefundEvent(chainIdentifier: string, event: RefundEvent<SwapData>): Promise<void> {
-        const paymentHash = event.paymentHash;
-
-        const swap = await this.storageManager.getData(paymentHash, event.sequence);
-        if(swap==null || swap.chainIdentifier!==chainIdentifier) return;
-
-        swap.txIds.refund = (event as any).meta?.txId;
-
+    protected async processRefundEvent(chainIdentifier: string, swap: ToBtcLnSwapAbs, event: RefundEvent<SwapData>): Promise<void> {
         this.swapLogger.info(swap, "SC: RefundEvent: swap refunded back to the client, invoice: "+swap.pr);
 
         await this.removeSwapData(swap, ToBtcLnSwapState.REFUNDED);
@@ -443,7 +429,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
      * @param exactIn
      * @throws {DefinedRuntimeError} will throw an error if the swap was exactIn, but amount not specified
      */
-    private checkAmount(amount: BN, exactIn: boolean): void {
+    private checkAmount(amount: bigint, exactIn: boolean): void {
         if(exactIn) {
             if(amount==null) {
                 throw {
@@ -460,8 +446,8 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
      * @param maxFee
      * @throws {DefinedRuntimeError} will throw an error if the maxFee is zero or negative
      */
-    private checkMaxFee(maxFee: BN): void {
-        if(maxFee.isNeg() || maxFee.isZero()) {
+    private checkMaxFee(maxFee: bigint): void {
+        if(maxFee <= 0) {
             throw {
                 code: 20030,
                 msg: "Invalid request body (maxFee too low)!"
@@ -472,10 +458,11 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
     /**
      * Checks and parses a payment request (bolt11 invoice), additionally also checks expiration time of the invoice
      *
+     * @param chainIdentifier
      * @param pr
      * @throws {DefinedRuntimeError} will throw an error if the pr is invalid, without amount or expired
      */
-    private async checkPaymentRequest(pr: string): Promise<{
+    private async checkPaymentRequest(chainIdentifier: string, pr: string): Promise<{
         parsedPR: ParsedPaymentRequest,
         halfConfidence: boolean
     }> {
@@ -496,7 +483,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
         };
 
         let halfConfidence = false;
-        if(parsedPR.expiryEpochMillis < Date.now()+((this.config.authorizationTimeout+(2*60))*1000) ) {
+        if(parsedPR.expiryEpochMillis < Date.now()+((this.getInitAuthorizationTimeout(chainIdentifier)+(2*60))*1000) ) {
             if(!this.config.allowShortExpiry) {
                 throw {
                     code: 20020,
@@ -521,8 +508,8 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
      * @param currentTimestamp
      * @throws {DefinedRuntimeError} will throw an error if the expiry time is too short
      */
-    private checkExpiry(expiryTimestamp: BN, currentTimestamp: BN): void {
-        const expiresTooSoon = expiryTimestamp.sub(currentTimestamp).lt(this.config.minTsSendCltv);
+    private checkExpiry(expiryTimestamp: bigint, currentTimestamp: bigint): void {
+        const expiresTooSoon = (expiryTimestamp - currentTimestamp) < this.config.minTsSendCltv;
         if(expiresTooSoon) {
             throw {
                 code: 20001,
@@ -555,7 +542,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
      * @param useCached Whether to use cached liquidity values
      * @throws {DefinedRuntimeError} will throw an error if there isn't enough liquidity
      */
-    private async checkLiquidity(amount: BN, abortSignal: AbortSignal, useCached: boolean = false): Promise<void> {
+    private async checkLiquidity(amount: bigint, abortSignal: AbortSignal, useCached: boolean = false): Promise<void> {
         if(!useCached || this.lightningLiquidityCache==null || this.lightningLiquidityCache.timestamp<Date.now()-this.LIGHTNING_LIQUIDITY_CACHE_TIMEOUT) {
             const channelBalances = await this.lightning.getLightningBalance();
             this.lightningLiquidityCache = {
@@ -563,7 +550,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                 timestamp: Date.now()
             }
         }
-        if(amount.gt(this.lightningLiquidityCache.liquidity)) {
+        if(amount > this.lightningLiquidityCache.liquidity) {
             throw {
                 code: 20002,
                 msg: "Not enough liquidity"
@@ -585,23 +572,23 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
      * @param abortSignal
      * @throws {DefinedRuntimeError} will throw an error if the destination is unreachable
      */
-    private async checkAndGetNetworkFee(amountBD: BN, maxFee: BN, expiryTimestamp: BN, currentTimestamp: BN, pr: string, metadata: any, abortSignal: AbortSignal): Promise<{
+    private async checkAndGetNetworkFee(amountBD: bigint, maxFee: bigint, expiryTimestamp: bigint, currentTimestamp: bigint, pr: string, metadata: any, abortSignal: AbortSignal): Promise<{
         confidence: number,
-        networkFee: BN
+        networkFee: bigint
     }> {
-        const maxUsableCLTV: BN = expiryTimestamp.sub(currentTimestamp).sub(this.config.gracePeriod).div(this.config.bitcoinBlocktime.mul(this.config.safetyFactor));
+        const maxUsableCLTV: bigint = (expiryTimestamp - currentTimestamp - this.config.gracePeriod) / (this.config.bitcoinBlocktime * this.config.safetyFactor);
 
         const blockHeight = await this.lightning.getBlockheight();
         abortSignal.throwIfAborted();
         metadata.times.blockheightFetched = Date.now();
 
-        const maxTimeoutBlockheight = new BN(blockHeight).add(maxUsableCLTV);
+        const maxTimeoutBlockheight = BigInt(blockHeight) + maxUsableCLTV;
 
         const req: ProbeAndRouteInit = {
             request: pr,
-            amountMtokens: amountBD.mul(new BN(1000)),
-            maxFeeMtokens: maxFee.mul(new BN(1000)),
-            maxTimeoutHeight: maxTimeoutBlockheight.toNumber()
+            amountMtokens: amountBD * 1000n,
+            maxFeeMtokens: maxFee * 1000n,
+            maxTimeoutHeight: Number(maxTimeoutBlockheight)
         };
 
         let probeOrRouteResp: ProbeAndRouteResponse = await this.lightning.probe(req);
@@ -638,19 +625,19 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                 " fee mtokens: "+probeOrRouteResp.feeMtokens.toString(10));
         }
 
-        const safeFeeTokens = probeOrRouteResp.feeMtokens.add(new BN(999)).div(new BN(1000));
+        const safeFeeTokens = (probeOrRouteResp.feeMtokens + 999n) / 1000n;
 
-        let actualRoutingFee: BN = safeFeeTokens.mul(this.config.routingFeeMultiplier);
+        let actualRoutingFee: bigint = safeFeeTokens * this.config.routingFeeMultiplier;
 
-        const minRoutingFee: BN = amountBD.mul(this.config.minLnRoutingFeePPM).div(new BN(1000000)).add(this.config.minLnBaseFee);
-        if(actualRoutingFee.lt(minRoutingFee)) {
+        const minRoutingFee: bigint = (amountBD * this.config.minLnRoutingFeePPM / 1000000n)  + this.config.minLnBaseFee;
+        if(actualRoutingFee < minRoutingFee) {
             actualRoutingFee = minRoutingFee;
-            if(actualRoutingFee.gt(maxFee)) {
+            if(actualRoutingFee > maxFee) {
                 probeOrRouteResp.confidence = 0;
             }
         }
 
-        if(actualRoutingFee.gt(maxFee)) {
+        if(actualRoutingFee > maxFee) {
             actualRoutingFee = maxFee;
         }
 
@@ -698,7 +685,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
         if(
             parsedRequest.destination!==parsedAuth.initialInvoice.destination ||
             parsedRequest.cltvDelta!==parsedAuth.initialInvoice.cltvDelta ||
-            !parsedRequest.mtokens.eq(parsedAuth.amount.mul(new BN(1000)))
+            parsedRequest.mtokens!==parsedAuth.amount * 1000n
         ) {
             throw {
                 code: 20102,
@@ -740,14 +727,15 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
 
             //Check request params
             const parsedAuth = this.checkExactInAuthorization(parsedBody.reqId);
-            const {parsedPR, halfConfidence} = await this.checkPaymentRequest(parsedBody.pr);
+            const {parsedPR, halfConfidence} = await this.checkPaymentRequest(parsedAuth.chainIdentifier, parsedBody.pr);
             await this.checkPaymentRequestMatchesInitial(parsedBody.pr, parsedAuth);
 
             const metadata = parsedAuth.metadata;
 
-            const sequence = new BN(randomBytes(8));
+            const sequence = BigIntBufferUtils.fromBuffer(randomBytes(8));
 
             const {swapContract, signer} = this.getChain(parsedAuth.chainIdentifier);
+            const claimHash = swapContract.getHashForHtlc(Buffer.from(parsedPR.id, "hex"))
 
             //Create swap data
             const payObject: SwapData = await swapContract.createSwapData(
@@ -756,15 +744,13 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                 signer.getAddress(),
                 parsedAuth.token,
                 parsedAuth.total,
-                parsedPR.id,
+                claimHash.toString("hex"),
                 sequence,
                 parsedAuth.swapExpiry,
-                new BN(0),
-                0,
                 true,
                 false,
-                new BN(0),
-                new BN(0)
+                0n,
+                0n
             );
             metadata.times.swapCreated = Date.now();
 
@@ -776,6 +762,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
             //Create swap
             const createdSwap = new ToBtcLnSwapAbs(
                 parsedAuth.chainIdentifier,
+                parsedPR.id,
                 parsedBody.pr,
                 parsedPR.mtokens,
                 parsedAuth.swapFee,
@@ -849,8 +836,8 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
              */
             const parsedBody: ToBtcLnRequestType = await req.paramReader.getParams({
                 pr: FieldTypeEnum.String,
-                maxFee: FieldTypeEnum.BN,
-                expiryTimestamp: FieldTypeEnum.BN,
+                maxFee: FieldTypeEnum.BigInt,
+                expiryTimestamp: FieldTypeEnum.BigInt,
                 token: (val: string) => val!=null &&
                         typeof(val)==="string" &&
                         this.isTokenSupported(chainIdentifier, val) ? val : null,
@@ -858,7 +845,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                         typeof(val)==="string" &&
                         swapContract.isValidAddress(val) ? val : null,
                 exactIn: FieldTypeEnum.BooleanOptional,
-                amount: FieldTypeEnum.BNOptional
+                amount: FieldTypeEnum.BigIntOptional
             });
             if (parsedBody==null) {
                 throw {
@@ -878,17 +865,17 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
 
             const responseStream = res.responseStream;
 
-            const currentTimestamp: BN = new BN(Math.floor(Date.now()/1000));
+            const currentTimestamp: bigint = BigInt(Math.floor(Date.now()/1000));
 
             //Check request params
             this.checkAmount(parsedBody.amount, parsedBody.exactIn);
             this.checkMaxFee(parsedBody.maxFee);
             this.checkExpiry(parsedBody.expiryTimestamp, currentTimestamp);
             await this.checkVaultInitialized(chainIdentifier, parsedBody.token);
-            const {parsedPR, halfConfidence} = await this.checkPaymentRequest(parsedBody.pr);
+            const {parsedPR, halfConfidence} = await this.checkPaymentRequest(chainIdentifier, parsedBody.pr);
             const requestedAmount = {
                 input: !!parsedBody.exactIn,
-                amount: !!parsedBody.exactIn ? parsedBody.amount : parsedPR.mtokens.add(new BN(999)).div(new BN(1000))
+                amount: !!parsedBody.exactIn ? parsedBody.amount : (parsedPR.mtokens + 999n) / 1000n
             };
             const fees = await this.preCheckAmounts(request, requestedAmount, useToken);
             metadata.times.requestChecked = Date.now();
@@ -911,7 +898,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                 swapFee,
                 swapFeeInToken,
                 networkFeeInToken
-            } = await this.checkToBtcAmount(request, requestedAmount, fees, useToken, async (amountBD: BN) => {
+            } = await this.checkToBtcAmount(request, requestedAmount, fees, useToken, async (amountBD: bigint) => {
                 //Check if we have enough liquidity to process the swap
                 await this.checkLiquidity(amountBD, abortController.signal, true);
                 metadata.times.liquidityChecked = Date.now();
@@ -966,7 +953,8 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                 return;
             }
 
-            const sequence = new BN(randomBytes(8));
+            const sequence = BigIntBufferUtils.fromBuffer(randomBytes(8));
+            const claimHash = swapContract.getHashForHtlc(Buffer.from(parsedPR.id, "hex"));
 
             //Create swap data
             const payObject: SwapData = await swapContract.createSwapData(
@@ -975,15 +963,13 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                 signer.getAddress(),
                 useToken,
                 totalInToken,
-                parsedPR.id,
+                claimHash.toString("hex"),
                 sequence,
                 parsedBody.expiryTimestamp,
-                new BN(0),
-                0,
                 true,
                 false,
-                new BN(0),
-                new BN(0)
+                0n,
+                0n
             );
             abortController.signal.throwIfAborted();
             metadata.times.swapCreated = Date.now();
@@ -995,6 +981,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
             //Create swap
             const createdSwap = new ToBtcLnSwapAbs(
                 chainIdentifier,
+                parsedPR.id,
                 parsedBody.pr,
                 parsedPR.mtokens,
                 swapFee,
@@ -1010,7 +997,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
             createdSwap.feeRate = sigData.feeRate;
 
             await PluginManager.swapCreate(createdSwap);
-            await this.storageManager.saveData(parsedPR.id, sequence, createdSwap);
+            await this.saveSwapData(createdSwap);
 
             this.swapLogger.info(createdSwap, "REST: /payInvoice: created swap,"+
                 " amount: "+amountBD.toString(10)+
@@ -1047,7 +1034,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                     typeof(val)==="string" &&
                     val.length===64 &&
                     HEX_REGEX.test(val) ? val: null,
-                sequence: FieldTypeEnum.BN
+                sequence: FieldTypeEnum.BigInt
             });
             if (parsedBody==null) throw {
                 code: 20100,
@@ -1062,14 +1049,14 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
             if(isSwapFound) {
                 const {signer, swapContract} = this.getChain(data.chainIdentifier);
 
-                if(swapContract.isExpired(signer.getAddress(), data.data)) throw {
+                if(await swapContract.isExpired(signer.getAddress(), data.data)) throw {
                     _httpStatus: 200,
                     code: 20010,
                     msg: "Payment expired"
                 };
 
                 if(data.state===ToBtcLnSwapState.NON_PAYABLE) {
-                    const refundSigData = await swapContract.getRefundSignature(signer, data.data, this.config.authorizationTimeout);
+                    const refundSigData = await swapContract.getRefundSignature(signer, data.data, this.config.refundAuthorizationTimeout);
 
                     //Double check the state after promise result
                     if (data.state !== ToBtcLnSwapState.NON_PAYABLE) throw {
@@ -1133,12 +1120,13 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
     }
 
     async init() {
-        await this.storageManager.loadData(ToBtcLnSwapAbs);
+        await this.loadData(ToBtcLnSwapAbs);
         //Check if all swaps contain a valid amount
-        for(let swap of await this.storageManager.query([])) {
-            if(swap.amount==null) {
+        for(let {obj: swap} of await this.storageManager.query([])) {
+            if(swap.amount==null || swap.lnPaymentHash==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;
+                swap.lnPaymentHash = parsedPR.id;
             }
         }
         this.subscribeToEvents();
@@ -1147,8 +1135,8 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
 
     getInfoData(): any {
         return {
-            minCltv: this.config.minSendCltv.toNumber(),
-            minTimestampCltv: this.config.minTsSendCltv.toNumber()
+            minCltv: Number(this.config.minSendCltv),
+            minTimestampCltv: Number(this.config.minTsSendCltv)
         };
     }
 

package/src/swaps/tobtcln_abstract/ToBtcLnSwapAbs.ts

@@ -1,7 +1,6 @@
-import * as BN from "bn.js";
 import {SwapData} from "@atomiqlabs/base";
 import {SwapHandlerType} from "../..";
-import {deserializeBN, serializeBN} from "../../utils/Utils";
+import {deserializeBN} from "../../utils/Utils";
 import {ToBtcBaseSwap} from "../ToBtcBaseSwap";
 
 export enum ToBtcLnSwapState {
@@ -16,30 +15,34 @@ export enum ToBtcLnSwapState {
 
 export class ToBtcLnSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T, ToBtcLnSwapState> {
 
+    lnPaymentHash: string;
     readonly pr: string;
 
     secret: string;
 
     constructor(
         chainIdentifier: string,
+        lnPaymentHash: string,
         pr: string,
-        amountMtokens: BN,
-        swapFee: BN,
-        swapFeeInToken: BN,
-        quotedNetworkFee: BN,
-        quotedNetworkFeeInToken: BN,
+        amountMtokens: bigint,
+        swapFee: bigint,
+        swapFeeInToken: bigint,
+        quotedNetworkFee: bigint,
+        quotedNetworkFeeInToken: bigint,
     );
     constructor(obj: any);
 
-    constructor(chainIdOrObj: string | any, pr?: string, amount?: BN, swapFee?: BN, swapFeeInToken?: BN, quotedNetworkFee?: BN, quotedNetworkFeeInToken?: BN) {
+    constructor(chainIdOrObj: string | any, lnPaymentHash?: string, pr?: string, amount?: bigint, swapFee?: bigint, swapFeeInToken?: bigint, quotedNetworkFee?: bigint, quotedNetworkFeeInToken?: bigint) {
         if(typeof(chainIdOrObj)==="string") {
-            super(chainIdOrObj, amount.add(new BN(999)).div(new BN(1000)), swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken);
+            super(chainIdOrObj, (amount + 999n) / 1000n, swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken);
             this.state = ToBtcLnSwapState.SAVED;
+            this.lnPaymentHash = lnPaymentHash;
             this.pr = pr;
         } else {
             super(chainIdOrObj);
             this.pr = chainIdOrObj.pr;
             this.secret = chainIdOrObj.secret;
+            this.lnPaymentHash = chainIdOrObj.lnPaymentHash;
 
             //Compatibility with older versions
             this.quotedNetworkFee ??= deserializeBN(chainIdOrObj.maxFee);
@@ -48,9 +51,14 @@ export class ToBtcLnSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap
         this.type = SwapHandlerType.TO_BTCLN;
     }
 
+    getIdentifierHash(): string {
+        return this.lnPaymentHash;
+    }
+
     serialize(): any {
         const partialSerialized = super.serialize();
         partialSerialized.pr = this.pr;
+        partialSerialized.lnPaymentHash = this.lnPaymentHash;
         partialSerialized.secret = this.secret;
         return partialSerialized;
     }