@atomiqlabs/sdk 8.1.7 → 8.3.1

package/src/swaps/spv_swaps/SpvFromBTCSwap.ts

@@ -38,24 +38,75 @@ import {
     serializePriceInfoType
 } from "../../types/PriceInfoType";
 import {toBitcoinWallet} from "../../utils/BitcoinWalletUtils";
+import {SwapExecutionActionBitcoin} from "../../types/SwapExecutionAction";
 
 /**
- * State enum for SPV FromBTC swaps
+ * State enum for SPV vault (UTXO-controlled vault) based swaps
  * @category Swaps
  */
 export enum SpvFromBTCSwapState {
+    /**
+     * Catastrophic failure has occurred when processing the swap on the smart chain side,
+     *  this implies a bug in the smart contract code or the user and intermediary deliberately
+     *  creating a bitcoin transaction with invalid format unparsable by the smart contract.
+     */
     CLOSED = -5,
-    FAILED = -4, //Btc tx double-spent, or btc tx inputs double-spent
+    /**
+     * Some of the bitcoin swap transaction inputs were double-spent, this means the swap
+     *  has failed and no BTC was sent
+     */
+    FAILED = -4,
+    /**
+     * The intermediary (LP) declined to co-sign the submitted PSBT, hence the swap failed
+     */
     DECLINED = -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,
-    CREATED = 0, //Swap data received from the LP
-    SIGNED = 1, //Swap bitcoin tx funded and signed by the client
-    POSTED = 2, //Swap bitcoin tx posted to the LP
-    BROADCASTED = 3, //LP broadcasted the posted tx
-    FRONTED = 4, //Payout on SC was fronted
-    BTC_TX_CONFIRMED = 5, //Bitcoin transaction confirmed
-    CLAIMED = 6 //Funds claimed
+    /**
+     * Swap was created, use the {@link SpvFromBTCSwap.getFundedPsbt} or {@link SpvFromBTCSwap.getPsbt} functions
+     *  to get the bitcoin swap PSBT that should be signed by the user's wallet and then submitted via the
+     *  {@link SpvFromBTCSwap.submitPsbt} function.
+     */
+    CREATED = 0,
+    /**
+     * Swap bitcoin PSBT was submitted by the client to the SDK
+     */
+    SIGNED = 1,
+    /**
+     * Swap bitcoin PSBT sent to the intermediary (LP), waiting for the intermediary co-sign
+     *  it and broadcast. You can use the {@link SpvFromBTCSwap.waitTillClaimedOrFronted}
+     *  function to wait till the intermediary broadcasts the transaction and the transaction
+     *  confirms.
+     */
+    POSTED = 2,
+    /**
+     * Intermediary (LP) has co-signed and broadcasted the bitcoin transaction. You can use the
+     *  {@link SpvFromBTCSwap.waitTillClaimedOrFronted} function to wait till the transaction
+     *  confirms.
+     */
+    BROADCASTED = 3,
+    /**
+     * Settlement on the destination smart chain was fronted and funds were already received
+     *  by the user, even before the final settlement.
+     */
+    FRONTED = 4,
+    /**
+     * Bitcoin transaction confirmed with necessary amount of confirmations, wait for automatic
+     *  settlement by the watchtower with the {@link waitTillClaimedOrFronted} function, or settle manually
+     *  using the {@link FromBTCSwap.claim} or {@link FromBTCSwap.txsClaim} function.
+     */
+    BTC_TX_CONFIRMED = 5,
+    /**
+     * Swap settled on the smart chain and funds received
+     */
+    CLAIMED = 6
 }
 
 export type SpvFromBTCSwapInit = ISwapInit & {
@@ -116,52 +167,80 @@ export function isSpvFromBTCSwapInit(obj: any): obj is SpvFromBTCSwapInit {
         isISwapInit(obj);
 }
 
+/**
+ * New spv vault (UTXO-controlled vault) based swaps for Bitcoin -> Smart chain swaps not requiring
+ *  any initiation on the destination chain, and with the added possibility for the user to receive
+ *  a native token on the destination chain as part of the swap (a "gas drop" feature).
+ *
+ * @category Swaps
+ */
 export class SpvFromBTCSwap<T extends ChainType>
     extends ISwap<T, SpvFromBTCTypeDefinition<T>>
     implements IBTCWalletSwap, ISwapWithGasDrop<T>, IClaimableSwap<T, SpvFromBTCTypeDefinition<T>, SpvFromBTCSwapState> {
 
-    readonly TYPE = SwapType.SPV_VAULT_FROM_BTC;
+    readonly TYPE: SwapType.SPV_VAULT_FROM_BTC = SwapType.SPV_VAULT_FROM_BTC;
+    /**
+     * @inheritDoc
+     * @internal
+     */
     protected readonly logger: LoggerType;
 
-    readonly quoteId: string;
-    readonly recipient: string;
+    private readonly quoteId: string;
+    private readonly recipient: string;
 
-    readonly vaultOwner: string;
-    readonly vaultId: bigint;
-    readonly vaultRequiredConfirmations: number;
-    readonly vaultTokenMultipliers: bigint[];
+    private readonly vaultOwner: string;
+    private readonly vaultId: bigint;
+    private readonly vaultRequiredConfirmations: number;
+    private readonly vaultTokenMultipliers: bigint[];
 
-    readonly vaultBtcAddress: string;
-    readonly vaultUtxo: string;
-    readonly vaultUtxoValue: bigint;
+    private readonly vaultBtcAddress: string;
+    private readonly vaultUtxo: string;
+    private readonly vaultUtxoValue: bigint;
 
-    readonly btcDestinationAddress: string;
-    readonly btcAmount: bigint;
-    readonly btcAmountSwap: bigint;
-    readonly btcAmountGas: bigint;
-    readonly minimumBtcFeeRate: number;
+    private readonly btcDestinationAddress: string;
+    private readonly btcAmount: bigint;
+    private readonly btcAmountSwap: bigint;
+    private readonly btcAmountGas: bigint;
 
-    readonly outputTotalSwap: bigint;
-    readonly outputSwapToken: string;
-    readonly outputTotalGas: bigint;
-    readonly outputGasToken: string;
+    private readonly outputTotalSwap: bigint;
+    private readonly outputSwapToken: string;
+    private readonly outputTotalGas: bigint;
+    private readonly outputGasToken: string;
 
-    readonly gasSwapFeeBtc: bigint;
-    readonly gasSwapFee: bigint;
+    private readonly gasSwapFeeBtc: bigint;
+    private readonly gasSwapFee: bigint;
 
-    readonly callerFeeShare: bigint;
-    readonly frontingFeeShare: bigint;
-    readonly executionFeeShare: bigint;
+    private readonly callerFeeShare: bigint;
+    private readonly frontingFeeShare: bigint;
+    private readonly executionFeeShare: bigint;
 
-    readonly genesisSmartChainBlockHeight: number;
-
-    gasPricingInfo?: PriceInfoType;
+    private readonly gasPricingInfo?: PriceInfoType;
 
-    senderAddress?: string;
+    /**
+     * @internal
+     */
+    readonly _genesisSmartChainBlockHeight: number;
+    /**
+     * @internal
+     */
+    _senderAddress?: string;
+    /**
+     * @internal
+     */
+    _claimTxId?: string;
+    /**
+     * @internal
+     */
+    _frontTxId?: string;
+    /**
+     * @internal
+     */
+    _data?: T["SpvVaultWithdrawalData"];
 
-    claimTxId?: string;
-    frontTxId?: string;
-    data?: T["SpvVaultWithdrawalData"];
+    /**
+     * Minimum fee rate in sats/vB that the input bitcoin transaction needs to pay
+     */
+    readonly minimumBtcFeeRate: number;
 
     constructor(wrapper: SpvFromBTCWrapper<T>, init: SpvFromBTCSwapInit);
     constructor(wrapper: SpvFromBTCWrapper<T>, obj: any);
@@ -169,7 +248,7 @@ export class SpvFromBTCSwap<T extends ChainType>
         if(isSpvFromBTCSwapInit(initOrObject) && initOrObject.url!=null) initOrObject.url += "/frombtc_spv";
         super(wrapper, initOrObject);
         if(isSpvFromBTCSwapInit(initOrObject)) {
-            this.state = SpvFromBTCSwapState.CREATED;
+            this._state = SpvFromBTCSwapState.CREATED;
             this.quoteId = initOrObject.quoteId;
             this.recipient = initOrObject.recipient;
             this.vaultOwner = initOrObject.vaultOwner;
@@ -193,9 +272,9 @@ export class SpvFromBTCSwap<T extends ChainType>
             this.callerFeeShare = initOrObject.callerFeeShare;
             this.frontingFeeShare = initOrObject.frontingFeeShare;
             this.executionFeeShare = initOrObject.executionFeeShare;
-            this.genesisSmartChainBlockHeight = initOrObject.genesisSmartChainBlockHeight;
+            this._genesisSmartChainBlockHeight = initOrObject.genesisSmartChainBlockHeight;
             this.gasPricingInfo = initOrObject.gasPricingInfo;
-            const vaultAddressType = toCoinselectAddressType(toOutputScript(this.wrapper.options.bitcoinNetwork, this.vaultBtcAddress));
+            const vaultAddressType = toCoinselectAddressType(toOutputScript(this.wrapper._options.bitcoinNetwork, this.vaultBtcAddress));
             if(vaultAddressType!=="p2tr" && vaultAddressType!=="p2wpkh" && vaultAddressType!=="p2wsh")
                 throw new Error("Vault address type must be of witness type: p2tr, p2wpkh, p2wsh");
         } else {
@@ -222,22 +301,26 @@ export class SpvFromBTCSwap<T extends ChainType>
             this.callerFeeShare = BigInt(initOrObject.callerFeeShare);
             this.frontingFeeShare = BigInt(initOrObject.frontingFeeShare);
             this.executionFeeShare = BigInt(initOrObject.executionFeeShare);
-            this.genesisSmartChainBlockHeight = initOrObject.genesisSmartChainBlockHeight;
-            this.senderAddress = initOrObject.senderAddress;
-            this.claimTxId = initOrObject.claimTxId;
-            this.frontTxId = initOrObject.frontTxId;
+            this._genesisSmartChainBlockHeight = initOrObject.genesisSmartChainBlockHeight;
+            this._senderAddress = initOrObject.senderAddress;
+            this._claimTxId = initOrObject.claimTxId;
+            this._frontTxId = initOrObject.frontTxId;
             this.gasPricingInfo = deserializePriceInfoType(initOrObject.gasPricingInfo);
-            if(initOrObject.data!=null) this.data = new this.wrapper.spvWithdrawalDataDeserializer(initOrObject.data);
+            if(initOrObject.data!=null) this._data = new this.wrapper._spvWithdrawalDataDeserializer(initOrObject.data);
         }
         this.tryCalculateSwapFee();
         this.logger = getLogger("SPVFromBTC("+this.getId()+"): ");
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     protected upgradeVersion() { /*NOOP*/ }
 
     /**
-     * In case swapFee in BTC is not supplied it recalculates it based on swap price
-     * @protected
+     * @inheritDoc
+     * @internal
      */
     protected tryCalculateSwapFee() {
         if(this.swapFeeBtc==null && this.swapFee!=null) {
@@ -246,7 +329,7 @@ export class SpvFromBTCSwap<T extends ChainType>
 
         if(this.pricingInfo!=null && this.pricingInfo.swapPriceUSatPerToken==null) {
             const priceUsdPerBtc = this.pricingInfo.realPriceUsdPerBitcoin;
-            this.pricingInfo = this.wrapper.prices.recomputePriceInfoReceive(
+            this.pricingInfo = this.wrapper._prices.recomputePriceInfoReceive(
                 this.chainIdentifier,
                 this.btcAmountSwap,
                 this.pricingInfo.satsBaseFee,
@@ -262,10 +345,13 @@ export class SpvFromBTCSwap<T extends ChainType>
     //////////////////////////////
     //// Pricing
 
+    /**
+     * @inheritDoc
+     */
     async refreshPriceData(): Promise<void> {
         if(this.pricingInfo==null) return;
         const usdPricePerBtc = this.pricingInfo.realPriceUsdPerBitcoin;
-        this.pricingInfo = await this.wrapper.prices.isValidAmountReceive(
+        this.pricingInfo = await this.wrapper._prices.isValidAmountReceive(
             this.chainIdentifier,
             this.btcAmountSwap,
             this.pricingInfo.satsBaseFee,
@@ -280,97 +366,198 @@ export class SpvFromBTCSwap<T extends ChainType>
     //////////////////////////////
     //// Getters & utils
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     _getInitiator(): string {
         return this.recipient;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     _getEscrowHash(): string | null {
-        return this.data?.btcTx?.txid ?? null;
+        return this._data?.btcTx?.txid ?? null;
     }
 
+    /**
+     * @inheritDoc
+     */
     getId(): string {
-        return this.quoteId+this.randomNonce;
+        return this.quoteId+this._randomNonce;
     }
 
+    /**
+     * @inheritDoc
+     */
     getQuoteExpiry(): number {
         return this.expiry - 20*1000;
     }
 
-    verifyQuoteValid(): Promise<boolean> {
-        return Promise.resolve(this.expiry>Date.now() && (this.state===SpvFromBTCSwapState.CREATED || this.state===SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED));
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _verifyQuoteDefinitelyExpired(): Promise<boolean> {
+        return Promise.resolve(this.expiry<Date.now());
+    }
+
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _verifyQuoteValid(): Promise<boolean> {
+        return Promise.resolve(this.expiry>Date.now() && (this._state===SpvFromBTCSwapState.CREATED || this._state===SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED));
     }
 
+    /**
+     * @inheritDoc
+     */
     getOutputAddress(): string | null {
         return this.recipient;
     }
 
+    /**
+     * @inheritDoc
+     */
     getOutputTxId(): string | null {
-        return this.frontTxId ?? this.claimTxId ?? null;
+        return this._frontTxId ?? this._claimTxId ?? null;
     }
 
+    /**
+     * @inheritDoc
+     */
     getInputAddress(): string | null {
-        return this.senderAddress ?? null;
+        return this._senderAddress ?? null;
     }
 
+    /**
+     * @inheritDoc
+     */
     getInputTxId(): string | null {
-        return this.data?.btcTx?.txid ?? null;
+        return this._data?.btcTx?.txid ?? null;
     }
 
+    /**
+     * @inheritDoc
+     */
     requiresAction(): boolean {
-        return this.state===SpvFromBTCSwapState.BTC_TX_CONFIRMED;
+        return this._state===SpvFromBTCSwapState.BTC_TX_CONFIRMED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isFinished(): boolean {
-        return this.state===SpvFromBTCSwapState.CLAIMED || this.state===SpvFromBTCSwapState.QUOTE_EXPIRED || this.state===SpvFromBTCSwapState.FAILED;
+        return this._state===SpvFromBTCSwapState.CLAIMED || this._state===SpvFromBTCSwapState.QUOTE_EXPIRED || this._state===SpvFromBTCSwapState.FAILED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isClaimable(): boolean {
-        return this.state===SpvFromBTCSwapState.BTC_TX_CONFIRMED;
+        return this._state===SpvFromBTCSwapState.BTC_TX_CONFIRMED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isSuccessful(): boolean {
-        return this.state===SpvFromBTCSwapState.FRONTED || this.state===SpvFromBTCSwapState.CLAIMED;
+        return this._state===SpvFromBTCSwapState.FRONTED || this._state===SpvFromBTCSwapState.CLAIMED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isFailed(): boolean {
-        return this.state===SpvFromBTCSwapState.FAILED || this.state===SpvFromBTCSwapState.DECLINED || this.state===SpvFromBTCSwapState.CLOSED;
+        return this._state===SpvFromBTCSwapState.FAILED || this._state===SpvFromBTCSwapState.DECLINED || this._state===SpvFromBTCSwapState.CLOSED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isQuoteExpired(): boolean {
-        return this.state===SpvFromBTCSwapState.QUOTE_EXPIRED;
+        return this._state===SpvFromBTCSwapState.QUOTE_EXPIRED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isQuoteSoftExpired(): boolean {
-        return this.state===SpvFromBTCSwapState.QUOTE_EXPIRED || this.state===SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED;
+        return this._state===SpvFromBTCSwapState.QUOTE_EXPIRED || this._state===SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED;
+    }
+
+    /**
+     * Returns the data about used spv vault (UTXO-controlled vault) to perform the swap
+     */
+    getSpvVaultData(): {
+        owner: string,
+        vaultId: bigint,
+        utxo: string
+    } {
+        return {
+            owner: this.vaultOwner,
+            vaultId: this.vaultId,
+            utxo: this.vaultUtxo
+        }
     }
 
 
     //////////////////////////////
     //// Amounts & fees
 
+    /**
+     * Returns the input BTC amount in sats without any fees
+     *
+     * @internal
+     */
     protected getInputSwapAmountWithoutFee(): bigint {
         return (this.btcAmountSwap - this.swapFeeBtc) * 100_000n / (100_000n + this.callerFeeShare + this.frontingFeeShare + this.executionFeeShare);
     }
 
+    /**
+     * Returns the input gas BTC amount in sats without any fees
+     *
+     * @internal
+     */
     protected getInputGasAmountWithoutFee(): bigint {
         return (this.btcAmountGas - this.gasSwapFeeBtc) * 100_000n / (100_000n + this.callerFeeShare + this.frontingFeeShare);
     }
 
+    /**
+     * Returns to total input BTC amount in sats without any fees (this is BTC amount for the swap + BTC amount
+     *  for the gas drop).
+     *
+     * @internal
+     */
     protected getInputAmountWithoutFee(): bigint {
         return this.getInputSwapAmountWithoutFee() + this.getInputGasAmountWithoutFee();
     }
 
+    /**
+     * Returns the swap output amount without any fees, this value is therefore always higher than
+     *  the actual received output.
+     *
+     * @internal
+     */
     protected getOutputWithoutFee(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true> {
         return toTokenAmount(
             (this.outputTotalSwap * (100_000n + this.callerFeeShare + this.frontingFeeShare + this.executionFeeShare) / 100_000n) + (this.swapFee ?? 0n),
-            this.wrapper.tokens[this.outputSwapToken], this.wrapper.prices, this.pricingInfo
+            this.wrapper._tokens[this.outputSwapToken], this.wrapper._prices, this.pricingInfo
         );
     }
 
+    /**
+     * Returns the swap fee charged by the intermediary (LP) on this swap
+     *
+     * @internal
+     */
     protected getSwapFee(): Fee<T["ChainId"], BtcToken<false>, SCToken<T["ChainId"]>> {
         if(this.pricingInfo==null) throw new Error("No pricing info known, cannot estimate fee!");
 
-        const outputToken = this.wrapper.tokens[this.outputSwapToken];
+        const outputToken = this.wrapper._tokens[this.outputSwapToken];
         const gasSwapFeeInOutputToken = this.gasSwapFeeBtc
             * (10n ** BigInt(outputToken.decimals))
             * 1_000_000n
@@ -380,38 +567,44 @@ export class SpvFromBTCSwap<T extends ChainType>
         const swapFeePPM = feeWithoutBaseFee * 1000000n / (this.btcAmount - this.swapFeeBtc - this.gasSwapFeeBtc);
 
         const amountInSrcToken = toTokenAmount(
-            this.swapFeeBtc + this.gasSwapFeeBtc, BitcoinTokens.BTC, this.wrapper.prices, this.pricingInfo
+            this.swapFeeBtc + this.gasSwapFeeBtc, BitcoinTokens.BTC, this.wrapper._prices, this.pricingInfo
         );
         return {
             amountInSrcToken,
-            amountInDstToken: toTokenAmount(this.swapFee + gasSwapFeeInOutputToken, outputToken, this.wrapper.prices, this.pricingInfo),
+            amountInDstToken: toTokenAmount(this.swapFee + gasSwapFeeInOutputToken, outputToken, this.wrapper._prices, this.pricingInfo),
             currentUsdValue: amountInSrcToken.currentUsdValue,
             usdValue: amountInSrcToken.usdValue,
             pastUsdValue: amountInSrcToken.pastUsdValue,
             composition: {
-                base: toTokenAmount(this.pricingInfo.satsBaseFee, BitcoinTokens.BTC, this.wrapper.prices, this.pricingInfo),
+                base: toTokenAmount(this.pricingInfo.satsBaseFee, BitcoinTokens.BTC, this.wrapper._prices, this.pricingInfo),
                 percentage: ppmToPercentage(swapFeePPM)
             }
         };
     }
 
+    /**
+     * Returns the fee to be paid to watchtowers on the destination chain to automatically
+     *  process and settle this swap without requiring any user interaction
+     *
+     * @internal
+     */
     protected getWatchtowerFee(): Fee<T["ChainId"], BtcToken<false>, SCToken<T["ChainId"]>> {
         if(this.pricingInfo==null) throw new Error("No pricing info known, cannot estimate fee!");
 
         const totalFeeShare = this.callerFeeShare + this.frontingFeeShare;
-        const outputToken = this.wrapper.tokens[this.outputSwapToken];
+        const outputToken = this.wrapper._tokens[this.outputSwapToken];
         const watchtowerFeeInOutputToken = this.getInputGasAmountWithoutFee() * totalFeeShare
             * (10n ** BigInt(outputToken.decimals))
             * 1_000_000n
             / this.pricingInfo.swapPriceUSatPerToken
             / 100_000n;
         const feeBtc = this.getInputAmountWithoutFee() * (totalFeeShare + this.executionFeeShare) / 100_000n;
-        const amountInSrcToken = toTokenAmount(feeBtc, BitcoinTokens.BTC, this.wrapper.prices, this.pricingInfo);
+        const amountInSrcToken = toTokenAmount(feeBtc, BitcoinTokens.BTC, this.wrapper._prices, this.pricingInfo);
         return {
             amountInSrcToken,
             amountInDstToken: toTokenAmount(
                 (this.outputTotalSwap * (totalFeeShare + this.executionFeeShare) / 100_000n) + watchtowerFeeInOutputToken,
-                outputToken, this.wrapper.prices, this.pricingInfo
+                outputToken, this.wrapper._prices, this.pricingInfo
             ),
             currentUsdValue: amountInSrcToken.currentUsdValue,
             usdValue: amountInSrcToken.usdValue,
@@ -419,19 +612,22 @@ export class SpvFromBTCSwap<T extends ChainType>
         };
     }
 
+    /**
+     * @inheritDoc
+     */
     getFee(): Fee<T["ChainId"], BtcToken<false>, SCToken<T["ChainId"]>> {
         const swapFee = this.getSwapFee();
         const watchtowerFee = this.getWatchtowerFee();
 
         const amountInSrcToken = toTokenAmount(
           swapFee.amountInSrcToken.rawAmount + watchtowerFee.amountInSrcToken.rawAmount,
-            BitcoinTokens.BTC, this.wrapper.prices, this.pricingInfo
+            BitcoinTokens.BTC, this.wrapper._prices, this.pricingInfo
         );
         return {
             amountInSrcToken,
             amountInDstToken: toTokenAmount(
               swapFee.amountInDstToken.rawAmount + watchtowerFee.amountInDstToken.rawAmount,
-                this.wrapper.tokens[this.outputSwapToken], this.wrapper.prices, this.pricingInfo
+                this.wrapper._tokens[this.outputSwapToken], this.wrapper._prices, this.pricingInfo
             ),
             currentUsdValue: amountInSrcToken.currentUsdValue,
             usdValue: amountInSrcToken.usdValue,
@@ -439,6 +635,9 @@ export class SpvFromBTCSwap<T extends ChainType>
         };
     }
 
+    /**
+     * @inheritDoc
+     */
     getFeeBreakdown(): [
         {type: FeeType.SWAP, fee: Fee<T["ChainId"], BtcToken<false>, SCToken<T["ChainId"]>>},
         {type: FeeType.NETWORK_OUTPUT, fee: Fee<T["ChainId"], BtcToken<false>, SCToken<T["ChainId"]>>}
@@ -455,38 +654,63 @@ export class SpvFromBTCSwap<T extends ChainType>
         ];
     }
 
+    /**
+     * @inheritDoc
+     */
     getOutputToken(): SCToken<T["ChainId"]> {
-        return this.wrapper.tokens[this.outputSwapToken];
+        return this.wrapper._tokens[this.outputSwapToken];
     }
 
+    /**
+     * @inheritDoc
+     */
     getOutput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true> {
-        return toTokenAmount(this.outputTotalSwap, this.wrapper.tokens[this.outputSwapToken], this.wrapper.prices, this.pricingInfo);
+        return toTokenAmount(this.outputTotalSwap, this.wrapper._tokens[this.outputSwapToken], this.wrapper._prices, this.pricingInfo);
     }
 
+    /**
+     * @inheritDoc
+     */
     getGasDropOutput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true> {
-        return toTokenAmount(this.outputTotalGas, this.wrapper.tokens[this.outputGasToken], this.wrapper.prices, this.gasPricingInfo);
+        return toTokenAmount(this.outputTotalGas, this.wrapper._tokens[this.outputGasToken], this.wrapper._prices, this.gasPricingInfo);
     }
 
+    /**
+     * @inheritDoc
+     */
     getInputWithoutFee(): TokenAmount<T["ChainId"], BtcToken<false>, true> {
-        return toTokenAmount(this.getInputAmountWithoutFee(), BitcoinTokens.BTC, this.wrapper.prices, this.pricingInfo);
+        return toTokenAmount(this.getInputAmountWithoutFee(), BitcoinTokens.BTC, this.wrapper._prices, this.pricingInfo);
     }
 
+    /**
+     * @inheritDoc
+     */
     getInputToken(): BtcToken<false> {
         return BitcoinTokens.BTC;
     }
 
+    /**
+     * @inheritDoc
+     */
     getInput(): TokenAmount<T["ChainId"], BtcToken<false>, true> {
-        return toTokenAmount(this.btcAmount, BitcoinTokens.BTC, this.wrapper.prices, this.pricingInfo);
+        return toTokenAmount(this.btcAmount, BitcoinTokens.BTC, this.wrapper._prices, this.pricingInfo);
     }
 
 
     //////////////////////////////
     //// Bitcoin tx
 
+    /**
+     * @inheritDoc
+     */
     getRequiredConfirmationsCount(): number {
         return this.vaultRequiredConfirmations;
     }
 
+    /**
+     * Returns raw transaction details that can be used to manually create a swap PSBT. It is better to use
+     *  the {@link getPsbt} or {@link getFundedPsbt} function retrieve an already prepared PSBT.
+     */
     async getTransactionDetails(): Promise<{
         in0txid: string,
         in0vout: number,
@@ -501,11 +725,11 @@ export class SpvFromBTCSwap<T extends ChainType>
     }> {
         const [txId, voutStr] = this.vaultUtxo.split(":");
 
-        const vaultScript = toOutputScript(this.wrapper.options.bitcoinNetwork, this.vaultBtcAddress);
+        const vaultScript = toOutputScript(this.wrapper._options.bitcoinNetwork, this.vaultBtcAddress);
 
-        const out2script = toOutputScript(this.wrapper.options.bitcoinNetwork, this.btcDestinationAddress);
+        const out2script = toOutputScript(this.wrapper._options.bitcoinNetwork, this.btcDestinationAddress);
 
-        const opReturnData = this.wrapper.contract.toOpReturnData(
+        const opReturnData = this.wrapper._contract.toOpReturnData(
             this.recipient,
             [
                 this.outputTotalSwap / this.vaultTokenMultipliers[0],
@@ -539,9 +763,9 @@ export class SpvFromBTCSwap<T extends ChainType>
     }
 
     /**
-     * Returns the raw PSBT (not funded), the wallet should fund the PSBT (add its inputs), set the nSequence field of the
-     *  2nd input (input 1 - indexing from 0) to the value returned in `in1sequence`, sign the PSBT and then pass
-     *  it back to the SDK with `swap.submitPsbt()`
+     * Returns the raw PSBT (not funded), the wallet should fund the PSBT (add its inputs) and importantly **set the nSequence field of the
+     *  2nd input** (input 1 - indexing from 0) to the value returned in `in1sequence`, sign the PSBT and then pass
+     *  it back to the swap with {@link submitPsbt} function.
      */
     async getPsbt(): Promise<{
         psbt: Transaction,
@@ -586,13 +810,9 @@ export class SpvFromBTCSwap<T extends 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()`
+     * Note that when passing the `feeRate` argument, the fee must be at least {@link minimumBtcFeeRate} sats/vB.
      *
-     * @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
+     * @inheritDoc
      */
     async getFundedPsbt(
         _bitcoinWallet: IBitcoinWallet | MinimalBitcoinWalletInterface,
@@ -604,7 +824,7 @@ export class SpvFromBTCSwap<T extends ChainType>
         psbtBase64: string,
         signInputs: number[]
     }> {
-        const bitcoinWallet: IBitcoinWallet = toBitcoinWallet(_bitcoinWallet, this.wrapper.btcRpc, this.wrapper.options.bitcoinNetwork);
+        const bitcoinWallet: IBitcoinWallet = toBitcoinWallet(_bitcoinWallet, this.wrapper._btcRpc, this.wrapper._options.bitcoinNetwork);
         if(feeRate!=null) {
             if(feeRate<this.minimumBtcFeeRate) throw new Error("Bitcoin tx fee needs to be at least "+this.minimumBtcFeeRate+" sats/vB");
         } else {
@@ -614,7 +834,7 @@ export class SpvFromBTCSwap<T extends ChainType>
         if(additionalOutputs!=null) additionalOutputs.forEach(output => {
             psbt.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)
             });
         });
         psbt = await bitcoinWallet.fundPsbt(psbt, feeRate);
@@ -634,9 +854,7 @@ export class SpvFromBTCSwap<T extends ChainType>
     }
 
     /**
-     * Submits a PSBT signed by the wallet back to the SDK
-     *
-     * @param _psbt A psbt - either a Transaction object or a hex or base64 encoded PSBT string
+     * @inheritDoc
      */
     async submitPsbt(_psbt: Transaction | string): Promise<string> {
         const psbt = parsePsbtTransaction(_psbt);
@@ -647,7 +865,7 @@ export class SpvFromBTCSwap<T extends ChainType>
         }
 
         //Ensure valid state
-        if(this.state!==SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED && this.state!==SpvFromBTCSwapState.CREATED) {
+        if(this._state!==SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED && this._state!==SpvFromBTCSwapState.CREATED) {
             throw new Error("Invalid swap state!");
         }
         if(this.url==null) throw new Error("LP URL not known, cannot submit PSBT!");
@@ -658,8 +876,8 @@ export class SpvFromBTCSwap<T extends ChainType>
                 throw new Error("Legacy (non-segwit) inputs are not allowed in the transaction!");
             psbt.finalizeIdx(i);
         }
-        const btcTx = await this.wrapper.btcRpc.parseTransaction(Buffer.from(psbt.toBytes(true)).toString("hex"));
-        const data = await this.wrapper.contract.getWithdrawalData(btcTx);
+        const btcTx = await this.wrapper._btcRpc.parseTransaction(Buffer.from(psbt.toBytes(true)).toString("hex"));
+        const data = await this.wrapper._contract.getWithdrawalData(btcTx);
 
         this.logger.debug("submitPsbt(): parsed withdrawal data: ", data);
 
@@ -673,7 +891,7 @@ export class SpvFromBTCSwap<T extends ChainType>
             data.executionFeeRate!==this.executionFeeShare ||
             data.getSpentVaultUtxo()!==this.vaultUtxo ||
             BigInt(data.getNewVaultBtcAmount())!==this.vaultUtxoValue ||
-            !data.getNewVaultScript().equals(toOutputScript(this.wrapper.options.bitcoinNetwork, this.vaultBtcAddress)) ||
+            !data.getNewVaultScript().equals(toOutputScript(this.wrapper._options.bitcoinNetwork, this.vaultBtcAddress)) ||
             data.getExecutionData()!=null
         ) {
             throw new Error("Invalid withdrawal tx data submitted!");
@@ -684,19 +902,19 @@ export class SpvFromBTCSwap<T extends ChainType>
         if(
             lpOutput.script==null ||
             lpOutput.amount!==this.btcAmount ||
-            !toOutputScript(this.wrapper.options.bitcoinNetwork, this.btcDestinationAddress).equals(Buffer.from(lpOutput.script))
+            !toOutputScript(this.wrapper._options.bitcoinNetwork, this.btcDestinationAddress).equals(Buffer.from(lpOutput.script))
         ) {
             throw new Error("Invalid LP bitcoin output in transaction!");
         }
 
         //Verify vault utxo not spent yet
-        if(await this.wrapper.btcRpc.isSpent(this.vaultUtxo)) {
+        if(await this.wrapper._btcRpc.isSpent(this.vaultUtxo)) {
             throw new Error("Vault UTXO already spent, please create new swap!");
         }
 
         //Verify tx is parsable by the contract
         try {
-            await this.wrapper.contract.checkWithdrawalTx(data);
+            await this.wrapper._contract.checkWithdrawalTx(data);
         } catch (e: any) {
             throw new Error("Transaction not parsable by the contract: "+(e.message ?? e.toString()));
         }
@@ -706,7 +924,7 @@ export class SpvFromBTCSwap<T extends ChainType>
             throw new Error("Quote expired!");
         }
 
-        this.data = data;
+        this._data = data;
         this.initiated = true;
         await this._saveAndEmit(SpvFromBTCSwapState.SIGNED);
 
@@ -725,16 +943,22 @@ export class SpvFromBTCSwap<T extends ChainType>
             throw e;
         }
 
-        return this.data.getTxId();
+        return this._data.getTxId();
     }
 
+    /**
+     * @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);
+        const bitcoinWallet: IBitcoinWallet = toBitcoinWallet(_bitcoinWallet, this.wrapper._btcRpc, this.wrapper._options.bitcoinNetwork);
         const txFee = await bitcoinWallet.getFundedPsbtFee((await this.getPsbt()).psbt, feeRate);
         if(txFee==null) return null;
-        return toTokenAmount(BigInt(txFee), BitcoinTokens.BTC, this.wrapper.prices, this.pricingInfo);
+        return toTokenAmount(BigInt(txFee), BitcoinTokens.BTC, this.wrapper._prices, this.pricingInfo);
     }
 
+    /**
+     * @inheritDoc
+     */
     async sendBitcoinTransaction(wallet: IBitcoinWallet | MinimalBitcoinWalletInterfaceWithSigner, feeRate?: number): Promise<string> {
         const {psbt, psbtBase64, psbtHex, signInputs} = await this.getFundedPsbt(wallet, feeRate);
         let signedPsbt: Transaction | string;
@@ -749,14 +973,15 @@ export class SpvFromBTCSwap<T extends ChainType>
     }
 
     /**
-     * Executes the swap with the provided bitcoin wallet,
+     * Executes the swap with the provided bitcoin wallet
      *
      * @param wallet Bitcoin wallet to use to sign the bitcoin transaction
      * @param callbacks Callbacks to track the progress of the swap
      * @param options Optional options for the swap like feeRate, AbortSignal, and timeouts/intervals
      *
      * @returns {boolean} Whether a swap was settled automatically by swap watchtowers or requires manual claim by the
-     *  user, in case `false` is returned the user should call `swap.claim()` to settle the swap on the destination manually
+     *  user, in case `false` is returned the user should call the {@link claim} function to settle the swap on the
+     *  destination manually
      */
     async execute(
         wallet: IBitcoinWallet | MinimalBitcoinWalletInterfaceWithSigner,
@@ -773,23 +998,23 @@ export class SpvFromBTCSwap<T extends ChainType>
             maxWaitTillAutomaticSettlementSeconds?: number
         }
     ): Promise<boolean> {
-        if(this.state===SpvFromBTCSwapState.CLOSED) throw new Error("Swap encountered a catastrophic failure!");
-        if(this.state===SpvFromBTCSwapState.FAILED) throw new Error("Swap failed!");
-        if(this.state===SpvFromBTCSwapState.DECLINED) throw new Error("Swap execution already declined by the LP!");
-        if(this.state===SpvFromBTCSwapState.QUOTE_EXPIRED || this.state===SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED) throw new Error("Swap quote expired!");
-        if(this.state===SpvFromBTCSwapState.CLAIMED || this.state===SpvFromBTCSwapState.FRONTED) throw new Error("Swap already settled or fronted!");
+        if(this._state===SpvFromBTCSwapState.CLOSED) throw new Error("Swap encountered a catastrophic failure!");
+        if(this._state===SpvFromBTCSwapState.FAILED) throw new Error("Swap failed!");
+        if(this._state===SpvFromBTCSwapState.DECLINED) throw new Error("Swap execution already declined by the LP!");
+        if(this._state===SpvFromBTCSwapState.QUOTE_EXPIRED) throw new Error("Swap quote expired!");
+        if(this._state===SpvFromBTCSwapState.CLAIMED || this._state===SpvFromBTCSwapState.FRONTED) throw new Error("Swap already settled or fronted!");
 
-        if(this.state===SpvFromBTCSwapState.CREATED) {
+        if(this._state===SpvFromBTCSwapState.CREATED) {
             const txId = await this.sendBitcoinTransaction(wallet, options?.feeRate);
             if(callbacks?.onSourceTransactionSent!=null) callbacks.onSourceTransactionSent(txId);
         }
-        if(this.state===SpvFromBTCSwapState.POSTED || this.state===SpvFromBTCSwapState.BROADCASTED) {
+        if(this._state===SpvFromBTCSwapState.POSTED || this._state===SpvFromBTCSwapState.BROADCASTED) {
             const txId = await this.waitForBitcoinTransaction(callbacks?.onSourceTransactionConfirmationStatus, options?.btcTxCheckIntervalSeconds, options?.abortSignal);
             if (callbacks?.onSourceTransactionConfirmed != null) callbacks.onSourceTransactionConfirmed(txId);
         }
         // @ts-ignore
-        if(this.state===SpvFromBTCSwapState.CLAIMED || this.state===SpvFromBTCSwapState.FRONTED) return true;
-        if(this.state===SpvFromBTCSwapState.BTC_TX_CONFIRMED) {
+        if(this._state===SpvFromBTCSwapState.CLAIMED || this._state===SpvFromBTCSwapState.FRONTED) return true;
+        if(this._state===SpvFromBTCSwapState.BTC_TX_CONFIRMED) {
             const success = await this.waitTillClaimedOrFronted(options?.maxWaitTillAutomaticSettlementSeconds ?? 60, options?.abortSignal);
             if(success && callbacks?.onSwapSettled!=null) callbacks.onSwapSettled(this.getOutputTxId()!);
             return success;
@@ -798,14 +1023,24 @@ export class SpvFromBTCSwap<T extends ChainType>
         throw new Error("Unexpected state reached!");
     }
 
+    /**
+     * @inheritDoc
+     *
+     * @param options.bitcoinWallet Optional bitcoin wallet address specification to return a funded PSBT,
+     *  if not provided a raw PSBT is returned instead which necessitates the implementor to manually add
+     *  inputs to the bitcoin transaction and **set the nSequence field of the 2nd input** (input 1 -
+     *  indexing from 0) to the value returned in `in1sequence`
+     */
     async txsExecute(options?: {
         bitcoinWallet?: MinimalBitcoinWalletInterface,
-    }) {
-        if(this.state===SpvFromBTCSwapState.CREATED) {
-            if (!await this.verifyQuoteValid()) throw new Error("Quote already expired or close to expiry!");
+    }): Promise<[
+        SwapExecutionActionBitcoin<"RAW_PSBT" | "FUNDED_PSBT">
+    ]> {
+        if(this._state===SpvFromBTCSwapState.CREATED) {
+            if (!await this._verifyQuoteValid()) throw new Error("Quote already expired or close to expiry!");
             return [
                 {
-                    name: "Payment" as const,
+                    name: "Payment",
                     description: "Send funds to the bitcoin swap address",
                     chain: "BITCOIN",
                     txs: [
@@ -826,6 +1061,7 @@ export class SpvFromBTCSwap<T extends ChainType>
 
     /**
      * 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,
@@ -833,9 +1069,9 @@ export class SpvFromBTCSwap<T extends ChainType>
         targetConfirmations: number,
         inputAddresses?: string[]
     } | null> {
-        if(this.data?.btcTx?.txid==null) return null;
+        if(this._data?.btcTx?.txid==null) return null;
 
-        const result = await this.wrapper.btcRpc.getTransaction(this.data?.btcTx?.txid);
+        const result = await this.wrapper._btcRpc.getTransaction(this._data?.btcTx?.txid);
         if(result==null) return null;
 
         return {
@@ -847,12 +1083,9 @@ export class SpvFromBTCSwap<T extends ChainType>
     }
 
     /**
-     * Waits till the bitcoin transaction confirms and swap becomes claimable
-     *
-     * @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)
+     * @inheritDoc
+     * @throws {Error} if in invalid state (must be {@link SpvFromBTCSwapState.POSTED} or
+     *  {@link SpvFromBTCSwapState.BROADCASTED} states)
      */
     async waitForBitcoinTransaction(
         updateCallback?: (txId?: string, confirmations?: number, targetConfirmations?: number, txEtaMs?: number) => void,
@@ -860,25 +1093,25 @@ export class SpvFromBTCSwap<T extends ChainType>
         abortSignal?: AbortSignal
     ): Promise<string> {
         if(
-            this.state!==SpvFromBTCSwapState.POSTED &&
-            this.state!==SpvFromBTCSwapState.BROADCASTED &&
-            !(this.state===SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED && this.initiated)
+            this._state!==SpvFromBTCSwapState.POSTED &&
+            this._state!==SpvFromBTCSwapState.BROADCASTED &&
+            !(this._state===SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED && this.initiated)
         ) throw new Error("Must be in POSTED or BROADCASTED state!");
-        if(this.data==null) throw new Error("Expected swap to have withdrawal data filled!");
+        if(this._data==null) throw new Error("Expected swap to have withdrawal data filled!");
 
-        const result = await this.wrapper.btcRpc.waitForTransaction(
-            this.data.btcTx.txid,
+        const result = await this.wrapper._btcRpc.waitForTransaction(
+            this._data.btcTx.txid,
             this.vaultRequiredConfirmations,
             (btcTx?: BtcTxWithBlockheight, txEtaMs?: number) => {
                 if(updateCallback!=null) updateCallback(btcTx?.txid, btcTx?.confirmations, this.vaultRequiredConfirmations, txEtaMs);
                 if(btcTx==null) return;
                 let save = false;
-                if(btcTx.inputAddresses!=null && this.senderAddress==null) {
-                    this.senderAddress = btcTx.inputAddresses[1];
+                if(btcTx.inputAddresses!=null && this._senderAddress==null) {
+                    this._senderAddress = btcTx.inputAddresses[1];
                     save = true;
                 }
-                if(this.state===SpvFromBTCSwapState.POSTED || this.state==SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED) {
-                    this.state = SpvFromBTCSwapState.BROADCASTED;
+                if(this._state===SpvFromBTCSwapState.POSTED || this._state==SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED) {
+                    this._state = SpvFromBTCSwapState.BROADCASTED;
                     save = true;
                 }
                 if(save) this._saveAndEmit();
@@ -890,15 +1123,15 @@ export class SpvFromBTCSwap<T extends ChainType>
         if(abortSignal!=null) abortSignal.throwIfAborted();
 
         let save = false;
-        if(result.inputAddresses!=null && this.senderAddress==null) {
-            this.senderAddress = result.inputAddresses[1];
+        if(result.inputAddresses!=null && this._senderAddress==null) {
+            this._senderAddress = result.inputAddresses[1];
             save = true;
         }
         if(
-            (this.state as SpvFromBTCSwapState)!==SpvFromBTCSwapState.FRONTED &&
-            (this.state as SpvFromBTCSwapState)!==SpvFromBTCSwapState.CLAIMED
+            (this._state as SpvFromBTCSwapState)!==SpvFromBTCSwapState.FRONTED &&
+            (this._state as SpvFromBTCSwapState)!==SpvFromBTCSwapState.CLAIMED
         ) {
-            this.state = SpvFromBTCSwapState.BTC_TX_CONFIRMED;
+            this._state = SpvFromBTCSwapState.BTC_TX_CONFIRMED;
             save = true;
         }
         if(save) await this._saveAndEmit();
@@ -911,10 +1144,11 @@ export class SpvFromBTCSwap<T extends 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
+     * Also possibly also syncs the bitcoin light client if necessary
+     *
+     * @inheritDoc
      *
-     * @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 SpvFromBTCSwapState.BTC_TX_CONFIRMED})
      */
     async txsClaim(_signer?: string | T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]> {
         let address: string | undefined = undefined;
@@ -924,77 +1158,84 @@ export class SpvFromBTCSwap<T extends ChainType>
             } else if (isAbstractSigner(_signer)) {
                 address = _signer.getAddress();
             } else {
-                address = (await this.wrapper.chain.wrapSigner(_signer)).getAddress();
+                address = (await this.wrapper._chain.wrapSigner(_signer)).getAddress();
             }
         }
 
         if(!this.isClaimable()) throw new Error("Must be in BTC_TX_CONFIRMED state!");
-        if(this.data==null) throw new Error("Expected swap to have withdrawal data filled!");
+        if(this._data==null) throw new Error("Expected swap to have withdrawal data filled!");
 
-        const vaultData = await this.wrapper.contract.getVaultData(this.vaultOwner, this.vaultId);
+        const vaultData = await this.wrapper._contract.getVaultData(this.vaultOwner, this.vaultId);
         if(vaultData==null) throw new Error(`Vault data for ${this.vaultOwner}:${this.vaultId.toString(10)} not found (already closed???)!`);
 
-        const btcTx = await this.wrapper.btcRpc.getTransaction(this.data.btcTx.txid);
-        if(btcTx==null) throw new Error(`Bitcoin transaction ${this.data.btcTx.txid} not found!`);
+        const btcTx = await this.wrapper._btcRpc.getTransaction(this._data.btcTx.txid);
+        if(btcTx==null) throw new Error(`Bitcoin transaction ${this._data.btcTx.txid} not found!`);
         const txs = [btcTx];
 
         //Trace back from current tx to the vaultData-specified UTXO
         const vaultUtxo = vaultData.getUtxo();
         while(txs[0].ins[0].txid+":"+txs[0].ins[0].vout!==vaultUtxo) {
-            const btcTx = await this.wrapper.btcRpc.getTransaction(txs[0].ins[0].txid);
-            if(btcTx==null) throw new Error(`Prior withdrawal bitcoin transaction ${this.data.btcTx.txid} not found!`);
+            const btcTx = await this.wrapper._btcRpc.getTransaction(txs[0].ins[0].txid);
+            if(btcTx==null) throw new Error(`Prior withdrawal bitcoin transaction ${this._data.btcTx.txid} not found!`);
             txs.unshift(btcTx);
         }
 
         //Parse transactions to withdrawal data
         const withdrawalData: T["SpvVaultWithdrawalData"][] = [];
         for(let tx of txs) {
-            withdrawalData.push(await this.wrapper.contract.getWithdrawalData(tx));
+            withdrawalData.push(await this.wrapper._contract.getWithdrawalData(tx));
         }
 
-        return await this.wrapper.contract.txsClaim(
+        return await this.wrapper._contract.txsClaim(
             address ?? this._getInitiator(), vaultData,
             withdrawalData.map(tx => {return {tx}}),
-            this.wrapper.synchronizer, true
+            this.wrapper._synchronizer, true
         );
     }
 
     /**
-     * Claims and finishes the swap
+     * Also possibly also syncs the bitcoin light client if necessary
      *
-     * @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
+     * @inheritDoc
+     *
+     * @throws {Error} If the swap is in invalid state (must be {@link SpvFromBTCSwapState.BTC_TX_CONFIRMED})
      */
-    async claim(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal): Promise<string> {
-        const signer = isAbstractSigner(_signer) ? _signer : await this.wrapper.chain.wrapSigner(_signer);
+    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);
         let txIds: string[];
         try {
-            txIds = await this.wrapper.chain.sendAndConfirm(
-                signer, await this.txsClaim(signer), true, abortSignal
+            let txCount = 0;
+            const txs = await this.txsClaim(signer);
+            txIds = await this.wrapper._chain.sendAndConfirm(
+                signer, txs, true, abortSignal, undefined, (txId: string) => {
+                    txCount++;
+                    if(onBeforeTxSent!=null && txCount===txs.length) onBeforeTxSent(txId);
+                    return Promise.resolve();
+                }
             );
         } catch (e) {
-            if(this.data==null) throw e;
+            if(this._data==null) throw e;
 
             this.logger.info("claim(): Failed to claim ourselves, checking swap claim state...");
-            if(this.state===SpvFromBTCSwapState.CLAIMED) {
+            if(this._state===SpvFromBTCSwapState.CLAIMED) {
                 this.logger.info("claim(): Transaction state is CLAIMED, swap was successfully claimed by the watchtower");
-                return this.claimTxId!;
+                return this._claimTxId!;
             }
-            const withdrawalState = await this.wrapper.contract.getWithdrawalState(this.data, this.genesisSmartChainBlockHeight);
+            const withdrawalState = await this.wrapper._contract.getWithdrawalState(this._data, this._genesisSmartChainBlockHeight);
             if(withdrawalState!=null && withdrawalState.type===SpvWithdrawalStateType.CLAIMED) {
                 this.logger.info("claim(): Transaction status is CLAIMED, swap was successfully claimed by the watchtower");
-                this.claimTxId = withdrawalState.txId;
+                this._claimTxId = withdrawalState.txId;
                 await this._saveAndEmit(SpvFromBTCSwapState.CLAIMED);
                 return withdrawalState.txId;
             }
             throw e;
         }
 
-        this.claimTxId = txIds[0];
+        this._claimTxId = txIds[0];
         if(
-            this.state===SpvFromBTCSwapState.POSTED || this.state===SpvFromBTCSwapState.BROADCASTED ||
-            this.state===SpvFromBTCSwapState.BTC_TX_CONFIRMED || this.state===SpvFromBTCSwapState.FAILED ||
-            this.state===SpvFromBTCSwapState.FRONTED
+            this._state===SpvFromBTCSwapState.POSTED || this._state===SpvFromBTCSwapState.BROADCASTED ||
+            this._state===SpvFromBTCSwapState.BTC_TX_CONFIRMED || this._state===SpvFromBTCSwapState.FAILED ||
+            this._state===SpvFromBTCSwapState.FRONTED
         ) {
             await this._saveAndEmit(SpvFromBTCSwapState.CLAIMED);
         }
@@ -1006,12 +1247,12 @@ export class SpvFromBTCSwap<T extends ChainType>
      *
      * @param abortSignal
      * @param interval How often to check (in seconds), default to 5s
-     * @protected
+     * @internal
      */
     protected async watchdogWaitTillResult(abortSignal?: AbortSignal, interval: number = 5): Promise<
         SpvWithdrawalClaimedState | SpvWithdrawalFrontedState | SpvWithdrawalClosedState
     > {
-        if(this.data==null) throw new Error("Cannot await the result before the btc transaction is sent!");
+        if(this._data==null) throw new Error("Cannot await the result before the btc transaction is sent!");
 
         let status: SpvWithdrawalState = {type: SpvWithdrawalStateType.NOT_FOUND};
         while(status.type===SpvWithdrawalStateType.NOT_FOUND) {
@@ -1019,8 +1260,8 @@ export class SpvFromBTCSwap<T extends ChainType>
             try {
                 //Be smart about checking withdrawal state
                 if(await this._shouldCheckWithdrawalState()) {
-                    status = await this.wrapper.contract.getWithdrawalState(
-                        this.data, this.genesisSmartChainBlockHeight
+                    status = await this.wrapper._contract.getWithdrawalState(
+                        this._data, this._genesisSmartChainBlockHeight
                     ) ?? {type: SpvWithdrawalStateType.NOT_FOUND};
                 }
             } catch (e) {
@@ -1032,17 +1273,27 @@ export class SpvFromBTCSwap<T extends ChainType>
     }
 
     /**
-     * Waits till the swap is successfully executed
+     * This is an alias for the {@link waitTillClaimedOrFronted} function and will
+     *  also resolve if the swap has been fronted (not necessarily claimed)
+     *
+     * @inheritDoc
+     */
+    waitTillClaimed(maxWaitTimeSeconds?: number, abortSignal?: AbortSignal): Promise<boolean> {
+        return this.waitTillClaimedOrFronted(maxWaitTimeSeconds, abortSignal);
+    }
+
+    /**
+     * Waits till the swap is successfully fronted or settled on the destination chain
+     *
+     * @param maxWaitTimeSeconds Maximum time in seconds to wait for the swap to be settled (by default
+     *  it waits indefinitely)
+     * @param abortSignal Abort signal
      *
-     * @param maxWaitTimeSeconds Maximum time in seconds to wait for the swap to be settled
-     * @param abortSignal
-     * @throws {Error} If swap is in invalid state (must be BTC_TX_CONFIRMED)
-     * @throws {Error} If the LP refunded sooner than we were able to claim
      * @returns {boolean} whether the swap was claimed or fronted automatically or not, if the swap was not claimed
-     *  the user can claim manually through `swap.claim()`
+     *  the user can claim manually through the {@link claim} function
      */
     async waitTillClaimedOrFronted(maxWaitTimeSeconds?: number, abortSignal?: AbortSignal): Promise<boolean> {
-        if(this.state===SpvFromBTCSwapState.CLAIMED || this.state===SpvFromBTCSwapState.FRONTED) return Promise.resolve(true);
+        if(this._state===SpvFromBTCSwapState.CLAIMED || this._state===SpvFromBTCSwapState.FRONTED) return Promise.resolve(true);
 
         const abortController = extendAbortController(abortSignal);
 
@@ -1089,24 +1340,24 @@ export class SpvFromBTCSwap<T extends ChainType>
 
         if(res.type===SpvWithdrawalStateType.FRONTED) {
             if(
-                (this.state as SpvFromBTCSwapState)!==SpvFromBTCSwapState.FRONTED ||
-                (this.state as SpvFromBTCSwapState)!==SpvFromBTCSwapState.CLAIMED
+                (this._state as SpvFromBTCSwapState)!==SpvFromBTCSwapState.FRONTED ||
+                (this._state as SpvFromBTCSwapState)!==SpvFromBTCSwapState.CLAIMED
             ) {
-                this.frontTxId = res.txId;
+                this._frontTxId = res.txId;
                 await this._saveAndEmit(SpvFromBTCSwapState.FRONTED);
             }
         }
         if(res.type===SpvWithdrawalStateType.CLAIMED) {
             if(
-                (this.state as SpvFromBTCSwapState)!==SpvFromBTCSwapState.CLAIMED
+                (this._state as SpvFromBTCSwapState)!==SpvFromBTCSwapState.CLAIMED
             ) {
-                this.claimTxId = res.txId;
+                this._claimTxId = res.txId;
                 await this._saveAndEmit(SpvFromBTCSwapState.FRONTED);
             }
         }
         if(res.type===SpvWithdrawalStateType.CLOSED) {
             if(
-                (this.state as SpvFromBTCSwapState)!==SpvFromBTCSwapState.CLOSED
+                (this._state as SpvFromBTCSwapState)!==SpvFromBTCSwapState.CLOSED
             ) await this._saveAndEmit(SpvFromBTCSwapState.CLOSED);
             throw new Error("Swap failed with catastrophic error!");
         }
@@ -1115,12 +1366,14 @@ export class SpvFromBTCSwap<T extends ChainType>
     }
 
     /**
-     * Waits till the bitcoin transaction confirms and swap is claimed
+     * Waits till the bitcoin transaction confirms and swap settled on the destination chain
      *
-     * @param abortSignal Abort signal
-     * @param checkIntervalSeconds How often to check the bitcoin transaction
      * @param updateCallback Callback called when txId is found, and also called with subsequent confirmations
-     * @throws {Error} if in invalid state (must be CLAIM_COMMITED)
+     * @param checkIntervalSeconds How often to check the bitcoin transaction (5 seconds by default)
+     * @param abortSignal Abort signal
+     *
+     * @throws {Error} if in invalid state (must be {@link SpvFromBTCSwapState.POSTED} or
+     *  {@link SpvFromBTCSwapState.BROADCASTED} states)
      */
     async waitTillExecuted(
         updateCallback?: (txId?: string, confirmations?: number, targetConfirmations?: number, txEtaMs?: number) => void,
@@ -1135,6 +1388,9 @@ export class SpvFromBTCSwap<T extends ChainType>
     //////////////////////////////
     //// Storage
 
+    /**
+     * @inheritDoc
+     */
     serialize(): any {
         return {
             ...super.serialize(),
@@ -1161,13 +1417,13 @@ export class SpvFromBTCSwap<T extends ChainType>
             callerFeeShare: this.callerFeeShare.toString(10),
             frontingFeeShare: this.frontingFeeShare.toString(10),
             executionFeeShare: this.executionFeeShare.toString(10),
-            genesisSmartChainBlockHeight: this.genesisSmartChainBlockHeight,
+            genesisSmartChainBlockHeight: this._genesisSmartChainBlockHeight,
             gasPricingInfo: serializePriceInfoType(this.gasPricingInfo),
 
-            senderAddress: this.senderAddress,
-            claimTxId: this.claimTxId,
-            frontTxId: this.frontTxId,
-            data: this.data?.serialize()
+            senderAddress: this._senderAddress,
+            claimTxId: this._claimTxId,
+            frontTxId: this._frontTxId,
+            data: this._data?.serialize()
         };
     }
 
@@ -1176,41 +1432,45 @@ export class SpvFromBTCSwap<T extends ChainType>
     //// Swap ticks & sync
 
     /**
-     * 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
+     * @internal
      */
     async _setBitcoinTxId(txId: string) {
-        if(this.data==null) return;
-        if(txId!=this.data.btcTx.txid) return;
+        if(this._data==null) return;
+        if(txId!=this._data.btcTx.txid) return;
 
-        if(this.senderAddress!=null) return;
-        const btcTx = await this.wrapper.btcRpc.getTransaction(txId);
+        if(this._senderAddress!=null) return;
+        const btcTx = await this.wrapper._btcRpc.getTransaction(txId);
         if(btcTx==null || btcTx.inputAddresses==null) return;
 
-        this.senderAddress = btcTx.inputAddresses[1];
+        this._senderAddress = btcTx.inputAddresses[1];
     }
 
+    /**
+     * @internal
+     */
     async _syncStateFromBitcoin(save?: boolean) {
-        if(this.data?.btcTx==null) return false;
+        if(this._data?.btcTx==null) return false;
 
         //Check if bitcoin payment was confirmed
         const res = await this.getBitcoinPayment();
         if(res==null) {
             //Check inputs double-spent
-            for(let input of this.data.btcTx.ins) {
-                if(await this.wrapper.btcRpc.isSpent(input.txid+":"+input.vout, true)) {
+            for(let input of this._data.btcTx.ins) {
+                if(await this.wrapper._btcRpc.isSpent(input.txid+":"+input.vout, true)) {
                     if(
-                        this.state===SpvFromBTCSwapState.SIGNED ||
-                        this.state===SpvFromBTCSwapState.POSTED ||
-                        this.state===SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED ||
-                        this.state===SpvFromBTCSwapState.DECLINED
+                        this._state===SpvFromBTCSwapState.SIGNED ||
+                        this._state===SpvFromBTCSwapState.POSTED ||
+                        this._state===SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED ||
+                        this._state===SpvFromBTCSwapState.DECLINED
                     ) {
                         //One of the inputs was double-spent
-                        this.state = SpvFromBTCSwapState.QUOTE_EXPIRED;
+                        this._state = SpvFromBTCSwapState.QUOTE_EXPIRED;
                     } else {
                         //One of the inputs was double-spent
-                        this.state = SpvFromBTCSwapState.FAILED;
+                        this._state = SpvFromBTCSwapState.FAILED;
                     }
                     if(save) await this._saveAndEmit();
                     return true;
@@ -1218,26 +1478,26 @@ export class SpvFromBTCSwap<T extends ChainType>
             }
         } else {
             let needsSave = false;
-            if(res.inputAddresses!=null && this.senderAddress==null) {
-                this.senderAddress = res.inputAddresses[1];
+            if(res.inputAddresses!=null && this._senderAddress==null) {
+                this._senderAddress = res.inputAddresses[1];
                 needsSave = true;
             }
             if(res.confirmations>=this.vaultRequiredConfirmations) {
                 if(
-                    this.state!==SpvFromBTCSwapState.BTC_TX_CONFIRMED &&
-                    this.state!==SpvFromBTCSwapState.FRONTED &&
-                    this.state!==SpvFromBTCSwapState.CLAIMED
+                    this._state!==SpvFromBTCSwapState.BTC_TX_CONFIRMED &&
+                    this._state!==SpvFromBTCSwapState.FRONTED &&
+                    this._state!==SpvFromBTCSwapState.CLAIMED
                 ) {
-                    this.state = SpvFromBTCSwapState.BTC_TX_CONFIRMED;
+                    this._state = SpvFromBTCSwapState.BTC_TX_CONFIRMED;
                     needsSave = true;
                 }
             } else if(
-                this.state===SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED ||
-                this.state===SpvFromBTCSwapState.POSTED ||
-                this.state===SpvFromBTCSwapState.SIGNED ||
-                this.state===SpvFromBTCSwapState.DECLINED
+                this._state===SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED ||
+                this._state===SpvFromBTCSwapState.POSTED ||
+                this._state===SpvFromBTCSwapState.SIGNED ||
+                this._state===SpvFromBTCSwapState.DECLINED
             ) {
-                this.state = SpvFromBTCSwapState.BROADCASTED;
+                this._state = SpvFromBTCSwapState.BROADCASTED;
                 needsSave = true;
             }
             if(needsSave && save) await this._saveAndEmit();
@@ -1249,41 +1509,39 @@ export class SpvFromBTCSwap<T extends ChainType>
     /**
      * Checks the swap's state on-chain and compares it to its internal state, updates/changes it according to on-chain
      *  data
-     *
-     * @private
      */
     private async syncStateFromChain(): Promise<boolean> {
         let changed: boolean = false;
 
         if(
-            this.state===SpvFromBTCSwapState.SIGNED ||
-            this.state===SpvFromBTCSwapState.POSTED ||
-            this.state===SpvFromBTCSwapState.BROADCASTED ||
-            this.state===SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED ||
-            this.state===SpvFromBTCSwapState.DECLINED ||
-            this.state===SpvFromBTCSwapState.BTC_TX_CONFIRMED
+            this._state===SpvFromBTCSwapState.SIGNED ||
+            this._state===SpvFromBTCSwapState.POSTED ||
+            this._state===SpvFromBTCSwapState.BROADCASTED ||
+            this._state===SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED ||
+            this._state===SpvFromBTCSwapState.DECLINED ||
+            this._state===SpvFromBTCSwapState.BTC_TX_CONFIRMED
         ) {
             //Check BTC transaction
             if(await this._syncStateFromBitcoin(false)) changed ||= true;
         }
 
-        if(this.state===SpvFromBTCSwapState.BROADCASTED || this.state===SpvFromBTCSwapState.BTC_TX_CONFIRMED) {
+        if(this._state===SpvFromBTCSwapState.BROADCASTED || this._state===SpvFromBTCSwapState.BTC_TX_CONFIRMED) {
             if(await this._shouldCheckWithdrawalState()) {
-                const status = await this.wrapper.contract.getWithdrawalState(this.data!, this.genesisSmartChainBlockHeight);
-                this.logger.debug("syncStateFromChain(): status of "+this.data!.btcTx.txid, status);
+                const status = await this.wrapper._contract.getWithdrawalState(this._data!, this._genesisSmartChainBlockHeight);
+                this.logger.debug("syncStateFromChain(): status of "+this._data!.btcTx.txid, status);
                 switch(status?.type) {
                     case SpvWithdrawalStateType.FRONTED:
-                        this.frontTxId = status.txId;
-                        this.state = SpvFromBTCSwapState.FRONTED;
+                        this._frontTxId = status.txId;
+                        this._state = SpvFromBTCSwapState.FRONTED;
                         changed ||= true;
                         break;
                     case SpvWithdrawalStateType.CLAIMED:
-                        this.claimTxId = status.txId;
-                        this.state = SpvFromBTCSwapState.CLAIMED;
+                        this._claimTxId = status.txId;
+                        this._state = SpvFromBTCSwapState.CLAIMED;
                         changed ||= true;
                         break;
                     case SpvWithdrawalStateType.CLOSED:
-                        this.state = SpvFromBTCSwapState.CLOSED;
+                        this._state = SpvFromBTCSwapState.CLOSED;
                         changed ||= true;
                         break;
                 }
@@ -1291,15 +1549,15 @@ export class SpvFromBTCSwap<T extends ChainType>
         }
 
         if(
-            this.state===SpvFromBTCSwapState.CREATED ||
-            this.state===SpvFromBTCSwapState.SIGNED ||
-            this.state===SpvFromBTCSwapState.POSTED
+            this._state===SpvFromBTCSwapState.CREATED ||
+            this._state===SpvFromBTCSwapState.SIGNED ||
+            this._state===SpvFromBTCSwapState.POSTED
         ) {
             if(this.expiry<Date.now()) {
-                if(this.state===SpvFromBTCSwapState.CREATED) {
-                    this.state = SpvFromBTCSwapState.QUOTE_EXPIRED;
+                if(this._state===SpvFromBTCSwapState.CREATED) {
+                    this._state = SpvFromBTCSwapState.QUOTE_EXPIRED;
                 } else {
-                    this.state = SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED;
+                    this._state = SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED;
                 }
                 changed ||= true;
             }
@@ -1308,27 +1566,35 @@ export class SpvFromBTCSwap<T extends ChainType>
         return changed;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     async _sync(save?: boolean): Promise<boolean> {
         const changed = await this.syncStateFromChain();
         if(changed && save) await this._saveAndEmit();
         return changed;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     async _tick(save?: boolean): Promise<boolean> {
         if(
-            this.state===SpvFromBTCSwapState.CREATED ||
-            this.state===SpvFromBTCSwapState.SIGNED
+            this._state===SpvFromBTCSwapState.CREATED ||
+            this._state===SpvFromBTCSwapState.SIGNED
         ) {
             if(this.getQuoteExpiry()<Date.now()) {
-                this.state = SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED;
+                this._state = SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED;
                 if(save) await this._saveAndEmit();
                 return true;
             }
         }
 
-        if(this.state===SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED && !this.initiated) {
+        if(this._state===SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED && !this.initiated) {
             if(this.expiry<Date.now()) {
-                this.state = SpvFromBTCSwapState.QUOTE_EXPIRED;
+                this._state = SpvFromBTCSwapState.QUOTE_EXPIRED;
                 if(save) await this._saveAndEmit();
                 return true;
             }
@@ -1336,8 +1602,8 @@ export class SpvFromBTCSwap<T extends ChainType>
 
         if(Math.floor(Date.now()/1000)%120===0) {
             if (
-                this.state === SpvFromBTCSwapState.POSTED ||
-                this.state === SpvFromBTCSwapState.BROADCASTED
+                this._state === SpvFromBTCSwapState.POSTED ||
+                this._state === SpvFromBTCSwapState.BROADCASTED
             ) {
                 try {
                     //Check if bitcoin payment was confirmed
@@ -1351,19 +1617,24 @@ export class SpvFromBTCSwap<T extends ChainType>
         return false;
     }
 
+    /**
+     * Checks whether an on-chain withdrawal state should be fetched for this specific swap
+     *
+     * @internal
+     */
     async _shouldCheckWithdrawalState(frontingAddress?: string | null, vaultDataUtxo?: string | null) {
-        if(frontingAddress===undefined) frontingAddress = await this.wrapper.contract.getFronterAddress(this.vaultOwner, this.vaultId, this.data!);
-        if(vaultDataUtxo===undefined) vaultDataUtxo = await this.wrapper.contract.getVaultLatestUtxo(this.vaultOwner, this.vaultId);
+        if(frontingAddress===undefined) frontingAddress = await this.wrapper._contract.getFronterAddress(this.vaultOwner, this.vaultId, this._data!);
+        if(vaultDataUtxo===undefined) vaultDataUtxo = await this.wrapper._contract.getVaultLatestUtxo(this.vaultOwner, this.vaultId);
 
         if(frontingAddress != null) return true; //In case the swap is fronted there will for sure be a fronted event
         if(vaultDataUtxo == null) return true; //Vault UTXO is null (the vault closed)
 
         const [txId, _] = vaultDataUtxo.split(":");
         //Don't check both txns if their txId is equal
-        if(this.data!.btcTx.txid===txId) return true;
+        if(this._data!.btcTx.txid===txId) return true;
         const [btcTx, latestVaultTx] = await Promise.all([
-            this.wrapper.btcRpc.getTransaction(this.data!.btcTx.txid),
-            this.wrapper.btcRpc.getTransaction(txId)
+            this.wrapper._btcRpc.getTransaction(this._data!.btcTx.txid),
+            this.wrapper._btcRpc.getTransaction(txId)
         ]);
 
         if(latestVaultTx==null || latestVaultTx.blockheight==null) {
@@ -1384,7 +1655,7 @@ export class SpvFromBTCSwap<T extends ChainType>
             }
         } else {
             //Definitely not claimed because the transaction was probably double-spent (or evicted from mempool)
-            this.logger.debug(`_shouldCheckWithdrawalState(): Skipped checking withdrawal state, btc tx probably replaced or evicted: ${this.data!.btcTx.txid} and not fronted`);
+            this.logger.debug(`_shouldCheckWithdrawalState(): Skipped checking withdrawal state, btc tx probably replaced or evicted: ${this._data!.btcTx.txid} and not fronted`);
             return false;
         }