@atomiqlabs/sdk 8.1.8 → 8.3.5

package/src/swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoSwap.ts

@@ -2,7 +2,8 @@ import {decode as bolt11Decode} from "@atomiqlabs/bolt11";
 import {SwapType} from "../../../../enums/SwapType";
 import {
     ChainSwapType,
-    ChainType, isAbstractSigner,
+    ChainType,
+    isAbstractSigner,
     SwapClaimWitnessMessage,
     SwapCommitState,
     SwapCommitStateType,
@@ -17,10 +18,7 @@ import {
     InvoiceStatusResponseCodes
 } from "../../../../intermediaries/apis/IntermediaryAPI";
 import {IntermediaryError} from "../../../../errors/IntermediaryError";
-import {
-    extendAbortController,
-    toBigInt
-} from "../../../../utils/Utils";
+import {extendAbortController, toBigInt} from "../../../../utils/Utils";
 import {Fee} from "../../../../types/fees/Fee";
 import {IAddressSwap} from "../../../IAddressSwap";
 import {FromBTCLNAutoDefinition, FromBTCLNAutoWrapper} from "./FromBTCLNAutoWrapper";
@@ -31,7 +29,7 @@ import {IEscrowSwap, IEscrowSwapInit, isIEscrowSwapInit} from "../../IEscrowSwap
 import {FeeType} from "../../../../enums/FeeType";
 import {ppmToPercentage} from "../../../../types/fees/PercentagePPM";
 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 {timeoutPromise} from "../../../../utils/TimeoutUtils";
 import {isLNURLWithdraw, LNURLWithdraw, LNURLWithdrawParamsWithUrl} from "../../../../types/lnurl/LNURLWithdraw";
@@ -41,10 +39,11 @@ import {
     PriceInfoType,
     serializePriceInfoType
 } from "../../../../types/PriceInfoType";
+import {sha256} from "@noble/hashes/sha2";
 
 /**
  * State enum for FromBTCLNAuto swaps
- * @category Swaps
+ * @category Swaps/Lightning → Smart chain
  */
 export enum FromBTCLNAutoSwapState {
     FAILED = -4,
@@ -58,12 +57,12 @@ export enum FromBTCLNAutoSwapState {
 }
 
 export type FromBTCLNAutoSwapInit<T extends SwapData> = IEscrowSwapInit<T> & {
-    pr: string,
-    secret: string,
+    pr?: string,
+    secret?: string,
     initialSwapData: T,
 
-    btcAmountSwap: bigint,
-    btcAmountGas: bigint,
+    btcAmountSwap?: bigint,
+    btcAmountGas?: bigint,
 
     gasSwapFeeBtc: bigint,
     gasSwapFee: bigint,
@@ -75,10 +74,10 @@ export type FromBTCLNAutoSwapInit<T extends SwapData> = IEscrowSwapInit<T> & {
 };
 
 export function isFromBTCLNAutoSwapInit<T extends SwapData>(obj: any): obj is FromBTCLNAutoSwapInit<T> {
-    return typeof obj.pr==="string" &&
-        typeof obj.secret==="string" &&
-        typeof obj.btcAmountSwap==="bigint" &&
-        typeof obj.btcAmountGas==="bigint" &&
+    return (obj.pr==null || typeof obj.pr==="string") &&
+        (obj.secret==null || typeof obj.secret==="string") &&
+        (obj.btcAmountSwap==null || typeof obj.btcAmountSwap==="bigint") &&
+        (obj.btcAmountGas==null || typeof obj.btcAmountGas==="bigint") &&
         typeof obj.gasSwapFeeBtc==="bigint" &&
         typeof obj.gasSwapFee==="bigint" &&
         (obj.gasPricingInfo==null || isPriceInfoType(obj.gasPricingInfo)) &&
@@ -88,34 +87,65 @@ export function isFromBTCLNAutoSwapInit<T extends SwapData>(obj: any): obj is Fr
         isIEscrowSwapInit(obj);
 }
 
+/**
+ * New escrow based (HTLC) swaps for Bitcoin Lightning -> Smart chain swaps not requiring manual settlement on
+ *  the destination by the user, and instead letting the LP initiate the escrow. Permissionless watchtower network
+ *  handles the claiming of HTLC, with the swap secret broadcasted over Nostr. Also adds a possibility for the user
+ *  to receive a native token on the destination chain as part of the swap (a "gas drop" feature).
+ *
+ * @category Swaps/Lightning → Smart chain
+ */
 export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
     extends IEscrowSwap<T, FromBTCLNAutoDefinition<T>>
     implements IAddressSwap, ISwapWithGasDrop<T>, IClaimableSwap<T, FromBTCLNAutoDefinition<T>, FromBTCLNAutoSwapState> {
 
+    protected readonly TYPE: SwapType.FROM_BTCLN_AUTO = SwapType.FROM_BTCLN_AUTO;
+    /**
+     * @internal
+     */
     protected readonly logger: LoggerType;
+    /**
+     * @internal
+     */
     protected readonly inputToken: BtcToken<true> = BitcoinTokens.BTCLN;
-    protected readonly TYPE = SwapType.FROM_BTCLN_AUTO;
 
-    protected readonly lnurlFailSignal: AbortController = new AbortController();
+    private readonly lnurlFailSignal: AbortController = new AbortController();
+    private readonly usesClaimHashAsId: boolean;
+    private readonly initialSwapData: T["Data"];
 
-    protected readonly pr: string;
-    protected readonly secret: string;
-    protected initialSwapData: T["Data"];
+    private readonly btcAmountSwap?: bigint;
+    private readonly btcAmountGas?: bigint;
 
-    protected readonly btcAmountSwap: bigint;
-    protected readonly btcAmountGas: bigint;
+    private readonly gasSwapFeeBtc: bigint;
+    private readonly gasSwapFee: bigint;
 
-    protected readonly gasSwapFeeBtc: bigint;
-    protected readonly gasSwapFee: bigint;
-    gasPricingInfo?: PriceInfoType;
+    private readonly gasPricingInfo?: PriceInfoType;
 
-    lnurl?: string;
-    lnurlK1?: string;
-    lnurlCallback?: string;
-    prPosted?: boolean = false;
+    /**
+     * In case the swap is recovered from on-chain data, the pr saved here is just a payment hash,
+     *  as it is impossible to retrieve the actual lightning network invoice paid purely from on-chain
+     *  data
+     * @private
+     */
+    private pr?: string;
+    private secret?: string;
 
-    protected getSwapData(): T["Data"] {
-        return this.data ?? this.initialSwapData;
+    private lnurl?: string;
+    private lnurlK1?: string;
+    private lnurlCallback?: string;
+    private prPosted?: boolean = false;
+
+    private broadcastTickCounter: number = 0;
+
+    /**
+     * Sets the LNURL data for the swap
+     *
+     * @internal
+     */
+    _setLNURLData(lnurl: string, lnurlK1: string, lnurlCallback: string) {
+        this.lnurl = lnurl;
+        this.lnurlK1 = lnurlK1;
+        this.lnurlCallback = lnurlCallback;
     }
 
     constructor(wrapper: FromBTCLNAutoWrapper<T>, init: FromBTCLNAutoSwapInit<T["Data"]>);
@@ -127,7 +157,7 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         if(isFromBTCLNAutoSwapInit(initOrObject) && initOrObject.url!=null) initOrObject.url += "/frombtcln_auto";
         super(wrapper, initOrObject);
         if(isFromBTCLNAutoSwapInit(initOrObject)) {
-            this.state = FromBTCLNAutoSwapState.PR_CREATED;
+            this._state = FromBTCLNAutoSwapState.PR_CREATED;
             this.pr = initOrObject.pr;
             this.secret = initOrObject.secret;
             this.initialSwapData = initOrObject.initialSwapData;
@@ -139,12 +169,13 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
             this.lnurl = initOrObject.lnurl;
             this.lnurlK1 = initOrObject.lnurlK1;
             this.lnurlCallback = initOrObject.lnurlCallback;
+            this.usesClaimHashAsId = true;
         } else {
             this.pr = initOrObject.pr;
             this.secret = initOrObject.secret;
 
             if(initOrObject.initialSwapData==null) {
-                this.initialSwapData = this.data!;
+                this.initialSwapData = this._data!;
             } else {
                 this.initialSwapData = SwapData.deserialize<T["Data"]>(initOrObject.initialSwapData);
             }
@@ -155,29 +186,42 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
             this.gasSwapFee = toBigInt(initOrObject.gasSwapFee);
             this.gasPricingInfo = deserializePriceInfoType(initOrObject.gasPricingInfo);
 
-            this.commitTxId = initOrObject.commitTxId;
-            this.claimTxId = initOrObject.claimTxId;
+            this._commitTxId = initOrObject.commitTxId;
+            this._claimTxId = initOrObject.claimTxId;
 
             this.lnurl = initOrObject.lnurl;
             this.lnurlK1 = initOrObject.lnurlK1;
             this.lnurlCallback = initOrObject.lnurlCallback;
             this.prPosted = initOrObject.prPosted;
+            this.usesClaimHashAsId = initOrObject.usesClaimHashAsId ?? false;
         }
         this.tryRecomputeSwapPrice();
         this.logger = getLogger("FromBTCLNAuto("+this.getIdentifierHashString()+"): ");
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    protected getSwapData(): T["Data"] {
+        return this._data ?? this.initialSwapData;
+    }
+
+    /**
+     * @inheritDoc
+     * @internal
+     */
     protected upgradeVersion() { /*NOOP*/ }
 
     /**
-     * In case swapFee in BTC is not supplied it recalculates it based on swap price
-     * @protected
+     * @inheritDoc
+     * @internal
      */
     protected tryRecomputeSwapPrice() {
-        if(this.pricingInfo==null) return;
+        if(this.pricingInfo==null || this.btcAmountSwap==null) return;
         if(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,
@@ -193,10 +237,13 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
     //////////////////////////////
     //// Pricing
 
+    /**
+     * @inheritDoc
+     */
     async refreshPriceData(): Promise<void> {
-        if(this.pricingInfo==null) return;
+        if(this.pricingInfo==null || this.btcAmountSwap==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,
@@ -211,60 +258,107 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
     //////////////////////////////
     //// Getters & utils
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     _getEscrowHash(): string | null {
         //Use claim hash in case the data is not yet known
-        return this.data == null ? this.initialSwapData?.getClaimHash() : this.data?.getEscrowHash();
+        return this._data == null ? this.initialSwapData?.getClaimHash() : this._data?.getEscrowHash();
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     _getInitiator(): string {
         return this.getSwapData().getClaimer();
     }
 
+    /**
+     * @inheritDoc
+     */
     getId(): string {
         return this.getIdentifierHashString();
     }
 
+    /**
+     * @inheritDoc
+     */
     getOutputAddress(): string | null {
         return this._getInitiator();
     }
 
+    /**
+     * @inheritDoc
+     */
     getOutputTxId(): string | null {
-        return this.claimTxId ?? null;
+        return this._claimTxId ?? null;
     }
 
+    /**
+     * @inheritDoc
+     */
     requiresAction(): boolean {
-        return this.state===FromBTCLNAutoSwapState.CLAIM_COMMITED;
+        return this._state===FromBTCLNAutoSwapState.CLAIM_COMMITED;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     protected getIdentifierHashString(): string {
-        const paymentHashBuffer = this.getPaymentHash();
-        if(this.randomNonce==null) return paymentHashBuffer?.toString("hex");
-        return paymentHashBuffer.toString("hex") + this.randomNonce;
+        const id: string = this.usesClaimHashAsId
+            ? this.getClaimHash()
+            : this.getPaymentHash()!.toString("hex");
+        if(this._randomNonce==null) return id;
+        return id + this._randomNonce;
     }
 
-    protected getPaymentHash(): Buffer {
-        const decodedPR = bolt11Decode(this.pr);
-        if(decodedPR.tagsObject.payment_hash==null) throw new Error("Swap invoice doesn't contain payment hash field!");
-        return Buffer.from(decodedPR.tagsObject.payment_hash, "hex");
+    /**
+     * Returns the payment hash of the swap and lightning network invoice, or `null` if not known (i.e. if
+     *  the swap was recovered from on-chain data, the payment hash might not be known)
+     *
+     * @internal
+     */
+    protected getPaymentHash(): Buffer | null {
+        if(this.pr==null) return null;
+        if(this.pr.toLowerCase().startsWith("ln")) {
+            const parsed = bolt11Decode(this.pr);
+            if(parsed.tagsObject.payment_hash==null) throw new Error("Swap invoice has no payment hash field!");
+            return Buffer.from(parsed.tagsObject.payment_hash, "hex");
+        }
+        return Buffer.from(this.pr, "hex");
     }
 
+    /**
+     * @inheritDoc
+     */
     getInputAddress(): string | null {
-        return this.lnurl ?? this.pr;
+        return this.lnurl ?? this.pr ?? null;
     }
 
-    getInputTxId(): string {
-        return this.getPaymentHash().toString("hex");
+    /**
+     * @inheritDoc
+     */
+    getInputTxId(): string | null {
+        const paymentHash = this.getPaymentHash();
+        if(paymentHash==null) return null;
+        return paymentHash.toString("hex");
     }
 
     /**
      * Returns the lightning network BOLT11 invoice that needs to be paid as an input to the swap
      */
     getAddress(): string {
-        return this.pr;
+        return this.pr ?? "";
     }
 
+    /**
+     * @inheritDoc
+     */
     getHyperlink(): string {
-        return "lightning:"+this.pr.toUpperCase();
+        return this.pr==null ? "" : "lightning:"+this.pr.toUpperCase();
     }
 
     /**
@@ -272,11 +366,12 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
      *  if the LP doesn't make it expired sooner
      */
     getDefinitiveExpiryTime(): number {
+        if(this.pr==null || !this.pr.toLowerCase().startsWith("ln")) return 0;
         const decoded = bolt11Decode(this.pr);
         if(decoded.tagsObject.min_final_cltv_expiry==null) throw new Error("Swap invoice doesn't contain final ctlv delta field!");
         if(decoded.timeExpireDate==null) throw new Error("Swap invoice doesn't contain expiry date field!");
         const finalCltvExpiryDelta = decoded.tagsObject.min_final_cltv_expiry ?? 144;
-        const finalCltvExpiryDelay = finalCltvExpiryDelta * this.wrapper.options.bitcoinBlocktime * this.wrapper.options.safetyFactor;
+        const finalCltvExpiryDelay = finalCltvExpiryDelta * this.wrapper._options.bitcoinBlocktime * this.wrapper._options.safetyFactor;
         return (decoded.timeExpireDate + finalCltvExpiryDelay)*1000;
     }
 
@@ -284,38 +379,62 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
      * Returns timeout time (in UNIX milliseconds) when the swap htlc will expire
      */
     getHtlcTimeoutTime(): number | null {
-        return this.data==null ? null : Number(this.wrapper.getHtlcTimeout(this.data))*1000;
+        return this._data==null ? null : Number(this.wrapper._getHtlcTimeout(this._data))*1000;
     }
 
+    /**
+     * @inheritDoc
+     */
     isFinished(): boolean {
-        return this.state===FromBTCLNAutoSwapState.CLAIM_CLAIMED || this.state===FromBTCLNAutoSwapState.QUOTE_EXPIRED || this.state===FromBTCLNAutoSwapState.FAILED;
+        return this._state===FromBTCLNAutoSwapState.CLAIM_CLAIMED || this._state===FromBTCLNAutoSwapState.QUOTE_EXPIRED || this._state===FromBTCLNAutoSwapState.FAILED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isClaimable(): boolean {
-        return this.state===FromBTCLNAutoSwapState.CLAIM_COMMITED;
+        return this._state===FromBTCLNAutoSwapState.CLAIM_COMMITED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isSuccessful(): boolean {
-        return this.state===FromBTCLNAutoSwapState.CLAIM_CLAIMED;
+        return this._state===FromBTCLNAutoSwapState.CLAIM_CLAIMED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isFailed(): boolean {
-        return this.state===FromBTCLNAutoSwapState.FAILED || this.state===FromBTCLNAutoSwapState.EXPIRED;
+        return this._state===FromBTCLNAutoSwapState.FAILED || this._state===FromBTCLNAutoSwapState.EXPIRED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isQuoteExpired(): boolean {
-        return this.state===FromBTCLNAutoSwapState.QUOTE_EXPIRED;
+        return this._state===FromBTCLNAutoSwapState.QUOTE_EXPIRED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isQuoteSoftExpired(): boolean {
-        return this.state===FromBTCLNAutoSwapState.QUOTE_EXPIRED;
+        return this._state===FromBTCLNAutoSwapState.QUOTE_EXPIRED;
     }
 
+    /**
+     * @inheritDoc
+     */
     _verifyQuoteDefinitelyExpired(): Promise<boolean> {
         return Promise.resolve(this.getDefinitiveExpiryTime()<Date.now());
     }
 
-    verifyQuoteValid(): Promise<boolean> {
+    /**
+     * @inheritDoc
+     */
+    _verifyQuoteValid(): Promise<boolean> {
         return Promise.resolve(this.getQuoteExpiry()>Date.now());
     }
 
@@ -323,119 +442,194 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
     //////////////////////////////
     //// Amounts & fees
 
-    protected getLightningInvoiceSats(): bigint {
+    /**
+     * Returns the satoshi amount of the lightning network invoice, or `null` if the lightning network
+     *  invoice is not known (i.e. when the swap was recovered from on-chain data, the paid invoice
+     *  cannot be recovered because it is purely off-chain)
+     *
+     * @internal
+     */
+    protected getLightningInvoiceSats(): bigint | null {
+        if(this.pr==null || !this.pr.toLowerCase().startsWith("ln")) return null;
+
         const parsed = bolt11Decode(this.pr);
         if(parsed.millisatoshis==null) throw new Error("Swap invoice doesn't contain msat amount field!");
         return (BigInt(parsed.millisatoshis) + 999n) / 1000n;
     }
 
-    protected getWatchtowerFeeAmountBtc() {
+    /**
+     * Returns the watchtower fee paid in BTC satoshis, or null if known (i.e. if the swap was recovered from
+     *  on-chain data)
+     *
+     * @protected
+     */
+    protected getWatchtowerFeeAmountBtc(): bigint | null {
+        if(this.btcAmountGas==null) return null;
         return (this.btcAmountGas - this.gasSwapFeeBtc) * this.getSwapData().getClaimerBounty() / this.getSwapData().getTotalDeposit();
     }
 
-    protected getInputSwapAmountWithoutFee(): bigint {
+    /**
+     * Returns the input amount for the actual swap (excluding the input amount used to cover the "gas drop"
+     *  part of the swap), excluding fees
+     *
+     * @internal
+     */
+    protected getInputSwapAmountWithoutFee(): bigint | null {
+        if(this.btcAmountSwap==null) return null;
         return this.btcAmountSwap - this.swapFeeBtc;
     }
 
-    protected getInputGasAmountWithoutFee(): bigint {
+    /**
+     * Returns the input amount purely for the "gas drop" part of the swap (this much BTC in sats will be
+     *  swapped into the native gas token on the destination chain), excluding fees
+     *
+     * @internal
+     */
+    protected getInputGasAmountWithoutFee(): bigint | null {
+        if(this.btcAmountGas==null) return null;
         return this.btcAmountGas - this.gasSwapFeeBtc;
     }
 
-    protected getInputAmountWithoutFee(): bigint {
-        return this.getInputSwapAmountWithoutFee() + this.getInputGasAmountWithoutFee() - this.getWatchtowerFeeAmountBtc();
+    /**
+     * Get total btc amount in sats on the input, excluding the swap fee and watchtower fee
+     *
+     * @internal
+     */
+    protected getInputAmountWithoutFee(): bigint | null {
+        if(this.btcAmountGas==null || this.btcAmountSwap) return null;
+        return this.getInputSwapAmountWithoutFee()! + this.getInputGasAmountWithoutFee()! - this.getWatchtowerFeeAmountBtc()!;
     }
 
+    /**
+     * Returns the "would be" output amount if the swap charged no swap fee
+     *
+     * @internal
+     */
     protected getOutputAmountWithoutFee(): bigint {
         return this.getSwapData().getAmount() + this.swapFee;
     }
 
+    /**
+     * @inheritDoc
+     */
     getInputToken(): BtcToken<true> {
         return BitcoinTokens.BTCLN;
     }
 
+    /**
+     * @inheritDoc
+     */
     getInput(): TokenAmount<T["ChainId"], BtcToken<true>> {
-        return toTokenAmount(this.getLightningInvoiceSats(), this.inputToken, this.wrapper.prices, this.pricingInfo);
+        return toTokenAmount(this.getLightningInvoiceSats(), this.inputToken, this.wrapper._prices, this.pricingInfo);
     }
 
+    /**
+     * @inheritDoc
+     */
     getInputWithoutFee(): TokenAmount<T["ChainId"], BtcToken<true>> {
-        return toTokenAmount(this.getInputAmountWithoutFee(), this.inputToken, this.wrapper.prices, this.pricingInfo);
+        return toTokenAmount(this.getInputAmountWithoutFee(), this.inputToken, this.wrapper._prices, this.pricingInfo);
     }
 
+    /**
+     * @inheritDoc
+     */
     getOutputToken(): SCToken<T["ChainId"]> {
-        return this.wrapper.tokens[this.getSwapData().getToken()];
+        return this.wrapper._tokens[this.getSwapData().getToken()];
     }
 
+    /**
+     * @inheritDoc
+     */
     getOutput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true> {
-        return toTokenAmount(this.getSwapData().getAmount(), this.wrapper.tokens[this.getSwapData().getToken()], this.wrapper.prices, this.pricingInfo);
+        return toTokenAmount(this.getSwapData().getAmount(), this.wrapper._tokens[this.getSwapData().getToken()], this.wrapper._prices, this.pricingInfo);
     }
 
+    /**
+     * @inheritDoc
+     */
     getGasDropOutput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true> {
         return toTokenAmount(
             this.getSwapData().getSecurityDeposit() - this.getSwapData().getClaimerBounty(),
-            this.wrapper.tokens[this.getSwapData().getDepositToken()], this.wrapper.prices, this.gasPricingInfo
+            this.wrapper._tokens[this.getSwapData().getDepositToken()], this.wrapper._prices, this.gasPricingInfo
         );
     }
 
+    /**
+     * Returns the swap fee charged by the intermediary (LP) on this swap
+     *
+     * @internal
+     */
     protected getSwapFee(): Fee<T["ChainId"], BtcToken<true>, SCToken<T["ChainId"]>> {
         if(this.pricingInfo==null) throw new Error("No pricing info known, cannot estimate fee!");
 
-        const outputToken = this.wrapper.tokens[this.getSwapData().getToken()];
+        const outputToken = this.wrapper._tokens[this.getSwapData().getToken()];
         const gasSwapFeeInOutputToken = this.gasSwapFeeBtc
             * (10n ** BigInt(outputToken.decimals))
             * 1_000_000n
             / this.pricingInfo.swapPriceUSatPerToken;
 
         const feeWithoutBaseFee = this.gasSwapFeeBtc + this.swapFeeBtc - this.pricingInfo.satsBaseFee;
-        const swapFeePPM = feeWithoutBaseFee * 1000000n / (this.getLightningInvoiceSats() - this.swapFeeBtc - this.gasSwapFeeBtc);
+        const inputSats = this.getLightningInvoiceSats();
+        const swapFeePPM = inputSats!=null
+            ? feeWithoutBaseFee * 1000000n / (inputSats - this.swapFeeBtc - this.gasSwapFeeBtc)
+            : 0n;
 
-        const amountInSrcToken = toTokenAmount(this.swapFeeBtc + this.gasSwapFeeBtc, BitcoinTokens.BTCLN, this.wrapper.prices, this.pricingInfo);
+        const amountInSrcToken = toTokenAmount(this.swapFeeBtc + this.gasSwapFeeBtc, BitcoinTokens.BTCLN, 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,
             pastUsdValue: amountInSrcToken.pastUsdValue,
             usdValue: amountInSrcToken.usdValue,
             composition: {
-                base: toTokenAmount(this.pricingInfo.satsBaseFee, BitcoinTokens.BTCLN, this.wrapper.prices, this.pricingInfo),
+                base: toTokenAmount(this.pricingInfo.satsBaseFee, BitcoinTokens.BTCLN, 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<true>, SCToken<T["ChainId"]>> {
         if(this.pricingInfo==null) throw new Error("No pricing info known, cannot estimate fee!");
 
         const btcWatchtowerFee = this.getWatchtowerFeeAmountBtc();
-        const outputToken = this.wrapper.tokens[this.getSwapData().getToken()];
-        const watchtowerFeeInOutputToken = btcWatchtowerFee
+        const outputToken = this.wrapper._tokens[this.getSwapData().getToken()];
+        const watchtowerFeeInOutputToken = btcWatchtowerFee==null ? 0n : btcWatchtowerFee
             * (10n ** BigInt(outputToken.decimals))
             * 1_000_000n
             / this.pricingInfo.swapPriceUSatPerToken;
 
-        const amountInSrcToken = toTokenAmount(btcWatchtowerFee, BitcoinTokens.BTCLN, this.wrapper.prices, this.pricingInfo);
+        const amountInSrcToken = toTokenAmount(btcWatchtowerFee, BitcoinTokens.BTCLN, this.wrapper._prices, this.pricingInfo);
         return {
             amountInSrcToken,
-            amountInDstToken: toTokenAmount(watchtowerFeeInOutputToken, outputToken, this.wrapper.prices, this.pricingInfo),
+            amountInDstToken: toTokenAmount(watchtowerFeeInOutputToken, outputToken, this.wrapper._prices, this.pricingInfo),
             currentUsdValue: amountInSrcToken.currentUsdValue,
             usdValue: amountInSrcToken.usdValue,
             pastUsdValue: amountInSrcToken.pastUsdValue
         };
     }
 
-
+    /**
+     * @inheritDoc
+     */
     getFee(): Fee<T["ChainId"], BtcToken<true>, SCToken<T["ChainId"]>> {
         const swapFee = this.getSwapFee();
         const watchtowerFee = this.getWatchtowerFee();
 
         const amountInSrcToken = toTokenAmount(
           swapFee.amountInSrcToken.rawAmount + watchtowerFee.amountInSrcToken.rawAmount,
-            BitcoinTokens.BTCLN, this.wrapper.prices, this.pricingInfo
+            BitcoinTokens.BTCLN, this.wrapper._prices, this.pricingInfo
         );
         return {
             amountInSrcToken,
             amountInDstToken: toTokenAmount(
               swapFee.amountInDstToken.rawAmount + watchtowerFee.amountInDstToken.rawAmount,
-                this.wrapper.tokens[this.getSwapData().getToken()], this.wrapper.prices, this.pricingInfo
+                this.wrapper._tokens[this.getSwapData().getToken()], this.wrapper._prices, this.pricingInfo
             ),
             currentUsdValue: amountInSrcToken.currentUsdValue,
             usdValue: amountInSrcToken.usdValue,
@@ -443,6 +637,9 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         };
     }
 
+    /**
+     * @inheritDoc
+     */
     getFeeBreakdown(): [
         {type: FeeType.SWAP, fee: Fee<T["ChainId"], BtcToken<true>, SCToken<T["ChainId"]>>},
         {type: FeeType.NETWORK_OUTPUT, fee: Fee<T["ChainId"], BtcToken<true>, SCToken<T["ChainId"]>>}
@@ -459,6 +656,12 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         ];
     }
 
+    private isValidSecretPreimage(secret: string) {
+        const paymentHash = Buffer.from(sha256(Buffer.from(secret, "hex")));
+        const claimHash = this.wrapper._contract.getHashForHtlc(paymentHash).toString("hex");
+        return this.getSwapData().getClaimHash()===claimHash;
+    }
+
 
     //////////////////////////////
     //// Execution
@@ -470,6 +673,8 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
      *  link, wallet is not required and the LN invoice can be paid externally as well (just pass null or undefined here)
      * @param callbacks Callbacks to track the progress of the swap
      * @param options Optional options for the swap like feeRate, AbortSignal, and timeouts/intervals
+     * @param secret A swap secret to broadcast to watchtowers, generally only needed if the swap
+     *  was recovered from on-chain data, or the pre-image was generated outside the SDK
      *
      * @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
@@ -484,17 +689,21 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
             abortSignal?: AbortSignal,
             lightningTxCheckIntervalSeconds?: number,
             maxWaitTillAutomaticSettlementSeconds?: number
-        }
+        },
+        secret?: string
     ): Promise<boolean> {
-        if(this.state===FromBTCLNAutoSwapState.FAILED) throw new Error("Swap failed!");
-        if(this.state===FromBTCLNAutoSwapState.EXPIRED) throw new Error("Swap HTLC expired!");
-        if(this.state===FromBTCLNAutoSwapState.QUOTE_EXPIRED || this.state===FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED) throw new Error("Swap quote expired!");
-        if(this.state===FromBTCLNAutoSwapState.CLAIM_CLAIMED) throw new Error("Swap already settled!");
+        if(this._state===FromBTCLNAutoSwapState.FAILED) throw new Error("Swap failed!");
+        if(this._state===FromBTCLNAutoSwapState.EXPIRED) throw new Error("Swap HTLC expired!");
+        if(this._state===FromBTCLNAutoSwapState.QUOTE_EXPIRED || this._state===FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED) throw new Error("Swap quote expired!");
+        if(this._state===FromBTCLNAutoSwapState.CLAIM_CLAIMED) throw new Error("Swap already settled!");
 
         let abortSignal = options?.abortSignal;
 
-        if(this.state===FromBTCLNAutoSwapState.PR_CREATED) {
+        if(this._state===FromBTCLNAutoSwapState.PR_CREATED) {
             if(walletOrLnurlWithdraw!=null && this.lnurl==null) {
+                if(this.pr==null || !this.pr.toLowerCase().startsWith("ln"))
+                    throw new Error("Input lightning network invoice not available, the swap was probably recovered!");
+
                 if(typeof(walletOrLnurlWithdraw)==="string" || isLNURLWithdraw(walletOrLnurlWithdraw)) {
                     await this.settleWithLNURLWithdraw(walletOrLnurlWithdraw);
                 } else {
@@ -508,15 +717,17 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
             }
         }
 
-        if(this.state===FromBTCLNAutoSwapState.PR_CREATED || this.state===FromBTCLNAutoSwapState.PR_PAID) {
+        if(this._state===FromBTCLNAutoSwapState.PR_CREATED || this._state===FromBTCLNAutoSwapState.PR_PAID) {
             const paymentSuccess = await this.waitForPayment(callbacks?.onSourceTransactionReceived, options?.lightningTxCheckIntervalSeconds, abortSignal);
             if (!paymentSuccess) throw new Error("Failed to receive lightning network payment");
         }
 
-        if((this.state as FromBTCLNAutoSwapState)===FromBTCLNAutoSwapState.CLAIM_CLAIMED) return true;
+        if((this._state as FromBTCLNAutoSwapState)===FromBTCLNAutoSwapState.CLAIM_CLAIMED) return true;
 
-        if(this.state===FromBTCLNAutoSwapState.CLAIM_COMMITED) {
-            const success = await this.waitTillClaimed(options?.maxWaitTillAutomaticSettlementSeconds ?? 60, options?.abortSignal);
+        if(this._state===FromBTCLNAutoSwapState.CLAIM_COMMITED) {
+            if(this.secret==null && secret==null)
+                throw new Error("Tried to wait till settlement, but no secret pre-image is known, please pass the secret pre-image as an argument!");
+            const success = await this.waitTillClaimed(options?.maxWaitTillAutomaticSettlementSeconds ?? 60, options?.abortSignal, secret);
             if (success && callbacks?.onSwapSettled != null) callbacks.onSwapSettled(this.getOutputTxId()!);
             return success;
         }
@@ -524,17 +735,21 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         throw new Error("Invalid state reached!");
     }
 
+    /**
+     * @inheritDoc
+     */
     async txsExecute() {
-        if (this.state === FromBTCLNAutoSwapState.PR_CREATED) {
-            if (!await this.verifyQuoteValid()) throw new Error("Quote already expired or close to expiry!");
+        if (this._state === FromBTCLNAutoSwapState.PR_CREATED) {
+            if (!await this._verifyQuoteValid()) throw new Error("Quote already expired or close to expiry!");
             return [
                 {
                     name: "Payment" as const,
                     description: "Initiates the swap by paying up the lightning network invoice",
-                    chain: "LIGHTNING",
+                    chain: "LIGHTNING" as const,
                     txs: [
                         {
-                            address: this.pr,
+                            type: "BOLT11_PAYMENT_REQUEST" as const,
+                            address: this.getAddress(),
                             hyperlink: this.getHyperlink()
                         }
                     ]
@@ -550,30 +765,38 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
     //// Payment
 
     /**
-     * Checks whether the LP received the LN payment and we can continue by committing & claiming the HTLC on-chain
+     * Checks whether the LP received the LN payment
      *
      * @param save If the new swap state should be saved
+     *
+     * @internal
      */
     async _checkIntermediaryPaymentReceived(save: boolean = true): Promise<boolean | null> {
         if(
-            this.state===FromBTCLNAutoSwapState.PR_PAID ||
-            this.state===FromBTCLNAutoSwapState.CLAIM_COMMITED ||
-            this.state===FromBTCLNAutoSwapState.CLAIM_CLAIMED ||
-            this.state===FromBTCLNAutoSwapState.FAILED
+            this._state===FromBTCLNAutoSwapState.PR_PAID ||
+            this._state===FromBTCLNAutoSwapState.CLAIM_COMMITED ||
+            this._state===FromBTCLNAutoSwapState.CLAIM_CLAIMED ||
+            this._state===FromBTCLNAutoSwapState.FAILED ||
+            this._state===FromBTCLNAutoSwapState.EXPIRED
         ) return true;
-        if(this.state===FromBTCLNAutoSwapState.QUOTE_EXPIRED) return false;
+        if(this._state===FromBTCLNAutoSwapState.QUOTE_EXPIRED) return false;
         if(this.url==null) return false;
-        const resp = await IntermediaryAPI.getInvoiceStatus(this.url, this.getPaymentHash().toString("hex"));
+
+        const paymentHash = this.getPaymentHash();
+        if(paymentHash==null)
+            throw new Error("Failed to check LP payment received, payment hash not known (probably recovered swap?)");
+
+        const resp = await IntermediaryAPI.getInvoiceStatus(this.url, paymentHash.toString("hex"));
         switch(resp.code) {
             case InvoiceStatusResponseCodes.PAID:
-                const data = new this.wrapper.swapDataDeserializer(resp.data.data);
-                if(this.state===FromBTCLNAutoSwapState.PR_CREATED || this.state===FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED) try {
+                const data = new this.wrapper._swapDataDeserializer(resp.data.data);
+                if(this._state===FromBTCLNAutoSwapState.PR_CREATED || this._state===FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED) try {
                     await this._saveRealSwapData(data, save);
                     return true;
                 } catch (e) {}
                 return null;
             case InvoiceStatusResponseCodes.EXPIRED:
-                this.state = FromBTCLNAutoSwapState.QUOTE_EXPIRED;
+                this._state = FromBTCLNAutoSwapState.QUOTE_EXPIRED;
                 this.initiated = true;
                 if(save) await this._saveAndEmit();
                 return false;
@@ -582,11 +805,20 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         }
     }
 
+    /**
+     * Checks and overrides the swap data for this swap. This is used to set the swap data from
+     *  on-chain events.
+     *
+     * @param data Swap data of the escrow swap
+     * @param save If the new data should be saved
+     *
+     * @internal
+     */
     async _saveRealSwapData(data: T["Data"], save?: boolean): Promise<boolean> {
         await this.checkIntermediaryReturnedData(data);
-        if(this.state===FromBTCLNAutoSwapState.PR_CREATED || this.state===FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED) {
-            this.state = FromBTCLNAutoSwapState.PR_PAID;
-            this.data = data;
+        if(this._state===FromBTCLNAutoSwapState.PR_CREATED || this._state===FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED) {
+            this._state = FromBTCLNAutoSwapState.PR_PAID;
+            this._data = data;
             this.initiated = true;
             if(save) await this._saveAndEmit();
             return true;
@@ -598,11 +830,13 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
      * Checks the data returned by the intermediary in the payment auth request
      *
      * @param data Parsed swap data as returned by the intermediary
-     * @protected
+     *
      * @throws {IntermediaryError} If the returned are not valid
      * @throws {Error} If the swap is already committed on-chain
+     *
+     * @private
      */
-    protected async checkIntermediaryReturnedData(data: T["Data"]): Promise<void> {
+    private async checkIntermediaryReturnedData(data: T["Data"]): Promise<void> {
         if (!data.isPayOut()) throw new IntermediaryError("Invalid not pay out");
         if (data.getType() !== ChainSwapType.HTLC) throw new IntermediaryError("Invalid swap type");
         if (!data.isOfferer(this.getSwapData().getOfferer())) throw new IntermediaryError("Invalid offerer used");
@@ -615,25 +849,31 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         if (!data.isDepositToken(this.getSwapData().getDepositToken())) throw new IntermediaryError("Invalid deposit token used!");
         if (data.hasSuccessAction()) throw new IntermediaryError("Invalid has success action");
 
-        if (await this.wrapper.contract.isExpired(this._getInitiator(), data)) throw new IntermediaryError("Not enough time to claim!");
-        if (this.wrapper.getHtlcTimeout(data) <= (Date.now()/1000)) throw new IntermediaryError("HTLC expires too soon!");
+        if (await this.wrapper._contract.isExpired(this._getInitiator(), data)) throw new IntermediaryError("Not enough time to claim!");
+        if (this.wrapper._getHtlcTimeout(data) <= (Date.now()/1000)) throw new IntermediaryError("HTLC expires too soon!");
     }
 
     /**
-     * Waits till an LN payment is received by the intermediary and client can continue commiting & claiming the HTLC
+     * Waits till a lightning network payment is received by the intermediary, and the intermediary
+     *  initiates the swap HTLC on the smart chain side. After the HTLC is initiated you can wait
+     *  for an automatic settlement by the watchtowers with the {@link waitTillClaimed} function,
+     *  or settle manually using the {@link claim} or {@link txsClaim} functions.
+     *
+     * If this swap is using an LNURL-withdraw link as input, it automatically posts the
+     *  generated invoice to the LNURL service to pay it.
      *
      * @param onPaymentReceived Callback as for when the LP reports having received the ln payment
-     * @param checkIntervalSeconds How often to poll the intermediary for answer (default 5 seconds)
      * @param abortSignal Abort signal to stop waiting for payment
+     * @param checkIntervalSeconds How often to poll the intermediary for answer (default 5 seconds)
      */
     async waitForPayment(onPaymentReceived?: (txId: string) => void, checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<boolean> {
         checkIntervalSeconds ??= 5;
-        if(this.state===FromBTCLNAutoSwapState.PR_PAID) {
+        if(this._state===FromBTCLNAutoSwapState.PR_PAID) {
             await this.waitTillCommited(checkIntervalSeconds, abortSignal);
         }
-        if(this.state>=FromBTCLNAutoSwapState.CLAIM_COMMITED) return true;
+        if(this._state>=FromBTCLNAutoSwapState.CLAIM_COMMITED) return true;
         if(
-            this.state!==FromBTCLNAutoSwapState.PR_CREATED
+            this._state!==FromBTCLNAutoSwapState.PR_CREATED
         ) throw new Error("Must be in PR_CREATED state!");
 
         const abortController = new AbortController();
@@ -642,6 +882,9 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         let save = false;
 
         if(this.lnurl!=null && this.lnurlK1!=null && this.lnurlCallback!=null && !this.prPosted) {
+            if(this.pr==null || !this.pr.toLowerCase().startsWith("ln"))
+                throw new Error("Input lightning network invoice not available, the swap was probably recovered!");
+
             LNURL.postInvoiceToLNURLWithdraw({k1: this.lnurlK1, callback: this.lnurlCallback}, this.pr).catch(e => {
                 this.lnurlFailSignal.abort(e);
             });
@@ -660,18 +903,22 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         this.lnurlFailSignal.signal.addEventListener("abort", lnurlFailListener);
         this.lnurlFailSignal.signal.throwIfAborted();
 
-        if(this.wrapper.messenger.warmup!=null) await this.wrapper.messenger.warmup().catch(e => {
+        const paymentHash = this.getPaymentHash();
+        if(paymentHash==null)
+            throw new Error("Swap payment hash not available, the swap was probably recovered!");
+
+        if(this.wrapper._messenger.warmup!=null) await this.wrapper._messenger.warmup().catch(e => {
             this.logger.warn("waitForPayment(): Failed to warmup messenger: ", e);
         });
 
-        if(this.state===FromBTCLNAutoSwapState.PR_CREATED) {
+        if(this._state===FromBTCLNAutoSwapState.PR_CREATED) {
             const promises: Promise<boolean | undefined>[] = [
                 this.waitTillState(FromBTCLNAutoSwapState.PR_PAID, "gte", abortController.signal).then(() => true)
             ];
             if(this.url!=null) promises.push((async () => {
                 let resp: InvoiceStatusResponse = {code: InvoiceStatusResponseCodes.PENDING, msg: ""};
                 while(!abortController.signal.aborted && resp.code===InvoiceStatusResponseCodes.PENDING) {
-                    resp = await IntermediaryAPI.getInvoiceStatus(this.url!, this.getPaymentHash().toString("hex"));
+                    resp = await IntermediaryAPI.getInvoiceStatus(this.url!, paymentHash.toString("hex"));
                     if(resp.code===InvoiceStatusResponseCodes.PENDING)
                         await timeoutPromise(checkIntervalSeconds*1000, abortController.signal);
                 }
@@ -679,11 +926,11 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
                 abortController.signal.throwIfAborted();
 
                 if(resp.code===InvoiceStatusResponseCodes.PAID) {
-                    const swapData = new this.wrapper.swapDataDeserializer(resp.data.data);
+                    const swapData = new this.wrapper._swapDataDeserializer(resp.data.data);
                     return await this._saveRealSwapData(swapData, true);
                 }
 
-                if(this.state===FromBTCLNAutoSwapState.PR_CREATED || this.state===FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED) {
+                if(this._state===FromBTCLNAutoSwapState.PR_CREATED || this._state===FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED) {
                     if(resp.code===InvoiceStatusResponseCodes.EXPIRED) {
                         await this._saveAndEmit(FromBTCLNAutoSwapState.QUOTE_EXPIRED);
                     }
@@ -694,23 +941,31 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
             abortController.abort();
 
             if(!paymentResult) return false;
-            if(onPaymentReceived!=null) onPaymentReceived(this.getInputTxId());
+            if(onPaymentReceived!=null) onPaymentReceived(this.getInputTxId()!);
         }
 
-        if((this.state as FromBTCLNAutoSwapState)===FromBTCLNAutoSwapState.PR_PAID) {
+        if((this._state as FromBTCLNAutoSwapState)===FromBTCLNAutoSwapState.PR_PAID) {
             await this.waitTillCommited(checkIntervalSeconds, abortSignal);
         }
 
-        return this.state>=FromBTCLNAutoSwapState.CLAIM_COMMITED;
+        return this._state>=FromBTCLNAutoSwapState.CLAIM_COMMITED;
     }
 
 
     //////////////////////////////
     //// Commit
 
+    /**
+     * Waits till the intermediary (LP) initiates the swap HTLC escrow on the destination smart chain side
+     *
+     * @param checkIntervalSeconds How often to check via a polling watchdog
+     * @param abortSignal Abort signal
+     *
+     * @internal
+     */
     protected async waitTillCommited(checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<void> {
-        if(this.state===FromBTCLNAutoSwapState.CLAIM_COMMITED || this.state===FromBTCLNAutoSwapState.CLAIM_CLAIMED) return Promise.resolve();
-        if(this.state!==FromBTCLNAutoSwapState.PR_PAID) throw new Error("Invalid state");
+        if(this._state===FromBTCLNAutoSwapState.CLAIM_COMMITED || this._state===FromBTCLNAutoSwapState.CLAIM_CLAIMED) return Promise.resolve();
+        if(this._state!==FromBTCLNAutoSwapState.PR_PAID) throw new Error("Invalid state");
 
         const abortController = extendAbortController(abortSignal);
         let result: number | boolean;
@@ -728,7 +983,7 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         if(result===false) {
             this.logger.debug("waitTillCommited(): Resolved from watchdog - HTLC expired");
             if(
-                this.state===FromBTCLNAutoSwapState.PR_PAID
+                this._state===FromBTCLNAutoSwapState.PR_PAID
             ) {
                 await this._saveAndEmit(FromBTCLNAutoSwapState.EXPIRED);
             }
@@ -736,7 +991,7 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         }
 
         if(
-            this.state===FromBTCLNAutoSwapState.PR_PAID
+            this._state===FromBTCLNAutoSwapState.PR_PAID
         ) {
             await this._saveAndEmit(FromBTCLNAutoSwapState.CLAIM_COMMITED);
         }
@@ -744,7 +999,7 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         if(result===0) this.logger.debug("waitTillCommited(): Resolved from state changed");
         if(result===true) {
             this.logger.debug("waitTillCommited(): Resolved from watchdog - commited");
-            await this._broadcastSecret().catch(e => {
+            if(this.secret!=null) await this._broadcastSecret().catch(e => {
                 this.logger.error("waitTillCommited(): Error broadcasting swap secret: ", e);
             });
         }
@@ -755,55 +1010,82 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
     //// Claim
 
     /**
-     * Returns transactions required for claiming the HTLC and finishing the swap by revealing the HTLC secret
-     *  (hash preimage)
+     * @inheritDoc
      *
      * @param _signer Optional signer address to use for claiming the swap, can also be different from the initializer
-     * @throws {Error} If in invalid state (must be CLAIM_COMMITED)
+     * @param secret A swap secret to use for the claim transaction, generally only needed if the swap
+     *  was recovered from on-chain data, or the pre-image was generated outside the SDK
+     *
+     * @throws {Error} If in invalid state (must be {@link FromBTCLNAutoSwapState.CLAIM_COMMITED})
      */
-    async txsClaim(_signer?: T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]> {
-        if(this.state!==FromBTCLNAutoSwapState.CLAIM_COMMITED) throw new Error("Must be in CLAIM_COMMITED state!");
-        if(this.data==null) throw new Error("Unknown data, wrong state?");
+    async txsClaim(_signer?: T["Signer"] | T["NativeSigner"], secret?: string): Promise<T["TX"][]> {
+        if(this._state!==FromBTCLNAutoSwapState.CLAIM_COMMITED) throw new Error("Must be in CLAIM_COMMITED state!");
+        if(this._data==null) throw new Error("Unknown data, wrong state?");
+
+        const useSecret = secret ?? this.secret;
+        if(useSecret==null)
+            throw new Error("Swap secret pre-image not known and not provided, please provide the swap secret pre-image as an argument");
+        if(!this.isValidSecretPreimage(useSecret))
+            throw new Error("Invalid swap secret pre-image provided!");
 
-        return await this.wrapper.contract.txsClaimWithSecret(
+        return await this.wrapper._contract.txsClaimWithSecret(
             _signer==null ?
                 this._getInitiator() :
-                (isAbstractSigner(_signer) ? _signer : await this.wrapper.chain.wrapSigner(_signer)),
-            this.data, this.secret, true, true
+                (isAbstractSigner(_signer) ? _signer : await this.wrapper._chain.wrapSigner(_signer)),
+            this._data, useSecret, true, true
         );
     }
 
     /**
-     * Claims and finishes the swap
+     * @inheritDoc
      *
      * @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
+     * @param secret A swap secret to use for the claim transaction, generally only needed if the swap
+     *  was recovered from on-chain data, or the pre-image was generated outside the SDK
      */
-    async claim(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal): Promise<string> {
-        const signer = isAbstractSigner(_signer) ? _signer : await this.wrapper.chain.wrapSigner(_signer);
-        const result = await this.wrapper.chain.sendAndConfirm(
-            signer, await this.txsClaim(), true, abortSignal
+    async claim(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, onBeforeTxSent?: (txId: string) => void, secret?: string): Promise<string> {
+        const signer = isAbstractSigner(_signer) ? _signer : await this.wrapper._chain.wrapSigner(_signer);
+        let txCount = 0;
+        const txs = await this.txsClaim(_signer, secret);
+        const result = await this.wrapper._chain.sendAndConfirm(
+            signer, txs, true, abortSignal, undefined, (txId: string) => {
+                txCount++;
+                if(onBeforeTxSent!=null && txCount===1) onBeforeTxSent(txId);
+                return Promise.resolve();
+            }
         );
 
-        this.claimTxId = result[0];
-        if(this.state===FromBTCLNAutoSwapState.CLAIM_COMMITED || this.state===FromBTCLNAutoSwapState.EXPIRED || this.state===FromBTCLNAutoSwapState.FAILED) {
+        this._claimTxId = result[0];
+        if(this._state===FromBTCLNAutoSwapState.CLAIM_COMMITED || this._state===FromBTCLNAutoSwapState.EXPIRED || this._state===FromBTCLNAutoSwapState.FAILED) {
             await this._saveAndEmit(FromBTCLNAutoSwapState.CLAIM_CLAIMED);
         }
         return result[0];
     }
 
     /**
-     * Waits till the swap is successfully claimed
+     * Waits till the swap is successfully settled (claimed), should be called after sending the claim (settlement)
+     *  transactions manually to wait till the SDK processes the settlement and updates the swap state accordingly.
      *
      * @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)
+     * @param secret A swap secret to broadcast to watchtowers, generally only needed if the swap
+     *  was recovered from on-chain data, or the pre-image was generated outside the SDK
+     *
+     * @throws {Error} If swap is in invalid state (must be {@link FromBTCLNAutoSwapState.CLAIM_COMMITED})
      * @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===FromBTCLNAutoSwapState.CLAIM_CLAIMED) return Promise.resolve(true);
-        if(this.state!==FromBTCLNAutoSwapState.CLAIM_COMMITED) throw new Error("Invalid state (not CLAIM_COMMITED)");
+    async waitTillClaimed(maxWaitTimeSeconds?: number, abortSignal?: AbortSignal, secret?: string): Promise<boolean> {
+        if(this._state===FromBTCLNAutoSwapState.CLAIM_CLAIMED) return Promise.resolve(true);
+        if(this._state!==FromBTCLNAutoSwapState.CLAIM_COMMITED) throw new Error("Invalid state (not CLAIM_COMMITED)");
+
+        if(secret!=null) {
+            if(!this.isValidSecretPreimage(secret))
+                throw new Error("Invalid swap secret pre-image provided!");
+            this.secret = secret;
+        }
 
         const abortController = new AbortController();
         if(abortSignal!=null) abortSignal.addEventListener("abort", () => abortController.abort(abortSignal.reason));
@@ -841,15 +1123,15 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         this.logger.debug("waitTillClaimed(): Resolved from watchdog");
 
         if(res?.type===SwapCommitStateType.PAID) {
-            if((this.state as FromBTCLNAutoSwapState)!==FromBTCLNAutoSwapState.CLAIM_CLAIMED) {
-                this.claimTxId = await res.getClaimTxId();
+            if((this._state as FromBTCLNAutoSwapState)!==FromBTCLNAutoSwapState.CLAIM_CLAIMED) {
+                this._claimTxId = await res.getClaimTxId();
                 await this._saveAndEmit(FromBTCLNAutoSwapState.CLAIM_CLAIMED);
             }
         }
         if(res?.type===SwapCommitStateType.NOT_COMMITED || res?.type===SwapCommitStateType.EXPIRED) {
             if(
-                (this.state as FromBTCLNAutoSwapState)!==FromBTCLNAutoSwapState.CLAIM_CLAIMED &&
-                (this.state as FromBTCLNAutoSwapState)!==FromBTCLNAutoSwapState.FAILED
+                (this._state as FromBTCLNAutoSwapState)!==FromBTCLNAutoSwapState.CLAIM_CLAIMED &&
+                (this._state as FromBTCLNAutoSwapState)!==FromBTCLNAutoSwapState.FAILED
             ) {
                 await this._saveAndEmit(FromBTCLNAutoSwapState.FAILED);
             }
@@ -863,23 +1145,33 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
     //// LNURL
 
     /**
-     * Is this an LNURL-withdraw swap?
+     * Whether this swap uses an LNURL-withdraw link
      */
     isLNURL(): boolean {
         return this.lnurl!=null;
     }
 
     /**
-     * Gets the used LNURL or null if this is not an LNURL-withdraw swap
+     * Gets the used LNURL or `null` if this is not an LNURL-withdraw swap
      */
     getLNURL(): string | null {
         return this.lnurl ?? null;
     }
 
     /**
-     * Pay the generated lightning network invoice with LNURL-withdraw
+     * Pay the generated lightning network invoice with an LNURL-withdraw link, this
+     *  is useful when you want to display a lightning payment QR code and also want to
+     *  allow payments using LNURL-withdraw NFC cards.
+     *
+     * Note that the swap needs to be created **without** an LNURL to begin with for this function
+     *  to work. If this swap is already using an LNURL-withdraw link, this function throws.
      */
     async settleWithLNURLWithdraw(lnurl: string | LNURLWithdraw): Promise<void> {
+        if(
+            this._state!==FromBTCLNAutoSwapState.PR_CREATED &&
+            this._state!==FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED
+        ) throw new Error("Must be in PR_CREATED state!");
+
         if(this.lnurl!=null) throw new Error("Cannot settle LNURL-withdraw swap with different LNURL");
         let lnurlParams: LNURLWithdrawParamsWithUrl;
         if(typeof(lnurl)==="string") {
@@ -890,6 +1182,10 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         } else {
             lnurlParams = lnurl.params;
         }
+
+        if(this.pr==null || !this.pr.toLowerCase().startsWith("ln"))
+            throw new Error("Input lightning network invoice not available, the swap was probably recovered!");
+
         LNURL.useLNURLWithdraw(lnurlParams, this.pr).catch(e => this.lnurlFailSignal.abort(e));
         this.lnurl = lnurlParams.url;
         this.lnurlCallback = lnurlParams.callback;
@@ -902,12 +1198,15 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
     //////////////////////////////
     //// Storage
 
+    /**
+     * @inheritDoc
+     */
     serialize(): any {
         return {
             ...super.serialize(),
-            data: this.data==null ? null : this.data.serialize(),
-            commitTxId: this.commitTxId,
-            claimTxId: this.claimTxId,
+            data: this._data==null ? null : this._data.serialize(),
+            commitTxId: this._commitTxId,
+            claimTxId: this._claimTxId,
             btcAmountSwap: this.btcAmountSwap==null ? null : this.btcAmountSwap.toString(10),
             btcAmountGas: this.btcAmountGas==null ? null : this.btcAmountGas.toString(10),
             gasSwapFeeBtc: this.gasSwapFeeBtc==null ? null : this.gasSwapFeeBtc.toString(10),
@@ -919,7 +1218,8 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
             lnurlK1: this.lnurlK1,
             lnurlCallback: this.lnurlCallback,
             prPosted: this.prPosted,
-            initialSwapData: this.initialSwapData.serialize()
+            initialSwapData: this.initialSwapData.serialize(),
+            usesClaimHashAsId: this.usesClaimHashAsId
         };
     }
 
@@ -934,69 +1234,66 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
      * @private
      */
     private async syncStateFromChain(quoteDefinitelyExpired?: boolean, commitStatus?: SwapCommitState): Promise<boolean> {
-        //Check for expiry before the getCommitStatus to prevent race conditions
-        let quoteExpired: boolean = false;
-        if(this.state===FromBTCLNAutoSwapState.PR_PAID) {
-            quoteExpired = quoteDefinitelyExpired ?? await this._verifyQuoteDefinitelyExpired();
-        }
-
-        if(this.state===FromBTCLNAutoSwapState.CLAIM_COMMITED || this.state===FromBTCLNAutoSwapState.EXPIRED) {
-            //Check if it's already successfully paid
-            commitStatus ??= await this.wrapper.contract.getCommitStatus(this._getInitiator(), this.data!);
-            if(commitStatus?.type===SwapCommitStateType.PAID) {
-                if(this.claimTxId==null) this.claimTxId = await commitStatus.getClaimTxId();
-                this.state = FromBTCLNAutoSwapState.CLAIM_CLAIMED;
-                return true;
+        if(
+            this._state===FromBTCLNAutoSwapState.PR_PAID ||
+            this._state===FromBTCLNAutoSwapState.CLAIM_COMMITED ||
+            this._state===FromBTCLNAutoSwapState.EXPIRED
+        ) {
+            //Check for expiry before the getCommitStatus to prevent race conditions
+            let quoteExpired: boolean = false;
+            if(this._state===FromBTCLNAutoSwapState.PR_PAID) {
+                quoteExpired = quoteDefinitelyExpired ?? await this._verifyQuoteDefinitelyExpired();
             }
 
-            if(commitStatus?.type===SwapCommitStateType.NOT_COMMITED || commitStatus?.type===SwapCommitStateType.EXPIRED) {
-                this.state = FromBTCLNAutoSwapState.FAILED;
-                return true;
-            }
-        }
+            //Check if it's already successfully paid
+            commitStatus ??= await this.wrapper._contract.getCommitStatus(this._getInitiator(), this._data!);
+            if(commitStatus!=null && await this._forciblySetOnchainState(commitStatus)) return true;
 
-        if(this.state===FromBTCLNAutoSwapState.PR_PAID) {
-            //Check if it's already committed
-            commitStatus ??= await this.wrapper.contract.getCommitStatus(this._getInitiator(), this.data!);
-            switch(commitStatus?.type) {
-                case SwapCommitStateType.COMMITED:
-                    this.state = FromBTCLNAutoSwapState.CLAIM_COMMITED;
-                    return true;
-                case SwapCommitStateType.EXPIRED:
-                    this.state = FromBTCLNAutoSwapState.EXPIRED;
-                    return true;
-                case SwapCommitStateType.PAID:
-                    if(this.claimTxId==null) this.claimTxId = await commitStatus.getClaimTxId();
-                    this.state = FromBTCLNAutoSwapState.CLAIM_CLAIMED;
+            if(this._state===FromBTCLNAutoSwapState.PR_PAID) {
+                if(quoteExpired) {
+                    this._state = FromBTCLNAutoSwapState.QUOTE_EXPIRED;
                     return true;
-            }
-            if(quoteExpired) {
-                this.state = FromBTCLNAutoSwapState.QUOTE_EXPIRED;
-                return true;
+                }
             }
         }
 
         return false;
     }
 
-    _shouldFetchCommitStatus(): boolean {
-        return this.state===FromBTCLNAutoSwapState.PR_PAID || this.state===FromBTCLNAutoSwapState.CLAIM_COMMITED || this.state===FromBTCLNAutoSwapState.EXPIRED;
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _shouldFetchOnchainState(): boolean {
+        return this._state===FromBTCLNAutoSwapState.PR_PAID || this._state===FromBTCLNAutoSwapState.CLAIM_COMMITED || this._state===FromBTCLNAutoSwapState.EXPIRED;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     _shouldFetchExpiryStatus(): boolean {
-        return this.state===FromBTCLNAutoSwapState.PR_PAID;
+        return this._state===FromBTCLNAutoSwapState.PR_PAID;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     _shouldCheckIntermediary(): boolean {
-        return this.state===FromBTCLNAutoSwapState.PR_CREATED || this.state===FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED;
+        return this._state===FromBTCLNAutoSwapState.PR_CREATED || this._state===FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     async _sync(save?: boolean, quoteDefinitelyExpired?: boolean, commitStatus?: SwapCommitState, skipLpCheck?: boolean): Promise<boolean> {
         let changed = false;
 
-        if(this.state===FromBTCLNAutoSwapState.PR_CREATED || this.state===FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED) {
-            if(this.state!==FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED && this.getQuoteExpiry()<Date.now()) {
-                this.state = FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED;
+        if(this._state===FromBTCLNAutoSwapState.PR_CREATED || this._state===FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED) {
+            if(this._state!==FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED && this.getQuoteExpiry()<Date.now()) {
+                this._state = FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED;
                 changed ||= true;
             }
 
@@ -1007,9 +1304,9 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
                 this.logger.error("_sync(): Failed to synchronize swap, error: ", e);
             }
 
-            if(this.state===FromBTCLNAutoSwapState.PR_CREATED || this.state===FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED) {
+            if(this._state===FromBTCLNAutoSwapState.PR_CREATED || this._state===FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED) {
                 if(await this._verifyQuoteDefinitelyExpired()) {
-                    this.state = FromBTCLNAutoSwapState.QUOTE_EXPIRED;
+                    this._state = FromBTCLNAutoSwapState.QUOTE_EXPIRED;
                     changed ||= true;
                 }
             }
@@ -1017,54 +1314,110 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
 
         if(await this.syncStateFromChain(quoteDefinitelyExpired, commitStatus)) changed = true;
 
+        if(this._state===FromBTCLNAutoSwapState.CLAIM_COMMITED) {
+            const expired = await this.wrapper._contract.isExpired(this._getInitiator(), this._data!);
+            if(expired) {
+                this._state = FromBTCLNAutoSwapState.EXPIRED;
+                changed = true;
+            }
+        }
+
         if(save && changed) await this._saveAndEmit();
 
-        if(this.state===FromBTCLNAutoSwapState.CLAIM_COMMITED) await this._broadcastSecret().catch(e => {
+        if(this._state===FromBTCLNAutoSwapState.CLAIM_COMMITED && this.secret!=null) await this._broadcastSecret().catch(e => {
             this.logger.error("_sync(): Error when broadcasting swap secret: ", e);
         });
 
         return changed;
     }
 
-    private broadcastTickCounter: number = 0;
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    async _forciblySetOnchainState(commitStatus: SwapCommitState): Promise<boolean> {
+        switch(commitStatus?.type) {
+            case SwapCommitStateType.PAID:
+                if(this._claimTxId==null) this._claimTxId = await commitStatus.getClaimTxId();
+                if(this.secret==null || this.pr==null) this._setSwapSecret(await commitStatus.getClaimResult());
+                this._state = FromBTCLNAutoSwapState.CLAIM_CLAIMED;
+                return true;
+            case SwapCommitStateType.NOT_COMMITED:
+                if(this._refundTxId==null && commitStatus.getRefundTxId!=null) this._refundTxId = await commitStatus.getRefundTxId();
+                if(this._refundTxId!=null) {
+                    this._state = FromBTCLNAutoSwapState.FAILED;
+                    return true;
+                }
+                break;
+            case SwapCommitStateType.EXPIRED:
+                if(this._refundTxId==null && commitStatus.getRefundTxId!=null) this._refundTxId = await commitStatus.getRefundTxId();
+                this._state = this._refundTxId==null ? FromBTCLNAutoSwapState.QUOTE_EXPIRED : FromBTCLNAutoSwapState.FAILED;
+                return true;
+            case SwapCommitStateType.COMMITED:
+                if(this._state!==FromBTCLNAutoSwapState.CLAIM_COMMITED && this._state!==FromBTCLNAutoSwapState.EXPIRED) {
+                    this._state = FromBTCLNAutoSwapState.CLAIM_COMMITED;
+                    return true;
+                }
+                break;
+        }
+        return false;
+    }
 
-    async _broadcastSecret(noCheckExpiry?: boolean): Promise<void> {
-        if(this.state!==FromBTCLNAutoSwapState.CLAIM_COMMITED) throw new Error("Must be in CLAIM_COMMITED state to broadcast swap secret!");
-        if(this.data==null) throw new Error("Unknown data, wrong state?");
+    /**
+     * Broadcasts the swap secret to the underlying data propagation layer (e.g. Nostr by default)
+     *
+     * @param noCheckExpiry Whether a swap expiration check should be skipped broadcasting
+     * @param secret An optional secret pre-image for the swap to broadcast
+     *
+     * @internal
+     */
+    async _broadcastSecret(noCheckExpiry?: boolean, secret?: string): Promise<void> {
+        if(this._state!==FromBTCLNAutoSwapState.CLAIM_COMMITED) throw new Error("Must be in CLAIM_COMMITED state to broadcast swap secret!");
+        if(this._data==null) throw new Error("Unknown data, wrong state?");
+
+        const useSecret = secret ?? this.secret;
+        if(useSecret==null)
+            throw new Error("Swap secret pre-image not known and not provided, please provide the swap secret pre-image as an argument");
+        if(!this.isValidSecretPreimage(useSecret))
+            throw new Error("Invalid swap secret pre-image provided!");
 
         if(!noCheckExpiry) {
-            if(await this.wrapper.contract.isExpired(this._getInitiator(), this.data)) throw new Error("On-chain HTLC already expired!");
+            if(await this.wrapper._contract.isExpired(this._getInitiator(), this._data)) throw new Error("On-chain HTLC already expired!");
         }
-        await this.wrapper.messenger.broadcast(new SwapClaimWitnessMessage(this.data, this.secret));
+        await this.wrapper._messenger.broadcast(new SwapClaimWitnessMessage(this._data, useSecret));
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     async _tick(save?: boolean): Promise<boolean> {
-        switch(this.state) {
+        switch(this._state) {
             case FromBTCLNAutoSwapState.PR_CREATED:
                 if(this.getQuoteExpiry() < Date.now()) {
-                    this.state = FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED;
+                    this._state = FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED;
                     if(save) await this._saveAndEmit();
                     return true;
                 }
                 break;
             case FromBTCLNAutoSwapState.QUOTE_SOFT_EXPIRED:
                 if(this.getDefinitiveExpiryTime() < Date.now()) {
-                    this.state = FromBTCLNAutoSwapState.QUOTE_EXPIRED;
+                    this._state = FromBTCLNAutoSwapState.QUOTE_EXPIRED;
                     if(save) await this._saveAndEmit();
                     return true;
                 }
                 break;
             case FromBTCLNAutoSwapState.PR_PAID:
             case FromBTCLNAutoSwapState.CLAIM_COMMITED:
-                const expired = await this.wrapper.contract.isExpired(this._getInitiator(), this.data!);
+                const expired = await this.wrapper._contract.isExpired(this._getInitiator(), this._data!);
                 if(expired) {
-                    this.state = FromBTCLNAutoSwapState.EXPIRED;
+                    this._state = FromBTCLNAutoSwapState.EXPIRED;
                     if(save) await this._saveAndEmit();
                     return true;
                 }
-                if(this.state===FromBTCLNAutoSwapState.CLAIM_COMMITED) {
+                if(this._state===FromBTCLNAutoSwapState.CLAIM_COMMITED) {
                     //Broadcast the secret over the provided messenger channel
-                    if(this.broadcastTickCounter===0) await this._broadcastSecret(true).catch(e => {
+                    if(this.broadcastTickCounter===0 && this.secret!=null) await this._broadcastSecret(true).catch(e => {
                         this.logger.warn("_tick(): Error when broadcasting swap secret: ", e);
                     });
                     this.broadcastTickCounter = (this.broadcastTickCounter + 1) % 3; //Broadcast every 3rd tick
@@ -1075,4 +1428,16 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
         return false;
     }
 
+    /**
+     * Forcibly sets the swap secret pre-image from on-chain data
+     *
+     * @internal
+     */
+    _setSwapSecret(secret: string) {
+        this.secret = secret;
+        if(this.pr==null) {
+            this.pr = Buffer.from(sha256(Buffer.from(secret, "hex"))).toString("hex");
+        }
+    }
+
 }