@atomiqlabs/sdk

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