@atomiqlabs/sdk 8.8.3 → 8.9.0

package/dist/swaps/escrow_swaps/frombtc/onchain/FromBTCSwap.js

@@ -200,6 +200,29 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
     getInputTxId() {
         return this.txId ?? null;
     }
+    async _setSubmittedBitcoinTx(txId, psbt) {
+        let changed = false;
+        if (this.txId !== txId) {
+            this.txId = txId;
+            changed = true;
+        }
+        const submittedVout = this.address == null || this.amount == null || psbt == null
+            ? undefined
+            : (0, BitcoinUtils_1.getVoutIndex)(psbt, this.wrapper._options.bitcoinNetwork, this.address, this.amount);
+        if (submittedVout != null && this.vout !== submittedVout) {
+            this.vout = submittedVout;
+            changed = true;
+        }
+        const submittedSenderAddress = psbt == null
+            ? undefined
+            : (0, BitcoinUtils_1.getSenderAddress)(psbt, this.wrapper._options.bitcoinNetwork);
+        if (submittedSenderAddress != null && this.senderAddress !== submittedSenderAddress) {
+            this.senderAddress = submittedSenderAddress;
+            changed = true;
+        }
+        if (changed)
+            await this._saveAndEmit();
+    }
     /**
      * Returns timeout time (in UNIX milliseconds) when the on-chain address will expire and no funds should be sent
      *  to that address anymore
@@ -404,7 +427,10 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
             if (btcTx != null && vout != null && requiredConfirmations == null) {
                 requiredConfirmations = this.inferRequiredConfirmationsCount(btcTx, vout);
             }
-            if (btcTx != null && (btcTx.txid !== this.txId || (this.requiredConfirmations == null && requiredConfirmations != null))) {
+            if (btcTx != null && (btcTx.txid !== this.txId ||
+                this.vout == null ||
+                this.senderAddress == null ||
+                (this.requiredConfirmations == null && requiredConfirmations != null))) {
                 this.txId = btcTx.txid;
                 this.vout = vout;
                 this.requiredConfirmations = requiredConfirmations;
@@ -496,7 +522,8 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
             psbt,
             psbtHex: serializedPsbt.toString("hex"),
             psbtBase64: serializedPsbt.toString("base64"),
-            signInputs
+            signInputs,
+            feeRate
         };
     }
     /**
@@ -505,6 +532,8 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
     getFundedPsbt(_bitcoinWallet, feeRate, additionalOutputs) {
         if (this._state !== FromBTCSwapState.CLAIM_COMMITED)
             throw new Error("Swap not committed yet, please initiate the swap first with commit() call!");
+        if (this.txId != null)
+            throw new Error("Bitcoin transaction already submitted for this swap!");
         return this._getFundedPsbt(_bitcoinWallet, feeRate, additionalOutputs);
     }
     /**
@@ -517,6 +546,8 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
         const psbt = (0, BitcoinUtils_1.parsePsbtTransaction)(_psbt);
         if (this._state !== FromBTCSwapState.CLAIM_COMMITED)
             throw new Error("Swap not committed yet, please initiate the swap first with commit() call!");
+        if (this.txId != null)
+            throw new Error("Bitcoin transaction already submitted for this swap!");
         //Ensure not expired
         if (this.getTimeoutTime() < Date.now()) {
             throw new Error("Swap address expired!");
@@ -531,7 +562,9 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
         }
         if (!psbt.isFinal)
             psbt.finalize();
-        return await this.wrapper._btcRpc.sendRawTransaction(buffer_1.Buffer.from(psbt.toBytes(true, true)).toString("hex"));
+        const txId = await this.wrapper._btcRpc.sendRawTransaction(buffer_1.Buffer.from(psbt.toBytes(true, true)).toString("hex"));
+        await this._setSubmittedBitcoinTx(txId, psbt);
+        return txId;
     }
     /**
      * @inheritDoc
@@ -553,12 +586,16 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
             throw new Error("Cannot send bitcoin transaction, because the address is not known! This can happen after a swap is recovered.");
         if (this._state !== FromBTCSwapState.CLAIM_COMMITED)
             throw new Error("Swap not committed yet, please initiate the swap first with commit() call!");
+        if (this.txId != null)
+            throw new Error("Bitcoin transaction already submitted for this swap!");
         //Ensure not expired
         if (this.getTimeoutTime() < Date.now()) {
             throw new Error("Swap address expired!");
         }
         if ((0, IBitcoinWallet_1.isIBitcoinWallet)(wallet)) {
-            return await wallet.sendTransaction(this.address, this.amount, feeRate);
+            const txId = await wallet.sendTransaction(this.address, this.amount, feeRate);
+            await this._setSubmittedBitcoinTx(txId);
+            return txId;
         }
         else {
             const { psbt, psbtHex, psbtBase64, signInputs } = await this.getFundedPsbt(wallet, feeRate);
@@ -600,7 +637,7 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
         if (this._state === FromBTCSwapState.CLAIM_COMMITED) {
             if (wallet != null) {
                 const bitcoinPaymentSent = await this.getBitcoinPayment();
-                if (bitcoinPaymentSent == null) {
+                if (bitcoinPaymentSent == null && this.txId == null) {
                     //Send btc tx
                     const txId = await this.sendBitcoinTransaction(wallet, options?.feeRate);
                     if (callbacks?.onSourceTransactionSent != null)
@@ -623,71 +660,352 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
         throw new Error("Invalid state reached!");
     }
     /**
-     * @inheritDoc
-     *
-     * @param options.bitcoinFeeRate Optional fee rate to use for the created Bitcoin transaction
-     * @param options.bitcoinWallet Bitcoin wallet to use, when provided the function returns a funded
-     *  psbt (`"FUNDED_PSBT"`), if not passed just a bitcoin receive address is returned (`"ADDRESS"`)
-     * @param options.skipChecks Skip checks like making sure init signature is still valid and swap
-     *  wasn't commited yet (this is handled on swap creation, if you commit right after quoting, you
-     *  can use `skipChecks=true`)
-     *
-     * @throws {Error} if the swap or quote is expired, or if triggered in invalid state
+     * @internal
      */
