@atomiqlabs/lp-lib 15.0.13 → 15.0.14

package/dist/swaps/escrow/EscrowHandler.d.ts

@@ -1,51 +1,51 @@
-import { SwapBaseConfig, SwapHandler } from "../SwapHandler";
-import { ChainEvent, ChainSwapType, ClaimEvent, InitializeEvent, RefundEvent, SwapData, SwapEvent } from "@atomiqlabs/base";
-import { EscrowHandlerSwap } from "./EscrowHandlerSwap";
-import { ServerParamEncoder } from "../../utils/paramcoders/server/ServerParamEncoder";
-import { SwapHandlerSwap } from "../SwapHandlerSwap";
-export type ToBtcBaseConfig = SwapBaseConfig & {
-    gracePeriod: bigint;
-    refundAuthorizationTimeout: number;
-};
-export declare abstract class EscrowHandler<V extends EscrowHandlerSwap<SwapData, S>, S> extends SwapHandler<V, S> {
-    abstract readonly swapType: ChainSwapType;
-    readonly escrowHashMap: Map<string, V>;
-    protected swapLogger: {
-        debug: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
-        info: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
-        warn: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
-        error: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => 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
-     *
-     * @param chainIdentifier
-     * @param eventData
-     */
-    protected processEvent(chainIdentifier: string, eventData: ChainEvent<SwapData>[]): Promise<boolean>;
-    /**
-     * Initializes chain events subscription
-     */
-    protected subscribeToEvents(): void;
-    protected loadData(ctor: new (data: any) => V): Promise<void>;
-    protected removeSwapData(hash: string, sequence: bigint): Promise<void>;
-    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;
-    protected getIdentifierFromEvent(event: SwapEvent<SwapData>): string;
-    protected getIdentifierFromSwapData(swapData: SwapData): string;
-    protected getIdentifier(swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData): string;
-    /**
-     * Starts a pre-fetch for signature data
-     *
-     * @param chainIdentifier
-     * @param abortController
-     * @param responseStream
-     */
-    protected getSignDataPrefetch(chainIdentifier: string, abortController: AbortController, responseStream?: ServerParamEncoder): Promise<any>;
-}
+import { SwapBaseConfig, SwapHandler } from "../SwapHandler";
+import { ChainEvent, ChainSwapType, ClaimEvent, InitializeEvent, RefundEvent, SwapData, SwapEvent } from "@atomiqlabs/base";
+import { EscrowHandlerSwap } from "./EscrowHandlerSwap";
+import { ServerParamEncoder } from "../../utils/paramcoders/server/ServerParamEncoder";
+import { SwapHandlerSwap } from "../SwapHandlerSwap";
+export type ToBtcBaseConfig = SwapBaseConfig & {
+    gracePeriod: bigint;
+    refundAuthorizationTimeout: number;
+};
+export declare abstract class EscrowHandler<V extends EscrowHandlerSwap<SwapData, S>, S> extends SwapHandler<V, S> {
+    abstract readonly swapType: ChainSwapType;
+    readonly escrowHashMap: Map<string, V>;
+    protected swapLogger: {
+        debug: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
+        info: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
+        warn: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
+        error: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => 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
+     *
+     * @param chainIdentifier
+     * @param eventData
+     */
+    protected processEvent(chainIdentifier: string, eventData: ChainEvent<SwapData>[]): Promise<boolean>;
+    /**
+     * Initializes chain events subscription
+     */
+    protected subscribeToEvents(): void;
+    protected loadData(ctor: new (data: any) => V): Promise<void>;
+    protected removeSwapData(hash: string, sequence: bigint): Promise<void>;
+    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;
+    protected getIdentifierFromEvent(event: SwapEvent<SwapData>): string;
+    protected getIdentifierFromSwapData(swapData: SwapData): string;
+    protected getIdentifier(swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData): string;
+    /**
+     * Starts a pre-fetch for signature data
+     *
+     * @param chainIdentifier
+     * @param abortController
+     * @param responseStream
+     */
+    protected getSignDataPrefetch(chainIdentifier: string, abortController: AbortController, responseStream?: ServerParamEncoder): Promise<any>;
+}

package/dist/swaps/escrow/EscrowHandler.js

@@ -1,158 +1,158 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EscrowHandler = void 0;
-const SwapHandler_1 = require("../SwapHandler");
-const base_1 = require("@atomiqlabs/base");
-const PluginManager_1 = require("../../plugins/PluginManager");
-const SwapHandlerSwap_1 = require("../SwapHandlerSwap");
-class EscrowHandler extends SwapHandler_1.SwapHandler {
-    constructor() {
-        super(...arguments);
-        this.escrowHashMap = new Map();
-        this.swapLogger = {
-            debug: (swap, msg, ...args) => this.logger.debug(this.getIdentifier(swap) + ": " + msg, ...args),
-            info: (swap, msg, ...args) => this.logger.info(this.getIdentifier(swap) + ": " + msg, ...args),
-            warn: (swap, msg, ...args) => this.logger.warn(this.getIdentifier(swap) + ": " + msg, ...args),
-            error: (swap, msg, ...args) => this.logger.error(this.getIdentifier(swap) + ": " + msg, ...args)
-        };
-    }
-    /**
-     * Chain event processor
-     *
-     * @param chainIdentifier
-     * @param eventData
-     */
-    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
-     */
-    subscribeToEvents() {
-        for (let key in this.chains.chains) {
-            this.chains.chains[key].chainEvents.registerListener((events) => this.processEvent(key, events));
-        }
-        this.logger.info("SC: Events: subscribed to smartchain events");
-    }
-    async loadData(ctor) {
-        await super.loadData(ctor);
-        for (let { obj: swap, hash, sequence } of await this.storageManager.query([])) {
-            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);
-        return super.saveSwapData(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.getEscrowHash());
-    }
-    getSwapByEscrowHash(chainIdentifier, escrowHash) {
-        return this.escrowHashMap.get(chainIdentifier + "_" + escrowHash);
-    }
-    getIdentifierFromEvent(event) {
-        if (event instanceof base_1.SwapEvent) {
-            const foundSwap = this.escrowHashMap.get(event.escrowHash);
-            if (foundSwap != null) {
-                return foundSwap.getIdentifier();
-            }
-            return "UNKNOWN_" + event.escrowHash;
-        }
-    }
-    getIdentifierFromSwapData(swapData) {
-        if (swapData.getSequence == null)
-            return swapData.getClaimHash();
-        return swapData.getClaimHash() + "_" + swapData.getSequence().toString(16);
-    }
-    getIdentifier(swap) {
-        if (swap instanceof SwapHandlerSwap_1.SwapHandlerSwap) {
-            return swap.getIdentifier();
-        }
-        if (swap instanceof base_1.ChainEvent) {
-            return this.getIdentifierFromEvent(swap);
-        }
-        return this.getIdentifierFromSwapData(swap);
-    }
-    /**
-     * Starts a pre-fetch for signature data
-     *
-     * @param chainIdentifier
-     * @param abortController
-     * @param responseStream
-     */
-    getSignDataPrefetch(chainIdentifier, abortController, responseStream) {
-        const { swapContract } = this.getChain(chainIdentifier);
-        let signDataPrefetchPromise = swapContract.preFetchBlockDataForSignatures != null ? swapContract.preFetchBlockDataForSignatures().catch(e => {
-            this.logger.error("getSignDataPrefetch(): signDataPrefetch: ", e);
-            abortController.abort(e);
-            return null;
-        }) : null;
-        if (signDataPrefetchPromise != null && responseStream != null) {
-            signDataPrefetchPromise = signDataPrefetchPromise.then(val => val == null || abortController.signal.aborted ? null : responseStream.writeParams({
-                signDataPrefetch: val
-            }).then(() => val).catch(e => {
-                this.logger.error("getSignDataPrefetch(): signDataPreFetch: error when sending sign data to the client: ", e);
-                abortController.abort(e);
-                return null;
-            }));
-        }
-        return signDataPrefetchPromise;
-    }
-}
-exports.EscrowHandler = EscrowHandler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EscrowHandler = void 0;
+const SwapHandler_1 = require("../SwapHandler");
+const base_1 = require("@atomiqlabs/base");
+const PluginManager_1 = require("../../plugins/PluginManager");
+const SwapHandlerSwap_1 = require("../SwapHandlerSwap");
+class EscrowHandler extends SwapHandler_1.SwapHandler {
+    constructor() {
+        super(...arguments);
+        this.escrowHashMap = new Map();
+        this.swapLogger = {
+            debug: (swap, msg, ...args) => this.logger.debug(this.getIdentifier(swap) + ": " + msg, ...args),
+            info: (swap, msg, ...args) => this.logger.info(this.getIdentifier(swap) + ": " + msg, ...args),
+            warn: (swap, msg, ...args) => this.logger.warn(this.getIdentifier(swap) + ": " + msg, ...args),
+            error: (swap, msg, ...args) => this.logger.error(this.getIdentifier(swap) + ": " + msg, ...args)
+        };
+    }
+    /**
+     * Chain event processor
+     *
+     * @param chainIdentifier
+     * @param eventData
+     */
+    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
+     */
+    subscribeToEvents() {
+        for (let key in this.chains.chains) {
+            this.chains.chains[key].chainEvents.registerListener((events) => this.processEvent(key, events));
+        }
+        this.logger.info("SC: Events: subscribed to smartchain events");
+    }
+    async loadData(ctor) {
+        await super.loadData(ctor);
+        for (let { obj: swap, hash, sequence } of await this.storageManager.query([])) {
+            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);
+        return super.saveSwapData(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.getEscrowHash());
+    }
+    getSwapByEscrowHash(chainIdentifier, escrowHash) {
+        return this.escrowHashMap.get(chainIdentifier + "_" + escrowHash);
+    }
+    getIdentifierFromEvent(event) {
+        if (event instanceof base_1.SwapEvent) {
+            const foundSwap = this.escrowHashMap.get(event.escrowHash);
+            if (foundSwap != null) {
+                return foundSwap.getIdentifier();
+            }
+            return "UNKNOWN_" + event.escrowHash;
+        }
+    }
+    getIdentifierFromSwapData(swapData) {
+        if (swapData.getSequence == null)
+            return swapData.getClaimHash();
+        return swapData.getClaimHash() + "_" + swapData.getSequence().toString(16);
+    }
+    getIdentifier(swap) {
+        if (swap instanceof SwapHandlerSwap_1.SwapHandlerSwap) {
+            return swap.getIdentifier();
+        }
+        if (swap instanceof base_1.ChainEvent) {
+            return this.getIdentifierFromEvent(swap);
+        }
+        return this.getIdentifierFromSwapData(swap);
+    }
+    /**
+     * Starts a pre-fetch for signature data
+     *
+     * @param chainIdentifier
+     * @param abortController
+     * @param responseStream
+     */
+    getSignDataPrefetch(chainIdentifier, abortController, responseStream) {
+        const { swapContract } = this.getChain(chainIdentifier);
+        let signDataPrefetchPromise = swapContract.preFetchBlockDataForSignatures != null ? swapContract.preFetchBlockDataForSignatures().catch(e => {
+            this.logger.error("getSignDataPrefetch(): signDataPrefetch: ", e);
+            abortController.abort(e);
+            return null;
+        }) : null;
+        if (signDataPrefetchPromise != null && responseStream != null) {
+            signDataPrefetchPromise = signDataPrefetchPromise.then(val => val == null || abortController.signal.aborted ? null : responseStream.writeParams({
+                signDataPrefetch: val
+            }).then(() => val).catch(e => {
+                this.logger.error("getSignDataPrefetch(): signDataPreFetch: error when sending sign data to the client: ", e);
+                abortController.abort(e);
+                return null;
+            }));
+        }
+        return signDataPrefetchPromise;
+    }
+}
+exports.EscrowHandler = EscrowHandler;

package/dist/swaps/escrow/EscrowHandlerSwap.d.ts

@@ -1,35 +1,35 @@
-import { SwapData } from "@atomiqlabs/base";
-import { SwapHandlerSwap } from "../SwapHandlerSwap";
-export declare abstract class EscrowHandlerSwap<T extends SwapData = SwapData, S = any> extends SwapHandlerSwap<S> {
-    data: T;
-    txIds: {
-        init?: string;
-        claim?: string;
-        refund?: string;
-    };
-    prefix: string;
-    timeout: string;
-    signature: string;
-    feeRate: string;
-    protected constructor(chainIdentifier: string, swapFee: bigint, swapFeeInToken: bigint);
-    protected constructor(obj: any);
-    serialize(): any;
-    /**
-     * 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 the smart chain token used for the swap
-     */
-    getToken(): string;
-}
+import { SwapData } from "@atomiqlabs/base";
+import { SwapHandlerSwap } from "../SwapHandlerSwap";
+export declare abstract class EscrowHandlerSwap<T extends SwapData = SwapData, S = any> extends SwapHandlerSwap<S> {
+    data: T;
+    txIds: {
+        init?: string;
+        claim?: string;
+        refund?: string;
+    };
+    prefix: string;
+    timeout: string;
+    signature: string;
+    feeRate: string;
+    protected constructor(chainIdentifier: string, swapFee: bigint, swapFeeInToken: bigint);
+    protected constructor(obj: any);
+    serialize(): any;
+    /**
+     * 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 the smart chain token used for the swap
+     */
+    getToken(): string;
+}

package/dist/swaps/escrow/EscrowHandlerSwap.js

@@ -1,69 +1,69 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EscrowHandlerSwap = void 0;
-const base_1 = require("@atomiqlabs/base");
-const SwapHandlerSwap_1 = require("../SwapHandlerSwap");
-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 EscrowHandlerSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
-    constructor(obj, swapFee, swapFeeInToken) {
-        super(obj, swapFee, swapFeeInToken);
-        this.txIds = {};
-        if (typeof (obj) === "string" && typeof (swapFee) === "bigint" && typeof (swapFeeInToken) === "bigint") {
-            return;
-        }
-        else {
-            this.data = obj.data == null ? null : base_1.SwapData.deserialize(obj.data);
-            this.prefix = obj.prefix;
-            this.timeout = obj.timeout;
-            this.signature = obj.signature;
-            this.feeRate = obj.feeRate;
-        }
-    }
-    serialize() {
-        return {
-            ...super.serialize(),
-            data: this.data == null ? null : this.data.serialize(),
-            prefix: this.prefix,
-            timeout: this.timeout,
-            signature: this.signature,
-            feeRate: this.feeRate
-        };
-    }
-    /**
-     * 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 == null ? null : this.data.getSequence();
-    }
-    /**
-     * Returns the smart chain token used for the swap
-     */
-    getToken() {
-        return this.data?.getToken();
-    }
-}
-exports.EscrowHandlerSwap = EscrowHandlerSwap;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EscrowHandlerSwap = void 0;
+const base_1 = require("@atomiqlabs/base");
+const SwapHandlerSwap_1 = require("../SwapHandlerSwap");
+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 EscrowHandlerSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
+    constructor(obj, swapFee, swapFeeInToken) {
+        super(obj, swapFee, swapFeeInToken);
+        this.txIds = {};
+        if (typeof (obj) === "string" && typeof (swapFee) === "bigint" && typeof (swapFeeInToken) === "bigint") {
+            return;
+        }
+        else {
+            this.data = obj.data == null ? null : base_1.SwapData.deserialize(obj.data);
+            this.prefix = obj.prefix;
+            this.timeout = obj.timeout;
+            this.signature = obj.signature;
+            this.feeRate = obj.feeRate;
+        }
+    }
+    serialize() {
+        return {
+            ...super.serialize(),
+            data: this.data == null ? null : this.data.serialize(),
+            prefix: this.prefix,
+            timeout: this.timeout,
+            signature: this.signature,
+            feeRate: this.feeRate
+        };
+    }
+    /**
+     * 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 == null ? null : this.data.getSequence();
+    }
+    /**
+     * Returns the smart chain token used for the swap
+     */
+    getToken() {
+        return this.data?.getToken();
+    }
+}
+exports.EscrowHandlerSwap = EscrowHandlerSwap;