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

package/dist/swaps/FromBtcLnBaseSwapHandler.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcLnBaseSwapHandler = void 0;
 const FromBtcBaseSwapHandler_1 = require("./FromBtcBaseSwapHandler");
@@ -24,22 +15,20 @@ class FromBtcLnBaseSwapHandler extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapH
      * @param signal
      * @throws {DefinedRuntimeError} will throw an error if there isn't enough inbound liquidity to receive the LN payment
      */
-    checkInboundLiquidity(amountBD, channelsPrefetch, signal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const channelsResponse = yield channelsPrefetch;
-            signal.throwIfAborted();
-            let hasEnoughInboundLiquidity = false;
-            channelsResponse.forEach(channel => {
-                if (channel.remoteBalance.gte(amountBD))
-                    hasEnoughInboundLiquidity = true;
-            });
-            if (!hasEnoughInboundLiquidity) {
-                throw {
-                    code: 20050,
-                    msg: "Not enough LN inbound liquidity"
-                };
-            }
+    async checkInboundLiquidity(amountBD, channelsPrefetch, signal) {
+        const channelsResponse = await channelsPrefetch;
+        signal.throwIfAborted();
+        let hasEnoughInboundLiquidity = false;
+        channelsResponse.forEach(channel => {
+            if (channel.remoteBalance >= amountBD)
+                hasEnoughInboundLiquidity = true;
         });
+        if (!hasEnoughInboundLiquidity) {
+            throw {
+                code: 20050,
+                msg: "Not enough LN inbound liquidity"
+            };
+        }
     }
     /**
      * Starts LN channels pre-fetch

package/dist/swaps/ISwapPrice.d.ts

@@ -1,4 +1,3 @@
-import * as BN from "bn.js";
 export type ISwapPriceCoinsMap<T extends {
     decimals: number;
 }> = {
@@ -18,9 +17,9 @@ export declare abstract class ISwapPrice<T extends {
      *
      * @param tokenData
      */
-    protected abstract getPrice(tokenData: T): Promise<BN>;
+    protected abstract getPrice(tokenData: T): Promise<bigint>;
     getTokenData(tokenAddress: string, chainId: string): T;
-    preFetchPrice(token: string, chainId: string): Promise<BN>;
+    preFetchPrice(token: string, chainId: string): Promise<bigint>;
     /**
      * Returns amount of satoshis that are equivalent to {fromAmount} of {fromToken}
      *
@@ -30,7 +29,7 @@ export declare abstract class ISwapPrice<T extends {
      * @param roundUp Whether result should be rounded up
      * @param preFetch Price pre-fetch promise returned from preFetchPrice()
      */
-    getToBtcSwapAmount(fromAmount: BN, fromToken: string, tokenChainIdentification: string, roundUp?: boolean, preFetch?: Promise<BN>): Promise<BN>;
+    getToBtcSwapAmount(fromAmount: bigint, fromToken: string, tokenChainIdentification: string, roundUp?: boolean, preFetch?: Promise<bigint>): Promise<bigint>;
     /**
      * Returns amount of {toToken} that are equivalent to {fromAmount} satoshis
      *
@@ -40,5 +39,5 @@ export declare abstract class ISwapPrice<T extends {
      * @param roundUp Whether result should be rounded up
      * @param preFetch Price pre-fetch promise returned from preFetchPrice()
      */
-    getFromBtcSwapAmount(fromAmount: BN, toToken: string, tokenChainIdentification: string, roundUp?: boolean, preFetch?: Promise<BN>): Promise<BN>;
+    getFromBtcSwapAmount(fromAmount: bigint, toToken: string, tokenChainIdentification: string, roundUp?: boolean, preFetch?: Promise<bigint>): Promise<bigint>;
 }

package/dist/swaps/ISwapPrice.js

