@atomiqlabs/lp-lib 12.1.0 → 13.0.0-beta.1

package/src/swaps/{ToBtcBaseSwapHandler.ts → assertions/ToBtcAmountAssertions.ts}

@@ -1,74 +1,36 @@
-import {RequestData, SwapBaseConfig, SwapHandler} from "./SwapHandler";
-import {SwapHandlerSwap} from "./SwapHandlerSwap";
-import {SwapData} from "@atomiqlabs/base";
-import {ServerParamEncoder} from "../utils/paramcoders/server/ServerParamEncoder";
-import {IParamReader} from "../utils/paramcoders/IParamReader";
-import {FieldTypeEnum} from "../utils/paramcoders/SchemaVerifier";
-import {PluginManager} from "../plugins/PluginManager";
-import {
-    isQuoteSetFees,
-    isToBtcPluginQuote
-} from "../plugins/IPlugin";
-import {ToBtcLnRequestType} from "./tobtcln_abstract/ToBtcLnAbs";
-import {ToBtcRequestType} from "./tobtc_abstract/ToBtcAbs";
-import {Request} from "express";
+import {AmountAssertions} from "./AmountAssertions";
+import {ToBtcLnRequestType} from "../escrow/tobtcln_abstract/ToBtcLnAbs";
+import {ToBtcRequestType} from "../escrow/tobtc_abstract/ToBtcAbs";
+import {PluginManager} from "../../plugins/PluginManager";
+import {isQuoteSetFees, isToBtcPluginQuote} from "../../plugins/IPlugin";
+import {RequestData, SwapHandlerType} from "../SwapHandler";
 
-export type ToBtcBaseConfig = SwapBaseConfig & {
-    gracePeriod: bigint,
-    refundAuthorizationTimeout: number
-};
 
