@atomiqlabs/lp-lib 15.0.13 → 16.0.0

package/dist/swaps/escrow/frombtcln_autoinit/FromBtcLnAutoSwap.d.ts

@@ -0,0 +1,55 @@
+import { SwapData } from "@atomiqlabs/base";
+import { FromBtcBaseSwap } from "../FromBtcBaseSwap";
+export declare enum FromBtcLnAutoSwapState {
+    REFUNDED = -2,
+    CANCELED = -1,
+    CREATED = 0,
+    RECEIVED = 1,
+    TXS_SENT = 2,
+    COMMITED = 3,
+    CLAIMED = 4,
+    SETTLED = 5
+}
+export declare class FromBtcLnAutoSwap<T extends SwapData = SwapData> extends FromBtcBaseSwap<T, FromBtcLnAutoSwapState> {
+    readonly pr: string;
+    readonly lnPaymentHash: string;
+    readonly claimHash: string;
+    readonly claimer: string;
+    readonly token: string;
+    readonly gasToken: string;
+    readonly amountToken: bigint;
+    readonly amountGasToken: bigint;
+    readonly tokenSwapFee: bigint;
+    readonly tokenSwapFeeInToken: bigint;
+    readonly gasSwapFee: bigint;
+    readonly gasSwapFeeInToken: bigint;
+    readonly claimerBounty: bigint;
+    secret: string;
+    constructor(chainIdentifier: string, pr: string, lnPaymentHash: string, claimHash: string, amountMtokens: bigint, claimer: string, token: string, gasToken: string, amountToken: bigint, amountGasToken: bigint, tokenSwapFee: bigint, tokenSwapFeeInToken: bigint, gasSwapFee: bigint, gasSwapFeeInToken: bigint, claimerBounty: bigint);
+    constructor(obj: any);
+    serialize(): any;
+    getClaimHash(): string;
+    getIdentifierHash(): string;
+    getOutputGasAmount(): bigint;
+    getOutputAmount(): bigint;
+    getTotalOutputAmount(): bigint;
+    getTotalOutputGasAmount(): bigint;
+    getSequence(): bigint;
+    getSwapFee(): {
+        inInputToken: bigint;
+        inOutputToken: bigint;
+    };
+    getTokenSwapFee(): {
+        inInputToken: bigint;
+        inOutputToken: bigint;
+    };
+    getGasSwapFee(): {
+        inInputToken: bigint;
+        inOutputToken: bigint;
+    };
+    getToken(): string;
+    getGasToken(): string;
+    isInitiated(): boolean;
+    isFailed(): boolean;
+    isSuccess(): boolean;
+}

