@atomiqlabs/sdk 7.0.12 → 8.0.7

package/dist/swaps/escrow_swaps/frombtc/onchain/FromBTCWrapper.d.ts

@@ -0,0 +1,120 @@
+/// <reference types="node" />
+import { IFromBTCWrapper } from "../IFromBTCWrapper";
+import { FromBTCSwap, FromBTCSwapState } from "./FromBTCSwap";
+import { ChainType, ClaimEvent, InitializeEvent, RefundEvent, RelaySynchronizer, SwapData, BtcRelay } from "@atomiqlabs/base";
+import { EventEmitter } from "events";
+import { Intermediary } from "../../../../intermediaries/Intermediary";
+import { BitcoinRpcWithAddressIndex } from "../../../../bitcoin/BitcoinRpcWithAddressIndex";
+import { ISwapPrice } from "../../../../prices/abstract/ISwapPrice";
+import { ISwapWrapperOptions, WrapperCtorTokens } from "../../../ISwapWrapper";
+import { SwapType } from "../../../../enums/SwapType";
+import { BTC_NETWORK } from "@scure/btc-signer/utils";
+import { UnifiedSwapEventListener } from "../../../../events/UnifiedSwapEventListener";
+import { UnifiedSwapStorage } from "../../../../storage/UnifiedSwapStorage";
+import { ISwap } from "../../../ISwap";
+import { IClaimableSwapWrapper } from "../../../IClaimableSwapWrapper";
+import { IFromBTCSelfInitDefinition } from "../IFromBTCSelfInitSwap";
+import { AmountData } from "../../../../types/AmountData";
+import { AllOptional } from "../../../../utils/TypeUtils";
+export type FromBTCOptions = {
+    feeSafetyFactor?: bigint;
+    blockSafetyFactor?: number;
+    unsafeZeroWatchtowerFee?: boolean;
+};
+export type FromBTCWrapperOptions = ISwapWrapperOptions & {
+    safetyFactor: number;
+    blocksTillTxConfirms: number;
+    maxConfirmations: number;
+    minSendWindow: number;
+    bitcoinNetwork: BTC_NETWORK;
+    bitcoinBlocktime: number;
+};
+export type FromBTCDefinition<T extends ChainType> = IFromBTCSelfInitDefinition<T, FromBTCWrapper<T>, FromBTCSwap<T>>;
+export declare class FromBTCWrapper<T extends ChainType> extends IFromBTCWrapper<T, FromBTCDefinition<T>, FromBTCWrapperOptions> implements IClaimableSwapWrapper<FromBTCSwap<T>> {
+    readonly claimableSwapStates: FromBTCSwapState[];
+    readonly TYPE = SwapType.FROM_BTC;
+    readonly swapDeserializer: typeof FromBTCSwap;
+    readonly synchronizer: RelaySynchronizer<any, T["TX"], any>;
+    readonly btcRelay: BtcRelay<any, T["TX"], any>;
+    readonly btcRpc: BitcoinRpcWithAddressIndex<any>;
+    /**
+     * @param chainIdentifier
+     * @param unifiedStorage Storage interface for the current environment
+     * @param unifiedChainEvents On-chain event listener
+     * @param chain
+     * @param contract Underlying contract handling the swaps
+     * @param prices Pricing to use
+     * @param tokens
+     * @param swapDataDeserializer Deserializer for SwapData
+     * @param btcRelay
+     * @param synchronizer Btc relay synchronizer
+     * @param btcRpc Bitcoin RPC which also supports getting transactions by txoHash
+     * @param options
+     * @param events Instance to use for emitting events
+     */
+    constructor(chainIdentifier: string, unifiedStorage: UnifiedSwapStorage<T>, unifiedChainEvents: UnifiedSwapEventListener<T>, chain: T["ChainInterface"], contract: T["Contract"], prices: ISwapPrice, tokens: WrapperCtorTokens, swapDataDeserializer: new (data: any) => T["Data"], btcRelay: BtcRelay<any, T["TX"], any>, synchronizer: RelaySynchronizer<any, T["TX"], any>, btcRpc: BitcoinRpcWithAddressIndex<any>, options?: AllOptional<FromBTCWrapperOptions>, events?: EventEmitter<{
+        swapState: [ISwap];
+    }>);
+    readonly pendingSwapStates: FromBTCSwapState[];
+    readonly tickSwapState: FromBTCSwapState[];
+    protected processEventInitialize(swap: FromBTCSwap<T>, event: InitializeEvent<T["Data"]>): Promise<boolean>;
+    protected processEventClaim(swap: FromBTCSwap<T>, event: ClaimEvent<T["Data"]>): Promise<boolean>;
+    protected processEventRefund(swap: FromBTCSwap<T>, event: RefundEvent<T["Data"]>): Promise<boolean>;
+    /**
+     * Returns the swap expiry, leaving enough time for the user to send a transaction and for it to confirm
+     *
+     * @param data Parsed swap data
+     * @param requiredConfirmations Confirmations required to claim the tx
+     */
+    getOnchainSendTimeout(data: SwapData, requiredConfirmations: number): bigint;
+    /**
+     * Pre-fetches claimer (watchtower) bounty data for the swap. Doesn't throw, instead returns null and aborts the
+     *  provided abortController
+     *
+     * @param signer Smartchain signer address initiating the swap
+     * @param amountData
+     * @param options Options as passed to the swap creation function
+     * @param abortController
+     * @private
+     */
+    private preFetchClaimerBounty;
+    /**
+     * Returns calculated claimer bounty calculated from the claimer bounty data as fetched from preFetchClaimerBounty()
+     *
+     * @param data Parsed swap data returned from the intermediary
+     * @param options Options as passed to the swap creation function
+     * @param claimerBounty Claimer bounty data as fetched from preFetchClaimerBounty() function
+     * @private
+     */
+    private getClaimerBounty;
+    /**
+     * Verifies response returned from intermediary
+     *
+     * @param signer
+     * @param resp Response as returned by the intermediary
+     * @param amountData
+     * @param lp Intermediary
+     * @param options Options as passed to the swap creation function
+     * @param data Parsed swap data returned by the intermediary
+     * @param sequence Required swap sequence
+     * @param claimerBounty Claimer bount data as returned from the preFetchClaimerBounty() pre-fetch promise
+     * @param depositToken
+     * @private
+     * @throws {IntermediaryError} in case the response is invalid
+     */
+    private verifyReturnedData;
+    /**
+     * Returns a newly created swap, receiving 'amount' on chain
+     *
+     * @param signer                Smartchain signer's address intiating the swap
+     * @param amountData            Amount of token & amount to swap
+     * @param lps                   LPs (liquidity providers) to get the quotes from
+     * @param options               Quote options
+     * @param additionalParams      Additional parameters sent to the LP when creating the swap
+     * @param abortSignal           Abort signal for aborting the process
+     */
+    create(signer: string, amountData: AmountData, lps: Intermediary[], options?: FromBTCOptions, additionalParams?: Record<string, any>, abortSignal?: AbortSignal): {
+        quote: Promise<FromBTCSwap<T>>;
+        intermediary: Intermediary;
+    }[];
+}

