@buildonspark/spark-sdk 0.1.44 → 0.1.46

package/dist/index.d.cts

@@ -1,28 +1,773 @@
-export { A as AuthenticationError, C as ConfigurationError, b as InternalValidationError, N as NetworkError, d as NotImplementedError, R as RPCError, a as SparkSDKError, S as SparkWallet, V as ValidationError, c as createDummyTx } from './index-CZmDdSts.cjs';
-export { BroadcastConfig, BroadcastResult, DEFAULT_FEE_SATS, FeeBumpTxChain, FeeBumpTxPackage, FeeRate, LeafInfo, TxChain, Utxo, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, calculateAvailableTokenAmount, checkIfSelectedOutputsAreAvailable, checkIfValidSequence, collectResponses, computeTaprootKeyNoScript, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createRefundTx, createSigningCommitment, createSigningNonce, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, filterTokenBalanceForTokenPublicKey, generateAdaptorFromSignature, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getSparkAddressFromTaproot, getTransactionSequence, getTransferPackageSigningPayload, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, isEphemeralAnchorOutput, isTxBroadcast, lastKeyWithTarget, maybeApplyFee, proofOfPossessionMessageHashForDepositAddress, subtractPrivateKeys, subtractPublicKeys, sumOfPrivateKeys, validateOutboundAdaptorSignature } from './utils/index.cjs';
-export { L as LRC_WALLET_NETWORK, c as LRC_WALLET_NETWORK_TYPE, N as Network, b as NetworkToProto, a as NetworkType, g as getNetwork, d as getNetworkFromAddress, e as getNetworkFromString } from './network-CfxLnaot.cjs';
-export { V as VerifiableSecretShare, d as bigIntToPrivateKey, c as computerLagrangeCoefficients, e as evaluatePolynomial, f as fieldDiv, a as generatePolynomialForSecretSharing, g as getRandomBigInt, m as modInverse, r as recoverSecret, s as splitSecret, b as splitSecretWithProofs, v as validateShare } from './signer-DaY8c60s.cjs';
-import './RequestLightningSendInput-BxbCtwpV.cjs';
+import { m as LeavesSwapFeeEstimateOutput, D as StaticDepositQuoteOutput, C as ClaimStaticDepositOutput, q as LightningReceiveRequest, u as LightningSendRequest, E as ExitSpeed, f as CoopExitFeeQuote, i as CoopExitRequest, T as Transfer$1 } from './RequestLightningSendInput-2cSh_In4.cjs';
+import { L as LightningSendFeeEstimateInput } from './LightningSendFeeEstimateInput-BgOhEAI-.cjs';
+import { h as SigningCommitment, V as VerifiableSecretShare, S as SparkSigner } from './signer-BP6F__oR.cjs';
+export { d as bigIntToPrivateKey, c as computerLagrangeCoefficients, e as evaluatePolynomial, f as fieldDiv, a as generatePolynomialForSecretSharing, g as getRandomBigInt, m as modInverse, r as recoverSecret, s as splitSecret, b as splitSecretWithProofs, v as validateShare } from './signer-BP6F__oR.cjs';
+import { h as RequestedSigningCommitments, U as UserSignedTxSigningJob, b as TreeNode, e as Transfer, L as LeafRefundTxSigningResult, i as NodeSignatures, F as FinalizeNodeSignaturesResponse, Q as QueryTransfersResponse, j as OutputWithPreviousTransactionData } from './spark-DbzGfse6.cjs';
+import { WalletConfigService } from './services/config.cjs';
+import { ConnectionManager } from './services/connection.cjs';
+import { Lrc20ConnectionManager } from './services/lrc-connection.cjs';
+import { Transaction } from '@scure/btc-signer';
+import { ConfigOptions } from './services/wallet-config.cjs';
+import { LRCWallet } from '@buildonspark/lrc20-sdk';
+import { EventEmitter } from 'eventemitter3';
+import { SparkAddressFormat } from './address/index.cjs';
+import { a as WalletTransfer, W as WalletLeaf } from './sdk-types-Ct8xmN7l.cjs';
+import { S as SparkWalletProps, I as InitWalletResponse, b as TokenBalanceMap, T as TransferParams, C as CreateLightningInvoiceParams, P as PayLightningInvoiceParams } from './index-CKL5DodV.cjs';
+export { a6 as BroadcastConfig, a7 as BroadcastResult, U as DEFAULT_FEE_SATS, a4 as FeeBumpTxChain, a3 as FeeBumpTxPackage, a2 as FeeRate, a0 as LeafInfo, a5 as TxChain, a1 as Utxo, t as addPrivateKeys, q as addPublicKeys, e as applyAdaptorToSignature, r as applyAdditiveTweakToPublicKey, N as calculateAvailableTokenAmount, O as checkIfSelectedOutputsAreAvailable, Z as checkIfValidSequence, B as collectResponses, f as computeTaprootKeyNoScript, ab as constructFeeBumpTx, aa as constructUnilateralExitFeeBumpPackages, a9 as constructUnilateralExitTxs, W as createRefundTx, K as createSigningCommitment, F as createSigningNonce, M as decodeBytesToSigningCommitment, J as decodeBytesToSigningNonce, L as encodeSigningCommitmentToBytes, H as encodeSigningNonceToBytes, Q as filterTokenBalanceForTokenPublicKey, d as generateAdaptorFromSignature, g as generateSignatureFromExistingAdaptor, X as getCurrentTimelock, $ as getEphemeralAnchorOutput, y as getLatestDepositTxId, _ as getNextTransactionSequence, j as getP2TRAddressFromPkScript, i as getP2TRAddressFromPublicKey, h as getP2TRScriptFromPublicKey, k as getP2WPKHAddressFromPublicKey, E as getRandomSigningNonce, n as getSigHashFromTx, G as getSigningCommitmentFromNonce, ac as getSparkAddressFromTaproot, Y as getTransactionSequence, R as getTransferPackageSigningPayload, m as getTxFromRawTxBytes, l as getTxFromRawTxHex, o as getTxId, p as getTxIdNoReverse, a8 as isEphemeralAnchorOutput, z as isTxBroadcast, x as lastKeyWithTarget, V as maybeApplyFee, A as proofOfPossessionMessageHashForDepositAddress, u as subtractPrivateKeys, s as subtractPublicKeys, w as sumOfPrivateKeys, v as validateOutboundAdaptorSignature } from './index-CKL5DodV.cjs';
+import { TokenTransactionWithStatus } from './proto/spark_token.cjs';
+export { L as LRC_WALLET_NETWORK, c as LRC_WALLET_NETWORK_TYPE, N as Network, b as NetworkToProto, a as NetworkType, g as getNetwork, d as getNetworkFromAddress, e as getNetworkFromString } from './network-Css46DAz.cjs';
 import '@lightsparkdev/core';
 import './BitcoinNetwork-TnABML0T.cjs';
