@atomiqlabs/sdk 8.1.8 → 8.3.5

package/src/swaps/escrow_swaps/tobtc/IToBTCSwap.ts

@@ -23,6 +23,7 @@ import {ppmToPercentage} from "../../../types/fees/PercentagePPM";
 import {TokenAmount, toTokenAmount} from "../../../types/TokenAmount";
 import {BtcToken, SCToken} from "../../../types/Token";
 import {timeoutPromise} from "../../../utils/TimeoutUtils";
+import {SwapExecutionActionCommit} from "../../../types/SwapExecutionAction";
 
 export type IToBTCSwapInit<T extends SwapData> = IEscrowSelfInitSwapInit<T> & {
     signatureData?: SignatureData,
@@ -44,16 +45,79 @@ export function isIToBTCSwapInit<T extends SwapData>(obj: any): obj is IToBTCSwa
         isIEscrowSelfInitSwapInit<T>(obj);
 }
 
+/**
+ * State enum for escrow-based Smart chain -> Bitcoin (on-chain & lightning) swaps
+ *
+ * @category Swaps/Smart chain → Bitcoin
+ */
+export enum ToBTCSwapState {
+    /**
+     * Intermediary (LP) was unable to process the swap and the funds were refunded on the
+     *  source chain
+     */
+    REFUNDED = -3,
+    /**
+     * Swap has expired for good and there is no way how it can be executed anymore
+     */
+    QUOTE_EXPIRED = -2,
+    /**
+     * A swap is almost expired, and it should be presented to the user as expired, though
+     *  there is still a chance that it will be processed
+     */
+    QUOTE_SOFT_EXPIRED = -1,
+    /**
+     * Swap was created, use the {@link IToBTCSwap.commit} or {@link IToBTCSwap.txsCommit} to
+     *  initiate it by creating the swap escrow on the source chain
+     */
+    CREATED = 0,
+    /**
+     * Swap escrow was initiated (committed) on the source chain, the intermediary (LP) will
+     *  now process the swap. You can wait till that happens with the {@link IToBTCSwap.waitForPayment}
+     *  function.
+     */
+    COMMITED = 1,
+    /**
+     * The intermediary (LP) has processed the transaction and sent out the funds on the destination chain,
+     *  but hasn't yet settled the escrow on the source chain.
+     */
+    SOFT_CLAIMED = 2,
+    /**
+     * Swap was successfully settled by the intermediary (LP) on the source chain
+     */
+    CLAIMED = 3,
+    /**
+     * Intermediary (LP) was unable to process the swap and the swap escrow on the source chain
+     *  is refundable, call {@link IToBTCSwap.refund} or {@link IToBTCSwap.txsRefund} to refund
+     */
+    REFUNDABLE = 4
+}
+
+/**
+ * Base class for escrow-based Smart chain -> Bitcoin (on-chain & lightning) swaps
+ *
+ * @category Swaps/Smart chain → Bitcoin
+ */
 export abstract class IToBTCSwap<
     T extends ChainType = ChainType,
     D extends IToBTCDefinition<T, IToBTCWrapper<T, D>, IToBTCSwap<T, D>> = IToBTCDefinition<T, IToBTCWrapper<T, any>, IToBTCSwap<T, any>>,
 > extends IEscrowSelfInitSwap<T, D, ToBTCSwapState> implements IRefundableSwap<T, D, ToBTCSwapState> {
+    /**
+     * @internal
+     */
+    protected readonly abstract outputToken: BtcToken;
+    /**
+     * @internal
+     */
     protected readonly networkFee: bigint;
+    /**
+     * @internal
+     */
     protected networkFeeBtc: bigint;
-    protected readonly abstract outputToken: BtcToken;
 
-    readonly data!: T["Data"];
-    readonly signatureData?: SignatureData;
+    /**
+     * @internal
+     */
+    readonly _data!: T["Data"];
 
     protected constructor(wrapper: D["Wrapper"], serializedObject: any);
     protected constructor(wrapper: D["Wrapper"], init: IToBTCSwapInit<T["Data"]>);
@@ -63,10 +127,10 @@ export abstract class IToBTCSwap<
     ) {
         super(wrapper, initOrObject);
         if(isIToBTCSwapInit<T["Data"]>(initOrObject)) {
-            this.state = ToBTCSwapState.CREATED;
+            this._state = ToBTCSwapState.CREATED;
             this.networkFee = initOrObject.networkFee;
             this.networkFeeBtc = initOrObject.networkFeeBtc;
-            this.data = initOrObject.data;
+            this._data = initOrObject.data;
             this.signatureData = initOrObject.signatureData;
         } else {
             this.networkFee = toBigInt(initOrObject.networkFee);
@@ -74,30 +138,38 @@ export abstract class IToBTCSwap<
         }
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     protected getSwapData(): T["Data"] {
-        return this.data;
+        return this._data;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     protected upgradeVersion() {
         if(this.version == null) {
-            switch(this.state) {
+            switch(this._state) {
                 case -2:
-                    this.state = ToBTCSwapState.REFUNDED
+                    this._state = ToBTCSwapState.REFUNDED
                     break;
                 case -1:
-                    this.state = ToBTCSwapState.QUOTE_EXPIRED
+                    this._state = ToBTCSwapState.QUOTE_EXPIRED
                     break;
                 case 0:
-                    this.state = ToBTCSwapState.CREATED
+                    this._state = ToBTCSwapState.CREATED
                     break;
                 case 1:
-                    this.state = ToBTCSwapState.COMMITED
+                    this._state = ToBTCSwapState.COMMITED
                     break;
                 case 2:
-                    this.state = ToBTCSwapState.CLAIMED
+                    this._state = ToBTCSwapState.CLAIMED
                     break;
                 case 3:
-                    this.state = ToBTCSwapState.REFUNDABLE
+                    this._state = ToBTCSwapState.REFUNDABLE
                     break;
             }
             this.version = 1;
@@ -105,8 +177,8 @@ export abstract class IToBTCSwap<
     }
 
     /**
-     * In case swapFee in BTC is not supplied it recalculates it based on swap price
-     * @protected
+     * @inheritDoc
+     * @internal
      */
     protected tryRecomputeSwapPrice() {
         const output = this.getOutput();
@@ -123,7 +195,7 @@ export abstract class IToBTCSwap<
 
     /**
      * Returns the payment hash identifier to be sent to the LP for getStatus and getRefund
-     * @protected
+     * @internal
      */
     protected getLpIdentifier(): string {
         return this.getClaimHash();
@@ -136,6 +208,8 @@ export abstract class IToBTCSwap<
      * @param check Whether to check the passed result
      * @returns true if check passed, false if check failed with a soft error (e.g. tx not yet found in the mempool)
      * @throws {IntermediaryError} When the data returned by the intermediary isn't valid
+     *
+     * @internal
      */
     abstract _setPaymentResult(result: {secret?: string, txId?: string}, check?: boolean): Promise<boolean>;
 
@@ -143,53 +217,86 @@ export abstract class IToBTCSwap<
     //////////////////////////////
     //// Getters & utils
 
+    /**
+     * @inheritDoc
+     */
     getInputAddress(): string | null {
         return this._getInitiator();
     }
 
+    /**
+     * @inheritDoc
+     */
     getInputTxId(): string | null {
-        return this.commitTxId ?? null;
+        return this._commitTxId ?? null;
     }
 
+    /**
+     * @inheritDoc
+     */
     requiresAction(): boolean {
         return this.isRefundable();
     }
 
     /**
-     * Returns whether the swap is finished and in its terminal state (this can mean successful, refunded or failed)
+     * @inheritDoc
      */
     isFinished(): boolean {
-        return this.state===ToBTCSwapState.CLAIMED || this.state===ToBTCSwapState.REFUNDED || this.state===ToBTCSwapState.QUOTE_EXPIRED;
+        return this._state===ToBTCSwapState.CLAIMED || this._state===ToBTCSwapState.REFUNDED || this._state===ToBTCSwapState.QUOTE_EXPIRED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isRefundable(): boolean {
-        return this.state===ToBTCSwapState.REFUNDABLE;
+        return this._state===ToBTCSwapState.REFUNDABLE;
     }
 
+    /**
+     * @inheritDoc
+     */
     isQuoteExpired(): boolean {
-        return this.state===ToBTCSwapState.QUOTE_EXPIRED;
+        return this._state===ToBTCSwapState.QUOTE_EXPIRED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isQuoteSoftExpired(): boolean {
-        return this.state===ToBTCSwapState.QUOTE_EXPIRED || this.state===ToBTCSwapState.QUOTE_SOFT_EXPIRED;
+        return this._state===ToBTCSwapState.QUOTE_EXPIRED || this._state===ToBTCSwapState.QUOTE_SOFT_EXPIRED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isSuccessful(): boolean {
-        return this.state===ToBTCSwapState.CLAIMED;
+        return this._state===ToBTCSwapState.CLAIMED;
     }
 
+    /**
+     * @inheritDoc
+     */
     isFailed(): boolean {
-        return this.state===ToBTCSwapState.REFUNDED;
+        return this._state===ToBTCSwapState.REFUNDED;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     _getInitiator(): string {
-        return this.data.getOfferer();
+        return this._data.getOfferer();
     }
 
 
     //////////////////////////////
     //// Amounts & fees
 
+    /**
+     * Returns the swap fee charged by the intermediary (LP) on this swap
+     *
+     * @internal
+     */
     protected getSwapFee(): Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken> {
         if(this.pricingInfo==null) throw new Error("No pricing info known, cannot estimate fee!");
 
@@ -198,32 +305,33 @@ export abstract class IToBTCSwap<
         const swapFeePPM = output.rawAmount==null ? 0n : feeWithoutBaseFee * 1000000n / output.rawAmount;
 
         const amountInDstToken = toTokenAmount(
-            this.swapFeeBtc, this.outputToken, this.wrapper.prices, this.pricingInfo
+            this.swapFeeBtc, this.outputToken, this.wrapper._prices, this.pricingInfo
         );
         return {
-            amountInSrcToken: toTokenAmount(this.swapFee, this.wrapper.tokens[this.data.getToken()], this.wrapper.prices, this.pricingInfo),
+            amountInSrcToken: toTokenAmount(this.swapFee, this.wrapper._tokens[this._data.getToken()], this.wrapper._prices, this.pricingInfo),
             amountInDstToken,
             currentUsdValue: amountInDstToken.currentUsdValue,
             usdValue: amountInDstToken.usdValue,
             pastUsdValue: amountInDstToken.pastUsdValue,
             composition: {
-                base: toTokenAmount(this.pricingInfo.satsBaseFee, this.outputToken, this.wrapper.prices, this.pricingInfo),
+                base: toTokenAmount(this.pricingInfo.satsBaseFee, this.outputToken, this.wrapper._prices, this.pricingInfo),
                 percentage: ppmToPercentage(swapFeePPM)
             }
         };
     }
 
     /**
-     * Returns network fee for the swap, the fee is represented in source currency & destination currency, but is
-     *  paid only once
+     * Returns network fee for on the destination chain for the swap
+     *
+     * @internal
      */
     protected getNetworkFee(): Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken> {
         const amountInDstToken = toTokenAmount(
-            this.networkFeeBtc, this.outputToken, this.wrapper.prices, this.pricingInfo
+            this.networkFeeBtc, this.outputToken, this.wrapper._prices, this.pricingInfo
         );
         return {
             amountInSrcToken: toTokenAmount(
-                this.networkFee, this.wrapper.tokens[this.data.getToken()], this.wrapper.prices, this.pricingInfo
+                this.networkFee, this.wrapper._tokens[this._data.getToken()], this.wrapper._prices, this.pricingInfo
             ),
             amountInDstToken,
             currentUsdValue: amountInDstToken.currentUsdValue,
@@ -232,14 +340,17 @@ export abstract class IToBTCSwap<
         };
     }
 
+    /**
+     * @inheritDoc
+     */
     getFee(): Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken> {
         const amountInDstToken = toTokenAmount(
-            this.swapFeeBtc + this.networkFeeBtc, this.outputToken, this.wrapper.prices, this.pricingInfo
+            this.swapFeeBtc + this.networkFeeBtc, this.outputToken, this.wrapper._prices, this.pricingInfo
         );
         return {
             amountInSrcToken: toTokenAmount(
-                this.swapFee + this.networkFee, this.wrapper.tokens[this.data.getToken()],
-                this.wrapper.prices, this.pricingInfo
+                this.swapFee + this.networkFee, this.wrapper._tokens[this._data.getToken()],
+                this.wrapper._prices, this.pricingInfo
             ),
             amountInDstToken,
             currentUsdValue: amountInDstToken.currentUsdValue,
@@ -248,6 +359,9 @@ export abstract class IToBTCSwap<
         }
     }
 
+    /**
+     * @inheritDoc
+     */
     getFeeBreakdown(): [
         {type: FeeType.SWAP, fee: Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken>},
         {type: FeeType.NETWORK_OUTPUT, fee: Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken>},
@@ -264,26 +378,35 @@ export abstract class IToBTCSwap<
         ];
     }
 
+    /**
+     * @inheritDoc
+     */
     getInputToken(): SCToken<T["ChainId"]> {
-        return this.wrapper.tokens[this.data.getToken()];
+        return this.wrapper._tokens[this._data.getToken()];
     }
 
+    /**
+     * @inheritDoc
+     */
     getInput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true> {
         return toTokenAmount(
-            this.data.getAmount(), this.wrapper.tokens[this.data.getToken()],
-            this.wrapper.prices, this.pricingInfo
+            this._data.getAmount(), this.wrapper._tokens[this._data.getToken()],
+            this.wrapper._prices, this.pricingInfo
         );
     }
 
+    /**
+     * @inheritDoc
+     */
     getInputWithoutFee(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true> {
         return toTokenAmount(
-            this.data.getAmount() - (this.swapFee + this.networkFee),
-            this.wrapper.tokens[this.data.getToken()], this.wrapper.prices, this.pricingInfo
+            this._data.getAmount() - (this.swapFee + this.networkFee),
+            this.wrapper._tokens[this._data.getToken()], this.wrapper._prices, this.pricingInfo
         );
     }
 
     /**
-     * Checks if the intiator/sender has enough balance to go through with the swap
+     * Checks if the initiator/sender on the source chain has enough balance to go through with the swap
      */
     async hasEnoughBalance(): Promise<{
         enoughBalance: boolean,
@@ -291,20 +414,21 @@ export abstract class IToBTCSwap<
         required: TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>
     }> {
         const [balance, commitFee] = await Promise.all([
-            this.wrapper.contract.getBalance(this._getInitiator(), this.data.getToken(), false),
-            this.data.getToken()===this.wrapper.chain.getNativeCurrencyAddress() ? this.getCommitFee() : Promise.resolve(null)
+            this.wrapper._contract.getBalance(this._getInitiator(), this._data.getToken(), false),
+            this._data.getToken()===this.wrapper._chain.getNativeCurrencyAddress() ? this.getCommitFee() : Promise.resolve(null)
         ]);
-        let required = this.data.getAmount();
+        let required = this._data.getAmount();
         if(commitFee!=null) required = required + commitFee;
         return {
             enoughBalance: balance >= required,
-            balance: toTokenAmount(balance, this.wrapper.tokens[this.data.getToken()], this.wrapper.prices, this.pricingInfo),
-            required: toTokenAmount(required, this.wrapper.tokens[this.data.getToken()], this.wrapper.prices, this.pricingInfo)
+            balance: toTokenAmount(balance, this.wrapper._tokens[this._data.getToken()], this.wrapper._prices, this.pricingInfo),
+            required: toTokenAmount(required, this.wrapper._tokens[this._data.getToken()], this.wrapper._prices, this.pricingInfo)
         };
     }
 
     /**
-     * Check if the initiator/sender has enough balance to cover the transaction fee for processing the swap
+     * Checks if the initiator/sender on the source chain has enough native token balance
+     *  to cover the transaction fee of initiating the swap
      */
     async hasEnoughForTxFees(): Promise<{
         enoughBalance: boolean,
@@ -312,13 +436,13 @@ export abstract class IToBTCSwap<
         required: TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>
     }> {
         const [balance, commitFee] = await Promise.all([
-            this.wrapper.contract.getBalance(this._getInitiator(), this.wrapper.chain.getNativeCurrencyAddress(), false),
+            this.wrapper._contract.getBalance(this._getInitiator(), this.wrapper._chain.getNativeCurrencyAddress(), false),
             this.getCommitFee()
         ]);
         return {
             enoughBalance: balance >= commitFee,
-            balance: toTokenAmount(balance, this.wrapper.getNativeToken(), this.wrapper.prices),
-            required: toTokenAmount(commitFee, this.wrapper.getNativeToken(), this.wrapper.prices)
+            balance: toTokenAmount(balance, this.wrapper._getNativeToken(), this.wrapper._prices),
+            required: toTokenAmount(commitFee, this.wrapper._getNativeToken(), this.wrapper._prices)
         };
     }
 
@@ -334,7 +458,7 @@ export abstract class IToBTCSwap<
      * @param options Optional options for the swap like feeRate, AbortSignal, and timeouts/intervals
      *
      * @returns {boolean} Whether the swap was successfully processed by the LP, in case `false` is returned
-     *  the user can refund their funds back on the source chain by calling `swap.refund()`
+     *  the user can refund their funds back on the source chain by calling {@link refund}
      */
     async execute(
         signer: T["Signer"] | T["NativeSigner"],
@@ -349,20 +473,20 @@ export abstract class IToBTCSwap<
             maxWaitTillSwapProcessedSeconds?: number
         }
     ): Promise<boolean> {
-        if(this.state===ToBTCSwapState.QUOTE_EXPIRED || this.state===ToBTCSwapState.QUOTE_SOFT_EXPIRED) throw new Error("Quote expired");
-        if(this.state===ToBTCSwapState.REFUNDED) throw new Error("Swap already refunded");
-        if(this.state===ToBTCSwapState.REFUNDABLE) throw new Error("Swap refundable, refund with swap.refund()");
-        if(this.state===ToBTCSwapState.SOFT_CLAIMED || this.state===ToBTCSwapState.CLAIMED) throw new Error("Swap already settled!");
+        if(this._state===ToBTCSwapState.QUOTE_EXPIRED || this._state===ToBTCSwapState.QUOTE_SOFT_EXPIRED) throw new Error("Quote expired");
+        if(this._state===ToBTCSwapState.REFUNDED) throw new Error("Swap already refunded");
+        if(this._state===ToBTCSwapState.REFUNDABLE) throw new Error("Swap refundable, refund with swap.refund()");
+        if(this._state===ToBTCSwapState.SOFT_CLAIMED || this._state===ToBTCSwapState.CLAIMED) throw new Error("Swap already settled!");
 
-        if(this.state===ToBTCSwapState.CREATED) {
+        if(this._state===ToBTCSwapState.CREATED) {
             const txId = await this.commit(signer, options?.abortSignal, false, callbacks?.onSourceTransactionSent);
             if(callbacks?.onSourceTransactionConfirmed!=null) callbacks.onSourceTransactionConfirmed(txId);
         }
 
         // @ts-ignore
-        if(this.state===ToBTCSwapState.CLAIMED || this.state===ToBTCSwapState.SOFT_CLAIMED) return true;
+        if(this._state===ToBTCSwapState.CLAIMED || this._state===ToBTCSwapState.SOFT_CLAIMED) return true;
 
-        if(this.state===ToBTCSwapState.COMMITED) {
+        if(this._state===ToBTCSwapState.COMMITED) {
             const success = await this.waitForPayment(options?.maxWaitTillSwapProcessedSeconds ?? 120, options?.paymentCheckIntervalSeconds, options?.abortSignal);
             if(success) {
                 if(callbacks?.onSwapSettled!=null) callbacks.onSwapSettled(this.getOutputTxId()!);
@@ -375,10 +499,17 @@ export abstract class IToBTCSwap<
         throw new Error("Unexpected state reached!");
     }
 
+    /**
+     * @inheritDoc
+     * @param options.skipChecks Skip checks like making sure init signature is still valid and swap wasn't commited yet
+     *  (this is handled on swap creation, if you commit right after quoting, you can use `skipChecks=true`)
+     */
     async txsExecute(options?: {
         skipChecks?: boolean
-    }) {
-        if(this.state!==ToBTCSwapState.CREATED) throw new Error("Invalid swap state, needs to be CREATED!");
+    }): Promise<[
+        SwapExecutionActionCommit<T>
+    ]> {
+        if(this._state!==ToBTCSwapState.CREATED) throw new Error("Invalid swap state, needs to be CREATED!");
         const txsCommit = await this.txsCommit(options?.skipChecks);
         return [
             {
@@ -395,15 +526,12 @@ export abstract class IToBTCSwap<
     //// Commit
 
     /**
-     * Returns transactions for committing the swap on-chain, initiating the swap
-     *
-     * @param skipChecks Skip checks like making sure init signature is still valid and swap wasn't commited yet
-     *  (this is handled on swap creation, if you commit right after quoting, you can use skipChecks=true)
+     * @inheritDoc
      *
-     * @throws {Error} When in invalid state (not PR_CREATED)
+     * @throws {Error} When in invalid state (not {@link ToBTCSwapState.CREATED})
      */
     async txsCommit(skipChecks?: boolean): Promise<T["TX"][]> {
-        if(this.state!==ToBTCSwapState.CREATED) throw new Error("Must be in CREATED state!");
+        if(this._state!==ToBTCSwapState.CREATED) throw new Error("Must be in CREATED state!");
         if(this.signatureData==null) throw new Error("Init signature data not known, cannot commit!");
 
         if(!this.initiated) {
@@ -411,27 +539,22 @@ export abstract class IToBTCSwap<
             await this._saveAndEmit();
         }
 
-        return await this.wrapper.contract.txsInit(
-            this._getInitiator(), this.data, this.signatureData, skipChecks, this.feeRate
+        return await this.wrapper._contract.txsInit(
+            this._getInitiator(), this._data, this.signatureData, skipChecks, this.feeRate
         ).catch(e => Promise.reject(e instanceof SignatureVerificationError ? new Error("Request timed out") : e));
     }
 
     /**
-     * Commits the swap on-chain, initiating the swap
+     * @inheritDoc
      *
-     * @param _signer Signer to sign the transactions with, must be the same as used in the initialization
-     * @param abortSignal Abort signal
-     * @param skipChecks Skip checks like making sure init signature is still valid and swap wasn't commited yet
-     *  (this is handled on swap creation, if you commit right after quoting, you can skipChecks)`
-     * @param onBeforeTxSent
      * @throws {Error} If invalid signer is provided that doesn't match the swap data
      */
     async commit(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, skipChecks?: boolean, onBeforeTxSent?: (txId: string) => void): Promise<string> {
-        const signer = isAbstractSigner(_signer) ? _signer : await this.wrapper.chain.wrapSigner(_signer);
+        const signer = isAbstractSigner(_signer) ? _signer : await this.wrapper._chain.wrapSigner(_signer);
         this.checkSigner(signer);
         const txs = await this.txsCommit(skipChecks);
         let txCount = 0;
-        const result = await this.wrapper.chain.sendAndConfirm(
+        const result = await this.wrapper._chain.sendAndConfirm(
             signer, txs, true, abortSignal, false, (txId, rawTx) => {
                 txCount++;
                 if(onBeforeTxSent!=null && txCount===txs.length) onBeforeTxSent(txId);
@@ -439,22 +562,21 @@ export abstract class IToBTCSwap<
             }
         );
 
-        this.commitTxId = result[result.length-1];
-        if(this.state===ToBTCSwapState.CREATED || this.state===ToBTCSwapState.QUOTE_SOFT_EXPIRED || this.state===ToBTCSwapState.QUOTE_EXPIRED) {
+        this._commitTxId = result[result.length-1];
+        if(this._state===ToBTCSwapState.CREATED || this._state===ToBTCSwapState.QUOTE_SOFT_EXPIRED || this._state===ToBTCSwapState.QUOTE_EXPIRED) {
             await this._saveAndEmit(ToBTCSwapState.COMMITED);
         }
-        return this.commitTxId;
+        return this._commitTxId;
     }
 
     /**
-     * Waits till a swap is committed, should be called after sending the commit transactions manually
+     * @inheritDoc
      *
-     * @param abortSignal   AbortSignal
-     * @throws {Error} If swap is not in the correct state (must be CREATED)
+     * @throws {Error} If swap is not in the correct state (must be {@link ToBTCSwapState.CREATED})
      */
     async waitTillCommited(abortSignal?: AbortSignal): Promise<void> {
-        if(this.state===ToBTCSwapState.COMMITED || this.state===ToBTCSwapState.CLAIMED) return Promise.resolve();
-        if(this.state!==ToBTCSwapState.CREATED && this.state!==ToBTCSwapState.QUOTE_SOFT_EXPIRED) throw new Error("Invalid state (not CREATED)");
+        if(this._state===ToBTCSwapState.COMMITED || this._state===ToBTCSwapState.CLAIMED) return Promise.resolve();
+        if(this._state!==ToBTCSwapState.CREATED && this._state!==ToBTCSwapState.QUOTE_SOFT_EXPIRED) throw new Error("Invalid state (not CREATED)");
 
         const abortController = extendAbortController(abortSignal);
         let result: number | boolean;
@@ -473,13 +595,13 @@ export abstract class IToBTCSwap<
         if(result===true) this.logger.debug("waitTillCommited(): Resolved from watchdog - commited");
         if(result===false) {
             this.logger.debug("waitTillCommited(): Resolved from watchdog - signature expiry");
-            if(this.state===ToBTCSwapState.QUOTE_SOFT_EXPIRED || this.state===ToBTCSwapState.CREATED) {
+            if(this._state===ToBTCSwapState.QUOTE_SOFT_EXPIRED || this._state===ToBTCSwapState.CREATED) {
                 await this._saveAndEmit(ToBTCSwapState.QUOTE_EXPIRED);
             }
             throw new Error("Quote expired while waiting for transaction confirmation!");
         }
 
-        if(this.state===ToBTCSwapState.QUOTE_SOFT_EXPIRED || this.state===ToBTCSwapState.CREATED || this.state===ToBTCSwapState.QUOTE_EXPIRED) {
+        if(this._state===ToBTCSwapState.QUOTE_SOFT_EXPIRED || this._state===ToBTCSwapState.CREATED || this._state===ToBTCSwapState.QUOTE_EXPIRED) {
             await this._saveAndEmit(ToBTCSwapState.COMMITED);
         }
     }
@@ -488,6 +610,13 @@ export abstract class IToBTCSwap<
     //////////////////////////////
     //// Payment
 
+    /**
+     * Waits till the swap is processed by the intermediary (LP)
+     *
+     * @param checkIntervalSeconds How often to poll the intermediary for status (5 seconds default)
+     * @param abortSignal Abort signal
+     * @internal
+     */
     protected async waitTillIntermediarySwapProcessed(
         checkIntervalSeconds?: number,
         abortSignal?: AbortSignal
@@ -498,11 +627,11 @@ export abstract class IToBTCSwap<
         while(!abortSignal?.aborted && (
             resp.code===RefundAuthorizationResponseCodes.PENDING || resp.code===RefundAuthorizationResponseCodes.NOT_FOUND
         )) {
-            resp = await IntermediaryAPI.getRefundAuthorization(this.url, this.getLpIdentifier(), this.data.getSequence());
+            resp = await IntermediaryAPI.getRefundAuthorization(this.url, this.getLpIdentifier(), this._data.getSequence());
             if(resp.code===RefundAuthorizationResponseCodes.PAID) {
                 const validResponse = await this._setPaymentResult(resp.data, true);
                 if(validResponse) {
-                    if(this.state===ToBTCSwapState.COMMITED || this.state===ToBTCSwapState.REFUNDABLE) {
+                    if(this._state===ToBTCSwapState.COMMITED || this._state===ToBTCSwapState.REFUNDABLE) {
                         await this._saveAndEmit(ToBTCSwapState.SOFT_CLAIMED);
                     }
                 } else {
@@ -523,25 +652,26 @@ export abstract class IToBTCSwap<
      *  refund.
      *
      * @param save whether to save the data
-     * @returns true if swap is processed, false if the swap is still ongoing
-     * @private
+     * @returns `true` if swap is processed, `false` if the swap is still ongoing
+     *
+     * @internal
      */
     protected async checkIntermediarySwapProcessed(save: boolean = true): Promise<boolean> {
-        if(this.state===ToBTCSwapState.CREATED || this.state==ToBTCSwapState.QUOTE_EXPIRED || this.url==null) return false;
+        if(this._state===ToBTCSwapState.CREATED || this._state==ToBTCSwapState.QUOTE_EXPIRED || this.url==null) return false;
         if(this.isFinished() || this.isRefundable()) return true;
         //Check if that maybe already concluded according to the LP
-        const resp = await IntermediaryAPI.getRefundAuthorization(this.url, this.getLpIdentifier(), this.data.getSequence());
+        const resp = await IntermediaryAPI.getRefundAuthorization(this.url, this.getLpIdentifier(), this._data.getSequence());
         switch(resp.code) {
             case RefundAuthorizationResponseCodes.PAID:
                 const processed = await this._setPaymentResult(resp.data, true);
                 if(processed) {
-                    this.state = ToBTCSwapState.SOFT_CLAIMED;
+                    this._state = ToBTCSwapState.SOFT_CLAIMED;
                     if(save) await this._saveAndEmit();
                 }
                 return processed;
             case RefundAuthorizationResponseCodes.REFUND_DATA:
-                await this.wrapper.contract.isValidRefundAuthorization(this.data, resp.data);
-                this.state = ToBTCSwapState.REFUNDABLE;
+                await this.wrapper._contract.isValidRefundAuthorization(this._data, resp.data);
+                this._state = ToBTCSwapState.REFUNDABLE;
                 if(save) await this._saveAndEmit();
                 return true;
             default:
@@ -550,22 +680,23 @@ export abstract class IToBTCSwap<
     }
 
     /**
-     * A blocking promise resolving when swap was concluded by the intermediary,
+     * A blocking promise resolving when swap was concluded by the intermediary (LP),
      *  rejecting in case of failure
      *
      * @param maxWaitTimeSeconds Maximum time in seconds to wait for the swap to be settled, an error is thrown if the
      *  swap is taking too long to claim
-     * @param checkIntervalSeconds  How often to poll the intermediary for answer
-     * @param abortSignal           Abort signal
-     * @returns {Promise<boolean>}  Was the payment successful? If not we can refund.
+     * @param checkIntervalSeconds How often to poll the intermediary for answer
+     * @param abortSignal Abort signal
+     * @returns `true` if swap was successful, `false` if swap failed and we can refund
+     *
      * @throws {IntermediaryError} If a swap is determined expired by the intermediary, but it is actually still valid
      * @throws {SignatureVerificationError} If the swap should be cooperatively refundable but the intermediary returned
      *  invalid refund signature
-     * @throws {Error} When swap expires or if the swap has invalid state (must be COMMITED)
+     * @throws {Error} When swap expires or if the swap has invalid state (must be {@link ToBTCSwapState.COMMITED})
      */
     async waitForPayment(maxWaitTimeSeconds?: number, checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<boolean> {
-        if(this.state===ToBTCSwapState.CLAIMED) return Promise.resolve(true);
-        if(this.state!==ToBTCSwapState.COMMITED && this.state!==ToBTCSwapState.SOFT_CLAIMED) throw new Error("Invalid state (not COMMITED)");
+        if(this._state===ToBTCSwapState.CLAIMED) return Promise.resolve(true);
+        if(this._state!==ToBTCSwapState.COMMITED && this._state!==ToBTCSwapState.SOFT_CLAIMED) throw new Error("Invalid state (not COMMITED)");
 
         const abortController = extendAbortController(abortSignal);
 
@@ -589,13 +720,13 @@ export abstract class IToBTCSwap<
             abortController.abort();
             if(timedOut) {
                 throw new Error("Timed out while waiting for LP to process the swap, the LP might be unresponsive or offline!" +
-                    ` Please check later or wait till ${new Date(Number(this.data.getExpiry())*1000).toLocaleString()} to refund unilaterally!`);
+                    ` Please check later or wait till ${new Date(Number(this._data.getExpiry())*1000).toLocaleString()} to refund unilaterally!`);
             }
             throw e;
         }
 
         if(typeof result !== "object") {
-            if((this.state as ToBTCSwapState)===ToBTCSwapState.REFUNDABLE) throw new Error("Swap expired");
+            if((this._state as ToBTCSwapState)===ToBTCSwapState.REFUNDABLE) throw new Error("Swap expired");
             this.logger.debug("waitTillRefunded(): Resolved from state change");
             return true;
         }
@@ -606,17 +737,17 @@ export abstract class IToBTCSwap<
                 return true;
             case RefundAuthorizationResponseCodes.REFUND_DATA:
                 const resultData = result.data;
-                await this.wrapper.contract.isValidRefundAuthorization(
-                    this.data,
+                await this.wrapper._contract.isValidRefundAuthorization(
+                    this._data,
                     resultData
                 );
                 await this._saveAndEmit(ToBTCSwapState.REFUNDABLE);
                 return false;
             case RefundAuthorizationResponseCodes.EXPIRED:
-                if(await this.wrapper.contract.isExpired(this._getInitiator(), this.data)) throw new Error("Swap expired");
+                if(await this.wrapper._contract.isExpired(this._getInitiator(), this._data)) throw new Error("Swap expired");
                 throw new IntermediaryError("Swap expired");
             case RefundAuthorizationResponseCodes.NOT_FOUND:
-                if((this.state as ToBTCSwapState)===ToBTCSwapState.CLAIMED) return true;
+                if((this._state as ToBTCSwapState)===ToBTCSwapState.CLAIMED) return true;
                 throw new Error("LP swap not found");
         }
 
@@ -630,12 +761,17 @@ export abstract class IToBTCSwap<
     /**
      * Get the estimated smart chain transaction fee of the refund transaction
      */
-    getRefundFee(): Promise<bigint> {
-        return this.wrapper.contract.getRefundFee(this._getInitiator(), this.data);
+    async getRefundNetworkFee(): Promise<TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>> {
+        const swapContract: T["Contract"] = this.wrapper._contract;
+        return toTokenAmount(
+            await swapContract.getRefundFee(this._getInitiator(), this._data),
+            this.wrapper._getNativeToken(),
+            this.wrapper._prices
+        );
     }
 
     /**
-     * Returns transactions for refunding the swap if the swap is in refundable state, you can check so with isRefundable()
+     * @inheritDoc
      *
      * @throws {IntermediaryError} If intermediary returns invalid response in case cooperative refund should be used
      * @throws {SignatureVerificationError} If intermediary returned invalid cooperative refund signature
@@ -646,15 +782,15 @@ export abstract class IToBTCSwap<
 
         signer ??= this._getInitiator();
 
-        if(await this.wrapper.contract.isExpired(this._getInitiator(), this.data)) {
-            return await this.wrapper.contract.txsRefund(signer, this.data, true, true);
+        if(await this.wrapper._contract.isExpired(this._getInitiator(), this._data)) {
+            return await this.wrapper._contract.txsRefund(signer, this._data, true, true);
         } else {
             if(this.url==null) throw new Error("LP URL not known, cannot get cooperative refund message, wait till expiry to refund!");
-            const res = await IntermediaryAPI.getRefundAuthorization(this.url, this.getLpIdentifier(), this.data.getSequence());
+            const res = await IntermediaryAPI.getRefundAuthorization(this.url, this.getLpIdentifier(), this._data.getSequence());
             if(res.code===RefundAuthorizationResponseCodes.REFUND_DATA) {
-                return await this.wrapper.contract.txsRefundWithAuthorization(
+                return await this.wrapper._contract.txsRefundWithAuthorization(
                     signer,
-                    this.data,
+                    this._data,
                     res.data,
                     true,
                     true
@@ -665,33 +801,35 @@ export abstract class IToBTCSwap<
     }
 
     /**
-     * Refunds the swap if the swap is in refundable state, you can check so with isRefundable()
+     * @inheritDoc
      *
-     * @param _signer Signer to sign the transactions with, must be the same as used in the initialization
-     * @param abortSignal               Abort signal
      * @throws {Error} If invalid signer is provided that doesn't match the swap data
      */
     async refund(_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.txsRefund(signer.getAddress()), true, abortSignal)
+        const signer = isAbstractSigner(_signer) ? _signer : await this.wrapper._chain.wrapSigner(_signer);
+        const result = await this.wrapper._chain.sendAndConfirm(signer, await this.txsRefund(signer.getAddress()), true, abortSignal)
 
-        this.refundTxId = result[0];
-        if(this.state===ToBTCSwapState.COMMITED || this.state===ToBTCSwapState.REFUNDABLE || this.state===ToBTCSwapState.SOFT_CLAIMED) {
+        this._refundTxId = result[0];
+        if(this._state===ToBTCSwapState.COMMITED || this._state===ToBTCSwapState.REFUNDABLE || this._state===ToBTCSwapState.SOFT_CLAIMED) {
             await this._saveAndEmit(ToBTCSwapState.REFUNDED);
         }
         return result[0];
     }
 
     /**
-     * Waits till a swap is refunded, should be called after sending the refund transactions manually
+     * @inheritDoc
      *
-     * @param abortSignal   AbortSignal
-     * @throws {Error} When swap is not in a valid state (must be COMMITED)
+     * @throws {Error} When swap is not in a valid state (must be {@link ToBTCSwapState.COMMITED} or
+     *  {@link ToBTCSwapState.REFUNDABLE})
      * @throws {Error} If we tried to refund but claimer was able to claim first
      */
     async waitTillRefunded(abortSignal?: AbortSignal): Promise<void> {
-        if(this.state===ToBTCSwapState.REFUNDED) return Promise.resolve();
-        if(this.state!==ToBTCSwapState.COMMITED && this.state!==ToBTCSwapState.SOFT_CLAIMED) throw new Error("Invalid state (not COMMITED)");
+        if(this._state===ToBTCSwapState.REFUNDED) return Promise.resolve();
+        if(
+            this._state!==ToBTCSwapState.COMMITED &&
+            this._state!==ToBTCSwapState.SOFT_CLAIMED &&
+            this._state!==ToBTCSwapState.REFUNDABLE
+        ) throw new Error("Invalid state (not COMMITED)");
 
         const abortController = new AbortController();
         if(abortSignal!=null) abortSignal.addEventListener("abort", () => abortController.abort(abortSignal.reason));
@@ -713,12 +851,12 @@ export abstract class IToBTCSwap<
         this.logger.debug("waitTillRefunded(): Resolved from watchdog");
 
         if(res?.type===SwapCommitStateType.PAID) {
-            if(this.claimTxId==null) this.claimTxId = await res.getClaimTxId();
+            if(this._claimTxId==null) this._claimTxId = await res.getClaimTxId();
             await this._saveAndEmit(ToBTCSwapState.CLAIMED);
             throw new Error("Tried to refund swap, but claimer claimed it in the meantime!");
         }
         if(res?.type===SwapCommitStateType.NOT_COMMITED) {
-            if(this.refundTxId==null && res.getRefundTxId!=null) this.refundTxId = await res.getRefundTxId();
+            if(this._refundTxId==null && res.getRefundTxId!=null) this._refundTxId = await res.getRefundTxId();
             await this._saveAndEmit(ToBTCSwapState.REFUNDED);
         }
     }
@@ -727,6 +865,9 @@ export abstract class IToBTCSwap<
     //////////////////////////////
     //// Storage
 
+    /**
+     * @inheritDoc
+     */
     serialize(): any {
         const obj = super.serialize();
         return {
@@ -748,55 +889,24 @@ export abstract class IToBTCSwap<
      */
     private async syncStateFromChain(quoteDefinitelyExpired?: boolean, commitStatus?: SwapCommitState): Promise<boolean> {
         if(
-            this.state===ToBTCSwapState.CREATED ||
-            this.state===ToBTCSwapState.QUOTE_SOFT_EXPIRED ||
-            this.state===ToBTCSwapState.COMMITED ||
-            this.state===ToBTCSwapState.SOFT_CLAIMED ||
-            this.state===ToBTCSwapState.REFUNDABLE
+            this._state===ToBTCSwapState.CREATED ||
+            this._state===ToBTCSwapState.QUOTE_SOFT_EXPIRED ||
+            this._state===ToBTCSwapState.COMMITED ||
+            this._state===ToBTCSwapState.SOFT_CLAIMED ||
+            this._state===ToBTCSwapState.REFUNDABLE
         ) {
             let quoteExpired = false;
-            if(this.state===ToBTCSwapState.CREATED || this.state===ToBTCSwapState.QUOTE_SOFT_EXPIRED) {
+            if(this._state===ToBTCSwapState.CREATED || this._state===ToBTCSwapState.QUOTE_SOFT_EXPIRED) {
                 //Check if quote is still valid
                 quoteExpired = quoteDefinitelyExpired ?? await this._verifyQuoteDefinitelyExpired();
             }
 
-            commitStatus ??= await this.wrapper.contract.getCommitStatus(this._getInitiator(), this.data);
-            switch(commitStatus?.type) {
-                case SwapCommitStateType.PAID:
-                    if(this.claimTxId==null && commitStatus.getClaimTxId) this.claimTxId = await commitStatus.getClaimTxId();
-                    const eventResult = await commitStatus.getClaimResult();
-                    try {
-                        await this._setPaymentResult({secret: eventResult, txId: Buffer.from(eventResult, "hex").reverse().toString("hex")});
-                    } catch (e) {
-                        this.logger.error(`Failed to set payment result ${eventResult} on the swap!`);
-                    }
-                    this.state = ToBTCSwapState.CLAIMED;
-                    return true;
-                case SwapCommitStateType.REFUNDABLE:
-                    this.state = ToBTCSwapState.REFUNDABLE;
-                    return true;
-                case SwapCommitStateType.EXPIRED:
-                    if(this.refundTxId==null && commitStatus.getRefundTxId) this.refundTxId = await commitStatus.getRefundTxId();
-                    this.state = ToBTCSwapState.QUOTE_EXPIRED;
-                    return true;
-                case SwapCommitStateType.NOT_COMMITED:
-                    if(this.refundTxId==null && commitStatus.getRefundTxId) this.refundTxId = await commitStatus.getRefundTxId();
-                    if(this.state===ToBTCSwapState.COMMITED || this.state===ToBTCSwapState.REFUNDABLE) {
-                        this.state = ToBTCSwapState.REFUNDED;
-                        return true;
-                    }
-                    break;
-                case SwapCommitStateType.COMMITED:
-                    if(this.state!==ToBTCSwapState.COMMITED && this.state!==ToBTCSwapState.REFUNDABLE) {
-                        this.state = ToBTCSwapState.COMMITED;
-                        return true;
-                    }
-                    break;
-            }
+            commitStatus ??= await this.wrapper._contract.getCommitStatus(this._getInitiator(), this._data);
+            if(commitStatus!=null && await this._forciblySetOnchainState(commitStatus)) return true;
 
-            if((this.state===ToBTCSwapState.CREATED || this.state===ToBTCSwapState.QUOTE_SOFT_EXPIRED)) {
+            if((this._state===ToBTCSwapState.CREATED || this._state===ToBTCSwapState.QUOTE_SOFT_EXPIRED)) {
                 if(quoteExpired) {
-                    this.state = ToBTCSwapState.QUOTE_EXPIRED;
+                    this._state = ToBTCSwapState.QUOTE_EXPIRED;
                     return true;
                 }
             }
@@ -804,22 +914,34 @@ export abstract class IToBTCSwap<
         return false;
     }
 
-    _shouldFetchCommitStatus(): boolean {
-        return this.state===ToBTCSwapState.CREATED ||
-            this.state===ToBTCSwapState.QUOTE_SOFT_EXPIRED ||
-            this.state===ToBTCSwapState.COMMITED ||
-            this.state===ToBTCSwapState.SOFT_CLAIMED ||
-            this.state===ToBTCSwapState.REFUNDABLE;
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _shouldFetchOnchainState(): boolean {
+        return this._state===ToBTCSwapState.CREATED ||
+            this._state===ToBTCSwapState.QUOTE_SOFT_EXPIRED ||
+            this._state===ToBTCSwapState.COMMITED ||
+            this._state===ToBTCSwapState.SOFT_CLAIMED ||
+            this._state===ToBTCSwapState.REFUNDABLE;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     _shouldFetchExpiryStatus(): boolean {
-        return this.state===ToBTCSwapState.CREATED || this.state===ToBTCSwapState.QUOTE_SOFT_EXPIRED;
+        return this._state===ToBTCSwapState.CREATED || this._state===ToBTCSwapState.QUOTE_SOFT_EXPIRED;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
     async _sync(save?: boolean, quoteDefinitelyExpired?: boolean, commitStatus?: SwapCommitState): Promise<boolean> {
         let changed = await this.syncStateFromChain(quoteDefinitelyExpired, commitStatus);
 
-        if(this.state===ToBTCSwapState.COMMITED || this.state===ToBTCSwapState.SOFT_CLAIMED) {
+        if(this._state===ToBTCSwapState.COMMITED || this._state===ToBTCSwapState.SOFT_CLAIMED) {
             //Check if that maybe already concluded
             try {
                 if(await this.checkIntermediarySwapProcessed(false)) changed = true;
@@ -833,20 +955,64 @@ export abstract class IToBTCSwap<
         return changed;
     }
 
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    async _forciblySetOnchainState(commitStatus: SwapCommitState): Promise<boolean> {
+        switch(commitStatus.type) {
+            case SwapCommitStateType.PAID:
+                if(this._claimTxId==null && commitStatus.getClaimTxId) this._claimTxId = await commitStatus.getClaimTxId();
+                const eventResult = await commitStatus.getClaimResult();
+                try {
+                    await this._setPaymentResult({secret: eventResult, txId: Buffer.from(eventResult, "hex").reverse().toString("hex")});
+                } catch (e) {
+                    this.logger.error(`Failed to set payment result ${eventResult} on the swap!`);
+                }
+                this._state = ToBTCSwapState.CLAIMED;
+                return true;
+            case SwapCommitStateType.REFUNDABLE:
+                this._state = ToBTCSwapState.REFUNDABLE;
+                return true;
+            case SwapCommitStateType.EXPIRED:
+                if(this._refundTxId==null && commitStatus.getRefundTxId) this._refundTxId = await commitStatus.getRefundTxId();
+                this._state = this._refundTxId==null ? ToBTCSwapState.QUOTE_EXPIRED : ToBTCSwapState.REFUNDED;
+                return true;
+            case SwapCommitStateType.NOT_COMMITED:
+                if(this._refundTxId==null && commitStatus.getRefundTxId) this._refundTxId = await commitStatus.getRefundTxId();
+                if(this._refundTxId!=null) {
+                    this._state = ToBTCSwapState.REFUNDED;
+                    return true;
+                }
+                break;
+            case SwapCommitStateType.COMMITED:
+                if(this._state!==ToBTCSwapState.COMMITED && this._state!==ToBTCSwapState.REFUNDABLE && this._state!==ToBTCSwapState.SOFT_CLAIMED) {
+                    this._state = ToBTCSwapState.COMMITED;
+                    return true;
+                }
+                break;
+        }
+        return false;
+    }
+
+    /**
+     * @inheritDoc
+     * @internal
+     */
     async _tick(save?: boolean): Promise<boolean> {
-        switch(this.state) {
+        switch(this._state) {
             case ToBTCSwapState.CREATED:
                 if(this.expiry<Date.now()) {
-                    this.state = ToBTCSwapState.QUOTE_SOFT_EXPIRED;
+                    this._state = ToBTCSwapState.QUOTE_SOFT_EXPIRED;
                     if(save) await this._saveAndEmit();
                     return true;
                 }
                 break;
             case ToBTCSwapState.COMMITED:
             case ToBTCSwapState.SOFT_CLAIMED:
-                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 = ToBTCSwapState.REFUNDABLE;
+                    this._state = ToBTCSwapState.REFUNDABLE;
                     if(save) await this._saveAndEmit();
                     return true;
                 }
@@ -854,15 +1020,4 @@ export abstract class IToBTCSwap<
         }
         return false;
     }
-}
-
-export enum ToBTCSwapState {
-    REFUNDED = -3,
-    QUOTE_EXPIRED = -2,
-    QUOTE_SOFT_EXPIRED = -1,
-    CREATED = 0,
-    COMMITED = 1,
-    SOFT_CLAIMED = 2,
-    CLAIMED = 3,
-    REFUNDABLE = 4
-}
+}