@atomiqlabs/sdk 8.8.3 → 8.8.4

package/src/swaps/IAddressSwap.ts

@@ -1,30 +1,30 @@
-/**
- * Type guard to check if an object is an {@link IAddressSwap}
- *
- * @category Swaps/Types
- */
-export function isIAddressSwap(obj: any): obj is IAddressSwap {
-    return obj!=null &&
-        typeof(obj.getAddress) === "function" &&
-        typeof(obj.getHyperlink) === "function";
-}
-
-/**
- * Interface for swaps which require a user to send funds to a specific address
- *
- * @category Swaps/Types
- */
-export interface IAddressSwap {
-
-    /**
-     * An address to which the user needs to send funds on the source chain
-     */
-    getAddress(): string;
-
-    /**
-     * A hyperlink representation of the address + amount that the user needs to sends on the source chain.
-     *  This is suitable to be displayed in a form of QR code.
-     */
-    getHyperlink(): string;
-
-}
+/**
+ * Type guard to check if an object is an {@link IAddressSwap}
+ *
+ * @category Swaps/Types
+ */
+export function isIAddressSwap(obj: any): obj is IAddressSwap {
+    return obj!=null &&
+        typeof(obj.getAddress) === "function" &&
+        typeof(obj.getHyperlink) === "function";
+}
+
+/**
+ * Interface for swaps which require a user to send funds to a specific address
+ *
+ * @category Swaps/Types
+ */
+export interface IAddressSwap {
+
+    /**
+     * An address to which the user needs to send funds on the source chain
+     */
+    getAddress(): string;
+
+    /**
+     * A hyperlink representation of the address + amount that the user needs to sends on the source chain.
+     *  This is suitable to be displayed in a form of QR code.
+     */
+    getHyperlink(): string;
+
+}

package/src/swaps/IBTCWalletSwap.ts

