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

package/dist/swaps/spv_vault_swap/SpvVaults.js

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpvVaults = exports.VAULT_DUST_AMOUNT = void 0;
+const SpvVault_1 = require("./SpvVault");
+const Utils_1 = require("../../utils/Utils");
+const PluginManager_1 = require("../../plugins/PluginManager");
+const AmountAssertions_1 = require("../assertions/AmountAssertions");
+const btc_signer_1 = require("@scure/btc-signer");
+exports.VAULT_DUST_AMOUNT = 600;
+const VAULT_INIT_CONFIRMATIONS = 2;
+const BTC_FINALIZATION_CONFIRMATIONS = 6;
+class SpvVaults {
+    constructor(vaultStorage, bitcoin, vaultSigner, bitcoinRpc, getChain, config) {
+        this.logger = {
+            debug: (msg, ...args) => console.debug("SpvVaults: " + msg, ...args),
+            info: (msg, ...args) => console.info("SpvVaults: " + msg, ...args),
+            warn: (msg, ...args) => console.warn("SpvVaults: " + msg, ...args),
+            error: (msg, ...args) => console.error("SpvVaults: " + msg, ...args)
+        };
+        this.vaultStorage = vaultStorage;
+        this.bitcoin = bitcoin;
+        this.vaultSigner = vaultSigner;
+        this.bitcoinRpc = bitcoinRpc;
+        this.getChain = getChain;
+        this.config = config;
+    }
+    async processDepositEvent(vault, event) {
+        vault.update(event);
+        await this.saveVault(vault);
+    }
+    async processOpenEvent(vault, event) {
+        if (vault.state === SpvVault_1.SpvVaultState.BTC_CONFIRMED) {
+            vault.state = SpvVault_1.SpvVaultState.OPENED;
+        }
+        vault.update(event);
+        await this.saveVault(vault);
+    }
+    async processCloseEvent(vault, event) {
+        if (vault.state === SpvVault_1.SpvVaultState.OPENED) {
+            vault.state = SpvVault_1.SpvVaultState.CLOSED;
+        }
+        vault.update(event);
+        await this.saveVault(vault);
+    }
+    async processClaimEvent(vault, swap, event) {
+        //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, count, token, confirmations = 2, feeRate) {
+        const { signer, chainInterface, tokenMultipliers, spvVaultContract } = this.getChain(chainId);
+        const signerAddress = signer.getAddress();
+        //Check vaultId of the latest saved vault
+        let latestVaultId = -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 = [];
+        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: exports.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_1.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, token) {
+        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, tokenAmounts) {
+        if (vault.state !== SpvVault_1.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, tokenAmounts, feeRate) {
+        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;
+        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 btc_signer_1.Transaction({
+            allowUnknownOutputs: true
+        });
+        psbt.addInput({
+            txid: txId,
+            index: parseInt(voutStr),
+            witnessUtxo: {
+                amount: BigInt(exports.VAULT_DUST_AMOUNT),
+                script: this.bitcoin.toOutputScript(vault.btcAddress)
+            }
+        });
+        psbt.addOutput({
+            amount: BigInt(exports.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 = [];
+        for (let vault of vaults) {
+            const { signer, spvVaultContract, chainInterface } = this.getChain(vault.chainId);
+            if (vault.data.getOwner() !== signer.getAddress())
+                continue;
+            if (vault.state === SpvVault_1.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 === SpvVault_1.SpvVaultState.BTC_INITIATED) {
+                        vault.state = SpvVault_1.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 === SpvVault_1.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 = SpvVault_1.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, rawTx) => {
+                    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 = SpvVault_1.SpvVaultState.OPENED;
+                await this.saveVault(vault);
+            }
+            if (vault.state === SpvVault_1.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, withdrawal) {
+        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, owner, vaultId) {
+        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, totalSats, token, amount, gasToken, gasTokenAmount) {
+        const { signer } = this.getChain(chainIdentifier);
+        const pluginResponse = await PluginManager_1.PluginManager.onVaultSelection(chainIdentifier, totalSats, { token, amount }, { token: gasToken, amount: gasTokenAmount });
+        if (pluginResponse != null) {
+            AmountAssertions_1.AmountAssertions.handlePluginErrorResponses(pluginResponse);
+            return pluginResponse;
+        }
+        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) => (0, Utils_1.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) {
+        return this.vaultStorage.saveData(vault.getIdentifier(), vault);
+    }
+    async startVaultsWatchdog() {
+        let rerun;
+        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_1.SpvVault);
+    }
+}
+exports.SpvVaults = SpvVaults;

package/dist/swaps/{frombtc_trusted → trusted/frombtc_trusted}/FromBtcTrusted.d.ts

@@ -1,12 +1,12 @@
-import { FromBtcBaseConfig, FromBtcBaseSwapHandler } from "../FromBtcBaseSwapHandler";
 import { FromBtcTrustedSwap, FromBtcTrustedSwapState } from "./FromBtcTrustedSwap";
-import { BitcoinRpc, BtcBlock, BtcTx, ClaimEvent, InitializeEvent, RefundEvent, SwapData } from "@atomiqlabs/base";
+import { BitcoinRpc, BtcBlock, BtcTx } from "@atomiqlabs/base";
 import { Express } from "express";
-import { MultichainData, SwapHandlerType } from "../SwapHandler";
-import { IIntermediaryStorage } from "../../storage/IIntermediaryStorage";
-import { ISwapPrice } from "../ISwapPrice";
-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 { IBitcoinWallet } from "../../../wallets/IBitcoinWallet";
+import { FromBtcAmountAssertions } from "../../assertions/FromBtcAmountAssertions";
+export type FromBtcTrustedConfig = SwapBaseConfig & {
     doubleSpendCheckInterval: number;
     swapAddressExpiry: number;
     recommendFeeMultiplier?: number;
@@ -18,9 +18,8 @@ export type FromBtcTrustedRequestType = {
     refundAddress?: string;
     token?: string;
 };
-export declare class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTrustedSwap, FromBtcTrustedSwapState> {
-    readonly type: SwapHandlerType;
-    readonly swapType: any;
+export declare class FromBtcTrusted extends SwapHandler<FromBtcTrustedSwap, FromBtcTrustedSwapState> {
+    readonly type = SwapHandlerType.FROM_BTC_TRUSTED;
     readonly config: FromBtcTrustedConfig;
     readonly bitcoin: IBitcoinWallet;
     readonly bitcoinRpc: BitcoinRpc<BtcBlock>;
@@ -34,6 +33,7 @@ export declare class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTruste
         adjustedAmount: bigint;
         adjustedTotal: bigint;
     }>;
+    readonly AmountAssertions: FromBtcAmountAssertions;
     constructor(storageDirectory: IIntermediaryStorage<FromBtcTrustedSwap>, path: string, chains: MultichainData, bitcoin: IBitcoinWallet, swapPricing: ISwapPrice, bitcoinRpc: BitcoinRpc<BtcBlock>, config: FromBtcTrustedConfig);
     private getAllAncestors;
     private refundSwap;
@@ -48,7 +48,4 @@ export declare class FromBtcTrusted extends FromBtcBaseSwapHandler<FromBtcTruste
     startWatchdog(): Promise<void>;
     init(): Promise<void>;
     getInfoData(): any;
-    protected processClaimEvent(chainIdentifier: string, swap: FromBtcTrustedSwap, event: ClaimEvent<SwapData>): Promise<void>;
-    protected processInitializeEvent(chainIdentifier: string, swap: FromBtcTrustedSwap, event: InitializeEvent<SwapData>): Promise<void>;
-    protected processRefundEvent(chainIdentifier: string, swap: FromBtcTrustedSwap, event: RefundEvent<SwapData>): Promise<void>;
 }

package/dist/swaps/{frombtc_trusted → trusted/frombtc_trusted}/FromBtcTrusted.js

@@ -1,23 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcTrusted = void 0;
-const FromBtcBaseSwapHandler_1 = require("../FromBtcBaseSwapHandler");
 const FromBtcTrustedSwap_1 = require("./FromBtcTrustedSwap");
-const SwapHandler_1 = require("../SwapHandler");
-const PluginManager_1 = require("../../plugins/PluginManager");
-const Utils_1 = require("../../utils/Utils");
-const SchemaVerifier_1 = require("../../utils/paramcoders/SchemaVerifier");
-class FromBtcTrusted extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
+const SwapHandler_1 = require("../../SwapHandler");
+const PluginManager_1 = require("../../../plugins/PluginManager");
+const Utils_1 = require("../../../utils/Utils");
+const SchemaVerifier_1 = require("../../../utils/paramcoders/SchemaVerifier");
+const FromBtcAmountAssertions_1 = require("../../assertions/FromBtcAmountAssertions");
+class FromBtcTrusted extends SwapHandler_1.SwapHandler {
     constructor(storageDirectory, path, chains, bitcoin, swapPricing, bitcoinRpc, config) {
         var _a;
         super(storageDirectory, path, chains, swapPricing);
         this.type = SwapHandler_1.SwapHandlerType.FROM_BTC_TRUSTED;
-        this.swapType = null;
         this.subscriptions = new Map();
         this.doubleSpendWatchdogSwaps = new Set();
         this.refundedSwaps = new Map();
         this.doubleSpentSwaps = new Map();
         this.processedTxIds = new Map();
+        this.AmountAssertions = new FromBtcAmountAssertions_1.FromBtcAmountAssertions(config, swapPricing);
         this.config = config;
         (_a = this.config).recommendFeeMultiplier ?? (_a.recommendFeeMultiplier = 1.25);
         this.bitcoin = bitcoin;
@@ -108,7 +108,7 @@ class FromBtcTrusted extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
     }
     async processPastSwap(swap, tx, vout) {
         const foundVout = 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");
         if (swap.state === FromBtcTrustedSwap_1.FromBtcTrustedSwapState.CREATED) {
             this.subscriptions.set(outputScript, swap);
@@ -220,7 +220,7 @@ class FromBtcTrusted extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
         }
         if (swap.state === FromBtcTrustedSwap_1.FromBtcTrustedSwapState.BTC_CONFIRMED) {
             //Send gas token
-            const balance = swapContract.getBalance(signer.getAddress(), swap.token, false);
+            const balance = chainInterface.getBalance(signer.getAddress(), swap.token);
             try {
                 await this.checkBalance(swap.adjustedOutput, balance, null);
                 if (swap.metadata != null)
@@ -236,8 +236,8 @@ class FromBtcTrusted extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             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, rawTx) => {
+            const txns = await chainInterface.txsTransfer(signer.getAddress(), swap.token, swap.adjustedOutput, swap.dstAddress);
+            await chainInterface.sendAndConfirm(signer, txns, true, null, false, async (txId, rawTx) => {
                 swap.txIds = { init: txId };
                 swap.scRawTx = rawTx;
                 if (swap.state === FromBtcTrustedSwap_1.FromBtcTrustedSwapState.BTC_CONFIRMED) {
@@ -250,7 +250,7 @@ class FromBtcTrusted extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             });
         }
         if (swap.state === FromBtcTrustedSwap_1.FromBtcTrustedSwapState.SENT) {
-            const txStatus = await swapContract.getTxStatus(swap.scRawTx);
+            const txStatus = await chainInterface.getTxStatus(swap.scRawTx);
             switch (txStatus) {
                 case "not_found":
                     //Retry
@@ -335,7 +335,7 @@ class FromBtcTrusted extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             var _a;
             const metadata = { request: {}, times: {} };
             const chainIdentifier = req.query.chain ?? this.chains.default;
-            const { swapContract, signer } = this.getChain(chainIdentifier);
+            const { chainInterface, signer } = this.getChain(chainIdentifier);
             metadata.times.requestReceived = Date.now();
             /**
              * address: string              solana address of the recipient
@@ -343,11 +343,11 @@ class FromBtcTrusted extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
              * amount: string               amount (in lamports/smart chain base units) of the invoice
              * exactOut: boolean            whether to create and exact output swap
              */
-            (_a = req.query).token ?? (_a.token = swapContract.getNativeCurrencyAddress());
+            (_a = req.query).token ?? (_a.token = chainInterface.getNativeCurrencyAddress());
             const parsedBody = (0, SchemaVerifier_1.verifySchema)(req.query, {
                 address: (val) => val != null &&
                     typeof (val) === "string" &&
-                    swapContract.isValidAddress(val) ? val : null,
+                    chainInterface.isValidAddress(val) ? val : null,
                 refundAddress: (val) => val == null ? "" :
                     typeof (val) === "string" &&
                         this.isValidBitcoinAddress(val) ? val : null,
@@ -365,7 +365,7 @@ class FromBtcTrusted extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
                 };
             metadata.request = parsedBody;
             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,
@@ -374,20 +374,24 @@ class FromBtcTrusted extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
             };
             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 = (0, Utils_1.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;
             });
             //Check valid amount specified (min/max)
-            const { amountBD, swapFee, swapFeeInToken, totalInToken } = await this.checkFromBtcAmount(request, requestedAmount, fees, useToken, abortController.signal, pricePrefetchPromise);
+            const { amountBD, swapFee, swapFeeInToken, totalInToken } = 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
             await this.checkBalance(totalInToken * 4n, balancePrefetch, abortController.signal);
@@ -642,14 +646,5 @@ class FromBtcTrusted extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
     getInfoData() {
         return {};
     }
-    processClaimEvent(chainIdentifier, swap, event) {
-        return Promise.resolve(undefined);
-    }
-    processInitializeEvent(chainIdentifier, swap, event) {
-        return Promise.resolve(undefined);
-    }
-    processRefundEvent(chainIdentifier, swap, event) {
-        return Promise.resolve(undefined);
-    }
 }
 exports.FromBtcTrusted = FromBtcTrusted;

package/dist/swaps/{frombtc_trusted → trusted/frombtc_trusted}/FromBtcTrustedSwap.d.ts

@@ -1,5 +1,5 @@
-import { BtcTx, SwapData } from "@atomiqlabs/base";
-import { FromBtcBaseSwap } from "../FromBtcBaseSwap";
+import { BtcTx } from "@atomiqlabs/base";
+import { SwapHandlerSwap } from "../../SwapHandlerSwap";
 export declare enum FromBtcTrustedSwapState {
     DOUBLE_SPENT = -4,
     REFUNDED = -3,
@@ -12,7 +12,8 @@ export declare enum FromBtcTrustedSwapState {
     CONFIRMED = 4,
     FINISHED = 5
 }
-export declare class FromBtcTrustedSwap<T extends SwapData = SwapData> extends FromBtcBaseSwap<T, FromBtcTrustedSwapState> {
+export declare class FromBtcTrustedSwap extends SwapHandlerSwap<FromBtcTrustedSwapState> {
+    readonly amount: bigint;
     readonly sequence: bigint;
     readonly btcAddress: string;
     readonly dstAddress: string;
@@ -36,12 +37,16 @@ export declare class FromBtcTrustedSwap<T extends SwapData = SwapData> extends F
     constructor(chainIdentifier: string, swapFee: bigint, swapFeeInToken: bigint, btcAddress: string, inputSats: bigint, dstAddress: string, outputTokens: bigint, createdHeight: number, expiresAt: number, recommendedFee: number, refundAddress: string, token: string);
     constructor(obj: any);
     serialize(): any;
-    getClaimHash(): string;
     getSequence(): bigint;
     getToken(): string;
     getOutputAmount(): bigint;
     getTotalInputAmount(): bigint;
+    getSwapFee(): {
+        inInputToken: bigint;
+        inOutputToken: bigint;
+    };
     isFailed(): boolean;
     isInitiated(): boolean;
     isSuccess(): boolean;
+    getIdentifierHash(): string;
 }