@atomiqlabs/lp-lib 15.0.5 → 15.0.6

package/src/swaps/escrow/EscrowHandler.ts

@@ -1,179 +1,179 @@
-import {SwapBaseConfig, SwapHandler} from "../SwapHandler";
-import {
-    ChainEvent, ChainSwapType, ClaimEvent, InitializeEvent, RefundEvent,
-    SwapData,
-    SwapEvent
-} from "@atomiqlabs/base";
-import {PluginManager} from "../../plugins/PluginManager";
-import {EscrowHandlerSwap} from "./EscrowHandlerSwap";
-import {ServerParamEncoder} from "../../utils/paramcoders/server/ServerParamEncoder";
-import {SwapHandlerSwap} from "../SwapHandlerSwap";
-
-export type ToBtcBaseConfig = SwapBaseConfig & {
-    gracePeriod: bigint,
-    refundAuthorizationTimeout: number
-};
-
-export abstract class EscrowHandler<V extends EscrowHandlerSwap<SwapData, S>, S> extends SwapHandler<V, S> {
-
-    abstract readonly swapType: ChainSwapType;
-
-    readonly escrowHashMap: Map<string, V> = new Map();
-
-    protected swapLogger = {
-        debug: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => this.logger.debug(this.getIdentifier(swap)+": "+msg, ...args),
-        info: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => this.logger.info(this.getIdentifier(swap)+": "+msg, ...args),
-        warn: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => this.logger.warn(this.getIdentifier(swap)+": "+msg, ...args),
-        error: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => this.logger.error(this.getIdentifier(swap)+": "+msg, ...args)
-    };
-
-    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 async processEvent(chainIdentifier: string, eventData: ChainEvent<SwapData>[]): Promise<boolean> {
-        if(this.swapType==null) return true;
-
-        for(let event of eventData) {
-            if(event instanceof 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 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 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
-     */
-    protected subscribeToEvents() {
-        for(let key in this.chains.chains) {
-            this.chains.chains[key].chainEvents.registerListener((events: ChainEvent<SwapData>[]) => this.processEvent(key, events));
-        }
-        this.logger.info("SC: Events: subscribed to smartchain events");
-    }
-
-    protected async loadData(ctor: new (data: any) => V) {
-        await super.loadData(ctor);
-        for(let {obj: swap, hash, sequence} of await this.storageManager.query([])) {
-            this.saveSwapToEscrowHashMap(swap);
-        }
-    }
-
-    protected removeSwapData(hash: string, sequence: bigint): Promise<void>;
-    protected removeSwapData(swap: V, ultimateState?: S): Promise<void>;
-    protected async removeSwapData(hashOrSwap: string | V, sequenceOrUltimateState?: bigint | S) {
-        let swap: V;
-        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.swapRemove(swap);
-        this.swapLogger.debug(swap, "removeSwapData(): removing swap final state: "+swap.state);
-        this.removeSwapFromEscrowHashMap(swap);
-        await this.storageManager.removeData(swap.getIdentifierHash(), swap.getSequence());
-    }
-
-    protected async saveSwapData(swap: V) {
-        this.saveSwapToEscrowHashMap(swap);
-        return super.saveSwapData(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.getEscrowHash());
-    }
-
-    protected getSwapByEscrowHash(chainIdentifier: string, escrowHash: string) {
-        return this.escrowHashMap.get(chainIdentifier+"_"+escrowHash);
-    }
-
-    protected getIdentifierFromEvent(event: SwapEvent<SwapData>): string {
-        if(event instanceof SwapEvent) {
-            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==null) return swapData.getClaimHash();
-        return swapData.getClaimHash()+"_"+swapData.getSequence().toString(16);
-    }
-
-    protected getIdentifier(swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData) {
-        if(swap instanceof SwapHandlerSwap) {
-            return swap.getIdentifier();
-        }
-        if(swap instanceof ChainEvent) {
-            return this.getIdentifierFromEvent(swap);
-        }
-        return this.getIdentifierFromSwapData(swap);
-    }
-
-    /**
-     * Starts a pre-fetch for signature data
-     *
-     * @param chainIdentifier
-     * @param abortController
-     * @param responseStream
-     */
-    protected getSignDataPrefetch(chainIdentifier: string, abortController: AbortController, responseStream?: ServerParamEncoder): Promise<any> {
-        const {swapContract} = this.getChain(chainIdentifier);
-        let signDataPrefetchPromise: Promise<any> = 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;
-    }
-
-}
+import {SwapBaseConfig, SwapHandler} from "../SwapHandler";
+import {
+    ChainEvent, ChainSwapType, ClaimEvent, InitializeEvent, RefundEvent,
+    SwapData,
+    SwapEvent
+} from "@atomiqlabs/base";
+import {PluginManager} from "../../plugins/PluginManager";
+import {EscrowHandlerSwap} from "./EscrowHandlerSwap";
+import {ServerParamEncoder} from "../../utils/paramcoders/server/ServerParamEncoder";
+import {SwapHandlerSwap} from "../SwapHandlerSwap";
+
+export type ToBtcBaseConfig = SwapBaseConfig & {
+    gracePeriod: bigint,
+    refundAuthorizationTimeout: number
+};
+
+export abstract class EscrowHandler<V extends EscrowHandlerSwap<SwapData, S>, S> extends SwapHandler<V, S> {
+
+    abstract readonly swapType: ChainSwapType;
+
+    readonly escrowHashMap: Map<string, V> = new Map();
+
+    protected swapLogger = {
+        debug: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => this.logger.debug(this.getIdentifier(swap)+": "+msg, ...args),
+        info: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => this.logger.info(this.getIdentifier(swap)+": "+msg, ...args),
+        warn: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => this.logger.warn(this.getIdentifier(swap)+": "+msg, ...args),
+        error: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => this.logger.error(this.getIdentifier(swap)+": "+msg, ...args)
+    };
+
+    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 async processEvent(chainIdentifier: string, eventData: ChainEvent<SwapData>[]): Promise<boolean> {
+        if(this.swapType==null) return true;
+
+        for(let event of eventData) {
+            if(event instanceof 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 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 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
+     */
+    protected subscribeToEvents() {
+        for(let key in this.chains.chains) {
+            this.chains.chains[key].chainEvents.registerListener((events: ChainEvent<SwapData>[]) => this.processEvent(key, events));
+        }
+        this.logger.info("SC: Events: subscribed to smartchain events");
+    }
+
+    protected async loadData(ctor: new (data: any) => V) {
+        await super.loadData(ctor);
+        for(let {obj: swap, hash, sequence} of await this.storageManager.query([])) {
+            this.saveSwapToEscrowHashMap(swap);
+        }
+    }
+
+    protected removeSwapData(hash: string, sequence: bigint): Promise<void>;
+    protected removeSwapData(swap: V, ultimateState?: S): Promise<void>;
+    protected async removeSwapData(hashOrSwap: string | V, sequenceOrUltimateState?: bigint | S) {
+        let swap: V;
+        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.swapRemove(swap);
+        this.swapLogger.debug(swap, "removeSwapData(): removing swap final state: "+swap.state);
+        this.removeSwapFromEscrowHashMap(swap);
+        await this.storageManager.removeData(swap.getIdentifierHash(), swap.getSequence());
+    }
+
+    protected async saveSwapData(swap: V) {
+        this.saveSwapToEscrowHashMap(swap);
+        return super.saveSwapData(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.getEscrowHash());
+    }
+
+    protected getSwapByEscrowHash(chainIdentifier: string, escrowHash: string) {
+        return this.escrowHashMap.get(chainIdentifier+"_"+escrowHash);
+    }
+
+    protected getIdentifierFromEvent(event: SwapEvent<SwapData>): string {
+        if(event instanceof SwapEvent) {
+            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==null) return swapData.getClaimHash();
+        return swapData.getClaimHash()+"_"+swapData.getSequence().toString(16);
+    }
+
+    protected getIdentifier(swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData) {
+        if(swap instanceof SwapHandlerSwap) {
+            return swap.getIdentifier();
+        }
+        if(swap instanceof ChainEvent) {
+            return this.getIdentifierFromEvent(swap);
+        }
+        return this.getIdentifierFromSwapData(swap);
+    }
+
+    /**
+     * Starts a pre-fetch for signature data
+     *
+     * @param chainIdentifier
+     * @param abortController
+     * @param responseStream
+     */
+    protected getSignDataPrefetch(chainIdentifier: string, abortController: AbortController, responseStream?: ServerParamEncoder): Promise<any> {
+        const {swapContract} = this.getChain(chainIdentifier);
+        let signDataPrefetchPromise: Promise<any> = 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;
+    }
+
+}

package/src/swaps/escrow/EscrowHandlerSwap.ts

@@ -1,87 +1,87 @@
-import {Lockable, StorageObject, SwapData} from "@atomiqlabs/base";
-import {SwapHandlerSwap} from "../SwapHandlerSwap";
-
-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 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);
-
-    protected constructor(obj?: any | string, swapFee?: bigint, swapFeeInToken?: bigint) {
-        super(obj, swapFee, swapFeeInToken);
-        if(typeof(obj)==="string" && typeof(swapFee)==="bigint" && typeof(swapFeeInToken)==="bigint") {
-            return;
-        } else {
-            this.data = obj.data==null ? null : SwapData.deserialize(obj.data);
-            this.prefix = obj.prefix;
-            this.timeout = obj.timeout;
-            this.signature = obj.signature;
-            this.feeRate = obj.feeRate;
-        }
-    }
-
-    serialize(): any {
-        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(): 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(): bigint | null {
-        return this.data?.getSequence==null ? null : this.data.getSequence();
-    }
-
-    /**
-     * Returns the smart chain token used for the swap
-     */
-    getToken(): string {
-        return this.data?.getToken();
-    }
-
+import {Lockable, StorageObject, SwapData} from "@atomiqlabs/base";
+import {SwapHandlerSwap} from "../SwapHandlerSwap";
+
+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 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);
+
+    protected constructor(obj?: any | string, swapFee?: bigint, swapFeeInToken?: bigint) {
+        super(obj, swapFee, swapFeeInToken);
+        if(typeof(obj)==="string" && typeof(swapFee)==="bigint" && typeof(swapFeeInToken)==="bigint") {
+            return;
+        } else {
+            this.data = obj.data==null ? null : SwapData.deserialize(obj.data);
+            this.prefix = obj.prefix;
+            this.timeout = obj.timeout;
+            this.signature = obj.signature;
+            this.feeRate = obj.feeRate;
+        }
+    }
+
+    serialize(): any {
+        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(): 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(): bigint | null {
+        return this.data?.getSequence==null ? null : this.data.getSequence();
+    }
+
+    /**
+     * Returns the smart chain token used for the swap
+     */
+    getToken(): string {
+        return this.data?.getToken();
+    }
+
 }

package/src/swaps/escrow/FromBtcBaseSwap.ts

@@ -1,39 +1,39 @@
-import {deserializeBN, serializeBN} from "../../utils/Utils";
-import {EscrowHandlerSwap} from "./EscrowHandlerSwap";
-import {SwapData} from "@atomiqlabs/base";
-
-export abstract class FromBtcBaseSwap<T extends SwapData = SwapData, S = any> extends EscrowHandlerSwap<T, S> {
-
-    amount: bigint;
-
-    protected constructor(chainIdentifier: string, amount: bigint, swapFee: bigint, swapFeeInToken: bigint);
-    protected constructor(obj: any);
-
-    protected constructor(obj?: any | string, amount?: bigint, swapFee?: bigint, swapFeeInToken?: bigint) {
-        super(obj, swapFee, swapFeeInToken);
-        if (typeof (obj) === "string" && typeof(amount)==="bigint" && typeof(swapFee)==="bigint" && typeof(swapFeeInToken)==="bigint") {
-            this.amount = amount;
-        } else {
-            this.amount = deserializeBN(obj.amount);
-        }
-    };
-
-    getTotalInputAmount(): bigint {
-        return this.amount;
-    }
-
-    getOutputAmount(): bigint {
-        return this.data?.getAmount();
-    }
-
-    getSwapFee(): { inInputToken: bigint; inOutputToken: bigint } {
-        return {inInputToken: this.swapFee, inOutputToken: this.swapFeeInToken};
-    }
-
-    serialize(): any {
-        const partialSerialized = super.serialize();
-        partialSerialized.amount = serializeBN(this.amount);
-        return partialSerialized;
-    }
-
+import {deserializeBN, serializeBN} from "../../utils/Utils";
+import {EscrowHandlerSwap} from "./EscrowHandlerSwap";
+import {SwapData} from "@atomiqlabs/base";
+
+export abstract class FromBtcBaseSwap<T extends SwapData = SwapData, S = any> extends EscrowHandlerSwap<T, S> {
+
+    amount: bigint;
+
+    protected constructor(chainIdentifier: string, amount: bigint, swapFee: bigint, swapFeeInToken: bigint);
+    protected constructor(obj: any);
+
+    protected constructor(obj?: any | string, amount?: bigint, swapFee?: bigint, swapFeeInToken?: bigint) {
+        super(obj, swapFee, swapFeeInToken);
+        if (typeof (obj) === "string" && typeof(amount)==="bigint" && typeof(swapFee)==="bigint" && typeof(swapFeeInToken)==="bigint") {
+            this.amount = amount;
+        } else {
+            this.amount = deserializeBN(obj.amount);
+        }
+    };
+
+    getTotalInputAmount(): bigint {
+        return this.amount;
+    }
+
+    getOutputAmount(): bigint {
+        return this.data?.getAmount();
+    }
+
+    getSwapFee(): { inInputToken: bigint; inOutputToken: bigint } {
+        return {inInputToken: this.swapFee, inOutputToken: this.swapFeeInToken};
+    }
+
+    serialize(): any {
+        const partialSerialized = super.serialize();
+        partialSerialized.amount = serializeBN(this.amount);
+        return partialSerialized;
+    }
+
 }