@@ -1,93 +1,93 @@
-import {IBitcoinWallet} from "../bitcoin/wallet/IBitcoinWallet";
-import {Transaction} from "@scure/btc-signer";
-import {
-    MinimalBitcoinWalletInterface,
-    MinimalBitcoinWalletInterfaceWithSigner
-} from "../types/wallets/MinimalBitcoinWalletInterface";
-import {TokenAmount} from "../types/TokenAmount";
-import {BtcToken} from "../types/Token";
-
-/**
- * Type guard to check if an object is an {@link IBTCWalletSwap}
- *
- * @category Swaps/Types
- */
-export function isIBTCWalletSwap(obj: any): obj is IBTCWalletSwap {
-    return obj!=null &&
-        typeof(obj.getFundedPsbt) === "function" &&
-        typeof(obj.submitPsbt) === "function" &&
-        typeof(obj.estimateBitcoinFee) === "function" &&
-        typeof(obj.sendBitcoinTransaction) === "function" &&
-        typeof(obj.waitForBitcoinTransaction) === "function" &&
-        typeof(obj.getRequiredConfirmationsCount) === "function";
-}
-
-/**
- * Interface for swaps requiring Bitcoin wallet interaction
- *
- * @category Swaps/Types
- */
-export interface IBTCWalletSwap {
-
-    /**
-     * Returns the PSBT that is already funded with wallet's UTXOs (runs a coin-selection algorithm to choose UTXOs to use),
-     *  also returns inputs indices that need to be signed by the wallet before submitting the PSBT back to the SDK with
-     *  {@link submitPsbt}
-     *
-     * @param _bitcoinWallet Sender's bitcoin wallet
-     * @param feeRate Optional fee rate in sats/vB for the transaction
-     * @param additionalOutputs additional outputs to add to the PSBT - can be used to collect fees from users
-     */
-    getFundedPsbt(
-        _bitcoinWallet: IBitcoinWallet | MinimalBitcoinWalletInterface,
-        feeRate?: number,
-        additionalOutputs?: ({amount: bigint, outputScript: Uint8Array} | {amount: bigint, address: string})[]
-    ): Promise<{psbt: Transaction, psbtHex: string, psbtBase64: string, signInputs: number[]}>;
-
-    /**
-     * Submits a PSBT signed by the wallet back to the SDK
-     *
-     * @param psbt A PSBT, either a Transaction object or a hex or base64 encoded PSBT string
-     */
-    submitPsbt(psbt: Transaction | string): Promise<string>;
-
-    /**
-     * Estimates a bitcoin on-chain fee paid for the bitcoin swap transaction
-     *
-     * @param wallet Sender's bitcoin wallet
-     * @param feeRate Optional fee rate in sats/vB for the transaction
-     */
-    estimateBitcoinFee(wallet: IBitcoinWallet | MinimalBitcoinWalletInterface, feeRate?: number): Promise<TokenAmount<BtcToken<false>> | null>;
-
-    /**
-     * Sends a swap bitcoin transaction via the passed bitcoin wallet
-     *
-     * @param wallet Sender's bitcoin wallet
-     * @param feeRate Optional fee rate in sats/vB for the transaction
-     */
-    sendBitcoinTransaction(
-        wallet: IBitcoinWallet | MinimalBitcoinWalletInterfaceWithSigner,
-        feeRate?: number
-    ): Promise<string>;
-
-    /**
-     * Waits till the bitcoin transaction gets the required number of confirmations
-     *
-     * @param updateCallback Callback called when txId is found, and also called with subsequent confirmations
-     * @param checkIntervalSeconds How often to check the bitcoin transaction
-     * @param abortSignal Abort signal
-     * @throws {Error} if in invalid state
-     */
-    waitForBitcoinTransaction(
-        updateCallback?: (txId?: string, confirmations?: number, targetConfirmations?: number, txEtaMs?: number) => void,
-        checkIntervalSeconds?: number,
-        abortSignal?: AbortSignal,
-    ): Promise<string>;
-
-    /**
-     * Returns the number of confirmations required for the bitcoin transaction for this swap
-     *  to complete and settle
-     */
-    getRequiredConfirmationsCount(): number;
-
+import {IBitcoinWallet} from "../bitcoin/wallet/IBitcoinWallet";
+import {Transaction} from "@scure/btc-signer";
+import {
+    MinimalBitcoinWalletInterface,
+    MinimalBitcoinWalletInterfaceWithSigner
+} from "../types/wallets/MinimalBitcoinWalletInterface";
+import {TokenAmount} from "../types/TokenAmount";
+import {BtcToken} from "../types/Token";
+
+/**
+ * Type guard to check if an object is an {@link IBTCWalletSwap}
+ *
+ * @category Swaps/Types
+ */
+export function isIBTCWalletSwap(obj: any): obj is IBTCWalletSwap {
+    return obj!=null &&
+        typeof(obj.getFundedPsbt) === "function" &&
+        typeof(obj.submitPsbt) === "function" &&
+        typeof(obj.estimateBitcoinFee) === "function" &&
+        typeof(obj.sendBitcoinTransaction) === "function" &&
+        typeof(obj.waitForBitcoinTransaction) === "function" &&
+        typeof(obj.getRequiredConfirmationsCount) === "function";
+}
+
+/**
+ * Interface for swaps requiring Bitcoin wallet interaction
+ *
+ * @category Swaps/Types
+ */
+export interface IBTCWalletSwap {
+
+    /**
+     * Returns the PSBT that is already funded with wallet's UTXOs (runs a coin-selection algorithm to choose UTXOs to use),
+     *  also returns inputs indices that need to be signed by the wallet before submitting the PSBT back to the SDK with
+     *  {@link submitPsbt}
+     *
+     * @param _bitcoinWallet Sender's bitcoin wallet
+     * @param feeRate Optional fee rate in sats/vB for the transaction
+     * @param additionalOutputs additional outputs to add to the PSBT - can be used to collect fees from users
+     */
+    getFundedPsbt(
+        _bitcoinWallet: IBitcoinWallet | MinimalBitcoinWalletInterface,
+        feeRate?: number,
+        additionalOutputs?: ({amount: bigint, outputScript: Uint8Array} | {amount: bigint, address: string})[]
+    ): Promise<{psbt: Transaction, psbtHex: string, psbtBase64: string, signInputs: number[]}>;
+
+    /**
+     * Submits a PSBT signed by the wallet back to the SDK
+     *
+     * @param psbt A PSBT, either a Transaction object or a hex or base64 encoded PSBT string
+     */
+    submitPsbt(psbt: Transaction | string): Promise<string>;
+
+    /**
+     * Estimates a bitcoin on-chain fee paid for the bitcoin swap transaction
+     *
+     * @param wallet Sender's bitcoin wallet
+     * @param feeRate Optional fee rate in sats/vB for the transaction
+     */
+    estimateBitcoinFee(wallet: IBitcoinWallet | MinimalBitcoinWalletInterface, feeRate?: number): Promise<TokenAmount<BtcToken<false>> | null>;
+
+    /**
+     * Sends a swap bitcoin transaction via the passed bitcoin wallet
+     *
+     * @param wallet Sender's bitcoin wallet
+     * @param feeRate Optional fee rate in sats/vB for the transaction
+     */
+    sendBitcoinTransaction(
+        wallet: IBitcoinWallet | MinimalBitcoinWalletInterfaceWithSigner,
+        feeRate?: number
+    ): Promise<string>;
+
+    /**
+     * Waits till the bitcoin transaction gets the required number of confirmations
+     *
+     * @param updateCallback Callback called when txId is found, and also called with subsequent confirmations
+     * @param checkIntervalSeconds How often to check the bitcoin transaction
+     * @param abortSignal Abort signal
+     * @throws {Error} if in invalid state
+     */
+    waitForBitcoinTransaction(
+        updateCallback?: (txId?: string, confirmations?: number, targetConfirmations?: number, txEtaMs?: number) => void,
+        checkIntervalSeconds?: number,
+        abortSignal?: AbortSignal,
+    ): Promise<string>;
+
+    /**
+     * Returns the number of confirmations required for the bitcoin transaction for this swap
+     *  to complete and settle
+     */
+    getRequiredConfirmationsCount(): number;
+
 }

package/src/swaps/IClaimableSwap.ts

@@ -1,65 +1,65 @@
-import {ChainType} from "@atomiqlabs/base";
-import {ISwap} from "./ISwap";
-import {ISwapWrapper, SwapTypeDefinition} from "./ISwapWrapper";
-
-/**
- * Type guard to check if an object is an {@link IClaimableSwap}
- *
- * @category Swaps/Types
- */
-export function isIClaimableSwap(obj: any): obj is IClaimableSwap {
-    return obj!=null &&
-        typeof(obj.isClaimable) === "function" &&
-        typeof(obj.txsClaim) === "function" &&
-        typeof(obj.claim) === "function";
-}
-
-/**
- * Interface for swaps that can end up in a claimable state, requiring the user to claim the
- *  assets on the destination chain.
- *
- * @category Swaps/Types
- */
-export interface IClaimableSwap<
-    T extends ChainType = ChainType,
-    D extends SwapTypeDefinition<T, ISwapWrapper<T, D>, IClaimableSwap<T, D, S>> = SwapTypeDefinition<T, ISwapWrapper<T, any>, IClaimableSwap<T, any, any>>,
-    S extends number = number
-> extends ISwap<T, D, S> {
-
-    /**
-     * Checks whether a swap currently requires a manual claiming (settlement)
-     */
-    isClaimable(): boolean;
-
-    /**
-     * Returns transactions for settling (claiming) the swap if the swap requires manual settlement, you can check
-     *  so with {@link isClaimable}. After sending the transaction manually be sure to call the {@link waitTillClaimed}
-     *  function to wait till the claim transaction is observed, processed by the SDK and state of the swap
-     *  properly updated.
-     *
-     * @param _signer Address of the signer to create the settlement (claim) transactions for
-     */
-    txsClaim(_signer?: string | T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]>;
-
-    /**
-     * Settles the swap by claiming the funds on the destination chain if the swap requires manual settlement,
-     *  you can check so with {@link isClaimable}
-     *
-     * @param _signer Signer to use for signing the settlement transactions
-     * @param abortSignal Abort signal
-     * @param onBeforeTxSent Optional callback triggered before the claim transaction is broadcasted
-     */
-    claim(_signer?: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, onBeforeTxSent?: (txId: string) => void): Promise<string>;
-
-    /**
-     * Waits till the swap is successfully settled (claimed), should be called after sending the claim (settlement)
-     *  transactions manually to wait till the SDK processes the settlement and updates the swap state accordingly
-     *
-     * @param maxWaitTimeSeconds Maximum time in seconds to wait for the swap to be settled
-     * @param abortSignal AbortSignal
-     *
-     * @returns {boolean} whether the swap was claimed in time or not
-     */
-    waitTillClaimed(maxWaitTimeSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
-
-}
+import {ChainType} from "@atomiqlabs/base";
+import {ISwap} from "./ISwap";
+import {ISwapWrapper, SwapTypeDefinition} from "./ISwapWrapper";
+
+/**
+ * Type guard to check if an object is an {@link IClaimableSwap}
+ *
+ * @category Swaps/Types
+ */
+export function isIClaimableSwap(obj: any): obj is IClaimableSwap {
+    return obj!=null &&
+        typeof(obj.isClaimable) === "function" &&
+        typeof(obj.txsClaim) === "function" &&
+        typeof(obj.claim) === "function";
+}
+
+/**
+ * Interface for swaps that can end up in a claimable state, requiring the user to claim the
+ *  assets on the destination chain.
+ *
+ * @category Swaps/Types
+ */
+export interface IClaimableSwap<
+    T extends ChainType = ChainType,
+    D extends SwapTypeDefinition<T, ISwapWrapper<T, D>, IClaimableSwap<T, D, S>> = SwapTypeDefinition<T, ISwapWrapper<T, any>, IClaimableSwap<T, any, any>>,
+    S extends number = number
+> extends ISwap<T, D, S> {
+
+    /**
+     * Checks whether a swap currently requires a manual claiming (settlement)
+     */
+    isClaimable(): boolean;
+
+    /**
+     * Returns transactions for settling (claiming) the swap if the swap requires manual settlement, you can check
+     *  so with {@link isClaimable}. After sending the transaction manually be sure to call the {@link waitTillClaimed}
+     *  function to wait till the claim transaction is observed, processed by the SDK and state of the swap
+     *  properly updated.
+     *
+     * @param _signer Address of the signer to create the settlement (claim) transactions for
+     */
+    txsClaim(_signer?: string | T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]>;
+
+    /**
+     * Settles the swap by claiming the funds on the destination chain if the swap requires manual settlement,
+     *  you can check so with {@link isClaimable}
+     *
+     * @param _signer Signer to use for signing the settlement transactions
+     * @param abortSignal Abort signal
+     * @param onBeforeTxSent Optional callback triggered before the claim transaction is broadcasted
+     */
+    claim(_signer?: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, onBeforeTxSent?: (txId: string) => void): Promise<string>;
+
+    /**
+     * Waits till the swap is successfully settled (claimed), should be called after sending the claim (settlement)
+     *  transactions manually to wait till the SDK processes the settlement and updates the swap state accordingly
+     *
+     * @param maxWaitTimeSeconds Maximum time in seconds to wait for the swap to be settled
+     * @param abortSignal AbortSignal
+     *
+     * @returns {boolean} whether the swap was claimed in time or not
+     */
+    waitTillClaimed(maxWaitTimeSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
+
+}

package/src/swaps/IClaimableSwapWrapper.ts

@@ -1,18 +1,18 @@
-import {ISwap} from "./ISwap";
-import {IClaimableSwap} from "./IClaimableSwap";
-
-/**
- * Interface for a swap wrapper for swaps that can end up in a claimable state, requiring the user to claim the
- *  assets on the destination chain.
- *
- * @category Swaps/Abstract
- */
-export interface IClaimableSwapWrapper<T extends ISwap & IClaimableSwap = ISwap & IClaimableSwap> {
-
-    /**
-     * A list of swap states when the swap is potentially claimable
-     * @internal
-     */
-    _claimableSwapStates: T["_state"][];
-
+import {ISwap} from "./ISwap";
+import {IClaimableSwap} from "./IClaimableSwap";
+
+/**
+ * Interface for a swap wrapper for swaps that can end up in a claimable state, requiring the user to claim the
+ *  assets on the destination chain.
+ *
+ * @category Swaps/Abstract
+ */
+export interface IClaimableSwapWrapper<T extends ISwap & IClaimableSwap = ISwap & IClaimableSwap> {
+
+    /**
+     * A list of swap states when the swap is potentially claimable
+     * @internal
+     */
+    _claimableSwapStates: T["_state"][];
+
 }

package/src/swaps/IRefundableSwap.ts

@@ -1,58 +1,58 @@
-import {ChainType} from "@atomiqlabs/base";
-import {ISwap} from "./ISwap";
-import {ISwapWrapper, SwapTypeDefinition} from "./ISwapWrapper";
-
-/**
- * Type guard to check if an object is an {@link IRefundableSwap}
- *
- * @category Swaps/Types
- */
-export function isIRefundableSwap(obj: any): obj is IRefundableSwap {
-    return typeof(obj.isRefundable) === "function" &&
-        typeof(obj.txsRefund) === "function" &&
-        typeof(obj.refund) === "function";
-}
-
-/**
- * Interface for swaps that can be refunded in case of failure
- *
- * @category Swaps/Types
- */
-export interface IRefundableSwap<
-    T extends ChainType = ChainType,
-    D extends SwapTypeDefinition<T, ISwapWrapper<T, D>, IRefundableSwap<T, D, S>> = SwapTypeDefinition<T, ISwapWrapper<T, any>, IRefundableSwap<T, any, any>>,
-    S extends number = number
-> extends ISwap<T, D, S> {
-
-    /**
-     * Checks whether a swap is currently refundable
-     */
-    isRefundable(): boolean;
-
-    /**
-     * Returns transactions for refunding the swap if the swap is in refundable state, you can check so with
-     *  {@link isRefundable}. After sending the transaction manually be sure to call the {@link waitTillRefunded}
-     *  function to wait till the refund transaction is observed, processed by the SDK and state of the swap
-     *  properly updated.
-     *
-     * @param _signer Address of the signer to create the refund transactions for
-     */
-    txsRefund(_signer?: string): Promise<T["TX"][]>;
-
-    /**
-     * Refunds the swap if the swap is in refundable state, you can check so with {@link isRefundable}
-     *
-     * @param _signer Signer to sign the transactions with, must be the same as used in the initialization
-     * @param abortSignal Abort signal
-     */
-    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 to
-     *  wait till the SDK processes the refund and updates the swap state accordingly
-     *
-     * @param abortSignal AbortSignal
-     */
-    waitTillRefunded(abortSignal?: AbortSignal): Promise<void>;
-
-}
+import {ChainType} from "@atomiqlabs/base";
+import {ISwap} from "./ISwap";
+import {ISwapWrapper, SwapTypeDefinition} from "./ISwapWrapper";
+
+/**
+ * Type guard to check if an object is an {@link IRefundableSwap}
+ *
+ * @category Swaps/Types
+ */
+export function isIRefundableSwap(obj: any): obj is IRefundableSwap {
+    return typeof(obj.isRefundable) === "function" &&
+        typeof(obj.txsRefund) === "function" &&
+        typeof(obj.refund) === "function";
+}
+
+/**
+ * Interface for swaps that can be refunded in case of failure
+ *
+ * @category Swaps/Types
+ */
+export interface IRefundableSwap<
+    T extends ChainType = ChainType,
+    D extends SwapTypeDefinition<T, ISwapWrapper<T, D>, IRefundableSwap<T, D, S>> = SwapTypeDefinition<T, ISwapWrapper<T, any>, IRefundableSwap<T, any, any>>,
+    S extends number = number
+> extends ISwap<T, D, S> {
+
+    /**
+     * Checks whether a swap is currently refundable
+     */
+    isRefundable(): boolean;
+
+    /**
+     * Returns transactions for refunding the swap if the swap is in refundable state, you can check so with
+     *  {@link isRefundable}. After sending the transaction manually be sure to call the {@link waitTillRefunded}
+     *  function to wait till the refund transaction is observed, processed by the SDK and state of the swap
+     *  properly updated.
+     *
+     * @param _signer Address of the signer to create the refund transactions for
+     */
+    txsRefund(_signer?: string): Promise<T["TX"][]>;
+
+    /**
+     * Refunds the swap if the swap is in refundable state, you can check so with {@link isRefundable}
+     *
+     * @param _signer Signer to sign the transactions with, must be the same as used in the initialization
+     * @param abortSignal Abort signal
+     */
+    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 to
+     *  wait till the SDK processes the refund and updates the swap state accordingly
+     *
+     * @param abortSignal AbortSignal
+     */
+    waitTillRefunded(abortSignal?: AbortSignal): Promise<void>;
+
+}