@atomiqlabs/sdk 8.9.0 → 8.9.2

package/dist/swaps/escrow_swaps/tobtc/IToBTCSwap.d.ts

@@ -1,446 +1,446 @@
-import { IToBTCDefinition, IToBTCWrapper } from "./IToBTCWrapper";
-import { ChainType, SignatureData, SwapCommitState, SwapData } from "@atomiqlabs/base";
-import { RefundAuthorizationResponse } from "../../../intermediaries/apis/IntermediaryAPI";
-import { Fee } from "../../../types/fees/Fee";
-import { IEscrowSelfInitSwap, IEscrowSelfInitSwapInit } from "../IEscrowSelfInitSwap";
-import { IRefundableSwap } from "../../IRefundableSwap";
-import { FeeType } from "../../../enums/FeeType";
-import { TokenAmount } from "../../../types/TokenAmount";
-import { BtcToken, SCToken } from "../../../types/Token";
-import { SwapExecutionActionSignSmartChainTx, SwapExecutionActionWait } from "../../../types/SwapExecutionAction";
-import { 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 declare function isIToBTCSwapInit<T extends SwapData>(obj: any): obj is IToBTCSwapInit<T>;
-/**
- * State enum for escrow-based Smart chain -> Bitcoin (on-chain & lightning) swaps
- *
- * @category Swaps/Smart chain → Bitcoin
- */
-export declare enum ToBTCSwapState {
-    /**
-     * Intermediary (LP) was unable to process the swap and the funds were refunded on the
-     *  source chain
-     */
-    REFUNDED = -3,
-    /**
-     * Swap has expired for good and there is no way how it can be executed anymore
-     */
-    QUOTE_EXPIRED = -2,
-    /**
-     * A swap is almost expired, and it should be presented to the user as expired, though
-     *  there is still a chance that it will be processed
-     */
-    QUOTE_SOFT_EXPIRED = -1,
-    /**
-     * Swap was created, use the {@link IToBTCSwap.commit} or {@link IToBTCSwap.txsCommit} to
-     *  initiate it by creating the swap escrow on the source chain
-     */
-    CREATED = 0,
-    /**
-     * Swap escrow was initiated (committed) on the source chain, the intermediary (LP) will
-     *  now process the swap. You can wait till that happens with the {@link IToBTCSwap.waitForPayment}
-     *  function.
-     */
-    COMMITED = 1,
-    /**
-     * The intermediary (LP) has processed the transaction and sent out the funds on the destination chain,
-     *  but hasn't yet settled the escrow on the source chain.
-     */
-    SOFT_CLAIMED = 2,
-    /**
-     * Swap was successfully settled by the intermediary (LP) on the source chain
-     */
-    CLAIMED = 3,
-    /**
-     * Intermediary (LP) was unable to process the swap and the swap escrow on the source chain
-     *  is refundable, call {@link IToBTCSwap.refund} or {@link IToBTCSwap.txsRefund} to refund
-     */
-    REFUNDABLE = 4
-}
-/**
- * Base class for escrow-based Smart chain -> Bitcoin (on-chain & lightning) swaps
- *
- * @category Swaps/Smart chain → Bitcoin
- */
-export declare 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: {
-        [-3]: string;
-        [-2]: string;
-        [-1]: string;
-        0: string;
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-    };
-    /**
-     * @internal
-     */
-    protected readonly swapStateName: (state: number) => string;
-    /**
-     * @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"]>);
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    protected getSwapData(): T["Data"];
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    protected upgradeVersion(): void;
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    protected tryRecomputeSwapPrice(): void;
-    /**
-     * Returns the payment hash identifier to be sent to the LP for getStatus and getRefund
-     * @internal
-     */
-    protected getLpIdentifier(): string;
-    /**
-     * 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>;
-    /**
-     * @inheritDoc
-     */
-    getInputAddress(): string | null;
-    /**
-     * @inheritDoc
-     */
-    getInputTxId(): string | null;
-    /**
-     * @inheritDoc
-     */
-    requiresAction(): boolean;
-    /**
-     * @inheritDoc
-     */
-    isFinished(): boolean;
-    /**
-     * @inheritDoc
-     */
-    isRefundable(): boolean;
-    /**
-     * @inheritDoc
-     */
-    isQuoteExpired(): boolean;
-    /**
-     * @inheritDoc
-     */
-    isQuoteSoftExpired(): boolean;
-    /**
-     * @inheritDoc
-     */
-    isSuccessful(): boolean;
-    /**
-     * @inheritDoc
-     */
-    isFailed(): boolean;
-    /**
-     * @inheritDoc
-     */
-    isInProgress(): boolean;
-    /**
-     * 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;
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    _getInitiator(): string;
-    /**
-     * Returns the swap fee charged by the intermediary (LP) on this swap
-     *
-     * @internal
-     */
-    protected getSwapFee(): Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken>;
-    /**
-     * Returns network fee for on the destination chain for the swap
-     *
-     * @internal
-     */
-    protected getNetworkFee(): Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken>;
-    /**
-     * @inheritDoc
-     */
-    getFee(): Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken>;
-    /**
-     * @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>;
-        }
-    ];
-    /**
-     * @inheritDoc
-     */
-    getInputToken(): SCToken<T["ChainId"]>;
-    /**
-     * @inheritDoc
-     */
-    getInput(): TokenAmount<SCToken<T["ChainId"]>, true>;
-    /**
-     * @inheritDoc
-     */
-    getInputWithoutFee(): TokenAmount<SCToken<T["ChainId"]>, true>;
-    /**
-     * Checks if the initiator/sender on the source chain has enough balance to go through with the swap
-     */
-    hasEnoughBalance(): Promise<{
-        enoughBalance: boolean;
-        balance: TokenAmount<SCToken<T["ChainId"]>, true>;
-        required: TokenAmount<SCToken<T["ChainId"]>, true>;
-    }>;
-    /**
-     * Checks if the initiator/sender on the source chain has enough native token balance
-     *  to cover the transaction fee of initiating the swap
-     */
-    hasEnoughForTxFees(): Promise<{
-        enoughBalance: boolean;
-        balance: TokenAmount<SCToken<T["ChainId"]>, true>;
-        required: TokenAmount<SCToken<T["ChainId"]>, true>;
-    }>;
-    /**
-     * 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}
-     */
-    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>;
-    /**
-     * @internal
-     */
-    protected _getExecutionStatus(): Promise<{
-        steps: [SwapExecutionStepPayment<T["ChainId"]>, SwapExecutionStepSettlement<"BITCOIN" | "LIGHTNING", "soft_settled">, SwapExecutionStepRefund<T["ChainId"]>];
-        buildCurrentAction: (actionOptions?: {
-            skipChecks?: boolean;
-            refundSmartChainSigner?: string | T["Signer"] | T["NativeSigner"];
-        }) => Promise<SwapExecutionActionSignSmartChainTx<T> | SwapExecutionActionWait<"LP"> | undefined>;
-        state: ToBTCSwapState;
-    }>;
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    _submitExecutionTransactions(txs: (T["SignedTXType"] | string)[], abortSignal?: AbortSignal, requiredStates?: ToBTCSwapState[], idempotent?: boolean): Promise<string[]>;
-    /**
-     * @internal
-     */
-    private _buildInitSmartChainTxAction;
-    /**
-     * @internal
-     */
-    private _buildWaitLpAction;
-    /**
-     * @internal
-     */
-    private _buildRefundSmartChainTxAction;
-    /**
-     * @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
-     */
-    getExecutionAction(options?: {
-        skipChecks?: boolean;
-        refundSmartChainSigner?: string | T["Signer"] | T["NativeSigner"];
-    }): Promise<SwapExecutionActionSignSmartChainTx<T> | SwapExecutionActionWait<"LP"> | undefined>;
-    /**
-     * @inheritDoc
-     */
-    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>;
-    }>;
-    /**
-     * @inheritDoc
-     */
-    getExecutionSteps(): Promise<[
-        SwapExecutionStepPayment<T["ChainId"]>,
-        SwapExecutionStepSettlement<"BITCOIN" | "LIGHTNING", "soft_settled">,
-        SwapExecutionStepRefund<T["ChainId"]>
-    ]>;
-    /**
-     * @inheritDoc
-     *
-     * @throws {Error} When in invalid state (not {@link ToBTCSwapState.CREATED})
-     */
-    txsCommit(skipChecks?: boolean): Promise<T["TX"][]>;
-    /**
-     * @inheritDoc
-     *
-     * @throws {Error} If invalid signer is provided that doesn't match the swap data
-     */
-    commit(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, skipChecks?: boolean, onBeforeTxSent?: (txId: string) => void): Promise<string>;
-    /**
-     * @inheritDoc
-     *
-     * @throws {Error} If swap is not in the correct state (must be {@link ToBTCSwapState.CREATED})
-     */
-    waitTillCommited(abortSignal?: AbortSignal): Promise<void>;
-    /**
-     * 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 waitTillIntermediarySwapProcessed(checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<RefundAuthorizationResponse>;
-    /**
-     * 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 checkIntermediarySwapProcessed(save?: boolean): Promise<boolean>;
-    /**
-     * 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})
-     */
-    waitForPayment(maxWaitTimeSeconds?: number, checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
-    /**
-     * Get the estimated smart chain transaction fee of the refund transaction
-     */
-    getRefundNetworkFee(): Promise<TokenAmount<SCToken<T["ChainId"]>, true>>;
-    /**
-     * @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
-     */
-    txsRefund(_signer?: string | T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]>;
-    /**
-     * @inheritDoc
-     *
-     * @throws {Error} If invalid signer is provided that doesn't match the swap data
-     */
-    refund(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal): Promise<string>;
-    /**
-     * @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
-     */
-    waitTillRefunded(abortSignal?: AbortSignal): Promise<void>;
-    /**
-     * @inheritDoc
-     */
-    serialize(): any;
-    /**
-     * Checks the swap's state on-chain and compares it to its internal state, updates/changes it according to on-chain
-     *  data
-     *
-     * @private
-     */
-    private syncStateFromChain;
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    _shouldFetchOnchainState(): boolean;
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    _shouldFetchExpiryStatus(): boolean;
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    _sync(save?: boolean, quoteDefinitelyExpired?: boolean, commitStatus?: SwapCommitState): Promise<boolean>;
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    _forciblySetOnchainState(commitStatus: SwapCommitState): Promise<boolean>;
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    _tick(save?: boolean): Promise<boolean>;
-}
+import { IToBTCDefinition, IToBTCWrapper } from "./IToBTCWrapper";
+import { ChainType, SignatureData, SwapCommitState, SwapData } from "@atomiqlabs/base";
+import { RefundAuthorizationResponse } from "../../../intermediaries/apis/IntermediaryAPI";
+import { Fee } from "../../../types/fees/Fee";
+import { IEscrowSelfInitSwap, IEscrowSelfInitSwapInit } from "../IEscrowSelfInitSwap";
+import { IRefundableSwap } from "../../IRefundableSwap";
+import { FeeType } from "../../../enums/FeeType";
+import { TokenAmount } from "../../../types/TokenAmount";
+import { BtcToken, SCToken } from "../../../types/Token";
+import { SwapExecutionActionSignSmartChainTx, SwapExecutionActionWait } from "../../../types/SwapExecutionAction";
+import { 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 declare function isIToBTCSwapInit<T extends SwapData>(obj: any): obj is IToBTCSwapInit<T>;
+/**
+ * State enum for escrow-based Smart chain -> Bitcoin (on-chain & lightning) swaps
+ *
+ * @category Swaps/Smart chain → Bitcoin
+ */
+export declare enum ToBTCSwapState {
+    /**
+     * Intermediary (LP) was unable to process the swap and the funds were refunded on the
+     *  source chain
+     */
+    REFUNDED = -3,
+    /**
+     * Swap has expired for good and there is no way how it can be executed anymore
+     */
+    QUOTE_EXPIRED = -2,
+    /**
+     * A swap is almost expired, and it should be presented to the user as expired, though
+     *  there is still a chance that it will be processed
+     */
+    QUOTE_SOFT_EXPIRED = -1,
+    /**
+     * Swap was created, use the {@link IToBTCSwap.commit} or {@link IToBTCSwap.txsCommit} to
+     *  initiate it by creating the swap escrow on the source chain
+     */
+    CREATED = 0,
+    /**
+     * Swap escrow was initiated (committed) on the source chain, the intermediary (LP) will
+     *  now process the swap. You can wait till that happens with the {@link IToBTCSwap.waitForPayment}
+     *  function.
+     */
+    COMMITED = 1,
+    /**
+     * The intermediary (LP) has processed the transaction and sent out the funds on the destination chain,
+     *  but hasn't yet settled the escrow on the source chain.
+     */
+    SOFT_CLAIMED = 2,
+    /**
+     * Swap was successfully settled by the intermediary (LP) on the source chain
+     */
+    CLAIMED = 3,
+    /**
+     * Intermediary (LP) was unable to process the swap and the swap escrow on the source chain
+     *  is refundable, call {@link IToBTCSwap.refund} or {@link IToBTCSwap.txsRefund} to refund
+     */
+    REFUNDABLE = 4
+}
+/**
+ * Base class for escrow-based Smart chain -> Bitcoin (on-chain & lightning) swaps
+ *
+ * @category Swaps/Smart chain → Bitcoin
+ */
+export declare 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: {
+        [-3]: string;
+        [-2]: string;
+        [-1]: string;
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+    };
+    /**
+     * @internal
+     */
+    protected readonly swapStateName: (state: number) => string;
+    /**
+     * @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"]>);
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    protected getSwapData(): T["Data"];
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    protected upgradeVersion(): void;
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    protected tryRecomputeSwapPrice(): void;
+    /**
+     * Returns the payment hash identifier to be sent to the LP for getStatus and getRefund
+     * @internal
+     */
+    protected getLpIdentifier(): string;
+    /**
+     * 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>;
+    /**
+     * @inheritDoc
+     */
+    getInputAddress(): string | null;
+    /**
+     * @inheritDoc
+     */
+    getInputTxId(): string | null;
+    /**
+     * @inheritDoc
+     */
+    requiresAction(): boolean;
+    /**
+     * @inheritDoc
+     */
+    isFinished(): boolean;
+    /**
+     * @inheritDoc
+     */
+    isRefundable(): boolean;
+    /**
+     * @inheritDoc
+     */
+    isQuoteExpired(): boolean;
+    /**
+     * @inheritDoc
+     */
+    isQuoteSoftExpired(): boolean;
+    /**
+     * @inheritDoc
+     */
+    isSuccessful(): boolean;
+    /**
+     * @inheritDoc
+     */
+    isFailed(): boolean;
+    /**
+     * @inheritDoc
+     */
+    isInProgress(): boolean;
+    /**
+     * 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;
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _getInitiator(): string;
+    /**
+     * Returns the swap fee charged by the intermediary (LP) on this swap
+     *
+     * @internal
+     */
+    protected getSwapFee(): Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken>;
+    /**
+     * Returns network fee for on the destination chain for the swap
+     *
+     * @internal
+     */
+    protected getNetworkFee(): Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken>;
+    /**
+     * @inheritDoc
+     */
+    getFee(): Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken>;
+    /**
+     * @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>;
+        }
+    ];
+    /**
+     * @inheritDoc
+     */
+    getInputToken(): SCToken<T["ChainId"]>;
+    /**
+     * @inheritDoc
+     */
+    getInput(): TokenAmount<SCToken<T["ChainId"]>, true>;
+    /**
+     * @inheritDoc
+     */
+    getInputWithoutFee(): TokenAmount<SCToken<T["ChainId"]>, true>;
+    /**
+     * Checks if the initiator/sender on the source chain has enough balance to go through with the swap
+     */
+    hasEnoughBalance(): Promise<{
+        enoughBalance: boolean;
+        balance: TokenAmount<SCToken<T["ChainId"]>, true>;
+        required: TokenAmount<SCToken<T["ChainId"]>, true>;
+    }>;
+    /**
+     * Checks if the initiator/sender on the source chain has enough native token balance
+     *  to cover the transaction fee of initiating the swap
+     */
+    hasEnoughForTxFees(): Promise<{
+        enoughBalance: boolean;
+        balance: TokenAmount<SCToken<T["ChainId"]>, true>;
+        required: TokenAmount<SCToken<T["ChainId"]>, true>;
+    }>;
+    /**
+     * 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}
+     */
+    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>;
+    /**
+     * @internal
+     */
+    protected _getExecutionStatus(): Promise<{
+        steps: [SwapExecutionStepPayment<T["ChainId"]>, SwapExecutionStepSettlement<"BITCOIN" | "LIGHTNING", "soft_settled">, SwapExecutionStepRefund<T["ChainId"]>];
+        buildCurrentAction: (actionOptions?: {
+            skipChecks?: boolean;
+            refundSmartChainSigner?: string | T["Signer"] | T["NativeSigner"];
+        }) => Promise<SwapExecutionActionSignSmartChainTx<T> | SwapExecutionActionWait<"LP"> | undefined>;
+        state: ToBTCSwapState;
+    }>;
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _submitExecutionTransactions(txs: (T["SignedTXType"] | string)[], abortSignal?: AbortSignal, requiredStates?: ToBTCSwapState[], idempotent?: boolean): Promise<string[]>;
+    /**
+     * @internal
+     */
+    private _buildInitSmartChainTxAction;
+    /**
+     * @internal
+     */
+    private _buildWaitLpAction;
+    /**
+     * @internal
+     */
+    private _buildRefundSmartChainTxAction;
+    /**
+     * @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
+     */
+    getExecutionAction(options?: {
+        skipChecks?: boolean;
+        refundSmartChainSigner?: string | T["Signer"] | T["NativeSigner"];
+    }): Promise<SwapExecutionActionSignSmartChainTx<T> | SwapExecutionActionWait<"LP"> | undefined>;
+    /**
+     * @inheritDoc
+     */
+    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>;
+    }>;
+    /**
+     * @inheritDoc
+     */
+    getExecutionSteps(): Promise<[
+        SwapExecutionStepPayment<T["ChainId"]>,
+        SwapExecutionStepSettlement<"BITCOIN" | "LIGHTNING", "soft_settled">,
+        SwapExecutionStepRefund<T["ChainId"]>
+    ]>;
+    /**
+     * @inheritDoc
+     *
+     * @throws {Error} When in invalid state (not {@link ToBTCSwapState.CREATED})
+     */
+    txsCommit(skipChecks?: boolean): Promise<T["TX"][]>;
+    /**
+     * @inheritDoc
+     *
+     * @throws {Error} If invalid signer is provided that doesn't match the swap data
+     */
+    commit(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, skipChecks?: boolean, onBeforeTxSent?: (txId: string) => void): Promise<string>;
+    /**
+     * @inheritDoc
+     *
+     * @throws {Error} If swap is not in the correct state (must be {@link ToBTCSwapState.CREATED})
+     */
+    waitTillCommited(abortSignal?: AbortSignal): Promise<void>;
+    /**
+     * 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 waitTillIntermediarySwapProcessed(checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<RefundAuthorizationResponse>;
+    /**
+     * 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 checkIntermediarySwapProcessed(save?: boolean): Promise<boolean>;
+    /**
+     * 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})
+     */
+    waitForPayment(maxWaitTimeSeconds?: number, checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
+    /**
+     * Get the estimated smart chain transaction fee of the refund transaction
+     */
+    getRefundNetworkFee(): Promise<TokenAmount<SCToken<T["ChainId"]>, true>>;
+    /**
+     * @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
+     */
+    txsRefund(_signer?: string | T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]>;
+    /**
+     * @inheritDoc
+     *
+     * @throws {Error} If invalid signer is provided that doesn't match the swap data
+     */
+    refund(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal): Promise<string>;
+    /**
+     * @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
+     */
+    waitTillRefunded(abortSignal?: AbortSignal): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    serialize(): any;
+    /**
+     * Checks the swap's state on-chain and compares it to its internal state, updates/changes it according to on-chain
+     *  data
+     *
+     * @private
+     */
+    private syncStateFromChain;
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _shouldFetchOnchainState(): boolean;
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _shouldFetchExpiryStatus(): boolean;
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _sync(save?: boolean, quoteDefinitelyExpired?: boolean, commitStatus?: SwapCommitState): Promise<boolean>;
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _forciblySetOnchainState(commitStatus: SwapCommitState): Promise<boolean>;
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _tick(save?: boolean): Promise<boolean>;
+}