@buildonspark/spark-sdk 0.3.5 → 0.3.7

package/dist/{spark-wallet-BoMIOPWW.d.cts → spark-wallet-CE5PYiIb.d.ts}

@@ -1,13 +1,12 @@
-import { B as BitcoinNetwork, M as MayHaveSspClientOptions, t as SspClientOptions, H as HasSspClientOptions, S as SparkSigner, l as KeyDerivation, i as SigningCommitmentWithOptionalNonce, V as VerifiableSecretShare, W as WalletTransfer, L as LeavesSwapFeeEstimateOutput, u as StaticDepositQuoteOutput, C as ClaimStaticDepositOutput, w as WalletLeaf, x as LightningReceiveRequest, y as LightningSendRequest, z as LightningSendFeeEstimateInput, E as ExitSpeed, F as CoopExitFeeQuote, G as CoopExitRequest, I as TransferWithUserRequest } from './client-DWml6sjL.cjs';
-import { N as Network$1, E as Empty, c as SparkServiceClient, d as SparkInvoiceFields, R as RequestedSigningCommitments, U as UserSignedTxSigningJob, b as TreeNode, T as Transfer, L as LeafRefundTxSigningResult, e as NodeSignatures, F as FinalizeNodeSignaturesResponse, Q as QueryTransfersResponse, O as OutputWithPreviousTransactionData, f as QuerySparkInvoicesResponse } from './spark-DasxuVfm.cjs';
-import { SparkTokenServiceClient, TokenMetadata, QueryTokenTransactionsResponse } from './proto/spark_token.cjs';
+import { B as BitcoinNetwork, M as MayHaveSspClientOptions, t as SspClientOptions, H as HasSspClientOptions, S as SparkSigner, l as KeyDerivation, i as SigningCommitmentWithOptionalNonce, V as VerifiableSecretShare, W as WalletTransfer, D as DefaultSparkSigner, L as LeavesSwapFeeEstimateOutput, u as StaticDepositQuoteOutput, C as ClaimStaticDepositOutput, w as WalletLeaf, x as LightningReceiveRequest, y as LightningSendRequest, z as LightningSendFeeEstimateInput, E as ExitSpeed, F as CoopExitFeeQuote, G as CoopExitRequest, I as TransferWithUserRequest } from './client-D9T58OY8.js';
+import { N as Network$1, d as SparkServiceClient, b as SparkServiceDefinition, e as SparkInvoiceFields, R as RequestedSigningCommitments, U as UserSignedTxSigningJob, c as TreeNode, T as Transfer, L as LeafRefundTxSigningResult, f as NodeSignatures, F as FinalizeNodeSignaturesResponse, Q as QueryTransfersResponse, O as OutputWithPreviousTransactionData, g as QuerySparkInvoicesResponse } from './spark-WA_4wcBr.js';
+import { SparkTokenServiceClient, SparkTokenServiceDefinition, TokenMetadata, QueryTokenTransactionsResponse } from './proto/spark_token.js';
 import * as btc from '@scure/btc-signer';
 import { Transaction } from '@scure/btc-signer';
-import * as bitcoin from 'bitcoinjs-lib';
 import { Channel } from 'nice-grpc';
+import { CallOptions, ClientMiddlewareCall, Metadata } from 'nice-grpc-common';
 import { Channel as Channel$1 } from 'nice-grpc-web';
 import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
-import { CallOptions } from 'nice-grpc-common';
 import * as _scure_base from '@scure/base';
 import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
 import { EventEmitter } from 'eventemitter3';
@@ -23,13 +22,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.
  *
