@buildonspark/spark-sdk 0.3.7 → 0.3.9

package/dist/{spark-wallet-BuFrUWeE.d.cts → wallet-config-DQw5llqA.d.cts}

@@ -1,13 +1,15 @@
-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-Bcb7TUIp.cjs';
-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.cjs';
-import { SparkTokenServiceClient, SparkTokenServiceDefinition, TokenMetadata, QueryTokenTransactionsResponse } from './proto/spark_token.cjs';
+import { B as BitcoinNetwork, H as HasSspClientOptions, S as SparkSigner, t as SspClientOptions, l as KeyDerivation, i as SigningCommitmentWithOptionalNonce, V as VerifiableSecretShare, D as DefaultSparkSigner, L as LeavesSwapFeeEstimateOutput, u as StaticDepositQuoteOutput, C as ClaimStaticDepositOutput, W as WalletLeaf, w as WalletTransfer, x as LightningReceiveRequest, y as LightningSendRequest, z as LightningSendFeeEstimateInput, E as ExitSpeed, F as CoopExitFeeQuote, G as CoopExitRequest, I as TransferWithUserRequest, M as MayHaveSspClientOptions } from './client-BIqiUNy4.cjs';
 import * as btc from '@scure/btc-signer';
 import { Transaction } from '@scure/btc-signer';
+import { N as Network$1, e as SparkInvoiceFields, b as SparkServiceDefinition, f as SparkServiceClient, d as SubscribeToEventsResponse, R as RequestedSigningCommitments, U as UserSignedTxSigningJob, c as TreeNode, T as Transfer, g as StartTransferRequest, L as LeafRefundTxSigningResult, h as NodeSignatures, F as FinalizeNodeSignaturesResponse, Q as QueryTransfersResponse, i as QuerySparkInvoicesResponse, O as OutputWithPreviousTransactionData } from './spark-DOpheE8_.cjs';
+import { SparkTokenServiceDefinition, SparkTokenServiceClient, QueryTokenTransactionsResponse, TokenMetadata } from './proto/spark_token.cjs';
+import * as _scure_base from '@scure/base';
 import { Channel } from 'nice-grpc';
-import { CallOptions, ClientMiddlewareCall, Metadata } from 'nice-grpc-common';
+import { CallOptions, ClientMiddleware, ClientMiddlewareCall, Metadata } from 'nice-grpc-common';
 import { Channel as Channel$1 } from 'nice-grpc-web';
 import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
-import * as _scure_base from '@scure/base';
+import { RetryOptions as RetryOptions$1 } from 'nice-grpc-client-middleware-retry';
+import { TransactionOutput } from '@scure/btc-signer/psbt';
 import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
 import { EventEmitter } from 'eventemitter3';
 
@@ -37,37 +39,61 @@ declare function getNetworkFromAddress(address: string): BitcoinNetwork.MAINNET
  */
 declare function getNetworkFromString(network?: string): Network;
 
