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

package/src/swaps/tobtc_abstract/ToBtcAbs.ts

@@ -1,5 +1,4 @@
 import {Express, Request, Response} from "express";
-import * as BN from "bn.js";
 import {ToBtcSwapAbs, ToBtcSwapState} from "./ToBtcSwapAbs";
 import {MultichainData, SwapHandlerType} from "../SwapHandler";
 import {ISwapPrice} from "../ISwapPrice";
@@ -11,8 +10,8 @@ import {
     RefundEvent,
     SwapCommitStatus,
     SwapData,
-    BitcoinRpc, 
-    BtcBlock
+    BitcoinRpc,
+    BtcBlock, BigIntBufferUtils
 } from "@atomiqlabs/base";
 import {expressHandlerWrapper, HEX_REGEX, isDefinedRuntimeError} from "../../utils/Utils";
 import {PluginManager} from "../../plugins/PluginManager";
@@ -29,9 +28,9 @@ import {IBitcoinWallet} from "../../wallets/IBitcoinWallet";
 const OUTPUT_SCRIPT_MAX_LENGTH = 200;
 
 export type ToBtcConfig = ToBtcBaseConfig & {
-    sendSafetyFactor: BN,
+    sendSafetyFactor: bigint,
 
-    minChainCltv: BN,
+    minChainCltv: bigint,
 
     networkFeeMultiplier: number,
     minConfirmations: number,
@@ -44,10 +43,10 @@ export type ToBtcConfig = ToBtcBaseConfig & {
 
 export type ToBtcRequestType = {
     address: string,
-    amount: BN,
+    amount: bigint,
     confirmationTarget: number,
     confirmations: number,
-    nonce: BN,
+    nonce: bigint,
     token: string,
     offerer: string,
     exactIn?: boolean
@@ -58,6 +57,7 @@ export type ToBtcRequestType = {
  */
 export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>  {
     readonly type = SwapHandlerType.TO_BTC;
+    readonly swapType = ChainSwapType.CHAIN_NONCED;
 
     activeSubscriptions: {[txId: string]: ToBtcSwapAbs} = {};
     bitcoinRpc: BitcoinRpc<BtcBlock>;
@@ -86,13 +86,14 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
      *
      * @param chainIdentifier
      * @param address
+     * @param confirmations
      * @param nonce
      * @param amount
      */
-    private getHash(chainIdentifier: string, address: string, nonce: BN, amount: BN): Buffer {
+    private getHash(chainIdentifier: string, address: string, confirmations: number, nonce: bigint, amount: bigint): Buffer {
         const parsedOutputScript = this.bitcoin.toOutputScript(address);
         const {swapContract} = this.getChain(chainIdentifier);
-        return swapContract.getHashForOnchain(parsedOutputScript, amount, nonce);
+        return swapContract.getHashForOnchain(parsedOutputScript, amount, confirmations, nonce);
     }
 
     /**
@@ -113,9 +114,19 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
 
         try {
             this.swapLogger.debug(swap, "tryClaimSwap(): initiate claim of swap, height: "+blockHeader.getHeight()+" utxo: "+tx.txid+":"+vout);
-            const result = await swapContract.claimWithTxData(signer, swap.data, blockHeader.getHeight(), tx, vout, null, null, false, {
-                waitForConfirmation: true
-            });
+            const result = await swapContract.claimWithTxData(
+                signer,
+                swap.data,
+                {...tx, height: blockHeader.getHeight()},
+                swap.requiredConfirmations,
+                vout,
+                null,
+                null,
+                false,
+                {
+                    waitForConfirmation: true
+                }
+            );
             this.swapLogger.info(swap, "tryClaimSwap(): swap claimed successfully, height: "+blockHeader.getHeight()+" utxo: "+tx.txid+":"+vout+" address: "+swap.address);
             if(swap.metadata!=null) swap.metadata.times.txClaimed = Date.now();
             unlock();
@@ -139,14 +150,14 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
                 } else {
                     this.swapLogger.info(swap, "processPastSwap(state=SAVED): swap committed (detected from processPastSwap), address: "+swap.address);
                     await swap.setState(ToBtcSwapState.COMMITED);
-                    await this.storageManager.saveData(swap.getHash(), swap.data.getSequence(), swap);
+                    await this.saveSwapData(swap);
                 }
                 return;
             }
         }
 
         if(swap.state===ToBtcSwapState.NON_PAYABLE || swap.state===ToBtcSwapState.SAVED) {
-            if(swapContract.isExpired(signer.getAddress(), swap.data)) {
+            if(await swapContract.isExpired(signer.getAddress(), swap.data)) {
                 this.swapLogger.info(swap, "processPastSwap(state=NON_PAYABLE|SAVED): swap expired, cancelling, address: "+swap.address);
                 await this.removeSwapData(swap, ToBtcSwapState.CANCELED);
                 return;
@@ -194,7 +205,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
             }
         ]);
 
-        for(let swap of queriedData) {
+        for(let {obj: swap} of queriedData) {
             await this.processPastSwap(swap);
         }
     }
@@ -203,7 +214,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
         tx.confirmations = tx.confirmations || 0;
 
         //Check transaction has enough confirmations
-        const hasEnoughConfirmations = tx.confirmations>=swap.data.getConfirmations();
+        const hasEnoughConfirmations = tx.confirmations>=swap.requiredConfirmations;
         if(!hasEnoughConfirmations) {
             return false;
         }
@@ -212,7 +223,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
 
         //Search for required transaction output (vout)
         const outputScript = this.bitcoin.toOutputScript(swap.address);
-        const vout = tx.outs.find(e => new BN(e.value).eq(swap.amount) && Buffer.from(e.scriptPubKey.hex, "hex").equals(outputScript));
+        const vout = tx.outs.find(e => BigInt(e.value)===swap.amount && Buffer.from(e.scriptPubKey.hex, "hex").equals(outputScript));
         if(vout==null) {
             this.swapLogger.warn(swap, "processBtcTx(): cannot find correct vout,"+
                 " required output script: "+outputScript.toString("hex")+
@@ -282,10 +293,10 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
      * @throws DefinedRuntimeError will throw an error in case there isn't enough time for us to send a BTC payout tx
      */
     protected checkExpiresTooSoon(swap: ToBtcSwapAbs): void {
-        const currentTimestamp = new BN(Math.floor(Date.now()/1000));
-        const tsDelta = swap.data.getExpiry().sub(currentTimestamp);
-        const minRequiredCLTV = this.getExpiryFromCLTV(swap.preferedConfirmationTarget, swap.data.getConfirmations());
-        const hasRequiredCLTVDelta = tsDelta.gte(minRequiredCLTV);
+        const currentTimestamp = BigInt(Math.floor(Date.now()/1000));
+        const tsDelta = swap.data.getExpiry() - currentTimestamp;
+        const minRequiredCLTV = this.getExpiryFromCLTV(swap.preferedConfirmationTarget, swap.requiredConfirmations);
+        const hasRequiredCLTVDelta = tsDelta >= minRequiredCLTV;
         if(!hasRequiredCLTVDelta) throw {
             code: 90001,
             msg: "TS delta too low",
@@ -304,8 +315,8 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
      * @private
      * @throws DefinedRuntimeError will throw an error in case the actual fee is higher than quoted fee
      */
-    protected checkCalculatedTxFee(quotedSatsPerVbyte: BN, actualSatsPerVbyte: BN): void {
-        const swapPaysEnoughNetworkFee = quotedSatsPerVbyte.gte(actualSatsPerVbyte);
+    protected checkCalculatedTxFee(quotedSatsPerVbyte: bigint, actualSatsPerVbyte: bigint): void {
+        const swapPaysEnoughNetworkFee = quotedSatsPerVbyte >= actualSatsPerVbyte;
         if(!swapPaysEnoughNetworkFee) throw {
             code: 90003,
             msg: "Fee changed too much!",
@@ -332,15 +343,15 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
             if(swap.metadata!=null) swap.metadata.times.payCLTVChecked = Date.now();
 
             const satsPerVbyte = await this.bitcoin.getFeeRate();
-            this.checkCalculatedTxFee(swap.satsPerVbyte, new BN(satsPerVbyte));
+            this.checkCalculatedTxFee(swap.satsPerVbyte, BigInt(satsPerVbyte));
             if(swap.metadata!=null) swap.metadata.times.payChainFee = Date.now();
 
             const signResult = await this.bitcoin.getSignedTransaction(
                 swap.address,
-                swap.amount.toNumber(),
+                Number(swap.amount),
                 satsPerVbyte,
-                swap.data.getEscrowNonce(),
-                swap.satsPerVbyte.toNumber()
+                swap.nonce,
+                Number(swap.satsPerVbyte)
             );
             if(signResult==null) throw {
                 code: 90002,
@@ -349,17 +360,17 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
             if(swap.metadata!=null) swap.metadata.times.paySignPSBT = Date.now();
 
             this.swapLogger.debug(swap, "sendBitcoinPayment(): signed raw transaction: "+signResult.raw);
-            swap.txId = signResult.tx.getId();
-            swap.setRealNetworkFee(new BN(signResult.networkFee));
+            swap.txId = signResult.tx.id;
+            swap.setRealNetworkFee(BigInt(signResult.networkFee));
             await swap.setState(ToBtcSwapState.BTC_SENDING);
-            await this.storageManager.saveData(swap.getHash(), swap.getSequence(), swap);
+            await this.saveSwapData(swap);
 
             await this.bitcoin.sendRawTransaction(signResult.raw);
             if(swap.metadata!=null) swap.metadata.times.payTxSent = Date.now();
-            this.swapLogger.info(swap, "sendBitcoinPayment(): btc transaction generated, signed & broadcasted, txId: "+signResult.tx.getId()+" address: "+swap.address);
+            this.swapLogger.info(swap, "sendBitcoinPayment(): btc transaction generated, signed & broadcasted, txId: "+swap.txId+" address: "+swap.address);
 
             await swap.setState(ToBtcSwapState.BTC_SENT);
-            await this.storageManager.saveData(swap.getHash(), swap.getSequence(), swap);
+            await this.saveSwapData(swap);
         });
     }
 
@@ -381,14 +392,14 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
             } else {
                 this.swapLogger.info(swap, "processInitialized(state=BTC_SENDING): btc transaction found, advancing to BTC_SENT state, txId: "+swap.txId+" address: "+swap.address);
                 await swap.setState(ToBtcSwapState.BTC_SENT);
-                await this.storageManager.saveData(swap.getHash(), swap.data.getSequence(), swap);
+                await this.saveSwapData(swap);
             }
         }
 
         if(swap.state===ToBtcSwapState.SAVED) {
             this.swapLogger.info(swap, "processInitialized(state=SAVED): advancing to COMMITED state, address: "+swap.address);
             await swap.setState(ToBtcSwapState.COMMITED);
-            await this.storageManager.saveData(swap.getHash(), swap.data.getSequence(), swap);
+            await this.saveSwapData(swap);
         }
 
         if(swap.state===ToBtcSwapState.COMMITED) {
@@ -405,7 +416,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
                     this.swapLogger.error(swap, "processInitialized(state=COMMITED): setting state to NON_PAYABLE due to send bitcoin payment error", e);
                     if(swap.metadata!=null) swap.metadata.payError = e;
                     await swap.setState(ToBtcSwapState.NON_PAYABLE);
-                    await this.storageManager.saveData(swap.getHash(), swap.data.getSequence(), swap);
+                    await this.saveSwapData(swap);
                 } else {
                     this.swapLogger.error(swap, "processInitialized(state=COMMITED): send bitcoin payment error", e);
                     throw e;
@@ -420,30 +431,13 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
         this.subscribeToPayment(swap);
     }
 
-    protected async processInitializeEvent(chainIdentifier: string, event: InitializeEvent<SwapData>): Promise<void> {
-        if(event.swapType!==ChainSwapType.CHAIN_NONCED) 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: ToBtcSwapAbs, event: InitializeEvent<SwapData>): Promise<void> {
         this.swapLogger.info(swap, "SC: InitializeEvent: swap initialized by the client, address: "+swap.address);
 
         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;
-
+    protected async processClaimEvent(chainIdentifier: string, swap: ToBtcSwapAbs, event: ClaimEvent<SwapData>): Promise<void> {
         this.swapLogger.info(swap, "SC: ClaimEvent: swap successfully claimed to us, address: "+swap.address);
 
         //Also remove transaction from active subscriptions
@@ -451,14 +445,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
         await this.removeSwapData(swap, ToBtcSwapState.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: ToBtcSwapAbs, event: RefundEvent<SwapData>): Promise<void> {
         this.swapLogger.info(swap, "SC: RefundEvent: swap successfully refunded by the user, address: "+swap.address);
 
         //Also remove transaction from active subscriptions
@@ -472,14 +459,14 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
      * @param confirmationTarget
      * @param confirmations
      */
-    protected getExpiryFromCLTV(confirmationTarget: number, confirmations: number): BN {
+    protected getExpiryFromCLTV(confirmationTarget: number, confirmations: number): bigint {
         //Blocks = 10 + (confirmations + confirmationTarget)*2
         //Time = 3600 + (600*blocks*2)
-        const cltv = this.config.minChainCltv.add(
-            new BN(confirmations).add(new BN(confirmationTarget)).mul(this.config.sendSafetyFactor)
+        const cltv = this.config.minChainCltv + (
+            BigInt(confirmations + confirmationTarget) * this.config.sendSafetyFactor
         );
 
-        return this.config.gracePeriod.add(this.config.bitcoinBlocktime.mul(cltv).mul(this.config.safetyFactor));
+        return this.config.gracePeriod + (this.config.bitcoinBlocktime * cltv * this.config.safetyFactor);
     }
 
     /**
@@ -488,17 +475,16 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
      * @param nonce
      * @throws {DefinedRuntimeError} will throw an error if the nonce is invalid
      */
-    private checkNonceValid(nonce: BN): void {
-        if(nonce.isNeg() || nonce.gte(new BN(2).pow(new BN(64)))) throw {
+    private checkNonceValid(nonce: bigint): void {
+        if(nonce < 0 || nonce >= (2n ** 64n)) throw {
             code: 20021,
             msg: "Invalid request body (nonce - cannot be parsed)"
         };
 
-        const nonceBuffer = Buffer.from(nonce.toArray("be", 8));
-        const firstPart = new BN(nonceBuffer.slice(0, 5), "be");
+        const firstPart = nonce >> 24n;
 
-        const maxAllowedValue = new BN(Math.floor(Date.now()/1000)-600000000);
-        if(firstPart.gt(maxAllowedValue)) throw {
+        const maxAllowedValue = BigInt(Math.floor(Date.now()/1000)-600000000);
+        if(firstPart > maxAllowedValue) throw {
             code: 20022,
             msg: "Invalid request body (nonce - too high)"
         };
@@ -568,9 +554,9 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
      * @param swap
      * @throws {DefinedRuntimeError} will throw an error if the swap is expired
      */
-    protected checkExpired(swap: ToBtcSwapAbs) {
+    protected async checkExpired(swap: ToBtcSwapAbs) {
         const {swapContract, signer} = this.getChain(swap.chainIdentifier);
-        const isExpired = swapContract.isExpired(signer.getAddress(), swap.data);
+        const isExpired = await swapContract.isExpired(signer.getAddress(), swap.data);
         if(isExpired) throw {
             _httpStatus: 200,
             code: 20010,
@@ -585,8 +571,8 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
      * @param amount
      * @throws {DefinedRuntimeError} will throw an error if there are not enough BTC funds
      */
-    private async checkAndGetNetworkFee(address: string, amount: BN): Promise<{ networkFee: BN, satsPerVbyte: BN }> {
-        let chainFeeResp = await this.bitcoin.estimateFee(address, amount.toNumber(), null, this.config.networkFeeMultiplier);
+    private async checkAndGetNetworkFee(address: string, amount: bigint): Promise<{ networkFee: bigint, satsPerVbyte: bigint }> {
+        let chainFeeResp = await this.bitcoin.estimateFee(address, Number(amount), null, this.config.networkFeeMultiplier);
 
         const hasEnoughFunds = chainFeeResp!=null;
         if(!hasEnoughFunds) throw {
@@ -595,8 +581,8 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
         };
 
         return {
-            networkFee: new BN(chainFeeResp.networkFee),
-            satsPerVbyte: new BN(chainFeeResp.satsPerVbyte)
+            networkFee: BigInt(chainFeeResp.networkFee),
+            satsPerVbyte: BigInt(chainFeeResp.satsPerVbyte)
         };
     }
 
@@ -628,10 +614,10 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
              */
             const parsedBody: ToBtcRequestType = await req.paramReader.getParams({
                 address: FieldTypeEnum.String,
-                amount: FieldTypeEnum.BN,
+                amount: FieldTypeEnum.BigInt,
                 confirmationTarget: FieldTypeEnum.Number,
                 confirmations: FieldTypeEnum.Number,
-                nonce: FieldTypeEnum.BN,
+                nonce: FieldTypeEnum.BigInt,
                 token: (val: string) => val!=null &&
                         typeof(val)==="string" &&
                         this.isTokenSupported(chainIdentifier, val) ? val : null,
@@ -678,7 +664,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
                 swapFee,
                 swapFeeInToken,
                 networkFeeInToken
-            } = await this.checkToBtcAmount(request, requestedAmount, fees, useToken, async (amount: BN) => {
+            } = await this.checkToBtcAmount(request, requestedAmount, fees, useToken, async (amount: bigint) => {
                 metadata.times.amountsChecked = Date.now();
                 const resp = await this.checkAndGetNetworkFee(parsedBody.address, amount);
                 metadata.times.chainFeeCalculated = Date.now();
@@ -686,14 +672,14 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
             }, abortController.signal, pricePrefetchPromise);
             metadata.times.priceCalculated = Date.now();
 
-            const paymentHash = this.getHash(chainIdentifier, parsedBody.address, parsedBody.nonce, amountBD).toString("hex");
+            const paymentHash = this.getHash(chainIdentifier, parsedBody.address, parsedBody.confirmations, parsedBody.nonce, amountBD).toString("hex");
 
             //Add grace period another time, so the user has 1 hour to commit
-            const expirySeconds = this.getExpiryFromCLTV(parsedBody.confirmationTarget, parsedBody.confirmations).add(new BN(this.config.gracePeriod));
-            const currentTimestamp = new BN(Math.floor(Date.now()/1000));
-            const minRequiredExpiry = currentTimestamp.add(expirySeconds);
+            const expirySeconds = this.getExpiryFromCLTV(parsedBody.confirmationTarget, parsedBody.confirmations) + this.config.gracePeriod;
+            const currentTimestamp = BigInt(Math.floor(Date.now()/1000));
+            const minRequiredExpiry = currentTimestamp + expirySeconds;
 
-            const sequence = new BN(randomBytes(8));
+            const sequence = BigIntBufferUtils.fromBuffer(randomBytes(8));
             const payObject: SwapData = await swapContract.createSwapData(
                 ChainSwapType.CHAIN_NONCED,
                 parsedBody.offerer,
@@ -703,12 +689,10 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
                 paymentHash,
                 sequence,
                 minRequiredExpiry,
-                parsedBody.nonce,
-                parsedBody.confirmations,
                 true,
                 false,
-                new BN(0),
-                new BN(0)
+                0n,
+                0n
             );
             abortController.signal.throwIfAborted();
             metadata.times.swapCreated = Date.now();
@@ -726,6 +710,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
                 networkFeeInToken,
                 networkFeeData.satsPerVbyte,
                 parsedBody.nonce,
+                parsedBody.confirmations,
                 parsedBody.confirmationTarget
             );
             createdSwap.data = payObject;
@@ -736,7 +721,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
             createdSwap.feeRate = sigData.feeRate;
 
             await PluginManager.swapCreate(createdSwap);
-            await this.storageManager.saveData(paymentHash, sequence, createdSwap);
+            await this.saveSwapData(createdSwap);
 
             this.swapLogger.info(createdSwap, "REST: /payInvoice: created swap address: "+createdSwap.address+" amount: "+amountBD.toString(10));
 
@@ -749,7 +734,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
                     satsPervByte: networkFeeData.satsPerVbyte.toString(10),
                     networkFee: networkFeeInToken.toString(10),
                     swapFee: swapFeeInToken.toString(10),
-                    totalFee: swapFeeInToken.add(networkFeeInToken).toString(10),
+                    totalFee: (swapFeeInToken + networkFeeInToken).toString(10),
                     total: totalInToken.toString(10),
                     minRequiredExpiry: minRequiredExpiry.toString(10),
 
@@ -771,9 +756,8 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
             const parsedBody = verifySchema({...req.body, ...req.query}, {
                 paymentHash: (val: string) => val!=null &&
                     typeof(val)==="string" &&
-                    val.length===64 &&
                     HEX_REGEX.test(val) ? val: null,
-                sequence: FieldTypeEnum.BN
+                sequence: FieldTypeEnum.BigInt
             });
             if (parsedBody==null) throw {
                 code: 20100,
@@ -789,7 +773,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
                 msg: "Payment not found"
             };
 
-            this.checkExpired(payment);
+            await this.checkExpired(payment);
 
             if (payment.state === ToBtcSwapState.COMMITED) throw {
                 _httpStatus: 200,
@@ -815,7 +799,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
                     msg: "Not committed"
                 };
 
-                const refundResponse = await swapContract.getRefundSignature(signer, payment.data, this.config.authorizationTimeout);
+                const refundResponse = await swapContract.getRefundSignature(signer, payment.data, this.config.refundAuthorizationTimeout);
 
                 //Double check the state after promise result
                 if (payment.state !== ToBtcSwapState.NON_PAYABLE) throw {
@@ -869,14 +853,14 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
     }
 
     async init() {
-        await this.storageManager.loadData(ToBtcSwapAbs);
+        await this.loadData(ToBtcSwapAbs);
         this.subscribeToEvents();
         await PluginManager.serviceInitialize(this);
     }
 
     getInfoData(): any {
         return {
-            minCltv: this.config.minChainCltv.toNumber(),
+            minCltv: Number(this.config.minChainCltv),
 
             minConfirmations: this.config.minConfirmations,
             maxConfirmations: this.config.maxConfirmations,

package/src/swaps/tobtc_abstract/ToBtcSwapAbs.ts

@@ -1,8 +1,7 @@
-import * as BN from "bn.js";
 import {SwapData} from "@atomiqlabs/base";
 import {SwapHandlerType} from "../..";
 import {ToBtcBaseSwap} from "../ToBtcBaseSwap";
-import {deserializeBN, serializeBN} from "../../utils/Utils";
+import {deserializeBN} from "../../utils/Utils";
 
 export enum ToBtcSwapState {
     REFUNDED = -3,
@@ -18,8 +17,9 @@ export enum ToBtcSwapState {
 export class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T, ToBtcSwapState> {
 
     readonly address: string;
-    readonly satsPerVbyte: BN;
-    readonly nonce: BN;
+    readonly satsPerVbyte: bigint;
+    readonly nonce: bigint;
+    readonly requiredConfirmations: number;
     readonly preferedConfirmationTarget: number;
 
     txId: string;
@@ -27,13 +27,14 @@ export class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T
     constructor(
         chainIdentifier: string,
         address: string,
-        amount: BN,
-        swapFee: BN,
-        swapFeeInToken: BN,
-        networkFee: BN,
-        networkFeeInToken: BN,
-        satsPerVbyte: BN,
-        nonce: BN,
+        amount: bigint,
+        swapFee: bigint,
+        swapFeeInToken: bigint,
+        networkFee: bigint,
+        networkFeeInToken: bigint,
+        satsPerVbyte: bigint,
+        nonce: bigint,
+        requiredConfirmations: number,
         preferedConfirmationTarget: number
     );
     constructor(obj: any);
@@ -41,13 +42,14 @@ export class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T
     constructor(
         chainIdOrObj: string | any,
         address?: string,
-        amount?: BN,
-        swapFee?: BN,
-        swapFeeInToken?: BN,
-        networkFee?: BN,
-        networkFeeInToken?: BN,
-        satsPerVbyte?: BN,
-        nonce?: BN,
+        amount?: bigint,
+        swapFee?: bigint,
+        swapFeeInToken?: bigint,
+        networkFee?: bigint,
+        networkFeeInToken?: bigint,
+        satsPerVbyte?: bigint,
+        nonce?: bigint,
+        requiredConfirmations?: number,
         preferedConfirmationTarget?: number
     ) {
         if(typeof(chainIdOrObj)==="string") {
@@ -56,12 +58,14 @@ export class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T
             this.address = address;
             this.satsPerVbyte = satsPerVbyte;
             this.nonce = nonce;
+            this.requiredConfirmations = requiredConfirmations;
             this.preferedConfirmationTarget = preferedConfirmationTarget;
         } else {
             super(chainIdOrObj);
             this.address = chainIdOrObj.address;
-            this.satsPerVbyte = new BN(chainIdOrObj.satsPerVbyte);
-            this.nonce = new BN(chainIdOrObj.nonce);
+            this.satsPerVbyte = BigInt(chainIdOrObj.satsPerVbyte);
+            this.nonce = BigInt(chainIdOrObj.nonce);
+            this.requiredConfirmations = chainIdOrObj.requiredConfirmations;
             this.preferedConfirmationTarget = chainIdOrObj.preferedConfirmationTarget;
 
             this.txId = chainIdOrObj.txId;
@@ -76,6 +80,7 @@ export class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T
         const partialSerialized = super.serialize();
         partialSerialized.address = this.address;
         partialSerialized.satsPerVbyte = this.satsPerVbyte.toString(10);
+        partialSerialized.requiredConfirmations = this.requiredConfirmations;
         partialSerialized.nonce = this.nonce.toString(10);
         partialSerialized.preferedConfirmationTarget = this.preferedConfirmationTarget;
         partialSerialized.txId = this.txId;