@@ -1,16 +1,6 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ISwapPrice = void 0;
-const BN = require("bn.js");
 class ISwapPrice {
     constructor(coinsMap) {
         this.coinsMap = coinsMap;
@@ -38,16 +28,10 @@ class ISwapPrice {
      * @param roundUp Whether result should be rounded up
      * @param preFetch Price pre-fetch promise returned from preFetchPrice()
      */
-    getToBtcSwapAmount(fromAmount, fromToken, tokenChainIdentification, roundUp, preFetch) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const coin = this.getTokenData(fromToken, tokenChainIdentification);
-            const price = (preFetch == null ? null : yield preFetch) || (yield this.getPrice(coin));
-            return fromAmount
-                .mul(price)
-                .div(new BN(10).pow(new BN(coin.decimals)))
-                .add(roundUp ? new BN(999999) : new BN(0))
-                .div(new BN(1000000));
-        });
+    async getToBtcSwapAmount(fromAmount, fromToken, tokenChainIdentification, roundUp, preFetch) {
+        const coin = this.getTokenData(fromToken, tokenChainIdentification);
+        const price = (preFetch == null ? null : await preFetch) || await this.getPrice(coin);
+        return ((fromAmount * price * (10n ** BigInt(coin.decimals))) + (roundUp ? 999999n : 0n)) / 1000000n;
     }
     /**
      * Returns amount of {toToken} that are equivalent to {fromAmount} satoshis
@@ -58,16 +42,10 @@ class ISwapPrice {
      * @param roundUp Whether result should be rounded up
      * @param preFetch Price pre-fetch promise returned from preFetchPrice()
      */
-    getFromBtcSwapAmount(fromAmount, toToken, tokenChainIdentification, roundUp, preFetch) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const coin = this.getTokenData(toToken, tokenChainIdentification);
-            const price = (preFetch == null ? null : yield preFetch) || (yield this.getPrice(coin));
-            return fromAmount
-                .mul(new BN(10).pow(new BN(coin.decimals)))
-                .mul(new BN(1000000)) //To usat
-                .add(roundUp ? price.sub(new BN(1)) : new BN(0))
-                .div(price);
-        });
+    async getFromBtcSwapAmount(fromAmount, toToken, tokenChainIdentification, roundUp, preFetch) {
+        const coin = this.getTokenData(toToken, tokenChainIdentification);
+        const price = (preFetch == null ? null : await preFetch) || await this.getPrice(coin);
+        return ((fromAmount * (10n ** BigInt(coin.decimals)) * 1000000n) + (roundUp ? price - 1n : 0n)) / price;
     }
 }
 exports.ISwapPrice = ISwapPrice;

package/dist/swaps/SwapHandler.d.ts

@@ -1,9 +1,8 @@
 import { Express, Request } from "express";
 import { ISwapPrice } from "./ISwapPrice";
-import { ChainType, ClaimEvent, InitializeEvent, RefundEvent, SwapData, SwapEvent } from "@atomiqlabs/base";
+import { ChainSwapType, ChainType, ClaimEvent, InitializeEvent, RefundEvent, SwapData, SwapEvent } from "@atomiqlabs/base";
 import { SwapHandlerSwap } from "./SwapHandlerSwap";
 import { IIntermediaryStorage } from "../storage/IIntermediaryStorage";
