@atomiqlabs/sdk 8.1.8 → 8.3.5

package/dist/swaps/escrow_swaps/tobtc/IToBTCSwap.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToBTCSwapState = exports.IToBTCSwap = exports.isIToBTCSwapInit = void 0;
+exports.IToBTCSwap = exports.ToBTCSwapState = exports.isIToBTCSwapInit = void 0;
 const base_1 = require("@atomiqlabs/base");
 const IntermediaryAPI_1 = require("../../../intermediaries/apis/IntermediaryAPI");
 const IntermediaryError_1 = require("../../../errors/IntermediaryError");
@@ -21,14 +21,66 @@ function isIToBTCSwapInit(obj) {
         (0, IEscrowSelfInitSwap_1.isIEscrowSelfInitSwapInit)(obj);
 }
 exports.isIToBTCSwapInit = isIToBTCSwapInit;
+/**
+ * State enum for escrow-based Smart chain -> Bitcoin (on-chain & lightning) swaps
+ *
+ * @category Swaps/Smart chain → Bitcoin
+ */
+var ToBTCSwapState;
+(function (ToBTCSwapState) {
+    /**
+     * Intermediary (LP) was unable to process the swap and the funds were refunded on the
+     *  source chain
+     */
+    ToBTCSwapState[ToBTCSwapState["REFUNDED"] = -3] = "REFUNDED";
+    /**
+     * Swap has expired for good and there is no way how it can be executed anymore
+     */
+    ToBTCSwapState[ToBTCSwapState["QUOTE_EXPIRED"] = -2] = "QUOTE_EXPIRED";
+    /**
+     * 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
+     */
+    ToBTCSwapState[ToBTCSwapState["QUOTE_SOFT_EXPIRED"] = -1] = "QUOTE_SOFT_EXPIRED";
+    /**
+     * Swap was created, use the {@link IToBTCSwap.commit} or {@link IToBTCSwap.txsCommit} to
+     *  initiate it by creating the swap escrow on the source chain
+     */
+    ToBTCSwapState[ToBTCSwapState["CREATED"] = 0] = "CREATED";
+    /**
+     * 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.
+     */
+    ToBTCSwapState[ToBTCSwapState["COMMITED"] = 1] = "COMMITED";
+    /**
+     * 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.
+     */
+    ToBTCSwapState[ToBTCSwapState["SOFT_CLAIMED"] = 2] = "SOFT_CLAIMED";
+    /**
+     * Swap was successfully settled by the intermediary (LP) on the source chain
+     */
+    ToBTCSwapState[ToBTCSwapState["CLAIMED"] = 3] = "CLAIMED";
+    /**
+     * 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
+     */
+    ToBTCSwapState[ToBTCSwapState["REFUNDABLE"] = 4] = "REFUNDABLE";
+})(ToBTCSwapState = exports.ToBTCSwapState || (exports.ToBTCSwapState = {}));
+/**
+ * Base class for escrow-based Smart chain -> Bitcoin (on-chain & lightning) swaps
+ *
+ * @category Swaps/Smart chain → Bitcoin
+ */
 class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
     constructor(wrapper, initOrObject) {
         super(wrapper, initOrObject);
         if (isIToBTCSwapInit(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 {
@@ -36,37 +88,45 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
             this.networkFeeBtc = (0, Utils_1.toBigInt)(initOrObject.networkFeeBtc);
         }
     }
+    /**
+     * @inheritDoc
+     * @internal
+     */
     getSwapData() {
-        return this.data;
+        return this._data;
     }
+    /**
+     * @inheritDoc
+     * @internal
+     */
     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;
         }
     }
     /**
-     * In case swapFee in BTC is not supplied it recalculates it based on swap price
-     * @protected
+     * @inheritDoc
+     * @internal
      */
     tryRecomputeSwapPrice() {
         const output = this.getOutput();
@@ -82,91 +142,131 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
     }
     /**
      * Returns the payment hash identifier to be sent to the LP for getStatus and getRefund
-     * @protected
+     * @internal
      */
     getLpIdentifier() {
         return this.getClaimHash();
     }
     //////////////////////////////
     //// Getters & utils