package/dist/swaps/escrow/frombtcln_autoinit/FromBtcLnAutoSwap.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromBtcLnAutoSwap = exports.FromBtcLnAutoSwapState = void 0;
+const index_1 = require("../../../index");
+const FromBtcBaseSwap_1 = require("../FromBtcBaseSwap");
+const Utils_1 = require("../../../utils/Utils");
+var FromBtcLnAutoSwapState;
+(function (FromBtcLnAutoSwapState) {
+    FromBtcLnAutoSwapState[FromBtcLnAutoSwapState["REFUNDED"] = -2] = "REFUNDED";
+    FromBtcLnAutoSwapState[FromBtcLnAutoSwapState["CANCELED"] = -1] = "CANCELED";
+    FromBtcLnAutoSwapState[FromBtcLnAutoSwapState["CREATED"] = 0] = "CREATED";
+    FromBtcLnAutoSwapState[FromBtcLnAutoSwapState["RECEIVED"] = 1] = "RECEIVED";
+    FromBtcLnAutoSwapState[FromBtcLnAutoSwapState["TXS_SENT"] = 2] = "TXS_SENT";
+    FromBtcLnAutoSwapState[FromBtcLnAutoSwapState["COMMITED"] = 3] = "COMMITED";
+    FromBtcLnAutoSwapState[FromBtcLnAutoSwapState["CLAIMED"] = 4] = "CLAIMED";
+    FromBtcLnAutoSwapState[FromBtcLnAutoSwapState["SETTLED"] = 5] = "SETTLED";
+})(FromBtcLnAutoSwapState = exports.FromBtcLnAutoSwapState || (exports.FromBtcLnAutoSwapState = {}));
+class FromBtcLnAutoSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
+    constructor(chainIdOrObj, pr, lnPaymentHash, claimHash, amountMtokens, claimer, token, gasToken, amountToken, amountGasToken, tokenSwapFee, tokenSwapFeeInToken, gasSwapFee, gasSwapFeeInToken, claimerBounty) {
+        if (typeof (chainIdOrObj) === "string") {
+            super(chainIdOrObj, (amountMtokens + 999n) / 1000n, tokenSwapFee + gasSwapFee, tokenSwapFeeInToken);
+            this.state = FromBtcLnAutoSwapState.CREATED;
+            this.pr = pr;
+            this.lnPaymentHash = lnPaymentHash;
+            this.claimHash = claimHash;
+            this.claimer = claimer;
+            this.token = token;
+            this.gasToken = gasToken;
+            this.amountToken = amountToken;
+            this.amountGasToken = amountGasToken;
+            this.tokenSwapFee = tokenSwapFee;
+            this.tokenSwapFeeInToken = tokenSwapFeeInToken;
+            this.gasSwapFee = gasSwapFee;
+            this.gasSwapFeeInToken = gasSwapFeeInToken;
+            this.claimerBounty = claimerBounty;
+        }
+        else {
+            super(chainIdOrObj);
+            this.pr = chainIdOrObj.pr;
+            this.lnPaymentHash = chainIdOrObj.lnPaymentHash;
+            this.claimHash = chainIdOrObj.claimHash;
+            this.claimer = chainIdOrObj.claimer;
+            this.token = chainIdOrObj.token;
+            this.gasToken = chainIdOrObj.gasToken;
+            this.amountToken = (0, Utils_1.deserializeBN)(chainIdOrObj.amountToken);
+            this.amountGasToken = (0, Utils_1.deserializeBN)(chainIdOrObj.amountGasToken);
+            this.tokenSwapFee = (0, Utils_1.deserializeBN)(chainIdOrObj.tokenSwapFee);
+            this.tokenSwapFeeInToken = (0, Utils_1.deserializeBN)(chainIdOrObj.tokenSwapFeeInToken);
+            this.gasSwapFee = (0, Utils_1.deserializeBN)(chainIdOrObj.gasSwapFee);
+            this.gasSwapFeeInToken = (0, Utils_1.deserializeBN)(chainIdOrObj.gasSwapFeeInToken);
+            this.claimerBounty = (0, Utils_1.deserializeBN)(chainIdOrObj.claimerBounty);
+            this.secret = chainIdOrObj.secret;
+        }
+        this.type = index_1.SwapHandlerType.FROM_BTCLN_AUTO;
+    }
+    serialize() {
+        const partialSerialized = super.serialize();
+        partialSerialized.pr = this.pr;
+        partialSerialized.secret = this.secret;
+        partialSerialized.lnPaymentHash = this.lnPaymentHash;
+        partialSerialized.claimHash = this.claimHash;
+        partialSerialized.claimer = this.claimer;
+        partialSerialized.token = this.token;
+        partialSerialized.gasToken = this.gasToken;
+        partialSerialized.amountToken = (0, Utils_1.serializeBN)(this.amountToken);
+        partialSerialized.amountGasToken = (0, Utils_1.serializeBN)(this.amountGasToken);
+        partialSerialized.tokenSwapFee = (0, Utils_1.serializeBN)(this.tokenSwapFee);
+        partialSerialized.tokenSwapFeeInToken = (0, Utils_1.serializeBN)(this.tokenSwapFeeInToken);
+        partialSerialized.gasSwapFee = (0, Utils_1.serializeBN)(this.gasSwapFee);
+        partialSerialized.gasSwapFeeInToken = (0, Utils_1.serializeBN)(this.gasSwapFeeInToken);
+        partialSerialized.claimerBounty = (0, Utils_1.serializeBN)(this.claimerBounty);
+        return partialSerialized;
+    }
+    getClaimHash() {
+        return this.claimHash;
+    }
+    getIdentifierHash() {
+        return this.lnPaymentHash;
+    }
+    getOutputGasAmount() {
+        return this.amountGasToken;
+    }
+    getOutputAmount() {
+        return this.amountToken;
+    }
+    getTotalOutputAmount() {
+        return this.amountToken;
+    }
+    getTotalOutputGasAmount() {
+        return this.amountGasToken + this.claimerBounty;
+    }
+    getSequence() {
+        return 0n;
+    }
+    getSwapFee() {
+        return { inInputToken: this.swapFee, inOutputToken: this.swapFeeInToken };
+    }
+    getTokenSwapFee() {
+        return { inInputToken: this.tokenSwapFee, inOutputToken: this.tokenSwapFeeInToken };
+    }
+    getGasSwapFee() {
+        return { inInputToken: this.gasSwapFee, inOutputToken: this.gasSwapFeeInToken };
+    }
+    getToken() {
+        return this.token;
+    }
+    getGasToken() {
+        return this.gasToken;
+    }
+    isInitiated() {
+        return this.state !== FromBtcLnAutoSwapState.CREATED;
+    }
+    isFailed() {
+        return this.state === FromBtcLnAutoSwapState.CANCELED || this.state === FromBtcLnAutoSwapState.REFUNDED;
+    }
+    isSuccess() {
+        return this.state === FromBtcLnAutoSwapState.SETTLED;
+    }
+}
+exports.FromBtcLnAutoSwap = FromBtcLnAutoSwap;

