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

package/dist/swaps/escrow/EscrowHandler.js

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

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

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

package/dist/swaps/escrow/EscrowHandlerSwap.js

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

package/dist/swaps/{FromBtcBaseSwap.d.ts → escrow/FromBtcBaseSwap.d.ts}

@@ -1,10 +1,9 @@
+import { EscrowHandlerSwap } from "./EscrowHandlerSwap";
 import { SwapData } from "@atomiqlabs/base";
-import { SwapHandlerSwap } from "./SwapHandlerSwap";
-export declare abstract class FromBtcBaseSwap<T extends SwapData, S = any> extends SwapHandlerSwap<T, S> {
+export declare 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);
-    getInputAmount(): bigint;
     getTotalInputAmount(): bigint;
     getOutputAmount(): bigint;
     getSwapFee(): {

package/dist/swaps/{FromBtcBaseSwap.js → escrow/FromBtcBaseSwap.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcBaseSwap = void 0;
-const SwapHandlerSwap_1 = require("./SwapHandlerSwap");
-const Utils_1 = require("../utils/Utils");
-class FromBtcBaseSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
+const Utils_1 = require("../../utils/Utils");
+const EscrowHandlerSwap_1 = require("./EscrowHandlerSwap");
+class FromBtcBaseSwap extends EscrowHandlerSwap_1.EscrowHandlerSwap {
     constructor(obj, amount, swapFee, swapFeeInToken) {
         super(obj, swapFee, swapFeeInToken);
         if (typeof (obj) === "string" && typeof (amount) === "bigint" && typeof (swapFee) === "bigint" && typeof (swapFeeInToken) === "bigint") {
@@ -14,14 +14,11 @@ class FromBtcBaseSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
         }
     }
     ;
-    getInputAmount() {
-        return this.getTotalInputAmount() - this.getSwapFee().inInputToken;
-    }
     getTotalInputAmount() {
         return this.amount;
     }
     getOutputAmount() {
-        return this.data.getAmount();
+        return this.data?.getAmount();
     }
     getSwapFee() {
         return { inInputToken: this.swapFee, inOutputToken: this.swapFeeInToken };

package/dist/swaps/{FromBtcBaseSwapHandler.d.ts → escrow/FromBtcBaseSwapHandler.d.ts}

@@ -1,16 +1,19 @@
-import { SwapHandlerSwap } from "./SwapHandlerSwap";
 import { SwapData } from "@atomiqlabs/base";
-import { RequestData, SwapBaseConfig, SwapHandler } from "./SwapHandler";
-import { IParamReader } from "../utils/paramcoders/IParamReader";
-import { FromBtcLnRequestType } from "./frombtcln_abstract/FromBtcLnAbs";
-import { FromBtcRequestType } from "./frombtc_abstract/FromBtcAbs";
+import { MultichainData, SwapBaseConfig } from "../SwapHandler";
+import { IParamReader } from "../../utils/paramcoders/IParamReader";
 import { Request } from "express";
-import { FromBtcLnTrustedRequestType } from "./frombtcln_trusted/FromBtcLnTrusted";
+import { EscrowHandler } from "./EscrowHandler";
+import { FromBtcBaseSwap } from "./FromBtcBaseSwap";
+import { FromBtcAmountAssertions } from "../assertions/FromBtcAmountAssertions";
+import { IIntermediaryStorage } from "../../storage/IIntermediaryStorage";
+import { ISwapPrice } from "../../prices/ISwapPrice";
 export type FromBtcBaseConfig = SwapBaseConfig & {
     securityDepositAPY: number;
 };
-export declare abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S>, S> extends SwapHandler<V, S> {
+export declare abstract class FromBtcBaseSwapHandler<V extends FromBtcBaseSwap<SwapData, S>, S> extends EscrowHandler<V, S> {
     abstract config: FromBtcBaseConfig;
+    readonly AmountAssertions: FromBtcAmountAssertions;
+    constructor(storageDirectory: IIntermediaryStorage<V>, path: string, chainsData: MultichainData, swapPricing: ISwapPrice, config: FromBtcBaseConfig);
     /**
      * Starts a pre-fetch for swap price & security deposit price
      *
@@ -60,48 +63,6 @@ export declare abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<S
      * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
      */
     protected checkAllowedDepositToken(chainIdentifier: string, depositToken: string): void;
-    /**
-     * Checks minimums/maximums, calculates the fee & total amount
-     *
-     * @param request
-     * @param requestedAmount
-     * @param useToken
-     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
-     */
-    protected preCheckAmounts(request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>, requestedAmount: {
-        input: boolean;
-        amount: bigint;
-    }, useToken: string): Promise<{
-        baseFee: bigint;
-        feePPM: bigint;
-        securityDepositApyPPM?: bigint;
-        securityDepositBaseMultiplierPPM?: bigint;
-    }>;
-    /**
-     * Checks minimums/maximums, calculates the fee & total amount
-     *
-     * @param request
-     * @param requestedAmount
-     * @param fees
-     * @param useToken
-     * @param signal
-     * @param pricePrefetchPromise
-     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
-     */
-    protected checkFromBtcAmount(request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>, requestedAmount: {
-        input: boolean;
-        amount: bigint;
-    }, fees: {
-        baseFee: bigint;
-        feePPM: bigint;
-    }, useToken: string, signal: AbortSignal, pricePrefetchPromise?: Promise<bigint>): Promise<{
-        amountBD: bigint;
-        swapFee: bigint;
-        swapFeeInToken: bigint;
-        totalInToken: bigint;
-        securityDepositApyPPM?: bigint;
-        securityDepositBaseMultiplierPPM?: bigint;
-    }>;
     /**
      * Signs the created swap
      *

package/dist/swaps/{FromBtcBaseSwapHandler.js → escrow/FromBtcBaseSwapHandler.js}

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcBaseSwapHandler = void 0;
-const SwapHandler_1 = require("./SwapHandler");
-const SchemaVerifier_1 = require("../utils/paramcoders/SchemaVerifier");
-const PluginManager_1 = require("../plugins/PluginManager");
-const IPlugin_1 = require("../plugins/IPlugin");
+const SchemaVerifier_1 = require("../../utils/paramcoders/SchemaVerifier");
+const EscrowHandler_1 = require("./EscrowHandler");
+const FromBtcAmountAssertions_1 = require("../assertions/FromBtcAmountAssertions");
 const secondsInYear = BigInt(365 * 24 * 60 * 60);
-class FromBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
+class FromBtcBaseSwapHandler extends EscrowHandler_1.EscrowHandler {
+    constructor(storageDirectory, path, chainsData, swapPricing, config) {
+        super(storageDirectory, path, chainsData, swapPricing);
+        this.AmountAssertions = new FromBtcAmountAssertions_1.FromBtcAmountAssertions(config, swapPricing);
+    }
     /**
      * Starts a pre-fetch for swap price & security deposit price
      *
@@ -21,15 +24,15 @@ class FromBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
             abortController.abort(e);
             return null;
         });
-        const { swapContract } = this.getChain(chainIdentifier);
-        const gasTokenPricePrefetchPromise = useToken.toString() === swapContract.getNativeCurrencyAddress().toString() ?
+        const { chainInterface } = this.getChain(chainIdentifier);
+        const gasTokenPricePrefetchPromise = useToken.toString() === chainInterface.getNativeCurrencyAddress().toString() ?
             pricePrefetchPromise :
-            this.swapPricing.preFetchPrice(swapContract.getNativeCurrencyAddress(), chainIdentifier).catch(e => {
+            this.swapPricing.preFetchPrice(chainInterface.getNativeCurrencyAddress(), chainIdentifier).catch(e => {
                 this.logger.error("getFromBtcPricePrefetches(): gasTokenPricePrefetchPromise error: ", e);
                 abortController.abort(e);
                 return null;
             });
-        const depositTokenPricePrefetchPromise = depositToken === swapContract.getNativeCurrencyAddress() ?
+        const depositTokenPricePrefetchPromise = depositToken === chainInterface.getNativeCurrencyAddress() ?
             gasTokenPricePrefetchPromise :
             this.swapPricing.preFetchPrice(depositToken, chainIdentifier).catch(e => {
                 this.logger.error("getFromBtcPricePrefetches(): depositTokenPricePrefetchPromise error: ", e);
@@ -50,9 +53,9 @@ class FromBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
      */
     async getBaseSecurityDepositPrefetch(chainIdentifier, dummySwapData, depositToken, gasTokenPricePrefetchPromise, depositTokenPricePrefetchPromise, abortController) {
         //Solana workaround
-        const { swapContract } = this.getChain(chainIdentifier);
+        const { swapContract, chainInterface } = this.getChain(chainIdentifier);
         let feeResult;
-        const gasToken = swapContract.getNativeCurrencyAddress();
+        const gasToken = chainInterface.getNativeCurrencyAddress();
         if (swapContract.getRawRefundFee != null) {
             try {
                 feeResult = await swapContract.getRawRefundFee(dummySwapData);
@@ -124,9 +127,9 @@ class FromBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
      * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
      */
     checkAllowedDepositToken(chainIdentifier, depositToken) {
-        const { swapContract, allowedDepositTokens } = this.getChain(chainIdentifier);
+        const { chainInterface, allowedDepositTokens } = this.getChain(chainIdentifier);
         if (allowedDepositTokens == null) {
-            if (depositToken !== swapContract.getNativeCurrencyAddress())
+            if (depositToken !== chainInterface.getNativeCurrencyAddress())
                 throw {
                     code: 20190,
                     msg: "Unsupported deposit token"
@@ -140,130 +143,6 @@ class FromBtcBaseSwapHandler extends SwapHandler_1.SwapHandler {
                 };
         }
     }
-    /**
-     * Checks minimums/maximums, calculates the fee & total amount
-     *
-     * @param request
-     * @param requestedAmount
-     * @param useToken
-     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
-     */
-    async preCheckAmounts(request, requestedAmount, useToken) {
-        const res = await PluginManager_1.PluginManager.onHandlePreFromBtcQuote(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);
-            if ((0, IPlugin_1.isQuoteSetFees)(res)) {
-                return {
-                    baseFee: res.baseFee || this.config.baseFee,
-                    feePPM: res.feePPM || this.config.feePPM,
-                    securityDepositApyPPM: res.securityDepositApyPPM,
-                    securityDepositBaseMultiplierPPM: res.securityDepositBaseMultiplierPPM
-                };
-            }
-        }
-        if (requestedAmount.input)
-            this.checkBtcAmountInBounds(requestedAmount.amount);
-        return {
-            baseFee: this.config.baseFee,
-            feePPM: this.config.feePPM
-        };
-    }
-    /**
-     * Checks minimums/maximums, calculates the fee & total amount
-     *
-     * @param request
-     * @param requestedAmount
-     * @param fees
-     * @param useToken
-     * @param signal
-     * @param pricePrefetchPromise
-     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
-     */
-    async checkFromBtcAmount(request, requestedAmount, fees, useToken, signal, pricePrefetchPromise = Promise.resolve(null)) {
-        const chainIdentifier = request.chainIdentifier;
-        let securityDepositApyPPM;
-        let securityDepositBaseMultiplierPPM;
-        const res = await PluginManager_1.PluginManager.onHandlePostFromBtcQuote(request, requestedAmount, chainIdentifier, useToken, { minInBtc: this.config.min, maxInBtc: this.config.max }, { baseFeeInBtc: fees.baseFee, feePPM: fees.feePPM }, pricePrefetchPromise);
-        signal.throwIfAborted();
-        if (res != null) {
-            this.handlePluginErrorResponses(res);
-            if ((0, IPlugin_1.isQuoteSetFees)(res)) {
-                if (res.baseFee != null)
-                    fees.baseFee = res.baseFee;
-                if (res.feePPM != null)
-                    fees.feePPM = res.feePPM;
-                if (res.securityDepositApyPPM != null)
-                    securityDepositApyPPM = res.securityDepositApyPPM;
-                if (res.securityDepositBaseMultiplierPPM != null)
-                    securityDepositBaseMultiplierPPM = res.securityDepositBaseMultiplierPPM;
-            }
-            if ((0, IPlugin_1.isPluginQuote)(res)) {
-                if (!requestedAmount.input) {
-                    return {
-                        amountBD: res.amount.amount + res.swapFee.inInputTokens,
-                        swapFee: res.swapFee.inInputTokens,
-                        swapFeeInToken: res.swapFee.inOutputTokens,
-                        totalInToken: requestedAmount.amount
-                    };
-                }
-                else {
-                    return {
-                        amountBD: requestedAmount.amount,
-                        swapFee: res.swapFee.inInputTokens,
-                        swapFeeInToken: res.swapFee.inOutputTokens,
-                        totalInToken: res.amount.amount
-                    };
-                }
-            }
-        }
-        let amountBD;
-        if (!requestedAmount.input) {
-            amountBD = await this.swapPricing.getToBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, true, pricePrefetchPromise);
-            signal.throwIfAborted();
-            // amt = (amt+base_fee)/(1-fee)
-            amountBD = (amountBD + fees.baseFee) * 1000000n / (1000000n - fees.feePPM);
-            const tooLow = amountBD < (this.config.min * 95n / 100n);
-            const tooHigh = amountBD > (this.config.max * 105n / 100n);
-            if (tooLow || tooHigh) {
-                const adjustedMin = this.config.min * (1000000n - fees.feePPM) / (1000000n - fees.baseFee);
-                const adjustedMax = this.config.max * (1000000n - fees.feePPM) / (1000000n - fees.baseFee);
-                const minIn = await this.swapPricing.getFromBtcSwapAmount(adjustedMin, useToken, chainIdentifier, null, pricePrefetchPromise);
-                const maxIn = await this.swapPricing.getFromBtcSwapAmount(adjustedMax, useToken, chainIdentifier, null, pricePrefetchPromise);
-                throw {
-                    code: tooLow ? 20003 : 20004,
-                    msg: tooLow ? "Amount too low!" : "Amount too high!",
-                    data: {
-                        min: minIn.toString(10),
-                        max: maxIn.toString(10)
-                    }
-                };
-            }
-        }
-        else {
-            amountBD = requestedAmount.amount;
-            this.checkBtcAmountInBounds(amountBD);
-        }
-        const swapFee = fees.baseFee + (amountBD * fees.feePPM / 1000000n);
-        const swapFeeInToken = await this.swapPricing.getFromBtcSwapAmount(swapFee, useToken, chainIdentifier, true, pricePrefetchPromise);
-        signal.throwIfAborted();
-        let totalInToken;
-        if (!requestedAmount.input) {
-            totalInToken = requestedAmount.amount;
-        }
-        else {
-            const amountInToken = await this.swapPricing.getFromBtcSwapAmount(requestedAmount.amount, useToken, chainIdentifier, null, pricePrefetchPromise);
-            totalInToken = amountInToken - swapFeeInToken;
-            signal.throwIfAborted();
-        }
-        return {
-            amountBD,
-            swapFee,
-            swapFeeInToken,
-            totalInToken,
-            securityDepositApyPPM,
-            securityDepositBaseMultiplierPPM
-        };
-    }
     /**
      * Signs the created swap
      *

package/dist/swaps/{ToBtcBaseSwap.d.ts → escrow/ToBtcBaseSwap.d.ts}

@@ -1,6 +1,6 @@
-import { SwapHandlerSwap } from "./SwapHandlerSwap";
 import { SwapData } from "@atomiqlabs/base";
-export declare abstract class ToBtcBaseSwap<T extends SwapData = SwapData, S = any> extends SwapHandlerSwap<T, S> {
+import { EscrowHandlerSwap } from "./EscrowHandlerSwap";
+export declare abstract class ToBtcBaseSwap<T extends SwapData = SwapData, S = any> extends EscrowHandlerSwap<T, S> {
     amount: bigint;
     quotedNetworkFee: bigint;
     readonly quotedNetworkFeeInToken: bigint;

package/dist/swaps/{ToBtcBaseSwap.js → escrow/ToBtcBaseSwap.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToBtcBaseSwap = void 0;
-const SwapHandlerSwap_1 = require("./SwapHandlerSwap");
-const Utils_1 = require("../utils/Utils");
-class ToBtcBaseSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
+const Utils_1 = require("../../utils/Utils");
+const EscrowHandlerSwap_1 = require("./EscrowHandlerSwap");
+class ToBtcBaseSwap extends EscrowHandlerSwap_1.EscrowHandlerSwap {
     constructor(obj, amount, swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken) {
         if (typeof (obj) === "string" && typeof (amount) === "bigint" && typeof (swapFee) === "bigint" && typeof (swapFeeInToken) === "bigint" &&
             typeof (quotedNetworkFee) === "bigint" && typeof (quotedNetworkFeeInToken) === "bigint") {
@@ -38,7 +38,7 @@ class ToBtcBaseSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
         }
     }
     getInputAmount() {
-        return this.data.getAmount() - this.getSwapFee().inInputToken - this.getQuotedNetworkFee().inInputToken;
+        return this.getTotalInputAmount() - this.getSwapFee().inInputToken - this.getQuotedNetworkFee().inInputToken;
     }
     getTotalInputAmount() {
         return this.data.getAmount();

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

@@ -0,0 +1,53 @@
+import { MultichainData, SwapBaseConfig } from "../SwapHandler";
+import { SwapData } from "@atomiqlabs/base";
+import { ServerParamEncoder } from "../../utils/paramcoders/server/ServerParamEncoder";
+import { IParamReader } from "../../utils/paramcoders/IParamReader";
+import { Request } from "express";
+import { ToBtcBaseSwap } from "./ToBtcBaseSwap";
+import { EscrowHandler } from "./EscrowHandler";
+import { ToBtcAmountAssertions } from "../assertions/ToBtcAmountAssertions";
+import { IIntermediaryStorage } from "../../storage/IIntermediaryStorage";
+import { ISwapPrice } from "../../prices/ISwapPrice";
+export type ToBtcBaseConfig = SwapBaseConfig & {
+    gracePeriod: bigint;
+    refundAuthorizationTimeout: number;
+};
+export declare abstract class ToBtcBaseSwapHandler<V extends ToBtcBaseSwap<SwapData, S>, S> extends EscrowHandler<V, S> {
+    readonly AmountAssertions: ToBtcAmountAssertions;
+    readonly pdaExistsForToken: {
+        [chainIdentifier: string]: {
+            [token: string]: boolean;
+        };
+    };
+    constructor(storageDirectory: IIntermediaryStorage<V>, path: string, chainsData: MultichainData, swapPricing: ISwapPrice, config: ToBtcBaseConfig);
+    protected checkVaultInitialized(chainIdentifier: string, token: string): Promise<void>;
+    /**
+     * 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>;
+    };
+    /**
+     * Signs the created swap
+     *
+     * @param chainIdentifier
+     * @param swapObject
+     * @param req
+     * @param abortSignal
+     * @param signDataPrefetchPromise
+     */
+    protected getToBtcSignatureData(chainIdentifier: string, swapObject: SwapData, req: Request & {
+        paramReader: IParamReader;
+    }, abortSignal: AbortSignal, signDataPrefetchPromise?: Promise<any>): Promise<{
+        prefix: string;
+        timeout: string;
+        signature: string;
+        feeRate: string;
+    }>;
+}