@@ -81,7 +73,7 @@ declare class WalletConfigService implements HasSspClientOptions {
     private readonly config;
     readonly signer: SparkSigner;
     readonly sspClientOptions: SspClientOptions;
-    constructor(options?: ConfigOptions, signer?: SparkSigner);
+    constructor(options: ConfigOptions | undefined, signer: SparkSigner);
     private getDefaultConfig;
     getCoordinatorAddress(): string;
     getSigningOperators(): Readonly<Record<string, SigningOperator>>;
@@ -101,50 +93,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
+/** 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;
 }
-interface CleanUpPreimageShareRequest {
-    paymentHash: 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 CleanUpPreimageShareRequest: MessageFns<CleanUpPreimageShareRequest>;
-interface InterruptTransferRequest {
-    action: InterruptTransferRequest_InterruptTransferAction;
+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 InterruptTransferRequest: MessageFns<InterruptTransferRequest>;
-interface UpdateNodesStatusRequest {
-    nodeIds: string[];
-    status: string;
+declare const GetChallengeRequest: MessageFns<GetChallengeRequest>;
+/** Response containing the protected challenge */
+interface GetChallengeResponse {
+    /** The protected challenge from the server */
+    protectedChallenge: ProtectedChallenge | undefined;
 }
-declare const UpdateNodesStatusRequest: MessageFns<UpdateNodesStatusRequest>;
-/** TriggerTaskRequest is used to trigger a scheduled task immediately in hermetic tests. */
-interface TriggerTaskRequest {
-    taskName: string;
+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 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 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;
@@ -164,19 +189,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;
     }>;
@@ -189,12 +222,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>;
@@ -456,8 +489,9 @@ type RawTokenIdentifierHex = string & {
 };
 type TokenOutputsMap = Map<Bech32mTokenIdentifier, OutputWithPreviousTransactionData[]>;
 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;
@@ -493,7 +527,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;
@@ -516,13 +550,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[]>;
@@ -595,11 +628,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
@@ -1110,4 +1142,4 @@ declare class SparkWallet extends EventEmitter<SparkWalletEvents> {
     private wrapSparkWalletMethodsWithTracing;
 }
 
-export { type SparkWalletEvents as $, getNetworkFromBech32mTokenIdentifier as A, type Bech32mTokenIdentifier as B, ConnectionManager as C, type DecodedSparkAddressData as D, type CreateLightningInvoiceParams as E, type TransferWithInvoiceParams as F, type TransferWithInvoiceOutcome as G, type FulfillSparkInvoiceResponse as H, type TokenInvoice as I, type InvalidInvoice as J, type GroupSparkInvoicesResult as K, type LegacySparkAddressFormat as L, type DepositParams as M, Network as N, type TokenBalanceMap as O, type PayLightningInvoiceParams as P, type TokenOutputsMap as Q, type RawTokenIdentifierHex as R, type SparkAddressFormat as S, type TransferParams as T, type UserTokenMetadata as U, type TokenMetadataMap as V, WalletConfigService as W, type InitWalletResponse as X, type SparkWalletProps as Y, SparkWalletEvent as Z, type SparkWalletEventType as _, WalletConfig as a, SparkWallet as a0, type ConfigOptions as b, type SparkAddressData as c, encodeSparkAddressWithSignature as d, encodeSparkAddress as e, decodeSparkAddress as f, getNetworkFromSparkAddress as g, isValidSparkAddress as h, isLegacySparkAddress as i, isValidPublicKey as j, validateSparkInvoiceSignature as k, assertBech32 as l, bech32mDecode as m, isSafeForNumber as n, type NetworkType as o, NetworkToProto as p, protoToNetwork as q, getNetwork as r, LRC_WALLET_NETWORK as s, toProtoTimestamp as t, getNetworkFromAddress as u, validateSparkInvoiceFields as v, getNetworkFromString as w, type Bech32mTokenIdentifierData as x, encodeBech32mTokenIdentifier as y, decodeBech32mTokenIdentifier as z };
+export { type SparkCallOptions as $, type CreateLightningInvoiceParams as A, type Bech32mTokenIdentifier as B, ConnectionManager as C, type DecodedSparkAddressData as D, type TransferWithInvoiceParams as E, type TransferWithInvoiceOutcome as F, type FulfillSparkInvoiceResponse as G, type TokenInvoice as H, type InvalidInvoice as I, type GroupSparkInvoicesResult as J, type DepositParams as K, type LegacySparkAddressFormat as L, type TokenBalanceMap as M, Network as N, type TokenOutputsMap as O, type PayLightningInvoiceParams as P, type TokenMetadataMap as Q, type RawTokenIdentifierHex as R, type SparkAddressFormat as S, type TransferParams as T, type UserTokenMetadata as U, type InitWalletResponse as V, WalletConfigService as W, type SparkWalletProps as X, SparkWalletEvent as Y, type SparkWalletEventType as Z, type SparkWalletEvents as _, WalletConfig as a, SparkAuthnServiceDefinition as a0, SparkWallet as a1, type ConfigOptions as b, type SparkAddressData as c, encodeSparkAddressWithSignature as d, encodeSparkAddress as e, decodeSparkAddress as f, getNetworkFromSparkAddress as g, isValidSparkAddress as h, isLegacySparkAddress as i, isValidPublicKey as j, validateSparkInvoiceSignature as k, assertBech32 as l, bech32mDecode as m, isSafeForNumber as n, type NetworkType as o, NetworkToProto as p, protoToNetwork as q, getNetwork as r, getNetworkFromAddress as s, toProtoTimestamp as t, getNetworkFromString as u, validateSparkInvoiceFields as v, type Bech32mTokenIdentifierData as w, encodeBech32mTokenIdentifier as x, decodeBech32mTokenIdentifier as y, getNetworkFromBech32mTokenIdentifier as z };

package/dist/spark-wallet.browser-BwYkkOBU.d.ts

@@ -0,0 +1,26 @@
+import { C as ConnectionManager, W as WalletConfigService, $ as SparkCallOptions, a0 as SparkAuthnServiceDefinition, a1 as SparkWallet } from './spark-wallet-CE5PYiIb.js';
+import * as nice_grpc_web_lib_client_Transport_js from 'nice-grpc-web/lib/client/Transport.js';
+import { createChannel, Channel } from 'nice-grpc-web';
+import { ClientMiddlewareCall } from 'nice-grpc-common';
+import { b as SparkServiceDefinition } from './spark-WA_4wcBr.js';
+import { SparkTokenServiceDefinition } from './proto/spark_token.js';
+
+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>;
+    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, 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 function initializeTracerEnvBrowser({ spanProcessors, traceUrls, }: Parameters<SparkWallet["initializeTracerEnv"]>[0]): void;
+
+export { ConnectionManagerBrowser as C, SparkWalletBrowser as S, initializeTracerEnvBrowser as i };

package/dist/spark-wallet.browser-DC3jdQPW.d.cts

@@ -0,0 +1,26 @@
+import { C as ConnectionManager, W as WalletConfigService, $ as SparkCallOptions, a0 as SparkAuthnServiceDefinition, a1 as SparkWallet } from './spark-wallet-BuFrUWeE.cjs';
+import * as nice_grpc_web_lib_client_Transport_js from 'nice-grpc-web/lib/client/Transport.js';
+import { createChannel, Channel } from 'nice-grpc-web';
+import { ClientMiddlewareCall } from 'nice-grpc-common';
+import { b as SparkServiceDefinition } from './spark-WA_4wcBr.cjs';
+import { SparkTokenServiceDefinition } from './proto/spark_token.cjs';
+
+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>;
+    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, 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 function initializeTracerEnvBrowser({ spanProcessors, traceUrls, }: Parameters<SparkWallet["initializeTracerEnv"]>[0]): void;
+
+export { ConnectionManagerBrowser as C, SparkWalletBrowser as S, initializeTracerEnvBrowser as i };

package/dist/spark-wallet.node-C9d2W-Nb.d.ts

@@ -0,0 +1,90 @@
+import { C as ConnectionManager, W as WalletConfigService, $ as SparkCallOptions, a0 as SparkAuthnServiceDefinition, a1 as SparkWallet } from './spark-wallet-CE5PYiIb.js';
+import { Channel } from 'nice-grpc';
+import { CallOptions, ClientMiddlewareCall } from 'nice-grpc-common';
+import { E as Empty, b as SparkServiceDefinition } from './spark-WA_4wcBr.js';
+import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
+import { SparkTokenServiceDefinition } from './proto/spark_token.js';
+
+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 ConnectionManagerNodeJS extends ConnectionManager {
+    constructor(config: WalletConfigService);
+    createMockClient(address: string): Promise<MockServiceClient & {
+        close: () => void;
+    }>;
+    protected createChannelWithTLS(address: string, certPath?: string): Promise<Channel>;
+    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, withRetries: boolean, middleware?: any): Promise<T & {
+        close: () => void;
+    }>;
+}
+
+declare class SparkWalletNodeJS extends SparkWallet {
+    protected buildConnectionManager(config: WalletConfigService): ConnectionManagerNodeJS;
+    protected initializeTracerEnv({ spanProcessors, traceUrls, }: Parameters<SparkWallet["initializeTracerEnv"]>[0]): void;
+}
+declare function initializeTracerEnvNodeJS({ spanProcessors, traceUrls, }: Parameters<SparkWallet["initializeTracerEnv"]>[0]): void;
+
+export { ConnectionManagerNodeJS as C, SparkWalletNodeJS as S, initializeTracerEnvNodeJS as i };

