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

package/src/swaps/spv_vault_swap/SpvVaults.ts

@@ -0,0 +1,441 @@
+import {SpvVault, SpvVaultState} from "./SpvVault";
+import {
+    BitcoinRpc,
+    IStorageManager,
+    SpvVaultClaimEvent,
+    SpvVaultCloseEvent,
+    SpvVaultDepositEvent,
+    SpvVaultOpenEvent, SpvWithdrawalTransactionData
+} from "@atomiqlabs/base";
+import {SpvVaultSwap} from "./SpvVaultSwap";
+import {bigIntSorter} from "../../utils/Utils";
+import {PluginManager} from "../../plugins/PluginManager";
+import {IBitcoinWallet} from "../../wallets/IBitcoinWallet";
+import {ISpvVaultSigner} from "../../wallets/ISpvVaultSigner";
+import {AmountAssertions} from "../assertions/AmountAssertions";
+import {ChainData} from "../SwapHandler";
+import {Transaction} from "@scure/btc-signer";
+
+export const VAULT_DUST_AMOUNT = 600;
+const VAULT_INIT_CONFIRMATIONS = 2;
+const BTC_FINALIZATION_CONFIRMATIONS = 6;
+
+export class SpvVaults {
+
+    readonly vaultStorage: IStorageManager<SpvVault>;
+
+    readonly bitcoin: IBitcoinWallet;
+    readonly vaultSigner: ISpvVaultSigner;
+    readonly bitcoinRpc: BitcoinRpc<any>;
+    readonly config: {vaultsCheckInterval: number, maxUnclaimedWithdrawals?: number};
+    readonly getChain: (chainId: string) => ChainData
+
+    readonly logger = {
+        debug: (msg: string, ...args: any) => console.debug("SpvVaults: "+msg, ...args),
+        info: (msg: string, ...args: any) => console.info("SpvVaults: "+msg, ...args),
+        warn: (msg: string, ...args: any) => console.warn("SpvVaults: "+msg, ...args),
+        error: (msg: string, ...args: any) => console.error("SpvVaults: "+msg, ...args)
+    };
+
+    constructor(
+        vaultStorage: IStorageManager<SpvVault>,
+        bitcoin: IBitcoinWallet,
+        vaultSigner: ISpvVaultSigner,
+        bitcoinRpc: BitcoinRpc<any>,
+        getChain: (chainId: string) => ChainData,
+        config: {vaultsCheckInterval: number, maxUnclaimedWithdrawals?: number}
+    ) {
+        this.vaultStorage = vaultStorage;
+        this.bitcoin = bitcoin;
+        this.vaultSigner = vaultSigner;
+        this.bitcoinRpc = bitcoinRpc;
+        this.getChain = getChain;
+        this.config = config;
+    }
+
+    async processDepositEvent(vault: SpvVault, event: SpvVaultDepositEvent): Promise<void> {
+        vault.update(event);
+        await this.saveVault(vault);
+    }
+
+    async processOpenEvent(vault: SpvVault, event: SpvVaultOpenEvent): Promise<void> {
+        if(vault.state===SpvVaultState.BTC_CONFIRMED) {
+            vault.state = SpvVaultState.OPENED;
+        }
+        vault.update(event);
+        await this.saveVault(vault);
+    }
+
+    async processCloseEvent(vault: SpvVault, event: SpvVaultCloseEvent): Promise<void> {
+        if(vault.state===SpvVaultState.OPENED) {
+            vault.state = SpvVaultState.CLOSED;
+        }
+        vault.update(event);
+        await this.saveVault(vault);
+    }
+
+    async processClaimEvent(vault: SpvVault, swap: SpvVaultSwap | null, event: SpvVaultClaimEvent): Promise<void> {
+        //Update vault
+        const foundPendingWithdrawal = vault.pendingWithdrawals.findIndex(val => val.btcTx.txid===event.btcTxId);
+        if(foundPendingWithdrawal!==-1) vault.pendingWithdrawals.splice(foundPendingWithdrawal, 1);
+        vault.update(event);
+        await this.saveVault(vault);
+    }
+
+    async createVaults(chainId: string, count: number, token: string, confirmations: number = 2, feeRate?: number): Promise<{vaultsCreated: bigint[], btcTxId: string}> {
+        const {signer, chainInterface, tokenMultipliers, spvVaultContract} = this.getChain(chainId);
+
+        const signerAddress = signer.getAddress();
+
+        //Check vaultId of the latest saved vault
+        let latestVaultId: bigint = -1n;
+        for(let key in this.vaultStorage.data) {
+            const vault = this.vaultStorage.data[key];
+            if(vault.chainId!==chainId) continue;
+            if(vault.data.getOwner()!==signerAddress) continue;
+            if(vault.data.getVaultId() > latestVaultId) latestVaultId = vault.data.getVaultId();
+        }
+
+        latestVaultId++;
+
+        const vaultAddreses: {vaultId: bigint, address: string}[] = [];
+        for(let i=0;i<count;i++) {
+            const vaultId = latestVaultId + BigInt(i);
+            const address = await this.vaultSigner.getAddress(chainId, vaultId);
+            vaultAddreses.push({vaultId, address});
+        }
+
+        //Construct transaction
+        const txResult = await this.bitcoin.getSignedMultiTransaction(vaultAddreses.map(val => {
+            return {address: val.address, amount: VAULT_DUST_AMOUNT}
+        }), feeRate);
+
+        const nativeToken = chainInterface.getNativeCurrencyAddress();
+
+        const vaults = await Promise.all(vaultAddreses.map(async (val, index) => {
+            const vaultData = await spvVaultContract.createVaultData(signerAddress, val.vaultId, txResult.txId+":"+index, confirmations, [
+                {token, multiplier: tokenMultipliers?.[token] ?? 1n},
+                {token: nativeToken, multiplier: tokenMultipliers?.[nativeToken] ?? 1n}
+            ]);
+            return new SpvVault(chainId, vaultData, val.address);
+        }));
+
+        //Save vaults
+        if(this.vaultStorage.saveDataArr!=null) {
+            await this.vaultStorage.saveDataArr(vaults.map(val => {
+                return {id: val.getIdentifier(), object: val}
+            }));
+        } else {
+            for(let vault of vaults) {
+                await this.vaultStorage.saveData(vault.getIdentifier(), vault);
+            }
+        }
+
+        //Send bitcoin tx
+        await this.bitcoin.sendRawTransaction(txResult.raw);
+
+        this.logger.info("createVaults(): Funding "+count+" vaults, bitcoin txId: "+txResult.txId);
+
+        return {
+            vaultsCreated: vaults.map(val => val.data.getVaultId()),
+            btcTxId: txResult.txId
+        };
+    }
+
+    async listVaults(chainId?: string, token?: string) {
+        return Object.keys(this.vaultStorage.data)
+            .map(key => this.vaultStorage.data[key])
+            .filter(val => chainId==null ? true : val.chainId===chainId)
+            .filter(val => val.data.getOwner()===this.getChain(val.chainId)?.signer?.getAddress())
+            .filter(val => token==null ? true : val.data.getTokenData()[0].token===token);
+    }
+
+    async fundVault(vault: SpvVault, tokenAmounts: bigint[]): Promise<string> {
+        if(vault.state!==SpvVaultState.OPENED) throw new Error("Vault not opened!");
+
+        this.logger.info("fundVault(): Depositing tokens to the vault "+vault.data.getVaultId().toString(10)+", amounts: "+tokenAmounts.map(val => val.toString(10)).join(", "));
+
+        const {signer, spvVaultContract} = this.getChain(vault.chainId);
+
+        const txId = await spvVaultContract.deposit(signer, vault.data, tokenAmounts, {waitForConfirmation: true});
+
+        this.logger.info("fundVault(): Tokens deposited to vault "+vault.data.getVaultId().toString(10)+", amounts: "+tokenAmounts.map(val => val.toString(10)).join(", ")+", txId: "+txId);
+
+        return txId;
+    }
+
+    async withdrawFromVault(vault: SpvVault, tokenAmounts: bigint[], feeRate?: number): Promise<string> {
+        tokenAmounts.forEach((rawAmount, index) => {
+            if(vault.balances[index]==null) throw new Error("Token not found in the vault");
+            if(vault.balances[index].rawAmount<rawAmount) throw new Error("Not enough balance in the vault");
+        });
+
+        if(!vault.isReady()) throw new Error("Vault not ready, wait for the latest swap to get at least 1 confirmation!");
+
+        const {signer, spvVaultContract} = this.getChain(vault.chainId);
+
+        const latestUtxo = vault.getLatestUtxo();
+        const [txId, voutStr] = latestUtxo.split(":");
+
+        const opReturnData = spvVaultContract.toOpReturnData(signer.getAddress(), tokenAmounts);
+        let opReturnScript: Buffer;
+        if(opReturnData.length<76) {
+            opReturnScript = Buffer.concat([
+                Buffer.from([0x6a, opReturnData.length]),
+                opReturnData
+            ]);
+        } else {
+            opReturnScript = Buffer.concat([
+                Buffer.from([0x6a, 0x4c, opReturnData.length]),
+                opReturnData
+            ]);
+        }
+
+        let psbt = new Transaction({
+            allowUnknownOutputs: true
+        });
+        psbt.addInput({
+            txid: txId,
+            index: parseInt(voutStr),
+            witnessUtxo: {
+                amount: BigInt(VAULT_DUST_AMOUNT),
+                script: this.bitcoin.toOutputScript(vault.btcAddress)
+            }
+        });
+        psbt.addOutput({
+            amount: BigInt(VAULT_DUST_AMOUNT),
+            script: this.bitcoin.toOutputScript(vault.btcAddress)
+        });
+        psbt.addOutput({
+            amount: 0n,
+            script: opReturnScript
+        });
+
+        psbt = await this.bitcoin.fundPsbt(psbt, feeRate);
+        if(psbt.inputsLength<2) throw new Error("PSBT needs at least 2 inputs!");
+        psbt.updateInput(0, {sequence: 0x80000000});
+        psbt.updateInput(1, {sequence: 0x80000000});
+        psbt = await this.vaultSigner.signPsbt(vault.chainId, vault.data.getVaultId(), psbt, [0]);
+        const res = await this.bitcoin.signPsbt(psbt);
+
+        const parsedTransaction = await this.bitcoinRpc.parseTransaction(res.raw);
+        const withdrawalData = await spvVaultContract.getWithdrawalData(parsedTransaction);
+
+        if(withdrawalData.getSpentVaultUtxo()!==vault.getLatestUtxo()) {
+            throw new Error("Latest vault UTXO already spent! Please try again later.");
+        }
+        vault.addWithdrawal(withdrawalData);
+        await this.saveVault(vault);
+
+        try {
+            await this.bitcoin.sendRawTransaction(res.raw);
+        } catch (e) {
+            vault.removeWithdrawal(withdrawalData);
+            await this.saveVault(vault);
+            throw e;
+        }
+
+        return res.txId;
+    }
+
+    async checkVaults() {
+        const vaults = Object.keys(this.vaultStorage.data).map(key => this.vaultStorage.data[key]);
+
+        const claimWithdrawals: {vault: SpvVault, withdrawals: SpvWithdrawalTransactionData[]}[] = [];
+
+        for(let vault of vaults) {
+            const {signer, spvVaultContract, chainInterface} = this.getChain(vault.chainId);
+            if(vault.data.getOwner()!==signer.getAddress()) continue;
+
+            if(vault.state===SpvVaultState.BTC_INITIATED) {
+                //Check if btc tx confirmed
+                const txId = vault.initialUtxo.split(":")[0];
+                const btcTx = await this.bitcoinRpc.getTransaction(txId);
+                if(btcTx.confirmations >= VAULT_INIT_CONFIRMATIONS) {
+                    //Double-check the state here to prevent race condition
+                    if(vault.state===SpvVaultState.BTC_INITIATED) {
+                        vault.state = SpvVaultState.BTC_CONFIRMED;
+                        await this.saveVault(vault);
+                    }
+                    this.logger.info("checkVaults(): Vault ID "+vault.data.getVaultId().toString(10)+" confirmed on bitcoin, opening vault on "+vault.chainId);
+                }
+            }
+
+            if(vault.state===SpvVaultState.BTC_CONFIRMED) {
+                //Check if open txs were sent already
+                if(vault.scOpenTx!=null) {
+                    //Check if confirmed
+                    const status = await chainInterface.getTxStatus(vault.scOpenTx.rawTx);
+                    if(status==="pending") return;
+                    if(status==="success") {
+                        vault.state = SpvVaultState.OPENED;
+                        await this.saveVault(vault);
+                        return;
+                    }
+                }
+
+                const txs = await spvVaultContract.txsOpen(signer.getAddress(), vault.data);
+                let numTx = 0;
+                const txIds = await chainInterface.sendAndConfirm(
+                    signer, txs, true, undefined, false,
+                    async (txId: string, rawTx: string) => {
+                        numTx++;
+                        if(numTx===txs.length) {
+                            //Final tx
+                            vault.scOpenTx = {txId, rawTx};
+                            await this.saveVault(vault);
+                        }
+                    }
+                );
+                this.logger.info("checkVaults(): Vault ID "+vault.data.getVaultId().toString(10)+" opened on "+vault.chainId+" txId: "+txIds.join(", "));
+
+                vault.state = SpvVaultState.OPENED;
+                await this.saveVault(vault);
+            }
+
+            if(vault.state===SpvVaultState.OPENED) {
+                let changed = false;
+                //Check if some of the pendingWithdrawals got confirmed
+                let latestOwnWithdrawalIndex = -1;
+                let latestConfirmedWithdrawalIndex = -1;
+                for(let i=0; i<vault.pendingWithdrawals.length; i++) {
+                    const pendingWithdrawal = vault.pendingWithdrawals[i];
+                    //Check all the pending withdrawals that were not finalized yet
+                    if(pendingWithdrawal.btcTx.confirmations==null || pendingWithdrawal.btcTx.confirmations < BTC_FINALIZATION_CONFIRMATIONS) {
+                        const btcTx = await this.bitcoinRpc.getTransaction(pendingWithdrawal.btcTx.txid);
+                        if(btcTx==null) {
+                            //Probable double-spend, remove from pending withdrawals
+                            const index = vault.pendingWithdrawals.indexOf(pendingWithdrawal);
+                            if(index===-1) {
+                                this.logger.warn("checkVaults(): Tried to remove pending withdrawal txId: "+pendingWithdrawal.btcTx.txid+", but doesn't exist anymore!")
+                            } else {
+                                vault.pendingWithdrawals.splice(index, 1);
+                            }
+                            changed = true;
+                        } else {
+                            //Update confirmations count
+                            if(
+                                pendingWithdrawal.btcTx.confirmations !== btcTx.confirmations ||
+                                pendingWithdrawal.btcTx.blockhash !== btcTx.blockhash
+                            ) {
+                                pendingWithdrawal.btcTx.confirmations = btcTx.confirmations;
+                                pendingWithdrawal.btcTx.blockhash = btcTx.blockhash;
+                                changed = true;
+                            }
+                        }
+                    }
+                    //Check it has enough confirmations
+                    if(pendingWithdrawal.btcTx.confirmations >= vault.data.getConfirmations()) {
+                        latestConfirmedWithdrawalIndex = i;
+                        //Check if the pending withdrawals contain a withdrawal to our own address
+                        if (pendingWithdrawal.isRecipient(signer.getAddress())) {
+                            latestOwnWithdrawalIndex = i;
+                        }
+                    }
+                }
+                if(changed) {
+                    await this.saveVault(vault);
+                }
+                if(this.config.maxUnclaimedWithdrawals!=null && latestConfirmedWithdrawalIndex+1 >= this.config.maxUnclaimedWithdrawals) {
+                    this.logger.info("checkVaults(): Processing withdrawals by self, because a lot of them are unclaimed!");
+                    claimWithdrawals.push({vault, withdrawals: vault.pendingWithdrawals.slice(0, latestConfirmedWithdrawalIndex+1)});
+                } else if(latestOwnWithdrawalIndex!==-1) {
+                    claimWithdrawals.push({vault, withdrawals: vault.pendingWithdrawals.slice(0, latestOwnWithdrawalIndex+1)});
+                }
+            }
+        }
+
+        for(let {vault, withdrawals} of claimWithdrawals) {
+            if(!await this.claimWithdrawals(vault, withdrawals)) {
+                this.logger.error("checkVaults(): Cannot process withdrawals "+withdrawals.map(val => val.btcTx.txid).join(", ")+" for vault: "+vault.data.getVaultId());
+                break;
+            }
+        }
+    }
+
+    async claimWithdrawals(vault: SpvVault, withdrawal: SpvWithdrawalTransactionData[]): Promise<boolean> {
+        const {signer, spvVaultContract} = this.getChain(vault.chainId);
+
+        try {
+            const txId = await spvVaultContract.claim(signer, vault.data, withdrawal.map(tx => {
+                return {tx};
+            }), undefined, true, {waitForConfirmation: true});
+            this.logger.info("claimWithdrawal(): Successfully claimed withdrawals, btcTxIds: "+withdrawal.map(val => val.btcTx.txid).join(", ")+" smartChainTxId: "+txId);
+            return true;
+        } catch (e) {
+            this.logger.error("claimWithdrawal(): Tried to claim but got error: ", e);
+            return false;
+        }
+    }
+
+    async getVault(chainId: string, owner: string, vaultId: bigint) {
+        return this.vaultStorage.data[chainId+"_"+owner+"_"+vaultId.toString(10)];
+    }
+
+    /**
+     * Returns a ready-to-use vault for a specific request
+     *
+     * @param chainIdentifier
+     * @param totalSats
+     * @param token
+     * @param amount
+     * @param gasToken
+     * @param gasTokenAmount
+     * @protected
+     */
+    async findVaultForSwap(chainIdentifier: string, totalSats: bigint, token: string, amount: bigint, gasToken: string, gasTokenAmount: bigint): Promise<SpvVault | null> {
+        const {signer} = this.getChain(chainIdentifier);
+
+        const pluginResponse = await PluginManager.onVaultSelection(
+            chainIdentifier, totalSats, {token, amount}, {token: gasToken, amount: gasTokenAmount}
+        );
+        if(pluginResponse!=null) {
+            AmountAssertions.handlePluginErrorResponses(pluginResponse);
+            return pluginResponse as SpvVault;
+        }
+
+        const candidates = Object.keys(this.vaultStorage.data)
+            .map(key => this.vaultStorage.data[key])
+            .filter(vault =>
+                vault.chainId===chainIdentifier && vault.data.getOwner()===signer.getAddress() && vault.isReady()
+            )
+            .filter(vault => {
+                const token0 = vault.balances[0];
+                if(token0.token!==token || token0.scaledAmount < amount) return false;
+                if(gasToken!=null && gasTokenAmount!==0n) {
+                    const token1 = vault.balances[1];
+                    if(token1.token!==gasToken || token1.scaledAmount < gasTokenAmount) return false;
+                }
+                return true;
+            });
+
+        candidates.sort((a, b) => bigIntSorter(a.balances[0].scaledAmount, b.balances[0].scaledAmount));
+
+        const result = candidates[0];
+
+        if(result==null) throw {
+            code: 20301,
+            msg: "No suitable swap vault found, try again later!"
+        };
+
+        return result;
+    }
+
+    saveVault(vault: SpvVault) {
+        return this.vaultStorage.saveData(vault.getIdentifier(), vault);
+    }
+
+    async startVaultsWatchdog() {
+        let rerun: () => Promise<void>;
+        rerun = async () => {
+            await this.checkVaults().catch( e => console.error(e));
+            setTimeout(rerun, this.config.vaultsCheckInterval);
+        };
+        await rerun();
+    }
+
+    async init() {
+        const vaults = await this.vaultStorage.loadData(SpvVault);
+    }
+
+}