-import * as BN from "bn.js";
 import { ServerParamEncoder } from "../utils/paramcoders/server/ServerParamEncoder";
 import { IParamReader } from "../utils/paramcoders/IParamReader";
 export declare enum SwapHandlerType {
@@ -26,13 +25,16 @@ export type SwapHandlerInfoType = {
     data?: any;
 };
 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;
 };
 export type MultichainData = {
@@ -46,6 +48,7 @@ export type ChainData<T extends ChainType = ChainType> = {
     swapContract: T["Contract"];
     chainEvents: T["Events"];
     allowedTokens: string[];
+    allowedDepositTokens?: string[];
     btcRelay?: T["BtcRelay"];
 };
 export type RequestData<T> = {
@@ -61,7 +64,9 @@ export type RequestData<T> = {
  */
 export declare 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>;
     readonly path: string;
     readonly chains: MultichainData;
     readonly allowedTokens: {
@@ -89,9 +94,9 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S>
      * Starts the watchdog checking past swaps for expiry or claim eligibility.
      */
     startWatchdog(): Promise<void>;
-    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
      *
@@ -107,6 +112,7 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S>
      * Initializes swap handler, loads data and subscribes to chain events
      */
     abstract init(): Promise<void>;
+    protected loadData(ctor: new (data: any) => V): Promise<void>;
     /**
      * Sets up required listeners for the REST server
      *
@@ -123,7 +129,7 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S>
      * @param hash
      * @param sequence
      */
-    protected removeSwapData(hash: string, sequence: BN): Promise<void>;
+    protected removeSwapData(hash: string, sequence: bigint): Promise<void>;
     /**
      * Remove swap data
      *
@@ -131,6 +137,10 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S>
      * @param ultimateState set the ultimate state of the swap before removing
      */
     protected removeSwapData(swap: V, ultimateState?: S): Promise<void>;
+    protected saveSwapData(swap: V): Promise<void>;
+    protected saveSwapToEscrowHashMap(swap: V): void;
+    protected removeSwapFromEscrowHashMap(swap: V): void;
+    protected getSwapByEscrowHash(chainIdentifier: string, escrowHash: string): V;
     /**
      * Checks whether the bitcoin amount is within specified min/max bounds
      *
@@ -138,7 +148,7 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S>
      * @protected
      * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
      */
-    protected checkBtcAmountInBounds(amount: BN): void;
+    protected checkBtcAmountInBounds(amount: bigint): void;
     /**
      * Handles and throws plugin errors
      *
@@ -170,7 +180,7 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S>
      * @param sequence
      * @throws {DefinedRuntimeError} will throw an error if sequence number is out of bounds
      */
-    protected checkSequence(sequence: BN): void;
+    protected checkSequence(sequence: bigint): void;
     /**
      * Checks whether a given token is supported on a specified chain
      *
@@ -180,4 +190,5 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S>
      */
     protected isTokenSupported(chainId: string, token: string): boolean;
     getInfo(): SwapHandlerInfoType;
+    protected getInitAuthorizationTimeout(chainIdentifier: string): number;
 }

package/dist/swaps/SwapHandler.js

@@ -1,19 +1,9 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwapHandler = exports.SwapHandlerType = void 0;
 const base_1 = require("@atomiqlabs/base");
 const SwapHandlerSwap_1 = require("./SwapHandlerSwap");
 const PluginManager_1 = require("../plugins/PluginManager");
-const BN = require("bn.js");
 const IPlugin_1 = require("../plugins/IPlugin");
 var SwapHandlerType;
 (function (SwapHandlerType) {
@@ -29,6 +19,7 @@ var SwapHandlerType;
  */
 class SwapHandler {
     constructor(storageDirectory, path, chainsData, swapPricing) {
+        this.escrowHashMap = new Map();
         this.logger = {
             debug: (msg, ...args) => console.debug("SwapHandler(" + this.type + "): " + msg, ...args),
             info: (msg, ...args) => console.info("SwapHandler(" + this.type + "): " + msg, ...args),
@@ -66,15 +57,13 @@ class SwapHandler {
     /**
      * Starts the watchdog checking past swaps for expiry or claim eligibility.
      */
-    startWatchdog() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let rerun;
-            rerun = () => __awaiter(this, void 0, void 0, function* () {
-                yield this.processPastSwaps().catch(e => console.error(e));
-                setTimeout(rerun, this.config.swapCheckInterval);
-            });
-            yield rerun();
-        });
+    async startWatchdog() {
+        let rerun;
+        rerun = async () => {
+            await this.processPastSwaps().catch(e => console.error(e));
+            setTimeout(rerun, this.config.swapCheckInterval);
+        };
+        await rerun();
     }
     /**
      * Chain event processor
@@ -82,24 +71,41 @@ class SwapHandler {
      * @param chainIdentifier
      * @param eventData
      */
-    processEvent(chainIdentifier, eventData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let event of eventData) {
-                if (event instanceof base_1.InitializeEvent) {
-                    // this.swapLogger.debug(event, "SC: InitializeEvent: swap type: "+event.swapType);
-                    yield this.processInitializeEvent(chainIdentifier, event);
-                }
-                else if (event instanceof base_1.ClaimEvent) {
-                    // this.swapLogger.debug(event, "SC: ClaimEvent: swap secret: "+event.secret);
-                    yield this.processClaimEvent(chainIdentifier, event);
-                }
-                else if (event instanceof base_1.RefundEvent) {
-                    // this.swapLogger.debug(event, "SC: RefundEvent");
-                    yield this.processRefundEvent(chainIdentifier, event);
-                }
-            }
+    async processEvent(chainIdentifier, eventData) {
+        if (this.swapType == null)
             return true;
-        });
+        for (let event of eventData) {
+            if (event instanceof base_1.InitializeEvent) {
+                if (event.swapType !== this.swapType)
+                    continue;
+                const swap = this.getSwapByEscrowHash(chainIdentifier, event.escrowHash);
+                if (swap == null)
+                    continue;
+                swap.txIds.init = event.meta?.txId;
+                if (swap.metadata != null)
+                    swap.metadata.times.initTxReceived = Date.now();
+                await this.processInitializeEvent(chainIdentifier, swap, event);
+            }
+            else if (event instanceof base_1.ClaimEvent) {
+                const swap = this.getSwapByEscrowHash(chainIdentifier, event.escrowHash);
+                if (swap == null)
+                    continue;
+                swap.txIds.claim = event.meta?.txId;
+                if (swap.metadata != null)
+                    swap.metadata.times.claimTxReceived = Date.now();
+                await this.processClaimEvent(chainIdentifier, swap, event);
+            }
+            else if (event instanceof base_1.RefundEvent) {
+                const swap = this.getSwapByEscrowHash(chainIdentifier, event.escrowHash);
+                if (swap == null)
+                    continue;
+                swap.txIds.refund = event.meta?.txId;
+                if (swap.metadata != null)
+                    swap.metadata.times.refundTxReceived = Date.now();
+                await this.processRefundEvent(chainIdentifier, swap, event);
+            }
+        }
+        return true;
     }
     /**
      * Initializes chain events subscription
@@ -110,24 +116,52 @@ class SwapHandler {
         }
         this.logger.info("SC: Events: subscribed to smartchain events");
     }
-    removeSwapData(hashOrSwap, sequenceOrUltimateState) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let swap;
-            if (typeof (hashOrSwap) === "string") {
-                if (!BN.isBN(sequenceOrUltimateState))
-                    throw new Error("Sequence must be a BN instance!");
-                swap = yield this.storageManager.getData(hashOrSwap, sequenceOrUltimateState);
-            }
-            else {
-                swap = hashOrSwap;
-                if (sequenceOrUltimateState != null && !BN.isBN(sequenceOrUltimateState))
-                    yield swap.setState(sequenceOrUltimateState);
+    async loadData(ctor) {
+        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);
             }
-            if (swap != null)
-                yield PluginManager_1.PluginManager.swapRemove(swap);
-            this.swapLogger.debug(swap, "removeSwapData(): removing swap final state: " + swap.state);
-            yield this.storageManager.removeData(swap.getHash(), swap.getSequence());
-        });
+            this.saveSwapToEscrowHashMap(swap);
+        }
+    }
+    async removeSwapData(hashOrSwap, sequenceOrUltimateState) {
+        let swap;
+        if (typeof (hashOrSwap) === "string") {
+            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 && typeof (sequenceOrUltimateState) !== "bigint")
+                await swap.setState(sequenceOrUltimateState);
+        }
+        if (swap != null)
+            await PluginManager_1.PluginManager.swapRemove(swap);
+        this.swapLogger.debug(swap, "removeSwapData(): removing swap final state: " + swap.state);
+        this.removeSwapFromEscrowHashMap(swap);
+        await this.storageManager.removeData(swap.getIdentifierHash(), swap.getSequence());
+    }
+    async saveSwapData(swap) {
+        this.saveSwapToEscrowHashMap(swap);
+        await this.storageManager.saveData(swap.getIdentifierHash(), swap.getSequence(), swap);
+    }
+    saveSwapToEscrowHashMap(swap) {
+        if (swap.data != null)
+            this.escrowHashMap.set(swap.chainIdentifier + "_" + swap.getEscrowHash(), swap);
+    }
+    removeSwapFromEscrowHashMap(swap) {
+        if (swap.data != null)
+            this.escrowHashMap.delete(swap.chainIdentifier + "_" + swap.data.getEscrowHash());
+    }
+    getSwapByEscrowHash(chainIdentifier, escrowHash) {
+        return this.escrowHashMap.get(chainIdentifier + "_" + escrowHash);
     }
     /**
      * Checks whether the bitcoin amount is within specified min/max bounds
@@ -137,7 +171,7 @@ class SwapHandler {
      * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
      */
     checkBtcAmountInBounds(amount) {
-        if (amount.lt(this.config.min)) {
+        if (amount < this.config.min) {
             throw {
                 code: 20003,
                 msg: "Amount too low!",
@@ -147,7 +181,7 @@ class SwapHandler {
                 }
             };
         }
-        if (amount.gt(this.config.max)) {
+        if (amount > this.config.max) {
             throw {
                 code: 20004,
                 msg: "Amount too high!",
@@ -197,6 +231,8 @@ class SwapHandler {
      */
     getAbortController(responseStream) {
         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;
@@ -227,14 +263,16 @@ class SwapHandler {
         return signDataPrefetchPromise;
     }
     getIdentifierFromEvent(event) {
-        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;
     }
     getIdentifierFromSwapData(swapData) {
-        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);
     }
     getIdentifier(swap) {
         if (swap instanceof SwapHandlerSwap_1.SwapHandlerSwap) {
@@ -252,7 +290,7 @@ class SwapHandler {
      * @throws {DefinedRuntimeError} will throw an error if sequence number is out of bounds
      */
     checkSequence(sequence) {
-        if (sequence.isNeg() || sequence.gte(new BN(2).pow(new BN(64)))) {
+        if (sequence < 0n || sequence >= 2n ** 64n) {
             throw {
                 code: 20060,
                 msg: "Invalid sequence"
@@ -278,14 +316,17 @@ class SwapHandler {
             chainTokens[chainId] = Array.from(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(this.allowedTokens[this.chains.default]),
             chainTokens
         };
     }
+    getInitAuthorizationTimeout(chainIdentifier) {
+        return this.config.initAuthorizationTimeouts?.[chainIdentifier] ?? this.config.initAuthorizationTimeout;
+    }
 }
 exports.SwapHandler = SwapHandler;

package/dist/swaps/SwapHandlerSwap.d.ts

@@ -1,6 +1,5 @@
 import { Lockable, StorageObject, SwapData } from "@atomiqlabs/base";
 import { SwapHandlerType } from "./SwapHandler";
-import * as BN from "bn.js";
 export declare abstract class SwapHandlerSwap<T extends SwapData = SwapData, S = any> extends Lockable implements StorageObject {
     chainIdentifier: string;
     state: S;
@@ -18,13 +17,13 @@ export declare abstract class SwapHandlerSwap<T extends SwapData = SwapData, S =
         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);
     serialize(): any;
     /**
@@ -33,8 +32,20 @@ export declare abstract class SwapHandlerSwap<T extends SwapData = SwapData, S =
      * @param newState
      */
     setState(newState: S): Promise<void>;
-    getHash(): string;
-    getSequence(): BN;
+    /**
+     * Returns the escrow hash - i.e. hash of the escrow data
+     */
+    getEscrowHash(): string;
+    /**
+     * Returns the claim data hash - i.e. hash passed to the claim handler
+     */
+    getClaimHash(): string;
+    /**
+     * 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;
+    getSequence(): bigint | null;
     /**
      * Returns unique identifier of the swap in the form <hash>_<sequence> or just <hash> if the swap type doesn't
      *  use sequence number
@@ -59,21 +70,21 @@ export declare abstract class SwapHandlerSwap<T extends SwapData = SwapData, S =
     /**
      * 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;
+        inInputToken: bigint;
+        inOutputToken: bigint;
     };
 }

package/dist/swaps/SwapHandlerSwap.js

@@ -3,13 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwapHandlerSwap = void 0;
 const base_1 = require("@atomiqlabs/base");
 const PluginManager_1 = require("../plugins/PluginManager");
-const BN = require("bn.js");
 const Utils_1 = require("../utils/Utils");
+function objectBigIntsToString(obj) {
+    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;
+}
 class SwapHandlerSwap extends base_1.Lockable {
     constructor(obj, swapFee, swapFeeInToken) {
         super();
         this.txIds = {};
-        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;
@@ -34,7 +42,7 @@ class SwapHandlerSwap extends base_1.Lockable {
             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: (0, Utils_1.serializeBN)(this.swapFee),
             swapFeeInToken: (0, Utils_1.serializeBN)(this.swapFeeInToken),
@@ -54,11 +62,27 @@ class SwapHandlerSwap extends base_1.Lockable {
         this.state = newState;
         return PluginManager_1.PluginManager.swapStateChange(this, oldState);
     }
-    getHash() {
-        return this.data.getHash();
+    /**
+     * Returns the escrow hash - i.e. hash of the escrow data
+     */
+    getEscrowHash() {
+        return this.data.getEscrowHash();
+    }
+    /**
+     * Returns the claim data hash - i.e. hash passed to the claim handler
+     */
+    getClaimHash() {
+        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() {
+        return this.getClaimHash();
     }
     getSequence() {
-        return this.data.getSequence();
+        return this.data?.getSequence == null ? null : this.data.getSequence();
     }
     /**
      * Returns unique identifier of the swap in the form <hash>_<sequence> or just <hash> if the swap type doesn't
@@ -66,9 +90,9 @@ class SwapHandlerSwap extends base_1.Lockable {
      */
     getIdentifier() {
         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();
     }
     /**
      * Checks whether the swap is finished, such that it is final and either successful or failed