package/dist/swaps/escrow_swaps/frombtc/onchain/FromBTCWrapper.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromBTCWrapper = void 0;
+const IFromBTCWrapper_1 = require("../IFromBTCWrapper");
+const FromBTCSwap_1 = require("./FromBTCSwap");
+const base_1 = require("@atomiqlabs/base");
+const buffer_1 = require("buffer");
+const IntermediaryError_1 = require("../../../../errors/IntermediaryError");
+const SwapType_1 = require("../../../../enums/SwapType");
+const Utils_1 = require("../../../../utils/Utils");
+const BitcoinUtils_1 = require("../../../../utils/BitcoinUtils");
+const IntermediaryAPI_1 = require("../../../../intermediaries/apis/IntermediaryAPI");
+const RequestError_1 = require("../../../../errors/RequestError");
+const utils_1 = require("@scure/btc-signer/utils");
+const RetryUtils_1 = require("../../../../utils/RetryUtils");
+class FromBTCWrapper extends IFromBTCWrapper_1.IFromBTCWrapper {
+    /**
+     * @param chainIdentifier
+     * @param unifiedStorage Storage interface for the current environment
+     * @param unifiedChainEvents On-chain event listener
+     * @param chain
+     * @param contract Underlying contract handling the swaps
+     * @param prices Pricing to use
+     * @param tokens
+     * @param swapDataDeserializer Deserializer for SwapData
+     * @param btcRelay
+     * @param synchronizer Btc relay synchronizer
+     * @param btcRpc Bitcoin RPC which also supports getting transactions by txoHash
+     * @param options
+     * @param events Instance to use for emitting events
+     */
+    constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, contract, prices, tokens, swapDataDeserializer, btcRelay, synchronizer, btcRpc, options, events) {
+        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, contract, prices, tokens, swapDataDeserializer, {
+            bitcoinNetwork: options?.bitcoinNetwork ?? utils_1.TEST_NETWORK,
+            safetyFactor: options?.safetyFactor ?? 2,
+            blocksTillTxConfirms: options?.blocksTillTxConfirms ?? 12,
+            maxConfirmations: options?.maxConfirmations ?? 6,
+            minSendWindow: options?.minSendWindow ?? 30 * 60,
+            bitcoinBlocktime: options?.bitcoinBlocktime ?? 10 * 60
+        }, events);
+        this.claimableSwapStates = [FromBTCSwap_1.FromBTCSwapState.BTC_TX_CONFIRMED];
+        this.TYPE = SwapType_1.SwapType.FROM_BTC;
+        this.swapDeserializer = FromBTCSwap_1.FromBTCSwap;
+        this.pendingSwapStates = [
+            FromBTCSwap_1.FromBTCSwapState.PR_CREATED,
+            FromBTCSwap_1.FromBTCSwapState.QUOTE_SOFT_EXPIRED,
+            FromBTCSwap_1.FromBTCSwapState.CLAIM_COMMITED,
+            FromBTCSwap_1.FromBTCSwapState.BTC_TX_CONFIRMED,
+            FromBTCSwap_1.FromBTCSwapState.EXPIRED
+        ];
+        this.tickSwapState = [FromBTCSwap_1.FromBTCSwapState.PR_CREATED, FromBTCSwap_1.FromBTCSwapState.CLAIM_COMMITED, FromBTCSwap_1.FromBTCSwapState.EXPIRED];
+        this.btcRelay = btcRelay;
+        this.synchronizer = synchronizer;
+        this.btcRpc = btcRpc;
+    }
+    processEventInitialize(swap, event) {
+        if (swap.state === FromBTCSwap_1.FromBTCSwapState.PR_CREATED || swap.state === FromBTCSwap_1.FromBTCSwapState.QUOTE_SOFT_EXPIRED) {
+            swap.state = FromBTCSwap_1.FromBTCSwapState.CLAIM_COMMITED;
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(false);
+    }
+    async processEventClaim(swap, event) {
+        if (swap.state !== FromBTCSwap_1.FromBTCSwapState.FAILED && swap.state !== FromBTCSwap_1.FromBTCSwapState.CLAIM_CLAIMED) {
+            await swap._setBitcoinTxId(buffer_1.Buffer.from(event.result, "hex").reverse().toString("hex")).catch(e => {
+                this.logger.warn("processEventClaim(): Error setting bitcoin txId: ", e);
+            });
+            swap.state = FromBTCSwap_1.FromBTCSwapState.CLAIM_CLAIMED;
+            return true;
+        }
+        return false;
+    }
+    processEventRefund(swap, event) {
+        if (swap.state !== FromBTCSwap_1.FromBTCSwapState.CLAIM_CLAIMED && swap.state !== FromBTCSwap_1.FromBTCSwapState.FAILED) {
+            swap.state = FromBTCSwap_1.FromBTCSwapState.FAILED;
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(false);
+    }
+    /**
+     * Returns the swap expiry, leaving enough time for the user to send a transaction and for it to confirm
+     *
+     * @param data Parsed swap data
+     * @param requiredConfirmations Confirmations required to claim the tx
+     */
+    getOnchainSendTimeout(data, requiredConfirmations) {
+        const tsDelta = (this.options.blocksTillTxConfirms + requiredConfirmations) * this.options.bitcoinBlocktime * this.options.safetyFactor;
+        return data.getExpiry() - BigInt(tsDelta);
+    }
+    /**
+     * Pre-fetches claimer (watchtower) bounty data for the swap. Doesn't throw, instead returns null and aborts the
+     *  provided abortController
+     *
+     * @param signer Smartchain signer address initiating the swap
+     * @param amountData
+     * @param options Options as passed to the swap creation function
+     * @param abortController
+     * @private
+     */
+    async preFetchClaimerBounty(signer, amountData, options, abortController) {
+        const startTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        if (options.unsafeZeroWatchtowerFee) {
+            return {
+                feePerBlock: 0n,
+                safetyFactor: options.blockSafetyFactor,
+                startTimestamp: startTimestamp,
+                addBlock: 0,
+                addFee: 0n
+            };
+        }
+        const dummyAmount = BigInt(Math.floor(Math.random() * 0x1000000));
+        const dummySwapData = await this.contract.createSwapData(base_1.ChainSwapType.CHAIN, signer, signer, amountData.token, dummyAmount, this.contract.getHashForOnchain((0, Utils_1.randomBytes)(20), dummyAmount, 3).toString("hex"), this.getRandomSequence(), startTimestamp, false, true, BigInt(Math.floor(Math.random() * 0x10000)), BigInt(Math.floor(Math.random() * 0x10000)));
+        try {
+            const [feePerBlock, btcRelayData, currentBtcBlock, claimFeeRate] = await Promise.all([
+                this.btcRelay.getFeePerBlock(),
+                this.btcRelay.getTipData(),
+                this.btcRpc.getTipHeight(),
+                this.contract.getClaimFee(signer, dummySwapData)
+            ]);
+            if (btcRelayData == null)
+                throw new Error("Btc relay not initialized!");
+            const currentBtcRelayBlock = btcRelayData.blockheight;
+            const addBlock = Math.max(currentBtcBlock - currentBtcRelayBlock, 0);
+            return {
+                feePerBlock: feePerBlock * options.feeSafetyFactor,
+                safetyFactor: options.blockSafetyFactor,
+                startTimestamp: startTimestamp,
+                addBlock,
+                addFee: claimFeeRate * options.feeSafetyFactor
+            };
+        }
+        catch (e) {
+            abortController.abort(e);
+            return undefined;
+        }
+    }
+    /**
+     * Returns calculated claimer bounty calculated from the claimer bounty data as fetched from preFetchClaimerBounty()
+     *
+     * @param data Parsed swap data returned from the intermediary
+     * @param options Options as passed to the swap creation function
+     * @param claimerBounty Claimer bounty data as fetched from preFetchClaimerBounty() function
+     * @private
+     */
+    getClaimerBounty(data, options, claimerBounty) {
+        const tsDelta = data.getExpiry() - claimerBounty.startTimestamp;
+        const blocksDelta = tsDelta / BigInt(this.options.bitcoinBlocktime) * BigInt(options.blockSafetyFactor);
+        const totalBlock = blocksDelta + BigInt(claimerBounty.addBlock);
+        return claimerBounty.addFee + (totalBlock * claimerBounty.feePerBlock);
+    }
+    /**
+     * Verifies response returned from intermediary
+     *
+     * @param signer
+     * @param resp Response as returned by the intermediary
+     * @param amountData
+     * @param lp Intermediary
+     * @param options Options as passed to the swap creation function
+     * @param data Parsed swap data returned by the intermediary
+     * @param sequence Required swap sequence
+     * @param claimerBounty Claimer bount data as returned from the preFetchClaimerBounty() pre-fetch promise
+     * @param depositToken
+     * @private
+     * @throws {IntermediaryError} in case the response is invalid
+     */
+    verifyReturnedData(signer, resp, amountData, lp, options, data, sequence, claimerBounty, depositToken) {
+        if (amountData.exactIn) {
+            if (resp.amount !== amountData.amount)
+                throw new IntermediaryError_1.IntermediaryError("Invalid amount returned");
+        }
+        else {
+            if (resp.total !== amountData.amount)
+                throw new IntermediaryError_1.IntermediaryError("Invalid total returned");
+        }
+        const requiredConfirmations = resp.confirmations;
+        if (requiredConfirmations > this.options.maxConfirmations)
+            throw new IntermediaryError_1.IntermediaryError("Requires too many confirmations");
+        const totalClaimerBounty = this.getClaimerBounty(data, options, claimerBounty);
+        if (data.getClaimerBounty() !== totalClaimerBounty ||
+            data.getType() != base_1.ChainSwapType.CHAIN ||
+            data.getSequence() !== sequence ||
+            data.getAmount() !== resp.total ||
+            data.isPayIn() ||
+            !data.isToken(amountData.token) ||
+            !data.isOfferer(lp.getAddress(this.chainIdentifier)) ||
+            !data.isClaimer(signer) ||
+            !data.isDepositToken(depositToken) ||
+            data.hasSuccessAction()) {
+            throw new IntermediaryError_1.IntermediaryError("Invalid data returned");
+        }
+        //Check that we have enough time to send the TX and for it to confirm
+        const expiry = this.getOnchainSendTimeout(data, requiredConfirmations);
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        if ((expiry - currentTimestamp) < BigInt(this.options.minSendWindow)) {
+            throw new IntermediaryError_1.IntermediaryError("Send window too low");
+        }
+        const lockingScript = (0, BitcoinUtils_1.toOutputScript)(this.options.bitcoinNetwork, resp.btcAddress);
+        const desiredExtraData = this.contract.getExtraData(lockingScript, resp.amount, requiredConfirmations);
+        const desiredClaimHash = this.contract.getHashForOnchain(lockingScript, resp.amount, requiredConfirmations);
+        if (!desiredClaimHash.equals(buffer_1.Buffer.from(data.getClaimHash(), "hex"))) {
+            throw new IntermediaryError_1.IntermediaryError("Invalid claim hash returned!");
+        }
+        const extraData = data.getExtraData();
+        if (extraData == null || !desiredExtraData.equals(buffer_1.Buffer.from(extraData, "hex"))) {
+            throw new IntermediaryError_1.IntermediaryError("Invalid extra data returned!");
+        }
+    }
+    /**
+     * Returns a newly created swap, receiving 'amount' on chain
+     *
+     * @param signer                Smartchain signer's address intiating the swap
+     * @param amountData            Amount of token & amount to swap
+     * @param lps                   LPs (liquidity providers) to get the quotes from
+     * @param options               Quote options
+     * @param additionalParams      Additional parameters sent to the LP when creating the swap
+     * @param abortSignal           Abort signal for aborting the process
+     */
+    create(signer, amountData, lps, options, additionalParams, abortSignal) {
+        const _options = {
+            blockSafetyFactor: options?.blockSafetyFactor ?? 1,
+            feeSafetyFactor: options?.feeSafetyFactor ?? 2n,
+            unsafeZeroWatchtowerFee: options?.unsafeZeroWatchtowerFee ?? false
+        };
+        const sequence = this.getRandomSequence();
+        const _abortController = (0, Utils_1.extendAbortController)(abortSignal);
+        const pricePrefetchPromise = this.preFetchPrice(amountData, _abortController.signal);
+        const usdPricePrefetchPromise = this.preFetchUsdPrice(_abortController.signal);
+        const claimerBountyPrefetchPromise = this.preFetchClaimerBounty(signer, amountData, _options, _abortController);
+        const nativeTokenAddress = this.chain.getNativeCurrencyAddress();
+        const feeRatePromise = this.preFetchFeeRate(signer, amountData, undefined, _abortController);
+        const _signDataPromise = this.contract.preFetchBlockDataForSignatures == null ?
+            this.preFetchSignData(Promise.resolve(true)) :
+            undefined;
+        return lps.map(lp => {
+            return {
+                intermediary: lp,
+                quote: (async () => {
+                    if (lp.services[SwapType_1.SwapType.FROM_BTC] == null)
+                        throw new Error("LP service for processing from btc swaps not found!");
+                    const abortController = (0, Utils_1.extendAbortController)(_abortController.signal);
+                    const liquidityPromise = this.preFetchIntermediaryLiquidity(amountData, lp, abortController);
+                    try {
+                        const { signDataPromise, resp } = await (0, RetryUtils_1.tryWithRetries)(async (retryCount) => {
+                            const { signDataPrefetch, response } = IntermediaryAPI_1.IntermediaryAPI.initFromBTC(this.chainIdentifier, lp.url, nativeTokenAddress, {
+                                claimer: signer,
+                                amount: amountData.amount,
+                                token: amountData.token.toString(),
+                                exactOut: !amountData.exactIn,
+                                sequence,
+                                claimerBounty: (0, Utils_1.throwIfUndefined)(claimerBountyPrefetchPromise),
+                                feeRate: (0, Utils_1.throwIfUndefined)(feeRatePromise),
+                                additionalParams
+                            }, this.options.postRequestTimeout, abortController.signal, retryCount > 0 ? false : undefined);
+                            return {
+                                signDataPromise: _signDataPromise ?? this.preFetchSignData(signDataPrefetch),
+                                resp: await response
+                            };
+                        }, undefined, e => e instanceof RequestError_1.RequestError, abortController.signal);
+                        const data = new this.swapDataDeserializer(resp.data);
+                        data.setClaimer(signer);
+                        this.verifyReturnedData(signer, resp, amountData, lp, _options, data, sequence, (await claimerBountyPrefetchPromise), nativeTokenAddress);
+                        const [pricingInfo, signatureExpiry] = await Promise.all([
+                            //Get intermediary's liquidity
+                            this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.FROM_BTC], false, resp.amount, resp.total, amountData.token, {}, pricePrefetchPromise, usdPricePrefetchPromise, abortController.signal),
+                            this.verifyReturnedSignature(signer, data, resp, feeRatePromise, signDataPromise, abortController.signal),
+                            this.verifyIntermediaryLiquidity(data.getAmount(), (0, Utils_1.throwIfUndefined)(liquidityPromise)),
+                        ]);
+                        const quote = new FromBTCSwap_1.FromBTCSwap(this, {
+                            pricingInfo,
+                            url: lp.url,
+                            expiry: signatureExpiry,
+                            swapFee: resp.swapFee,
+                            swapFeeBtc: resp.swapFee * resp.amount / (data.getAmount() - resp.swapFee),
+                            feeRate: (await feeRatePromise),
+                            signatureData: resp,
+                            data,
+                            address: resp.btcAddress,
+                            amount: resp.amount,
+                            exactIn: amountData.exactIn ?? true,
+                            requiredConfirmations: resp.confirmations
+                        });
+                        await quote._save();
+                        return quote;
+                    }
+                    catch (e) {
+                        abortController.abort(e);
+                        throw e;
+                    }
+                })()
+            };
+        });
+    }
+}
+exports.FromBTCWrapper = FromBTCWrapper;

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

