@buildonspark/spark-sdk 0.3.4 → 0.3.6

package/dist/bare/index.d.cts

@@ -3,13 +3,13 @@ import * as btc from '@scure/btc-signer';
 import { Transaction } from '@scure/btc-signer';
 import { HDKey } from '@scure/bip32';
 import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
-import { CallOptions } from 'nice-grpc-common';
-import * as bitcoin from 'bitcoinjs-lib';
+import { CallOptions, ClientMiddlewareCall, Metadata } from 'nice-grpc-common';
 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 * as _scure_base from '@scure/base';
 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';
 import { TransactionOutput, TransactionInput } from '@scure/btc-signer/psbt';
 
 declare class SparkSDKError extends Error {
@@ -2162,6 +2162,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. */
@@ -2854,6 +3343,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
@@ -2900,13 +3452,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.
  *
@@ -2971,50 +3516,83 @@ declare class WalletConfigService implements HasSspClientOptions {
     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;
+/** 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 InterruptTransferRequest: MessageFns<InterruptTransferRequest>;
-interface UpdateNodesStatusRequest {
-    nodeIds: string[];
-    status: string;
+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 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>;
+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 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;
@@ -3034,19 +3612,27 @@ interface MessageFns<T> {
     fromPartial(object: DeepPartial<T>): T;
 }
 
+interface RetryOptions {
+    retry?: boolean;
+    retryMaxAttempts?: number;
+}
+type SparkCallOptions = CallOptions & RetryOptions;
+
 declare class ConnectionManager {
     private config;
-    private clients;
+    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>;
-    createMockClient(address: string): Promise<MockServiceClient & {
-        close: () => void;
-    }>;
-    private createChannelWithTLS;
+    protected createChannelWithTLS(address: string, certPath?: string): Promise<Channel | Channel$1>;
     createSparkStreamClient(address: string, certPath?: string): Promise<SparkServiceClient & {
         close?: () => void;
     }>;
@@ -3059,12 +3645,12 @@ declare class ConnectionManager {
     getStreamChannel(address: string): Promise<Channel | Channel$1 | undefined>;
     private authenticate;
     private createSparkAuthnGrpcConnection;
-    private createAuthnMiddleware;
-    private createMiddleware;
-    private handleMiddlewareError;
-    private createNodeMiddleware;
-    private createBrowserMiddleware;
-    private createGrpcClient;
+    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 const AddressNetwork: Record<NetworkType, string>;
@@ -3289,8 +3875,9 @@ type TokenBalanceMap = Map<Bech32mTokenIdentifier, {
 }>;
 type TokenOutputsMap = Map<Bech32mTokenIdentifier, OutputWithPreviousTransactionData$1[]>;
 type TokenMetadataMap = Map<Bech32mTokenIdentifier, TokenMetadata>;
-type InitWalletResponse = {
-    mnemonic?: string | undefined;
+type InitWalletResponse<T extends SparkWallet = SparkWallet> = {
+    wallet: T;
+    mnemonic: string | undefined;
 };
 interface SparkWalletProps {
     mnemonicOrSeed?: Uint8Array | string;
@@ -3325,7 +3912,7 @@ interface SparkWalletEvents {
  * 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;
@@ -3348,13 +3935,11 @@ 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, signer?: 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 buildConnectionManager(config: WalletConfigService): ConnectionManager;
     private handleStreamEvent;
     protected setupBackgroundStream(): Promise<void>;
     getLeaves(isBalanceCheck?: boolean): Promise<TreeNode[]>;
@@ -3427,11 +4012,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
@@ -3942,14 +4526,27 @@ declare class SparkWallet extends EventEmitter<SparkWalletEvents> {
     private wrapSparkWalletMethodsWithTracing;
 }
 
-declare class SparkWalletBrowser extends SparkWallet {
-    static initialize({ mnemonicOrSeed, accountNumber, signer, options, }: SparkWalletProps): Promise<{
-        mnemonic?: string | undefined;
-        wallet: SparkWalletBrowser;
+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 SparkWalletBrowser extends SparkWallet {
+    protected buildConnectionManager(config: WalletConfigService): ConnectionManagerBrowser;
     protected initializeTracerEnv({ spanProcessors, traceUrls, }: Parameters<SparkWallet["initializeTracerEnv"]>[0]): void;
 }
 
+declare class SparkWalletBare extends SparkWalletBrowser {
+    protected buildConnectionManager(config: WalletConfigService): ConnectionManagerBrowser;
+}
+
 /**
  * @deprecated Use `SparkWallet.getUtxosForDepositAddress()` instead.
  * Retrieves the most recent transaction that pays to the given deposit address
@@ -4135,4 +4732,4 @@ declare class SparkSdkLogger {
     static setAllEnabled(enabled: boolean): void;
 }
 
-export { type AggregateFrostParams, AuthenticationError, type Bech32mTokenIdentifier, type Bech32mTokenIdentifierData, type BroadcastConfig, type BroadcastResult, ConfigurationError, DEFAULT_FEE_SATS, DIRECT_TIMELOCK_OFFSET, type DecodedSparkAddressData, DefaultSparkSigner, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, type IKeyPackage, INITIAL_DIRECT_SEQUENCE, INITIAL_SEQUENCE, InternalValidationError, LOGGER_NAMES, LRC_WALLET_NETWORK, type LeafInfo, type LegacySparkAddressFormat, type LoggerName, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, RPCError, type SignFrostParams, type SparkAddressData, type SparkAddressFormat, SparkSDKError, SparkSdkLogger, type SparkSigner, SparkWalletBrowser as SparkWallet, TEST_UNILATERAL_DIRECT_SEQUENCE, TEST_UNILATERAL_SEQUENCE, TaprootOutputKeysGenerator, TaprootSparkSigner, type TxChain, UnsafeStatelessSparkSigner, type Utxo, ValidationError, type VerifiableSecretShare, 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 { type AggregateFrostParams, AuthenticationError, type Bech32mTokenIdentifier, type Bech32mTokenIdentifierData, type BroadcastConfig, type BroadcastResult, ConfigurationError, DEFAULT_FEE_SATS, DIRECT_TIMELOCK_OFFSET, type DecodedSparkAddressData, DefaultSparkSigner, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, type IKeyPackage, INITIAL_DIRECT_SEQUENCE, INITIAL_SEQUENCE, InternalValidationError, LOGGER_NAMES, type LeafInfo, type LegacySparkAddressFormat, type LoggerName, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, RPCError, type SignFrostParams, type SparkAddressData, type SparkAddressFormat, SparkSDKError, SparkSdkLogger, type SparkSigner, SparkWalletBare as SparkWallet, TEST_UNILATERAL_DIRECT_SEQUENCE, TEST_UNILATERAL_SEQUENCE, TaprootOutputKeysGenerator, TaprootSparkSigner, type TxChain, UnsafeStatelessSparkSigner, type Utxo, ValidationError, type VerifiableSecretShare, 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 };