@buildonspark/spark-sdk 0.1.45 → 0.1.47

package/dist/spark-wallet-CJkQW8pK.d.ts

@@ -0,0 +1,923 @@
+import { B as BitcoinNetwork, M as MayHaveSspClientOptions, N as SspClientOptions, K as SparkSigner, O as HasSspClientOptions, Q as SigningCommitment, W as VerifiableSecretShare, m as LeavesSwapFeeEstimateOutput, H as StaticDepositQuoteOutput, C as ClaimStaticDepositOutput, q as LightningReceiveRequest, v as LightningSendRequest, s as LightningSendFeeEstimateInput, E as ExitSpeed, f as CoopExitFeeQuote, i as CoopExitRequest, T as Transfer$1 } from './client-D7KgLN44.js';
+import { N as Network$1, P as PaymentIntentFields, E as Empty, g as SparkServiceClient, h as RequestedSigningCommitments, U as UserSignedTxSigningJob, d as TreeNode, f as Transfer, L as LeafRefundTxSigningResult, i as NodeSignatures, F as FinalizeNodeSignaturesResponse, Q as QueryTransfersResponse, j as OutputWithPreviousTransactionData } from './spark-BbUrbvZz.js';
+import { NetworkType as NetworkType$1, MayHaveLrc20WalletApiConfig, LRC20WalletApiConfig, HasLrc20WalletApiConfig, LRCWallet } from '@buildonspark/lrc20-sdk';
+import * as btc from '@scure/btc-signer';
+import { Transaction } from '@scure/btc-signer';
+import * as bitcoin from 'bitcoinjs-lib';
+import { Channel } from 'nice-grpc';
+import { Channel as Channel$1 } from 'nice-grpc-web';
+import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
+import { CallOptions } from 'nice-grpc-common';
+import { SparkTokenServiceClient, TokenMetadata, TokenTransactionWithStatus } from './proto/spark_token.js';
+import { EventEmitter } from 'eventemitter3';
+import { a as WalletTransfer, W as WalletLeaf } from './sdk-types-BGCeea0G.js';
+
+declare enum Network {
+    MAINNET = 0,
+    TESTNET = 1,
+    SIGNET = 2,
+    REGTEST = 3,
+    LOCAL = 4
+}
+type NetworkType = keyof typeof Network;
+declare const NetworkToProto: Record<Network, Network$1>;
+declare const protoToNetwork: (protoNetwork: Network$1) => Network | undefined;
+declare const getNetwork: (network: Network) => typeof btc.NETWORK;
+declare const LRC_WALLET_NETWORK: Readonly<{
+    0: bitcoin.networks.Network;
+    1: bitcoin.networks.Network;
+    2: bitcoin.networks.Network;
+    3: bitcoin.networks.Network;
+    4: bitcoin.networks.Network;
+}>;
+declare const LRC_WALLET_NETWORK_TYPE: Readonly<{
+    0: NetworkType$1.MAINNET;
+    1: NetworkType$1.TESTNET;
+    2: NetworkType$1.TESTNET;
+    3: NetworkType$1.REGTEST;
+    4: NetworkType$1.LOCAL;
+}>;
+/**
+ * Utility function to determine the network from a Bitcoin address.
+ *
+ * @param {string} address - The Bitcoin address
+ * @returns {BitcoinNetwork | null} The detected network or null if not detected
+ */
+declare function getNetworkFromAddress(address: string): BitcoinNetwork.MAINNET | BitcoinNetwork.REGTEST | null;
+/**
+ * Utility function to get the network enum value from a string.
+ *
+ * @param {string} network - The Bitcoin network to turn into an enum value
+ * @returns {Network} The enum value matching the string
+ */
+declare function getNetworkFromString(network?: string): Network;
+
+declare const AddressNetwork: Record<NetworkType, string>;
+type SparkAddressFormat = `${(typeof AddressNetwork)[keyof typeof AddressNetwork]}1${string}`;
+interface SparkAddressData {
+    identityPublicKey: string;
+    network: NetworkType;
+    paymentIntentFields?: PaymentIntentFields;
+}
+interface DecodedSparkAddressData {
+    identityPublicKey: string;
+    network: NetworkType;
+    paymentIntentFields?: {
+        id: string;
+        assetIdentifier?: string;
+        assetAmount: bigint;
+        memo?: string;
+    };
+}
+declare function encodeSparkAddress(payload: SparkAddressData): SparkAddressFormat;
+declare function decodeSparkAddress(address: string, network: NetworkType): DecodedSparkAddressData;
+declare function isValidSparkAddress(address: string): boolean;
+declare function isValidPublicKey(publicKey: string): void;
+
+type HumanReadableTokenIdentifier = `btk1${string}` | `btkrt1${string}` | `btkt1${string}` | `btks1${string}` | `btkl1${string}`;
+interface HumanReadableTokenIdentifierData {
+    tokenIdentifier: Uint8Array;
+    network: NetworkType;
+}
+declare function encodeHumanReadableTokenIdentifier(payload: HumanReadableTokenIdentifierData): HumanReadableTokenIdentifier;
+declare function decodeHumanReadableTokenIdentifier(humanReadableTokenIdentifier: HumanReadableTokenIdentifier, network: NetworkType): HumanReadableTokenIdentifierData;
+
+type SigningOperator = {
+    readonly id: number;
+    readonly identifier: string;
+    readonly address: string;
+    readonly identityPublicKey: string;
+};
+type ConfigOptions = MayHaveLrc20WalletApiConfig & MayHaveSspClientOptions & {
+    readonly network?: NetworkType;
+    readonly signingOperators?: Readonly<Record<string, SigningOperator>>;
+    readonly coodinatorIdentifier?: string;
+    readonly frostSignerAddress?: string;
+    readonly lrc20Address?: string;
+    readonly threshold?: number;
+    readonly tokenSignatures?: "ECDSA" | "SCHNORR";
+    readonly tokenValidityDurationSeconds?: number;
+    readonly tokenTransactionVersion?: "V0" | "V1";
+    readonly electrsUrl?: string;
+    readonly lrc20ApiConfig?: LRC20WalletApiConfig;
+    readonly sspClientOptions?: SspClientOptions;
+    readonly expectedWithdrawBondSats?: number;
+    readonly expectedWithdrawRelativeBlockLocktime?: number;
+};
+declare const WalletConfig: {
+    LOCAL: Required<ConfigOptions>;
+    LOCAL_SCHNORR: Required<ConfigOptions>;
+    LOCAL_ECDSA: Required<ConfigOptions>;
+    REGTEST: Required<ConfigOptions>;
+    MAINNET: Required<ConfigOptions>;
+};
+
+type CreateLightningInvoiceParams = {
+    amountSats: number;
+    memo?: string;
+    expirySeconds?: number;
+    includeSparkAddress?: boolean;
+    receiverIdentityPubkey?: string;
+    descriptionHash?: string;
+};
+type PayLightningInvoiceParams = {
+    invoice: string;
+    maxFeeSats: number;
+    preferSpark?: boolean;
+    amountSatsToSend?: number;
+};
+type TransferParams = {
+    amountSats: number;
+    receiverSparkAddress: string;
+};
+type DepositParams = {
+    signingPubKey: Uint8Array;
+    verifyingKey: Uint8Array;
+    depositTx: Transaction;
+    vout: number;
+};
+/**
+ * Token metadata containing essential information about a token.
+ * This is the wallet's internal representation with JavaScript-friendly types.
+ *
+ * rawTokenIdentifier: This is the raw binary token identifier - This is used to encode the human readable token identifier.
+ *
+ * tokenPublicKey: This is the hex-encoded public key of the token issuer - Same as issuerPublicKey.
+ *
+ * @example
+ * ```typescript
+ * const tokenMetadata: UserTokenMetadata = {
+ *   rawTokenIdentifier: new Uint8Array([1, 2, 3]),
+ *   tokenPublicKey: "0348fbb...",
+ *   tokenName: "SparkToken",
+ *   tokenTicker: "SPK",
+ *   decimals: 8,
+ *   maxSupply: 1000000n
+ * };
+ * ```
+ */
+type UserTokenMetadata = {
+    /** Raw binary token identifier - This is used to encode the human readable token identifier */
+    rawTokenIdentifier: Uint8Array;
+    /** Public key of the token issuer - Same as issuerPublicKey */
+    tokenPublicKey: string;
+    /** Human-readable name of the token (e.g., SparkToken)*/
+    tokenName: string;
+    /** Short ticker symbol for the token (e.g., "SPK") */
+    tokenTicker: string;
+    /** Number of decimal places for token amounts */
+    decimals: number;
+    /** Maximum supply of tokens that can ever be minted */
+    maxSupply: bigint;
+};
+type TokenBalanceMap = Map<HumanReadableTokenIdentifier, {
+    balance: bigint;
+    tokenMetadata: UserTokenMetadata;
+}>;
+type InitWalletResponse = {
+    mnemonic?: string | undefined;
+};
+interface SparkWalletProps {
+    mnemonicOrSeed?: Uint8Array | string;
+    accountNumber?: number;
+    signer?: SparkSigner;
+    options?: ConfigOptions;
+}
+interface SparkWalletEvents {
+    /** Emitted when an incoming transfer is successfully claimed. Includes the transfer ID and new total balance. */
+    "transfer:claimed": (transferId: string, updatedBalance: number) => void;
+    /** Emitted when a deposit is marked as available. Includes the deposit ID and new total balance. */
+    "deposit:confirmed": (depositId: string, updatedBalance: number) => void;
+    /** Emitted when the stream is connected */
+    "stream:connected": () => void;
+    /** Emitted when the stream disconnects and fails to reconnect after max attempts */
+    "stream:disconnected": (reason: string) => void;
+    /** Emitted when attempting to reconnect the stream */
+    "stream:reconnecting": (attempt: number, maxAttempts: number, delayMs: number, error: string) => void;
+}
+
+declare class WalletConfigService implements HasLrc20WalletApiConfig, HasSspClientOptions {
+    private readonly config;
+    readonly signer: SparkSigner;
+    readonly lrc20ApiConfig: LRC20WalletApiConfig;
+    readonly sspClientOptions: SspClientOptions;
+    constructor(options?: ConfigOptions, signer?: SparkSigner);
+    private getDefaultConfig;
+    getCoordinatorAddress(): string;
+    getLrc20Address(): string;
+    getSigningOperators(): Readonly<Record<string, SigningOperator>>;
+    getThreshold(): number;
+    getCoordinatorIdentifier(): string;
+    getExpectedWithdrawBondSats(): number;
+    getExpectedWithdrawRelativeBlockLocktime(): number;
+    getSspNetwork(): BitcoinNetwork;
+    getNetwork(): Network;
+    getNetworkType(): NetworkType;
+    getNetworkProto(): number;
+    getTokenSignatures(): "ECDSA" | "SCHNORR";
+    getTokenTransactionVersion(): "V0" | "V1";
+    getTokenValidityDurationSeconds(): number;
+    getElectrsUrl(): string;
+    getSspIdentityPublicKey(): string;
+}
+
+declare enum InterruptTransferRequest_InterruptTransferAction {
+    NONE = 0,
+    INTERRUPT = 1,
+    RESUME = 2,
+    UNRECOGNIZED = -1
+}
+interface CleanUpPreimageShareRequest {
+    paymentHash: Uint8Array;
+}
+declare const CleanUpPreimageShareRequest: MessageFns<CleanUpPreimageShareRequest>;
+interface InterruptTransferRequest {
+    action: InterruptTransferRequest_InterruptTransferAction;
+}
+declare const InterruptTransferRequest: MessageFns<InterruptTransferRequest>;
+interface UpdateNodesStatusRequest {
+    nodeIds: string[];
+    status: string;
+}
+declare const UpdateNodesStatusRequest: MessageFns<UpdateNodesStatusRequest>;
+interface MockServiceClient<CallOptionsExt = {}> {
+    clean_up_preimage_share(request: DeepPartial<CleanUpPreimageShareRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
+    interrupt_transfer(request: DeepPartial<InterruptTransferRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
+    update_nodes_status(request: DeepPartial<UpdateNodesStatusRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
+}
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial<T>): T;
+    fromPartial(object: DeepPartial<T>): T;
+}
+
+declare class ConnectionManager {
+    private config;
+    private clients;
+    private tokenClients;
+    private streamClients;
+    private authPromises;
+    constructor(config: WalletConfigService);
+    createClients(): Promise<void>;
+    closeConnections(): Promise<void>;
+    createMockClient(address: string): Promise<MockServiceClient & {
+        close: () => void;
+    }>;
+    private createChannelWithTLS;
+    createSparkStreamClient(address: string, certPath?: string): Promise<SparkServiceClient & {
+        close?: () => void;
+    }>;
+    createSparkClient(address: string, certPath?: string): Promise<SparkServiceClient & {
+        close?: () => void;
+    }>;
+    createSparkTokenClient(address: string, certPath?: string): Promise<SparkTokenServiceClient & {
+        close?: () => void;
+    }>;
+    getStreamChannel(address: string): Promise<Channel | Channel$1 | undefined>;
+    private authenticate;
+    private createSparkAuthnGrpcConnection;
+    private createAuthnMiddleware;
+    private createMiddleware;
+    private handleMiddlewareError;
+    private createNodeMiddleware;
+    private createBrowserMiddleware;
+    private createGrpcClient;
+}
+
+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 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[]>;
+    protected tokenMetadata: Map<string, TokenMetadata>;
+    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 getTokenMetadata;
+    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
+     * 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, issuerPublicKeys, tokenTransactionHashes, tokenIdentifiers, outputIds, }: {
+        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 { type ConfigOptions as C, type DecodedSparkAddressData as D, type HumanReadableTokenIdentifier as H, type InitWalletResponse as I, LRC_WALLET_NETWORK as L, Network as N, type PayLightningInvoiceParams as P, SparkWallet as S, type TokenBalanceMap as T, type UserTokenMetadata as U, WalletConfigService as W, type SparkWalletProps as a, type SparkAddressFormat as b, ConnectionManager as c, WalletConfig as d, type SparkAddressData as e, encodeSparkAddress as f, decodeSparkAddress as g, isValidPublicKey as h, isValidSparkAddress as i, type NetworkType as j, NetworkToProto as k, getNetwork as l, LRC_WALLET_NETWORK_TYPE as m, getNetworkFromAddress as n, getNetworkFromString as o, protoToNetwork as p, type HumanReadableTokenIdentifierData as q, encodeHumanReadableTokenIdentifier as r, decodeHumanReadableTokenIdentifier as s, type CreateLightningInvoiceParams as t, type TransferParams as u, type DepositParams as v, type SparkWalletEvents as w };