package/src/swaps/{frombtc_trusted → trusted/frombtc_trusted}/FromBtcTrusted.ts

@@ -1,27 +1,18 @@
-import {FromBtcBaseConfig, FromBtcBaseSwapHandler} from "../FromBtcBaseSwapHandler";
 import {FromBtcTrustedSwap, FromBtcTrustedSwapState} from "./FromBtcTrustedSwap";
-import {
-    BitcoinRpc,
-    BtcBlock,
-    BtcTx,
-    BtcVout,
-    ClaimEvent,
-    InitializeEvent,
-    RefundEvent,
-    SwapData
-} from "@atomiqlabs/base";
+import {BitcoinRpc, BtcBlock, BtcTx, BtcVout} from "@atomiqlabs/base";
 import {Express, Request, Response} from "express";
-import {MultichainData, SwapHandlerType} from "../SwapHandler";
-import {IIntermediaryStorage} from "../../storage/IIntermediaryStorage";
-import {ISwapPrice} from "../ISwapPrice";
-import {PluginManager} from "../../plugins/PluginManager";
-import {expressHandlerWrapper, HEX_REGEX} from "../../utils/Utils";
-import {IParamReader} from "../../utils/paramcoders/IParamReader";
-import {ServerParamEncoder} from "../../utils/paramcoders/server/ServerParamEncoder";
-import {FieldTypeEnum, verifySchema} from "../../utils/paramcoders/SchemaVerifier";
-import {IBitcoinWallet} from "../../wallets/IBitcoinWallet";
-
-export type FromBtcTrustedConfig = FromBtcBaseConfig & {
+import {MultichainData, SwapBaseConfig, SwapHandler, SwapHandlerType} from "../../SwapHandler";
+import {IIntermediaryStorage} from "../../../storage/IIntermediaryStorage";
+import {ISwapPrice} from "../../../prices/ISwapPrice";
+import {PluginManager} from "../../../plugins/PluginManager";
+import {expressHandlerWrapper, getAbortController, HEX_REGEX} from "../../../utils/Utils";
+import {IParamReader} from "../../../utils/paramcoders/IParamReader";
+import {ServerParamEncoder} from "../../../utils/paramcoders/server/ServerParamEncoder";
+import {FieldTypeEnum, verifySchema} from "../../../utils/paramcoders/SchemaVerifier";
+import {IBitcoinWallet} from "../../../wallets/IBitcoinWallet";
+import {FromBtcAmountAssertions} from "../../assertions/FromBtcAmountAssertions";
+
+export type FromBtcTrustedConfig = SwapBaseConfig & {
     doubleSpendCheckInterval: number,
     swapAddressExpiry: number,
     recommendFeeMultiplier?: number
@@ -35,9 +26,8 @@ export type FromBtcTrustedRequestType = {
     token?: string
 };
 
-export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, FromBtcTrustedSwapState> {
-    readonly type: SwapHandlerType = SwapHandlerType.FROM_BTC_TRUSTED;
-    readonly swapType = null;
+export class FromBtcTrusted extends SwapHandler<FromBtcTrustedSwap, FromBtcTrustedSwapState> {
+    readonly type = SwapHandlerType.FROM_BTC_TRUSTED;
 
     readonly config: FromBtcTrustedConfig;
     readonly bitcoin: IBitcoinWallet;
@@ -50,6 +40,8 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
     readonly doubleSpentSwaps: Map<string, string> = new Map();
     readonly processedTxIds: Map<string, { scTxId: string, txId: string, adjustedAmount: bigint, adjustedTotal: bigint }> = new Map();
 
+    readonly AmountAssertions: FromBtcAmountAssertions;
+
     constructor(
         storageDirectory: IIntermediaryStorage<FromBtcTrustedSwap>,
         path: string,
@@ -60,6 +52,7 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
         config: FromBtcTrustedConfig
     ) {
         super(storageDirectory, path, chains, swapPricing);
+        this.AmountAssertions = new FromBtcAmountAssertions(config, swapPricing);
         this.config = config;
         this.config.recommendFeeMultiplier ??= 1.25;
         this.bitcoin = bitcoin;
@@ -166,7 +159,7 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
     protected async processPastSwap(swap: FromBtcTrustedSwap, tx: BtcTx | null, vout: number | null): Promise<void> {
         const foundVout: BtcVout = tx.outs[vout];
 
-        const {swapContract, signer} = this.getChain(swap.chainIdentifier);
+        const {chainInterface, signer} = this.getChain(swap.chainIdentifier);
 
         const outputScript = this.bitcoin.toOutputScript(swap.btcAddress).toString("hex");
 
@@ -279,7 +272,7 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
 
         if(swap.state===FromBtcTrustedSwapState.BTC_CONFIRMED) {
             //Send gas token
-            const balance: Promise<bigint> = swapContract.getBalance(signer.getAddress(), swap.token, false);
+            const balance: Promise<bigint> = chainInterface.getBalance(signer.getAddress(), swap.token);
             try {
                 await this.checkBalance(swap.adjustedOutput, balance, null);
                 if(swap.metadata!=null) swap.metadata.times.receivedBalanceChecked = Date.now();
@@ -294,8 +287,8 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
             let unlock = swap.lock(30*1000);
             if(unlock==null) return;
 
-            const txns = await swapContract.txsTransfer(signer.getAddress(), swap.token, swap.adjustedOutput, swap.dstAddress);
-            await swapContract.sendAndConfirm(signer, txns, true, null, false, async (txId: string, rawTx: string) => {
+            const txns = await chainInterface.txsTransfer(signer.getAddress(), swap.token, swap.adjustedOutput, swap.dstAddress);
+            await chainInterface.sendAndConfirm(signer, txns, true, null, false, async (txId: string, rawTx: string) => {
                 swap.txIds = {init: txId};
                 swap.scRawTx = rawTx;
                 if(swap.state===FromBtcTrustedSwapState.BTC_CONFIRMED) {
@@ -308,7 +301,7 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
         }
 
         if(swap.state===FromBtcTrustedSwapState.SENT) {
-            const txStatus = await swapContract.getTxStatus(swap.scRawTx);
+            const txStatus = await chainInterface.getTxStatus(swap.scRawTx);
             switch(txStatus) {
                 case "not_found":
                     //Retry
@@ -401,7 +394,7 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
             } = {request: {}, times: {}};
 
             const chainIdentifier = req.query.chain as string ?? this.chains.default;
-            const {swapContract, signer} = this.getChain(chainIdentifier);
+            const {chainInterface, signer} = this.getChain(chainIdentifier);
 
             metadata.times.requestReceived = Date.now();
             /**
@@ -410,11 +403,11 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
              * amount: string               amount (in lamports/smart chain base units) of the invoice
              * exactOut: boolean            whether to create and exact output swap
              */
-            req.query.token ??= swapContract.getNativeCurrencyAddress();
+            req.query.token ??= chainInterface.getNativeCurrencyAddress();
             const parsedBody: FromBtcTrustedRequestType = verifySchema(req.query,{
                 address: (val: string) => val!=null &&
                     typeof(val)==="string" &&
-                    swapContract.isValidAddress(val) ? val : null,
+                    chainInterface.isValidAddress(val) ? val : null,
                 refundAddress: (val: string) => val==null ? "" :
                     typeof(val)==="string" &&
                     this.isValidBitcoinAddress(val) ? val : null,
@@ -433,7 +426,7 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
 
             const refundAddress = parsedBody.refundAddress==="" ? null : parsedBody.refundAddress;
 
-            const requestedAmount = {input: parsedBody.exactIn, amount: parsedBody.amount};
+            const requestedAmount = {input: parsedBody.exactIn, amount: parsedBody.amount, token: parsedBody.token};
             const request = {
                 chainIdentifier,
                 raw: req,
@@ -443,16 +436,20 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
             const useToken = parsedBody.token;
 
             //Check request params
-            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 {pricePrefetchPromise} = this.getFromBtcPricePrefetches(chainIdentifier, useToken, useToken, abortController);
-            const balancePrefetch = swapContract.getBalance(signer.getAddress(), useToken, false).catch(e => {
+            const pricePrefetchPromise = this.swapPricing.preFetchPrice(useToken, chainIdentifier).catch(e => {
+                this.logger.error("pricePrefetchPromise(): pricePrefetch error: ", e);
+                abortController.abort(e);
+                return null;
+            });
+            const balancePrefetch = chainInterface.getBalance(signer.getAddress(), useToken).catch(e => {
                 this.logger.error("getBalancePrefetch(): balancePrefetch error: ", e);
                 abortController.abort(e);
                 return null;
@@ -464,7 +461,7 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
                 swapFee,
                 swapFeeInToken,
                 totalInToken
-            } = 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();
 
             //Make sure we have MORE THAN ENOUGH to honor the swap request
@@ -748,16 +745,4 @@ export class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, F
         return {};
     }
 
-    protected processClaimEvent(chainIdentifier: string, swap: FromBtcTrustedSwap, event: ClaimEvent<SwapData>): Promise<void> {
-        return Promise.resolve(undefined);
-    }
-
-    protected processInitializeEvent(chainIdentifier: string, swap: FromBtcTrustedSwap, event: InitializeEvent<SwapData>): Promise<void> {
-        return Promise.resolve(undefined);
-    }
-
-    protected processRefundEvent(chainIdentifier: string, swap: FromBtcTrustedSwap, event: RefundEvent<SwapData>): Promise<void> {
-        return Promise.resolve(undefined);
-    }
-
 }