-export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S>, S> extends SwapHandler<V, S> {
-
-    readonly pdaExistsForToken: {
-        [chainIdentifier: string]: {
-            [token: string]: boolean
-        }
-    } = {};
-
-    abstract config: ToBtcBaseConfig;
-
-    protected async checkVaultInitialized(chainIdentifier: string, token: string): Promise<void> {
-        if(!this.pdaExistsForToken[chainIdentifier] || !this.pdaExistsForToken[chainIdentifier][token]) {
-            this.logger.debug("checkVaultInitialized(): checking vault exists for chain: "+chainIdentifier+" token: "+token);
-            const {swapContract, signer} = this.getChain(chainIdentifier);
-            const reputation = await swapContract.getIntermediaryReputation(signer.getAddress(), token);
-            this.logger.debug("checkVaultInitialized(): vault state, chain: "+chainIdentifier+" token: "+token+" exists: "+(reputation!=null));
-            if(reputation!=null) {
-                if(this.pdaExistsForToken[chainIdentifier]==null) this.pdaExistsForToken[chainIdentifier] = {};
-                this.pdaExistsForToken[chainIdentifier][token] = true;
-            } else {
-                throw {
-                    code: 20201,
-                    msg: "Token not supported!"
-                };
-            }
-        }
-    }
+export class ToBtcAmountAssertions extends AmountAssertions {
 
     /**
      * Checks minimums/maximums, calculates the fee & total amount
      *
+     * @param swapType
      * @param request
      * @param requestedAmount
-     * @param useToken
      * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
      */
-    protected async preCheckAmounts(
+    async preCheckToBtcAmounts(
+        swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC,
         request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
-        requestedAmount: {input: boolean, amount: bigint},
-        useToken: string
+        requestedAmount: {input: boolean, amount: bigint, token: string}
     ): Promise<{baseFee: bigint, feePPM: bigint}> {
         const res = await PluginManager.onHandlePreToBtcQuote(
+            swapType,
             request,
             requestedAmount,
             request.chainIdentifier,
-            useToken,
             {minInBtc: this.config.min, maxInBtc: this.config.max},
             {baseFeeInBtc: this.config.baseFee, feePPM: this.config.feePPM},
         );
         if(res!=null) {
-            this.handlePluginErrorResponses(res);
+            AmountAssertions.handlePluginErrorResponses(res);
             if(isQuoteSetFees(res)) {
                 return {
                     baseFee: res.baseFee || this.config.baseFee,
@@ -88,24 +50,22 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
     /**
      * Checks minimums/maximums, calculates network fee (based on the callback passed), swap fee & total amount
      *
+     * @param swapType
      * @param request
      * @param requestedAmount
      * @param fees
-     * @param useToken
      * @param getNetworkFee
      * @param signal
-     * @param pricePrefetchPromise
      * @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: bigint}>(
+    async checkToBtcAmount<T extends {networkFee: bigint}>(
+        swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC,
         request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
-        requestedAmount: {input: boolean, amount: bigint},
+        requestedAmount: {input: boolean, amount: bigint, token: string, pricePrefetch?: Promise<bigint>},
         fees: {baseFee: bigint, feePPM: bigint},
-        useToken: string,
         getNetworkFee: (amount: bigint) => Promise<T>,
-        signal: AbortSignal,
-        pricePrefetchPromise?: Promise<bigint>
+        signal: AbortSignal
     ): Promise<{
         amountBD: bigint,
         networkFeeData: T,
@@ -118,17 +78,16 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
         const chainIdentifier = request.chainIdentifier;
 
         const res = await PluginManager.onHandlePostToBtcQuote<T>(
+            swapType,
             request,
             requestedAmount,
             request.chainIdentifier,
-            useToken,
             {minInBtc: this.config.min, maxInBtc: this.config.max},
-            {baseFeeInBtc: fees.baseFee, feePPM: fees.feePPM, networkFeeGetter: getNetworkFee},
-            pricePrefetchPromise
+            {baseFeeInBtc: fees.baseFee, feePPM: fees.feePPM, networkFeeGetter: getNetworkFee}
         );
         signal.throwIfAborted();
         if(res!=null) {
-            this.handlePluginErrorResponses(res);
+            AmountAssertions.handlePluginErrorResponses(res);
             if(isQuoteSetFees(res)) {
                 if(res.baseFee!=null) fees.baseFee = res.baseFee;
                 if(res.feePPM!=null) fees.feePPM = res.feePPM;
@@ -161,7 +120,7 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
         let amountBD: bigint;
         let tooLow = false;
         if(requestedAmount.input) {
-            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, null, pricePrefetchPromise);
+            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch);
             signal.throwIfAborted();
 
             //Decrease by base fee
@@ -178,7 +137,6 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
         }
 
         const resp = await getNetworkFee(amountBD);
-        this.logger.debug("checkToBtcAmount(): network fee calculated, amount: "+amountBD.toString(10)+" fee: "+resp.networkFee.toString(10));
         signal.throwIfAborted();
 
         if(requestedAmount.input) {
@@ -197,10 +155,10 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
                 adjustedMin = adjustedMin + fees.baseFee + resp.networkFee;
                 adjustedMax = adjustedMax + fees.baseFee + resp.networkFee;
                 const minIn = await this.swapPricing.getFromBtcSwapAmount(
-                    adjustedMin, useToken, chainIdentifier, null, pricePrefetchPromise
+                    adjustedMin, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch
                 );
                 const maxIn = await this.swapPricing.getFromBtcSwapAmount(
-                    adjustedMax, useToken, chainIdentifier, null, pricePrefetchPromise
+                    adjustedMax, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch
                 );
                 throw {
                     code: tooLow ? 20003 : 2004,
@@ -216,10 +174,10 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
         const swapFee = fees.baseFee + (amountBD * fees.feePPM / 1000000n);
 
         const networkFeeInToken = await this.swapPricing.getFromBtcSwapAmount(
-            resp.networkFee, useToken, chainIdentifier, true, pricePrefetchPromise
+            resp.networkFee, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch
         );
         const swapFeeInToken = await this.swapPricing.getFromBtcSwapAmount(
-            swapFee, useToken, chainIdentifier, true, pricePrefetchPromise
+            swapFee, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch
         );
         signal.throwIfAborted();
 
@@ -228,7 +186,7 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
             total = requestedAmount.amount;
         } else {
             const amountInToken = await this.swapPricing.getFromBtcSwapAmount(
-                requestedAmount.amount, useToken, chainIdentifier, true, pricePrefetchPromise
+                requestedAmount.amount, requestedAmount.token, chainIdentifier, true, requestedAmount.pricePrefetch
             );
             signal.throwIfAborted();
             total = amountInToken + swapFeeInToken + networkFeeInToken;
@@ -237,77 +195,4 @@ export abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S
         return {amountBD, networkFeeData: resp, swapFee, swapFeeInToken, networkFee: resp.networkFee, networkFeeInToken, totalInToken: total};
     }
 
-    /**
-     * Starts pre-fetches for swap pricing & signature data
-     *
-     * @param chainIdentifier
-     * @param token
-     * @param responseStream
-     * @param abortController
-     */
-    protected getToBtcPrefetches(chainIdentifier: string, token: string, responseStream: ServerParamEncoder, abortController: AbortController): {
-        pricePrefetchPromise?: Promise<bigint>,
-        signDataPrefetchPromise?: Promise<any>
-    } {
-        //Fetch pricing & signature data in parallel
-        const pricePrefetchPromise: Promise<bigint> = this.swapPricing.preFetchPrice(token, chainIdentifier).catch(e => {
-            this.logger.error("getToBtcPrefetches(): pricePrefetch error", e);
-            abortController.abort(e);
-            return null;
-        });
-
-        return {
-            pricePrefetchPromise,
-            signDataPrefetchPromise: this.getSignDataPrefetch(chainIdentifier, abortController, responseStream)
-        }
-    }
-
-    /**
-     * Signs the created swap
-     *
-     * @param chainIdentifier
-     * @param swapObject
-     * @param req
-     * @param abortSignal
-     * @param signDataPrefetchPromise
-     */
-    protected async getToBtcSignatureData(
-        chainIdentifier: string,
-        swapObject: SwapData,
-        req: Request & {paramReader: IParamReader},
-        abortSignal: AbortSignal,
-        signDataPrefetchPromise?: Promise<any>
-    ): Promise<{
-        prefix: string,
-        timeout: string,
-        signature: string,
-        feeRate: string
-    }> {
-        const prefetchedSignData = signDataPrefetchPromise!=null ? await signDataPrefetchPromise : null;
-        if(prefetchedSignData!=null) this.logger.debug("getToBtcSignatureData(): pre-fetched signature data: ", prefetchedSignData);
-        abortSignal.throwIfAborted();
-
-        const feeRateObj = await req.paramReader.getParams({
-            feeRate: FieldTypeEnum.String
-        }).catch(() => null);
-        abortSignal.throwIfAborted();
-
-        const feeRate = feeRateObj?.feeRate!=null && typeof(feeRateObj.feeRate)==="string" ? feeRateObj.feeRate : null;
-        this.logger.debug("getToBtcSignatureData(): using fee rate from client: ", feeRate);
-        const {swapContract, signer} = this.getChain(chainIdentifier);
-        const sigData = await swapContract.getInitSignature(
-            signer,
-            swapObject,
-            this.getInitAuthorizationTimeout(chainIdentifier),
-            prefetchedSignData,
-            feeRate
-        );
-        abortSignal.throwIfAborted();
-
-        return {
-            ...sigData,
-            feeRate
-        };
-    }
-
 }

package/src/swaps/escrow/EscrowHandler.ts

@@ -0,0 +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 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) {
+                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) {
+                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);
+            }
+        }
+
+        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

@@ -0,0 +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();
+    }
+
+}

package/src/swaps/{FromBtcBaseSwap.ts → escrow/FromBtcBaseSwap.ts}

@@ -1,8 +1,8 @@
+import {deserializeBN, serializeBN} from "../../utils/Utils";
+import {EscrowHandlerSwap} from "./EscrowHandlerSwap";
 import {SwapData} from "@atomiqlabs/base";
-import {SwapHandlerSwap} from "./SwapHandlerSwap";
-import {deserializeBN, serializeBN} from "../utils/Utils";
 
-export abstract class FromBtcBaseSwap<T extends SwapData, S = any> extends SwapHandlerSwap<T, S> {
+export abstract class FromBtcBaseSwap<T extends SwapData = SwapData, S = any> extends EscrowHandlerSwap<T, S> {
 
     amount: bigint;
 
@@ -18,16 +18,12 @@ export abstract class FromBtcBaseSwap<T extends SwapData, S = any> extends SwapH
         }
     };
 
-    getInputAmount(): bigint {
-        return this.getTotalInputAmount() - this.getSwapFee().inInputToken;
-    }
-
     getTotalInputAmount(): bigint {
         return this.amount;
     }
 
     getOutputAmount(): bigint {
-        return this.data.getAmount();
+        return this.data?.getAmount();
     }
 
     getSwapFee(): { inInputToken: bigint; inOutputToken: bigint } {