import {IToBTCDefinition, IToBTCWrapper} from "./IToBTCWrapper";
import {
    ChainType,
    isAbstractSigner,
    SignatureData,
    SignatureVerificationError,
    SwapCommitState,
    SwapCommitStateType,
    SwapData
} from "@atomiqlabs/base";
import {
    IntermediaryAPI,
    RefundAuthorizationResponse,
    RefundAuthorizationResponseCodes
} from "../../../intermediaries/apis/IntermediaryAPI";
import {IntermediaryError} from "../../../errors/IntermediaryError";
import {extendAbortController, toBigInt} from "../../../utils/Utils";
import {Fee} from "../../../types/fees/Fee";
import {IEscrowSelfInitSwap, IEscrowSelfInitSwapInit, isIEscrowSelfInitSwapInit} from "../IEscrowSelfInitSwap";
import {IRefundableSwap} from "../../IRefundableSwap";
import {FeeType} from "../../../enums/FeeType";
import {ppmToPercentage} from "../../../types/fees/PercentagePPM";
import {TokenAmount, toTokenAmount} from "../../../types/TokenAmount";
import {BtcToken, SCToken} from "../../../types/Token";
import {timeoutPromise} from "../../../utils/TimeoutUtils";
import {SwapExecutionActionSignSmartChainTx, SwapExecutionActionWait} from "../../../types/SwapExecutionAction";
import {
    SwapExecutionStep,
    SwapExecutionStepPayment,
    SwapExecutionStepRefund,
    SwapExecutionStepSettlement
} from "../../../types/SwapExecutionStep";
import {SwapStateInfo} from "../../../types/SwapStateInfo";

export type IToBTCSwapInit<T extends SwapData> = IEscrowSelfInitSwapInit<T> & {
    signatureData?: SignatureData,
    data: T,
    networkFee: bigint,
    networkFeeBtc: bigint
};

export function isIToBTCSwapInit<T extends SwapData>(obj: any): obj is IToBTCSwapInit<T> {
    return typeof(obj.networkFee) === "bigint" &&
        typeof(obj.networkFeeBtc) === "bigint" &&
        (obj.signatureData==null || (
            typeof(obj.signatureData) === 'object' &&
            typeof(obj.signatureData.prefix)==="string" &&
            typeof(obj.signatureData.timeout)==="string" &&
            typeof(obj.signatureData.signature)==="string"
        )) &&
        typeof(obj.data) === 'object' &&
        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
}

const ToBTCSwapStateDescription = {
    [ToBTCSwapState.REFUNDED]: "Intermediary (LP) was unable to process the swap and the funds were refunded on the source chain",
    [ToBTCSwapState.QUOTE_EXPIRED]: "Swap has expired for good and there is no way how it can be executed anymore",
    [ToBTCSwapState.QUOTE_SOFT_EXPIRED]: "A swap is expired, though there is still a chance that it will be processed",
    [ToBTCSwapState.CREATED]: "Swap was created, initiate it by creating the swap escrow on the source chain",
    [ToBTCSwapState.COMMITED]: "Swap escrow was initiated (committed) on the source chain, the intermediary (LP) will now process the swap.",
    [ToBTCSwapState.SOFT_CLAIMED]: "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.CLAIMED]: "Swap was successfully settled by the intermediary (LP) on the source chain",
    [ToBTCSwapState.REFUNDABLE]: "Intermediary (LP) was unable to process the swap and the swap escrow on the source chain is refundable."
};