-type SigningOperator = {
-    readonly id: number;
-    readonly identifier: string;
-    readonly address: string;
-    readonly identityPublicKey: string;
-};
-type ConsoleOptions = {
-    otel?: boolean;
-};
-type ConfigOptions = MayHaveSspClientOptions & {
-    readonly network?: NetworkType;
-    readonly signingOperators?: Readonly<Record<string, SigningOperator>>;
-    readonly coordinatorIdentifier?: string;
-    readonly frostSignerAddress?: string;
-    readonly threshold?: number;
-    readonly tokenSignatures?: "ECDSA" | "SCHNORR";
-    readonly tokenValidityDurationSeconds?: number;
-    readonly electrsUrl?: string;
-    readonly sspClientOptions?: SspClientOptions;
-    readonly expectedWithdrawBondSats?: number;
-    readonly expectedWithdrawRelativeBlockLocktime?: number;
-    readonly signerWithPreExistingKeys?: boolean;
-    readonly console?: ConsoleOptions;
-};
-declare const WalletConfig: {
-    LOCAL: Required<ConfigOptions>;
-    LOCAL_SCHNORR: Required<ConfigOptions>;
-    LOCAL_ECDSA: Required<ConfigOptions>;
-    REGTEST: Required<ConfigOptions>;
-    MAINNET: Required<ConfigOptions>;
+declare const AddressNetwork: Record<NetworkType, string>;
+declare const LegacyAddressNetwork: Record<NetworkType, string>;
+type Bech32String = `${string}1${string}`;
+type SparkAddressFormat = `${(typeof AddressNetwork)[keyof typeof AddressNetwork]}1${string}`;
+type LegacySparkAddressFormat = `${(typeof LegacyAddressNetwork)[keyof typeof LegacyAddressNetwork]}1${string}`;
+interface SparkAddressData {
+    identityPublicKey: string;
+    network: NetworkType;
+    sparkInvoiceFields?: SparkInvoiceFields;
+}
+interface DecodedSparkAddressData {
+    identityPublicKey: string;
+    network: NetworkType;
+    sparkInvoiceFields?: {
+        version: number;
+        id: string;
+        paymentType?: {
+            type: "tokens";
+            tokenIdentifier?: string;
+            amount?: bigint;
+        } | {
+            type: "sats";
+            amount?: number;
+        };
+        memo?: string;
+        senderPublicKey?: string;
+        expiryTime?: Date;
+    };
+    signature?: string;
+}
+declare function encodeSparkAddress(payload: SparkAddressData): LegacySparkAddressFormat;
+declare function encodeSparkAddressWithSignature(payload: SparkAddressData, signature?: Uint8Array): LegacySparkAddressFormat;
+declare function decodeSparkAddress(address: string, network: NetworkType): DecodedSparkAddressData;
+declare function getNetworkFromSparkAddress(address: string): NetworkType;
+declare function isLegacySparkAddress(address: string): address is LegacySparkAddressFormat;
+declare function isValidSparkAddress(address: string): boolean;
+declare function isValidPublicKey(publicKey: string): void;
+declare function validateSparkInvoiceFields(sparkInvoiceFields: SparkInvoiceFields): void;
+declare function validateSparkInvoiceSignature(invoice: SparkAddressFormat): void;
+declare function toProtoTimestamp(date: Date): {
+    seconds: number;
+    nanos: number;
 };
+declare function assertBech32(s: string): asserts s is Bech32String;
+declare function bech32mDecode(address: string): _scure_base.Bech32Decoded<string>;
+declare function isSafeForNumber(bi: bigint): boolean;
+
+type Bech32mTokenIdentifier = `btkn1${string}` | `btknrt1${string}` | `btknt1${string}` | `btkns1${string}` | `btknl1${string}`;
+interface Bech32mTokenIdentifierData {
+    tokenIdentifier: Uint8Array;
+    network: NetworkType;
+}
+declare function encodeBech32mTokenIdentifier(payload: Bech32mTokenIdentifierData): Bech32mTokenIdentifier;
+declare function decodeBech32mTokenIdentifier(bech32mTokenIdentifier: Bech32mTokenIdentifier, network?: NetworkType): Bech32mTokenIdentifierData;
+declare function getNetworkFromBech32mTokenIdentifier(bech32mTokenIdentifier: Bech32mTokenIdentifier): NetworkType;
 
 declare class WalletConfigService implements HasSspClientOptions {
     private readonly config;
@@ -91,6 +117,7 @@ declare class WalletConfigService implements HasSspClientOptions {
     getSspBaseUrl(): string;
     getSspIdentityPublicKey(): string;
     getConsoleOptions(): ConsoleOptions;
+    getEvents(): Partial<SparkWalletEvents>;
 }
 
 /** Challenge represents the core challenge data */
@@ -195,87 +222,55 @@ interface RetryOptions {
 }
 type SparkCallOptions = CallOptions & RetryOptions;
 
-declare class ConnectionManager {
-    private config;
-    protected clients: Map<string, {
-        client: SparkServiceClient & {
-            close?: () => void;
-        };
-        authToken: string;
+type ChannelKey = string;
+type BrowserOrNodeJSChannel = Channel | Channel$1;
+type SparkClientType = "spark" | "stream" | "tokens";
+type Address = string;
+declare abstract class ConnectionManager {
+    private static channelCache;
+    private static channelInflight;
+    private static authTokenCache;
+    private static authInflight;
+    protected makeChannelKey(address: Address, stream?: boolean): ChannelKey;
+    protected static acquireChannel<T extends BrowserOrNodeJSChannel>(key: ChannelKey, create: () => Promise<T>): Promise<T>;
+    protected static releaseChannel(key: ChannelKey): void;
+    private static makeAuthTokenKey;
+    private static getCachedAuthToken;
+    private static setCachedAuthToken;
+    private static invalidateCachedAuthToken;
+    private static getOrCreateAuthToken;
+    protected abstract createChannelWithTLS(address: Address, isStreamClientType?: boolean): Promise<Channel | Channel$1>;
+    protected abstract createGrpcClient<T>(definition: SparkAuthnServiceDefinition | SparkServiceDefinition | SparkTokenServiceDefinition, channel: Channel | Channel$1, withRetries: boolean, middleware?: ClientMiddleware<RetryOptions$1, {}>, channelKey?: ChannelKey): Promise<T & {
+        close?: () => void;
     }>;
-    private tokenClients;
-    private streamClients;
-    private authPromises;
+    private config;
+    private clientsByType;
+    private identityPublicKeyHex?;
     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 & {
+    private getDefinitionForClientType;
+    protected static isStreamClientType(type: SparkClientType): type is "stream";
+    private getAddressToClientMap;
+    private getOrCreateClientInternal;
+    createSparkStreamClient(address: string): Promise<SparkServiceClient & {
         close?: () => void;
     }>;
-    createSparkClient(address: string, certPath?: string): Promise<SparkServiceClient & {
+    createSparkClient(address: string): Promise<SparkServiceClient & {
         close?: () => void;
     }>;
-    createSparkTokenClient(address: string, certPath?: string): Promise<SparkTokenServiceClient & {
+    createSparkTokenClient(address: string): Promise<SparkTokenServiceClient & {
         close?: () => void;
     }>;
-    getStreamChannel(address: string): Promise<Channel | Channel$1 | undefined>;
-    private authenticate;
+    getChannelForClient(clientType: SparkClientType, address: Address): Promise<BrowserOrNodeJSChannel | undefined>;
+    private getIdentityPublicKeyHex;
+    protected authenticate(address: string): Promise<string>;
     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 const AddressNetwork: Record<NetworkType, string>;
-declare const LegacyAddressNetwork: Record<NetworkType, string>;
-type Bech32String = `${string}1${string}`;
-type SparkAddressFormat = `${(typeof AddressNetwork)[keyof typeof AddressNetwork]}1${string}`;
-type LegacySparkAddressFormat = `${(typeof LegacyAddressNetwork)[keyof typeof LegacyAddressNetwork]}1${string}`;
-interface SparkAddressData {
-    identityPublicKey: string;
-    network: NetworkType;
-    sparkInvoiceFields?: SparkInvoiceFields;
+    protected createAuthnMiddleware(): <Req, Res>(call: ClientMiddlewareCall<Req, Res>, options: SparkCallOptions) => AsyncGenerator<Res, Res | void, undefined>;
+    protected createMiddleware(address: Address): <Req, Res>(call: ClientMiddlewareCall<Req, Res>, options: SparkCallOptions) => AsyncGenerator<Res, Res | void, undefined>;
+    protected handleMiddlewareError<Req, Res>(error: unknown, address: string, call: ClientMiddlewareCall<Req, Res>, metadata: Metadata, options: SparkCallOptions): AsyncGenerator<Awaited<Res>, void | Awaited<Res>, undefined>;
+    subscribeToEvents(address: string, signal: AbortSignal): Promise<AsyncIterable<SubscribeToEventsResponse>>;
 }
-interface DecodedSparkAddressData {
-    identityPublicKey: string;
-    network: NetworkType;
-    sparkInvoiceFields?: {
-        version: number;
-        id: string;
-        paymentType?: {
-            type: "tokens";
-            tokenIdentifier?: string;
-            amount?: bigint;
-        } | {
-            type: "sats";
-            amount?: number;
-        };
-        memo?: string;
-        senderPublicKey?: string;
-        expiryTime?: Date;
-    };
-    signature?: string;
-}
-declare function encodeSparkAddress(payload: SparkAddressData): LegacySparkAddressFormat;
-declare function encodeSparkAddressWithSignature(payload: SparkAddressData, signature?: Uint8Array): LegacySparkAddressFormat;
-declare function decodeSparkAddress(address: string, network: NetworkType): DecodedSparkAddressData;
-declare function getNetworkFromSparkAddress(address: string): NetworkType;
-declare function isLegacySparkAddress(address: string): address is LegacySparkAddressFormat;
-declare function isValidSparkAddress(address: string): boolean;
-declare function isValidPublicKey(publicKey: string): void;
-declare function validateSparkInvoiceFields(sparkInvoiceFields: SparkInvoiceFields): void;
-declare function validateSparkInvoiceSignature(invoice: SparkAddressFormat): void;
-declare function toProtoTimestamp(date: Date): {
-    seconds: number;
-    nanos: number;
-};
-declare function assertBech32(s: string): asserts s is Bech32String;
-declare function bech32mDecode(address: string): _scure_base.Bech32Decoded<string>;
-declare function isSafeForNumber(bi: bigint): boolean;
 
 declare class SigningService {
     private readonly config;
@@ -286,6 +281,12 @@ declare class SigningService {
         directLeafSigningJobs: UserSignedTxSigningJob[];
         directFromCpfpLeafSigningJobs: UserSignedTxSigningJob[];
     }>;
+    signRefundsForLightning(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, cpfpSigningCommitments: RequestedSigningCommitments[], directSigningCommitments: RequestedSigningCommitments[], directFromCpfpSigningCommitments: RequestedSigningCommitments[], hash: Uint8Array): Promise<{
+        cpfpLeafSigningJobs: UserSignedTxSigningJob[];
+        directLeafSigningJobs: UserSignedTxSigningJob[];
+        directFromCpfpLeafSigningJobs: UserSignedTxSigningJob[];
+    }>;
+    signSigningJobs(signingJobs: (SigningJobWithOptionalNonce & RequestedSigningCommitments)[]): Promise<Map<SigningJobType, UserSignedTxSigningJob>>;
 }
 
 type LeafKeyTweak = {
@@ -306,14 +307,27 @@ type LeafRefundSigningData = {
     directFromCpfpRefundSigningNonceCommitment: SigningCommitmentWithOptionalNonce;
     vout: number;
 };
+type SigningJobType = "split" | "directSplit" | "node" | "directNode" | "cpfp" | "direct" | "directFromCpfp";
+type SigningJobWithOptionalNonce = {
+    signingPublicKey: Uint8Array;
+    rawTx: Uint8Array;
+    signingNonceCommitment: SigningCommitmentWithOptionalNonce;
+    type: SigningJobType;
+    parentTxOut: TransactionOutput;
+    leafId: string;
+    keyDerivation: KeyDerivation;
+    verifyingKey: Uint8Array;
+};
 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, leaves: LeafKeyTweak[], cpfpRefundSignatureMap: Map<string, Uint8Array>, directRefundSignatureMap: Map<string, Uint8Array>, directFromCpfpRefundSignatureMap: Map<string, Uint8Array>): Promise<Transfer>;
+    prepareTransferForLightning(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, paymentHash: Uint8Array, expiryTime: Date, transferID: string): Promise<StartTransferRequest>;
     sendTransferWithKeyTweaks(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, sparkInvoice?: SparkAddressFormat): Promise<Transfer>;
     private prepareTransferPackage;
+    private prepareTransferPackageForLightning;
     signRefunds(leafDataMap: Map<string, LeafRefundSigningData>, operatorSigningResults: LeafRefundTxSigningResult[]): Promise<NodeSignatures[]>;
     private prepareSendTransferKeyTweaks;
     private prepareSingleSendTransferKeyTweak;
@@ -356,170 +370,12 @@ declare class TransferService extends BaseTransferService {
     claimTransferSignRefunds(transfer: Transfer, 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>;
-}
-
-type Bech32mTokenIdentifier = `btkn1${string}` | `btknrt1${string}` | `btknt1${string}` | `btkns1${string}` | `btknl1${string}`;
-interface Bech32mTokenIdentifierData {
-    tokenIdentifier: Uint8Array;
-    network: NetworkType;
-}
-declare function encodeBech32mTokenIdentifier(payload: Bech32mTokenIdentifierData): Bech32mTokenIdentifier;
-declare function decodeBech32mTokenIdentifier(bech32mTokenIdentifier: Bech32mTokenIdentifier, network?: NetworkType): Bech32mTokenIdentifierData;
-declare function getNetworkFromBech32mTokenIdentifier(bech32mTokenIdentifier: Bech32mTokenIdentifier): NetworkType;
-
-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[]>;
-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;
+    renewRefundTxn(node: TreeNode, parentNode: TreeNode): Promise<TreeNode>;
+    renewNodeTxn(node: TreeNode, parentNode: TreeNode): Promise<TreeNode>;
+    private createRenewRefundSigningJobs;
+    private createRenewNodeSigningJobs;
+    renewZeroTimelockNodeTxn(node: TreeNode): Promise<TreeNode>;
+    private createRenewZeroTimelockNodeSigningJobs;
 }
 
 /**
@@ -550,16 +406,15 @@ declare abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     protected tokenOutputs: TokenOutputsMap;
     private claimTransfersInterval;
     private tracer;
+    protected abstract buildConnectionManager(config: WalletConfigService): ConnectionManager;
     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[]>;
-    private checkExtendLeaves;
     private verifyKey;
     private popOrThrow;
     private selectLeaves;
@@ -870,15 +725,7 @@ declare abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     private transferWithInvoice;
     private buildTweaksByAmount;
     private toSendTweak;
-    private checkExtendTimeLockNodes;
-    /**
-     * Internal method to refresh timelock nodes.
-     *
-     * @param {string} nodeId - The optional ID of the node to refresh. If not provided, all nodes will be checked.
-     * @returns {Promise<void>}
-     * @private
-     */
-    private checkRefreshTimelockNodes;
+    private checkRenewLeaves;
     private claimTransferCore;
     private processClaimedTransferResults;
     /**
@@ -1117,13 +964,6 @@ declare abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
         nodeTimelock: number;
         refundTimelock: number;
     }>;
-    /**
-     * Refresh the timelock of a specific node.
-     *
-     * @param {string} nodeId - The ID of the node to refresh
-     * @returns {Promise<void>} Promise that resolves when the timelock is refreshed
-     */
-    testOnly_expireTimelock(nodeId: string): Promise<void>;
     private cleanup;
     cleanupConnections(): Promise<void>;
     private startPeriodicClaimTransfers;
@@ -1142,4 +982,187 @@ declare abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     private wrapSparkWalletMethodsWithTracing;
 }
 
-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 };
+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[]>;
+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;
+}
+
+type SigningOperator = {
+    readonly id: number;
+    readonly identifier: string;
+    readonly address: string;
+    readonly identityPublicKey: string;
+};
+type ConsoleOptions = {
+    otel?: boolean;
+};
+type ConfigOptions = MayHaveSspClientOptions & {
+    readonly network?: NetworkType;
+    readonly signingOperators?: Readonly<Record<string, SigningOperator>>;
+    readonly coordinatorIdentifier?: string;
+    readonly frostSignerAddress?: string;
+    readonly threshold?: number;
+    readonly tokenSignatures?: "ECDSA" | "SCHNORR";
+    readonly tokenValidityDurationSeconds?: number;
+    readonly electrsUrl?: string;
+    readonly sspClientOptions?: SspClientOptions;
+    readonly expectedWithdrawBondSats?: number;
+    readonly expectedWithdrawRelativeBlockLocktime?: number;
+    readonly signerWithPreExistingKeys?: boolean;
+    readonly console?: ConsoleOptions;
+    readonly events?: Partial<SparkWalletEvents>;
+};
+declare const WalletConfig: {
+    LOCAL: Required<ConfigOptions>;
+    LOCAL_SCHNORR: Required<ConfigOptions>;
+    LOCAL_ECDSA: Required<ConfigOptions>;
+    REGTEST: Required<ConfigOptions>;
+    MAINNET: Required<ConfigOptions>;
+};
+
+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, type RetryOptions as a1, SparkWallet as a2, 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 };