-    async txsExecute(options) {
-        if (this._state === FromBTCSwapState.PR_CREATED) {
-            if (!await this._verifyQuoteValid())
-                throw new Error("Quote already expired or close to expiry!");
-            if (this.getTimeoutTime() < Date.now())
-                throw new Error("Swap address already expired or close to expiry!");
-            return [
+    async _getExecutionStatus(options) {
+        const state = this._state;
+        const now = Date.now();
+        const timeoutTime = this.getTimeoutTime();
+        let confirmations;
+        let bitcoinTxId;
+        let destinationSetupStatus = "awaiting";
+        let bitcoinPaymentStatus = "inactive";
+        let destinationSettlementStatus = "inactive";
+        let buildCurrentAction = async () => undefined;
+        switch (state) {
+            case FromBTCSwapState.PR_CREATED: {
+                const quoteValid = await this._verifyQuoteValid();
+                destinationSetupStatus = quoteValid && timeoutTime >= now ? "awaiting" : "soft_expired";
+                if (quoteValid && timeoutTime >= now) {
+                    buildCurrentAction = this._buildInitSmartChainTxAction.bind(this);
+                }
+                break;
+            }
+            case FromBTCSwapState.QUOTE_SOFT_EXPIRED:
+                destinationSetupStatus = "soft_expired";
+                break;
+            case FromBTCSwapState.QUOTE_EXPIRED:
+                destinationSetupStatus = "expired";
+                break;
+            case FromBTCSwapState.CLAIM_COMMITED:
+            case FromBTCSwapState.EXPIRED:
+            case FromBTCSwapState.FAILED:
+                const bitcoinPayment = this.address == null ? null : await this.getBitcoinPayment();
+                bitcoinTxId = bitcoinPayment?.txId;
+                let bitcoinConfirmationDelay;
+                if (bitcoinPayment != null && bitcoinPayment.confirmations < bitcoinPayment.targetConfirmations) {
+                    const tx = await this.wrapper._btcRpc.getTransaction(bitcoinPayment.txId);
+                    const result = tx == null
+                        ? null
+                        : await this.wrapper._btcRpc.getConfirmationDelay(tx, bitcoinPayment.targetConfirmations);
+                    bitcoinConfirmationDelay = result ?? -1;
+                }
+                destinationSetupStatus = "completed";
+                if (bitcoinPayment == null) {
+                    if (this.txId != null) {
+                        bitcoinPaymentStatus = state === FromBTCSwapState.FAILED ? "expired" : "received";
+                        if (state !== FromBTCSwapState.FAILED) {
+                            buildCurrentAction = this._buildWaitBitcoinConfirmationsAction.bind(this, -1, "Wait for bitcoin transaction to be picked up by the RPC and confirmed.");
+                        }
+                    }
+                    else {
+                        bitcoinPaymentStatus = "awaiting";
+                        if (state === FromBTCSwapState.EXPIRED)
+                            bitcoinPaymentStatus = "soft_expired";
+                        if (state === FromBTCSwapState.FAILED)
+                            bitcoinPaymentStatus = "expired";
+                        if (state === FromBTCSwapState.CLAIM_COMMITED && timeoutTime >= now &&
+                            this.address != null && this.amount != null) {
+                            buildCurrentAction = this._buildSendToAddressOrSignPsbtAction.bind(this);
+                        }
+                    }
+                }
+                else if (bitcoinPayment.confirmations >= bitcoinPayment.targetConfirmations) {
+                    bitcoinPaymentStatus = "confirmed";
+                    if (state !== FromBTCSwapState.FAILED) {
+                        buildCurrentAction = this._buildWaitBitcoinConfirmationsAction.bind(this, bitcoinConfirmationDelay ?? -1, undefined);
+                    }
+                }
+                else {
+                    bitcoinPaymentStatus = "received";
+                    confirmations = {
+                        current: bitcoinPayment.confirmations,
+                        target: bitcoinPayment.targetConfirmations,
+                        etaSeconds: bitcoinConfirmationDelay ?? -1
+                    };
+                    if (state !== FromBTCSwapState.FAILED) {
+                        buildCurrentAction = this._buildWaitBitcoinConfirmationsAction.bind(this, bitcoinConfirmationDelay ?? -1, undefined);
+                    }
+                }
+                destinationSettlementStatus = state === FromBTCSwapState.FAILED ? "expired" : "inactive";
+                break;
+            case FromBTCSwapState.BTC_TX_CONFIRMED:
+                destinationSetupStatus = "completed";
+                bitcoinPaymentStatus = "confirmed";
+                if (this.btcTxConfirmedAt == null ||
+                    options?.maxWaitTillAutomaticSettlementSeconds === 0 ||
+                    (now - this.btcTxConfirmedAt) > (options?.maxWaitTillAutomaticSettlementSeconds ?? 60) * 1000) {
+                    destinationSettlementStatus = "awaiting_manual";
+                    buildCurrentAction = this._buildClaimSmartChainTxAction.bind(this);
+                }
+                else {
+                    destinationSettlementStatus = "awaiting_automatic";
+                    buildCurrentAction = this._buildWaitSettlementAction.bind(this, options?.maxWaitTillAutomaticSettlementSeconds);
+                }
+                break;
+            case FromBTCSwapState.CLAIM_CLAIMED:
+                destinationSetupStatus = "completed";
+                bitcoinPaymentStatus = "confirmed";
+                destinationSettlementStatus = "settled";
+                break;
+        }
+        if (bitcoinPaymentStatus === "confirmed") {
+            const requiredConfirmations = this.getRequiredConfirmationsCount();
+            if (!Number.isNaN(requiredConfirmations)) {
+                confirmations = {
+                    current: requiredConfirmations,
+                    target: requiredConfirmations,
+                    etaSeconds: 0
+                };
+            }
+        }
+        return {
+            steps: [
                 {
-                    name: "Commit",
-                    description: `Opens up the bitcoin swap address on the ${this.chainIdentifier} side`,
+                    type: "Setup",
+                    side: "destination",
                     chain: this.chainIdentifier,
-                    txs: await this.txsCommit(options?.skipChecks)
+                    title: "Open Bitcoin swap address",
+                    description: `Create the escrow on the ${this.chainIdentifier} side to open the Bitcoin swap address`,
+                    status: destinationSetupStatus,
+                    setupTxId: this._commitTxId
                 },
                 {
-                    name: "Payment",
-                    description: "Send funds to the bitcoin swap address",
+                    type: "Payment",
+                    side: "source",
                     chain: "BITCOIN",
-                    txs: [
-                        options?.bitcoinWallet == null ? {
-                            address: this.address ?? "",
-                            amount: Number(this.amount),
-                            hyperlink: this._getHyperlink(),
-                            type: "ADDRESS"
-                        } : {
-                            ...await this.getFundedPsbt(options.bitcoinWallet),
-                            type: "FUNDED_PSBT"
-                        }
-                    ]
+                    title: "Bitcoin payment",
+                    description: "Send Bitcoin to the swap address and wait for the transaction to confirm",
+                    status: bitcoinPaymentStatus,
+                    confirmations,
+                    initTxId: this.txId ?? bitcoinTxId,
+                    settleTxId: this.txId
+                },
+                {
+                    type: "Settlement",
+                    side: "destination",
+                    chain: this.chainIdentifier,
+                    title: "Destination settlement",
+                    description: `Wait for automatic settlement on the ${this.chainIdentifier} side, or settle manually if it takes too long`,
+                    status: destinationSettlementStatus,
+                    initTxId: this._commitTxId,
+                    settleTxId: this._claimTxId
+                }
+            ],
+            buildCurrentAction,
+            state
+        };
+    }
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    async _submitExecutionTransactions(txs, abortSignal, requiredStates, idempotent) {
+        if (txs.length === 0)
+            throw new Error("Need to submit at least 1 transaction in the array, submitted empty array of transactions!");
+        if (idempotent) {
+            // Handle idempotent calls
+            let idempotencyTriggered = false;
+            const txIds = [];
+            for (let tx of txs) {
+                let parsedTx;
+                if (typeof (tx) === "string") {
+                    try {
+                        parsedTx = await this.wrapper._chain.deserializeSignedTx(tx);
+                    }
+                    catch (e) { }
+                    try {
+                        parsedTx = (0, BitcoinUtils_1.parsePsbtTransaction)(tx);
+                    }
+                    catch (e) { }
+                }
+                else {
+                    parsedTx = tx;
                 }
-            ];
+                if (parsedTx == null) {
+                    this.logger.debug("_submitExecutionTransactions(): Failed to parse provided execution transaction: ", tx);
+                    continue;
+                }
+                if (parsedTx instanceof btc_signer_1.Transaction) {
+                    // Bitcoin tx
+                    const btcTx = await this.wrapper._btcRpc.parseTransaction(buffer_1.Buffer.from(parsedTx.toBytes(true)).toString("hex"));
+                    if (btcTx.txid === this.txId)
+                        idempotencyTriggered = true;
+                    txIds.push(btcTx.txid);
+                }
+                else {
+                    // SC tx
+                    if (this.wrapper._chain.getTxId != null) {
+                        const txId = await this.wrapper._chain.getTxId(parsedTx);
+                        if (this._commitTxId === txId || this._claimTxId === txId)
+                            idempotencyTriggered = true;
+                        txIds.push(txId);
+                    }
+                }
+            }
+            if (idempotencyTriggered)
+                return txIds;
         }
+        if (requiredStates != null && !requiredStates.includes(this._state))
+            throw new Error("Swap state has changed before transactions were submitted!");
         if (this._state === FromBTCSwapState.CLAIM_COMMITED) {
+            let psbt;
+            if (txs.length !== 1)
+                throw new Error("Need to submit exactly 1 signed PSBT!");
+            if (typeof (txs[0]) !== "string" && !(txs[0] instanceof btc_signer_1.Transaction))
+                throw new Error("Must submit a valid PSBT as hex/base64 string or `@scure/btc-signer` Transaction object!");
+            psbt = txs[0];
+            return [await this.submitPsbt(psbt)];
+        }
+        if (this._state === FromBTCSwapState.PR_CREATED || this._state === FromBTCSwapState.QUOTE_SOFT_EXPIRED) {
+            if (!await this._verifyQuoteValid())
+                throw new Error("Quote is already expired!");
             if (this.getTimeoutTime() < Date.now())
                 throw new Error("Swap address already expired or close to expiry!");
-            return [
-                {
-                    name: "Payment",
-                    description: "Send funds to the bitcoin swap address",
-                    chain: "BITCOIN",
-                    txs: [
-                        options?.bitcoinWallet == null ? {
-                            address: this.getAddress(),
-                            amount: Number(this.amount),
-                            hyperlink: this._getHyperlink(),
-                            type: "ADDRESS"
-                        } : {
-                            ...await this.getFundedPsbt(options.bitcoinWallet),
-                            type: "FUNDED_PSBT"
-                        }
-                    ]
+            const parsedTxs = [];
+            for (let tx of txs) {
+                parsedTxs.push(typeof (tx) === "string" ? await this.wrapper._chain.deserializeSignedTx(tx) : tx);
+            }
+            const txIds = await this.wrapper._chain.sendSignedAndConfirm(parsedTxs, true, abortSignal, false);
+            await this.waitTillCommited(abortSignal);
+            return txIds;
+        }
+        if (this._state === FromBTCSwapState.BTC_TX_CONFIRMED) {
+            const parsedTxs = [];
+            for (let tx of txs) {
+                parsedTxs.push(typeof (tx) === "string" ? await this.wrapper._chain.deserializeSignedTx(tx) : tx);
+            }
+            const txIds = await this.wrapper._chain.sendSignedAndConfirm(parsedTxs, true, abortSignal, false);
+            await this.waitTillClaimed(undefined, abortSignal);
+            return txIds;
+        }
+        throw new Error("Invalid swap state for transaction submission!");
+    }
+    /**
+     * @internal
+     */
+    async _buildSendToAddressOrSignPsbtAction(actionOptions) {
+        if (this.address == null)
+            throw new Error("Bitcoin swap address not known!");
+        if (this.amount == null)
+            throw new Error("Bitcoin swap amount not known!");
+        if (actionOptions?.bitcoinWallet == null) {
+            return {
+                type: "SendToAddress",
+                name: "Deposit on Bitcoin",
+                description: "Send funds to the bitcoin swap address",
+                chain: "BITCOIN",
+                txs: [{
+                        type: "BITCOIN_ADDRESS",
+                        address: this.address,
+                        hyperlink: this._getHyperlink(),
+                        amount: (0, TokenAmount_1.toTokenAmount)(this.amount, Token_1.BitcoinTokens.BTC, this.wrapper._prices)
+                    }],
+                waitForTransactions: async (maxWaitTimeSeconds, pollIntervalSeconds, abortSignal) => {
+                    let btcTxId;
+                    const abortController = (0, Utils_1.extendAbortController)(abortSignal, maxWaitTimeSeconds, "Timed out waiting for bitcoin transaction");
+                    try {
+                        return await this.waitForBitcoinTransaction((txId) => {
+                            btcTxId = txId;
+                            abortController.abort();
+                        }, pollIntervalSeconds, abortController.signal);
+                    }
+                    catch (e) {
+                        if (btcTxId != null)
+                            return btcTxId;
+                        throw e;
+                    }
                 }
-            ];
+            };
         }
-        throw new Error("Invalid swap state to obtain execution txns, required PR_CREATED or CLAIM_COMMITED");
+        return {
+            type: "SignPSBT",
+            name: "Deposit on Bitcoin",
+            description: "Send funds to the bitcoin swap address",
+            chain: "BITCOIN",
+            txs: [{
+                    ...await this.getFundedPsbt(actionOptions.bitcoinWallet, actionOptions?.bitcoinFeeRate),
+                    type: "FUNDED_PSBT"
+                }],
+            submitPsbt: async (signedPsbt, idempotent) => {
+                return this._submitExecutionTransactions(Array.isArray(signedPsbt) ? signedPsbt : [signedPsbt], undefined, [FromBTCSwapState.CLAIM_COMMITED], idempotent);
+            }
+        };
+    }
+    /**
+     * @internal
+     */
+    async _buildWaitBitcoinConfirmationsAction(confirmationDelay, description) {
+        return {
+            type: "Wait",
+            name: "Bitcoin confirmations",
+            description: description ?? "Wait for bitcoin transaction to confirm",
+            pollTimeSeconds: 10,
+            expectedTimeSeconds: confirmationDelay === -1 ? -1 : Math.floor(confirmationDelay / 1000),
+            wait: async (maxWaitTimeSeconds, pollIntervalSeconds, abortSignal, btcConfirmationsCallback) => {
+                const abortController = (0, Utils_1.extendAbortController)(abortSignal, maxWaitTimeSeconds, "Timed out waiting for bitcoin transaction to confirm");
+                await this.waitForBitcoinTransaction(btcConfirmationsCallback, pollIntervalSeconds, abortController.signal);
+            }
+        };
+    }
+    /**
+     * @internal
+     */
+    async _buildWaitSettlementAction(maxWaitTillAutomaticSettlementSeconds) {
+        return {
+            type: "Wait",
+            name: "Automatic settlement",
+            description: "Wait for automatic settlement by the watchtower",
+            pollTimeSeconds: 5,
+            expectedTimeSeconds: 10,
+            wait: async (maxWaitTimeSeconds, pollIntervalSeconds, abortSignal) => {
+                await this.waitTillClaimed(maxWaitTimeSeconds ?? maxWaitTillAutomaticSettlementSeconds ?? 60, abortSignal, pollIntervalSeconds);
+            }
+        };
+    }
+    /**
+     * @internal
+     */
+    async _buildInitSmartChainTxAction(actionOptions) {
+        return {
+            type: "SignSmartChainTransaction",
+            name: "Initiate swap",
+            description: `Opens up the bitcoin swap address on the ${this.chainIdentifier} side`,
+            chain: this.chainIdentifier,
+            txs: await this.prepareTransactions(this.txsCommit(actionOptions?.skipChecks)),
+            submitTransactions: async (txs, abortSignal, idempotent) => {
+                return this._submitExecutionTransactions(txs, abortSignal, [FromBTCSwapState.PR_CREATED, FromBTCSwapState.QUOTE_SOFT_EXPIRED], idempotent);
+            },
+            requiredSigner: this._getInitiator()
+        };
+    }
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    async _buildClaimSmartChainTxAction(actionOptions) {
+        const signerAddress = await this.wrapper._getSignerAddress(actionOptions?.manualSettlementSmartChainSigner);
+        return {
+            type: "SignSmartChainTransaction",
+            name: "Settle manually",
+            description: "Manually settle (claim) the swap on the destination smart chain",
+            chain: this.chainIdentifier,
+            txs: await this.prepareTransactions(this.txsClaim(actionOptions?.manualSettlementSmartChainSigner)),
+            submitTransactions: async (txs, abortSignal, idempotent) => {
+                return this._submitExecutionTransactions(txs, abortSignal, [FromBTCSwapState.BTC_TX_CONFIRMED], idempotent);
+            },
+            requiredSigner: signerAddress ?? this._getInitiator()
+        };
     }
     /**
      * @inheritDoc
@@ -702,26 +1020,26 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
      * @param options.maxWaitTillAutomaticSettlementSeconds Maximum time to wait for an automatic settlement after
      *  the bitcoin transaction is confirmed (defaults to 60 seconds)
      */
-    async getCurrentActions(options) {
-        if (this._state === FromBTCSwapState.PR_CREATED || this._state === FromBTCSwapState.CLAIM_COMMITED) {
-            try {
-                return await this.txsExecute(options);
-            }
-            catch (e) { }
-        }
-        if (this.isClaimable()) {
-            if (this.btcTxConfirmedAt == null ||
-                options?.maxWaitTillAutomaticSettlementSeconds === 0 ||
-                (Date.now() - this.btcTxConfirmedAt) > (options?.maxWaitTillAutomaticSettlementSeconds ?? 60) * 1000) {
-                return [{
-                        name: "Claim",
-                        description: "Manually settle (claim) the swap on the destination smart chain",
-                        chain: this.chainIdentifier,
-                        txs: await this.txsClaim(options?.manualSettlementSmartChainSigner)
-                    }];
-            }
-        }
-        return [];
+    async getExecutionAction(options) {
+        const executionStatus = await this._getExecutionStatus(options);
+        return executionStatus.buildCurrentAction(options);
+    }
+    /**
+     * @inheritDoc
+     */
+    async getExecutionStatus(options) {
+        const executionStatus = await this._getExecutionStatus(options);
+        return {
+            steps: executionStatus.steps,
+            currentAction: options?.skipBuildingAction ? undefined : await executionStatus.buildCurrentAction(options),
+            stateInfo: this._getStateInfo(executionStatus.state)
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    async getExecutionSteps(options) {
+        return (await this._getExecutionStatus(options)).steps;
     }
     //////////////////////////////
     //// Commit
@@ -761,11 +1079,13 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
             this.waitTillState(FromBTCSwapState.CLAIM_COMMITED, "gte", abortController.signal).then(() => 0)
         ]);
         abortController.abort();
-        if (result === 0)
+        if (result === 0) {
             this.logger.debug("waitTillCommited(): Resolved from state changed");
-        if (result === true)
+        }
+        else if (result != null) {
             this.logger.debug("waitTillCommited(): Resolved from watchdog - commited");
-        if (result === false) {
+        }
+        if (result === null) {
             this.logger.debug("waitTillCommited(): Resolved from watchdog - signature expired");
             if (this._state === FromBTCSwapState.PR_CREATED || this._state === FromBTCSwapState.QUOTE_SOFT_EXPIRED) {
                 await this._saveAndEmit(FromBTCSwapState.QUOTE_EXPIRED);
@@ -773,6 +1093,8 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
             return;
         }
         if (this._state === FromBTCSwapState.PR_CREATED || this._state === FromBTCSwapState.QUOTE_SOFT_EXPIRED) {
+            if (typeof (result) === "object" && result.getInitTxId != null && this._commitTxId == null)
+                this._commitTxId = await result.getInitTxId();
             await this._saveAndEmit(FromBTCSwapState.CLAIM_COMMITED);
         }
     }
@@ -880,7 +1202,7 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
      * @throws {Error} If swap is in invalid state (must be {@link FromBTCSwapState.BTC_TX_CONFIRMED})
      * @throws {Error} If the LP refunded sooner than we were able to claim
      */
-    async waitTillClaimed(maxWaitTimeSeconds, abortSignal) {
+    async waitTillClaimed(maxWaitTimeSeconds, abortSignal, pollIntervalSeconds) {
         if (this._state === FromBTCSwapState.CLAIM_CLAIMED)
             return Promise.resolve(true);
         if (this._state !== FromBTCSwapState.BTC_TX_CONFIRMED)
@@ -897,7 +1219,7 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
         let res;
         try {
             res = await Promise.race([
-                this.watchdogWaitTillResult(undefined, abortController.signal),
+                this.watchdogWaitTillResult(pollIntervalSeconds, abortController.signal),
                 this.waitTillState(FromBTCSwapState.CLAIM_CLAIMED, "eq", abortController.signal).then(() => 0),
                 this.waitTillState(FromBTCSwapState.FAILED, "eq", abortController.signal).then(() => 1),
             ]);
@@ -1018,6 +1340,8 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
     async _forciblySetOnchainState(status) {
         switch (status.type) {
             case base_1.SwapCommitStateType.PAID:
+                if (this._commitTxId == null && status.getInitTxId != null)
+                    this._commitTxId = await status.getInitTxId();
                 if (this._claimTxId == null)
                     this._claimTxId = await status.getClaimTxId();
                 const txId = buffer_1.Buffer.from(await status.getClaimResult(), "hex").reverse().toString("hex");
@@ -1025,20 +1349,33 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
                 this._state = FromBTCSwapState.CLAIM_CLAIMED;
                 return true;
             case base_1.SwapCommitStateType.NOT_COMMITED:
-                if (this._refundTxId == null && status.getRefundTxId)
+                let changed = false;
+                if (this._commitTxId == null && status.getInitTxId != null) {
+                    this._commitTxId = await status.getInitTxId();
+                    changed = true;
+                }
+                if (this._refundTxId == null && status.getRefundTxId) {
                     this._refundTxId = await status.getRefundTxId();
+                    changed = true;
+                }
                 if (this._refundTxId != null) {
                     this._state = FromBTCSwapState.FAILED;
-                    return true;
+                    changed = true;
                 }
-                break;
+                return changed;
             case base_1.SwapCommitStateType.EXPIRED:
+                if (this._commitTxId == null && status.getInitTxId != null)
+                    this._commitTxId = await status.getInitTxId();
                 if (this._refundTxId == null && status.getRefundTxId)
                     this._refundTxId = await status.getRefundTxId();
                 this._state = this._refundTxId == null ? FromBTCSwapState.QUOTE_EXPIRED : FromBTCSwapState.FAILED;
                 return true;
             case base_1.SwapCommitStateType.COMMITED:
                 let save = false;
+                if (this._commitTxId == null && status.getInitTxId != null) {
+                    this._commitTxId = await status.getInitTxId();
+                    save = true;
+                }
                 if (this._state !== FromBTCSwapState.CLAIM_COMMITED && this._state !== FromBTCSwapState.BTC_TX_CONFIRMED && this._state !== FromBTCSwapState.EXPIRED) {
                     this._state = FromBTCSwapState.CLAIM_COMMITED;
                     save = true;
@@ -1048,7 +1385,7 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
                 this.btcTxLastChecked = Date.now();
                 const res = await this.getBitcoinPayment();
                 if (res != null) {
-                    if (this.txId !== res.txId) {
+                    if (this.txId !== res.txId || this.vout !== res.vout || (res.inputAddresses != null && this.senderAddress == null)) {
                         if (res.inputAddresses != null)
                             this.senderAddress = res.inputAddresses[0];
                         this.txId = res.txId;
@@ -1095,7 +1432,7 @@ class FromBTCSwap extends IFromBTCSelfInitSwap_1.IFromBTCSelfInitSwap {
                             const res = await this.getBitcoinPayment();
                             if (res != null) {
                                 let shouldSave = false;
-                                if (this.txId !== res.txId) {
+                                if (this.txId !== res.txId || this.vout !== res.vout || (res.inputAddresses != null && this.senderAddress == null)) {
                                     this.txId = res.txId;
                                     this.vout = res.vout;
                                     if (res.inputAddresses != null)