@atomiqlabs/sdk 8.6.6 → 8.6.8

package/dist/swaps/IAddressSwap.d.ts

@@ -1,22 +1,22 @@
-/**
- * Type guard to check if an object is an {@link IAddressSwap}
- *
- * @category Swaps/Types
- */
-export declare function isIAddressSwap(obj: any): obj is IAddressSwap;
-/**
- * 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 declare function isIAddressSwap(obj: any): obj is IAddressSwap;
+/**
+ * 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/dist/swaps/IAddressSwap.js

@@ -1,13 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIAddressSwap = isIAddressSwap;
-/**
- * Type guard to check if an object is an {@link IAddressSwap}
- *
- * @category Swaps/Types
- */
-function isIAddressSwap(obj) {
-    return obj != null &&
-        typeof (obj.getAddress) === "function" &&
-        typeof (obj.getHyperlink) === "function";
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIAddressSwap = void 0;
+/**
+ * Type guard to check if an object is an {@link IAddressSwap}
+ *
+ * @category Swaps/Types
+ */
+function isIAddressSwap(obj) {
+    return obj != null &&
+        typeof (obj.getAddress) === "function" &&
+        typeof (obj.getHyperlink) === "function";
+}
+exports.isIAddressSwap = isIAddressSwap;

package/dist/swaps/IBTCWalletSwap.d.ts

@@ -1,73 +1,73 @@
-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 declare function isIBTCWalletSwap(obj: any): obj is IBTCWalletSwap;
-/**
- * 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 declare function isIBTCWalletSwap(obj: any): obj is IBTCWalletSwap;
+/**
+ * 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/dist/swaps/IBTCWalletSwap.js

@@ -1,17 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIBTCWalletSwap = isIBTCWalletSwap;
-/**
- * Type guard to check if an object is an {@link IBTCWalletSwap}
- *
- * @category Swaps/Types
- */
-function isIBTCWalletSwap(obj) {
-    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";
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIBTCWalletSwap = void 0;
+/**
+ * Type guard to check if an object is an {@link IBTCWalletSwap}
+ *
+ * @category Swaps/Types
+ */
+function isIBTCWalletSwap(obj) {
+    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";
+}
+exports.isIBTCWalletSwap = isIBTCWalletSwap;

package/dist/swaps/IClaimableSwap.d.ts

@@ -1,49 +1,49 @@
-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 declare function isIClaimableSwap(obj: any): obj is IClaimableSwap;
-/**
- * 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 declare function isIClaimableSwap(obj: any): obj is IClaimableSwap;
+/**
+ * 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/dist/swaps/IClaimableSwap.js

@@ -1,14 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIClaimableSwap = isIClaimableSwap;
-/**
- * Type guard to check if an object is an {@link IClaimableSwap}
- *
- * @category Swaps/Types
- */
-function isIClaimableSwap(obj) {
-    return obj != null &&
-        typeof (obj.isClaimable) === "function" &&
-        typeof (obj.txsClaim) === "function" &&
-        typeof (obj.claim) === "function";
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIClaimableSwap = void 0;
+/**
+ * Type guard to check if an object is an {@link IClaimableSwap}
+ *
+ * @category Swaps/Types
+ */
+function isIClaimableSwap(obj) {
+    return obj != null &&
+        typeof (obj.isClaimable) === "function" &&
+        typeof (obj.txsClaim) === "function" &&
+        typeof (obj.claim) === "function";
+}
+exports.isIClaimableSwap = isIClaimableSwap;

package/dist/swaps/IClaimableSwapWrapper.d.ts

@@ -1,15 +1,15 @@
-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/dist/swaps/IClaimableSwapWrapper.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/swaps/IRefundableSwap.d.ts

@@ -1,43 +1,43 @@
-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 declare function isIRefundableSwap(obj: any): obj is IRefundableSwap;
-/**
- * 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 declare function isIRefundableSwap(obj: any): obj is IRefundableSwap;
+/**
+ * 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>;
+}

package/dist/swaps/IRefundableSwap.js

@@ -1,13 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIRefundableSwap = isIRefundableSwap;
-/**
- * Type guard to check if an object is an {@link IRefundableSwap}
- *
- * @category Swaps/Types
- */
-function isIRefundableSwap(obj) {
-    return typeof (obj.isRefundable) === "function" &&
-        typeof (obj.txsRefund) === "function" &&
-        typeof (obj.refund) === "function";
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIRefundableSwap = void 0;
+/**
+ * Type guard to check if an object is an {@link IRefundableSwap}
+ *
+ * @category Swaps/Types
+ */
+function isIRefundableSwap(obj) {
+    return typeof (obj.isRefundable) === "function" &&
+        typeof (obj.txsRefund) === "function" &&
+        typeof (obj.refund) === "function";
+}
+exports.isIRefundableSwap = isIRefundableSwap;