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

package/src/swaps/SwapHandler.ts

@@ -1,6 +1,7 @@
 import {Express, Request} from "express";
 import {ISwapPrice} from "./ISwapPrice";
 import {
+    ChainSwapType,
     ChainType,
     ClaimEvent,
     InitializeEvent, RefundEvent,
@@ -10,7 +11,6 @@ import {
 import {SwapHandlerSwap} from "./SwapHandlerSwap";
 import {PluginManager} from "../plugins/PluginManager";
 import {IIntermediaryStorage} from "../storage/IIntermediaryStorage";
-import * as BN from "bn.js";
 import {ServerParamEncoder} from "../utils/paramcoders/server/ServerParamEncoder";
 import {
     isQuoteAmountTooHigh,
@@ -39,13 +39,16 @@ export type SwapHandlerInfoType = {
 };
 
 export type SwapBaseConfig = {
-    authorizationTimeout: number,
-    bitcoinBlocktime: BN,
-    baseFee: BN,
-    feePPM: BN,
-    max: BN,
-    min: BN,
-    safetyFactor: BN,
+    initAuthorizationTimeout: number,
+    initAuthorizationTimeouts?: {
+        [chainId: string]: number
+    },
+    bitcoinBlocktime: bigint,
+    baseFee: bigint,
+    feePPM: bigint,
+    max: bigint,
+    min: bigint,
+    safetyFactor: bigint,
     swapCheckInterval: number
 };
 
@@ -61,6 +64,7 @@ export type ChainData<T extends ChainType = ChainType> = {
     swapContract: T["Contract"],
     chainEvents: T["Events"],
     allowedTokens: string[],
+    allowedDepositTokens?: string[],
     btcRelay?: T["BtcRelay"]
 }
 
@@ -77,8 +81,10 @@ export type RequestData<T> = {
 export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapHandlerSwap, S = any> {
 
     abstract readonly type: SwapHandlerType;
+    abstract readonly swapType: ChainSwapType;
 
     readonly storageManager: IIntermediaryStorage<V>;
+    readonly escrowHashMap: Map<string, V> = new Map();
     readonly path: string;
 
     readonly chains: MultichainData;
@@ -145,9 +151,9 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
         await rerun();
     }
 
-    protected abstract processInitializeEvent(chainIdentifier: string, event: InitializeEvent<SwapData>): Promise<void>;
-    protected abstract processClaimEvent(chainIdentifier: string, event: ClaimEvent<SwapData>): Promise<void>;
-    protected abstract processRefundEvent(chainIdentifier: string, event: RefundEvent<SwapData>): Promise<void>;
+    protected abstract processInitializeEvent?(chainIdentifier: string, swap: V, event: InitializeEvent<SwapData>): Promise<void>;
+    protected abstract processClaimEvent?(chainIdentifier: string, swap: V, event: ClaimEvent<SwapData>): Promise<void>;
+    protected abstract processRefundEvent?(chainIdentifier: string, swap: V, event: RefundEvent<SwapData>): Promise<void>;
 
     /**
      * Chain event processor
@@ -156,16 +162,34 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
      * @param eventData
      */
     protected async processEvent(chainIdentifier: string, eventData: SwapEvent<SwapData>[]): Promise<boolean> {
+        if(this.swapType==null) return true;
+
         for(let event of eventData) {
             if(event instanceof InitializeEvent) {
-                // this.swapLogger.debug(event, "SC: InitializeEvent: swap type: "+event.swapType);
-                await this.processInitializeEvent(chainIdentifier, event);
+                if(event.swapType!==this.swapType) continue;
+                const swap = this.getSwapByEscrowHash(chainIdentifier, event.escrowHash);
+                if(swap==null) continue;
+
+                swap.txIds.init = (event as any).meta?.txId;
+                if(swap.metadata!=null) swap.metadata.times.initTxReceived = Date.now();
+
+                await this.processInitializeEvent(chainIdentifier, swap, event);
             } else if(event instanceof ClaimEvent) {
-                // this.swapLogger.debug(event, "SC: ClaimEvent: swap secret: "+event.secret);
-                await this.processClaimEvent(chainIdentifier, event);
+                const swap = this.getSwapByEscrowHash(chainIdentifier, event.escrowHash);
+                if(swap==null) continue;
+
+                swap.txIds.claim = (event as any).meta?.txId;
+                if(swap.metadata!=null) swap.metadata.times.claimTxReceived = Date.now();
+
+                await this.processClaimEvent(chainIdentifier, swap, event);
             } else if(event instanceof RefundEvent) {
-                // this.swapLogger.debug(event, "SC: RefundEvent");
-                await this.processRefundEvent(chainIdentifier, event);
+                const swap = this.getSwapByEscrowHash(chainIdentifier, event.escrowHash);
+                if(swap==null) continue;
+
+                swap.txIds.refund = (event as any).meta?.txId;
+                if(swap.metadata!=null) swap.metadata.times.refundTxReceived = Date.now();
+
+                await this.processRefundEvent(chainIdentifier, swap, event);
             }
         }
 
@@ -187,6 +211,22 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
      */
     abstract init(): Promise<void>;
 
+    protected async loadData(ctor: new (data: any) => V) {
+        await this.storageManager.loadData(ctor);
+        //Check if all swaps contain a valid amount
+        for(let {obj: swap, hash, sequence} of await this.storageManager.query([])) {
+            if(hash!==swap.getIdentifierHash() || sequence !== (swap.getSequence() ?? 0n)) {
+                this.swapLogger.info(swap, "loadData(): Swap storage key or sequence mismatch, fixing,"+
+                    " old hash: "+hash+" new hash: "+swap.getIdentifierHash()+
+                    " old seq: "+sequence.toString(10)+" new seq: "+(swap.getSequence() ?? 0n).toString(10));
+
+                await this.storageManager.removeData(hash, sequence);
+                await this.storageManager.saveData(swap.getIdentifierHash(), swap.getSequence(), swap);
+            }
+            this.saveSwapToEscrowHashMap(swap);
+        }
+    }
+
     /**
      * Sets up required listeners for the REST server
      *
@@ -205,7 +245,7 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
      * @param hash
      * @param sequence
      */
-    protected removeSwapData(hash: string, sequence: BN): Promise<void>;
+    protected removeSwapData(hash: string, sequence: bigint): Promise<void>;
 
     /**
      * Remove swap data
@@ -215,18 +255,36 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
      */
     protected removeSwapData(swap: V, ultimateState?: S): Promise<void>;
 
-    protected async removeSwapData(hashOrSwap: string | V, sequenceOrUltimateState?: BN | S) {
+    protected async removeSwapData(hashOrSwap: string | V, sequenceOrUltimateState?: bigint | S) {
         let swap: V;
         if(typeof(hashOrSwap)==="string") {
-            if(!BN.isBN(sequenceOrUltimateState)) throw new Error("Sequence must be a BN instance!");
+            if(typeof(sequenceOrUltimateState)!=="bigint") throw new Error("Sequence must be a BN instance!");
             swap = await this.storageManager.getData(hashOrSwap, sequenceOrUltimateState);
         } else {
             swap = hashOrSwap;
-            if(sequenceOrUltimateState!=null && !BN.isBN(sequenceOrUltimateState)) await swap.setState(sequenceOrUltimateState);
+            if(sequenceOrUltimateState!=null && typeof(sequenceOrUltimateState)!=="bigint") await swap.setState(sequenceOrUltimateState);
         }
         if(swap!=null) await PluginManager.swapRemove(swap);
         this.swapLogger.debug(swap, "removeSwapData(): removing swap final state: "+swap.state);
-        await this.storageManager.removeData(swap.getHash(), swap.getSequence());
+        this.removeSwapFromEscrowHashMap(swap);
+        await this.storageManager.removeData(swap.getIdentifierHash(), swap.getSequence());
+    }
+
+    protected async saveSwapData(swap: V) {
+        this.saveSwapToEscrowHashMap(swap);
+        await this.storageManager.saveData(swap.getIdentifierHash(), swap.getSequence(), swap);
+    }
+
+    protected saveSwapToEscrowHashMap(swap: V) {
+        if(swap.data!=null) this.escrowHashMap.set(swap.chainIdentifier+"_"+swap.getEscrowHash(), swap);
+    }
+
+    protected removeSwapFromEscrowHashMap(swap: V) {
+        if(swap.data!=null) this.escrowHashMap.delete(swap.chainIdentifier+"_"+swap.data.getEscrowHash());
+    }
+
+    protected getSwapByEscrowHash(chainIdentifier: string, escrowHash: string) {
+        return this.escrowHashMap.get(chainIdentifier+"_"+escrowHash);
     }
 
     /**
@@ -236,8 +294,8 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
      * @protected
      * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
      */
-    protected checkBtcAmountInBounds(amount: BN): void {
-        if (amount.lt(this.config.min)) {
+    protected checkBtcAmountInBounds(amount: bigint): void {
+        if (amount < this.config.min) {
             throw {
                 code: 20003,
                 msg: "Amount too low!",
@@ -248,7 +306,7 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
             };
         }
 
-        if(amount.gt(this.config.max)) {
+        if(amount > this.config.max) {
             throw {
                 code: 20004,
                 msg: "Amount too high!",
@@ -297,6 +355,7 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
      */
     protected getAbortController(responseStream: ServerParamEncoder): AbortController {
         const abortController = new AbortController();
+        if(responseStream==null || responseStream.getAbortSignal==null) return abortController;
         const responseStreamAbortController = responseStream.getAbortSignal();
         responseStreamAbortController.addEventListener("abort", () => abortController.abort(responseStreamAbortController.reason));
         return abortController;
@@ -331,13 +390,16 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
     }
 
     protected getIdentifierFromEvent(event: SwapEvent<SwapData>): string {
-        if(event.sequence.isZero()) return event.paymentHash;
-        return event.paymentHash+"_"+event.sequence.toString(16);
+        const foundSwap = this.escrowHashMap.get(event.escrowHash);
+        if(foundSwap!=null) {
+            return foundSwap.getIdentifier();
+        }
+        return "UNKNOWN_"+event.escrowHash;
     }
 
     protected getIdentifierFromSwapData(swapData: SwapData): string {
-        if(swapData.getSequence().isZero()) return swapData.getHash();
-        return swapData.getHash()+"_"+swapData.getSequence().toString(16);
+        if(swapData.getSequence==null) return swapData.getClaimHash();
+        return swapData.getClaimHash()+"_"+swapData.getSequence().toString(16);
     }
 
     protected getIdentifier(swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData) {
@@ -356,8 +418,8 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
      * @param sequence
      * @throws {DefinedRuntimeError} will throw an error if sequence number is out of bounds
      */
-    protected checkSequence(sequence: BN) {
-        if(sequence.isNeg() || sequence.gte(new BN(2).pow(new BN(64)))) {
+    protected checkSequence(sequence: bigint) {
+        if(sequence < 0n || sequence >= 2n ** 64n) {
             throw {
                 code: 20060,
                 msg: "Invalid sequence"
@@ -384,14 +446,18 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
             chainTokens[chainId] = Array.from<string>(this.allowedTokens[chainId]);
         }
         return {
-            swapFeePPM: this.config.feePPM.toNumber(),
-            swapBaseFee: this.config.baseFee.toNumber(),
-            min: this.config.min.toNumber(),
-            max: this.config.max.toNumber(),
+            swapFeePPM: Number(this.config.feePPM),
+            swapBaseFee: Number(this.config.baseFee),
+            min: Number(this.config.min),
+            max: Number(this.config.max),
             data: this.getInfoData(),
             tokens: Array.from<string>(this.allowedTokens[this.chains.default]),
             chainTokens
         };
     }
 
+    protected getInitAuthorizationTimeout(chainIdentifier: string) {
+        return this.config.initAuthorizationTimeouts?.[chainIdentifier] ?? this.config.initAuthorizationTimeout;
+    }
+
 }

package/src/swaps/SwapHandlerSwap.ts

@@ -1,9 +1,16 @@
 import {Lockable, StorageObject, SwapData} from "@atomiqlabs/base";
 import {SwapHandlerType} from "./SwapHandler";
 import {PluginManager} from "../plugins/PluginManager";
-import * as BN from "bn.js";
 import {deserializeBN, serializeBN} from "../utils/Utils";
 
+function objectBigIntsToString(obj: Object) {
+    for(let key in obj) {
+        if(typeof obj[key] === "bigint") obj[key] = obj[key].toString(10);
+        if(typeof obj[key] === "object") objectBigIntsToString(obj[key]);
+    }
+    return obj;
+}
+
 export abstract class SwapHandlerSwap<T extends SwapData = SwapData, S = any> extends Lockable implements StorageObject {
 
     chainIdentifier: string;
@@ -21,20 +28,20 @@ export abstract class SwapHandlerSwap<T extends SwapData = SwapData, S = any> ex
         claim?: string,
         refund?: string
     } = {};
-    readonly swapFee: BN;
-    readonly swapFeeInToken: BN;
+    readonly swapFee: bigint;
+    readonly swapFeeInToken: bigint;
 
     prefix: string;
     timeout: string;
     signature: string;
     feeRate: string;
 
-    protected constructor(chainIdentifier: string, swapFee: BN, swapFeeInToken: BN);
+    protected constructor(chainIdentifier: string, swapFee: bigint, swapFeeInToken: bigint);
     protected constructor(obj: any);
 
-    protected constructor(obj?: any | string, swapFee?: BN, swapFeeInToken?: BN) {
+    protected constructor(obj?: any | string, swapFee?: bigint, swapFeeInToken?: bigint) {
         super();
-        if(typeof(obj)==="string" && BN.isBN(swapFee) && BN.isBN(swapFeeInToken)) {
+        if(typeof(obj)==="string" && typeof(swapFee)==="bigint" && typeof(swapFeeInToken)==="bigint") {
             this.chainIdentifier = obj;
             this.swapFee = swapFee;
             this.swapFeeInToken = swapFeeInToken;
@@ -59,7 +66,7 @@ export abstract class SwapHandlerSwap<T extends SwapData = SwapData, S = any> ex
             state: this.state,
             data: this.data==null ? null : this.data.serialize(),
             chainIdentifier: this.chainIdentifier,
-            metadata: this.metadata,
+            metadata: objectBigIntsToString(this.metadata),
             txIds: this.txIds,
             swapFee: serializeBN(this.swapFee),
             swapFeeInToken: serializeBN(this.swapFeeInToken),
@@ -81,12 +88,30 @@ export abstract class SwapHandlerSwap<T extends SwapData = SwapData, S = any> ex
         return PluginManager.swapStateChange(this, oldState);
     }
 
-    getHash(): string {
-        return this.data.getHash();
+    /**
+     * Returns the escrow hash - i.e. hash of the escrow data
+     */
+    getEscrowHash(): string {
+        return this.data.getEscrowHash();
+    }
+
+    /**
+     * Returns the claim data hash - i.e. hash passed to the claim handler
+     */
+    getClaimHash(): string {
+        return this.data.getClaimHash();
+    }
+
+    /**
+     * Returns the identification hash of the swap, usually claim data hash, but can be overriden, e.g. for
+     *  lightning swaps the identifier hash is used instead of claim data hash
+     */
+    getIdentifierHash(): string {
+        return this.getClaimHash();
     }
 
-    getSequence(): BN {
-        return this.data.getSequence();
+    getSequence(): bigint | null {
+        return this.data?.getSequence==null ? null : this.data.getSequence();
     }
 
     /**
@@ -95,9 +120,9 @@ export abstract class SwapHandlerSwap<T extends SwapData = SwapData, S = any> ex
      */
     getIdentifier(): string {
         if(this.getSequence()!=null) {
-            return this.chainIdentifier+"_"+this.getHash()+"_"+this.getSequence().toString(16);
+            return this.chainIdentifier+"_"+this.getIdentifierHash()+"_"+this.getSequence().toString(16);
         }
-        return this.getHash();
+        return this.chainIdentifier+"_"+this.getIdentifierHash();
     }
 
     /**
@@ -125,22 +150,22 @@ export abstract class SwapHandlerSwap<T extends SwapData = SwapData, S = any> ex
     /**
      * Returns the input amount paid by the user (excluding fees)
      */
-    abstract getInputAmount(): BN;
+    abstract getInputAmount(): bigint;
 
     /**
      * Returns the total input amount paid by the user (including all fees)
      */
-    abstract getTotalInputAmount(): BN;
+    abstract getTotalInputAmount(): bigint;
 
     /**
      * Returns the actual output amount paid out to the user
      */
-    abstract getOutputAmount(): BN;
+    abstract getOutputAmount(): bigint;
 
     /**
      * Returns swap fee, denominated in input & output tokens (the fee is paid only once, it is just represented here in
      *  both denomination for ease of use)
      */
-    abstract getSwapFee(): {inInputToken: BN, inOutputToken: BN};
+    abstract getSwapFee(): {inInputToken: bigint, inOutputToken: bigint};
 
 }

package/src/swaps/ToBtcBaseSwap.ts

@@ -1,23 +1,25 @@
 import {SwapHandlerSwap} from "./SwapHandlerSwap";
 import {SwapData} from "@atomiqlabs/base";
-import * as BN from "bn.js";
 import {deserializeBN, serializeBN} from "../utils/Utils";
 
 
 export abstract class ToBtcBaseSwap<T extends SwapData = SwapData, S = any> extends SwapHandlerSwap<T, S> {
 
-    amount: BN;
+    amount: bigint;
 
-    quotedNetworkFee: BN;
-    readonly quotedNetworkFeeInToken: BN;
-    realNetworkFee: BN;
-    realNetworkFeeInToken: BN;
+    quotedNetworkFee: bigint;
+    readonly quotedNetworkFeeInToken: bigint;
+    realNetworkFee: bigint;
+    realNetworkFeeInToken: bigint;
 
-    protected constructor(chainIdentifier: string, amount: BN, swapFee: BN, swapFeeInToken: BN, quotedNetworkFee: BN, quotedNetworkFeeInToken: BN);
+    protected constructor(chainIdentifier: string, amount: bigint, swapFee: bigint, swapFeeInToken: bigint, quotedNetworkFee: bigint, quotedNetworkFeeInToken: bigint);
     protected constructor(obj: any);
 
-    protected constructor(obj?: any | string, amount?: BN, swapFee?: BN, swapFeeInToken?: BN, quotedNetworkFee?: BN, quotedNetworkFeeInToken?: BN) {
-        if(typeof(obj)==="string" && BN.isBN(amount) && BN.isBN(swapFee) && BN.isBN(swapFeeInToken) && BN.isBN(quotedNetworkFee) && BN.isBN(quotedNetworkFeeInToken)) {
+    protected constructor(obj?: any | string, amount?: bigint, swapFee?: bigint, swapFeeInToken?: bigint, quotedNetworkFee?: bigint, quotedNetworkFeeInToken?: bigint) {
+        if(
+            typeof(obj)==="string" && typeof(amount)==="bigint" && typeof(swapFee)==="bigint" && typeof(swapFeeInToken)==="bigint" &&
+            typeof(quotedNetworkFee)==="bigint" && typeof(quotedNetworkFeeInToken)==="bigint"
+        ) {
             super(obj, swapFee, swapFeeInToken);
             this.amount = amount;
             this.quotedNetworkFee = quotedNetworkFee;
@@ -43,22 +45,22 @@ export abstract class ToBtcBaseSwap<T extends SwapData = SwapData, S = any> exte
         return obj;
     }
 
-    setRealNetworkFee(networkFeeInBtc: BN) {
+    setRealNetworkFee(networkFeeInBtc: bigint) {
         this.realNetworkFee = networkFeeInBtc;
         if(this.quotedNetworkFee!=null && this.quotedNetworkFeeInToken!=null) {
-            this.realNetworkFeeInToken = this.realNetworkFee.mul(this.quotedNetworkFeeInToken).div(this.quotedNetworkFee);
+            this.realNetworkFeeInToken = this.realNetworkFee * this.quotedNetworkFeeInToken / this.quotedNetworkFee;
         }
     }
 
-    getInputAmount(): BN {
-        return this.data.getAmount().sub(this.getSwapFee().inInputToken).sub(this.getQuotedNetworkFee().inInputToken);
+    getInputAmount(): bigint {
+        return this.data.getAmount() - this.getSwapFee().inInputToken - this.getQuotedNetworkFee().inInputToken;
     }
 
-    getTotalInputAmount(): BN {
+    getTotalInputAmount(): bigint {
         return this.data.getAmount();
     }
 
-    getSwapFee(): { inInputToken: BN; inOutputToken: BN } {
+    getSwapFee(): { inInputToken: bigint; inOutputToken: bigint } {
         return {inInputToken: this.swapFeeInToken, inOutputToken: this.swapFee};
     }
 
@@ -66,7 +68,7 @@ export abstract class ToBtcBaseSwap<T extends SwapData = SwapData, S = any> exte
      * Returns quoted (expected) network fee, denominated in input & output tokens (the fee is paid only once, it is
      *  just represented here in both denomination for ease of use)
      */
-    getQuotedNetworkFee(): { inInputToken: BN; inOutputToken: BN } {
+    getQuotedNetworkFee(): { inInputToken: bigint; inOutputToken: bigint } {
         return {inInputToken: this.quotedNetworkFeeInToken, inOutputToken: this.quotedNetworkFee};
     }
 
@@ -74,11 +76,11 @@ export abstract class ToBtcBaseSwap<T extends SwapData = SwapData, S = any> exte
      * Returns real network fee paid for the swap, denominated in input & output tokens (the fee is paid only once, it is
      *  just represented here in both denomination for ease of use)
      */
-    getRealNetworkFee(): { inInputToken: BN; inOutputToken: BN } {
+    getRealNetworkFee(): { inInputToken: bigint; inOutputToken: bigint } {
         return {inInputToken: this.realNetworkFeeInToken, inOutputToken: this.realNetworkFee};
     }
 
-    getOutputAmount(): BN {
+    getOutputAmount(): bigint {
         return this.amount;
     }
 

package/src/swaps/ToBtcBaseSwapHandler.ts

@@ -1,7 +1,6 @@
 import {RequestData, SwapBaseConfig, SwapHandler} from "./SwapHandler";
 import {SwapHandlerSwap} from "./SwapHandlerSwap";
 import {SwapData} from "@atomiqlabs/base";
-import * as BN from "bn.js";
 import {ServerParamEncoder} from "../utils/paramcoders/server/ServerParamEncoder";
 import {IParamReader} from "../utils/paramcoders/IParamReader";
 import {FieldTypeEnum} from "../utils/paramcoders/SchemaVerifier";
@@ -15,7 +14,8 @@ import {ToBtcRequestType} from "./tobtc_abstract/ToBtcAbs";
 import {Request} from "express";
 
 export type ToBtcBaseConfig = SwapBaseConfig & {
-    gracePeriod: BN
+    gracePeriod: bigint,
+    refundAuthorizationTimeout: number
 };
 
 export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S>, S> extends SwapHandler<V, S> {
@@ -56,9 +56,9 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
      */
     protected async preCheckAmounts(
         request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
-        requestedAmount: {input: boolean, amount: BN},
+        requestedAmount: {input: boolean, amount: bigint},
         useToken: string
-    ): Promise<{baseFee: BN, feePPM: BN}> {
+    ): Promise<{baseFee: bigint, feePPM: bigint}> {
         const res = await PluginManager.onHandlePreToBtcQuote(
             request,
             requestedAmount,
@@ -98,22 +98,22 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
      * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds,
      *  or if we don't have enough funds (getNetworkFee callback throws)
      */
-    protected async checkToBtcAmount<T extends {networkFee: BN}>(
+    protected async checkToBtcAmount<T extends {networkFee: bigint}>(
         request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
-        requestedAmount: {input: boolean, amount: BN},
-        fees: {baseFee: BN, feePPM: BN},
+        requestedAmount: {input: boolean, amount: bigint},
+        fees: {baseFee: bigint, feePPM: bigint},
         useToken: string,
-        getNetworkFee: (amount: BN) => Promise<T>,
+        getNetworkFee: (amount: bigint) => Promise<T>,
         signal: AbortSignal,
-        pricePrefetchPromise?: Promise<BN>
+        pricePrefetchPromise?: Promise<bigint>
     ): Promise<{
-        amountBD: BN,
+        amountBD: bigint,
         networkFeeData: T,
-        swapFee: BN,
-        swapFeeInToken: BN,
-        networkFee: BN,
-        networkFeeInToken: BN,
-        totalInToken: BN
+        swapFee: bigint,
+        swapFeeInToken: bigint,
+        networkFee: bigint,
+        networkFeeInToken: bigint,
+        totalInToken: bigint
     }> {
         const chainIdentifier = request.chainIdentifier;
 
@@ -152,23 +152,23 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
                         networkFee: res.networkFee.inOutputTokens,
                         networkFeeInToken: res.networkFee.inInputTokens,
                         networkFeeData: res.networkFeeData,
-                        totalInToken: res.amount.amount.add(res.swapFee.inInputTokens).add(res.networkFee.inInputTokens)
+                        totalInToken: res.amount.amount + res.swapFee.inInputTokens + res.networkFee.inInputTokens
                     }
                 }
             }
         }
 
-        let amountBD: BN;
+        let amountBD: bigint;
         let tooLow = false;
         if(requestedAmount.input) {
             amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, null, pricePrefetchPromise);
             signal.throwIfAborted();
 
             //Decrease by base fee
-            amountBD = amountBD.sub(fees.baseFee);
+            amountBD = amountBD - fees.baseFee;
 
             //If it's already smaller than minimum, set it to minimum so we can calculate the network fee
-            if(amountBD.lt(this.config.min)) {
+            if(amountBD < this.config.min) {
                 amountBD = this.config.min;
                 tooLow = true;
             }
@@ -183,19 +183,19 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
 
         if(requestedAmount.input) {
             //Decrease by network fee
-            amountBD = amountBD.sub(resp.networkFee);
+            amountBD = amountBD - resp.networkFee;
 
             //Decrease by percentage fee
-            amountBD = amountBD.mul(new BN(1000000)).div(fees.feePPM.add(new BN(1000000)));
+            amountBD = amountBD * 1000000n / (fees.feePPM + 1000000n);
 
-            const tooHigh = amountBD.gt(this.config.max.mul(new BN(105)).div(new BN(100)));
-            tooLow ||= amountBD.lt(this.config.min.mul(new BN(95)).div(new BN(100)));
+            const tooHigh = amountBD > (this.config.max * 105n / 100n);
+            tooLow ||= amountBD < (this.config.min * 95n / 100n);
             if(tooLow || tooHigh) {
                 //Compute min/max
-                let adjustedMin = this.config.min.mul(fees.feePPM.add(new BN(1000000))).div(new BN(1000000));
-                let adjustedMax = this.config.max.mul(fees.feePPM.add(new BN(1000000))).div(new BN(1000000));
-                adjustedMin = adjustedMin.add(fees.baseFee).add(resp.networkFee);
-                adjustedMax = adjustedMax.add(fees.baseFee).add(resp.networkFee);
+                let adjustedMin = this.config.min * (fees.feePPM + 1000000n) / 1000000n;
+                let adjustedMax = this.config.max * (fees.feePPM + 1000000n) / 1000000n;
+                adjustedMin = adjustedMin + fees.baseFee + resp.networkFee;
+                adjustedMax = adjustedMax + fees.baseFee + resp.networkFee;
                 const minIn = await this.swapPricing.getFromBtcSwapAmount(
                     adjustedMin, useToken, chainIdentifier, null, pricePrefetchPromise
                 );
@@ -213,7 +213,7 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
             }
         }
 
-        const swapFee = fees.baseFee.add(amountBD.mul(fees.feePPM).div(new BN(1000000)));
+        const swapFee = fees.baseFee + (amountBD * fees.feePPM / 1000000n);
 
         const networkFeeInToken = await this.swapPricing.getFromBtcSwapAmount(
             resp.networkFee, useToken, chainIdentifier, true, pricePrefetchPromise
@@ -223,7 +223,7 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
         );
         signal.throwIfAborted();
 
-        let total: BN;
+        let total: bigint;
         if(requestedAmount.input) {
             total = requestedAmount.amount;
         } else {
@@ -231,7 +231,7 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
                 requestedAmount.amount, useToken, chainIdentifier, true, pricePrefetchPromise
             );
             signal.throwIfAborted();
-            total = amountInToken.add(swapFeeInToken).add(networkFeeInToken);
+            total = amountInToken + swapFeeInToken + networkFeeInToken;
         }
 
         return {amountBD, networkFeeData: resp, swapFee, swapFeeInToken, networkFee: resp.networkFee, networkFeeInToken, totalInToken: total};
@@ -246,11 +246,11 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
      * @param abortController
      */
     protected getToBtcPrefetches(chainIdentifier: string, token: string, responseStream: ServerParamEncoder, abortController: AbortController): {
-        pricePrefetchPromise?: Promise<BN>,
+        pricePrefetchPromise?: Promise<bigint>,
         signDataPrefetchPromise?: Promise<any>
     } {
         //Fetch pricing & signature data in parallel
-        const pricePrefetchPromise: Promise<BN> = this.swapPricing.preFetchPrice(token, chainIdentifier).catch(e => {
+        const pricePrefetchPromise: Promise<bigint> = this.swapPricing.preFetchPrice(token, chainIdentifier).catch(e => {
             this.logger.error("getToBtcPrefetches(): pricePrefetch error", e);
             abortController.abort(e);
             return null;
@@ -298,7 +298,7 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
         const sigData = await swapContract.getInitSignature(
             signer,
             swapObject,
-            this.config.authorizationTimeout,
+            this.getInitAuthorizationTimeout(chainIdentifier),
             prefetchedSignData,
             feeRate
         );