@@ -0,0 +1,228 @@
+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";
+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>;
+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> {
+    protected readonly networkFee: bigint;
+    protected networkFeeBtc: bigint;
+    protected readonly abstract outputToken: BtcToken;
+    readonly data: T["Data"];
+    readonly signatureData?: SignatureData;
+    protected constructor(wrapper: D["Wrapper"], serializedObject: any);
+    protected constructor(wrapper: D["Wrapper"], init: IToBTCSwapInit<T["Data"]>);
+    protected getSwapData(): T["Data"];
+    protected upgradeVersion(): void;
+    /**
+     * In case swapFee in BTC is not supplied it recalculates it based on swap price
+     * @protected
+     */
+    protected tryRecomputeSwapPrice(): void;
+    /**
+     * Returns the payment hash identifier to be sent to the LP for getStatus and getRefund
+     * @protected
+     */
+    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
+     */
+    abstract _setPaymentResult(result: {
+        secret?: string;
+        txId?: string;
+    }, check?: boolean): Promise<boolean>;
+    getInputAddress(): string | null;
+    getInputTxId(): string | null;
+    requiresAction(): boolean;
+    /**
+     * Returns whether the swap is finished and in its terminal state (this can mean successful, refunded or failed)
+     */
+    isFinished(): boolean;
+    isRefundable(): boolean;
+    isQuoteExpired(): boolean;
+    isQuoteSoftExpired(): boolean;
+    isSuccessful(): boolean;
+    isFailed(): boolean;
+    _getInitiator(): string;
+    protected getSwapFee(): Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken>;
+    /**
+     * Returns network fee for the swap, the fee is represented in source currency & destination currency, but is
+     *  paid only once
+     */
+    protected getNetworkFee(): Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken>;
+    getFee(): Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken>;
+    getFeeBreakdown(): [
+        {
+            type: FeeType.SWAP;
+            fee: Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken>;
+        },
+        {
+            type: FeeType.NETWORK_OUTPUT;
+            fee: Fee<T["ChainId"], SCToken<T["ChainId"]>, BtcToken>;
+        }
+    ];
+    getInputToken(): SCToken<T["ChainId"]>;
+    getInput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>>;
+    getInputWithoutFee(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>>;
+    /**
+     * Checks if the intiator/sender has enough balance to go through with the swap
+     */
+    hasEnoughBalance(): Promise<{
+        enoughBalance: boolean;
+        balance: TokenAmount;
+        required: TokenAmount;
+    }>;
+    /**
+     * Check if the initiator/sender has enough balance to cover the transaction fee for processing the swap
+     */
+    hasEnoughForTxFees(): Promise<{
+        enoughBalance: boolean;
+        balance: TokenAmount;
+        required: TokenAmount;
+    }>;
+    /**
+     * 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 `swap.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>;
+    txsExecute(options?: {
+        skipChecks?: boolean;
+    }): Promise<{
+        name: "Commit";
+        description: string;
+        chain: T["ChainId"];
+        txs: T["TX"][];
+    }[]>;
+    /**
+     * 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)
+     *
+     * @throws {Error} When in invalid state (not PR_CREATED)
+     */
+    txsCommit(skipChecks?: boolean): Promise<T["TX"][]>;
+    /**
+     * Commits the swap on-chain, initiating the swap
+     *
+     * @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
+     */
+    commit(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, skipChecks?: boolean, onBeforeTxSent?: (txId: string) => void): Promise<string>;
+    /**
+     * Waits till a swap is committed, should be called after sending the commit transactions manually
+     *
+     * @param abortSignal   AbortSignal
+     * @throws {Error} If swap is not in the correct state (must be CREATED)
+     */
+    waitTillCommited(abortSignal?: AbortSignal): Promise<void>;
+    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
+     * @private
+     */
+    protected checkIntermediarySwapProcessed(save?: boolean): Promise<boolean>;
+    /**
+     * A blocking promise resolving when swap was concluded by the intermediary,
+     *  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.
+     * @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)
+     */
+    waitForPayment(maxWaitTimeSeconds?: number, checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
+    /**
+     * Get the estimated smart chain transaction fee of the refund transaction
+     */
+    getRefundFee(): Promise<bigint>;
+    /**
+     * Returns transactions for refunding the swap if the swap is in refundable state, you can check so with isRefundable()
+     *
+     * @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): Promise<T["TX"][]>;
+    /**
+     * Refunds the swap if the swap is in refundable state, you can check so with isRefundable()
+     *
+     * @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
+     */
+    refund(_signer: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal): Promise<string>;
+    /**
+     * Waits till a swap is refunded, should be called after sending the refund transactions manually
+     *
+     * @param abortSignal   AbortSignal
+     * @throws {Error} When swap is not in a valid state (must be COMMITED)
+     * @throws {Error} If we tried to refund but claimer was able to claim first
+     */
+    waitTillRefunded(abortSignal?: AbortSignal): Promise<void>;
+    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;
+    _shouldFetchCommitStatus(): boolean;
+    _shouldFetchExpiryStatus(): boolean;
+    _sync(save?: boolean, quoteDefinitelyExpired?: boolean, commitStatus?: SwapCommitState): Promise<boolean>;
+    _tick(save?: boolean): Promise<boolean>;
+}
+export declare enum ToBTCSwapState {
+    REFUNDED = -3,
+    QUOTE_EXPIRED = -2,
+    QUOTE_SOFT_EXPIRED = -1,
+    CREATED = 0,
+    COMMITED = 1,
+    SOFT_CLAIMED = 2,
+    CLAIMED = 3,
+    REFUNDABLE = 4
+}