package/dist/swaps/escrow/tobtc_abstract/ToBtcAbs.d.ts

@@ -5,7 +5,6 @@ import { ISwapPrice } from "../../../prices/ISwapPrice";
 import { BtcTx, ChainSwapType, ClaimEvent, InitializeEvent, RefundEvent, SwapData, BitcoinRpc, BtcBlock } from "@atomiqlabs/base";
 import { IIntermediaryStorage } from "../../../storage/IIntermediaryStorage";
 import { ToBtcBaseConfig, ToBtcBaseSwapHandler } from "../ToBtcBaseSwapHandler";
-import { PromiseQueue } from "promise-queue-ts";
 import { IBitcoinWallet } from "../../../wallets/IBitcoinWallet";
 export type ToBtcConfig = ToBtcBaseConfig & {
     sendSafetyFactor: bigint;
@@ -38,7 +37,6 @@ export declare class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSw
     };
     bitcoinRpc: BitcoinRpc<BtcBlock>;
     bitcoin: IBitcoinWallet;
-    sendBtcQueue: PromiseQueue;
     readonly config: ToBtcConfig;
     constructor(storageDirectory: IIntermediaryStorage<ToBtcSwapAbs>, path: string, chainData: MultichainData, bitcoin: IBitcoinWallet, swapPricing: ISwapPrice, bitcoinRpc: BitcoinRpc<BtcBlock>, config: ToBtcConfig);
     /**

package/dist/swaps/escrow/tobtc_abstract/ToBtcAbs.js

@@ -10,9 +10,9 @@ const crypto_1 = require("crypto");
 const SchemaVerifier_1 = require("../../../utils/paramcoders/SchemaVerifier");
 const ServerParamDecoder_1 = require("../../../utils/paramcoders/server/ServerParamDecoder");
 const ToBtcBaseSwapHandler_1 = require("../ToBtcBaseSwapHandler");
-const promise_queue_ts_1 = require("promise-queue-ts");
 const BitcoinUtils_1 = require("../../../utils/BitcoinUtils");
 const OUTPUT_SCRIPT_MAX_LENGTH = 200;
+const MAX_PARALLEL_TX_PROCESSED = 10;
 /**
  * Handler for to BTC swaps, utilizing PTLCs (proof-time locked contracts) using btc relay (on-chain bitcoin SPV)
  */
@@ -22,7 +22,6 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
         this.type = SwapHandler_1.SwapHandlerType.TO_BTC;
         this.swapType = base_1.ChainSwapType.CHAIN_NONCED;
         this.activeSubscriptions = {};