/**
 * 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 swapStateDescription = ToBTCSwapStateDescription;
    /**
     * @internal
     */
    protected readonly swapStateName = (state: number) => ToBTCSwapState[state];
    /**
     * @internal
     */
    protected readonly abstract outputToken: BtcToken;
    /**
     * @internal
     */
    protected readonly networkFee: bigint;
    /**
     * @internal
     */
    protected networkFeeBtc: bigint;

    /**
     * @internal
     */
    readonly _data!: T["Data"];

    protected constructor(wrapper: D["Wrapper"], serializedObject: any);
    protected constructor(wrapper: D["Wrapper"], init: IToBTCSwapInit<T["Data"]>);
    protected constructor(
        wrapper: D["Wrapper"],
        initOrObject: IToBTCSwapInit<T["Data"]> | any
    ) {
        super(wrapper, initOrObject);
        if(isIToBTCSwapInit<T["Data"]>(initOrObject)) {
            this._state = ToBTCSwapState.CREATED;
            this.networkFee = initOrObject.networkFee;
            this.networkFeeBtc = initOrObject.networkFeeBtc;
            this._data = initOrObject.data;
            this.signatureData = initOrObject.signatureData;
        } else {
            this.networkFee = toBigInt(initOrObject.networkFee);
            this.networkFeeBtc = toBigInt(initOrObject.networkFeeBtc);
        }
    }

    /**
     * @inheritDoc
     * @internal
     */
    protected getSwapData(): T["Data"] {
        return this._data;
    }

    /**
     * @inheritDoc
     * @internal
     */
    protected upgradeVersion() {
        if(this.version == null) {
            switch(this._state) {
                case -2:
                    this._state = ToBTCSwapState.REFUNDED
                    break;
                case -1:
                    this._state = ToBTCSwapState.QUOTE_EXPIRED
                    break;
                case 0:
                    this._state = ToBTCSwapState.CREATED
                    break;
                case 1:
                    this._state = ToBTCSwapState.COMMITED
                    break;
                case 2:
                    this._state = ToBTCSwapState.CLAIMED
                    break;
                case 3:
                    this._state = ToBTCSwapState.REFUNDABLE
                    break;
            }
            this.version = 1;
        }
    }

    /**
     * @inheritDoc
     * @internal
     */
    protected tryRecomputeSwapPrice() {
        const output = this.getOutput();
        if(output.rawAmount!=null) {
            if(this.swapFeeBtc==null) {
                this.swapFeeBtc = this.swapFee * output.rawAmount / this.getInputWithoutFee().rawAmount;
            }
            if(this.networkFeeBtc==null) {
                this.networkFeeBtc = this.networkFee * output.rawAmount / this.getInputWithoutFee().rawAmount;
            }
        }
        super.tryRecomputeSwapPrice();
    }

    /**
     * Returns the payment hash identifier to be sent to the LP for getStatus and getRefund
     * @internal
     */
    protected getLpIdentifier(): string {
        return this.getClaimHash();
    }

    /**
     * Sets the payment result for the swap, optionally also checking it (checking that tx exist or swap secret is valid)
     *
     * @param result Result returned by the LP
     * @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>;


    //////////////////////////////
    //// Getters & utils

    /**
     * @inheritDoc
     */
    getInputAddress(): string | null {
        return this._getInitiator();
    }

    /**
     * @inheritDoc
     */
    getInputTxId(): string | null {
        return this._commitTxId ?? null;
    }

    /**
     * @inheritDoc
     */
    requiresAction(): boolean {
        return this.isRefundable();
    }

    /**
     * @inheritDoc
     */
    isFinished(): boolean {
        return this._state===ToBTCSwapState.CLAIMED || this._state===ToBTCSwapState.REFUNDED || this._state===ToBTCSwapState.QUOTE_EXPIRED;
    }

    /**
     * @inheritDoc
     */
    isRefundable(): boolean {
        return this._state===ToBTCSwapState.REFUNDABLE;
    }

    /**
     * @inheritDoc
     */
    isQuoteExpired(): boolean {
        return this._state===ToBTCSwapState.QUOTE_EXPIRED;
    }

    /**
     * @inheritDoc
     */
    isQuoteSoftExpired(): boolean {
        return this._state===ToBTCSwapState.QUOTE_EXPIRED || this._state===ToBTCSwapState.QUOTE_SOFT_EXPIRED;
    }

    /**
     * @inheritDoc
     */
    isSuccessful(): boolean {
        return this._state===ToBTCSwapState.CLAIMED;
    }

    /**
     * @inheritDoc
     */
    isFailed(): boolean {
        return this._state===ToBTCSwapState.REFUNDED;
    }

    /**
     * @inheritDoc
     */
    isInProgress(): boolean {
        return this._state===ToBTCSwapState.COMMITED || this._state===ToBTCSwapState.SOFT_CLAIMED;
    }

    /**
     * Returns the time (in UNIX milliseconds) at which the swap expires and the user is able to unilaterally
     *  refund it with the {@link refund} or {@link txsRefund} function.
     */
    getExpiry(): number {
        return Number(this._data.getExpiry())*1000;
    }

    /**
     * @inheritDoc
     * @internal
     */
    _getInitiator(): string {
        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!");

        const feeWithoutBaseFee = this.swapFeeBtc - this.pricingInfo.satsBaseFee;
        const output = this.getOutput();
        const swapFeePPM = output.rawAmount==null ? 0n : feeWithoutBaseFee * 1000000n / output.rawAmount;

        const amountInDstToken = toTokenAmount(
            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),
            amountInDstToken,
            currentUsdValue: amountInDstToken.currentUsdValue,
            usdValue: amountInDstToken.usdValue,
            pastUsdValue: amountInDstToken.pastUsdValue,
            composition: {
                base: toTokenAmount(this.pricingInfo.satsBaseFee, this.outputToken, this.wrapper._prices, this.pricingInfo),
                percentage: ppmToPercentage(swapFeePPM)
            }
        };
    }

    /**
     * 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
        );
        return {
            amountInSrcToken: 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(): Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken> {
        const amountInDstToken = toTokenAmount(
            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
            ),
            amountInDstToken,
            currentUsdValue: amountInDstToken.currentUsdValue,
            usdValue: amountInDstToken.usdValue,
            pastUsdValue: amountInDstToken.pastUsdValue
        }
    }

    /**
     * @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>},
    ] {
        return [
            {
                type: FeeType.SWAP,
                fee: this.getSwapFee()
            },
            {
                type: FeeType.NETWORK_OUTPUT,
                fee: this.getNetworkFee()
            }
        ];
    }

    /**
     * @inheritDoc
     */
    getInputToken(): SCToken<T["ChainId"]> {
        return this.wrapper._tokens[this._data.getToken()];
    }

    /**
     * @inheritDoc
     */
    getInput(): TokenAmount<SCToken<T["ChainId"]>, true> {
        return toTokenAmount(
            this._data.getAmount(), this.wrapper._tokens[this._data.getToken()],
            this.wrapper._prices, this.pricingInfo
        );
    }

    /**
     * @inheritDoc
     */
    getInputWithoutFee(): TokenAmount<SCToken<T["ChainId"]>, true> {
        return toTokenAmount(
            this._data.getAmount() - (this.swapFee + this.networkFee),
            this.wrapper._tokens[this._data.getToken()], this.wrapper._prices, this.pricingInfo
        );
    }

    /**
     * Checks if the initiator/sender on the source chain has enough balance to go through with the swap
     */
    async hasEnoughBalance(): Promise<{
        enoughBalance: boolean,
        balance: TokenAmount<SCToken<T["ChainId"]>, true>,
        required: TokenAmount<SCToken<T["ChainId"]>, true>
    }> {
        const [balance, commitFee] = await Promise.all([
            this._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();
        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)
        };
    }

    /**
     * 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,
        balance: TokenAmount<SCToken<T["ChainId"]>, true>,
        required: TokenAmount<SCToken<T["ChainId"]>, true>
    }> {
        const [balance, commitFee] = await Promise.all([
            this._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)
        };
    }


    //////////////////////////////
    //// Execution

    /**
     * Executes the swap with the provided smart chain wallet/signer
     *
     * @param signer Smart chain wallet/signer to use to sign the transaction on the source chain
     * @param callbacks Callbacks to track the progress of the swap
     * @param options Optional options for the swap like feeRate, AbortSignal, and timeouts/intervals
     *
     * @returns {boolean} Whether 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 {@link refund}
     */
    async execute(
        signer: T["Signer"] | T["NativeSigner"],
        callbacks?: {
            onSourceTransactionSent?: (sourceTxId: string) => void,
            onSourceTransactionConfirmed?: (sourceTxId: string) => void,
            onSwapSettled?: (destinationTxId: string) => void
        },
        options?: {
            abortSignal?: AbortSignal,
            paymentCheckIntervalSeconds?: number,
            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.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.COMMITED) {
            const success = await this.waitForPayment(options?.maxWaitTillSwapProcessedSeconds ?? 120, options?.paymentCheckIntervalSeconds, options?.abortSignal);
            if(success) {
                if(callbacks?.onSwapSettled!=null) callbacks.onSwapSettled(this.getOutputTxId()!);
                return true;
            } else {
                return false;
            }
        }

        throw new Error("Unexpected state reached!");
    }

    /**
     * @internal
     */
    protected async _getExecutionStatus() {
        const state = this._state;

        let sourcePaymentStatus: SwapExecutionStepPayment<T["ChainId"]>["status"] = "inactive";
        let destinationPayoutStatus: SwapExecutionStepSettlement<"BITCOIN" | "LIGHTNING", "soft_settled">["status"] = "inactive";
        let refundStatus: SwapExecutionStepRefund<T["ChainId"]>["status"] = "inactive";
        let buildCurrentAction: (actionOptions?: {
            skipChecks?: boolean,
            refundSmartChainSigner?: string | T["Signer"] | T["NativeSigner"]
        }) => Promise<
            SwapExecutionActionSignSmartChainTx<T> |
            SwapExecutionActionWait<"LP"> |
            undefined
        > = async () => undefined;

        switch(state) {
            case ToBTCSwapState.CREATED:
                const quoteValid = await this._verifyQuoteValid();
                sourcePaymentStatus = quoteValid ? "awaiting" : "soft_expired";
                if(this.signatureData!=null && quoteValid) {
                    buildCurrentAction = this._buildInitSmartChainTxAction.bind(this);
                }
                break;
            case ToBTCSwapState.QUOTE_SOFT_EXPIRED:
                sourcePaymentStatus = "soft_expired";
                break;
            case ToBTCSwapState.QUOTE_EXPIRED:
                sourcePaymentStatus = "expired";
                break;
            case ToBTCSwapState.COMMITED:
                sourcePaymentStatus = "confirmed";
                destinationPayoutStatus = "waiting_lp";
                buildCurrentAction = this._buildWaitLpAction.bind(this);
                break;
            case ToBTCSwapState.SOFT_CLAIMED:
                sourcePaymentStatus = "confirmed";
                destinationPayoutStatus = "soft_settled";
                break;
            case ToBTCSwapState.CLAIMED:
                sourcePaymentStatus = "confirmed";
                destinationPayoutStatus = "settled";
                break;
            case ToBTCSwapState.REFUNDABLE:
                sourcePaymentStatus = "confirmed";
                destinationPayoutStatus = "expired";
                refundStatus = "awaiting";
                buildCurrentAction = this._buildRefundSmartChainTxAction.bind(this);
                break;
            case ToBTCSwapState.REFUNDED:
                sourcePaymentStatus = "confirmed";
                destinationPayoutStatus = "expired";
                refundStatus = "refunded";
                break;
        }

        return {
            steps: [
                {
                    type: "Payment",
                    side: "source",
                    chain: this.chainIdentifier,
                    title: "Source payment",
                    description: `Initiate the swap by funding the escrow on the ${this.chainIdentifier} side`,
                    status: sourcePaymentStatus,
                    initTxId: this._commitTxId,
                    settleTxId: this._claimTxId
                },
                {
                    type: "Settlement",
                    side: "destination",
                    chain: this.outputToken.chainId,
                    title: "Destination payout",
                    description: `Wait for the LP to process the swap and send the payout on the ${this.outputToken.chainId} side`,
                    status: destinationPayoutStatus,
                    initTxId: destinationPayoutStatus==="settled" || destinationPayoutStatus==="soft_settled" ? this.getOutputTxId() : undefined,
                    settleTxId: destinationPayoutStatus==="settled" ? this.getOutputTxId() : undefined,
                },
                {
                    type: "Refund",
                    side: "source",
                    chain: this.chainIdentifier,
                    title: "Source refund",
                    description: `Refund escrowed funds on the ${this.chainIdentifier} side, after LP failed to execute`,
                    status: refundStatus,
                    refundTxId: this._refundTxId
                }
            ] as [
                SwapExecutionStepPayment<T["ChainId"]>,
                SwapExecutionStepSettlement<"BITCOIN" | "LIGHTNING", "soft_settled">,
                SwapExecutionStepRefund<T["ChainId"]>,
            ],
            buildCurrentAction,
            state
        };
    }

    /**
     * @inheritDoc
     * @internal
     */
    async _submitExecutionTransactions(txs: (T["SignedTXType"] | string)[], abortSignal?: AbortSignal, requiredStates?: ToBTCSwapState[], idempotent?: boolean): Promise<string[]> {
        const parsedTxs: T["SignedTXType"][] = [];
        for(let tx of txs) {
            parsedTxs.push(typeof(tx)==="string" ? await this.wrapper._chain.deserializeSignedTx(tx) : tx);
        }

        if(idempotent) {
            // Handle idempotent calls
            if(this.wrapper._chain.getTxId!=null) {
                const txIds = await Promise.all(parsedTxs.map(tx => this.wrapper._chain.getTxId!(tx)));
                const foundTxId = txIds.find(txId => this._commitTxId===txId || this._refundTxId===txId);
                if(foundTxId!=null) return txIds;
            }
        }

        if(requiredStates!=null && !requiredStates.includes(this._state)) throw new Error("Swap state has changed before transactions were submitted!");

        if(this._state===ToBTCSwapState.CREATED || this._state===ToBTCSwapState.QUOTE_SOFT_EXPIRED) {
            if(!await this._verifyQuoteValid()) throw new Error("Quote is already expired!");
            const txIds = await this.wrapper._chain.sendSignedAndConfirm(parsedTxs, true, abortSignal, false);
            await this.waitTillCommited(abortSignal);
            return txIds;
        }

        if(this._state===ToBTCSwapState.REFUNDABLE) {
            const txIds = await this.wrapper._chain.sendSignedAndConfirm(parsedTxs, true, abortSignal, false);
            await this.waitTillRefunded(abortSignal);
            return txIds;
        }

        throw new Error("Invalid swap state for transaction submission!");
    }

    /**
     * @internal
     */
    private async _buildInitSmartChainTxAction(actionOptions?: {
        skipChecks?: boolean
    }): Promise<SwapExecutionActionSignSmartChainTx> {
        return {
            type: "SignSmartChainTransaction",
            name: "Initiate swap",
            description: `Initiates the swap by commiting the funds to the escrow on the ${this.chainIdentifier} side`,
            chain: this.chainIdentifier,
            txs: await this.prepareTransactions(this.txsCommit(actionOptions?.skipChecks)),
            submitTransactions: async (txs: (T["SignedTXType"] | string)[], abortSignal?: AbortSignal, idempotent?: boolean) => {
                return this._submitExecutionTransactions(txs, abortSignal, [ToBTCSwapState.CREATED, ToBTCSwapState.QUOTE_SOFT_EXPIRED], idempotent);
            },
            requiredSigner: this._getInitiator()
        } as SwapExecutionActionSignSmartChainTx;
    }

    /**
     * @internal
     */
    private async _buildWaitLpAction(): Promise<SwapExecutionActionWait<"LP">> {
        return {
            type: "Wait",
            name: "Awaiting LP payout",
            description: "Wait for the intermediary to process the swap and either send the payout or make the swap refundable",
            pollTimeSeconds: 5,
            expectedTimeSeconds: 10,
            wait: async (
                maxWaitTimeSeconds?: number, pollIntervalSeconds?: number, abortSignal?: AbortSignal
            ) => {
                await this.waitForPayment(maxWaitTimeSeconds, pollIntervalSeconds, abortSignal);
            }
        } as SwapExecutionActionWait<"LP">;
    }

    /**
     * @internal
     */
    private async _buildRefundSmartChainTxAction(actionOptions?: {
        refundSmartChainSigner?: string | T["Signer"] | T["NativeSigner"]
    }): Promise<SwapExecutionActionSignSmartChainTx> {
        const signerAddress =
            await this.wrapper._getSignerAddress(actionOptions?.refundSmartChainSigner);

        return {
            type: "SignSmartChainTransaction",
            name: "Refund",
            description: "Refund the swap after it failed to execute",
            chain: this.chainIdentifier,
            txs: await this.prepareTransactions(this.txsRefund(actionOptions?.refundSmartChainSigner)),
            submitTransactions: async (txs: (T["SignedTXType"] | string)[], abortSignal?: AbortSignal, idempotent?: boolean) => {
                return this._submitExecutionTransactions(txs, abortSignal, [ToBTCSwapState.REFUNDABLE], idempotent);
            },
            requiredSigner: signerAddress ?? this._getInitiator()
        } as SwapExecutionActionSignSmartChainTx;
    }

    /**
     * @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`)
     * @param options.refundSmartChainSigner Optional smart chain signer to use when creating refunds transactions
     */
    async getExecutionAction(options?: {
        skipChecks?: boolean,
        refundSmartChainSigner?: string | T["Signer"] | T["NativeSigner"]
    }): Promise<
        SwapExecutionActionSignSmartChainTx<T> |
        SwapExecutionActionWait<"LP"> |
        undefined
    > {
        const executionStatus = await this._getExecutionStatus();
        return executionStatus.buildCurrentAction(options);
    }

    /**
     * @inheritDoc
     */
    async getExecutionStatus(options?: {
        skipBuildingAction?: boolean,
        skipChecks?: boolean,
        refundSmartChainSigner?: string | T["Signer"] | T["NativeSigner"]
    }): Promise<{
        steps: [
            SwapExecutionStepPayment<T["ChainId"]>,
            SwapExecutionStepSettlement<"BITCOIN" | "LIGHTNING", "soft_settled">,
            SwapExecutionStepRefund<T["ChainId"]>,
        ],
        currentAction:
            SwapExecutionActionSignSmartChainTx<T> |
            SwapExecutionActionWait<"LP"> |
            undefined,
        stateInfo: SwapStateInfo<ToBTCSwapState>
    }> {
        const executionStatus = await this._getExecutionStatus();
        return {
            steps: executionStatus.steps,
            currentAction: options?.skipBuildingAction ? undefined : await executionStatus.buildCurrentAction(options),
            stateInfo: this._getStateInfo(executionStatus.state)
        };
    }

    /**
     * @inheritDoc
     */
    async getExecutionSteps(): Promise<[
        SwapExecutionStepPayment<T["ChainId"]>,
        SwapExecutionStepSettlement<"BITCOIN" | "LIGHTNING", "soft_settled">,
        SwapExecutionStepRefund<T["ChainId"]>,
    ]> {
        return (await this._getExecutionStatus()).steps;
    }

    //////////////////////////////
    //// Commit

    /**
     * @inheritDoc
     *
     * @throws {Error} When in invalid state (not {@link ToBTCSwapState.CREATED})
     */
    async txsCommit(skipChecks?: boolean): Promise<T["TX"][]> {
        if(this._state!==ToBTCSwapState.CREATED && (!skipChecks || this._state!==ToBTCSwapState.QUOTE_SOFT_EXPIRED)) 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) {
            this.initiated = true;
            await this._saveAndEmit();
        }

        return await this._contract.txsInit(
            this._getInitiator(), this._data, this.signatureData, skipChecks, this.feeRate
        ).catch(e => Promise.reject(e instanceof SignatureVerificationError ? new Error("Request timed out") : e));
    }

    /**
     * @inheritDoc
     *
     * @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);
        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) => {
                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) {
            await this._saveAndEmit(ToBTCSwapState.COMMITED);
        }
        return this._commitTxId;
    }

    /**
     * @inheritDoc
     *
     * @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)");

        const abortController = extendAbortController(abortSignal);
        let result: SwapCommitState | number | null;
        try {
            result = await Promise.race([
                this.watchdogWaitTillCommited(undefined, abortController.signal),
                this.waitTillState(ToBTCSwapState.COMMITED, "gte", abortController.signal).then(() => 0)
            ]);
            abortController.abort();
        } catch (e) {
            abortController.abort();
            throw e;
        }

        if(result===0) {
            this.logger.debug("waitTillCommited(): Resolved from state change");
        } else if(result!=null) {
            this.logger.debug("waitTillCommited(): Resolved from watchdog - commited");
        }

        if(result===null) {
            this.logger.debug("waitTillCommited(): Resolved from watchdog - signature expiry");
            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(typeof(result)==="object" && (result as any).getInitTxId!=null && this._commitTxId==null)
                this._commitTxId = await (result as any).getInitTxId();
            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
     */
    protected async waitTillIntermediarySwapProcessed(
        checkIntervalSeconds?: number,
        abortSignal?: AbortSignal
    ): Promise<RefundAuthorizationResponse> {
        if(this.url==null) throw new Error("LP URL not specified!");
        checkIntervalSeconds ??= 5;
        let resp: RefundAuthorizationResponse = {code: RefundAuthorizationResponseCodes.PENDING, msg: ""};
        while(!abortSignal?.aborted && (
            resp.code===RefundAuthorizationResponseCodes.PENDING || resp.code===RefundAuthorizationResponseCodes.NOT_FOUND
        )) {
            resp = await this.wrapper._lpApi.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) {
                        await this._saveAndEmit(ToBTCSwapState.SOFT_CLAIMED);
                    }
                } else {
                    resp = {code: RefundAuthorizationResponseCodes.PENDING, msg: ""};
                }
            }
            if(
                resp.code===RefundAuthorizationResponseCodes.PENDING ||
                resp.code===RefundAuthorizationResponseCodes.NOT_FOUND
            ) await timeoutPromise(checkIntervalSeconds*1000, abortSignal);
        }
        return resp;
    }

    /**
     * Checks whether the swap was already processed by the LP and is either successful (requires proof which is
     *  either a HTLC pre-image for LN swaps or valid txId for on-chain swap) or failed and we can cooperatively
     *  refund.
     *
     * @param save whether to save the data
     * @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.isFinished() || this.isRefundable()) return true;
        //Check if that maybe already concluded according to the LP
        const resp = await this.wrapper._lpApi.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;
                    if(save) await this._saveAndEmit();
                }
                return processed;
            case RefundAuthorizationResponseCodes.REFUND_DATA:
                await this._contract.isValidRefundAuthorization(this._data, resp.data);
                this._state = ToBTCSwapState.REFUNDABLE;
                if(save) await this._saveAndEmit();
                return true;
            default:
                return false;
        }
    }

    /**
     * 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 `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 {@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)");

        const abortController = extendAbortController(abortSignal);

        let timedOut: boolean = false;
        if(maxWaitTimeSeconds!=null) {
            const timeout = setTimeout(() => {
                timedOut = true;
                abortController.abort();
            }, maxWaitTimeSeconds * 1000);
            abortController.signal.addEventListener("abort", () => clearTimeout(timeout));
        }

        let result: void | RefundAuthorizationResponse;
        try {
            result = await Promise.race([
                this.waitTillState(ToBTCSwapState.CLAIMED, "gte", abortController.signal),
                this.waitTillIntermediarySwapProcessed(checkIntervalSeconds, abortController.signal)
            ]);
            abortController.abort();
        } catch (e) {
            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!`);
            }
            throw e;
        }

        if(typeof result !== "object") {
            if((this._state as ToBTCSwapState)===ToBTCSwapState.REFUNDABLE) throw new Error("Swap expired");
            this.logger.debug("waitTillRefunded(): Resolved from state change");
            return true;
        }
        this.logger.debug("waitTillRefunded(): Resolved from intermediary response");

        switch(result.code) {
            case RefundAuthorizationResponseCodes.PAID:
                return true;
            case RefundAuthorizationResponseCodes.REFUND_DATA:
                const resultData = result.data;
                await this._contract.isValidRefundAuthorization(
                    this._data,
                    resultData
                );
                await this._saveAndEmit(ToBTCSwapState.REFUNDABLE);
                return false;
            case RefundAuthorizationResponseCodes.EXPIRED:
                if(await this._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;
                throw new Error("LP swap not found");
        }

        throw new Error("Invalid response code returned by the LP");
    }


    //////////////////////////////
    //// Refund

    /**
     * Get the estimated smart chain transaction fee of the refund transaction
     */
    async getRefundNetworkFee(): Promise<TokenAmount<SCToken<T["ChainId"]>, true>> {
        const swapContract: T["Contract"] = this._contract;
        return toTokenAmount(
            await swapContract.getRefundFee(this._getInitiator(), this._data),
            this.wrapper._getNativeToken(),
            this.wrapper._prices
        );
    }

    /**
     * @inheritDoc
     *
     * @throws {IntermediaryError} If intermediary returns invalid response in case cooperative refund should be used
     * @throws {SignatureVerificationError} If intermediary returned invalid cooperative refund signature
     * @throws {Error} When state is not refundable
     */
    async txsRefund(_signer?: string | T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]> {
        if(!this.isRefundable()) throw new Error("Must be in REFUNDABLE state or expired!");

        let signer: string;
        if(_signer!=null) {
            if (typeof (_signer) === "string") {
                signer = _signer;
            } else if (isAbstractSigner(_signer)) {
                signer = _signer.getAddress();
            } else {
                signer = (await this.wrapper._chain.wrapSigner(_signer)).getAddress();
            }
        } else {
            signer = this._getInitiator();
        }

        if(await this._contract.isExpired(this._getInitiator(), this._data)) {
            return await this._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 this.wrapper._lpApi.getRefundAuthorization(this.url, this.getLpIdentifier(), this._data.getSequence());
            if(res.code===RefundAuthorizationResponseCodes.REFUND_DATA) {
                return await this._contract.txsRefundWithAuthorization(
                    signer,
                    this._data,
                    res.data,
                    true,
                    true
                );
            }
            throw new IntermediaryError("Invalid intermediary cooperative message returned");
        }
    }

    /**
     * @inheritDoc
     *
     * @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)

        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];
    }

    /**
     * @inheritDoc
     *
     * @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 &&
            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));
        const res = await Promise.race([
            this.watchdogWaitTillResult(undefined, abortController.signal),
            this.waitTillState(ToBTCSwapState.REFUNDED, "eq", abortController.signal).then(() => 0 as const),
            this.waitTillState(ToBTCSwapState.CLAIMED, "eq", abortController.signal).then(() => 1 as const),
        ]);
        abortController.abort();

        if(res===0) {
            this.logger.debug("waitTillRefunded(): Resolved from state change (REFUNDED)");
            return;
        }
        if(res===1) {
            this.logger.debug("waitTillRefunded(): Resolved from state change (CLAIMED)");
            throw new Error("Tried to refund swap, but claimer claimed it in the meantime!");
        }
        this.logger.debug("waitTillRefunded(): Resolved from watchdog");

        if(res?.type===SwapCommitStateType.PAID) {
            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();
            await this._saveAndEmit(ToBTCSwapState.REFUNDED);
        }
    }


    //////////////////////////////
    //// Storage

    /**
     * @inheritDoc
     */
    serialize(): any {
        const obj = super.serialize();
        return {
            ...obj,
            networkFee: this.networkFee==null ? null : this.networkFee.toString(10),
            networkFeeBtc: this.networkFeeBtc==null ? null : this.networkFeeBtc.toString(10)
        };
    }


    //////////////////////////////
    //// Swap ticks & sync

    /**
     * Checks the swap's state on-chain and compares it to its internal state, updates/changes it according to on-chain
     *  data
     *
     * @private
     */
    private async syncStateFromChain(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
        ) {
            let quoteExpired = false;
            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._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;
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * @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;
    }

    /**
     * @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) {
            //Check if that maybe already concluded
            try {
                if(await this.checkIntermediarySwapProcessed(false)) changed = true;
            } catch (e) {
                this.logger.error("_sync(): Failed to synchronize swap, error: ", e);
            }
        }

        if(save && changed) await this._saveAndEmit();

        return changed;
    }

    /**
     * @inheritDoc
     * @internal
     */
    async _forciblySetOnchainState(commitStatus: SwapCommitState): Promise<boolean> {
        switch(commitStatus.type) {
            case SwapCommitStateType.PAID:
                if(this._commitTxId==null && (commitStatus as any).getInitTxId!=null) this._commitTxId = await (commitStatus as any).getInitTxId();
                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:
                if(this._commitTxId==null && (commitStatus as any).getInitTxId!=null) this._commitTxId = await (commitStatus as any).getInitTxId();
                this._state = ToBTCSwapState.REFUNDABLE;
                return true;
            case SwapCommitStateType.EXPIRED:
                if(this._commitTxId==null && (commitStatus as any).getInitTxId!=null) this._commitTxId = await (commitStatus as any).getInitTxId();
                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:
                let changed: boolean = false;
                if(this._commitTxId==null && (commitStatus as any).getInitTxId!=null) {
                    this._commitTxId = await (commitStatus as any).getInitTxId();
                    changed = true;
                }
                if(this._refundTxId==null && commitStatus.getRefundTxId) {
                    this._refundTxId = await commitStatus.getRefundTxId();
                    changed = true;
                }
                if(this._refundTxId!=null) {
                    this._state = ToBTCSwapState.REFUNDED;
                    changed = true;
                }
                return changed;
            case SwapCommitStateType.COMMITED:
                let save: boolean = false;
                if(this._commitTxId==null && (commitStatus as any).getInitTxId!=null) {
                    this._commitTxId = await (commitStatus as any).getInitTxId();
                    save = true;
                }
                if(this._state!==ToBTCSwapState.COMMITED && this._state!==ToBTCSwapState.REFUNDABLE && this._state!==ToBTCSwapState.SOFT_CLAIMED) {
                    this._state = ToBTCSwapState.COMMITED;
                    save = true;
                }
                return save;
        }
        return false;
    }

    /**
     * @inheritDoc
     * @internal
     */
    async _tick(save?: boolean): Promise<boolean> {
        switch(this._state) {
            case ToBTCSwapState.CREATED:
                if(this.expiry<Date.now()) {
                    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._contract.isExpired(this._getInitiator(), this._data);
                if(expired) {
                    this._state = ToBTCSwapState.REFUNDABLE;
                    if(save) await this._saveAndEmit();
                    return true;
                }
                break;
        }
        return false;
    }
}