@buildonspark/spark-sdk 0.3.5 → 0.3.7

package/dist/native/{index.d.cts → index.react-native.d.cts}

@@ -1,16 +1,16 @@
 import * as _scure_base from '@scure/base';
 import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
-import { CallOptions } from 'nice-grpc-common';
+import { CallOptions, ClientMiddlewareCall, Metadata } from 'nice-grpc-common';
 import * as btc from '@scure/btc-signer';
 import { Transaction } from '@scure/btc-signer';
-import * as bitcoin from 'bitcoinjs-lib';
 import { TransactionOutput, TransactionInput } from '@scure/btc-signer/psbt';
 import { HDKey } from '@scure/bip32';
 import { Query, Logger, LoggingLevel } from '@lightsparkdev/core';
 import { Channel } from 'nice-grpc';
-import { Channel as Channel$1 } from 'nice-grpc-web';
+import { Channel as Channel$1, createChannel } from 'nice-grpc-web';
 import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
 import { EventEmitter } from 'eventemitter3';
+import * as nice_grpc_web_lib_client_Transport_js from 'nice-grpc-web/lib/client/Transport.js';
 
 declare class SparkSDKError extends Error {
     readonly context: Record<string, unknown>;
@@ -1559,6 +1559,495 @@ interface TokenTransfer {
     finalTokenTransactionHash: Uint8Array;
 }
 declare const TokenTransfer: MessageFns$2<TokenTransfer>;
+type SparkServiceDefinition = typeof SparkServiceDefinition;
+declare const SparkServiceDefinition: {
+    readonly name: "SparkService";
+    readonly fullName: "spark.SparkService";
+    readonly methods: {
+        readonly generate_deposit_address: {
+            readonly name: "generate_deposit_address";
+            readonly requestType: MessageFns$2<GenerateDepositAddressRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<GenerateDepositAddressResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Generates a new static deposit address of the user or returns the existing one for the specified network. */
+        readonly generate_static_deposit_address: {
+            readonly name: "generate_static_deposit_address";
+            readonly requestType: MessageFns$2<GenerateStaticDepositAddressRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<GenerateStaticDepositAddressResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly start_deposit_tree_creation: {
+            readonly name: "start_deposit_tree_creation";
+            readonly requestType: MessageFns$2<StartDepositTreeCreationRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<StartDepositTreeCreationResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * This is deprecated, please use start_deposit_tree_creation instead.
+         *
+         * @deprecated
+         */
+        readonly start_tree_creation: {
+            readonly name: "start_tree_creation";
+            readonly requestType: MessageFns$2<StartTreeCreationRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<StartTreeCreationResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly finalize_node_signatures: {
+            readonly name: "finalize_node_signatures";
+            readonly requestType: MessageFns$2<FinalizeNodeSignaturesRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<FinalizeNodeSignaturesResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly start_transfer: {
+            readonly name: "start_transfer";
+            readonly requestType: MessageFns$2<StartTransferRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<StartTransferResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * This is deprecated, please use finalize_transfer_with_transfer_package instead.
+         *
+         * @deprecated
+         */
+        readonly finalize_transfer: {
+            readonly name: "finalize_transfer";
+            readonly requestType: MessageFns$2<FinalizeTransferRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<FinalizeTransferResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly finalize_transfer_with_transfer_package: {
+            readonly name: "finalize_transfer_with_transfer_package";
+            readonly requestType: MessageFns$2<FinalizeTransferWithTransferPackageRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<FinalizeTransferResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly cancel_transfer: {
+            readonly name: "cancel_transfer";
+            readonly requestType: MessageFns$2<CancelTransferRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<CancelTransferResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly query_pending_transfers: {
+            readonly name: "query_pending_transfers";
+            readonly requestType: MessageFns$2<TransferFilter>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<QueryTransfersResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly query_all_transfers: {
+            readonly name: "query_all_transfers";
+            readonly requestType: MessageFns$2<TransferFilter>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<QueryTransfersResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly claim_transfer_tweak_keys: {
+            readonly name: "claim_transfer_tweak_keys";
+            readonly requestType: MessageFns$2<ClaimTransferTweakKeysRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$4<Empty>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly claim_transfer_sign_refunds: {
+            readonly name: "claim_transfer_sign_refunds";
+            readonly requestType: MessageFns$2<ClaimTransferSignRefundsRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<ClaimTransferSignRefundsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly store_preimage_share: {
+            readonly name: "store_preimage_share";
+            readonly requestType: MessageFns$2<StorePreimageShareRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$4<Empty>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly get_signing_commitments: {
+            readonly name: "get_signing_commitments";
+            readonly requestType: MessageFns$2<GetSigningCommitmentsRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<GetSigningCommitmentsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly cooperative_exit: {
+            readonly name: "cooperative_exit";
+            readonly requestType: MessageFns$2<CooperativeExitRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<CooperativeExitResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly initiate_preimage_swap: {
+            readonly name: "initiate_preimage_swap";
+            readonly requestType: MessageFns$2<InitiatePreimageSwapRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<InitiatePreimageSwapResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly provide_preimage: {
+            readonly name: "provide_preimage";
+            readonly requestType: MessageFns$2<ProvidePreimageRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<ProvidePreimageResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * This is the exact same as start_transfer, but expresses to the SO
+         * this transfer is specifically for a leaf swap.
+         */
+        readonly start_leaf_swap: {
+            readonly name: "start_leaf_swap";
+            readonly requestType: MessageFns$2<StartTransferRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<StartTransferResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * This is deprecated, please use counter_leaf_swap instead.
+         *
+         * @deprecated
+         */
+        readonly leaf_swap: {
+            readonly name: "leaf_swap";
+            readonly requestType: MessageFns$2<CounterLeafSwapRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<CounterLeafSwapResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * This is the exact same as start_leaf_swap, but signs with
+         * an adaptor public key after a counterparty has begun the swap via start_leaf_swap.
+         */
+        readonly counter_leaf_swap: {
+            readonly name: "counter_leaf_swap";
+            readonly requestType: MessageFns$2<CounterLeafSwapRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<CounterLeafSwapResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly refresh_timelock: {
+            readonly name: "refresh_timelock";
+            readonly requestType: MessageFns$2<RefreshTimelockRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<RefreshTimelockResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly extend_leaf: {
+            readonly name: "extend_leaf";
+            readonly requestType: MessageFns$2<ExtendLeafRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<ExtendLeafResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * Resets the timelocks for a leaf's transactions. Can be used to reset the
+         * refund transaction timelock for a leaf (when the node transaction
+         * timelock is still > 300) or reset the node and refund transaction
+         * timelock. Returns an error if a leaf is not yet eligible to renew the
+         * timelocks, see RenewLeafRequest for more details.
+         */
+        readonly renew_leaf: {
+            readonly name: "renew_leaf";
+            readonly requestType: MessageFns$2<RenewLeafRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<RenewLeafResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly get_signing_operator_list: {
+            readonly name: "get_signing_operator_list";
+            readonly requestType: MessageFns$4<Empty>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<GetSigningOperatorListResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly query_nodes: {
+            readonly name: "query_nodes";
+            readonly requestType: MessageFns$2<QueryNodesRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<QueryNodesResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly query_nodes_distribution: {
+            readonly name: "query_nodes_distribution";
+            readonly requestType: MessageFns$2<QueryNodesDistributionRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<QueryNodesDistributionResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly query_nodes_by_value: {
+            readonly name: "query_nodes_by_value";
+            readonly requestType: MessageFns$2<QueryNodesByValueRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<QueryNodesByValueResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly query_balance: {
+            readonly name: "query_balance";
+            readonly requestType: MessageFns$2<QueryBalanceRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<QueryBalanceResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly query_user_signed_refunds: {
+            readonly name: "query_user_signed_refunds";
+            readonly requestType: MessageFns$2<QueryUserSignedRefundsRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<QueryUserSignedRefundsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Token RPCs */
+        readonly start_token_transaction: {
+            readonly name: "start_token_transaction";
+            readonly requestType: MessageFns$2<StartTokenTransactionRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<StartTokenTransactionResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly sign_token_transaction: {
+            readonly name: "sign_token_transaction";
+            readonly requestType: MessageFns$2<SignTokenTransactionRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<SignTokenTransactionResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly finalize_token_transaction: {
+            readonly name: "finalize_token_transaction";
+            readonly requestType: MessageFns$2<FinalizeTokenTransactionRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$4<Empty>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly freeze_tokens: {
+            readonly name: "freeze_tokens";
+            readonly requestType: MessageFns$2<FreezeTokensRequest$1>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<FreezeTokensResponse$1>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly query_token_outputs: {
+            readonly name: "query_token_outputs";
+            readonly requestType: MessageFns$2<QueryTokenOutputsRequest$1>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<QueryTokenOutputsResponse$1>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly query_token_transactions: {
+            readonly name: "query_token_transactions";
+            readonly requestType: MessageFns$2<QueryTokenTransactionsRequest$1>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<QueryTokenTransactionsResponse$1>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly return_lightning_payment: {
+            readonly name: "return_lightning_payment";
+            readonly requestType: MessageFns$2<ReturnLightningPaymentRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$4<Empty>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly query_unused_deposit_addresses: {
+            readonly name: "query_unused_deposit_addresses";
+            readonly requestType: MessageFns$2<QueryUnusedDepositAddressesRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<QueryUnusedDepositAddressesResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly query_static_deposit_addresses: {
+            readonly name: "query_static_deposit_addresses";
+            readonly requestType: MessageFns$2<QueryStaticDepositAddressesRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<QueryStaticDepositAddressesResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly subscribe_to_events: {
+            readonly name: "subscribe_to_events";
+            readonly requestType: MessageFns$2<SubscribeToEventsRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<SubscribeToEventsResponse>;
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /**
+         * Signs the provided refund transaction which spends the UTXO from a static
+         * deposit address. If successful, the UTXO will no longer be available to claim on
+         * the Spark network, and the refund transaction must be broadcasted on L1 to claim
+         * the funds. Returns an error if the UTXO has already been claimed.
+         */
+        readonly initiate_static_deposit_utxo_refund: {
+            readonly name: "initiate_static_deposit_utxo_refund";
+            readonly requestType: MessageFns$2<InitiateStaticDepositUtxoRefundRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<InitiateStaticDepositUtxoRefundResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * DEPRECATED: This unified method is being split for better clarity and type safety
+         *
+         * For swap operations: Use spark_ssp_internal.initiate_static_deposit_utxo_swap()
+         * For refund operations: Use initiate_static_deposit_utxo_refund()
+         *
+         * @deprecated
+         */
+        readonly initiate_utxo_swap: {
+            readonly name: "initiate_utxo_swap";
+            readonly requestType: MessageFns$2<InitiateUtxoSwapRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<InitiateUtxoSwapResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly exit_single_node_trees: {
+            readonly name: "exit_single_node_trees";
+            readonly requestType: MessageFns$2<ExitSingleNodeTreesRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<ExitSingleNodeTreesResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * The following endpoints enforce inclusion of Direct Transactions used
+         * for unilateral exits
+         */
+        readonly cooperative_exit_v2: {
+            readonly name: "cooperative_exit_v2";
+            readonly requestType: MessageFns$2<CooperativeExitRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<CooperativeExitResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly extend_leaf_v2: {
+            readonly name: "extend_leaf_v2";
+            readonly requestType: MessageFns$2<ExtendLeafRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<ExtendLeafResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly claim_transfer_sign_refunds_v2: {
+            readonly name: "claim_transfer_sign_refunds_v2";
+            readonly requestType: MessageFns$2<ClaimTransferSignRefundsRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<ClaimTransferSignRefundsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly finalize_node_signatures_v2: {
+            readonly name: "finalize_node_signatures_v2";
+            readonly requestType: MessageFns$2<FinalizeNodeSignaturesRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<FinalizeNodeSignaturesResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly initiate_preimage_swap_v2: {
+            readonly name: "initiate_preimage_swap_v2";
+            readonly requestType: MessageFns$2<InitiatePreimageSwapRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<InitiatePreimageSwapResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly start_leaf_swap_v2: {
+            readonly name: "start_leaf_swap_v2";
+            readonly requestType: MessageFns$2<StartTransferRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<StartTransferResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly counter_leaf_swap_v2: {
+            readonly name: "counter_leaf_swap_v2";
+            readonly requestType: MessageFns$2<CounterLeafSwapRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<CounterLeafSwapResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly start_transfer_v2: {
+            readonly name: "start_transfer_v2";
+            readonly requestType: MessageFns$2<StartTransferRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<StartTransferResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly refresh_timelock_v2: {
+            readonly name: "refresh_timelock_v2";
+            readonly requestType: MessageFns$2<RefreshTimelockRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<RefreshTimelockResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly get_utxos_for_address: {
+            readonly name: "get_utxos_for_address";
+            readonly requestType: MessageFns$2<GetUtxosForAddressRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<GetUtxosForAddressResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly query_spark_invoices: {
+            readonly name: "query_spark_invoices";
+            readonly requestType: MessageFns$2<QuerySparkInvoicesRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$2<QuerySparkInvoicesResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
 interface SparkServiceClient<CallOptionsExt = {}> {
     generate_deposit_address(request: DeepPartial$2<GenerateDepositAddressRequest>, options?: CallOptions & CallOptionsExt): Promise<GenerateDepositAddressResponse>;
     /** Generates a new static deposit address of the user or returns the existing one for the specified network. */
@@ -1712,13 +2201,6 @@ 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;
-}>;
 /**
  * Utility function to determine the network from a Bitcoin address.
  *
@@ -2220,6 +2702,69 @@ interface FreezeTokensResponse {
     impactedTokenAmount: Uint8Array;
 }
 declare const FreezeTokensResponse: MessageFns$1<FreezeTokensResponse>;
+type SparkTokenServiceDefinition = typeof SparkTokenServiceDefinition;
+declare const SparkTokenServiceDefinition: {
+    readonly name: "SparkTokenService";
+    readonly fullName: "spark_token.SparkTokenService";
+    readonly methods: {
+        /**
+         * Start process to create final token transaction with all inputs required
+         * from user and SOs (including revocation secret commitment)
+         */
+        readonly start_transaction: {
+            readonly name: "start_transaction";
+            readonly requestType: MessageFns$1<StartTransactionRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$1<StartTransactionResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * Complete the transaction and commit it with all SOs. This will be
+         * coordinated by one SO.
+         */
+        readonly commit_transaction: {
+            readonly name: "commit_transaction";
+            readonly requestType: MessageFns$1<CommitTransactionRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$1<CommitTransactionResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly query_token_metadata: {
+            readonly name: "query_token_metadata";
+            readonly requestType: MessageFns$1<QueryTokenMetadataRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$1<QueryTokenMetadataResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly query_token_transactions: {
+            readonly name: "query_token_transactions";
+            readonly requestType: MessageFns$1<QueryTokenTransactionsRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$1<QueryTokenTransactionsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly query_token_outputs: {
+            readonly name: "query_token_outputs";
+            readonly requestType: MessageFns$1<QueryTokenOutputsRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$1<QueryTokenOutputsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly freeze_tokens: {
+            readonly name: "freeze_tokens";
+            readonly requestType: MessageFns$1<FreezeTokensRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns$1<FreezeTokensResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
 interface SparkTokenServiceClient<CallOptionsExt = {}> {
     /**
      * Start process to create final token transaction with all inputs required
@@ -2756,7 +3301,7 @@ interface ClaimStaticDepositOutput {
 
 interface CompleteCoopExitInput {
     userOutboundTransferExternalId: string;
-    coopExitRequestId: string;
+    coopExitRequestId?: string | undefined;
 }
 
 interface CompleteLeavesSwapInput {
@@ -2844,11 +3389,12 @@ interface LightningSendFeeEstimateOutput {
 interface RequestCoopExitInput {
     leafExternalIds: string[];
     withdrawalAddress: string;
-    idempotencyKey: string;
+    idempotencyKey?: string | undefined;
     exitSpeed: ExitSpeed;
     withdrawAll: boolean;
     feeLeafExternalIds?: string[] | undefined;
     feeQuoteId?: string | undefined;
+    userOutboundTransferExternalId?: string | undefined;
 }
 
 interface UserLeafInput {
@@ -2908,12 +3454,13 @@ interface RequestLightningReceiveInput {
 
 interface RequestLightningSendInput {
     encodedInvoice: string;
-    idempotencyKey: string;
+    idempotencyKey?: string | undefined;
     /**
- * The amount you will pay for this invoice in sats. It should ONLY be set when the invoice amount is
- * zero.
-**/
+     * The amount you will pay for this invoice in sats. It should ONLY be set when the invoice amount is
+     * zero.
+     **/
     amountSats?: number | undefined;
+    userOutboundTransferExternalId?: string | undefined;
 }
 
 interface StaticDepositQuoteInput {
@@ -2970,10 +3517,10 @@ declare class SspClient {
     getLightningSendFeeEstimate(encodedInvoice: string, amountSats?: number): Promise<LightningSendFeeEstimateOutput | null>;
     getCoopExitFeeEstimate({ leafExternalIds, withdrawalAddress, }: CoopExitFeeEstimatesInput): Promise<CoopExitFeeEstimatesOutput | null>;
     getCurrentUser(): Promise<void>;
-    completeCoopExit({ userOutboundTransferExternalId, coopExitRequestId, }: CompleteCoopExitInput): Promise<CoopExitRequest | null>;
-    requestCoopExit({ leafExternalIds, withdrawalAddress, idempotencyKey, exitSpeed, feeLeafExternalIds, feeQuoteId, withdrawAll, }: RequestCoopExitInput): Promise<CoopExitRequest | null>;
+    completeCoopExit({ userOutboundTransferExternalId, }: CompleteCoopExitInput): Promise<CoopExitRequest | null>;
+    requestCoopExit({ leafExternalIds, withdrawalAddress, exitSpeed, feeLeafExternalIds, feeQuoteId, withdrawAll, userOutboundTransferExternalId, }: RequestCoopExitInput): Promise<CoopExitRequest | null>;
     requestLightningReceive({ amountSats, network, paymentHash, expirySecs, memo, includeSparkAddress, receiverIdentityPubkey, descriptionHash, }: RequestLightningReceiveInput): Promise<LightningReceiveRequest | null>;
-    requestLightningSend({ encodedInvoice, idempotencyKey, amountSats, }: RequestLightningSendInput): Promise<LightningSendRequest | null>;
+    requestLightningSend({ encodedInvoice, amountSats, userOutboundTransferExternalId, }: RequestLightningSendInput): Promise<LightningSendRequest | null>;
     requestLeaveSwap({ adaptorPubkey, directAdaptorPubkey, directFromCpfpAdaptorPubkey, totalAmountSats, targetAmountSats, feeSats, userLeaves, idempotencyKey, targetAmountSatsList, }: RequestLeavesSwapInput): Promise<LeavesSwapRequest | null>;
     completeLeaveSwap({ adaptorSecretKey, directAdaptorSecretKey, directFromCpfpAdaptorSecretKey, userOutboundTransferExternalId, leavesSwapRequestId, }: CompleteLeavesSwapInput): Promise<LeavesSwapRequest | null>;
     getLightningReceiveRequest(id: string): Promise<LightningReceiveRequest | null>;
@@ -3029,507 +3576,259 @@ declare const WalletConfig: {
     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 TransferWithInvoiceParams = {
-    amountSats: number;
-    receiverIdentityPubkey: Uint8Array;
-    sparkInvoice?: SparkAddressFormat;
-};
-type TransferWithInvoiceOutcome = {
-    ok: true;
-    transfer: WalletTransfer;
-    param: TransferWithInvoiceParams;
-} | {
-    ok: false;
-    error: Error;
-    param: TransferWithInvoiceParams;
-};
-type FulfillSparkInvoiceResponse = {
-    satsTransactionSuccess: {
-        invoice: SparkAddressFormat;
-        transferResponse: WalletTransfer;
-    }[];
-    tokenTransactionSuccess: {
-        tokenIdentifier: Bech32mTokenIdentifier;
-        txid: string;
-    }[];
-    satsTransactionErrors: {
-        invoice: string;
-        error: Error;
-    }[];
-    tokenTransactionErrors: {
-        tokenIdentifier: Bech32mTokenIdentifier;
-        error: Error;
-    }[];
-    invalidInvoices: {
-        invoice: string;
-        error: Error;
-    }[];
-};
-type TokenInvoice = {
-    invoice: string;
-    identifierHex: string;
-    amount: bigint;
-};
-type InvalidInvoice = {
-    invoice: string;
-    error: Error;
+declare class WalletConfigService implements HasSspClientOptions {
+    private readonly config;
+    readonly signer: SparkSigner;
+    readonly sspClientOptions: SspClientOptions;
+    constructor(options: ConfigOptions | undefined, signer: SparkSigner);
+    private getDefaultConfig;
+    getCoordinatorAddress(): 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";
+    getTokenValidityDurationSeconds(): number;
+    getElectrsUrl(): string;
+    getSspBaseUrl(): string;
+    getSspIdentityPublicKey(): string;
+    getConsoleOptions(): ConsoleOptions;
+}
+
+/** Challenge represents the core challenge data */
+interface Challenge {
+    /** Protocol version for backward compatibility */
+    version: number;
+    /** Timestamp when challenge was issued (UTC Unix seconds) */
+    timestamp: number;
+    /** Random nonce to prevent replay attacks (32 bytes) */
+    nonce: Uint8Array;
+    /** The public key this challenge is intended for (uncompressed secp256k1 public key) */
+    publicKey: Uint8Array;
+}
+declare const Challenge: MessageFns<Challenge>;
+/** ProtectedChallenge wraps a Challenge with a server HMAC */
+interface ProtectedChallenge {
+    /** Protocol version for backward compatibility */
+    version: number;
+    /** The core challenge data */
+    challenge: Challenge | undefined;
+    /** Server's HMAC of the Challenge */
+    serverHmac: Uint8Array;
+}
+declare const ProtectedChallenge: MessageFns<ProtectedChallenge>;
+/** Request to initiate an authentication challenge */
+interface GetChallengeRequest {
+    /** Client's public key (uncompressed secp256k1 public key) */
+    publicKey: Uint8Array;
+}
+declare const GetChallengeRequest: MessageFns<GetChallengeRequest>;
+/** Response containing the protected challenge */
+interface GetChallengeResponse {
+    /** The protected challenge from the server */
+    protectedChallenge: ProtectedChallenge | undefined;
+}
+declare const GetChallengeResponse: MessageFns<GetChallengeResponse>;
+/** Request to verify a signed challenge */
+interface VerifyChallengeRequest {
+    /** The protected challenge from the server */
+    protectedChallenge: ProtectedChallenge | undefined;
+    /** Client's secp256k1 signature of the Challenge */
+    signature: Uint8Array;
+    /** Client's public key (uncompressed secp256k1 public key) */
+    publicKey: Uint8Array;
+}
+declare const VerifyChallengeRequest: MessageFns<VerifyChallengeRequest>;
+/** Response after successful authentication */
+interface VerifyChallengeResponse {
+    /** Session token for subsequent API calls */
+    sessionToken: string;
+    /** Token expiration timestamp (UTC Unix seconds) */
+    expirationTimestamp: number;
+}
+declare const VerifyChallengeResponse: MessageFns<VerifyChallengeResponse>;
+type SparkAuthnServiceDefinition = typeof SparkAuthnServiceDefinition;
+declare const SparkAuthnServiceDefinition: {
+    readonly name: "SparkAuthnService";
+    readonly fullName: "spark_authn.SparkAuthnService";
+    readonly methods: {
+        /** Request a new authentication challenge for a public key */
+        readonly get_challenge: {
+            readonly name: "get_challenge";
+            readonly requestType: MessageFns<GetChallengeRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<GetChallengeResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Verify a signed challenge and return a session token */
+        readonly verify_challenge: {
+            readonly name: "verify_challenge";
+            readonly requestType: MessageFns<VerifyChallengeRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<VerifyChallengeResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
 };
-type GroupSparkInvoicesResult = {
-    satsInvoices: TransferWithInvoiceParams[];
-    tokenInvoices: Map<string, TokenInvoice[]>;
-    invalidInvoices: InvalidInvoice[];
+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;
+}
+
+interface RetryOptions {
+    retry?: boolean;
+    retryMaxAttempts?: number;
+}
+type SparkCallOptions = CallOptions & RetryOptions;
+
+declare class ConnectionManager {
+    private config;
+    protected clients: Map<string, {
+        client: SparkServiceClient & {
+            close?: () => void;
+        };
+        authToken: string;
+    }>;
+    private tokenClients;
+    private streamClients;
+    private authPromises;
+    constructor(config: WalletConfigService);
+    createClients(): Promise<void>;
+    closeConnections(): Promise<void>;
+    protected createChannelWithTLS(address: string, certPath?: string): Promise<Channel | Channel$1>;
+    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;
+    protected createAuthnMiddleware(): (call: ClientMiddlewareCall<any, any>, options: SparkCallOptions) => AsyncGenerator<any, any, undefined>;
+    protected createMiddleware(address: string, authToken: string): ((call: ClientMiddlewareCall<any, any>, options: SparkCallOptions) => AsyncGenerator<any, any, undefined>) | undefined;
+    protected handleMiddlewareError(error: unknown, address: string, call: ClientMiddlewareCall<any, any>, metadata: Metadata, options: SparkCallOptions): AsyncGenerator<any, any, undefined>;
+    protected createGrpcClient<T>(defintion: SparkAuthnServiceDefinition | SparkServiceDefinition | SparkTokenServiceDefinition, channel: Channel | Channel$1, withRetries: boolean, middleware?: any): Promise<T & {
+        close?: () => void;
+    }>;
+}
+
+declare class SigningService {
+    private readonly config;
+    constructor(config: WalletConfigService);
+    private signRefundsInternal;
+    signRefunds(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, cpfpSigningCommitments: RequestedSigningCommitments[], directSigningCommitments: RequestedSigningCommitments[], directFromCpfpSigningCommitments: RequestedSigningCommitments[]): Promise<{
+        cpfpLeafSigningJobs: UserSignedTxSigningJob[];
+        directLeafSigningJobs: UserSignedTxSigningJob[];
+        directFromCpfpLeafSigningJobs: UserSignedTxSigningJob[];
+    }>;
+}
+
+type LeafKeyTweak = {
+    leaf: TreeNode;
+    keyDerivation: KeyDerivation;
+    newKeyDerivation: KeyDerivation;
 };
-type DepositParams = {
+type LeafRefundSigningData = {
     keyDerivation: KeyDerivation;
-    verifyingKey: Uint8Array;
-    depositTx: Transaction;
+    receivingPubkey: Uint8Array;
+    signingNonceCommitment: SigningCommitmentWithOptionalNonce;
+    directSigningNonceCommitment: SigningCommitmentWithOptionalNonce;
+    tx: Transaction;
+    directTx?: Transaction;
+    refundTx?: Transaction;
+    directRefundTx?: Transaction;
+    directFromCpfpRefundTx?: Transaction;
+    directFromCpfpRefundSigningNonceCommitment: SigningCommitmentWithOptionalNonce;
     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 bech32m encoded 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<Bech32mTokenIdentifier, {
-    balance: bigint;
-    tokenMetadata: UserTokenMetadata;
-}>;
-type RawTokenIdentifierHex = string & {
-    readonly __brand: "RawTokenIdentifierHex";
-};
-type TokenOutputsMap = Map<Bech32mTokenIdentifier, OutputWithPreviousTransactionData$1[]>;
-type TokenMetadataMap = Map<Bech32mTokenIdentifier, TokenMetadata>;
-type InitWalletResponse = {
-    mnemonic?: string | undefined;
-};
-interface SparkWalletProps {
-    mnemonicOrSeed?: Uint8Array | string;
-    accountNumber?: number;
-    signer?: SparkSigner;
-    options?: ConfigOptions;
+declare class BaseTransferService {
+    protected readonly config: WalletConfigService;
+    protected readonly connectionManager: ConnectionManager;
+    protected readonly signingService: SigningService;
+    constructor(config: WalletConfigService, connectionManager: ConnectionManager, signingService: SigningService);
+    deliverTransferPackage(transfer: Transfer$1, leaves: LeafKeyTweak[], cpfpRefundSignatureMap: Map<string, Uint8Array>, directRefundSignatureMap: Map<string, Uint8Array>, directFromCpfpRefundSignatureMap: Map<string, Uint8Array>): Promise<Transfer$1>;
+    sendTransferWithKeyTweaks(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, sparkInvoice?: SparkAddressFormat): Promise<Transfer$1>;
+    private prepareTransferPackage;
+    signRefunds(leafDataMap: Map<string, LeafRefundSigningData>, operatorSigningResults: LeafRefundTxSigningResult[]): Promise<NodeSignatures[]>;
+    private prepareSendTransferKeyTweaks;
+    private prepareSingleSendTransferKeyTweak;
+    protected findShare(shares: VerifiableSecretShare[], operatorID: number): VerifiableSecretShare | undefined;
+    private compareTransfers;
 }
-declare const SparkWalletEvent: {
-    readonly All: "*";
-    readonly TransferClaimed: "transfer:claimed";
-    readonly DepositConfirmed: "deposit:confirmed";
-    readonly StreamConnected: "stream:connected";
-    readonly StreamDisconnected: "stream:disconnected";
-    readonly StreamReconnecting: "stream:reconnecting";
-};
-type SparkWalletEventType = (typeof SparkWalletEvent)[keyof typeof SparkWalletEvent];
-interface SparkWalletEvents {
-    [SparkWalletEvent.All]: (eventName: string, ...args: unknown[]) => void;
-    /** Emitted when an incoming transfer is successfully claimed. Includes the transfer ID and new total balance. */
-    [SparkWalletEvent.TransferClaimed]: (transferId: string, updatedBalance: bigint) => void;
-    /** Emitted when a deposit is marked as available. Includes the deposit ID and new total balance. */
-    [SparkWalletEvent.DepositConfirmed]: (depositId: string, updatedBalance: bigint) => void;
-    /** Emitted when the stream is connected */
-    [SparkWalletEvent.StreamConnected]: () => void;
-    /** Emitted when the stream disconnects and fails to reconnect after max attempts */
-    [SparkWalletEvent.StreamDisconnected]: (reason: string) => void;
-    /** Emitted when attempting to reconnect the stream */
-    [SparkWalletEvent.StreamReconnecting]: (attempt: number, maxAttempts: number, delayMs: number, error: string) => void;
+declare class TransferService extends BaseTransferService {
+    constructor(config: WalletConfigService, connectionManager: ConnectionManager, signingService: SigningService);
+    claimTransfer(transfer: Transfer$1, leaves: LeafKeyTweak[]): Promise<FinalizeNodeSignaturesResponse>;
+    queryPendingTransfers(transferIds?: string[]): Promise<QueryTransfersResponse>;
+    queryAllTransfers(limit: number, offset: number): Promise<QueryTransfersResponse>;
+    verifyPendingTransfer(transfer: Transfer$1): Promise<Map<string, Uint8Array>>;
+    queryTransfer(transferId: string): Promise<Transfer$1 | undefined>;
+    sendTransferSignRefund(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date): Promise<{
+        transfer: Transfer$1;
+        signatureMap: Map<string, Uint8Array>;
+        directSignatureMap: Map<string, Uint8Array>;
+        directFromCpfpSignatureMap: Map<string, Uint8Array>;
+        leafDataMap: Map<string, LeafRefundSigningData>;
+    }>;
+    startSwapSignRefund(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date): Promise<{
+        transfer: Transfer$1;
+        signatureMap: Map<string, Uint8Array>;
+        directSignatureMap: Map<string, Uint8Array>;
+        directFromCpfpSignatureMap: Map<string, Uint8Array>;
+        leafDataMap: Map<string, LeafRefundSigningData>;
+    }>;
+    sendTransferSignRefundInternal(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date, forSwap: boolean): Promise<{
+        transfer: Transfer$1;
+        signatureMap: Map<string, Uint8Array>;
+        directSignatureMap: Map<string, Uint8Array>;
+        directFromCpfpSignatureMap: Map<string, Uint8Array>;
+        leafDataMap: Map<string, LeafRefundSigningData>;
+        signingResults: LeafRefundTxSigningResult[];
+    }>;
+    private prepareRefundSoSigningJobs;
+    claimTransferTweakKeys(transfer: Transfer$1, leaves: LeafKeyTweak[]): Promise<Map<string, Uint8Array[]>>;
+    private prepareClaimLeavesKeyTweaks;
+    private prepareClaimLeafKeyTweaks;
+    claimTransferSignRefunds(transfer: Transfer$1, leafKeys: LeafKeyTweak[], proofMap?: Map<string, Uint8Array[]>): Promise<NodeSignatures[]>;
+    private finalizeNodeSignatures;
+    queryPendingTransfersBySender(operatorAddress: string): Promise<QueryTransfersResponse>;
+    private refreshTimelockNodesInternal;
+    refreshTimelockNodes(node: TreeNode, parentNode: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
+    extendTimelock(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
+    testonly_expireTimeLockNodeTx(node: TreeNode, parentNode: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
+    testonly_expireTimeLockRefundtx(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
 }
 
-declare function sumAvailableTokens(outputs: OutputWithPreviousTransactionData$1[]): bigint;
-declare function checkIfSelectedOutputsAreAvailable(selectedOutputs: OutputWithPreviousTransactionData$1[], tokenOutputs: TokenOutputsMap, tokenIdentifier: Bech32mTokenIdentifier): boolean;
-declare function filterTokenBalanceForTokenIdentifier(tokenBalances: TokenBalanceMap, tokenIdentifier: Bech32mTokenIdentifier): {
-    balance: bigint;
-};
-
-declare function getTransferPackageSigningPayload(transferID: string, transferPackage: TransferPackage): Uint8Array;
-
-declare const DIRECT_TIMELOCK_OFFSET = 50;
-declare const INITIAL_SEQUENCE: number;
-declare const INITIAL_DIRECT_SEQUENCE: number;
-declare const TEST_UNILATERAL_SEQUENCE: number;
-declare const TEST_UNILATERAL_DIRECT_SEQUENCE: number;
-declare const DEFAULT_FEE_SATS: number;
 /**
- * Subtracts the default fee from the amount if it's greater than the fee.
- * Returns the original amount if it's less than or equal to the fee.
+ * 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 function maybeApplyFee(amount: bigint): bigint;
-declare function createRootTx(depositOutPoint: TransactionInput, depositTxOut: TransactionOutput): [Transaction, Transaction];
-declare function createSplitTx(parentOutPoint: TransactionInput, childTxOuts: TransactionOutput[]): [Transaction, Transaction];
-interface CreateNodeTxInput {
-    txOut: TransactionOutput;
-    parentOutPoint: TransactionInput;
-    applyFee?: boolean;
-    includeAnchor?: boolean;
-}
-declare function createNodeTx({ txOut, parentOutPoint, applyFee, includeAnchor, }: CreateNodeTxInput): Transaction;
-declare function createNodeTxs(txOut: TransactionOutput, txIn: TransactionInput, directTxIn?: TransactionInput): {
-    cpfpNodeTx: Transaction;
-    directNodeTx?: Transaction;
-};
-declare function createLeafNodeTx(sequence: number, directSequence: number, parentOutPoint: TransactionInput, txOut: TransactionOutput, shouldCalculateFee: boolean): [Transaction, Transaction];
-interface CreateRefundTxInput {
-    sequence: number;
-    input: TransactionInput;
-    amountSats: bigint;
-    receivingPubkey: Uint8Array;
-    network: Network;
-    shouldCalculateFee: boolean;
-    includeAnchor: boolean;
-}
-declare function createRefundTx({ sequence, input, amountSats, receivingPubkey, network, shouldCalculateFee, includeAnchor, }: CreateRefundTxInput): Transaction;
-interface CreateRefundTxsInput {
-    sequence: number;
-    directSequence?: number;
-    input: TransactionInput;
-    directInput?: TransactionInput;
-    amountSats: bigint;
-    receivingPubkey: Uint8Array;
-    network: Network;
-}
-declare function createRefundTxs({ sequence, directSequence, input, directInput, amountSats, receivingPubkey, network, }: CreateRefundTxsInput): {
-    cpfpRefundTx: Transaction;
-    directRefundTx?: Transaction;
-    directFromCpfpRefundTx?: Transaction;
-};
-declare function createConnectorRefundTransactions(sequence: number, cpfpNodeOutPoint: TransactionInput, directNodeOutPoint: TransactionInput, connectorOutput: TransactionInput, amountSats: bigint, receiverPubKey: Uint8Array, network: Network, shouldCalculateFee: boolean): [Transaction, Transaction, Transaction];
-declare function getCurrentTimelock(currSequence?: number): number;
-declare function getTransactionSequence(currSequence?: number): {
-    nextSequence: number;
-    nextDirectSequence: number;
-};
-declare function checkIfValidSequence(currSequence?: number): void;
-declare function doesLeafNeedRefresh(currSequence: number, isNodeTx?: boolean): boolean;
-declare function getNextTransactionSequence(currSequence: number, isNodeTx?: boolean): {
-    nextSequence: number;
-    nextDirectSequence: number;
-};
-declare function getEphemeralAnchorOutput(): TransactionOutput;
-
-interface LeafInfo {
-    leafId: string;
-    nodeTx: string;
-    refundTx: string;
-}
-interface Utxo {
-    txid: string;
-    vout: number;
-    value: bigint;
-    script: string;
-    publicKey: string;
-}
-interface FeeRate {
-    satPerVbyte: number;
-}
-interface FeeBumpTxPackage {
-    tx: string;
-    feeBumpPsbt?: string;
-}
-interface FeeBumpTxChain {
-    leafId: string;
-    txPackages: FeeBumpTxPackage[];
-}
-interface TxChain {
-    leafId: string;
-    transactions: string[];
-}
-interface BroadcastConfig {
-    bitcoinCoreRpcUrl?: string;
-    rpcUsername?: string;
-    rpcPassword?: string;
-    autoBroadcast?: boolean;
-    network?: "MAINNET" | "REGTEST" | "TESTNET" | "SIGNET" | "LOCAL";
-}
-interface BroadcastResult {
-    success: boolean;
-    txids?: string[];
-    error?: string;
-    broadcastedPackages?: number;
-}
-declare function isEphemeralAnchorOutput(script?: Uint8Array, amount?: bigint): boolean;
-declare function constructUnilateralExitTxs(nodeHexStrings: string[], sparkClient?: SparkServiceClient, network?: any): Promise<TxChain[]>;
-declare function constructUnilateralExitFeeBumpPackages(nodeHexStrings: string[], utxos: Utxo[], feeRate: FeeRate, electrsUrl: string, sparkClient?: SparkServiceClient, network?: any): Promise<FeeBumpTxChain[]>;
-declare function constructFeeBumpTx(txHex: string, utxos: Utxo[], feeRate: FeeRate, previousFeeBumpTx?: string): {
-    feeBumpPsbt: string;
-    usedUtxos: Utxo[];
-    correctedParentTx?: string;
-};
-
-declare function getSparkAddressFromTaproot(taprootAddress: string): SparkAddressFormat;
-
-declare const LOGGER_NAMES: {
-    readonly wasm: "wasm";
-};
-type LoggerName = (typeof LOGGER_NAMES)[keyof typeof LOGGER_NAMES];
-declare class SparkSdkLogger {
-    private static loggers;
-    static get(name: LoggerName): Logger;
-    static setLevel(name: LoggerName, level: LoggingLevel): void;
-    static setAllLevels(level: LoggingLevel): void;
-    static setEnabled(name: LoggerName, enabled: boolean): void;
-    static setAllEnabled(enabled: boolean): void;
-}
-
-declare class ReactNativeSparkSigner extends DefaultSparkSigner {
-    signFrost({ message, keyDerivation, publicKey, verifyingKey, selfCommitment, statechainCommitments, adaptorPubKey, }: SignFrostParams): Promise<Uint8Array>;
-    aggregateFrost({ message, publicKey, verifyingKey, selfCommitment, statechainCommitments, adaptorPubKey, selfSignature, statechainSignatures, statechainPublicKeys, }: AggregateFrostParams): Promise<Uint8Array>;
-}
-
-declare class WalletConfigService implements HasSspClientOptions {
-    private readonly config;
-    readonly signer: SparkSigner;
-    readonly sspClientOptions: SspClientOptions;
-    constructor(options?: ConfigOptions, signer?: SparkSigner);
-    private getDefaultConfig;
-    getCoordinatorAddress(): 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";
-    getTokenValidityDurationSeconds(): number;
-    getElectrsUrl(): string;
-    getSspBaseUrl(): string;
-    getSspIdentityPublicKey(): string;
-    getConsoleOptions(): ConsoleOptions;
-}
-
-declare enum InterruptTransferRequest_InterruptTransferAction {
-    NONE = 0,
-    INTERRUPT = 1,
-    RESUME = 2,
-    UNRECOGNIZED = -1
-}
-declare enum InterruptCoopExitRequest_InterruptCoopExitAction {
-    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>;
-/** TriggerTaskRequest is used to trigger a scheduled task immediately in hermetic tests. */
-interface TriggerTaskRequest {
-    taskName: string;
-}
-declare const TriggerTaskRequest: MessageFns<TriggerTaskRequest>;
-interface InterruptCoopExitRequest {
-    action: InterruptCoopExitRequest_InterruptCoopExitAction;
-    /** optional, defaults to MockAction.TargetOperatorID */
-    targetOperator: string;
-}
-declare const InterruptCoopExitRequest: MessageFns<InterruptCoopExitRequest>;
-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>;
-    interrupt_coop_exit(request: DeepPartial<InterruptCoopExitRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
-    update_nodes_status(request: DeepPartial<UpdateNodesStatusRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
-    /** Triggers the execution of a scheduled task immediately by name. Used by hermetic tests */
-    trigger_task(request: DeepPartial<TriggerTaskRequest>, 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);
-    private signRefundsInternal;
-    signRefunds(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, cpfpSigningCommitments: RequestedSigningCommitments[], directSigningCommitments: RequestedSigningCommitments[], directFromCpfpSigningCommitments: RequestedSigningCommitments[]): Promise<{
-        cpfpLeafSigningJobs: UserSignedTxSigningJob[];
-        directLeafSigningJobs: UserSignedTxSigningJob[];
-        directFromCpfpLeafSigningJobs: UserSignedTxSigningJob[];
-    }>;
-}
-
-type LeafKeyTweak = {
-    leaf: TreeNode;
-    keyDerivation: KeyDerivation;
-    newKeyDerivation: KeyDerivation;
-};
-type LeafRefundSigningData = {
-    keyDerivation: KeyDerivation;
-    receivingPubkey: Uint8Array;
-    signingNonceCommitment: SigningCommitmentWithOptionalNonce;
-    directSigningNonceCommitment: SigningCommitmentWithOptionalNonce;
-    tx: Transaction;
-    directTx?: Transaction;
-    refundTx?: Transaction;
-    directRefundTx?: Transaction;
-    directFromCpfpRefundTx?: Transaction;
-    directFromCpfpRefundSigningNonceCommitment: SigningCommitmentWithOptionalNonce;
-    vout: number;
-};
-declare class BaseTransferService {
-    protected readonly config: WalletConfigService;
-    protected readonly connectionManager: ConnectionManager;
-    protected readonly signingService: SigningService;
-    constructor(config: WalletConfigService, connectionManager: ConnectionManager, signingService: SigningService);
-    deliverTransferPackage(transfer: Transfer$1, leaves: LeafKeyTweak[], cpfpRefundSignatureMap: Map<string, Uint8Array>, directRefundSignatureMap: Map<string, Uint8Array>, directFromCpfpRefundSignatureMap: Map<string, Uint8Array>): Promise<Transfer$1>;
-    sendTransferWithKeyTweaks(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, sparkInvoice?: SparkAddressFormat): Promise<Transfer$1>;
-    private prepareTransferPackage;
-    signRefunds(leafDataMap: Map<string, LeafRefundSigningData>, operatorSigningResults: LeafRefundTxSigningResult[]): 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);
-    claimTransfer(transfer: Transfer$1, leaves: LeafKeyTweak[]): Promise<FinalizeNodeSignaturesResponse>;
-    queryPendingTransfers(transferIds?: string[]): Promise<QueryTransfersResponse>;
-    queryAllTransfers(limit: number, offset: number): Promise<QueryTransfersResponse>;
-    verifyPendingTransfer(transfer: Transfer$1): Promise<Map<string, Uint8Array>>;
-    queryTransfer(transferId: string): Promise<Transfer$1 | undefined>;
-    sendTransferSignRefund(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date): Promise<{
-        transfer: Transfer$1;
-        signatureMap: Map<string, Uint8Array>;
-        directSignatureMap: Map<string, Uint8Array>;
-        directFromCpfpSignatureMap: Map<string, Uint8Array>;
-        leafDataMap: Map<string, LeafRefundSigningData>;
-    }>;
-    startSwapSignRefund(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date): Promise<{
-        transfer: Transfer$1;
-        signatureMap: Map<string, Uint8Array>;
-        directSignatureMap: Map<string, Uint8Array>;
-        directFromCpfpSignatureMap: Map<string, Uint8Array>;
-        leafDataMap: Map<string, LeafRefundSigningData>;
-    }>;
-    sendTransferSignRefundInternal(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date, forSwap: boolean): Promise<{
-        transfer: Transfer$1;
-        signatureMap: Map<string, Uint8Array>;
-        directSignatureMap: Map<string, Uint8Array>;
-        directFromCpfpSignatureMap: Map<string, Uint8Array>;
-        leafDataMap: Map<string, LeafRefundSigningData>;
-        signingResults: LeafRefundTxSigningResult[];
-    }>;
-    private prepareRefundSoSigningJobs;
-    claimTransferTweakKeys(transfer: Transfer$1, leaves: LeafKeyTweak[]): Promise<Map<string, Uint8Array[]>>;
-    private prepareClaimLeavesKeyTweaks;
-    private prepareClaimLeafKeyTweaks;
-    claimTransferSignRefunds(transfer: Transfer$1, leafKeys: LeafKeyTweak[], proofMap?: Map<string, Uint8Array[]>): Promise<NodeSignatures[]>;
-    private finalizeNodeSignatures;
-    queryPendingTransfersBySender(operatorAddress: string): Promise<QueryTransfersResponse>;
-    private refreshTimelockNodesInternal;
-    refreshTimelockNodes(node: TreeNode, parentNode: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
-    extendTimelock(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
-    testonly_expireTimeLockNodeTx(node: TreeNode, parentNode: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
-    testonly_expireTimeLockRefundtx(node: TreeNode): 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<SparkWalletEvents> {
+declare abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     protected config: WalletConfigService;
     protected connectionManager: ConnectionManager;
     protected transferService: TransferService;
@@ -3552,13 +3851,12 @@ declare class SparkWallet extends EventEmitter<SparkWalletEvents> {
     protected tokenOutputs: TokenOutputsMap;
     private claimTransfersInterval;
     private tracer;
-    protected constructor(options?: ConfigOptions, signer?: SparkSigner);
-    static initialize({ mnemonicOrSeed, accountNumber, signer, options, }: SparkWalletProps): Promise<{
-        mnemonic?: string | undefined;
-        wallet: SparkWallet;
-    }>;
-    private initializeWallet;
+    constructor(options?: ConfigOptions, signerArg?: SparkSigner);
+    static initialize<T extends SparkWallet>(this: new (options?: ConfigOptions, signer?: SparkSigner) => T, { mnemonicOrSeed, accountNumber, signer, options }: SparkWalletProps): Promise<InitWalletResponse<T>>;
+    private createClientsAndSyncWallet;
     private getSspClient;
+    protected buildSigner(): DefaultSparkSigner;
+    protected buildConnectionManager(config: WalletConfigService): ConnectionManager;
     private handleStreamEvent;
     protected setupBackgroundStream(): Promise<void>;
     getLeaves(isBalanceCheck?: boolean): Promise<TreeNode[]>;
@@ -3631,11 +3929,10 @@ declare class SparkWallet extends EventEmitter<SparkWalletEvents> {
      *
      * @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
+     *   - wallet: The wallet instance
      * @private
      */
-    protected initWallet(mnemonicOrSeed?: Uint8Array | string, accountNumber?: number): Promise<InitWalletResponse | undefined>;
+    protected initWallet(mnemonicOrSeed?: Uint8Array | string, accountNumber?: number, options?: ConfigOptions): Promise<InitWalletResponse<this>>;
     /**
      * Initializes the wallet without a seed. Meant for use with a signer with pre-existing keys.
      * @private
@@ -4146,6 +4443,313 @@ declare class SparkWallet extends EventEmitter<SparkWalletEvents> {
     private wrapSparkWalletMethodsWithTracing;
 }
 
+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 TransferWithInvoiceParams = {
+    amountSats: number;
+    receiverIdentityPubkey: Uint8Array;
+    sparkInvoice?: SparkAddressFormat;
+};
+type TransferWithInvoiceOutcome = {
+    ok: true;
+    transfer: WalletTransfer;
+    param: TransferWithInvoiceParams;
+} | {
+    ok: false;
+    error: Error;
+    param: TransferWithInvoiceParams;
+};
+type FulfillSparkInvoiceResponse = {
+    satsTransactionSuccess: {
+        invoice: SparkAddressFormat;
+        transferResponse: WalletTransfer;
+    }[];
+    tokenTransactionSuccess: {
+        tokenIdentifier: Bech32mTokenIdentifier;
+        txid: string;
+    }[];
+    satsTransactionErrors: {
+        invoice: string;
+        error: Error;
+    }[];
+    tokenTransactionErrors: {
+        tokenIdentifier: Bech32mTokenIdentifier;
+        error: Error;
+    }[];
+    invalidInvoices: {
+        invoice: string;
+        error: Error;
+    }[];
+};
+type TokenInvoice = {
+    invoice: string;
+    identifierHex: string;
+    amount: bigint;
+};
+type InvalidInvoice = {
+    invoice: string;
+    error: Error;
+};
+type GroupSparkInvoicesResult = {
+    satsInvoices: TransferWithInvoiceParams[];
+    tokenInvoices: Map<string, TokenInvoice[]>;
+    invalidInvoices: InvalidInvoice[];
+};
+type DepositParams = {
+    keyDerivation: KeyDerivation;
+    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 bech32m encoded 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<Bech32mTokenIdentifier, {
+    balance: bigint;
+    tokenMetadata: UserTokenMetadata;
+}>;
+type RawTokenIdentifierHex = string & {
+    readonly __brand: "RawTokenIdentifierHex";
+};
+type TokenOutputsMap = Map<Bech32mTokenIdentifier, OutputWithPreviousTransactionData$1[]>;
+type TokenMetadataMap = Map<Bech32mTokenIdentifier, TokenMetadata>;
+type InitWalletResponse<T extends SparkWallet = SparkWallet> = {
+    wallet: T;
+    mnemonic: string | undefined;
+};
+interface SparkWalletProps {
+    mnemonicOrSeed?: Uint8Array | string;
+    accountNumber?: number;
+    signer?: SparkSigner;
+    options?: ConfigOptions;
+}
+declare const SparkWalletEvent: {
+    readonly All: "*";
+    readonly TransferClaimed: "transfer:claimed";
+    readonly DepositConfirmed: "deposit:confirmed";
+    readonly StreamConnected: "stream:connected";
+    readonly StreamDisconnected: "stream:disconnected";
+    readonly StreamReconnecting: "stream:reconnecting";
+};
+type SparkWalletEventType = (typeof SparkWalletEvent)[keyof typeof SparkWalletEvent];
+interface SparkWalletEvents {
+    [SparkWalletEvent.All]: (eventName: string, ...args: unknown[]) => void;
+    /** Emitted when an incoming transfer is successfully claimed. Includes the transfer ID and new total balance. */
+    [SparkWalletEvent.TransferClaimed]: (transferId: string, updatedBalance: bigint) => void;
+    /** Emitted when a deposit is marked as available. Includes the deposit ID and new total balance. */
+    [SparkWalletEvent.DepositConfirmed]: (depositId: string, updatedBalance: bigint) => void;
+    /** Emitted when the stream is connected */
+    [SparkWalletEvent.StreamConnected]: () => void;
+    /** Emitted when the stream disconnects and fails to reconnect after max attempts */
+    [SparkWalletEvent.StreamDisconnected]: (reason: string) => void;
+    /** Emitted when attempting to reconnect the stream */
+    [SparkWalletEvent.StreamReconnecting]: (attempt: number, maxAttempts: number, delayMs: number, error: string) => void;
+}
+
+declare function sumAvailableTokens(outputs: OutputWithPreviousTransactionData$1[]): bigint;
+declare function checkIfSelectedOutputsAreAvailable(selectedOutputs: OutputWithPreviousTransactionData$1[], tokenOutputs: TokenOutputsMap, tokenIdentifier: Bech32mTokenIdentifier): boolean;
+declare function filterTokenBalanceForTokenIdentifier(tokenBalances: TokenBalanceMap, tokenIdentifier: Bech32mTokenIdentifier): {
+    balance: bigint;
+};
+
+declare function getTransferPackageSigningPayload(transferID: string, transferPackage: TransferPackage): Uint8Array;
+
+declare const DIRECT_TIMELOCK_OFFSET = 50;
+declare const INITIAL_SEQUENCE: number;
+declare const INITIAL_DIRECT_SEQUENCE: number;
+declare const TEST_UNILATERAL_SEQUENCE: number;
+declare const TEST_UNILATERAL_DIRECT_SEQUENCE: number;
+declare const DEFAULT_FEE_SATS: number;
+/**
+ * Subtracts the default fee from the amount if it's greater than the fee.
+ * Returns the original amount if it's less than or equal to the fee.
+ */
+declare function maybeApplyFee(amount: bigint): bigint;
+declare function createRootTx(depositOutPoint: TransactionInput, depositTxOut: TransactionOutput): [Transaction, Transaction];
+declare function createSplitTx(parentOutPoint: TransactionInput, childTxOuts: TransactionOutput[]): [Transaction, Transaction];
+interface CreateNodeTxInput {
+    txOut: TransactionOutput;
+    parentOutPoint: TransactionInput;
+    applyFee?: boolean;
+    includeAnchor?: boolean;
+}
+declare function createNodeTx({ txOut, parentOutPoint, applyFee, includeAnchor, }: CreateNodeTxInput): Transaction;
+declare function createNodeTxs(txOut: TransactionOutput, txIn: TransactionInput, directTxIn?: TransactionInput): {
+    cpfpNodeTx: Transaction;
+    directNodeTx?: Transaction;
+};
+declare function createLeafNodeTx(sequence: number, directSequence: number, parentOutPoint: TransactionInput, txOut: TransactionOutput, shouldCalculateFee: boolean): [Transaction, Transaction];
+interface CreateRefundTxInput {
+    sequence: number;
+    input: TransactionInput;
+    amountSats: bigint;
+    receivingPubkey: Uint8Array;
+    network: Network;
+    shouldCalculateFee: boolean;
+    includeAnchor: boolean;
+}
+declare function createRefundTx({ sequence, input, amountSats, receivingPubkey, network, shouldCalculateFee, includeAnchor, }: CreateRefundTxInput): Transaction;
+interface CreateRefundTxsInput {
+    sequence: number;
+    directSequence?: number;
+    input: TransactionInput;
+    directInput?: TransactionInput;
+    amountSats: bigint;
+    receivingPubkey: Uint8Array;
+    network: Network;
+}
+declare function createRefundTxs({ sequence, directSequence, input, directInput, amountSats, receivingPubkey, network, }: CreateRefundTxsInput): {
+    cpfpRefundTx: Transaction;
+    directRefundTx?: Transaction;
+    directFromCpfpRefundTx?: Transaction;
+};
+declare function createConnectorRefundTransactions(sequence: number, cpfpNodeOutPoint: TransactionInput, directNodeOutPoint: TransactionInput, connectorOutput: TransactionInput, amountSats: bigint, receiverPubKey: Uint8Array, network: Network, shouldCalculateFee: boolean): [Transaction, Transaction, Transaction];
+declare function getCurrentTimelock(currSequence?: number): number;
+declare function getTransactionSequence(currSequence?: number): {
+    nextSequence: number;
+    nextDirectSequence: number;
+};
+declare function checkIfValidSequence(currSequence?: number): void;
+declare function doesLeafNeedRefresh(currSequence: number, isNodeTx?: boolean): boolean;
+declare function getNextTransactionSequence(currSequence: number, isNodeTx?: boolean): {
+    nextSequence: number;
+    nextDirectSequence: number;
+};
+declare function getEphemeralAnchorOutput(): TransactionOutput;
+
+interface LeafInfo {
+    leafId: string;
+    nodeTx: string;
+    refundTx: string;
+}
+interface Utxo {
+    txid: string;
+    vout: number;
+    value: bigint;
+    script: string;
+    publicKey: string;
+}
+interface FeeRate {
+    satPerVbyte: number;
+}
+interface FeeBumpTxPackage {
+    tx: string;
+    feeBumpPsbt?: string;
+}
+interface FeeBumpTxChain {
+    leafId: string;
+    txPackages: FeeBumpTxPackage[];
+}
+interface TxChain {
+    leafId: string;
+    transactions: string[];
+}
+interface BroadcastConfig {
+    bitcoinCoreRpcUrl?: string;
+    rpcUsername?: string;
+    rpcPassword?: string;
+    autoBroadcast?: boolean;
+    network?: "MAINNET" | "REGTEST" | "TESTNET" | "SIGNET" | "LOCAL";
+}
+interface BroadcastResult {
+    success: boolean;
+    txids?: string[];
+    error?: string;
+    broadcastedPackages?: number;
+}
+declare function isEphemeralAnchorOutput(script?: Uint8Array, amount?: bigint): boolean;
+declare function constructUnilateralExitTxs(nodeHexStrings: string[], sparkClient?: SparkServiceClient, network?: any): Promise<TxChain[]>;
+declare function constructUnilateralExitFeeBumpPackages(nodeHexStrings: string[], utxos: Utxo[], feeRate: FeeRate, electrsUrl: string, sparkClient?: SparkServiceClient, network?: any): Promise<FeeBumpTxChain[]>;
+declare function constructFeeBumpTx(txHex: string, utxos: Utxo[], feeRate: FeeRate, previousFeeBumpTx?: string): {
+    feeBumpPsbt: string;
+    usedUtxos: Utxo[];
+    correctedParentTx?: string;
+};
+
+declare function getSparkAddressFromTaproot(taprootAddress: string): SparkAddressFormat;
+
+declare const LOGGER_NAMES: {
+    readonly wasm: "wasm";
+};
+type LoggerName = (typeof LOGGER_NAMES)[keyof typeof LOGGER_NAMES];
+declare class SparkSdkLogger {
+    private static loggers;
+    static get(name: LoggerName): Logger;
+    static setLevel(name: LoggerName, level: LoggingLevel): void;
+    static setAllLevels(level: LoggingLevel): void;
+    static setEnabled(name: LoggerName, enabled: boolean): void;
+    static setAllEnabled(enabled: boolean): void;
+}
+
+declare class ReactNativeSparkSigner extends DefaultSparkSigner {
+    signFrost({ message, keyDerivation, publicKey, verifyingKey, selfCommitment, statechainCommitments, adaptorPubKey, }: SignFrostParams): Promise<Uint8Array>;
+    aggregateFrost({ message, publicKey, verifyingKey, selfCommitment, statechainCommitments, adaptorPubKey, selfSignature, statechainSignatures, statechainPublicKeys, }: AggregateFrostParams): Promise<Uint8Array>;
+}
+
+type Transport = NonNullable<Parameters<typeof createChannel>[1]>;
+declare class ConnectionManagerBrowser extends ConnectionManager {
+    protected transport: Transport;
+    constructor(config: WalletConfigService, transport?: nice_grpc_web_lib_client_Transport_js.Transport);
+    protected createChannelWithTLS(address: string, certPath?: string): Promise<Channel$1>;
+    protected createAuthnMiddleware(): (call: ClientMiddlewareCall<any, any>, options: SparkCallOptions) => AsyncGenerator<any, any, undefined>;
+    protected createMiddleware(address: string, initialAuthToken: string): (call: ClientMiddlewareCall<any, any>, options: SparkCallOptions) => AsyncGenerator<any, any, undefined>;
+    protected createGrpcClient<T>(defintion: SparkAuthnServiceDefinition | SparkServiceDefinition | SparkTokenServiceDefinition, channel: Channel$1, withRetries: boolean, middleware?: any): Promise<T & {
+        close: undefined;
+    }>;
+}
+
+declare class SparkWalletReactNative extends SparkWallet {
+    protected buildSigner(): ReactNativeSparkSigner;
+    protected buildConnectionManager(config: WalletConfigService): ConnectionManagerBrowser;
+}
+
 interface FetchOwnedTokenOutputsParams {
     ownerPublicKeys: Uint8Array[];
     issuerPublicKeys?: Uint8Array[];
@@ -4191,4 +4795,4 @@ declare class TokenTransactionService {
     private createSignaturesForOperators;
 }
 
-export { AuthenticationError, type Bech32mTokenIdentifier, type Bech32mTokenIdentifierData, type BroadcastConfig, type BroadcastResult, type ConfigOptions, ConfigurationError, ConnectionManager, type CreateLightningInvoiceParams, DEFAULT_FEE_SATS, DIRECT_TIMELOCK_OFFSET, type DecodedSparkAddressData, ReactNativeSparkSigner as DefaultSparkSigner, type DepositParams, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, type FulfillSparkInvoiceResponse, type GroupSparkInvoicesResult, INITIAL_DIRECT_SEQUENCE, INITIAL_SEQUENCE, type InitWalletResponse, InternalValidationError, type InvalidInvoice, LOGGER_NAMES, LRC_WALLET_NETWORK, type LeafInfo, type LegacySparkAddressFormat, type LoggerName, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, type PayLightningInvoiceParams, RPCError, type RawTokenIdentifierHex, ReactNativeSparkSigner, type SparkAddressData, type SparkAddressFormat, SparkSDKError, SparkSdkLogger, SparkWallet, SparkWalletEvent, type SparkWalletEventType, type SparkWalletEvents, type SparkWalletProps, TEST_UNILATERAL_DIRECT_SEQUENCE, TEST_UNILATERAL_SEQUENCE, type TokenBalanceMap, type TokenInvoice, type TokenMetadataMap, type TokenOutputsMap, TokenTransactionService, type TransferParams, type TransferWithInvoiceOutcome, type TransferWithInvoiceParams, type TxChain, type UserTokenMetadata, type Utxo, ValidationError, type VerifiableSecretShare, WalletConfig, WalletConfigService, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, assertBech32, bech32mDecode, bigIntToPrivateKey, checkIfSelectedOutputsAreAvailable, checkIfValidSequence, collectResponses, computeTaprootKeyNoScript, computerLagrangeCoefficients, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createConnectorRefundTransactions, createLeafNodeTx, createNodeTx, createNodeTxs, createRefundTx, createRefundTxs, createRootTx, createSigningCommitment, createSigningNonce, createSplitTx, decodeBech32mTokenIdentifier, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, decodeSparkAddress, doesLeafNeedRefresh, encodeBech32mTokenIdentifier, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, encodeSparkAddress, encodeSparkAddressWithSignature, evaluatePolynomial, fieldDiv, filterTokenBalanceForTokenIdentifier, generateAdaptorFromSignature, generatePolynomialForSecretSharing, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNetwork, getNetworkFromAddress, getNetworkFromBech32mTokenIdentifier, getNetworkFromSparkAddress, getNetworkFromString, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomBigInt, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getSparkAddressFromTaproot, getTransactionSequence, getTransferPackageSigningPayload, getTxEstimatedVbytesSizeByNumberOfInputsOutputs, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, isEphemeralAnchorOutput, isLegacySparkAddress, isSafeForNumber, isTxBroadcast, isValidPublicKey, isValidSparkAddress, lastKeyWithTarget, maybeApplyFee, modInverse, proofOfPossessionMessageHashForDepositAddress, protoToNetwork, recoverSecret, splitSecret, splitSecretWithProofs, subtractPrivateKeys, subtractPublicKeys, sumAvailableTokens, sumOfPrivateKeys, toProtoTimestamp, validateOutboundAdaptorSignature, validateShare, validateSparkInvoiceFields, validateSparkInvoiceSignature };
+export { AuthenticationError, ConnectionManager as BaseConnectionManager, type Bech32mTokenIdentifier, type Bech32mTokenIdentifierData, type BroadcastConfig, type BroadcastResult, type ConfigOptions, ConfigurationError, ConnectionManagerBrowser as ConnectionManager, type CreateLightningInvoiceParams, DEFAULT_FEE_SATS, DIRECT_TIMELOCK_OFFSET, type DecodedSparkAddressData, ReactNativeSparkSigner as DefaultSparkSigner, type DepositParams, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, type FulfillSparkInvoiceResponse, type GroupSparkInvoicesResult, INITIAL_DIRECT_SEQUENCE, INITIAL_SEQUENCE, type InitWalletResponse, InternalValidationError, type InvalidInvoice, LOGGER_NAMES, type LeafInfo, type LegacySparkAddressFormat, type LoggerName, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, type PayLightningInvoiceParams, RPCError, type RawTokenIdentifierHex, ReactNativeSparkSigner, type SparkAddressData, type SparkAddressFormat, SparkSDKError, SparkSdkLogger, SparkWalletReactNative as SparkWallet, SparkWalletEvent, type SparkWalletEventType, type SparkWalletEvents, type SparkWalletProps, TEST_UNILATERAL_DIRECT_SEQUENCE, TEST_UNILATERAL_SEQUENCE, type TokenBalanceMap, type TokenInvoice, type TokenMetadataMap, type TokenOutputsMap, TokenTransactionService, type TransferParams, type TransferWithInvoiceOutcome, type TransferWithInvoiceParams, type TxChain, type UserTokenMetadata, type Utxo, ValidationError, type VerifiableSecretShare, WalletConfig, WalletConfigService, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, assertBech32, bech32mDecode, bigIntToPrivateKey, checkIfSelectedOutputsAreAvailable, checkIfValidSequence, collectResponses, computeTaprootKeyNoScript, computerLagrangeCoefficients, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createConnectorRefundTransactions, createLeafNodeTx, createNodeTx, createNodeTxs, createRefundTx, createRefundTxs, createRootTx, createSigningCommitment, createSigningNonce, createSplitTx, decodeBech32mTokenIdentifier, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, decodeSparkAddress, doesLeafNeedRefresh, encodeBech32mTokenIdentifier, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, encodeSparkAddress, encodeSparkAddressWithSignature, evaluatePolynomial, fieldDiv, filterTokenBalanceForTokenIdentifier, generateAdaptorFromSignature, generatePolynomialForSecretSharing, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNetwork, getNetworkFromAddress, getNetworkFromBech32mTokenIdentifier, getNetworkFromSparkAddress, getNetworkFromString, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomBigInt, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getSparkAddressFromTaproot, getTransactionSequence, getTransferPackageSigningPayload, getTxEstimatedVbytesSizeByNumberOfInputsOutputs, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, isEphemeralAnchorOutput, isLegacySparkAddress, isSafeForNumber, isTxBroadcast, isValidPublicKey, isValidSparkAddress, lastKeyWithTarget, maybeApplyFee, modInverse, proofOfPossessionMessageHashForDepositAddress, protoToNetwork, recoverSecret, splitSecret, splitSecretWithProofs, subtractPrivateKeys, subtractPublicKeys, sumAvailableTokens, sumOfPrivateKeys, toProtoTimestamp, validateOutboundAdaptorSignature, validateShare, validateSparkInvoiceFields, validateSparkInvoiceSignature };