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

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

@@ -1,17 +1,13 @@
-import {SwapHandlerSwap} from "./SwapHandlerSwap";
 import {SwapData} from "@atomiqlabs/base";
-import {RequestData, SwapBaseConfig, SwapHandler} from "./SwapHandler";
-import {IParamReader} from "../utils/paramcoders/IParamReader";
-import {FieldTypeEnum} from "../utils/paramcoders/SchemaVerifier";
-import {FromBtcLnRequestType} from "./frombtcln_abstract/FromBtcLnAbs";
-import {FromBtcRequestType} from "./frombtc_abstract/FromBtcAbs";
-import {PluginManager} from "../plugins/PluginManager";
-import {
-    isPluginQuote,
-    isQuoteSetFees
-} from "../plugins/IPlugin";
+import {MultichainData, SwapBaseConfig} from "../SwapHandler";
+import {IParamReader} from "../../utils/paramcoders/IParamReader";
+import {FieldTypeEnum} from "../../utils/paramcoders/SchemaVerifier";
 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";
 
 const secondsInYear = BigInt(365*24*60*60);
 
@@ -19,10 +15,23 @@ export type FromBtcBaseConfig = SwapBaseConfig & {
     securityDepositAPY: number
 };
 
-export abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S>, S> extends SwapHandler<V, S> {
+export 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
+    ) {
+        super(storageDirectory, path, chainsData, swapPricing);
+        this.AmountAssertions = new FromBtcAmountAssertions(config, swapPricing);
+    }
+
     /**
      * Starts a pre-fetch for swap price & security deposit price
      *
@@ -41,15 +50,15 @@ export abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData,
             abortController.abort(e);
             return null;
         });
-        const {swapContract} = this.getChain(chainIdentifier);
-        const gasTokenPricePrefetchPromise: Promise<bigint> = useToken.toString()===swapContract.getNativeCurrencyAddress().toString() ?
+        const {chainInterface} = this.getChain(chainIdentifier);
+        const gasTokenPricePrefetchPromise: Promise<bigint> = 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: Promise<bigint> = depositToken===swapContract.getNativeCurrencyAddress() ?
+        const depositTokenPricePrefetchPromise: Promise<bigint> = depositToken===chainInterface.getNativeCurrencyAddress() ?
             gasTokenPricePrefetchPromise :
             this.swapPricing.preFetchPrice(depositToken, chainIdentifier).catch(e => {
                 this.logger.error("getFromBtcPricePrefetches(): depositTokenPricePrefetchPromise error: ", e);
@@ -75,9 +84,9 @@ export abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData,
         abortController: AbortController
     ): Promise<bigint> {
         //Solana workaround
-        const {swapContract} = this.getChain(chainIdentifier);
+        const {swapContract, chainInterface} = this.getChain(chainIdentifier);
         let feeResult: bigint;
-        const gasToken = swapContract.getNativeCurrencyAddress();
+        const gasToken = chainInterface.getNativeCurrencyAddress();
         if (swapContract.getRawRefundFee != null) {
             try {
                 feeResult = await swapContract.getRawRefundFee(dummySwapData);
@@ -147,9 +156,9 @@ export abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData,
      * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
      */
     protected checkAllowedDepositToken(chainIdentifier: string, depositToken: string): void {
-        const {swapContract, allowedDepositTokens} = this.getChain(chainIdentifier);
+        const {chainInterface, allowedDepositTokens} = this.getChain(chainIdentifier);
         if(allowedDepositTokens==null) {
-            if(depositToken!==swapContract.getNativeCurrencyAddress()) throw {
+            if(depositToken!==chainInterface.getNativeCurrencyAddress()) throw {
                 code: 20190,
                 msg: "Unsupported deposit token"
             };
@@ -161,175 +170,6 @@ export abstract class FromBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData,
         }
     }
 
-
-    /**
-     * 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 async preCheckAmounts(
-        request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>,
-        requestedAmount: {input: boolean, amount: bigint},
-        useToken: string
-    ): Promise<{
-        baseFee: bigint,
-        feePPM: bigint,
-        securityDepositApyPPM?: bigint,
-        securityDepositBaseMultiplierPPM?: bigint,
-    }> {
-        const res = await 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(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
-     */
-    protected async checkFromBtcAmount(
-        request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>,
-        requestedAmount: {input: boolean, amount: bigint},
-        fees: {baseFee: bigint, feePPM: bigint},
-        useToken: string,
-        signal: AbortSignal,
-        pricePrefetchPromise: Promise<bigint> = Promise.resolve(null)
-    ): Promise<{
-        amountBD: bigint,
-        swapFee: bigint, //Swap fee in BTC
-        swapFeeInToken: bigint, //Swap fee in token on top of what should be paid out to the user
-        totalInToken: bigint, //Total to be paid out to the user
-        securityDepositApyPPM?: bigint,
-        securityDepositBaseMultiplierPPM?: bigint
-    }> {
-        const chainIdentifier = request.chainIdentifier;
-
-        let securityDepositApyPPM: bigint;
-        let securityDepositBaseMultiplierPPM: bigint;
-
-        const res = await 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(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(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: bigint;
-        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: bigint;
-        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/src/swaps/{ToBtcBaseSwap.ts → escrow/ToBtcBaseSwap.ts}

@@ -1,9 +1,8 @@
-import {SwapHandlerSwap} from "./SwapHandlerSwap";
 import {SwapData} from "@atomiqlabs/base";
-import {deserializeBN, serializeBN} from "../utils/Utils";
+import {deserializeBN, serializeBN} from "../../utils/Utils";
+import {EscrowHandlerSwap} from "./EscrowHandlerSwap";
 
-
-export abstract class ToBtcBaseSwap<T extends SwapData = SwapData, S = any> extends SwapHandlerSwap<T, S> {
+export abstract class ToBtcBaseSwap<T extends SwapData = SwapData, S = any> extends EscrowHandlerSwap<T, S> {
 
     amount: bigint;
 
@@ -53,7 +52,7 @@ export abstract class ToBtcBaseSwap<T extends SwapData = SwapData, S = any> exte
     }
 
     getInputAmount(): bigint {
-        return this.data.getAmount() - this.getSwapFee().inInputToken - this.getQuotedNetworkFee().inInputToken;
+        return this.getTotalInputAmount() - this.getSwapFee().inInputToken - this.getQuotedNetworkFee().inInputToken;
     }
 
     getTotalInputAmount(): bigint {

package/src/swaps/escrow/ToBtcBaseSwapHandler.ts

@@ -0,0 +1,130 @@
+import {MultichainData, SwapBaseConfig} from "../SwapHandler";
+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 {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 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
+    ) {
+        super(storageDirectory, path, chainsData, swapPricing);
+        this.AmountAssertions = new ToBtcAmountAssertions(config, swapPricing);
+    }
+
+    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!"
+                };
+            }
+        }
+    }
+
+    /**
+     * 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/{frombtc_abstract → escrow/frombtc_abstract}/FromBtcAbs.ts

@@ -1,7 +1,7 @@
 import {Express, Request, Response} from "express";
 import {FromBtcSwapAbs, FromBtcSwapState} from "./FromBtcSwapAbs";
-import {MultichainData, SwapHandlerType} from "../SwapHandler";
-import {ISwapPrice} from "../ISwapPrice";
+import {MultichainData, SwapHandlerType} from "../../SwapHandler";
+import {ISwapPrice} from "../../../prices/ISwapPrice";
 import {
     BigIntBufferUtils,
     ChainSwapType,
@@ -11,15 +11,15 @@ import {
     SwapData
 } from "@atomiqlabs/base";
 import {randomBytes} from "crypto";
-import {expressHandlerWrapper} from "../../utils/Utils";
-import {PluginManager} from "../../plugins/PluginManager";
-import {IIntermediaryStorage} from "../../storage/IIntermediaryStorage";
-import {FieldTypeEnum} from "../../utils/paramcoders/SchemaVerifier";
-import {serverParamDecoder} from "../../utils/paramcoders/server/ServerParamDecoder";
-import {IParamReader} from "../../utils/paramcoders/IParamReader";
-import {ServerParamEncoder} from "../../utils/paramcoders/server/ServerParamEncoder";
+import {expressHandlerWrapper, getAbortController} from "../../../utils/Utils";
+import {PluginManager} from "../../../plugins/PluginManager";
+import {IIntermediaryStorage} from "../../../storage/IIntermediaryStorage";
+import {FieldTypeEnum} from "../../../utils/paramcoders/SchemaVerifier";
+import {serverParamDecoder} from "../../../utils/paramcoders/server/ServerParamDecoder";
+import {IParamReader} from "../../../utils/paramcoders/IParamReader";
+import {ServerParamEncoder} from "../../../utils/paramcoders/server/ServerParamEncoder";
 import {FromBtcBaseConfig, FromBtcBaseSwapHandler} from "../FromBtcBaseSwapHandler";
-import {IBitcoinWallet} from "../../wallets/IBitcoinWallet";
+import {IBitcoinWallet} from "../../../wallets/IBitcoinWallet";
 
 export type FromBtcConfig = FromBtcBaseConfig & {
     confirmations: number,
@@ -53,7 +53,7 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
         swapPricing: ISwapPrice,
         config: FromBtcConfig
     ) {
-        super(storageDirectory, path, chains, swapPricing);
+        super(storageDirectory, path, chains, swapPricing, config);
         this.bitcoin = bitcoin;
         this.config = {
             ...config,
@@ -97,8 +97,8 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
             }
 
             this.swapLogger.info(swap, "processPastSwap(state=CREATED): removing past swap due to authorization expiry, address: "+swap.address);
-            await this.bitcoin.addUnusedAddress(swap.address);
             await this.removeSwapData(swap, FromBtcSwapState.CANCELED);
+            await this.bitcoin.addUnusedAddress(swap.address);
             return false;
         }
 
@@ -182,8 +182,8 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
         savedSwap.txIds.refund = (event as any).meta?.txId;
 
         this.swapLogger.info(event, "SC: RefundEvent: swap refunded, address: "+savedSwap.address);
-        await this.bitcoin.addUnusedAddress(savedSwap.address);
         await this.removeSwapData(savedSwap, FromBtcSwapState.REFUNDED);
+        await this.bitcoin.addUnusedAddress(savedSwap.address);
     }
 
     /**
@@ -255,8 +255,8 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
             } = {request: {}, times: {}};
 
             const chainIdentifier = req.query.chain as string ?? this.chains.default;
-            const {swapContract, signer} = this.getChain(chainIdentifier);
-            const depositToken = req.query.depositToken as string ?? swapContract.getNativeCurrencyAddress();
+            const {swapContract, signer, chainInterface} = this.getChain(chainIdentifier);
+            const depositToken = req.query.depositToken as string ?? chainInterface.getNativeCurrencyAddress();
             this.checkAllowedDepositToken(chainIdentifier, depositToken);
 
             metadata.times.requestReceived = Date.now();
@@ -279,7 +279,7 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
             const parsedBody: FromBtcRequestType = await req.paramReader.getParams({
                 address: (val: string) => val!=null &&
                         typeof(val)==="string" &&
-                        swapContract.isValidAddress(val) ? val : null,
+                        chainInterface.isValidAddress(val) ? val : null,
                 amount: FieldTypeEnum.BigInt,
                 token: (val: string) => val!=null &&
                         typeof(val)==="string" &&
@@ -293,7 +293,7 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
             };
             metadata.request = parsedBody;
 
-            const requestedAmount = {input: !parsedBody.exactOut, amount: parsedBody.amount};
+            const requestedAmount = {input: !parsedBody.exactOut, amount: parsedBody.amount, token: parsedBody.token};
             const request = {
                 chainIdentifier,
                 raw: req,
@@ -304,12 +304,12 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
 
             //Check request params
             this.checkSequence(parsedBody.sequence);
-            const fees = await this.preCheckAmounts(request, requestedAmount, useToken);
+            const fees = await this.AmountAssertions.preCheckFromBtcAmounts(this.type, request, requestedAmount);
             metadata.times.requestChecked = Date.now();
 
             //Create abortController for parallel prefetches
             const responseStream = res.responseStream;
-            const abortController = this.getAbortController(responseStream);
+            const abortController = getAbortController(responseStream);
 
             //Pre-fetch data
             const {
@@ -336,7 +336,7 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
                 totalInToken,
                 securityDepositApyPPM,
                 securityDepositBaseMultiplierPPM
-            } = await this.checkFromBtcAmount(request, requestedAmount, fees, useToken, abortController.signal, pricePrefetchPromise);
+            } = await this.AmountAssertions.checkFromBtcAmount(this.type, request, {...requestedAmount, pricePrefetch: pricePrefetchPromise}, fees, abortController.signal);
             metadata.times.priceCalculated = Date.now();
 
             if(securityDepositApyPPM!=null) fees.securityDepositApyPPM = securityDepositApyPPM;

package/src/swaps/{frombtc_abstract → escrow/frombtc_abstract}/FromBtcSwapAbs.ts

@@ -1,5 +1,5 @@
 import {SwapData} from "@atomiqlabs/base";
-import {SwapHandlerType} from "../SwapHandler";
+import {SwapHandlerType} from "../../SwapHandler";
 import {FromBtcBaseSwap} from "../FromBtcBaseSwap";
 
 export enum FromBtcSwapState {