+    /**
+     * @inheritDoc
+     */
     getInputAddress() {
         return this._getInitiator();
     }
+    /**
+     * @inheritDoc
+     */
     getInputTxId() {
-        return this.commitTxId ?? null;
+        return this._commitTxId ?? null;
     }
+    /**
+     * @inheritDoc
+     */
     requiresAction() {
         return this.isRefundable();
     }
     /**
-     * Returns whether the swap is finished and in its terminal state (this can mean successful, refunded or failed)
+     * @inheritDoc
      */
     isFinished() {
-        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() {
-        return this.state === ToBTCSwapState.REFUNDABLE;
+        return this._state === ToBTCSwapState.REFUNDABLE;
     }
+    /**
+     * @inheritDoc
+     */
     isQuoteExpired() {
-        return this.state === ToBTCSwapState.QUOTE_EXPIRED;
+        return this._state === ToBTCSwapState.QUOTE_EXPIRED;
     }
+    /**
+     * @inheritDoc
+     */
     isQuoteSoftExpired() {
-        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() {
-        return this.state === ToBTCSwapState.CLAIMED;
+        return this._state === ToBTCSwapState.CLAIMED;
     }
+    /**
+     * @inheritDoc
+     */
     isFailed() {
-        return this.state === ToBTCSwapState.REFUNDED;
+        return this._state === ToBTCSwapState.REFUNDED;
     }
+    /**
+     * @inheritDoc
+     * @internal
+     */
     _getInitiator() {
-        return this.data.getOfferer();
+        return this._data.getOfferer();
     }
     //////////////////////////////
     //// Amounts & fees
+    /**
+     * Returns the swap fee charged by the intermediary (LP) on this swap
+     *
+     * @internal
+     */
     getSwapFee() {
         if (this.pricingInfo == null)
             throw new Error("No pricing info known, cannot estimate fee!");
         const feeWithoutBaseFee = this.swapFeeBtc - this.pricingInfo.satsBaseFee;
         const output = this.getOutput();
         const swapFeePPM = output.rawAmount == null ? 0n : feeWithoutBaseFee * 1000000n / output.rawAmount;
-        const amountInDstToken = (0, TokenAmount_1.toTokenAmount)(this.swapFeeBtc, this.outputToken, this.wrapper.prices, this.pricingInfo);
+        const amountInDstToken = (0, TokenAmount_1.toTokenAmount)(this.swapFeeBtc, this.outputToken, this.wrapper._prices, this.pricingInfo);
         return {
-            amountInSrcToken: (0, TokenAmount_1.toTokenAmount)(this.swapFee, this.wrapper.tokens[this.data.getToken()], this.wrapper.prices, this.pricingInfo),
+            amountInSrcToken: (0, TokenAmount_1.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: (0, TokenAmount_1.toTokenAmount)(this.pricingInfo.satsBaseFee, this.outputToken, this.wrapper.prices, this.pricingInfo),
+                base: (0, TokenAmount_1.toTokenAmount)(this.pricingInfo.satsBaseFee, this.outputToken, this.wrapper._prices, this.pricingInfo),
                 percentage: (0, PercentagePPM_1.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
      */
     getNetworkFee() {
-        const amountInDstToken = (0, TokenAmount_1.toTokenAmount)(this.networkFeeBtc, this.outputToken, this.wrapper.prices, this.pricingInfo);
+        const amountInDstToken = (0, TokenAmount_1.toTokenAmount)(this.networkFeeBtc, this.outputToken, this.wrapper._prices, this.pricingInfo);
         return {
-            amountInSrcToken: (0, TokenAmount_1.toTokenAmount)(this.networkFee, this.wrapper.tokens[this.data.getToken()], this.wrapper.prices, this.pricingInfo),
+            amountInSrcToken: (0, TokenAmount_1.toTokenAmount)(this.networkFee, this.wrapper._tokens[this._data.getToken()], this.wrapper._prices, this.pricingInfo),
             amountInDstToken,
             currentUsdValue: amountInDstToken.currentUsdValue,
             usdValue: amountInDstToken.usdValue,
             pastUsdValue: amountInDstToken.pastUsdValue
         };
     }
+    /**
+     * @inheritDoc
+     */
     getFee() {
-        const amountInDstToken = (0, TokenAmount_1.toTokenAmount)(this.swapFeeBtc + this.networkFeeBtc, this.outputToken, this.wrapper.prices, this.pricingInfo);
+        const amountInDstToken = (0, TokenAmount_1.toTokenAmount)(this.swapFeeBtc + this.networkFeeBtc, this.outputToken, this.wrapper._prices, this.pricingInfo);
         return {
-            amountInSrcToken: (0, TokenAmount_1.toTokenAmount)(this.swapFee + this.networkFee, this.wrapper.tokens[this.data.getToken()], this.wrapper.prices, this.pricingInfo),
+            amountInSrcToken: (0, TokenAmount_1.toTokenAmount)(this.swapFee + this.networkFee, this.wrapper._tokens[this._data.getToken()], this.wrapper._prices, this.pricingInfo),
             amountInDstToken,
             currentUsdValue: amountInDstToken.currentUsdValue,
             usdValue: amountInDstToken.usdValue,
             pastUsdValue: amountInDstToken.pastUsdValue
         };
     }
+    /**
+     * @inheritDoc
+     */
     getFeeBreakdown() {
         return [
             {
@@ -179,44 +279,54 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
             }
         ];
     }
+    /**
+     * @inheritDoc
+     */
     getInputToken() {
-        return this.wrapper.tokens[this.data.getToken()];
+        return this.wrapper._tokens[this._data.getToken()];
     }
+    /**
+     * @inheritDoc
+     */
     getInput() {
-        return (0, TokenAmount_1.toTokenAmount)(this.data.getAmount(), this.wrapper.tokens[this.data.getToken()], this.wrapper.prices, this.pricingInfo);
+        return (0, TokenAmount_1.toTokenAmount)(this._data.getAmount(), this.wrapper._tokens[this._data.getToken()], this.wrapper._prices, this.pricingInfo);
     }
+    /**
+     * @inheritDoc
+     */
     getInputWithoutFee() {
-        return (0, TokenAmount_1.toTokenAmount)(this.data.getAmount() - (this.swapFee + this.networkFee), this.wrapper.tokens[this.data.getToken()], this.wrapper.prices, this.pricingInfo);
+        return (0, TokenAmount_1.toTokenAmount)(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() {
         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: (0, TokenAmount_1.toTokenAmount)(balance, this.wrapper.tokens[this.data.getToken()], this.wrapper.prices, this.pricingInfo),
-            required: (0, TokenAmount_1.toTokenAmount)(required, this.wrapper.tokens[this.data.getToken()], this.wrapper.prices, this.pricingInfo)
+            balance: (0, TokenAmount_1.toTokenAmount)(balance, this.wrapper._tokens[this._data.getToken()], this.wrapper._prices, this.pricingInfo),
+            required: (0, TokenAmount_1.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() {
         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: (0, TokenAmount_1.toTokenAmount)(balance, this.wrapper.getNativeToken(), this.wrapper.prices),
-            required: (0, TokenAmount_1.toTokenAmount)(commitFee, this.wrapper.getNativeToken(), this.wrapper.prices)
+            balance: (0, TokenAmount_1.toTokenAmount)(balance, this.wrapper._getNativeToken(), this.wrapper._prices),
+            required: (0, TokenAmount_1.toTokenAmount)(commitFee, this.wrapper._getNativeToken(), this.wrapper._prices)
         };
     }
     //////////////////////////////
@@ -229,26 +339,26 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
      * @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, callbacks, options) {
-        if (this.state === ToBTCSwapState.QUOTE_EXPIRED || this.state === ToBTCSwapState.QUOTE_SOFT_EXPIRED)
+        if (this._state === ToBTCSwapState.QUOTE_EXPIRED || this._state === ToBTCSwapState.QUOTE_SOFT_EXPIRED)
             throw new Error("Quote expired");
-        if (this.state === ToBTCSwapState.REFUNDED)
+        if (this._state === ToBTCSwapState.REFUNDED)
             throw new Error("Swap already refunded");
-        if (this.state === ToBTCSwapState.REFUNDABLE)
+        if (this._state === ToBTCSwapState.REFUNDABLE)
             throw new Error("Swap refundable, refund with swap.refund()");
-        if (this.state === ToBTCSwapState.SOFT_CLAIMED || this.state === ToBTCSwapState.CLAIMED)
+        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)
+        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)
@@ -261,8 +371,13 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
         }
         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) {
-        if (this.state !== ToBTCSwapState.CREATED)
+        if (this._state !== ToBTCSwapState.CREATED)
             throw new Error("Invalid swap state, needs to be CREATED!");
         const txsCommit = await this.txsCommit(options?.skipChecks);
         return [
@@ -277,15 +392,12 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
     //////////////////////////////
     //// 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) {
-        if (this.state !== ToBTCSwapState.CREATED)
+        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!");
@@ -293,45 +405,39 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
             this.initiated = true;
             await this._saveAndEmit();
         }
-        return await this.wrapper.contract.txsInit(this._getInitiator(), this.data, this.signatureData, skipChecks, this.feeRate).catch(e => Promise.reject(e instanceof base_1.SignatureVerificationError ? new Error("Request timed out") : e));
+        return await this.wrapper._contract.txsInit(this._getInitiator(), this._data, this.signatureData, skipChecks, this.feeRate).catch(e => Promise.reject(e instanceof base_1.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, abortSignal, skipChecks, onBeforeTxSent) {
-        const signer = (0, base_1.isAbstractSigner)(_signer) ? _signer : await this.wrapper.chain.wrapSigner(_signer);
+        const signer = (0, base_1.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(signer, txs, true, abortSignal, false, (txId, rawTx) => {
+        const result = await this.wrapper._chain.sendAndConfirm(signer, txs, true, abortSignal, false, (txId, rawTx) => {
             txCount++;
             if (onBeforeTxSent != null && txCount === txs.length)
                 onBeforeTxSent(txId);
             return Promise.resolve();
         });
-        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) {
-        if (this.state === ToBTCSwapState.COMMITED || this.state === ToBTCSwapState.CLAIMED)
+        if (this._state === ToBTCSwapState.COMMITED || this._state === ToBTCSwapState.CLAIMED)
             return Promise.resolve();
-        if (this.state !== ToBTCSwapState.CREATED && this.state !== ToBTCSwapState.QUOTE_SOFT_EXPIRED)
+        if (this._state !== ToBTCSwapState.CREATED && this._state !== ToBTCSwapState.QUOTE_SOFT_EXPIRED)
             throw new Error("Invalid state (not CREATED)");
         const abortController = (0, Utils_1.extendAbortController)(abortSignal);
         let result;
@@ -352,28 +458,35 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
             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);
         }
     }
     //////////////////////////////
     //// 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
+     */
     async waitTillIntermediarySwapProcessed(checkIntervalSeconds, abortSignal) {
         if (this.url == null)
             throw new Error("LP URL not specified!");
         checkIntervalSeconds ??= 5;
         let resp = { code: IntermediaryAPI_1.RefundAuthorizationResponseCodes.PENDING, msg: "" };
         while (!abortSignal?.aborted && (resp.code === IntermediaryAPI_1.RefundAuthorizationResponseCodes.PENDING || resp.code === IntermediaryAPI_1.RefundAuthorizationResponseCodes.NOT_FOUND)) {
-            resp = await IntermediaryAPI_1.IntermediaryAPI.getRefundAuthorization(this.url, this.getLpIdentifier(), this.data.getSequence());
+            resp = await IntermediaryAPI_1.IntermediaryAPI.getRefundAuthorization(this.url, this.getLpIdentifier(), this._data.getSequence());
             if (resp.code === IntermediaryAPI_1.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);
                     }
                 }
@@ -393,28 +506,29 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
      *  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
      */
     async checkIntermediarySwapProcessed(save = true) {
-        if (this.state === ToBTCSwapState.CREATED || this.state == ToBTCSwapState.QUOTE_EXPIRED || this.url == null)
+        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_1.IntermediaryAPI.getRefundAuthorization(this.url, this.getLpIdentifier(), this.data.getSequence());
+        const resp = await IntermediaryAPI_1.IntermediaryAPI.getRefundAuthorization(this.url, this.getLpIdentifier(), this._data.getSequence());
         switch (resp.code) {
             case IntermediaryAPI_1.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 IntermediaryAPI_1.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;
@@ -423,23 +537,24 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
         }
     }
     /**
-     * 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, checkIntervalSeconds, abortSignal) {
-        if (this.state === ToBTCSwapState.CLAIMED)
+        if (this._state === ToBTCSwapState.CLAIMED)
             return Promise.resolve(true);
-        if (this.state !== ToBTCSwapState.COMMITED && this.state !== ToBTCSwapState.SOFT_CLAIMED)
+        if (this._state !== ToBTCSwapState.COMMITED && this._state !== ToBTCSwapState.SOFT_CLAIMED)
             throw new Error("Invalid state (not COMMITED)");
         const abortController = (0, Utils_1.extendAbortController)(abortSignal);
         let timedOut = false;
@@ -462,12 +577,12 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
             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 === ToBTCSwapState.REFUNDABLE)
+            if (this._state === ToBTCSwapState.REFUNDABLE)
                 throw new Error("Swap expired");
             this.logger.debug("waitTillRefunded(): Resolved from state change");
             return true;
@@ -478,15 +593,15 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
                 return true;
             case IntermediaryAPI_1.RefundAuthorizationResponseCodes.REFUND_DATA:
                 const resultData = result.data;
-                await this.wrapper.contract.isValidRefundAuthorization(this.data, resultData);
+                await this.wrapper._contract.isValidRefundAuthorization(this._data, resultData);
                 await this._saveAndEmit(ToBTCSwapState.REFUNDABLE);
                 return false;
             case IntermediaryAPI_1.RefundAuthorizationResponseCodes.EXPIRED:
-                if (await this.wrapper.contract.isExpired(this._getInitiator(), this.data))
+                if (await this.wrapper._contract.isExpired(this._getInitiator(), this._data))
                     throw new Error("Swap expired");
                 throw new IntermediaryError_1.IntermediaryError("Swap expired");
             case IntermediaryAPI_1.RefundAuthorizationResponseCodes.NOT_FOUND:
-                if (this.state === ToBTCSwapState.CLAIMED)
+                if (this._state === ToBTCSwapState.CLAIMED)
                     return true;
                 throw new Error("LP swap not found");
         }
@@ -497,11 +612,12 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
     /**
      * Get the estimated smart chain transaction fee of the refund transaction
      */
-    getRefundFee() {
-        return this.wrapper.contract.getRefundFee(this._getInitiator(), this.data);
+    async getRefundNetworkFee() {
+        const swapContract = this.wrapper._contract;
+        return (0, TokenAmount_1.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
@@ -511,46 +627,46 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
         if (!this.isRefundable())
             throw new Error("Must be in REFUNDABLE state or expired!");
         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_1.IntermediaryAPI.getRefundAuthorization(this.url, this.getLpIdentifier(), this.data.getSequence());
+            const res = await IntermediaryAPI_1.IntermediaryAPI.getRefundAuthorization(this.url, this.getLpIdentifier(), this._data.getSequence());
             if (res.code === IntermediaryAPI_1.RefundAuthorizationResponseCodes.REFUND_DATA) {
-                return await this.wrapper.contract.txsRefundWithAuthorization(signer, this.data, res.data, true, true);
+                return await this.wrapper._contract.txsRefundWithAuthorization(signer, this._data, res.data, true, true);
             }
             throw new IntermediaryError_1.IntermediaryError("Invalid intermediary cooperative message returned");
         }
     }
     /**
-     * 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, abortSignal) {
-        const signer = (0, base_1.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) {
+        const signer = (0, base_1.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) {
             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) {
-        if (this.state === ToBTCSwapState.REFUNDED)
+        if (this._state === ToBTCSwapState.REFUNDED)
             return Promise.resolve();
-        if (this.state !== ToBTCSwapState.COMMITED && this.state !== ToBTCSwapState.SOFT_CLAIMED)
+        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)
@@ -571,19 +687,22 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
         }
         this.logger.debug("waitTillRefunded(): Resolved from watchdog");
         if (res?.type === base_1.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 === base_1.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);
         }
     }
     //////////////////////////////
     //// Storage
+    /**
+     * @inheritDoc
+     */
     serialize() {
         const obj = super.serialize();
         return {
@@ -601,75 +720,53 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
      * @private
      */
     async syncStateFromChain(quoteDefinitelyExpired, commitStatus) {
-        if (this.state === ToBTCSwapState.CREATED ||
-            this.state === ToBTCSwapState.QUOTE_SOFT_EXPIRED ||
-            this.state === ToBTCSwapState.COMMITED ||
-            this.state === ToBTCSwapState.SOFT_CLAIMED ||
-            this.state === ToBTCSwapState.REFUNDABLE) {
+        if (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 base_1.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 base_1.SwapCommitStateType.REFUNDABLE:
-                    this.state = ToBTCSwapState.REFUNDABLE;
-                    return true;
-                case base_1.SwapCommitStateType.EXPIRED:
-                    if (this.refundTxId == null && commitStatus.getRefundTxId)
-                        this.refundTxId = await commitStatus.getRefundTxId();
-                    this.state = ToBTCSwapState.QUOTE_EXPIRED;
-                    return true;
-                case base_1.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 base_1.SwapCommitStateType.COMMITED:
-                    if (this.state !== ToBTCSwapState.COMMITED && this.state !== ToBTCSwapState.REFUNDABLE) {
-                        this.state = ToBTCSwapState.COMMITED;
-                        return true;
-                    }
-                    break;
-            }
-            if ((this.state === ToBTCSwapState.CREATED || this.state === ToBTCSwapState.QUOTE_SOFT_EXPIRED)) {
+            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 (quoteExpired) {
-                    this.state = ToBTCSwapState.QUOTE_EXPIRED;
+                    this._state = ToBTCSwapState.QUOTE_EXPIRED;
                     return true;
                 }
             }
         }
         return false;
     }
-    _shouldFetchCommitStatus() {
-        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() {
+        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() {
-        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, quoteDefinitelyExpired, commitStatus) {
         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))
@@ -683,11 +780,58 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
             await this._saveAndEmit();
         return changed;
     }
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    async _forciblySetOnchainState(commitStatus) {
+        switch (commitStatus.type) {
+            case base_1.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 base_1.SwapCommitStateType.REFUNDABLE:
+                this._state = ToBTCSwapState.REFUNDABLE;
+                return true;
+            case base_1.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 base_1.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 base_1.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) {
-        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;
@@ -695,9 +839,9 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
                 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;
@@ -708,14 +852,3 @@ class IToBTCSwap extends IEscrowSelfInitSwap_1.IEscrowSelfInitSwap {
     }
 }
 exports.IToBTCSwap = IToBTCSwap;
-var ToBTCSwapState;
-(function (ToBTCSwapState) {
-    ToBTCSwapState[ToBTCSwapState["REFUNDED"] = -3] = "REFUNDED";
-    ToBTCSwapState[ToBTCSwapState["QUOTE_EXPIRED"] = -2] = "QUOTE_EXPIRED";
-    ToBTCSwapState[ToBTCSwapState["QUOTE_SOFT_EXPIRED"] = -1] = "QUOTE_SOFT_EXPIRED";
-    ToBTCSwapState[ToBTCSwapState["CREATED"] = 0] = "CREATED";
-    ToBTCSwapState[ToBTCSwapState["COMMITED"] = 1] = "COMMITED";
-    ToBTCSwapState[ToBTCSwapState["SOFT_CLAIMED"] = 2] = "SOFT_CLAIMED";
-    ToBTCSwapState[ToBTCSwapState["CLAIMED"] = 3] = "CLAIMED";
-    ToBTCSwapState[ToBTCSwapState["REFUNDABLE"] = 4] = "REFUNDABLE";
-})(ToBTCSwapState = exports.ToBTCSwapState || (exports.ToBTCSwapState = {}));