@buildonspark/spark-sdk 0.3.7 → 0.3.9

package/dist/native/index.react-native.d.ts

@@ -1,6 +1,6 @@
 import * as _scure_base from '@scure/base';
 import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
-import { CallOptions, ClientMiddlewareCall, Metadata } from 'nice-grpc-common';
+import { CallOptions, ClientMiddleware, ClientMiddlewareCall, Metadata } from 'nice-grpc-common';
 import * as btc from '@scure/btc-signer';
 import { Transaction } from '@scure/btc-signer';
 import { TransactionOutput, TransactionInput } from '@scure/btc-signer/psbt';
@@ -8,6 +8,7 @@ import { HDKey } from '@scure/bip32';
 import { Query, Logger, LoggingLevel } from '@lightsparkdev/core';
 import { Channel } from 'nice-grpc';
 import { Channel as Channel$1, createChannel } from 'nice-grpc-web';
+import { RetryOptions as RetryOptions$1 } from 'nice-grpc-client-middleware-retry';
 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';
@@ -359,7 +360,7 @@ interface GenerateDepositAddressRequest {
 }
 declare const GenerateDepositAddressRequest: MessageFns$2<GenerateDepositAddressRequest>;
 /** Address is the address of the user's public key + SE's public key. */
-interface Address {
+interface Address$1 {
     /** The p2tr address of the user's public key + SE's public key. */
     address: string;
     /** The verifying key of the address, which is user's public key + SE's public key. */
@@ -369,10 +370,10 @@ interface Address {
     /** Is it a static deposit address */
     isStatic: boolean;
 }
-declare const Address: MessageFns$2<Address>;
+declare const Address$1: MessageFns$2<Address$1>;
 /** GenerateDepositAddressResponse is the response to the request to generate a deposit address. */
 interface GenerateDepositAddressResponse {
-    depositAddress: Address | undefined;
+    depositAddress: Address$1 | undefined;
 }
 declare const GenerateDepositAddressResponse: MessageFns$2<GenerateDepositAddressResponse>;
 /** GenerateStaticDepositAddressRequest is the request to generate a static deposit address. */
@@ -387,7 +388,7 @@ interface GenerateStaticDepositAddressRequest {
 declare const GenerateStaticDepositAddressRequest: MessageFns$2<GenerateStaticDepositAddressRequest>;
 /** GenerateStaticDepositAddressResponse is the response to the request to generate a static deposit address. */
 interface GenerateStaticDepositAddressResponse {
-    depositAddress: Address | undefined;
+    depositAddress: Address$1 | undefined;
 }
 declare const GenerateStaticDepositAddressResponse: MessageFns$2<GenerateStaticDepositAddressResponse>;
 /**
@@ -459,7 +460,6 @@ interface SigningResult {
 declare const SigningResult: MessageFns$2<SigningResult>;
 interface RenewLeafRequest {
     leafId: string;
-    ownerIdentityPublicKey: Uint8Array;
     signingJobs?: //
     /**
      * Resets the node transaction timelock and refund transaction timelock
@@ -485,6 +485,17 @@ interface RenewLeafRequest {
     {
         $case: "renewRefundTimelockSigningJob";
         renewRefundTimelockSigningJob: RenewRefundTimelockSigningJob;
+    } | //
+    /**
+     * A special case of refresh for when the node transaction is at 0 and
+     * cannot be decremented further. This operation resets the refund
+     * transaction's timelock and, similar to renew node, adds an additional
+     * node transaction to the transaction chain with zero timelock as well.
+     * This case is mostly used for user-created trees from L1 deposits.
+     */
+    {
+        $case: "renewNodeZeroTimelockSigningJob";
+        renewNodeZeroTimelockSigningJob: RenewNodeZeroTimelockSigningJob;
     } | undefined;
 }
 declare const RenewLeafRequest: MessageFns$2<RenewLeafRequest>;
@@ -523,13 +534,32 @@ interface RenewRefundTimelockSigningJob {
     directFromCpfpRefundTxSigningJob: UserSignedTxSigningJob | undefined;
 }
 declare const RenewRefundTimelockSigningJob: MessageFns$2<RenewRefundTimelockSigningJob>;
+interface RenewNodeZeroTimelockSigningJob {
+    /**
+     * Signing job with the new node transaction. The updated transaction is
+     * expected to have a timelock of 0.
+     */
+    nodeTxSigningJob: UserSignedTxSigningJob | undefined;
+    /**
+     * Signing job with the updated refund transaction. This updated transaction
+     * must have a timelock of 2000.
+     */
+    refundTxSigningJob: UserSignedTxSigningJob | undefined;
+    directNodeTxSigningJob: UserSignedTxSigningJob | undefined;
+    directRefundTxSigningJob: UserSignedTxSigningJob | undefined;
+    directFromCpfpRefundTxSigningJob: UserSignedTxSigningJob | undefined;
+}
+declare const RenewNodeZeroTimelockSigningJob: MessageFns$2<RenewNodeZeroTimelockSigningJob>;
 interface RenewLeafResponse {
     renewResult?: {
-        $case: "extendResult";
-        extendResult: RenewNodeTimelockResult;
+        $case: "renewNodeTimelockResult";
+        renewNodeTimelockResult: RenewNodeTimelockResult;
+    } | {
+        $case: "renewRefundTimelockResult";
+        renewRefundTimelockResult: RenewRefundTimelockResult;
     } | {
-        $case: "refreshResult";
-        refreshResult: RenewRefundTimelockResult;
+        $case: "renewNodeZeroTimelockResult";
+        renewNodeZeroTimelockResult: RenewNodeZeroTimelockResult;
     } | undefined;
 }
 declare const RenewLeafResponse: MessageFns$2<RenewLeafResponse>;
@@ -542,6 +572,11 @@ interface RenewRefundTimelockResult {
     node: TreeNode | undefined;
 }
 declare const RenewRefundTimelockResult: MessageFns$2<RenewRefundTimelockResult>;
+interface RenewNodeZeroTimelockResult {
+    splitNode: TreeNode | undefined;
+    node: TreeNode | undefined;
+}
+declare const RenewNodeZeroTimelockResult: MessageFns$2<RenewNodeZeroTimelockResult>;
 /**
  * NodeSignatureShares is the signature shares for a node on the tree.
  * For each tree node, the verifying key stays the same for both transactions.
@@ -1144,15 +1179,28 @@ interface RequestedSigningCommitments {
 }
 declare const RequestedSigningCommitments: MessageFns$2<RequestedSigningCommitments>;
 interface GetSigningCommitmentsRequest {
+    /** The node IDs for which to get signing commitments. */
     nodeIds: string[];
+    /** The number of signing commitments to get per node ID. */
     count: number;
 }
 declare const GetSigningCommitmentsRequest: MessageFns$2<GetSigningCommitmentsRequest>;
 interface GetSigningCommitmentsResponse {
+    /**
+     * A list of signing commitments for each requested node ID. The signing commitments will be
+     * ordered in the same order as the requested node IDs, repeated for the number of commitments
+     * requested. For example, if node_ids = [A, B] and count = 2, the response will contain:
+     *
+     * [commitment_A1, commitment_B1, commitment_A2, commitment_B2]
+     */
     signingCommitments: RequestedSigningCommitments[];
 }
 declare const GetSigningCommitmentsResponse: MessageFns$2<GetSigningCommitmentsResponse>;
 interface SigningCommitments {
+    /**
+     * A map of signing operator ID (i.e. 000...01) to the signing commitment provided by that
+     * operator.
+     */
     signingCommitments: {
         [key: string]: SigningCommitment$1;
     };
@@ -1183,6 +1231,7 @@ interface InitiatePreimageSwapRequest {
     transfer: StartUserSignedTransferRequest | undefined;
     receiverIdentityPublicKey: Uint8Array;
     feeSats: number;
+    transferRequest: StartTransferRequest | undefined;
 }
 declare const InitiatePreimageSwapRequest: MessageFns$2<InitiatePreimageSwapRequest>;
 interface InitiatePreimageSwapResponse {
@@ -1687,6 +1736,10 @@ declare const SparkServiceDefinition: {
             readonly responseStream: false;
             readonly options: {};
         };
+        /**
+         * Gets a specified number of signing commmitments for a set of nodes, which can be used as
+         * part of a transfer package.
+         */
         readonly get_signing_commitments: {
             readonly name: "get_signing_commitments";
             readonly requestType: MessageFns$2<GetSigningCommitmentsRequest>;
@@ -2074,6 +2127,10 @@ interface SparkServiceClient<CallOptionsExt = {}> {
     claim_transfer_tweak_keys(request: DeepPartial$2<ClaimTransferTweakKeysRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
     claim_transfer_sign_refunds(request: DeepPartial$2<ClaimTransferSignRefundsRequest>, options?: CallOptions & CallOptionsExt): Promise<ClaimTransferSignRefundsResponse>;
     store_preimage_share(request: DeepPartial$2<StorePreimageShareRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
+    /**
+     * Gets a specified number of signing commmitments for a set of nodes, which can be used as
+     * part of a transfer package.
+     */
     get_signing_commitments(request: DeepPartial$2<GetSigningCommitmentsRequest>, options?: CallOptions & CallOptionsExt): Promise<GetSigningCommitmentsResponse>;
     cooperative_exit(request: DeepPartial$2<CooperativeExitRequest>, options?: CallOptions & CallOptionsExt): Promise<CooperativeExitResponse>;
     initiate_preimage_swap(request: DeepPartial$2<InitiatePreimageSwapRequest>, options?: CallOptions & CallOptionsExt): Promise<InitiatePreimageSwapResponse>;
@@ -3567,6 +3624,7 @@ type ConfigOptions = MayHaveSspClientOptions & {
     readonly expectedWithdrawRelativeBlockLocktime?: number;
     readonly signerWithPreExistingKeys?: boolean;
     readonly console?: ConsoleOptions;
+    readonly events?: Partial<SparkWalletEvents>;
 };
 declare const WalletConfig: {
     LOCAL: Required<ConfigOptions>;
@@ -3598,6 +3656,7 @@ declare class WalletConfigService implements HasSspClientOptions {
     getSspBaseUrl(): string;
     getSspIdentityPublicKey(): string;
     getConsoleOptions(): ConsoleOptions;
+    getEvents(): Partial<SparkWalletEvents>;
 }
 
 /** Challenge represents the core challenge data */
@@ -3702,39 +3761,54 @@ 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;
-    }>;
+    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>>;
 }
 
 declare class SigningService {
@@ -3746,6 +3820,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 = {
@@ -3766,14 +3846,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$1, leaves: LeafKeyTweak[], cpfpRefundSignatureMap: Map<string, Uint8Array>, directRefundSignatureMap: Map<string, Uint8Array>, directFromCpfpRefundSignatureMap: Map<string, Uint8Array>): Promise<Transfer$1>;
+    prepareTransferForLightning(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, paymentHash: Uint8Array, expiryTime: Date, transferID: string): Promise<StartTransferRequest>;
     sendTransferWithKeyTweaks(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, sparkInvoice?: SparkAddressFormat): Promise<Transfer$1>;
     private prepareTransferPackage;
+    private prepareTransferPackageForLightning;
     signRefunds(leafDataMap: Map<string, LeafRefundSigningData>, operatorSigningResults: LeafRefundTxSigningResult[]): Promise<NodeSignatures[]>;
     private prepareSendTransferKeyTweaks;
     private prepareSingleSendTransferKeyTweak;
@@ -3816,11 +3909,12 @@ declare class TransferService extends BaseTransferService {
     claimTransferSignRefunds(transfer: Transfer$1, leafKeys: LeafKeyTweak[], proofMap?: Map<string, Uint8Array[]>): Promise<NodeSignatures[]>;
     private finalizeNodeSignatures;
     queryPendingTransfersBySender(operatorAddress: string): Promise<QueryTransfersResponse>;
-    private refreshTimelockNodesInternal;
-    refreshTimelockNodes(node: TreeNode, parentNode: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
-    extendTimelock(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
-    testonly_expireTimeLockNodeTx(node: TreeNode, parentNode: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
-    testonly_expireTimeLockRefundtx(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
+    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;
 }
 
 /**
@@ -3851,16 +3945,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;
@@ -4171,15 +4264,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;
     /**
@@ -4418,13 +4503,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;
@@ -4602,8 +4680,9 @@ declare function filterTokenBalanceForTokenIdentifier(tokenBalances: TokenBalanc
 declare function getTransferPackageSigningPayload(transferID: string, transferPackage: TransferPackage): Uint8Array;
 
 declare const DIRECT_TIMELOCK_OFFSET = 50;
+declare const HTLC_TIMELOCK_OFFSET = 70;
+declare const DIRECT_HTLC_TIMELOCK_OFFSET = 85;
 declare const INITIAL_SEQUENCE: number;
-declare const INITIAL_DIRECT_SEQUENCE: number;
 declare const TEST_UNILATERAL_SEQUENCE: number;
 declare const TEST_UNILATERAL_DIRECT_SEQUENCE: number;
 declare const DEFAULT_FEE_SATS: number;
@@ -4612,51 +4691,60 @@ declare const DEFAULT_FEE_SATS: number;
  * Returns the original amount if it's less than or equal to the fee.
  */
 declare function maybeApplyFee(amount: bigint): bigint;
-declare function createRootTx(depositOutPoint: TransactionInput, depositTxOut: TransactionOutput): [Transaction, Transaction];
-declare function createSplitTx(parentOutPoint: TransactionInput, childTxOuts: TransactionOutput[]): [Transaction, Transaction];
-interface CreateNodeTxInput {
-    txOut: TransactionOutput;
-    parentOutPoint: TransactionInput;
-    applyFee?: boolean;
-    includeAnchor?: boolean;
-}
-declare function createNodeTx({ txOut, parentOutPoint, applyFee, includeAnchor, }: CreateNodeTxInput): Transaction;
-declare function createNodeTxs(txOut: TransactionOutput, txIn: TransactionInput, directTxIn?: TransactionInput): {
-    cpfpNodeTx: Transaction;
-    directNodeTx?: Transaction;
+declare function createRootNodeTx(parentTx: Transaction, vout: number): {
+    nodeTx: Transaction;
+    directNodeTx: Transaction;
 };
-declare function createLeafNodeTx(sequence: number, directSequence: number, parentOutPoint: TransactionInput, txOut: TransactionOutput, shouldCalculateFee: boolean): [Transaction, Transaction];
-interface CreateRefundTxInput {
-    sequence: number;
-    input: TransactionInput;
-    amountSats: bigint;
+declare function createZeroTimelockNodeTx(parentTx: Transaction): {
+    nodeTx: Transaction;
+    directNodeTx: Transaction;
+};
+declare function createInitialTimelockNodeTx(parentTx: Transaction): {
+    nodeTx: Transaction;
+    directNodeTx: Transaction;
+};
+declare function createDecrementedTimelockNodeTx(parentTx: Transaction, currentTx: Transaction): {
+    nodeTx: Transaction;
+    directNodeTx: Transaction;
+};
+declare function createTestUnilateralTimelockNodeTx(parentTx: Transaction, nodeTx: Transaction): {
+    nodeTx: Transaction;
+    directNodeTx: Transaction;
+};
+declare function getNextHTLCTransactionSequence(currSequence: number, isNodeTx?: boolean): {
+    nextSequence: number;
+    nextDirectSequence: number;
+};
+interface RefundTxParams {
+    nodeTx: Transaction;
+    directNodeTx?: Transaction;
     receivingPubkey: Uint8Array;
     network: Network;
-    shouldCalculateFee: boolean;
-    includeAnchor: boolean;
 }
-declare function createRefundTx({ sequence, input, amountSats, receivingPubkey, network, shouldCalculateFee, includeAnchor, }: CreateRefundTxInput): Transaction;
-interface CreateRefundTxsInput {
+interface RefundTxWithSequenceParams extends RefundTxParams {
     sequence: number;
-    directSequence?: number;
-    input: TransactionInput;
-    directInput?: TransactionInput;
-    amountSats: bigint;
-    receivingPubkey: Uint8Array;
-    network: Network;
 }
-declare function createRefundTxs({ sequence, directSequence, input, directInput, amountSats, receivingPubkey, network, }: CreateRefundTxsInput): {
+interface RefundTxWithSequenceAndConnectorOutputParams extends RefundTxWithSequenceParams {
+    connectorOutput: TransactionInput;
+}
+interface RefundTxs {
     cpfpRefundTx: Transaction;
     directRefundTx?: Transaction;
     directFromCpfpRefundTx?: Transaction;
-};
-declare function createConnectorRefundTransactions(sequence: number, cpfpNodeOutPoint: TransactionInput, directNodeOutPoint: TransactionInput, connectorOutput: TransactionInput, amountSats: bigint, receiverPubKey: Uint8Array, network: Network, shouldCalculateFee: boolean): [Transaction, Transaction, Transaction];
+}
+declare function createInitialTimelockRefundTxs(params: RefundTxParams): RefundTxs;
+declare function createDecrementedTimelockRefundTxs(params: RefundTxWithSequenceParams): RefundTxs;
+declare function createCurrentTimelockRefundTxs(params: RefundTxWithSequenceParams): RefundTxs;
+declare function createTestUnilateralRefundTxs(params: RefundTxParams): RefundTxs;
+declare function createConnectorRefundTxs(params: RefundTxWithSequenceAndConnectorOutputParams): RefundTxs;
 declare function getCurrentTimelock(currSequence?: number): number;
 declare function getTransactionSequence(currSequence?: number): {
     nextSequence: number;
     nextDirectSequence: number;
 };
 declare function checkIfValidSequence(currSequence?: number): void;
+declare function isZeroTimelock(currSequence: number): boolean;
+declare function doesTxnNeedRenewed(currSequence: number): boolean;
 declare function doesLeafNeedRefresh(currSequence: number, isNodeTx?: boolean): boolean;
 declare function getNextTransactionSequence(currSequence: number, isNodeTx?: boolean): {
     nextSequence: number;
@@ -4737,11 +4825,11 @@ 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;
+    protected createChannelWithTLS(address: string): Promise<Channel$1>;
+    protected createAuthnMiddleware(): <Req, Res>(call: ClientMiddlewareCall<Req, Res>, options: SparkCallOptions) => AsyncGenerator<Res, Res | void, undefined>;
+    protected createMiddleware(address: string): <Req, Res>(call: ClientMiddlewareCall<Req, Res>, options: SparkCallOptions) => AsyncGenerator<Res, Res | void, undefined>;
+    protected createGrpcClient<T>(definition: SparkAuthnServiceDefinition | SparkServiceDefinition | SparkTokenServiceDefinition, channel: Channel$1, withRetries: boolean, middleware?: ClientMiddleware<RetryOptions, {}>, channelKey?: string): Promise<T & {
+        close: (() => void) | undefined;
     }>;
 }
 
@@ -4795,4 +4883,4 @@ declare class TokenTransactionService {
     private createSignaturesForOperators;
 }
 
-export { AuthenticationError, ConnectionManager as BaseConnectionManager, type Bech32mTokenIdentifier, type Bech32mTokenIdentifierData, type BroadcastConfig, type BroadcastResult, type ConfigOptions, ConfigurationError, ConnectionManagerBrowser as ConnectionManager, type CreateLightningInvoiceParams, DEFAULT_FEE_SATS, DIRECT_TIMELOCK_OFFSET, type DecodedSparkAddressData, ReactNativeSparkSigner as DefaultSparkSigner, type DepositParams, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, type FulfillSparkInvoiceResponse, type GroupSparkInvoicesResult, INITIAL_DIRECT_SEQUENCE, INITIAL_SEQUENCE, type InitWalletResponse, InternalValidationError, type InvalidInvoice, LOGGER_NAMES, type LeafInfo, type LegacySparkAddressFormat, type LoggerName, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, type PayLightningInvoiceParams, RPCError, type RawTokenIdentifierHex, ReactNativeSparkSigner, type SparkAddressData, type SparkAddressFormat, SparkSDKError, SparkSdkLogger, SparkWalletReactNative as SparkWallet, SparkWalletEvent, type SparkWalletEventType, type SparkWalletEvents, type SparkWalletProps, TEST_UNILATERAL_DIRECT_SEQUENCE, TEST_UNILATERAL_SEQUENCE, type TokenBalanceMap, type TokenInvoice, type TokenMetadataMap, type TokenOutputsMap, TokenTransactionService, type TransferParams, type TransferWithInvoiceOutcome, type TransferWithInvoiceParams, type TxChain, type UserTokenMetadata, type Utxo, ValidationError, type VerifiableSecretShare, WalletConfig, WalletConfigService, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, assertBech32, bech32mDecode, bigIntToPrivateKey, checkIfSelectedOutputsAreAvailable, checkIfValidSequence, collectResponses, computeTaprootKeyNoScript, computerLagrangeCoefficients, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createConnectorRefundTransactions, createLeafNodeTx, createNodeTx, createNodeTxs, createRefundTx, createRefundTxs, createRootTx, createSigningCommitment, createSigningNonce, createSplitTx, decodeBech32mTokenIdentifier, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, decodeSparkAddress, doesLeafNeedRefresh, encodeBech32mTokenIdentifier, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, encodeSparkAddress, encodeSparkAddressWithSignature, evaluatePolynomial, fieldDiv, filterTokenBalanceForTokenIdentifier, generateAdaptorFromSignature, generatePolynomialForSecretSharing, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNetwork, getNetworkFromAddress, getNetworkFromBech32mTokenIdentifier, getNetworkFromSparkAddress, getNetworkFromString, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomBigInt, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getSparkAddressFromTaproot, getTransactionSequence, getTransferPackageSigningPayload, getTxEstimatedVbytesSizeByNumberOfInputsOutputs, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, isEphemeralAnchorOutput, isLegacySparkAddress, isSafeForNumber, isTxBroadcast, isValidPublicKey, isValidSparkAddress, lastKeyWithTarget, maybeApplyFee, modInverse, proofOfPossessionMessageHashForDepositAddress, protoToNetwork, recoverSecret, splitSecret, splitSecretWithProofs, subtractPrivateKeys, subtractPublicKeys, sumAvailableTokens, sumOfPrivateKeys, toProtoTimestamp, validateOutboundAdaptorSignature, validateShare, validateSparkInvoiceFields, validateSparkInvoiceSignature };
+export { AuthenticationError, ConnectionManager as BaseConnectionManager, type Bech32mTokenIdentifier, type Bech32mTokenIdentifierData, type BroadcastConfig, type BroadcastResult, type ConfigOptions, ConfigurationError, ConnectionManagerBrowser as ConnectionManager, type CreateLightningInvoiceParams, DEFAULT_FEE_SATS, DIRECT_HTLC_TIMELOCK_OFFSET, DIRECT_TIMELOCK_OFFSET, type DecodedSparkAddressData, ReactNativeSparkSigner as DefaultSparkSigner, type DepositParams, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, type FulfillSparkInvoiceResponse, type GroupSparkInvoicesResult, HTLC_TIMELOCK_OFFSET, INITIAL_SEQUENCE, type InitWalletResponse, InternalValidationError, type InvalidInvoice, LOGGER_NAMES, type LeafInfo, type LegacySparkAddressFormat, type LoggerName, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, type PayLightningInvoiceParams, RPCError, type RawTokenIdentifierHex, ReactNativeSparkSigner, type SparkAddressData, type SparkAddressFormat, SparkSDKError, SparkSdkLogger, SparkWalletReactNative as SparkWallet, SparkWalletEvent, type SparkWalletEventType, type SparkWalletEvents, type SparkWalletProps, TEST_UNILATERAL_DIRECT_SEQUENCE, TEST_UNILATERAL_SEQUENCE, type TokenBalanceMap, type TokenInvoice, type TokenMetadataMap, type TokenOutputsMap, TokenTransactionService, type TransferParams, type TransferWithInvoiceOutcome, type TransferWithInvoiceParams, type TxChain, type UserTokenMetadata, type Utxo, ValidationError, type VerifiableSecretShare, WalletConfig, WalletConfigService, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, assertBech32, bech32mDecode, bigIntToPrivateKey, checkIfSelectedOutputsAreAvailable, checkIfValidSequence, collectResponses, computeTaprootKeyNoScript, computerLagrangeCoefficients, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createConnectorRefundTxs, createCurrentTimelockRefundTxs, createDecrementedTimelockNodeTx, createDecrementedTimelockRefundTxs, createInitialTimelockNodeTx, createInitialTimelockRefundTxs, createRootNodeTx, createSigningCommitment, createSigningNonce, createTestUnilateralRefundTxs, createTestUnilateralTimelockNodeTx, createZeroTimelockNodeTx, decodeBech32mTokenIdentifier, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, decodeSparkAddress, doesLeafNeedRefresh, doesTxnNeedRenewed, encodeBech32mTokenIdentifier, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, encodeSparkAddress, encodeSparkAddressWithSignature, evaluatePolynomial, fieldDiv, filterTokenBalanceForTokenIdentifier, generateAdaptorFromSignature, generatePolynomialForSecretSharing, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNetwork, getNetworkFromAddress, getNetworkFromBech32mTokenIdentifier, getNetworkFromSparkAddress, getNetworkFromString, getNextHTLCTransactionSequence, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomBigInt, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getSparkAddressFromTaproot, getTransactionSequence, getTransferPackageSigningPayload, getTxEstimatedVbytesSizeByNumberOfInputsOutputs, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, isEphemeralAnchorOutput, isLegacySparkAddress, isSafeForNumber, isTxBroadcast, isValidPublicKey, isValidSparkAddress, isZeroTimelock, lastKeyWithTarget, maybeApplyFee, modInverse, proofOfPossessionMessageHashForDepositAddress, protoToNetwork, recoverSecret, splitSecret, splitSecretWithProofs, subtractPrivateKeys, subtractPublicKeys, sumAvailableTokens, sumOfPrivateKeys, toProtoTimestamp, validateOutboundAdaptorSignature, validateShare, validateSparkInvoiceFields, validateSparkInvoiceSignature };