package/dist/spark-wallet.node-CR_zNxmy.d.cts

@@ -0,0 +1,90 @@
+import { C as ConnectionManager, W as WalletConfigService, $ as SparkCallOptions, a0 as SparkAuthnServiceDefinition, a1 as SparkWallet } from './spark-wallet-BuFrUWeE.cjs';
+import { Channel } from 'nice-grpc';
+import { CallOptions, ClientMiddlewareCall } from 'nice-grpc-common';
+import { E as Empty, b as SparkServiceDefinition } from './spark-WA_4wcBr.cjs';
+import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
+import { SparkTokenServiceDefinition } from './proto/spark_token.cjs';
+
+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 ConnectionManagerNodeJS extends ConnectionManager {
+    constructor(config: WalletConfigService);
+    createMockClient(address: string): Promise<MockServiceClient & {
+        close: () => void;
+    }>;
+    protected createChannelWithTLS(address: string, certPath?: string): Promise<Channel>;
+    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, withRetries: boolean, middleware?: any): Promise<T & {
+        close: () => void;
+    }>;
+}
+
+declare class SparkWalletNodeJS extends SparkWallet {
+    protected buildConnectionManager(config: WalletConfigService): ConnectionManagerNodeJS;
+    protected initializeTracerEnv({ spanProcessors, traceUrls, }: Parameters<SparkWallet["initializeTracerEnv"]>[0]): void;
+}
+declare function initializeTracerEnvNodeJS({ spanProcessors, traceUrls, }: Parameters<SparkWallet["initializeTracerEnv"]>[0]): void;
+
+export { ConnectionManagerNodeJS as C, SparkWalletNodeJS as S, initializeTracerEnvNodeJS as i };