-        this.sendBtcQueue = new promise_queue_ts_1.PromiseQueue();
         this.bitcoinRpc = bitcoinRpc;
         this.bitcoin = bitcoin;
         this.config = config;
@@ -49,17 +48,25 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
      * @param vout
      */
     async tryClaimSwap(tx, swap, vout) {
-        const { swapContract, signer } = this.getChain(swap.chainIdentifier);
+        const { chainInterface, swapContract, signer } = this.getChain(swap.chainIdentifier);
         const blockHeader = await this.bitcoinRpc.getBlockHeader(tx.blockhash);
         //Set flag that we are sending the transaction already, so we don't end up with race condition
+        if (swap.isLocked())
+            return false;
+        let txns;
+        try {
+            txns = await swapContract.txsClaimWithTxData(signer, swap.data, { ...tx, height: blockHeader.getHeight() }, swap.requiredConfirmations, vout, null, null, false);
+        }
+        catch (e) {
+            this.swapLogger.error(swap, "tryClaimSwap(): error occurred creating swap claim transactions, height: " + blockHeader.getHeight() + " utxo: " + tx.txid + ":" + vout + " address: " + swap.address, e);
+            return false;
+        }
         const unlock = swap.lock(swapContract.claimWithTxDataTimeout);
         if (unlock == null)
             return false;
         try {
             this.swapLogger.debug(swap, "tryClaimSwap(): initiate claim of swap, height: " + blockHeader.getHeight() + " utxo: " + tx.txid + ":" + vout);
-            const result = await swapContract.claimWithTxData(signer, swap.data, { ...tx, height: blockHeader.getHeight() }, swap.requiredConfirmations, vout, null, null, false, {
-                waitForConfirmation: true
-            });
+            await chainInterface.sendAndConfirm(signer, txns, true);
             this.swapLogger.info(swap, "tryClaimSwap(): swap claimed successfully, height: " + blockHeader.getHeight() + " utxo: " + tx.txid + ":" + vout + " address: " + swap.address);
             if (swap.metadata != null)
                 swap.metadata.times.txClaimed = Date.now();
@@ -171,22 +178,30 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
      */
     async processBtcTxs() {
         const unsubscribeSwaps = [];
+        let promises = [];
         for (let txId in this.activeSubscriptions) {
             const swap = this.activeSubscriptions[txId];
             //TODO: RBF the transaction if it's already taking too long to confirm
-            try {
-                let tx = await this.bitcoin.getWalletTransaction(txId);
-                if (tx == null)
-                    continue;
-                if (await this.processBtcTx(swap, tx)) {
-                    this.swapLogger.info(swap, "processBtcTxs(): swap claimed successfully, txId: " + tx.txid + " address: " + swap.address);
-                    unsubscribeSwaps.push(swap);
+            promises.push((async () => {
+                try {
+                    let tx = await this.bitcoin.getWalletTransaction(txId);
+                    if (tx == null)
+                        return;
+                    if (await this.processBtcTx(swap, tx)) {
+                        this.swapLogger.info(swap, "processBtcTxs(): swap claimed successfully, txId: " + tx.txid + " address: " + swap.address);
+                        unsubscribeSwaps.push(swap);
+                    }
                 }
-            }
-            catch (e) {
-                this.swapLogger.error(swap, "processBtcTxs(): error processing btc transaction", e);
+                catch (e) {
+                    this.swapLogger.error(swap, "processBtcTxs(): error processing btc transaction", e);
+                }
+            })());
+            if (promises.length >= MAX_PARALLEL_TX_PROCESSED) {
+                await Promise.all(promises);
+                promises = [];
             }
         }
+        await Promise.all(promises);
         unsubscribeSwaps.forEach(swap => {
             this.unsubscribePayment(swap);
         });
@@ -260,7 +275,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
     sendBitcoinPayment(swap) {
         //Make sure that bitcoin payouts are processed sequentially to avoid race conditions between multiple payouts,
         // e.g. that 2 payouts share the same input and would effectively double-spend each other
-        return this.sendBtcQueue.enqueue(async () => {
+        return this.bitcoin.execute(async () => {
             //Run checks
             this.checkExpiresTooSoon(swap);
             if (swap.metadata != null)
@@ -502,7 +517,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
         restServer.use(this.path + "/payInvoice", (0, ServerParamDecoder_1.serverParamDecoder)(10 * 1000));
         restServer.post(this.path + "/payInvoice", (0, Utils_1.expressHandlerWrapper)(async (req, res) => {
             const metadata = { request: {}, times: {} };
-            const chainIdentifier = req.query.chain ?? this.chains.default;
+            const chainIdentifier = req.query.chain;
             const { swapContract, signer, chainInterface } = this.getChain(chainIdentifier);
             metadata.times.requestReceived = Date.now();
             /**
@@ -530,7 +545,7 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
                     this.isTokenSupported(chainIdentifier, val) ? val : null,
                 offerer: (val) => val != null &&
                     typeof (val) === "string" &&
-                    chainInterface.isValidAddress(val) ? val : null,
+                    chainInterface.isValidAddress(val, true) ? val : null,
                 exactIn: SchemaVerifier_1.FieldTypeEnum.BooleanOptional
             });
             if (parsedBody == null)
@@ -631,21 +646,23 @@ class ToBtcAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
                     msg: "Payment not found"
                 };
             await this.checkExpired(payment);
-            if (payment.state === ToBtcSwapAbs_1.ToBtcSwapState.COMMITED)
-                throw {
-                    _httpStatus: 200,
+            if (payment.state === ToBtcSwapAbs_1.ToBtcSwapState.COMMITED) {
+                res.status(200).json({
                     code: 20008,
                     msg: "Payment processing"
-                };
-            if (payment.state === ToBtcSwapAbs_1.ToBtcSwapState.BTC_SENT || payment.state === ToBtcSwapAbs_1.ToBtcSwapState.BTC_SENDING)
-                throw {
-                    _httpStatus: 200,
+                });
+                return;
+            }
+            if (payment.state === ToBtcSwapAbs_1.ToBtcSwapState.BTC_SENT || payment.state === ToBtcSwapAbs_1.ToBtcSwapState.BTC_SENDING) {
+                res.status(200).json({
                     code: 20006,
                     msg: "Already paid",
                     data: {
                         txId: payment.txId
                     }
-                };
+                });
+                return;
+            }
             const { swapContract, signer } = this.getChain(payment.chainIdentifier);
             if (payment.state === ToBtcSwapAbs_1.ToBtcSwapState.NON_PAYABLE) {
                 const isCommited = await swapContract.isCommited(payment.data);

package/dist/swaps/escrow/tobtcln_abstract/ToBtcLnAbs.js

@@ -604,7 +604,7 @@ class ToBtcLnAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
         restServer.use(this.path + "/payInvoice", (0, ServerParamDecoder_1.serverParamDecoder)(10 * 1000));
         restServer.post(this.path + "/payInvoice", (0, Utils_1.expressHandlerWrapper)(async (req, res) => {
             const metadata = { request: {}, times: {} };
-            const chainIdentifier = req.query.chain ?? this.chains.default;
+            const chainIdentifier = req.query.chain;
             const { swapContract, signer, chainInterface } = this.getChain(chainIdentifier);
             metadata.times.requestReceived = Date.now();
             /**
@@ -629,7 +629,7 @@ class ToBtcLnAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
                     this.isTokenSupported(chainIdentifier, val) ? val : null,
                 offerer: (val) => val != null &&
                     typeof (val) === "string" &&
-                    chainInterface.isValidAddress(val) ? val : null,
+                    chainInterface.isValidAddress(val, true) ? val : null,
                 exactIn: SchemaVerifier_1.FieldTypeEnum.BooleanOptional,
                 amount: SchemaVerifier_1.FieldTypeEnum.BigIntOptional
             });
@@ -811,21 +811,23 @@ class ToBtcLnAbs extends ToBtcBaseSwapHandler_1.ToBtcBaseSwapHandler {
                     code: 20007,
                     msg: "Payment not found"
                 };
-            if (payment.status === "pending")
-                throw {
-                    _httpStatus: 200,
+            if (payment.status === "pending") {
+                res.status(200).json({
                     code: 20008,
                     msg: "Payment in-flight"
-                };
-            if (payment.status === "confirmed")
-                throw {
-                    _httpStatus: 200,
+                });
+                return;
+            }
+            if (payment.status === "confirmed") {
+                res.status(200).json({
                     code: 20006,
                     msg: "Already paid",
                     data: {
                         secret: payment.secret
                     }
-                };
+                });
+                return;
+            }
             if (payment.status === "failed")
                 throw {
                     _httpStatus: 200,

package/dist/swaps/spv_vault_swap/SpvVault.d.ts

@@ -16,9 +16,8 @@ export declare class SpvVault<D extends SpvWithdrawalTransactionData = SpvWithdr
     data: T;
     state: SpvVaultState;
     balances: SpvVaultTokenBalance[];
-    scOpenTx: {
-        txId: string;
-        rawTx: string;
+    scOpenTxs: {
+        [txId: string]: string;
     };
     constructor(chainId: string, vault: T, btcAddress: string);
     constructor(obj: any);

package/dist/swaps/spv_vault_swap/SpvVault.js

@@ -28,7 +28,7 @@ class SpvVault extends base_1.Lockable {
             this.initialUtxo = chainIdOrObj.initialUtxo;
             this.btcAddress = chainIdOrObj.btcAddress;
             this.pendingWithdrawals = chainIdOrObj.pendingWithdrawals.map((base_1.SpvWithdrawalTransactionData.deserialize));
-            this.scOpenTx = chainIdOrObj.scOpenTx;
+            this.scOpenTxs = chainIdOrObj.scOpenTxs;
             this.replacedWithdrawals = new Map();
             if (chainIdOrObj.replacedWithdrawals != null) {
                 chainIdOrObj.replacedWithdrawals.forEach((val) => {
@@ -117,7 +117,7 @@ class SpvVault extends base_1.Lockable {
             btcAddress: this.btcAddress,
             pendingWithdrawals: this.pendingWithdrawals.map(val => val.serialize()),
             replacedWithdrawals,
-            scOpenTx: this.scOpenTx
+            scOpenTxs: this.scOpenTxs
         };
     }
     getIdentifier() {

package/dist/swaps/spv_vault_swap/SpvVaultSwapHandler.js

@@ -25,7 +25,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
         this.vaultSigner = spvVaultSigner;
         this.config = config;
         this.AmountAssertions = new FromBtcAmountAssertions_1.FromBtcAmountAssertions(config, swapPricing);
-        this.Vaults = new SpvVaults_1.SpvVaults(vaultStorage, bitcoin, spvVaultSigner, bitcoinRpc, this.getChain.bind(this), config);
+        this.Vaults = new SpvVaults_1.SpvVaults(vaultStorage, bitcoin, spvVaultSigner, bitcoinRpc, this.chains, config);
     }
     async processClaimEvent(swap, event) {
         if (swap == null)
@@ -121,7 +121,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
                 await this.saveSwapData(swap);
             }
         }
-        if (swap.state === SpvVaultSwap_1.SpvVaultSwapState.SENT) {
+        if (swap.state === SpvVaultSwap_1.SpvVaultSwapState.SENT || swap.state === SpvVaultSwap_1.SpvVaultSwapState.BTC_CONFIRMED) {
             //Check if confirmed or double-spent
             if (swap.sending)
                 return;
@@ -135,8 +135,10 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
                 return;
             }
             else if (tx.confirmations > 0) {
-                await swap.setState(SpvVaultSwap_1.SpvVaultSwapState.BTC_CONFIRMED);
-                await this.saveSwapData(swap);
+                if (swap.state !== SpvVaultSwap_1.SpvVaultSwapState.BTC_CONFIRMED) {
+                    await swap.setState(SpvVaultSwap_1.SpvVaultSwapState.BTC_CONFIRMED);
+                    await this.saveSwapData(swap);
+                }
             }
         }
     }
@@ -174,7 +176,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
         restServer.use(this.path + "/getQuote", (0, ServerParamDecoder_1.serverParamDecoder)(10 * 1000));
         restServer.post(this.path + "/getQuote", (0, Utils_1.expressHandlerWrapper)(async (req, res) => {
             const metadata = { request: {}, times: {} };
-            const chainIdentifier = req.query.chain ?? this.chains.default;
+            const chainIdentifier = req.query.chain;
             const { signer, chainInterface, spvVaultContract } = this.getChain(chainIdentifier);
             metadata.times.requestReceived = Date.now();
             /**
@@ -190,7 +192,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
             const parsedBody = await req.paramReader.getParams({
                 address: (val) => val != null &&
                     typeof (val) === "string" &&
-                    chainInterface.isValidAddress(val) ? val : null,
+                    chainInterface.isValidAddress(val, true) ? val : null,
                 amount: SchemaVerifier_1.FieldTypeEnum.BigInt,
                 token: (val) => val != null &&
                     typeof (val) === "string" &&
@@ -388,7 +390,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
                     msg: "PSBT transaction cannot be parsed!"
                 };
             }
-            if (data.recipient !== swap.recipient ||
+            if (!data.isRecipient(swap.recipient) ||
                 data.callerFeeRate !== swap.callerFeeShare ||
                 data.frontingFeeRate !== swap.frontingFeeShare ||
                 data.executionFeeRate !== swap.executionFeeShare ||
@@ -423,7 +425,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
                     msg: "One or more PSBT inputs not finalized!"
                 };
             const effectiveFeeRate = await this.bitcoinRpc.getEffectiveFeeRate(await this.bitcoin.parsePsbt(signedTx));
-            if (effectiveFeeRate.feeRate < swap.btcFeeRate)
+            if (effectiveFeeRate.feeRate < 1 || Math.round(effectiveFeeRate.feeRate) < swap.btcFeeRate)
                 throw {
                     code: 20511,
                     msg: "Bitcoin transaction fee too low, expected minimum: " + swap.btcFeeRate + " adjusted effective fee rate: " + effectiveFeeRate.feeRate

package/dist/swaps/spv_vault_swap/SpvVaults.d.ts

@@ -3,7 +3,7 @@ import { BitcoinRpc, IStorageManager, SpvVaultClaimEvent, SpvVaultCloseEvent, Sp
 import { SpvVaultSwap } from "./SpvVaultSwap";
 import { IBitcoinWallet } from "../../wallets/IBitcoinWallet";
 import { ISpvVaultSigner } from "../../wallets/ISpvVaultSigner";
-import { ChainData } from "../SwapHandler";
+import { MultichainData } from "../SwapHandler";
 export declare const VAULT_DUST_AMOUNT = 600;
 export declare class SpvVaults {
     readonly vaultStorage: IStorageManager<SpvVault>;
@@ -14,14 +14,9 @@ export declare class SpvVaults {
         vaultsCheckInterval: number;
         maxUnclaimedWithdrawals?: number;
     };
-    readonly getChain: (chainId: string) => ChainData;
-    readonly logger: {
-        debug: (msg: string, ...args: any) => void;
-        info: (msg: string, ...args: any) => void;
-        warn: (msg: string, ...args: any) => void;
-        error: (msg: string, ...args: any) => void;
-    };
-    constructor(vaultStorage: IStorageManager<SpvVault>, bitcoin: IBitcoinWallet, vaultSigner: ISpvVaultSigner, bitcoinRpc: BitcoinRpc<any>, getChain: (chainId: string) => ChainData, config: {
+    readonly chains: MultichainData;
+    readonly logger: import("../../utils/Utils").LoggerType;
+    constructor(vaultStorage: IStorageManager<SpvVault>, bitcoin: IBitcoinWallet, vaultSigner: ISpvVaultSigner, bitcoinRpc: BitcoinRpc<any>, chains: MultichainData, config: {
         vaultsCheckInterval: number;
         maxUnclaimedWithdrawals?: number;
     });