@atomiqlabs/sdk 8.1.8 → 8.3.5

package/src/swaps/escrow_swaps/frombtc/onchain/FromBTCSwap.ts

@@ -12,15 +12,16 @@ import {
 import {Buffer} from "buffer";
 import {
     extendAbortController,
-    getTxoHash
+    getTxoHash, toBigInt
 } from "../../../../utils/Utils";
 import {
+    fromOutputScript,
     parsePsbtTransaction,
     toOutputScript,
 } from "../../../../utils/BitcoinUtils";
 import {IBitcoinWallet, isIBitcoinWallet} from "../../../../bitcoin/wallet/IBitcoinWallet";
 import {IBTCWalletSwap} from "../../../IBTCWalletSwap";
-import {Address, OutScript, Transaction} from "@scure/btc-signer";
+import {Transaction} from "@scure/btc-signer";
 import {SingleAddressBitcoinWallet} from "../../../../bitcoin/wallet/SingleAddressBitcoinWallet";
 import {
     MinimalBitcoinWalletInterface,
@@ -30,59 +31,111 @@ import {IClaimableSwap} from "../../../IClaimableSwap";
 import {IEscrowSelfInitSwapInit, isIEscrowSelfInitSwapInit} from "../../IEscrowSelfInitSwap";
 import {IAddressSwap} from "../../../IAddressSwap";
 import {TokenAmount, toTokenAmount} from "../../../../types/TokenAmount";
-import {BitcoinTokens, BtcToken, SCToken, Token} from "../../../../types/Token";
+import {BitcoinTokens, BtcToken, SCToken} from "../../../../types/Token";
 import {getLogger, LoggerType} from "../../../../utils/Logger";
 import {toBitcoinWallet} from "../../../../utils/BitcoinWalletUtils";
 
 /**
- * State enum for FromBTC swaps
- * @category Swaps
+ * State enum for legacy escrow based Bitcoin -> Smart chain swaps.
+ *
+ * @category Swaps/Legacy/Bitcoin → Smart chain
  */
 export enum FromBTCSwapState {
+    /**
+     * Bitcoin swap address has expired and the intermediary (LP) has already refunded
+     *  its funds. No BTC should be sent anymore!
+     */
     FAILED = -4,
+    /**
+     * Bitcoin swap address has expired, user should not send any BTC anymore! Though
+     *  the intermediary (LP) hasn't refunded yet. So if there is a transaction already
+     *  in-flight the swap might still succeed.
+     */
     EXPIRED = -3,
+    /**
+     * Swap has expired for good and there is no way how it can be executed anymore
+     */
     QUOTE_EXPIRED = -2,
+    /**
+     * A swap is almost expired, and it should be presented to the user as expired, though
+     *  there is still a chance that it will be processed
+     */
     QUOTE_SOFT_EXPIRED = -1,
+    /**
+     * Swap quote was created, use the {@link FromBTCSwap.commit} or {@link FromBTCSwap.txsCommit} functions
+     *  to initiate it by creating the swap escrow on the destination smart chain
+     */
     PR_CREATED = 0,
+    /**
+     * Swap escrow was initiated (committed) on the destination chain, user can send the BTC to the
+     *  swap address with the {@link FromBTCSwap.getFundedPsbt}, {@link FromBTCSwap.getAddress} or
+     *  {@link FromBTCSwap.getHyperlink} functions.
+     */
     CLAIM_COMMITED = 1,
+    /**
+     * Input bitcoin transaction was confirmed, wait for automatic settlement by the watchtower
+     *  or settle manually using the {@link FromBTCSwap.claim} or {@link FromBTCSwap.txsClaim}
+     *  function.
+     */
     BTC_TX_CONFIRMED = 2,
+    /**
+     * Swap successfully settled and funds received on the destination chain
+     */
     CLAIM_CLAIMED = 3
 }
 
 export type FromBTCSwapInit<T extends SwapData> = IEscrowSelfInitSwapInit<T> & {
     data: T;
-    feeRate: string;
-    address: string;
-    amount: bigint;
-    requiredConfirmations: number;
+    address?: string;
+    amount?: bigint;
+    requiredConfirmations?: number;
 };
 
 export function isFromBTCSwapInit<T extends SwapData>(obj: any): obj is FromBTCSwapInit<T> {
-    return typeof(obj.address) === "string" &&
-        typeof(obj.amount) === "bigint" &&
-        typeof(obj.data) === "object" &&
-        typeof(obj.requiredConfirmations) === "number" &&
+    return typeof(obj.data) === "object" &&
+        (obj.address==null || typeof(obj.address) === "string") &&
+        (obj.amount==null || typeof(obj.amount) === "bigint") &&
+        (obj.requiredConfirmations==null || typeof(obj.requiredConfirmations) === "number") &&
         isIEscrowSelfInitSwapInit<T>(obj);
 }
 
+/**
+ * Legacy escrow (PrTLC) based swap for Bitcoin -> Smart chains, requires manual initiation
+ *  of the swap escrow on the destination chain.
+ *
+ * @category Swaps/Legacy/Bitcoin → Smart chain
+ */
 export class FromBTCSwap<T extends ChainType = ChainType>
     extends IFromBTCSelfInitSwap<T, FromBTCDefinition<T>, FromBTCSwapState>
     implements IBTCWalletSwap, IClaimableSwap<T, FromBTCDefinition<T>, FromBTCSwapState>, IAddressSwap {
 
+    protected readonly TYPE: SwapType.FROM_BTC = SwapType.FROM_BTC;
+
+    /**
+     * @internal
+     */
     protected readonly logger: LoggerType;
+    /**
+     * @internal
+     */
     protected readonly inputToken: BtcToken<false> = BitcoinTokens.BTC;
-    protected readonly TYPE = SwapType.FROM_BTC;
+    /**
+     * @internal
+     */
+    protected readonly feeRate!: string;
 
-    readonly data!: T["Data"];
-    readonly feeRate!: string;
+    /**
+     * @internal
+     */
+    readonly _data!: T["Data"];
 
-    address: string;
-    amount: bigint;
-    readonly requiredConfirmations: number;
+    private address?: string;
+    private amount?: bigint;
+    private requiredConfirmations?: number;
 
-    senderAddress?: string;
-    txId?: string;
-    vout?: number;
+    private senderAddress?: string;
+    private txId?: string;
+    private vout?: number;
 
     constructor(wrapper: FromBTCWrapper<T>, init: FromBTCSwapInit<T["Data"]>);
     constructor(wrapper: FromBTCWrapper<T>, obj: any);
@@ -90,48 +143,56 @@ export class FromBTCSwap<T extends ChainType = ChainType>
         if(isFromBTCSwapInit(initOrObject) && initOrObject.url!=null) initOrObject.url += "/frombtc";
         super(wrapper, initOrObject);
         if(isFromBTCSwapInit(initOrObject)) {
-            this.state = FromBTCSwapState.PR_CREATED;
-            this.data = initOrObject.data;
+            this._state = FromBTCSwapState.PR_CREATED;
+            this._data = initOrObject.data;
             this.feeRate = initOrObject.feeRate;
             this.address = initOrObject.address;
             this.amount = initOrObject.amount;
             this.requiredConfirmations = initOrObject.requiredConfirmations;
         } else {
             this.address = initOrObject.address;
-            this.amount = BigInt(initOrObject.amount);
+            this.amount = toBigInt(initOrObject.amount);
             this.senderAddress = initOrObject.senderAddress;
             this.txId = initOrObject.txId;
             this.vout = initOrObject.vout;
-            this.requiredConfirmations = initOrObject.requiredConfirmations ?? this.data.getConfirmationsHint();
+            this.requiredConfirmations = initOrObject.requiredConfirmations ?? this._data.getConfirmationsHint();
         }
         this.tryRecomputeSwapPrice();
         this.logger = getLogger("FromBTC("+this.getIdentifierHashString()+"): ");
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     protected getSwapData(): T["Data"] {
-        return this.data;
+        return this._data;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     protected upgradeVersion() {
         if(this.version == null) {
-            switch(this.state) {
+            switch(this._state) {
                 case -2:
-                    this.state = FromBTCSwapState.FAILED
+                    this._state = FromBTCSwapState.FAILED
                     break;
                 case -1:
-                    this.state = FromBTCSwapState.QUOTE_EXPIRED
+                    this._state = FromBTCSwapState.QUOTE_EXPIRED
                     break;
                 case 0:
-                    this.state = FromBTCSwapState.PR_CREATED
+                    this._state = FromBTCSwapState.PR_CREATED
                     break;
                 case 1:
-                    this.state = FromBTCSwapState.CLAIM_COMMITED
+                    this._state = FromBTCSwapState.CLAIM_COMMITED
                     break;
                 case 2:
-                    this.state = FromBTCSwapState.BTC_TX_CONFIRMED
+                    this._state = FromBTCSwapState.BTC_TX_CONFIRMED
                     break;
                 case 3:
-                    this.state = FromBTCSwapState.CLAIM_CLAIMED
+                    this._state = FromBTCSwapState.CLAIM_CLAIMED
                     break;
             }
             this.version = 1;
@@ -146,8 +207,8 @@ export class FromBTCSwap<T extends ChainType = ChainType>
      * Returns bitcoin address where the on-chain BTC should be sent to
      */
     getAddress(): string {
-        if(this.state===FromBTCSwapState.PR_CREATED) throw new Error("Cannot get bitcoin address of non-committed swap");
-        return this.address;
+        if(this._state===FromBTCSwapState.PR_CREATED) throw new Error("Cannot get bitcoin address of non-initiated swaps! Initiate swap first with commit() or txsCommit().");
+        return this.address ?? "";
     }
 
     /**
@@ -156,18 +217,27 @@ export class FromBTCSwap<T extends ChainType = ChainType>
      * @private
      */
     private _getHyperlink(): string {
-        return "bitcoin:"+this.address+"?amount="+encodeURIComponent((Number(this.amount) / 100000000).toString(10));
+        return this.address==null || this.amount==null ? "" : "bitcoin:"+this.address+"?amount="+encodeURIComponent((Number(this.amount) / 100000000).toString(10));
     }
 
+    /**
+     * @inheritDoc
+     */
     getHyperlink(): string {
-        if(this.state===FromBTCSwapState.PR_CREATED) throw new Error("Cannot get bitcoin address of non-committed swap");
+        if(this._state===FromBTCSwapState.PR_CREATED) throw new Error("Cannot get bitcoin address of non-initiated swaps! Initiate swap first with commit() or txsCommit().");
         return this._getHyperlink();
     }
 
+    /**
+     * @inheritDoc
+     */
     getInputAddress(): string | null {
         return this.senderAddress ?? null;
     }
 
+    /**
+     * @inheritDoc
+     */
     getInputTxId(): string | null {
         return this.txId ?? null;
     }
@@ -177,74 +247,136 @@ export class FromBTCSwap<T extends ChainType = ChainType>
      *  to that address anymore
      */
     getTimeoutTime(): number {
-        return Number(this.wrapper.getOnchainSendTimeout(this.data, this.requiredConfirmations)) * 1000;
+        return Number(this.wrapper._getOnchainSendTimeout(this._data, this.requiredConfirmations ?? 6)) * 1000;
     }
 
+    /**
+     * @inheritDoc
+     */
     requiresAction(): boolean {
-        return this.isClaimable() || (this.state===FromBTCSwapState.CLAIM_COMMITED && this.getTimeoutTime()>Date.now() && this.txId==null);
+        return this.isClaimable() || (this._state===FromBTCSwapState.CLAIM_COMMITED && this.getTimeoutTime()>Date.now() && this.txId==null);
     }
 
+    /**
+     * @inheritDoc
+     */
     isFinished(): boolean {
-        return this.state===FromBTCSwapState.CLAIM_CLAIMED || this.state===FromBTCSwapState.QUOTE_EXPIRED || this.state===FromBTCSwapState.FAILED;
+        return this._state===FromBTCSwapState.CLAIM_CLAIMED || this._state===FromBTCSwapState.QUOTE_EXPIRED || this._state===FromBTCSwapState.FAILED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isClaimable(): boolean {
-        return this.state===FromBTCSwapState.BTC_TX_CONFIRMED;
+        return this._state===FromBTCSwapState.BTC_TX_CONFIRMED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isSuccessful(): boolean {
-        return this.state===FromBTCSwapState.CLAIM_CLAIMED;
+        return this._state===FromBTCSwapState.CLAIM_CLAIMED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isFailed(): boolean {
-        return this.state===FromBTCSwapState.FAILED || this.state===FromBTCSwapState.EXPIRED;
+        return this._state===FromBTCSwapState.FAILED || this._state===FromBTCSwapState.EXPIRED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isQuoteExpired(): boolean {
-        return this.state===FromBTCSwapState.QUOTE_EXPIRED;
+        return this._state===FromBTCSwapState.QUOTE_EXPIRED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isQuoteSoftExpired(): boolean {
-        return this.state===FromBTCSwapState.QUOTE_EXPIRED || this.state===FromBTCSwapState.QUOTE_SOFT_EXPIRED;
+        return this._state===FromBTCSwapState.QUOTE_EXPIRED || this._state===FromBTCSwapState.QUOTE_SOFT_EXPIRED;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     protected canCommit(): boolean {
-        if(this.state!==FromBTCSwapState.PR_CREATED) return false;
-        const expiry = this.wrapper.getOnchainSendTimeout(this.data, this.requiredConfirmations);
+        if(this._state!==FromBTCSwapState.PR_CREATED) return false;
+        if(this.requiredConfirmations==null) return false;
+        const expiry = this.wrapper._getOnchainSendTimeout(this._data, this.requiredConfirmations);
         const currentTimestamp = BigInt(Math.floor(Date.now()/1000));
 
-        return (expiry - currentTimestamp) >= this.wrapper.options.minSendWindow;
+        return (expiry - currentTimestamp) >= this.wrapper._options.minSendWindow;
     }
 
 
     //////////////////////////////
     //// Amounts & fees
 
+    /**
+     * @inheritDoc
+     */
     getInputToken(): BtcToken<false> {
         return BitcoinTokens.BTC;
     }
 
+    /**
+     * @inheritDoc
+     */
     getInput(): TokenAmount<T["ChainId"], BtcToken<false>> {
-        return toTokenAmount(this.amount, this.inputToken, this.wrapper.prices);
+        return toTokenAmount(this.amount ?? null, this.inputToken, this.wrapper._prices);
     }
 
     /**
-     * Returns claimer bounty, acting as a reward for watchtowers to claim the swap automatically
+     * Returns claimer bounty, acting as a reward for watchtowers to claim the swap automatically,
+     *  this amount is pre-funded by the user on the destination chain when the swap escrow
+     *  is initiated. For total pre-funded deposit amount see {@link getTotalDeposit}.
      */
     getClaimerBounty(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true> {
-        return toTokenAmount(this.data.getClaimerBounty(), this.wrapper.tokens[this.data.getDepositToken()], this.wrapper.prices);
+        return toTokenAmount(this._data.getClaimerBounty(), this.wrapper._tokens[this._data.getDepositToken()], this.wrapper._prices);
     }
 
 
     //////////////////////////////
     //// Bitcoin tx
 
+    /**
+     * If the required number of confirmations is not known, this function tries to infer it by looping through
+     *  possible confirmation targets and comparing the claim hashes
+     *
+     * @param btcTx Bitcoin transaction
+     * @param vout Output index of the desired output in the bitcoin transaction
+     *
+     * @private
+     */
+    private inferRequiredConfirmationsCount(btcTx: Omit<BtcTxWithBlockheight, "hex" | "raw">, vout: number): number | undefined {
+        const txOut = btcTx.outs[vout];
+        for(let i=1;i<=20;i++) {
+            const computedClaimHash = this.wrapper._contract.getHashForOnchain(
+                Buffer.from(txOut.scriptPubKey.hex, "hex"),
+                BigInt(txOut.value),
+                i
+            );
+            if(computedClaimHash.toString("hex")===this._data.getClaimHash()) {
+                return i;
+            }
+        }
+    }
+
+    /**
+     * @inheritDoc
+     */
     getRequiredConfirmationsCount(): number {
-        return this.requiredConfirmations;
+        return this.requiredConfirmations ?? NaN;
     }
 
     /**
-     * Checks whether a bitcoin payment was already made, returns the payment or null when no payment has been made.
+     * Checks whether a bitcoin payment was already made, returns the payment or `null` when no payment has been made.
+     *
+     * @internal
      */
     protected async getBitcoinPayment(): Promise<{
         txId: string,
@@ -253,32 +385,39 @@ export class FromBTCSwap<T extends ChainType = ChainType>
         targetConfirmations: number,
         inputAddresses?: string[]
     } | null> {
-        const txoHashHint = this.data.getTxoHashHint();
-        if(txoHashHint==null) throw new Error("Swap data don't include the txo hash hint! Cannot check btc transaction!");
+        const txoHashHint = this._data.getTxoHashHint();
+        if(txoHashHint==null) throw new Error("Swap data doesn't include the txo hash hint! Cannot check bitcoin transaction!");
+        if(this.address==null) throw new Error("Cannot check bitcoin payment, because the address is not known! This can happen after a swap is recovered.");
 
-        const result = await this.wrapper.btcRpc.checkAddressTxos(this.address, Buffer.from(txoHashHint, "hex"));
+        const result = await this.wrapper._btcRpc.checkAddressTxos(this.address, Buffer.from(txoHashHint, "hex"));
         if(result==null) return null;
 
+        if(this.requiredConfirmations==null) {
+            this.requiredConfirmations = this.inferRequiredConfirmationsCount(result.tx, result.vout);
+        }
+
         return {
             inputAddresses: result.tx.inputAddresses,
             txId: result.tx.txid,
             vout: result.vout,
             confirmations: result.tx.confirmations ?? 0,
-            targetConfirmations: this.requiredConfirmations
+            targetConfirmations: this.getRequiredConfirmationsCount()
         }
     }
 
     /**
-     * For internal use! Used to set the txId of the bitcoin payment from the on-chain events listener
+     * Used to set the txId of the bitcoin payment from the on-chain events listener
+     *
+     * @param txId Transaction ID that settled the swap on the smart chain
      *
-     * @param txId
+     * @internal
      */
     async _setBitcoinTxId(txId: string) {
         if(this.txId!==txId || this.address==null || this.vout==null || this.senderAddress==null || this.amount==null) {
-            const btcTx = await this.wrapper.btcRpc.getTransaction(txId);
+            const btcTx = await this.wrapper._btcRpc.getTransaction(txId);
             if(btcTx==null) return;
 
-            const txoHashHint = this.data.getTxoHashHint();
+            const txoHashHint = this._data.getTxoHashHint();
             if(txoHashHint!=null) {
                 const expectedTxoHash = Buffer.from(txoHashHint, "hex");
                 const vout = btcTx.outs.findIndex(out => getTxoHash(out.scriptPubKey.hex, out.value).equals(expectedTxoHash));
@@ -289,11 +428,13 @@ export class FromBTCSwap<T extends ChainType = ChainType>
                     // hence doesn't contain the address and amount data
                     if(this.amount==null) this.amount = BigInt(btcTx.outs[vout].value);
                     if(this.address==null) try {
-                        const addressData = OutScript.decode(Buffer.from(btcTx.outs[vout].scriptPubKey.hex, "hex"));
-                        this.address = Address(this.wrapper.options.bitcoinNetwork).encode(addressData);
+                        this.address = fromOutputScript(this.wrapper._options.bitcoinNetwork, btcTx.outs[vout].scriptPubKey.hex);
                     } catch (e: any) {
                         this.logger.warn("_setBitcoinTxId(): Failed to parse address from output script: ", e);
                     }
+                    if(this.requiredConfirmations==null) {
+                        this.requiredConfirmations = this.inferRequiredConfirmationsCount(btcTx, vout);
+                    }
                 }
             }
 
@@ -306,40 +447,67 @@ export class FromBTCSwap<T extends ChainType = ChainType>
     }
 
     /**
-     * Waits till the bitcoin transaction confirms and swap becomes claimable
+     * @inheritDoc
      *
-     * @param updateCallback Callback called when txId is found, and also called with subsequent confirmations
-     * @param checkIntervalSeconds How often to check the bitcoin transaction
-     * @param abortSignal Abort signal
-     * @throws {Error} if in invalid state (must be CLAIM_COMMITED)
+     * @throws {Error} if in invalid state (must be {@link FromBTCSwapState.CLAIM_COMMITED})
      */
     async waitForBitcoinTransaction(
         updateCallback?: (txId?: string, confirmations?: number, targetConfirmations?: number, txEtaMs?: number) => void,
         checkIntervalSeconds?: number,
         abortSignal?: AbortSignal
     ): Promise<string> {
-        if(this.state!==FromBTCSwapState.CLAIM_COMMITED && this.state!==FromBTCSwapState.EXPIRED) throw new Error("Must be in COMMITED state!");
-        const txoHashHint = this.data.getTxoHashHint();
-        if(txoHashHint==null) throw new Error("Swap data don't include the txo hash hint! Cannot check btc transaction!");
+        if(this._state!==FromBTCSwapState.CLAIM_COMMITED && this._state!==FromBTCSwapState.EXPIRED) throw new Error("Must be in COMMITED state!");
+        const txoHashHint = this._data.getTxoHashHint();
+        if(txoHashHint==null) throw new Error("Swap data doesn't include the txo hash hint! Cannot check bitcoin transaction!");
+        if(this.address==null) throw new Error("Cannot check bitcoin payment, because the address is not known! This can happen after a swap is recovered.");
+
+        let abortedDueToEnoughConfirmationsResult: {
+            tx: Omit<BtcTxWithBlockheight, "hex" | "raw">, vout: number
+        } | undefined;
+        const abortController = extendAbortController(abortSignal);
 
-        const result = await this.wrapper.btcRpc.waitForAddressTxo(
+        const result = await this.wrapper._btcRpc.waitForAddressTxo(
             this.address,
             Buffer.from(txoHashHint, "hex"),
-            this.requiredConfirmations,
+            this.requiredConfirmations ?? 6, //In case confirmation count is not known, we use a conservative estimate
             (btcTx?: Omit<BtcTxWithBlockheight, "hex" | "raw">, vout?: number, txEtaMs?: number) => {
-                if(updateCallback!=null) updateCallback(btcTx?.txid, btcTx==null ? undefined : (btcTx?.confirmations ?? 0), this.requiredConfirmations, txEtaMs);
-                if(btcTx!=null && btcTx.txid!==this.txId) {
+                let requiredConfirmations = this.requiredConfirmations;
+
+                if(btcTx!=null && vout!=null && requiredConfirmations==null) {
+                    requiredConfirmations = this.inferRequiredConfirmationsCount(btcTx, vout);
+                }
+
+                if(btcTx!=null && (btcTx.txid!==this.txId || (this.requiredConfirmations==null && requiredConfirmations!=null))) {
                     this.txId = btcTx.txid;
                     this.vout = vout;
+                    this.requiredConfirmations = requiredConfirmations;
                     if(btcTx.inputAddresses!=null) this.senderAddress = btcTx.inputAddresses[0];
                     this._saveAndEmit().catch(e => {
                         this.logger.error("waitForBitcoinTransaction(): Failed to save swap from within waitForAddressTxo callback:", e)
                     });
                 }
+
+                //Abort the loop as soon as the transaction gets enough confirmations, this is required in case
+                // we pass a default 6 confirmations to the fn, but then are able to infer the actual confirmation
+                // target from the prior block
+                if(btcTx?.confirmations!=null && requiredConfirmations!=null && requiredConfirmations<=btcTx.confirmations && vout!=null) {
+                    abortedDueToEnoughConfirmationsResult = {
+                        tx: btcTx,
+                        vout
+                    };
+                    abortController.abort();
+                    return;
+                }
+
+                if(updateCallback!=null) updateCallback(btcTx?.txid, btcTx==null ? undefined : (btcTx?.confirmations ?? 0), requiredConfirmations ?? NaN, txEtaMs);
             },
-            abortSignal,
+            abortController.signal,
             checkIntervalSeconds
-        );
+        ).catch(e => {
+            //We catch the case when the loop was aborted due to the transaction getting enough confirmations
+            if(abortedDueToEnoughConfirmationsResult!=null) return abortedDueToEnoughConfirmationsResult;
+            throw e;
+        });
 
         if(abortSignal!=null) abortSignal.throwIfAborted();
 
@@ -348,10 +516,10 @@ export class FromBTCSwap<T extends ChainType = ChainType>
         if(result.tx.inputAddresses!=null) this.senderAddress = result.tx.inputAddresses[0];
 
         if(
-            (this.state as FromBTCSwapState)!==FromBTCSwapState.CLAIM_CLAIMED &&
-            (this.state as FromBTCSwapState)!==FromBTCSwapState.FAILED
+            (this._state as FromBTCSwapState)!==FromBTCSwapState.CLAIM_CLAIMED &&
+            (this._state as FromBTCSwapState)!==FromBTCSwapState.FAILED
         ) {
-            this.state = FromBTCSwapState.BTC_TX_CONFIRMED;
+            this._state = FromBTCSwapState.BTC_TX_CONFIRMED;
         }
 
         await this._saveAndEmit();
@@ -360,34 +528,26 @@ export class FromBTCSwap<T extends ChainType = ChainType>
     }
 
     /**
-     * Returns the PSBT that is already funded with wallet's UTXOs (runs a coin-selection algorithm to choose UTXOs to use),
-     *  also returns inputs indices that need to be signed by the wallet before submitting the PSBT back to the SDK with
-     *  `swap.submitPsbt()`
+     * Private getter of the funded PSBT that doesn't check current state
      *
-     * @param _bitcoinWallet Sender's bitcoin wallet
-     * @param feeRate Optional fee rate for the transaction, needs to be at least as big as {minimumBtcFeeRate} field
-     * @param additionalOutputs additional outputs to add to the PSBT - can be used to collect fees from users
+     * @param _bitcoinWallet Bitcoin wallet to fund the PSBT with
+     * @param feeRate Optional bitcoin fee rate in sats/vB
+     * @param additionalOutputs Optional additional outputs that should also be included in the generated PSBT
+     *
+     * @private
      */
-    getFundedPsbt(
-        _bitcoinWallet: IBitcoinWallet | MinimalBitcoinWalletInterface,
-        feeRate?: number,
-        additionalOutputs?: ({amount: bigint, outputScript: Uint8Array} | {amount: bigint, address: string})[]
-    ) {
-        if(this.state!==FromBTCSwapState.CLAIM_COMMITED)
-            throw new Error("Swap not committed yet, please initiate the swap first with commit() call!");
-        return this._getFundedPsbt(_bitcoinWallet, feeRate, additionalOutputs);
-    }
-
     private async _getFundedPsbt(
         _bitcoinWallet: IBitcoinWallet | MinimalBitcoinWalletInterface,
         feeRate?: number,
         additionalOutputs?: ({amount: bigint, outputScript: Uint8Array} | {amount: bigint, address: string})[]
     ): Promise<{psbt: Transaction, psbtHex: string, psbtBase64: string, signInputs: number[]}> {
+        if(this.address==null) throw new Error("Cannot create funded PSBT, because the address is not known! This can happen after a swap is recovered.");
+
         let bitcoinWallet: IBitcoinWallet;
         if(isIBitcoinWallet(_bitcoinWallet)) {
             bitcoinWallet = _bitcoinWallet;
         } else {
-            bitcoinWallet = new SingleAddressBitcoinWallet(this.wrapper.btcRpc, this.wrapper.options.bitcoinNetwork, _bitcoinWallet);
+            bitcoinWallet = new SingleAddressBitcoinWallet(this.wrapper._btcRpc, this.wrapper._options.bitcoinNetwork, _bitcoinWallet);
         }
         //TODO: Maybe re-introduce fee rate check here if passed from the user
         if(feeRate==null) {
@@ -400,12 +560,12 @@ export class FromBTCSwap<T extends ChainType = ChainType>
         });
         basePsbt.addOutput({
             amount: this.amount,
-            script: toOutputScript(this.wrapper.options.bitcoinNetwork, this.address)
+            script: toOutputScript(this.wrapper._options.bitcoinNetwork, this.address)
         });
         if(additionalOutputs!=null) additionalOutputs.forEach(output => {
             basePsbt.addOutput({
                 amount: output.amount,
-                script: (output as {outputScript: Uint8Array}).outputScript ?? toOutputScript(this.wrapper.options.bitcoinNetwork, (output as {address: string}).address)
+                script: (output as {outputScript: Uint8Array}).outputScript ?? toOutputScript(this.wrapper._options.bitcoinNetwork, (output as {address: string}).address)
             });
         });
 
@@ -425,13 +585,27 @@ export class FromBTCSwap<T extends ChainType = ChainType>
     }
 
     /**
-     * Submits a PSBT signed by the wallet back to the SDK
+     * @inheritDoc
+     */
+    getFundedPsbt(
+        _bitcoinWallet: IBitcoinWallet | MinimalBitcoinWalletInterface,
+        feeRate?: number,
+        additionalOutputs?: ({amount: bigint, outputScript: Uint8Array} | {amount: bigint, address: string})[]
+    ) {
+        if(this._state!==FromBTCSwapState.CLAIM_COMMITED)
+            throw new Error("Swap not committed yet, please initiate the swap first with commit() call!");
+        return this._getFundedPsbt(_bitcoinWallet, feeRate, additionalOutputs);
+    }
+
+    /**
+     * @inheritDoc
      *
-     * @param _psbt A psbt - either a Transaction object or a hex or base64 encoded PSBT string
+     * @throws {Error} if the swap is in invalid state (not in {@link FromBTCSwapState.CLAIM_COMMITED}), or if
+     *  the swap bitcoin address already expired.
      */
     async submitPsbt(_psbt: Transaction | string): Promise<string> {
         const psbt = parsePsbtTransaction(_psbt);
-        if(this.state!==FromBTCSwapState.CLAIM_COMMITED)
+        if(this._state!==FromBTCSwapState.CLAIM_COMMITED)
             throw new Error("Swap not committed yet, please initiate the swap first with commit() call!");
 
         //Ensure not expired
@@ -440,26 +614,37 @@ export class FromBTCSwap<T extends ChainType = ChainType>
         }
 
         const output0 = psbt.getOutput(0);
-        if(output0.amount!==this.amount)
+        if(this.amount!=null && output0.amount!==this.amount)
             throw new Error("PSBT output amount invalid, expected: "+this.amount+" got: "+output0.amount);
-        const expectedOutputScript = toOutputScript(this.wrapper.options.bitcoinNetwork, this.address);
-        if(output0.script==null || !expectedOutputScript.equals(output0.script))
-            throw new Error("PSBT output script invalid!");
+        if(this.address!=null) {
+            const expectedOutputScript = toOutputScript(this.wrapper._options.bitcoinNetwork, this.address);
+            if(output0.script==null || !expectedOutputScript.equals(output0.script))
+                throw new Error("PSBT output script invalid!");
+        }
 
         if(!psbt.isFinal) psbt.finalize();
 
-        return await this.wrapper.btcRpc.sendRawTransaction(Buffer.from(psbt.toBytes(true, true)).toString("hex"));
+        return await this.wrapper._btcRpc.sendRawTransaction(Buffer.from(psbt.toBytes(true, true)).toString("hex"));
     }
 
+    /**
+     * @inheritDoc
+     */
     async estimateBitcoinFee(_bitcoinWallet: IBitcoinWallet | MinimalBitcoinWalletInterface, feeRate?: number): Promise<TokenAmount<any, BtcToken<false>, true> | null> {
-        const bitcoinWallet: IBitcoinWallet = toBitcoinWallet(_bitcoinWallet, this.wrapper.btcRpc, this.wrapper.options.bitcoinNetwork);
+        if(this.address==null || this.amount==null) return null;
+        const bitcoinWallet: IBitcoinWallet = toBitcoinWallet(_bitcoinWallet, this.wrapper._btcRpc, this.wrapper._options.bitcoinNetwork);
         const txFee = await bitcoinWallet.getTransactionFee(this.address, this.amount, feeRate);
         if(txFee==null) return null;
-        return toTokenAmount(BigInt(txFee), BitcoinTokens.BTC, this.wrapper.prices);
+        return toTokenAmount(BigInt(txFee), BitcoinTokens.BTC, this.wrapper._prices);
     }
 
+    /**
+     * @inheritDoc
+     */
     async sendBitcoinTransaction(wallet: IBitcoinWallet | MinimalBitcoinWalletInterfaceWithSigner, feeRate?: number): Promise<string> {
-        if(this.state!==FromBTCSwapState.CLAIM_COMMITED)
+        if(this.address==null || this.amount==null) 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!");
 
         //Ensure not expired
@@ -514,15 +699,15 @@ export class FromBTCSwap<T extends ChainType = ChainType>
             maxWaitTillAutomaticSettlementSeconds?: number
         }
     ): Promise<boolean> {
-        if(this.state===FromBTCSwapState.FAILED) throw new Error("Swap failed!");
-        if(this.state===FromBTCSwapState.EXPIRED) throw new Error("Swap address expired!");
-        if(this.state===FromBTCSwapState.QUOTE_EXPIRED || this.state===FromBTCSwapState.QUOTE_SOFT_EXPIRED) throw new Error("Swap quote expired!");
-        if(this.state===FromBTCSwapState.CLAIM_CLAIMED) throw new Error("Swap already settled!");
+        if(this._state===FromBTCSwapState.FAILED) throw new Error("Swap failed!");
+        if(this._state===FromBTCSwapState.EXPIRED) throw new Error("Swap address expired!");
+        if(this._state===FromBTCSwapState.QUOTE_EXPIRED || this._state===FromBTCSwapState.QUOTE_SOFT_EXPIRED) throw new Error("Swap quote expired!");
+        if(this._state===FromBTCSwapState.CLAIM_CLAIMED) throw new Error("Swap already settled!");
 
-        if(this.state===FromBTCSwapState.PR_CREATED) {
+        if(this._state===FromBTCSwapState.PR_CREATED) {
             await this.commit(dstSigner, options?.abortSignal, undefined, callbacks?.onDestinationCommitSent);
         }
-        if(this.state===FromBTCSwapState.CLAIM_COMMITED) {
+        if(this._state===FromBTCSwapState.CLAIM_COMMITED) {
             if(wallet!=null) {
                 const bitcoinPaymentSent = await this.getBitcoinPayment();
 
@@ -538,9 +723,9 @@ export class FromBTCSwap<T extends ChainType = ChainType>
         }
 
         // @ts-ignore
-        if(this.state===FromBTCSwapState.CLAIM_CLAIMED) return true;
+        if(this._state===FromBTCSwapState.CLAIM_CLAIMED) return true;
 
-        if(this.state===FromBTCSwapState.BTC_TX_CONFIRMED) {
+        if(this._state===FromBTCSwapState.BTC_TX_CONFIRMED) {
             const success = await this.waitTillClaimed(options?.maxWaitTillAutomaticSettlementSeconds ?? 60, options?.abortSignal);
             if(success && callbacks?.onSwapSettled!=null) callbacks.onSwapSettled(this.getOutputTxId()!);
             return success;
@@ -549,12 +734,23 @@ export class FromBTCSwap<T extends ChainType = ChainType>
         throw new Error("Invalid state reached!");
     }
 
+    /**
+     * @inheritDoc
+     *
+     * @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
+     */
     async txsExecute(options?: {
         bitcoinWallet?: MinimalBitcoinWalletInterface,
         skipChecks?: boolean
     }) {
-        if(this.state===FromBTCSwapState.PR_CREATED) {
-            if(!await this.verifyQuoteValid()) throw new Error("Quote already expired or close to expiry!");
+        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 [
                 {
@@ -566,38 +762,38 @@ export class FromBTCSwap<T extends ChainType = ChainType>
                 {
                     name: "Payment" as const,
                     description: "Send funds to the bitcoin swap address",
-                    chain: "BITCOIN",
+                    chain: "BITCOIN" as const,
                     txs: [
                         options?.bitcoinWallet==null ? {
-                            address: this.address,
+                            address: this.address ?? "",
                             amount: Number(this.amount),
                             hyperlink: this._getHyperlink(),
-                            type: "ADDRESS"
+                            type: "ADDRESS" as const
                         } : {
                             ...await this.getFundedPsbt(options.bitcoinWallet),
-                            type: "FUNDED_PSBT"
+                            type: "FUNDED_PSBT" as const
                         }
                     ]
                 }
             ];
         }
 
-        if(this.state===FromBTCSwapState.CLAIM_COMMITED) {
+        if(this._state===FromBTCSwapState.CLAIM_COMMITED) {
             if(this.getTimeoutTime()<Date.now()) throw new Error("Swap address already expired or close to expiry!");
             return [
                 {
                     name: "Payment" as const,
                     description: "Send funds to the bitcoin swap address",
-                    chain: "BITCOIN",
+                    chain: "BITCOIN" as const,
                     txs: [
                         options?.bitcoinWallet==null ? {
-                            address: this.address,
+                            address: this.getAddress(),
                             amount: Number(this.amount),
                             hyperlink: this._getHyperlink(),
-                            type: "ADDRESS"
+                            type: "ADDRESS" as const
                         } : {
                             ...await this.getFundedPsbt(options.bitcoinWallet),
-                            type: "FUNDED_PSBT"
+                            type: "FUNDED_PSBT" as const
                         }
                     ]
                 }
@@ -612,21 +808,16 @@ export class FromBTCSwap<T extends ChainType = ChainType>
     //// Commit
 
     /**
-     * Commits the swap on-chain, locking the tokens from the intermediary in a PTLC
+     * @inheritDoc
      *
-     * @param _signer Signer to sign the transactions with, must be the same as used in the initialization
-     * @param abortSignal Abort signal to stop waiting for the transaction confirmation and abort
-     * @param skipChecks Skip checks like making sure init signature is still valid and swap wasn't commited yet
-     *  (this is handled when swap is created (quoted), if you commit right after quoting, you can use skipChecks=true)
-     * @param onBeforeTxSent
      * @throws {Error} If invalid signer is provided that doesn't match the swap data
      */
     async commit(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, skipChecks?: boolean, onBeforeTxSent?: (txId: string) => void): Promise<string> {
-        const signer = isAbstractSigner(_signer) ? _signer : await this.wrapper.chain.wrapSigner(_signer);
+        const signer = isAbstractSigner(_signer) ? _signer : await this.wrapper._chain.wrapSigner(_signer);
         this.checkSigner(signer);
         let txCount = 0;
         const txs = await this.txsCommit(skipChecks);
-        const result = await this.wrapper.chain.sendAndConfirm(
+        const result = await this.wrapper._chain.sendAndConfirm(
             signer, txs, true, abortSignal, undefined, (txId: string) => {
                 txCount++;
                 if(onBeforeTxSent!=null && txCount===txs.length) onBeforeTxSent(txId);
@@ -634,16 +825,19 @@ export class FromBTCSwap<T extends ChainType = ChainType>
             }
         );
 
-        this.commitTxId = result[result.length - 1];
-        if(this.state===FromBTCSwapState.PR_CREATED || this.state===FromBTCSwapState.QUOTE_SOFT_EXPIRED) {
+        this._commitTxId = result[result.length - 1];
+        if(this._state===FromBTCSwapState.PR_CREATED || this._state===FromBTCSwapState.QUOTE_SOFT_EXPIRED) {
             await this._saveAndEmit(FromBTCSwapState.CLAIM_COMMITED);
         }
-        return this.commitTxId;
+        return this._commitTxId;
     }
 
+    /**
+     * @inheritDoc
+     */
     async waitTillCommited(abortSignal?: AbortSignal): Promise<void> {
-        if(this.state===FromBTCSwapState.CLAIM_COMMITED || this.state===FromBTCSwapState.CLAIM_CLAIMED) return Promise.resolve();
-        if(this.state!==FromBTCSwapState.PR_CREATED && this.state!==FromBTCSwapState.QUOTE_SOFT_EXPIRED) throw new Error("Invalid state");
+        if(this._state===FromBTCSwapState.CLAIM_COMMITED || this._state===FromBTCSwapState.CLAIM_CLAIMED) return Promise.resolve();
+        if(this._state!==FromBTCSwapState.PR_CREATED && this._state!==FromBTCSwapState.QUOTE_SOFT_EXPIRED) throw new Error("Invalid state");
 
         const abortController = extendAbortController(abortSignal);
         const result = await Promise.race([
@@ -656,13 +850,13 @@ export class FromBTCSwap<T extends ChainType = ChainType>
         if(result===true) this.logger.debug("waitTillCommited(): Resolved from watchdog - commited");
         if(result===false) {
             this.logger.debug("waitTillCommited(): Resolved from watchdog - signature expired");
-            if(this.state===FromBTCSwapState.PR_CREATED || this.state===FromBTCSwapState.QUOTE_SOFT_EXPIRED) {
+            if(this._state===FromBTCSwapState.PR_CREATED || this._state===FromBTCSwapState.QUOTE_SOFT_EXPIRED) {
                 await this._saveAndEmit(FromBTCSwapState.QUOTE_EXPIRED);
             }
             return;
         }
 
-        if(this.state===FromBTCSwapState.PR_CREATED || this.state===FromBTCSwapState.QUOTE_SOFT_EXPIRED) {
+        if(this._state===FromBTCSwapState.PR_CREATED || this._state===FromBTCSwapState.QUOTE_SOFT_EXPIRED) {
             await this._saveAndEmit(FromBTCSwapState.CLAIM_COMMITED);
         }
     }
@@ -672,10 +866,16 @@ export class FromBTCSwap<T extends ChainType = ChainType>
     //// Claim
 
     /**
-     * Returns transactions required to claim the swap on-chain (and possibly also sync the bitcoin light client)
-     *  after a bitcoin transaction was sent and confirmed
+     * Returns transactions for settling (claiming) the swap if the swap requires manual settlement, you can check so
+     *  with isClaimable. After sending the transaction manually be sure to call the waitTillClaimed function to wait
+     *  till the claim transaction is observed, processed by the SDK and state of the swap properly updated.
+     *
+     * @remarks
+     * Might also return transactions necessary to sync the bitcoin light client.
+     *
+     * @param _signer Address of the signer to create the claim transactions for
      *
-     * @throws {Error} If the swap is in invalid state (must be BTC_TX_CONFIRMED)
+     * @throws {Error} If the swap is in invalid state (must be {@link FromBTCSwapState.BTC_TX_CONFIRMED})
      */
     async txsClaim(_signer?: string | T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]> {
         let signer: string | T["Signer"] | undefined = undefined;
@@ -685,41 +885,52 @@ export class FromBTCSwap<T extends ChainType = ChainType>
             } else if (isAbstractSigner(_signer)) {
                 signer = _signer;
             } else {
-                signer = await this.wrapper.chain.wrapSigner(_signer);
+                signer = await this.wrapper._chain.wrapSigner(_signer);
             }
         }
 
-        if(this.state!==FromBTCSwapState.BTC_TX_CONFIRMED) throw new Error("Must be in BTC_TX_CONFIRMED state!");
+        if(this._state!==FromBTCSwapState.BTC_TX_CONFIRMED) throw new Error("Must be in BTC_TX_CONFIRMED state!");
         if(this.txId==null || this.vout==null) throw new Error("Bitcoin transaction ID not known!");
 
-        const tx = await this.wrapper.btcRpc.getTransaction(this.txId);
+        const tx = await this.wrapper._btcRpc.getTransaction(this.txId);
         if(tx==null) throw new Error("Bitcoin transaction not found on the network!");
+
+        this.requiredConfirmations ??= this.inferRequiredConfirmationsCount(tx, this.vout);
+        if(this.requiredConfirmations==null)
+            throw new Error("Cannot create claim transaction, because required confirmations are not known and cannot be infered! This can happen after a swap is recovered.");
+
         if(tx.blockhash==null || tx.confirmations==null || tx.blockheight==null || tx.confirmations<this.requiredConfirmations)
             throw new Error("Bitcoin transaction not confirmed yet!");
 
-        return await this.wrapper.contract.txsClaimWithTxData(signer ?? this._getInitiator(), this.data, {
+        return await this.wrapper._contract.txsClaimWithTxData(signer ?? this._getInitiator(), this._data, {
             blockhash: tx.blockhash,
             confirmations: tx.confirmations,
             txid: tx.txid,
             hex: tx.hex,
             height: tx.blockheight
-        }, this.requiredConfirmations, this.vout, undefined, this.wrapper.synchronizer, true);
+        }, this.requiredConfirmations, this.vout, undefined, this.wrapper._synchronizer, true);
     }
 
     /**
-     * Claims and finishes the swap
+     * Settles the swap by claiming the funds on the destination chain if the swap requires manual settlement, you can
+     *  check so with isClaimable.
+     *
+     * @remarks
+     * Might also sync the bitcoin light client during the process.
+     *
+     * @param _signer Signer to use for signing the settlement transactions, can also be different to the recipient
+     * @param abortSignal Abort signal
+     * @param onBeforeTxSent Optional callback triggered before the claim transaction is broadcasted
      *
-     * @param _signer Signer to sign the transactions with, can also be different to the initializer
-     * @param abortSignal Abort signal to stop waiting for transaction confirmation
-     * @param onBeforeTxSent
+     * @returns Transaction ID of the settlement (claim) transaction on the destination smart chain
      */
     async claim(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, onBeforeTxSent?: (txId: string) => void): Promise<string> {
-        const signer = isAbstractSigner(_signer) ? _signer : await this.wrapper.chain.wrapSigner(_signer);
+        const signer = isAbstractSigner(_signer) ? _signer : await this.wrapper._chain.wrapSigner(_signer);
         let txIds: string[];
         try {
             let txCount = 0;
             const txs = await this.txsClaim(signer);
-            txIds = await this.wrapper.chain.sendAndConfirm(
+            txIds = await this.wrapper._chain.sendAndConfirm(
                 signer, txs, true, abortSignal, undefined, (txId: string) => {
                     txCount++;
                     if(onBeforeTxSent!=null && txCount===txs.length) onBeforeTxSent(txId);
@@ -728,26 +939,26 @@ export class FromBTCSwap<T extends ChainType = ChainType>
             );
         } catch (e) {
             this.logger.info("claim(): Failed to claim ourselves, checking swap claim state...");
-            if(this.state===FromBTCSwapState.CLAIM_CLAIMED) {
+            if(this._state===FromBTCSwapState.CLAIM_CLAIMED) {
                 this.logger.info("claim(): Transaction state is CLAIM_CLAIMED, swap was successfully claimed by the watchtower");
-                return this.claimTxId!;
+                return this._claimTxId!;
             }
-            const status = await this.wrapper.contract.getCommitStatus(this._getInitiator(), this.data);
+            const status = await this.wrapper._contract.getCommitStatus(this._getInitiator(), this._data);
             if(status?.type===SwapCommitStateType.PAID) {
                 this.logger.info("claim(): Transaction commit status is PAID, swap was successfully claimed by the watchtower");
-                if(this.claimTxId==null) this.claimTxId = await status.getClaimTxId();
+                if(this._claimTxId==null) this._claimTxId = await status.getClaimTxId();
                 const txId = Buffer.from(await status.getClaimResult(), "hex").reverse().toString("hex");
                 await this._setBitcoinTxId(txId);
                 await this._saveAndEmit(FromBTCSwapState.CLAIM_CLAIMED);
-                return this.claimTxId;
+                return this._claimTxId;
             }
             throw e;
         }
 
-        this.claimTxId = txIds[txIds.length - 1];
+        this._claimTxId = txIds[txIds.length - 1];
         if(
-            this.state===FromBTCSwapState.CLAIM_COMMITED || this.state===FromBTCSwapState.BTC_TX_CONFIRMED ||
-            this.state===FromBTCSwapState.EXPIRED || this.state===FromBTCSwapState.FAILED
+            this._state===FromBTCSwapState.CLAIM_COMMITED || this._state===FromBTCSwapState.BTC_TX_CONFIRMED ||
+            this._state===FromBTCSwapState.EXPIRED || this._state===FromBTCSwapState.FAILED
         ) {
             await this._saveAndEmit(FromBTCSwapState.CLAIM_CLAIMED);
         }
@@ -755,17 +966,14 @@ export class FromBTCSwap<T extends ChainType = ChainType>
     }
 
     /**
-     * Waits till the swap is successfully claimed
+     * @inheritDoc
      *
-     * @param maxWaitTimeSeconds Maximum time in seconds to wait for the swap to be settled
-     * @param abortSignal AbortSignal
-     * @throws {Error} If swap is in invalid state (must be BTC_TX_CONFIRMED)
+     * @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
-     * @returns {boolean} whether the swap was claimed in time or not
      */
     async waitTillClaimed(maxWaitTimeSeconds?: number, abortSignal?: AbortSignal): Promise<boolean> {
-        if(this.state===FromBTCSwapState.CLAIM_CLAIMED) return Promise.resolve(true);
-        if(this.state!==FromBTCSwapState.BTC_TX_CONFIRMED) throw new Error("Invalid state (not BTC_TX_CONFIRMED)");
+        if(this._state===FromBTCSwapState.CLAIM_CLAIMED) return Promise.resolve(true);
+        if(this._state!==FromBTCSwapState.BTC_TX_CONFIRMED) throw new Error("Invalid state (not BTC_TX_CONFIRMED)");
 
         const abortController = extendAbortController(abortSignal);
 
@@ -803,8 +1011,8 @@ export class FromBTCSwap<T extends ChainType = ChainType>
         this.logger.debug("waitTillClaimed(): Resolved from watchdog");
 
         if(res?.type===SwapCommitStateType.PAID) {
-            if((this.state as FromBTCSwapState)!==FromBTCSwapState.CLAIM_CLAIMED) {
-                if(this.claimTxId==null) this.claimTxId = await res.getClaimTxId();
+            if((this._state as FromBTCSwapState)!==FromBTCSwapState.CLAIM_CLAIMED) {
+                if(this._claimTxId==null) this._claimTxId = await res.getClaimTxId();
                 const txId = Buffer.from(await res.getClaimResult(), "hex").reverse().toString("hex");
                 await this._setBitcoinTxId(txId);
                 await this._saveAndEmit(FromBTCSwapState.CLAIM_CLAIMED);
@@ -812,10 +1020,10 @@ export class FromBTCSwap<T extends ChainType = ChainType>
         }
         if(res?.type===SwapCommitStateType.NOT_COMMITED || res?.type===SwapCommitStateType.EXPIRED) {
             if(
-                (this.state as FromBTCSwapState)!==FromBTCSwapState.CLAIM_CLAIMED &&
-                (this.state as FromBTCSwapState)!==FromBTCSwapState.FAILED
+                (this._state as FromBTCSwapState)!==FromBTCSwapState.CLAIM_CLAIMED &&
+                (this._state as FromBTCSwapState)!==FromBTCSwapState.FAILED
             ) {
-                if(res.getRefundTxId!=null) this.refundTxId = await res.getRefundTxId();
+                if(res.getRefundTxId!=null) this._refundTxId = await res.getRefundTxId();
                 await this._saveAndEmit(FromBTCSwapState.FAILED);
             }
             throw new Error("Swap expired while waiting for claim!");
@@ -828,11 +1036,14 @@ export class FromBTCSwap<T extends ChainType = ChainType>
     //////////////////////////////
     //// Storage
 
+    /**
+     * @inheritDoc
+     */
     serialize(): any {
         return {
             ...super.serialize(),
             address: this.address,
-            amount: this.amount.toString(10),
+            amount: this.amount==null ? null: this.amount.toString(10),
             requiredConfirmations: this.requiredConfirmations,
             senderAddress: this.senderAddress,
             txId: this.txId,
@@ -851,105 +1062,132 @@ export class FromBTCSwap<T extends ChainType = ChainType>
      * @private
      */
     private async syncStateFromChain(quoteDefinitelyExpired?: boolean, commitStatus?: SwapCommitState): Promise<boolean> {
-        if(this.state===FromBTCSwapState.PR_CREATED || this.state===FromBTCSwapState.QUOTE_SOFT_EXPIRED) {
-            const quoteExpired = quoteDefinitelyExpired ?? await this._verifyQuoteDefinitelyExpired(); //Make sure we check for expiry here, to prevent race conditions
-            const status = commitStatus ?? await this.wrapper.contract.getCommitStatus(this._getInitiator(), this.data);
-            switch(status?.type) {
-                case SwapCommitStateType.COMMITED:
-                    this.state = FromBTCSwapState.CLAIM_COMMITED;
-                    return true;
-                case SwapCommitStateType.EXPIRED:
-                    if(this.refundTxId==null && status.getRefundTxId) this.refundTxId = await status.getRefundTxId();
-                    this.state = FromBTCSwapState.QUOTE_EXPIRED;
-                    return true;
-                case SwapCommitStateType.PAID:
-                    if(this.claimTxId==null) this.claimTxId = await status.getClaimTxId();
-                    const txId = Buffer.from(await status.getClaimResult(), "hex").reverse().toString("hex");
-                    await this._setBitcoinTxId(txId);
-                    this.state = FromBTCSwapState.CLAIM_CLAIMED;
-                    return true;
-            }
-
-            if(quoteExpired) {
-                this.state = FromBTCSwapState.QUOTE_EXPIRED;
-                return true;
+        if(
+            this._state===FromBTCSwapState.PR_CREATED ||
+            this._state===FromBTCSwapState.QUOTE_SOFT_EXPIRED ||
+            this._state===FromBTCSwapState.CLAIM_COMMITED ||
+            this._state===FromBTCSwapState.BTC_TX_CONFIRMED ||
+            this._state===FromBTCSwapState.EXPIRED
+        ) {
+            let quoteExpired: boolean = false;
+            if(this._state===FromBTCSwapState.PR_CREATED || this._state===FromBTCSwapState.QUOTE_SOFT_EXPIRED) {
+                quoteExpired = quoteDefinitelyExpired ?? await this._verifyQuoteDefinitelyExpired(); //Make sure we check for expiry here, to prevent race conditions
             }
 
-            return false;
-        }
+            const status = commitStatus ?? await this.wrapper._contract.getCommitStatus(this._getInitiator(), this._data);
+            if(status!=null && await this._forciblySetOnchainState(status)) return true;
 
-        if(this.state===FromBTCSwapState.CLAIM_COMMITED || this.state===FromBTCSwapState.BTC_TX_CONFIRMED || this.state===FromBTCSwapState.EXPIRED) {
-            const status = commitStatus ?? await this.wrapper.contract.getCommitStatus(this._getInitiator(), this.data);
-            switch(status?.type) {
-                case SwapCommitStateType.PAID:
-                    if(this.claimTxId==null) this.claimTxId = await status.getClaimTxId();
-                    const txId = Buffer.from(await status.getClaimResult(), "hex").reverse().toString("hex");
-                    await this._setBitcoinTxId(txId);
-                    this.state = FromBTCSwapState.CLAIM_CLAIMED;
+            if(this._state===FromBTCSwapState.PR_CREATED || this._state===FromBTCSwapState.QUOTE_SOFT_EXPIRED) {
+                if(quoteExpired) {
+                    this._state = FromBTCSwapState.QUOTE_EXPIRED;
                     return true;
-                case SwapCommitStateType.NOT_COMMITED:
-                case SwapCommitStateType.EXPIRED:
-                    if(this.refundTxId==null && status.getRefundTxId) this.refundTxId = await status.getRefundTxId();
-                    this.state = FromBTCSwapState.FAILED;
-                    return true;
-                case SwapCommitStateType.COMMITED:
-                    const res = await this.getBitcoinPayment();
-                    if(res!=null) {
-                        let save: boolean = false;
-                        if(this.txId!==res.txId) {
-                            if(res.inputAddresses!=null) this.senderAddress = res.inputAddresses[0];
-                            this.txId = res.txId;
-                            this.vout = res.vout;
-                            save = true;
-                        }
-                        if(res.confirmations>=this.requiredConfirmations) {
-                            this.state = FromBTCSwapState.BTC_TX_CONFIRMED;
-                            save = true;
-                        }
-                        return save;
-                    }
-                    break;
+                }
             }
         }
 
         return false;
     }
 
-    _shouldFetchCommitStatus(): boolean {
-        return this.state===FromBTCSwapState.PR_CREATED || this.state===FromBTCSwapState.QUOTE_SOFT_EXPIRED ||
-            this.state===FromBTCSwapState.CLAIM_COMMITED || this.state===FromBTCSwapState.BTC_TX_CONFIRMED ||
-            this.state===FromBTCSwapState.EXPIRED;
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _shouldFetchOnchainState(): boolean {
+        return this._state===FromBTCSwapState.PR_CREATED || this._state===FromBTCSwapState.QUOTE_SOFT_EXPIRED ||
+            this._state===FromBTCSwapState.CLAIM_COMMITED || this._state===FromBTCSwapState.BTC_TX_CONFIRMED ||
+            this._state===FromBTCSwapState.EXPIRED;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     _shouldFetchExpiryStatus(): boolean {
-        return this.state===FromBTCSwapState.PR_CREATED || this.state===FromBTCSwapState.QUOTE_SOFT_EXPIRED;
+        return this._state===FromBTCSwapState.PR_CREATED || this._state===FromBTCSwapState.QUOTE_SOFT_EXPIRED;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     async _sync(save?: boolean, quoteDefinitelyExpired?: boolean, commitStatus?: SwapCommitState): Promise<boolean> {
         const changed = await this.syncStateFromChain(quoteDefinitelyExpired, commitStatus);
         if(changed && save) await this._saveAndEmit();
         return changed;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    async _forciblySetOnchainState(status: SwapCommitState): Promise<boolean> {
+        switch(status.type) {
+            case SwapCommitStateType.PAID:
+                if(this._claimTxId==null) this._claimTxId = await status.getClaimTxId();
+                const txId = Buffer.from(await status.getClaimResult(), "hex").reverse().toString("hex");
+                await this._setBitcoinTxId(txId);
+                this._state = FromBTCSwapState.CLAIM_CLAIMED;
+                return true;
+            case SwapCommitStateType.NOT_COMMITED:
+                if(this._refundTxId==null && status.getRefundTxId) this._refundTxId = await status.getRefundTxId();
+                if(this._refundTxId!=null) {
+                    this._state = FromBTCSwapState.FAILED;
+                    return true;
+                }
+                break;
+            case SwapCommitStateType.EXPIRED:
+                if(this._refundTxId==null && status.getRefundTxId) this._refundTxId = await status.getRefundTxId();
+                this._state = this._refundTxId==null ? FromBTCSwapState.QUOTE_EXPIRED : FromBTCSwapState.FAILED;
+                return true;
+            case SwapCommitStateType.COMMITED:
+                let save: boolean = false;
+                if(this._state!==FromBTCSwapState.CLAIM_COMMITED && this._state!==FromBTCSwapState.BTC_TX_CONFIRMED && this._state!==FromBTCSwapState.EXPIRED) {
+                    this._state = FromBTCSwapState.CLAIM_COMMITED;
+                    save = true;
+                }
+                if(this.address==null) return save;
+
+                const res = await this.getBitcoinPayment();
+                if(res!=null) {
+                    if(this.txId!==res.txId) {
+                        if(res.inputAddresses!=null) this.senderAddress = res.inputAddresses[0];
+                        this.txId = res.txId;
+                        this.vout = res.vout;
+                        save = true;
+                    }
+                    if(this.requiredConfirmations!=null && res.confirmations>=this.requiredConfirmations) {
+                        this._state = FromBTCSwapState.BTC_TX_CONFIRMED;
+                        save = true;
+                    }
+                }
+                return save;
+        }
+        return false;
+    }
+
+    /**
+     * @inheritDoc
+     * @internal
+     */
     async _tick(save?: boolean): Promise<boolean> {
-        switch(this.state) {
+        switch(this._state) {
             case FromBTCSwapState.PR_CREATED:
                 if(this.expiry<Date.now()) {
-                    this.state = FromBTCSwapState.QUOTE_SOFT_EXPIRED;
+                    this._state = FromBTCSwapState.QUOTE_SOFT_EXPIRED;
                     if(save) await this._saveAndEmit();
                     return true;
                 }
                 break;
             case FromBTCSwapState.CLAIM_COMMITED:
                 if(this.getTimeoutTime()<Date.now()) {
-                    this.state = FromBTCSwapState.EXPIRED;
+                    this._state = FromBTCSwapState.EXPIRED;
                     if(save) await this._saveAndEmit();
                     return true;
                 }
             case FromBTCSwapState.EXPIRED:
                 //Check if bitcoin payment was received every 2 minutes
                 if(Math.floor(Date.now()/1000)%120===0) {
-                    try {
+                    if(this.address!=null) try {
                         const res = await this.getBitcoinPayment();
                         if(res!=null) {
                             let shouldSave: boolean = false;
@@ -959,8 +1197,8 @@ export class FromBTCSwap<T extends ChainType = ChainType>
                                 if(res.inputAddresses!=null) this.senderAddress = res.inputAddresses[0];
                                 shouldSave = true;
                             }
-                            if(res.confirmations>=this.requiredConfirmations) {
-                                this.state = FromBTCSwapState.BTC_TX_CONFIRMED;
+                            if(this.requiredConfirmations!=null && res.confirmations>=this.requiredConfirmations) {
+                                this._state = FromBTCSwapState.BTC_TX_CONFIRMED;
                                 if(save) await this._saveAndEmit();
                                 shouldSave = true;
                             }