-import './LightningSendFeeEstimateInput-BgOhEAI-.cjs';
-import './spark-C4ZrsgjC.cjs';
-import '@bufbuild/protobuf/wire';
-import 'nice-grpc-common';
-import './services/config.cjs';
-import '@buildonspark/lrc20-sdk';
-import './services/wallet-config.cjs';
 import '@scure/bip32';
-import '@scure/btc-signer';
+import './types-C-Rp0Oo7.cjs';
 import 'bitcoinjs-lib';
 import '@buildonspark/lrc20-sdk/lrc/types';
-import './services/connection.cjs';
+import '@bufbuild/protobuf/wire';
+import 'nice-grpc-common';
 import 'nice-grpc';
 import 'nice-grpc-web';
-import './proto/spark_token.cjs';
-import './services/lrc-connection.cjs';
 import './proto/lrc20.cjs';
-import 'eventemitter3';
-import './address/index.cjs';
-import './sdk-types-BeCBoozO.cjs';
 import '@scure/btc-signer/psbt';
+
+declare class SparkSDKError extends Error {
+    readonly context: Record<string, unknown>;
+    readonly originalError?: Error;
+    constructor(message: string, context?: Record<string, unknown>, originalError?: Error);
+    toString(): string;
+    toJSON(): Record<string, unknown>;
+}
+
+/**
+ * NetworkError should be used for any errors related to network communication,
+ * such as failed HTTP requests, timeouts, or connection issues.
+ * This includes:
+ * - Failed API calls
+ * - Network timeouts
+ * - Connection refused
+ * - DNS resolution failures
+ * - SSL/TLS errors
+ */
+declare class NetworkError extends SparkSDKError {
+    constructor(message: string, context?: {
+        url?: string;
+        method?: string;
+        statusCode?: number;
+        response?: unknown;
+        errorCount?: number;
+        errors?: string;
+        operation?: string;
+        nodeSignaturesCount?: number;
+    }, originalError?: Error);
+}
+/**
+ * ValidationError should be used for any errors related to data validation in regards to the user's input,
+ * This includes:
+ * - Invalid signatures
+ * - Malformed addresses
+ * - Invalid proof of possession
+ * - Invalid cryptographic parameters
+ * - Data format validation failures
+ */
+declare class ValidationError extends SparkSDKError {
+    constructor(message: string, context?: {
+        field?: string;
+        value?: unknown;
+        expected?: unknown;
+        expectedLength?: number;
+        actualLength?: number;
+        rValue?: bigint;
+        fieldPrime?: bigint;
+        sValue?: bigint;
+        groupOrder?: bigint;
+        index?: number;
+        treeLength?: number;
+        addressNodesLength?: number;
+    }, originalError?: Error);
+}
+/**
+ * InternalValidationError should be used for any errors related to internal data validation
+ * that is not related to the user's input.
+ * This includes:
+ * - Invalid SO responses
+ */
+declare class InternalValidationError extends SparkSDKError {
+    constructor(message: string, context?: {
+        field?: string;
+        value?: unknown;
+        expected?: unknown;
+        outputIndex?: number;
+        keyshareInfo?: unknown;
+        signingOperators?: unknown;
+    }, originalError?: Error);
+}
+/**
+ * AuthenticationError should be used specifically for authentication and authorization failures,
+ * such as invalid credentials or insufficient permissions.
+ * This includes:
+ * - Invalid API keys
+ * - Expired tokens
+ * - Insufficient permissions
+ * - Authentication token validation failures
+ * - Authorization failures
+ */
+declare class AuthenticationError extends SparkSDKError {
+    constructor(message: string, context?: {
+        endpoint?: string;
+        reason?: string;
+    }, originalError?: Error);
+}
+/**
+ * RPCError should be used for errors that occur during RPC (Remote Procedure Call) operations,
+ * such as invalid RPC parameters or RPC-specific failures.
+ * This includes:
+ * - Invalid RPC method calls
+ * - RPC parameter validation failures
+ * - RPC-specific error codes
+ * - RPC protocol errors
+ */
+declare class RPCError extends SparkSDKError {
+    constructor(message: string, context?: {
+        method?: string;
+        params?: unknown;
+        code?: number;
+    }, originalError?: Error);
+}
+/**
+ * ConfigurationError should be used for errors related to SDK configuration,
+ * such as missing or invalid configuration values.
+ * This includes:
+ * - Missing required configuration
+ * - Invalid configuration values
+ * - Configuration format errors
+ * - Environment-specific configuration issues
+ */
+declare class ConfigurationError extends SparkSDKError {
+    constructor(message: string, context?: {
+        configKey?: string;
+        value?: unknown;
+    }, originalError?: Error);
+}
+/***
+ * NotImplementedError should be used for any errors related to features that are not yet implemented.
+ */
+declare class NotImplementedError extends SparkSDKError {
+    constructor(message: string, context?: Record<string, unknown>, originalError?: Error);
+}
+
+declare class SigningService {
+    private readonly config;
+    constructor(config: WalletConfigService);
+    signRefunds(leaves: LeafKeyTweak[], signingCommitments: RequestedSigningCommitments[], receiverIdentityPubkey: Uint8Array): Promise<UserSignedTxSigningJob[]>;
+}
+
+type LeafKeyTweak = {
+    leaf: TreeNode;
+    signingPubKey: Uint8Array;
+    newSigningPubKey: Uint8Array;
+};
+type ClaimLeafData = {
+    signingPubKey: Uint8Array;
+    tx?: Transaction;
+    refundTx?: Transaction;
+    signingNonceCommitment: SigningCommitment;
+    vout?: number;
+};
+type LeafRefundSigningData = {
+    signingPubKey: Uint8Array;
+    receivingPubkey: Uint8Array;
+    tx: Transaction;
+    refundTx?: Transaction;
+    signingNonceCommitment: SigningCommitment;
+    vout: number;
+};
+declare class BaseTransferService {
+    protected readonly config: WalletConfigService;
+    protected readonly connectionManager: ConnectionManager;
+    protected readonly signingService: SigningService;
+    constructor(config: WalletConfigService, connectionManager: ConnectionManager, signingService: SigningService);
+    sendTransferTweakKey(transfer: Transfer, leaves: LeafKeyTweak[], refundSignatureMap: Map<string, Uint8Array>): Promise<Transfer>;
+    deliverTransferPackage(transfer: Transfer, leaves: LeafKeyTweak[], refundSignatureMap: Map<string, Uint8Array>): Promise<Transfer>;
+    sendTransferWithKeyTweaks(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array): Promise<Transfer>;
+    private prepareTransferPackage;
+    private finalizeTransfer;
+    signRefunds(leafDataMap: Map<string, ClaimLeafData>, operatorSigningResults: LeafRefundTxSigningResult[], adaptorPubKey?: Uint8Array): Promise<NodeSignatures[]>;
+    private prepareSendTransferKeyTweaks;
+    private prepareSingleSendTransferKeyTweak;
+    protected findShare(shares: VerifiableSecretShare[], operatorID: number): VerifiableSecretShare | undefined;
+    private compareTransfers;
+}
+declare class TransferService extends BaseTransferService {
+    constructor(config: WalletConfigService, connectionManager: ConnectionManager, signingService: SigningService);
+    /**
+     * @deprecated Use sendTransferWithKeyTweaks instead
+     * Deprecated in v0.1.32
+     */
+    sendTransfer(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array): Promise<Transfer>;
+    claimTransfer(transfer: Transfer, leaves: LeafKeyTweak[]): Promise<FinalizeNodeSignaturesResponse>;
+    queryPendingTransfers(): Promise<QueryTransfersResponse>;
+    queryAllTransfers(limit: number, offset: number): Promise<QueryTransfersResponse>;
+    verifyPendingTransfer(transfer: Transfer): Promise<Map<string, Uint8Array>>;
+    queryTransfer(transferId: string): Promise<Transfer | undefined>;
+    sendTransferSignRefund(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date): Promise<{
+        transfer: Transfer;
+        signatureMap: Map<string, Uint8Array>;
+        leafDataMap: Map<string, LeafRefundSigningData>;
+    }>;
+    startSwapSignRefund(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date): Promise<{
+        transfer: Transfer;
+        signatureMap: Map<string, Uint8Array>;
+        leafDataMap: Map<string, LeafRefundSigningData>;
+    }>;
+    counterSwapSignRefund(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date, adaptorPubKey?: Uint8Array): Promise<{
+        transfer: Transfer;
+        signatureMap: Map<string, Uint8Array>;
+        leafDataMap: Map<string, LeafRefundSigningData>;
+        signingResults: LeafRefundTxSigningResult[];
+    }>;
+    sendTransferSignRefundInternal(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date, forSwap: boolean, adaptorPubKey?: Uint8Array): Promise<{
+        transfer: Transfer;
+        signatureMap: Map<string, Uint8Array>;
+        leafDataMap: Map<string, LeafRefundSigningData>;
+        signingResults: LeafRefundTxSigningResult[];
+    }>;
+    private prepareRefundSoSigningJobs;
+    claimTransferTweakKeys(transfer: Transfer, leaves: LeafKeyTweak[]): Promise<Map<string, Uint8Array[]>>;
+    private prepareClaimLeavesKeyTweaks;
+    private prepareClaimLeafKeyTweaks;
+    claimTransferSignRefunds(transfer: Transfer, leafKeys: LeafKeyTweak[], proofMap?: Map<string, Uint8Array[]>): Promise<NodeSignatures[]>;
+    private finalizeNodeSignatures;
+    cancelTransfer(transfer: Transfer, operatorAddress: string): Promise<Transfer | undefined>;
+    queryPendingTransfersBySender(operatorAddress: string): Promise<QueryTransfersResponse>;
+    refreshTimelockNodes(nodes: TreeNode[], parentNode: TreeNode, signingPubKey: Uint8Array): Promise<FinalizeNodeSignaturesResponse>;
+    extendTimelock(node: TreeNode, signingPubKey: Uint8Array): Promise<FinalizeNodeSignaturesResponse>;
+    refreshTimelockRefundTx(node: TreeNode, signingPubKey: Uint8Array): Promise<FinalizeNodeSignaturesResponse>;
+}
+
+/**
+ * The SparkWallet class is the primary interface for interacting with the Spark network.
+ * It provides methods for creating and managing wallets, handling deposits, executing transfers,
+ * and interacting with the Lightning Network.
+ */
+declare class SparkWallet extends EventEmitter {
+    protected config: WalletConfigService;
+    protected connectionManager: ConnectionManager;
+    protected lrc20ConnectionManager: Lrc20ConnectionManager;
+    protected lrc20Wallet: LRCWallet | undefined;
+    protected transferService: TransferService;
+    protected tracerId: string;
+    private depositService;
+    private treeCreationService;
+    private lightningService;
+    private coopExitService;
+    private signingService;
+    private tokenTransactionService;
+    private claimTransferMutex;
+    private leavesMutex;
+    private optimizationInProgress;
+    private sspClient;
+    private mutexes;
+    private pendingWithdrawnOutputIds;
+    private sparkAddress;
+    private streamController;
+    protected leaves: TreeNode[];
+    protected tokenOutputs: Map<string, OutputWithPreviousTransactionData[]>;
+    private claimTransfersInterval;
+    protected wrapWithOtelSpan<T>(name: string, fn: (...args: any[]) => Promise<T>): (...args: any[]) => Promise<T>;
+    protected constructor(options?: ConfigOptions, signer?: SparkSigner);
+    static initialize({ mnemonicOrSeed, accountNumber, signer, options, }: SparkWalletProps): Promise<{
+        mnemonic?: string | undefined;
+        wallet: SparkWallet;
+    }>;
+    private initializeWallet;
+    private getSspClient;
+    private handleStreamEvent;
+    protected setupBackgroundStream(): Promise<void>;
+    getLeaves(isBalanceCheck?: boolean): Promise<TreeNode[]>;
+    private selectLeaves;
+    private selectLeavesForSwap;
+    private areLeavesInefficient;
+    private optimizeLeaves;
+    private syncWallet;
+    private withLeaves;
+    /**
+     * Gets the identity public key of the wallet.
+     *
+     * @returns {Promise<string>} The identity public key as a hex string.
+     */
+    getIdentityPublicKey(): Promise<string>;
+    /**
+     * Gets the Spark address of the wallet.
+     *
+     * @returns {Promise<string>} The Spark address as a hex string.
+     */
+    getSparkAddress(): Promise<SparkAddressFormat>;
+    createSparkPaymentIntent(assetIdentifier?: string, assetAmount?: bigint, memo?: string): Promise<SparkAddressFormat>;
+    /**
+     * Initializes the wallet using either a mnemonic phrase or a raw seed.
+     * initWallet will also claim any pending incoming lightning payment, spark transfer,
+     * or bitcoin deposit.
+     *
+     * @param {Uint8Array | string} [mnemonicOrSeed] - (Optional) Either:
+     *   - A BIP-39 mnemonic phrase as string
+     *   - A raw seed as Uint8Array or hex string
+     *   If not provided, generates a new mnemonic and uses it to create a new wallet
+     *
+     * @param {number} [accountNumber] - (Optional) The account number to use for the wallet. Defaults to 1 to maintain backwards compatability for legacy mainnet wallets.
+     *
+     * @returns {Promise<Object>} Object containing:
+     *   - mnemonic: The mnemonic if one was generated (undefined for raw seed)
+     *   - balance: The wallet's initial balance in satoshis
+     *   - tokenBalance: Map of token balances
+     * @private
+     */
+    protected initWallet(mnemonicOrSeed?: Uint8Array | string, accountNumber?: number): Promise<InitWalletResponse | undefined>;
+    /**
+     * Initializes a wallet from a seed.
+     *
+     * @param {Uint8Array | string} seed - The seed to initialize the wallet from
+     * @returns {Promise<string>} The identity public key
+     * @private
+     */
+    private initWalletFromSeed;
+    /**
+     * Gets the estimated fee for a swap of leaves.
+     *
+     * @param amountSats - The amount of sats to swap
+     *  @returns {Promise<LeavesSwapFeeEstimateOutput>}  The estimated fee for the swap
+     */
+    getSwapFeeEstimate(amountSats: number): Promise<LeavesSwapFeeEstimateOutput>;
+    /**
+     * Requests a swap of leaves to optimize wallet structure.
+     *
+     * @param {Object} params - Parameters for the leaves swap
+     * @param {number} [params.targetAmount] - Target amount for the swap
+     * @param {TreeNode[]} [params.leaves] - Specific leaves to swap
+     * @returns {Promise<Object>} The completed swap response
+     * @private
+     */
+    private requestLeavesSwap;
+    /**
+     * Processes a single batch of leaves for swapping.
+     */
+    private processSwapBatch;
+    /**
+     * Gets all transfers for the wallet.
+     *
+     * @param {number} [limit=20] - Maximum number of transfers to return
+     * @param {number} [offset=0] - Offset for pagination
+     * @returns {Promise<QueryTransfersResponse>} Response containing the list of transfers
+     */
+    getTransfers(limit?: number, offset?: number): Promise<{
+        transfers: WalletTransfer[];
+        offset: number;
+    }>;
+    /**
+     * Gets the current balance of the wallet.
+     * You can use the forceRefetch option to synchronize your wallet and claim any
+     * pending incoming lightning payment, spark transfer, or bitcoin deposit before returning the balance.
+     *
+     * @returns {Promise<Object>} Object containing:
+     *   - balance: The wallet's current balance in satoshis
+     *   - tokenBalances: Map of the human readable token identifier to token balances and token info
+     */
+    getBalance(): Promise<{
+        balance: bigint;
+        tokenBalances: TokenBalanceMap;
+    }>;
+    private getTokenBalance;
+    private getInternalBalance;
+    /**
+     * Generates a new deposit address for receiving bitcoin funds.
+     * Note that this function returns a bitcoin address, not a spark address, and this address is single use.
+     * Once you deposit funds to this address, it cannot be used again.
+     * For Layer 1 Bitcoin deposits, Spark generates Pay to Taproot (P2TR) addresses.
+     * These addresses start with "bc1p" and can be used to receive Bitcoin from any wallet.
+     *
+     * @returns {Promise<string>} A Bitcoin address for depositing funds
+     */
+    getSingleUseDepositAddress(): Promise<string>;
+    /**
+     * Generates a new static deposit address for receiving bitcoin funds.
+     * This address is permanent and can be used multiple times.
+     *
+     * @returns {Promise<string>} A Bitcoin address for depositing funds
+     */
+    getStaticDepositAddress(): Promise<string>;
+    /**
+     * Generates a deposit address for receiving funds.
+     *
+     * @param {boolean} static - Whether the address is static or single use
+     * @returns {Promise<string>} A deposit address
+     * @private
+     */
+    private generateDepositAddress;
+    queryStaticDepositAddresses(): Promise<string[]>;
+    /**
+     * Get a quote on how much credit you can claim for a deposit from the SSP.
+     *
+     * @param {string} transactionId - The ID of the transaction
+     * @param {number} [outputIndex] - The index of the output
+     * @returns {Promise<StaticDepositQuoteOutput>} Quote for claiming a deposit to a static deposit address
+     */
+    getClaimStaticDepositQuote(transactionId: string, outputIndex?: number): Promise<StaticDepositQuoteOutput>;
+    /**
+     * Claims a deposit to a static deposit address.
+     *
+     * @param {string} transactionId - The ID of the transaction
+     * @param {number} creditAmountSats - The amount of credit to claim
+     * @param {string} sspSignature - The SSP signature for the deposit
+     * @param {number} [outputIndex] - The index of the output
+     * @returns {Promise<RequestClaimDepositQuoteOutput | null>} Quote for claiming a deposit to a static deposit address
+     */
+    claimStaticDeposit({ transactionId, creditAmountSats, sspSignature, outputIndex, }: {
+        transactionId: string;
+        creditAmountSats: number;
+        sspSignature: string;
+        outputIndex?: number;
+    }): Promise<ClaimStaticDepositOutput | null>;
+    /**
+     * Refunds a static deposit to a destination address.
+     *
+     * @param {string} depositTransactionId - The ID of the transaction
+     * @param {number} [outputIndex] - The index of the output
+     * @param {string} destinationAddress - The destination address
+     * @param {number} fee - The fee to refund
+     * @returns {Promise<string>} The hex of the refund transaction
+     */
+    refundStaticDeposit({ depositTransactionId, outputIndex, destinationAddress, fee, }: {
+        depositTransactionId: string;
+        outputIndex?: number;
+        destinationAddress: string;
+        fee: number;
+    }): Promise<string>;
+    private getStaticDepositSigningPayload;
+    private getDepositTransactionVout;
+    private getDepositTransaction;
+    /**
+     * Finalizes a deposit to the wallet.
+     *
+     * @param {DepositParams} params - Parameters for finalizing the deposit
+     * @returns {Promise<void>} The nodes created from the deposit
+     * @private
+     */
+    private finalizeDeposit;
+    /**
+     * Gets all unused deposit addresses for the wallet.
+     *
+     * @returns {Promise<string[]>} The unused deposit addresses
+     */
+    getUnusedDepositAddresses(): Promise<string[]>;
+    /**
+     * Gets all unused deposit addresses for the wallet.
+     *
+     * @param {Object} params - Parameters for querying unused deposit addresses
+     * @param {Uint8Array<ArrayBufferLike>} [params.identityPublicKey] - The identity public key
+     * @param {NetworkProto} [params.network] - The network
+     * @returns {Promise<DepositAddressQueryResult[]>} The unused deposit addresses
+     */
+    private queryAllUnusedDepositAddresses;
+    /**
+     * Claims a deposit to the wallet.
+     * Note that if you used advancedDeposit, you don't need to call this function.
+     * @param {string} txid - The transaction ID of the deposit
+     * @returns {Promise<WalletLeaf[] | undefined>} The nodes resulting from the deposit
+     */
+    claimDeposit(txid: string): Promise<WalletLeaf[]>;
+    /**
+     * Non-trusty flow for depositing funds to the wallet.
+     * Construct the tx spending from an L1 wallet to the Spark address.
+     * After calling this function, you must sign and broadcast the tx.
+     *
+     * @param {string} txHex - The hex string of the transaction to deposit
+     * @returns {Promise<TreeNode[] | undefined>} The nodes resulting from the deposit
+     */
+    advancedDeposit(txHex: string): Promise<TreeNode[]>;
+    /**
+     * Transfers deposit to self to claim ownership.
+     *
+     * @param {TreeNode[]} leaves - The leaves to transfer
+     * @param {Uint8Array} signingPubKey - The signing public key
+     * @returns {Promise<TreeNode[] | undefined>} The nodes resulting from the transfer
+     * @private
+     */
+    private transferLeavesToSelf;
+    /**
+     * Sends a transfer to another Spark user.
+     *
+     * @param {TransferParams} params - Parameters for the transfer
+     * @param {string} params.receiverSparkAddress - The recipient's Spark address
+     * @param {number} params.amountSats - Amount to send in satoshis
+     * @returns {Promise<WalletTransfer>} The completed transfer details
+     */
+    transfer({ amountSats, receiverSparkAddress, }: TransferParams): Promise<WalletTransfer>;
+    private checkExtendTimeLockNodes;
+    /**
+     * Internal method to refresh timelock nodes.
+     *
+     * @param {string} nodeId - The optional ID of the node to refresh. If not provided, all nodes will be checked.
+     * @returns {Promise<void>}
+     * @private
+     */
+    private checkRefreshTimelockNodes;
+    /**
+     * Claims a specific transfer.
+     *
+     * @param {Transfer} transfer - The transfer to claim
+     * @returns {Promise<Object>} The claim result
+     */
+    private claimTransfer;
+    /**
+     * Claims all pending transfers.
+     *
+     * @returns {Promise<string[]>} Array of successfully claimed transfer IDs
+     * @private
+     */
+    private claimTransfers;
+    /**
+     * Cancels all sender-initiated transfers.
+     *
+     * @returns {Promise<void>}
+     * @private
+     */
+    private cancelAllSenderInitiatedTransfers;
+    /**
+     * Creates a Lightning invoice for receiving payments.
+     *
+     * @param {Object} params - Parameters for the lightning invoice
+     * @param {number} params.amountSats - Amount in satoshis
+     * @param {string} [params.memo] - Description for the invoice. Should not be provided if the descriptionHash is provided.
+     * @param {number} [params.expirySeconds] - Optional expiry time in seconds
+     * @param {boolean} [params.includeSparkAddress] - Optional boolean signalling whether or not to include the spark address in the invoice
+     * @param {string} [params.receiverIdentityPubkey] - Optional public key of the wallet receiving the lightning invoice. If not present, the receiver will be the creator of this request.
+     * @param {string} [params.descriptionHash] - Optional h tag of the invoice. This is the hash of a longer description to include in the lightning invoice. It is used in LNURL and UMA as the hash of the metadata. This field is mutually exclusive with the memo field. Only one or the other should be provided.
+     * @returns {Promise<LightningReceiveRequest>} BOLT11 encoded invoice
+     */
+    createLightningInvoice({ amountSats, memo, expirySeconds, includeSparkAddress, receiverIdentityPubkey, descriptionHash, }: CreateLightningInvoiceParams): Promise<LightningReceiveRequest>;
+    /**
+     * Pays a Lightning invoice.
+     *
+     * @param {Object} params - Parameters for paying the invoice
+     * @param {string} params.invoice - The BOLT11-encoded Lightning invoice to pay
+     * @param {boolean} [params.preferSpark] - Whether to prefer a spark transfer over lightning for the payment
+     * @param {number} [params.amountSatsToSend] - The amount in sats to send. This is only valid for 0 amount lightning invoices.
+     * @returns {Promise<LightningSendRequest>} The Lightning payment request details
+     */
+    payLightningInvoice({ invoice, maxFeeSats, preferSpark, amountSatsToSend, }: PayLightningInvoiceParams): Promise<LightningSendRequest | WalletTransfer>;
+    /**
+     * Gets fee estimate for sending Lightning payments.
+     *
+     * @param {LightningSendFeeEstimateInput} params - Input parameters for fee estimation
+     * @returns {Promise<number>} Fee estimate for sending Lightning payments
+     */
+    getLightningSendFeeEstimate({ encodedInvoice, amountSats, }: LightningSendFeeEstimateInput): Promise<number>;
+    /**
+     * Generates a deposit address for a tree.
+     *
+     * @param {number} vout - The vout index
+     * @param {Uint8Array} parentSigningPubKey - The parent signing public key
+     * @param {Transaction} [parentTx] - Optional parent transaction
+     * @param {TreeNode} [parentNode] - Optional parent node
+     * @returns {Promise<Object>} Deposit address information
+     * @private
+     */
+    private generateDepositAddressForTree;
+    /**
+     * Creates a tree structure.
+     *
+     * @param {number} vout - The vout index
+     * @param {DepositAddressTree} root - The root of the tree
+     * @param {boolean} createLeaves - Whether to create leaves
+     * @param {Transaction} [parentTx] - Optional parent transaction
+     * @param {TreeNode} [parentNode] - Optional parent node
+     * @returns {Promise<Object>} The created tree
+     * @private
+     */
+    private createTree;
+    /**
+     * Initiates a withdrawal to move funds from the Spark network to an on-chain Bitcoin address.
+     *
+     * @param {Object} params - Parameters for the withdrawal
+     * @param {string} params.onchainAddress - The Bitcoin address where the funds should be sent
+     * @param {CoopExitFeeQuote} params.feeQuote - The fee quote for the withdrawal
+     * @param {ExitSpeed} params.exitSpeed - The exit speed chosen for the withdrawal
+     * @param {number} [params.amountSats] - The amount in satoshis to withdraw. If not specified, attempts to withdraw all available funds and deductFeeFromWithdrawalAmount is set to true.
+     * @param {boolean} [params.deductFeeFromWithdrawalAmount] - Controls how the withdrawal fee is handled. If true, the fee is deducted from the withdrawal amount (amountSats), meaning the recipient will receive amountSats minus the fee. If false, the fee is paid separately from the wallet balance, meaning the recipient will receive the full amountSats.
+     * @returns {Promise<CoopExitRequest | null | undefined>} The withdrawal request details, or null/undefined if the request cannot be completed
+     */
+    withdraw({ onchainAddress, exitSpeed, feeQuote, amountSats, deductFeeFromWithdrawalAmount, }: {
+        onchainAddress: string;
+        exitSpeed: ExitSpeed;
+        feeQuote: CoopExitFeeQuote;
+        amountSats?: number;
+        deductFeeFromWithdrawalAmount?: boolean;
+    }): Promise<CoopExitRequest | null>;
+    /**
+     * Internal method to perform a cooperative exit (withdrawal).
+     *
+     * @param {string} onchainAddress - The Bitcoin address where the funds should be sent
+     * @param {number} [targetAmountSats] - The amount in satoshis to withdraw
+     * @returns {Promise<Object | null | undefined>} The exit request details
+     * @private
+     */
+    private coopExit;
+    /**
+     * Gets fee estimate for cooperative exit (on-chain withdrawal).
+     *
+     * @param {Object} params - Input parameters for fee estimation
+     * @param {number} params.amountSats - The amount in satoshis to withdraw
+     * @param {string} params.withdrawalAddress - The Bitcoin address where the funds should be sent
+     * @returns {Promise<CoopExitFeeQuote | null>} Fee estimate for the withdrawal
+     */
+    getWithdrawalFeeQuote({ amountSats, withdrawalAddress, }: {
+        amountSats: number;
+        withdrawalAddress: string;
+    }): Promise<CoopExitFeeQuote | null>;
+    /**
+     * Gets a transfer that has been sent by the SSP to the wallet.
+     *
+     * @param {string} id - The ID of the transfer
+     * @returns {Promise<GraphQLTransferObj | null>} The transfer
+     */
+    getTransferFromSsp(id: string): Promise<Transfer$1 | null>;
+    /**
+     * Gets a transfer, that the wallet is a participant of, in the Spark network.
+     * Only contains data about the spark->spark transfer, use getTransferFromSsp if you're
+     * looking for information related to a lightning transfer.
+     *
+     * @param {string} id - The ID of the transfer
+     * @returns {Promise<Transfer | undefined>} The transfer
+     */
+    getTransfer(id: string): Promise<WalletTransfer | undefined>;
+    /**
+     * Synchronizes token outputs for the wallet.
+     *
+     * @returns {Promise<void>}
+     * @private
+     */
+    protected syncTokenOutputs(): Promise<void>;
+    /**
+     * Transfers tokens to another user.
+     *
+     * @param {Object} params - Parameters for the token transfer
+     * @param {string} params.tokenPublicKey - The public key of the token to transfer
+     * @param {bigint} params.tokenAmount - The amount of tokens to transfer
+     * @param {string} params.receiverSparkAddress - The recipient's public key
+     * @param {OutputWithPreviousTransactionData[]} [params.selectedOutputs] - Optional specific leaves to use for the transfer
+     * @returns {Promise<string>} The transaction ID of the token transfer
+     */
+    transferTokens({ tokenPublicKey, tokenAmount, receiverSparkAddress, outputSelectionStrategy, selectedOutputs, }: {
+        tokenPublicKey: string;
+        tokenAmount: bigint;
+        receiverSparkAddress: string;
+        outputSelectionStrategy?: "SMALL_FIRST" | "LARGE_FIRST";
+        selectedOutputs?: OutputWithPreviousTransactionData[];
+    }): Promise<string>;
+    /**
+     * Transfers tokens with multiple outputs
+     *
+     * @param {Array} receiverOutputs - Array of transfer parameters
+     * @param {string} receiverOutputs[].tokenPublicKey - The public key of the token to transfer
+     * @param {bigint} receiverOutputs[].tokenAmount - The amount of tokens to transfer
+     * @param {string} receiverOutputs[].receiverSparkAddress - The recipient's public key
+     * @param {OutputWithPreviousTransactionData[]} [selectedOutputs] - Optional specific leaves to use for the transfer
+     * @returns {Promise<string[]>} Array of transaction IDs for the token transfers
+     */
+    batchTransferTokens(receiverOutputs: {
+        tokenPublicKey: string;
+        tokenAmount: bigint;
+        receiverSparkAddress: string;
+    }[], outputSelectionStrategy?: "SMALL_FIRST" | "LARGE_FIRST", selectedOutputs?: OutputWithPreviousTransactionData[]): Promise<string>;
+    /**
+     * Retrieves token transaction history for specified tokens owned by the wallet.
+     * Can optionally filter by specific transaction hashes.
+     *
+     * @param ownerPublicKeys - Optional array of owner public keys to query transactions for
+     * @param issuerPublicKeys - Optional array of issuer public keys to query transactions for
+     * @param tokenTransactionHashes - Optional array of specific transaction hashes to filter by
+     * @param tokenIdentifiers - Optional array of token identifiers to filter by
+     * @param outputIds - Optional array of output IDs to filter by
+     * @returns Promise resolving to array of token transactions with their current status
+     */
+    queryTokenTransactions(ownerPublicKeys?: string[], issuerPublicKeys?: string[], tokenTransactionHashes?: string[], tokenIdentifiers?: string[], outputIds?: string[]): Promise<TokenTransactionWithStatus[]>;
+    getTokenL1Address(): Promise<string>;
+    /**
+     * Signs a message with the identity key.
+     *
+     * @param {string} message - The message to sign
+     * @param {boolean} [compact] - Whether to use compact encoding. If false, the message will be encoded as DER.
+     * @returns {Promise<string>} The signed message
+     */
+    signMessageWithIdentityKey(message: string, compact?: boolean): Promise<string>;
+    /**
+     * Validates a message with the identity key.
+     *
+     * @param {string} message - The original message that was signed
+     * @param {string | Uint8Array} signature - Signature to validate
+     * @returns {Promise<boolean>} Whether the message is valid
+     */
+    validateMessageWithIdentityKey(message: string, signature: string | Uint8Array): Promise<boolean>;
+    /**
+     * Signs a transaction with wallet keys.
+     *
+     * @param {string} txHex - The transaction hex to sign
+     * @param {string} keyType - The type of key to use for signing ("identity", "deposit", or "auto-detect")
+     * @returns {Promise<string>} The signed transaction hex
+     */
+    signTransaction(txHex: string, keyType?: string): Promise<string>;
+    /**
+     * Helper method to auto-detect which key should be used for signing a transaction.
+     */
+    private detectKeyForTransaction;
+    /**
+     * Get a Lightning receive request by ID.
+     *
+     * @param {string} id - The ID of the Lightning receive request
+     * @returns {Promise<LightningReceiveRequest | null>} The Lightning receive request
+     */
+    getLightningReceiveRequest(id: string): Promise<LightningReceiveRequest | null>;
+    /**
+     * Get a Lightning send request by ID.
+     *
+     * @param {string} id - The ID of the Lightning send request
+     * @returns {Promise<LightningSendRequest | null>} The Lightning send request
+     */
+    getLightningSendRequest(id: string): Promise<LightningSendRequest | null>;
+    /**
+     * Get a coop exit request by ID.
+     *
+     * @param {string} id - The ID of the coop exit request
+     * @returns {Promise<CoopExitRequest | null>} The coop exit request
+     */
+    getCoopExitRequest(id: string): Promise<CoopExitRequest | null>;
+    /**
+     * Check the remaining timelock on a given node.
+     *
+     * @param {string} nodeId - The ID of the node to check
+     * @returns {Promise<{nodeTimelock: number, refundTimelock: number}>} The remaining timelocks in blocks for both node and refund transactions
+     */
+    checkTimelock(nodeId: string): Promise<{
+        nodeTimelock: number;
+        refundTimelock: number;
+    }>;
+    /**
+     * Refresh the timelock of a specific node.
+     *
+     * @param {string} nodeId - The ID of the node to refresh
+     * @returns {Promise<void>} Promise that resolves when the timelock is refreshed
+     */
+    testOnly_expireTimelock(nodeId: string): Promise<void>;
+    /**
+     * Refresh the timelock of a specific node's refund transaction only.
+     *
+     * @param {string} nodeId - The ID of the node whose refund transaction to refresh
+     * @returns {Promise<void>} Promise that resolves when the refund timelock is refreshed
+     */
+    testOnly_expireTimelockRefundTx(nodeId: string): Promise<void>;
+    private cleanup;
+    cleanupConnections(): Promise<void>;
+    private startPeriodicClaimTransfers;
+    private updateLeaves;
+    private queryNodes;
+}
+
+export { AuthenticationError, ConfigurationError, InternalValidationError, NetworkError, NotImplementedError, RPCError, SparkSDKError, SparkWallet, ValidationError, VerifiableSecretShare };