@buildonspark/spark-sdk 0.2.2 → 0.2.4

package/dist/native/index.d.cts

@@ -694,7 +694,7 @@ interface FinalizeTokenTransactionRequest {
     sparkPaymentIntent: string;
 }
 declare const FinalizeTokenTransactionRequest: MessageFns$2<FinalizeTokenTransactionRequest>;
-interface FreezeTokensPayload {
+interface FreezeTokensPayload$1 {
     ownerPublicKey: Uint8Array;
     tokenPublicKey: Uint8Array;
     issuerProvidedTimestamp: number;
@@ -703,19 +703,19 @@ interface FreezeTokensPayload {
     shouldUnfreeze: boolean;
     tokenIdentifier?: Uint8Array | undefined;
 }
-declare const FreezeTokensPayload: MessageFns$2<FreezeTokensPayload>;
-interface FreezeTokensRequest {
-    freezeTokensPayload: FreezeTokensPayload | undefined;
+declare const FreezeTokensPayload$1: MessageFns$2<FreezeTokensPayload$1>;
+interface FreezeTokensRequest$1 {
+    freezeTokensPayload: FreezeTokensPayload$1 | undefined;
     /** This is a Schnorr or ECDSA DER signature which can be between 64 and 73 bytes. */
     issuerSignature: Uint8Array;
 }
-declare const FreezeTokensRequest: MessageFns$2<FreezeTokensRequest>;
-interface FreezeTokensResponse {
+declare const FreezeTokensRequest$1: MessageFns$2<FreezeTokensRequest$1>;
+interface FreezeTokensResponse$1 {
     impactedOutputIds: string[];
     /** Decoded uint128 */
     impactedTokenAmount: Uint8Array;
 }
-declare const FreezeTokensResponse: MessageFns$2<FreezeTokensResponse>;
+declare const FreezeTokensResponse$1: MessageFns$2<FreezeTokensResponse$1>;
 interface QueryTokenOutputsRequest$1 {
     ownerPublicKeys: Uint8Array[];
     /** Optionally provide token public keys. If not set return leaves for all tokens. */
@@ -1486,7 +1486,6 @@ interface SparkServiceClient<CallOptionsExt = {}> {
     extend_leaf(request: DeepPartial$2<ExtendLeafRequest>, options?: CallOptions & CallOptionsExt): Promise<ExtendLeafResponse>;
     prepare_tree_address(request: DeepPartial$2<PrepareTreeAddressRequest>, options?: CallOptions & CallOptionsExt): Promise<PrepareTreeAddressResponse>;
     create_tree(request: DeepPartial$2<CreateTreeRequest>, options?: CallOptions & CallOptionsExt): Promise<CreateTreeResponse>;
-    create_tree_v2(request: DeepPartial$2<CreateTreeRequest>, options?: CallOptions & CallOptionsExt): Promise<CreateTreeResponse>;
     get_signing_operator_list(request: DeepPartial$2<Empty>, options?: CallOptions & CallOptionsExt): Promise<GetSigningOperatorListResponse>;
     query_nodes(request: DeepPartial$2<QueryNodesRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryNodesResponse>;
     query_nodes_distribution(request: DeepPartial$2<QueryNodesDistributionRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryNodesDistributionResponse>;
@@ -1497,7 +1496,7 @@ interface SparkServiceClient<CallOptionsExt = {}> {
     start_token_transaction(request: DeepPartial$2<StartTokenTransactionRequest>, options?: CallOptions & CallOptionsExt): Promise<StartTokenTransactionResponse>;
     sign_token_transaction(request: DeepPartial$2<SignTokenTransactionRequest>, options?: CallOptions & CallOptionsExt): Promise<SignTokenTransactionResponse>;
     finalize_token_transaction(request: DeepPartial$2<FinalizeTokenTransactionRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
-    freeze_tokens(request: DeepPartial$2<FreezeTokensRequest>, options?: CallOptions & CallOptionsExt): Promise<FreezeTokensResponse>;
+    freeze_tokens(request: DeepPartial$2<FreezeTokensRequest$1>, options?: CallOptions & CallOptionsExt): Promise<FreezeTokensResponse$1>;
     query_token_outputs(request: DeepPartial$2<QueryTokenOutputsRequest$1>, options?: CallOptions & CallOptionsExt): Promise<QueryTokenOutputsResponse$1>;
     query_token_transactions(request: DeepPartial$2<QueryTokenTransactionsRequest$1>, options?: CallOptions & CallOptionsExt): Promise<QueryTokenTransactionsResponse$1>;
     return_lightning_payment(request: DeepPartial$2<ReturnLightningPaymentRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
@@ -1521,6 +1520,20 @@ interface SparkServiceClient<CallOptionsExt = {}> {
      */
     initiate_utxo_swap(request: DeepPartial$2<InitiateUtxoSwapRequest>, options?: CallOptions & CallOptionsExt): Promise<InitiateUtxoSwapResponse>;
     exit_single_node_trees(request: DeepPartial$2<ExitSingleNodeTreesRequest>, options?: CallOptions & CallOptionsExt): Promise<ExitSingleNodeTreesResponse>;
+    /**
+     * The following endpoints enforce inclusion of Direct Transactions used
+     * for unilateral exits
+     */
+    create_tree_v2(request: DeepPartial$2<CreateTreeRequest>, options?: CallOptions & CallOptionsExt): Promise<CreateTreeResponse>;
+    cooperative_exit_v2(request: DeepPartial$2<CooperativeExitRequest>, options?: CallOptions & CallOptionsExt): Promise<CooperativeExitResponse>;
+    extend_leaf_v2(request: DeepPartial$2<ExtendLeafRequest>, options?: CallOptions & CallOptionsExt): Promise<ExtendLeafResponse>;
+    claim_transfer_sign_refunds_v2(request: DeepPartial$2<ClaimTransferSignRefundsRequest>, options?: CallOptions & CallOptionsExt): Promise<ClaimTransferSignRefundsResponse>;
+    finalize_node_signatures_v2(request: DeepPartial$2<FinalizeNodeSignaturesRequest>, options?: CallOptions & CallOptionsExt): Promise<FinalizeNodeSignaturesResponse>;
+    initiate_preimage_swap_v2(request: DeepPartial$2<InitiatePreimageSwapRequest>, options?: CallOptions & CallOptionsExt): Promise<InitiatePreimageSwapResponse>;
+    start_leaf_swap_v2(request: DeepPartial$2<StartTransferRequest>, options?: CallOptions & CallOptionsExt): Promise<StartTransferResponse>;
+    counter_leaf_swap_v2(request: DeepPartial$2<CounterLeafSwapRequest>, options?: CallOptions & CallOptionsExt): Promise<CounterLeafSwapResponse>;
+    start_transfer_v2(request: DeepPartial$2<StartTransferRequest>, options?: CallOptions & CallOptionsExt): Promise<StartTransferResponse>;
+    refresh_timelock_v2(request: DeepPartial$2<RefreshTimelockRequest>, options?: CallOptions & CallOptionsExt): Promise<RefreshTimelockResponse>;
 }
 type Builtin$2 = Date | Function | Uint8Array | string | number | boolean | undefined;
 type DeepPartial$2<T> = T extends Builtin$2 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$2<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$2<U>> : T extends {
@@ -2004,6 +2017,29 @@ interface TokenTransactionWithStatus {
     tokenTransactionHash: Uint8Array;
 }
 declare const TokenTransactionWithStatus: MessageFns$1<TokenTransactionWithStatus>;
+interface FreezeTokensPayload {
+    version: number;
+    ownerPublicKey: Uint8Array;
+    tokenPublicKey?: Uint8Array | undefined;
+    tokenIdentifier?: Uint8Array | undefined;
+    issuerProvidedTimestamp: number;
+    operatorIdentityPublicKey: Uint8Array;
+    /** Set to false when requesting a freeze. */
+    shouldUnfreeze: boolean;
+}
+declare const FreezeTokensPayload: MessageFns$1<FreezeTokensPayload>;
+interface FreezeTokensRequest {
+    freezeTokensPayload: FreezeTokensPayload | undefined;
+    /** This is a Schnorr or ECDSA DER signature which can be between 64 and 73 bytes. */
+    issuerSignature: Uint8Array;
+}
+declare const FreezeTokensRequest: MessageFns$1<FreezeTokensRequest>;
+interface FreezeTokensResponse {
+    impactedOutputIds: string[];
+    /** Decoded uint128 */
+    impactedTokenAmount: Uint8Array;
+}
+declare const FreezeTokensResponse: MessageFns$1<FreezeTokensResponse>;
 interface SparkTokenServiceClient<CallOptionsExt = {}> {
     /**
      * Start process to create final token transaction with all inputs required
@@ -2018,6 +2054,7 @@ interface SparkTokenServiceClient<CallOptionsExt = {}> {
     query_token_metadata(request: DeepPartial$1<QueryTokenMetadataRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryTokenMetadataResponse>;
     query_token_transactions(request: DeepPartial$1<QueryTokenTransactionsRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryTokenTransactionsResponse>;
     query_token_outputs(request: DeepPartial$1<QueryTokenOutputsRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryTokenOutputsResponse>;
+    freeze_tokens(request: DeepPartial$1<FreezeTokensRequest>, options?: CallOptions & CallOptionsExt): Promise<FreezeTokensResponse>;
 }
 type Builtin$1 = Date | Function | Uint8Array | string | number | boolean | undefined;
 type DeepPartial$1<T> = T extends Builtin$1 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$1<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$1<U>> : T extends {
@@ -2304,6 +2341,8 @@ interface CompleteCoopExitInput {
 
 interface CompleteLeavesSwapInput {
     adaptorSecretKey: string;
+    directAdaptorSecretKey: string;
+    directFromCpfpAdaptorSecretKey: string;
     userOutboundTransferExternalId: string;
     leavesSwapRequestId: string;
 }
@@ -2399,6 +2438,10 @@ interface SwapLeaf {
     leafId: string;
     rawUnsignedRefundTransaction: string;
     adaptorSignedSignature: string;
+    directRawUnsignedRefundTransaction?: string;
+    directAdaptorSignedSignature?: string;
+    directFromCpfpRawUnsignedRefundTransaction?: string;
+    directFromCpfpAdaptorSignedSignature?: string;
 }
 
 interface LeavesSwapRequest {
@@ -2546,11 +2589,17 @@ interface RequestCoopExitInput {
 interface UserLeafInput {
     leaf_id: string;
     raw_unsigned_refund_transaction: string;
+    direct_raw_unsigned_refund_transaction: string;
+    direct_from_cpfp_raw_unsigned_refund_transaction: string;
     adaptor_added_signature: string;
+    direct_adaptor_added_signature: string;
+    direct_from_cpfp_adaptor_added_signature: string;
 }
 
 interface RequestLeavesSwapInput {
     adaptorPubkey: string;
+    directAdaptorPubkey?: string;
+    directFromCpfpAdaptorPubkey?: string;
     totalAmountSats: number;
     targetAmountSats: number;
     feeSats: number;
@@ -2657,8 +2706,8 @@ declare class SspClient {
     requestCoopExit({ leafExternalIds, withdrawalAddress, idempotencyKey, exitSpeed, feeLeafExternalIds, feeQuoteId, withdrawAll, }: RequestCoopExitInput): Promise<CoopExitRequest | null>;
     requestLightningReceive({ amountSats, network, paymentHash, expirySecs, memo, includeSparkAddress, receiverIdentityPubkey, descriptionHash, }: RequestLightningReceiveInput): Promise<LightningReceiveRequest | null>;
     requestLightningSend({ encodedInvoice, idempotencyKey, amountSats, }: RequestLightningSendInput): Promise<LightningSendRequest | null>;
-    requestLeaveSwap({ adaptorPubkey, totalAmountSats, targetAmountSats, feeSats, userLeaves, idempotencyKey, targetAmountSatsList, }: RequestLeavesSwapInput): Promise<LeavesSwapRequest | null>;
-    completeLeaveSwap({ adaptorSecretKey, userOutboundTransferExternalId, leavesSwapRequestId, }: CompleteLeavesSwapInput): Promise<LeavesSwapRequest | null>;
+    requestLeaveSwap({ adaptorPubkey, directAdaptorPubkey, directFromCpfpAdaptorPubkey, totalAmountSats, targetAmountSats, feeSats, userLeaves, idempotencyKey, targetAmountSatsList, }: RequestLeavesSwapInput): Promise<LeavesSwapRequest | null>;
+    completeLeaveSwap({ adaptorSecretKey, directAdaptorSecretKey, directFromCpfpAdaptorSecretKey, userOutboundTransferExternalId, leavesSwapRequestId, }: CompleteLeavesSwapInput): Promise<LeavesSwapRequest | null>;
     getLightningReceiveRequest(id: string): Promise<LightningReceiveRequest | null>;
     getLightningSendRequest(id: string): Promise<LightningSendRequest | null>;
     getLeaveSwapRequest(id: string): Promise<LeavesSwapRequest | null>;
@@ -2807,19 +2856,66 @@ declare function filterTokenBalanceForTokenPublicKey(tokenBalances: TokenBalance
 
 declare function getTransferPackageSigningPayload(transferID: string, transferPackage: TransferPackage): Uint8Array;
 
+declare const DIRECT_TIMELOCK_OFFSET = 50;
+declare const INITIAL_SEQUENCE: number;
+declare const INITIAL_DIRECT_SEQUENCE: number;
+declare const TEST_UNILATERAL_SEQUENCE: number;
+declare const TEST_UNILATERAL_DIRECT_SEQUENCE: number;
 declare const DEFAULT_FEE_SATS: number;
 /**
  * Subtracts the default fee from the amount if it's greater than the fee.
  * Returns the original amount if it's less than or equal to the fee.
  */
 declare function maybeApplyFee(amount: bigint): bigint;
-declare function createRefundTx(sequence: number, nodeOutPoint: TransactionInput, amountSats: bigint, receivingPubkey: Uint8Array, network: Network): Transaction;
+declare function createRootTx(depositOutPoint: TransactionInput, depositTxOut: TransactionOutput): [Transaction, Transaction];
+declare function createSplitTx(parentOutPoint: TransactionInput, childTxOuts: TransactionOutput[]): [Transaction, Transaction];
+interface CreateNodeTxInput {
+    txOut: TransactionOutput;
+    parentOutPoint: TransactionInput;
+    applyFee?: boolean;
+    includeAnchor?: boolean;
+}
+declare function createNodeTx({ txOut, parentOutPoint, applyFee, includeAnchor, }: CreateNodeTxInput): Transaction;
+declare function createNodeTxs(txOut: TransactionOutput, txIn: TransactionInput, directTxIn?: TransactionInput): {
+    cpfpNodeTx: Transaction;
+    directNodeTx?: Transaction;
+};
+declare function createLeafNodeTx(sequence: number, directSequence: number, parentOutPoint: TransactionInput, txOut: TransactionOutput, shouldCalculateFee: boolean): [Transaction, Transaction];
+interface CreateRefundTxInput {
+    sequence: number;
+    input: TransactionInput;
+    amountSats: bigint;
+    receivingPubkey: Uint8Array;
+    network: Network;
+    shouldCalculateFee: boolean;
+    includeAnchor: boolean;
+}
+declare function createRefundTx({ sequence, input, amountSats, receivingPubkey, network, shouldCalculateFee, includeAnchor, }: CreateRefundTxInput): Transaction;
+interface CreateRefundTxsInput {
+    sequence: number;
+    directSequence?: number;
+    input: TransactionInput;
+    directInput?: TransactionInput;
+    amountSats: bigint;
+    receivingPubkey: Uint8Array;
+    network: Network;
+}
+declare function createRefundTxs({ sequence, directSequence, input, directInput, amountSats, receivingPubkey, network, }: CreateRefundTxsInput): {
+    cpfpRefundTx: Transaction;
+    directRefundTx?: Transaction;
+    directFromCpfpRefundTx?: Transaction;
+};
+declare function createConnectorRefundTransactions(sequence: number, cpfpNodeOutPoint: TransactionInput, directNodeOutPoint: TransactionInput, connectorOutput: TransactionInput, amountSats: bigint, receiverPubKey: Uint8Array, network: Network, shouldCalculateFee: boolean): [Transaction, Transaction, Transaction];
 declare function getCurrentTimelock(currSequence?: number): number;
-declare function getTransactionSequence(currSequence?: number): number;
+declare function getTransactionSequence(currSequence?: number): {
+    nextSequence: number;
+    nextDirectSequence: number;
+};
 declare function checkIfValidSequence(currSequence?: number): void;
-declare function getNextTransactionSequence(currSequence?: number, forRefresh?: boolean): {
+declare function doesLeafNeedRefresh(currSequence: number, isNodeTx?: boolean): boolean;
+declare function getNextTransactionSequence(currSequence: number, isNodeTx?: boolean): {
     nextSequence: number;
-    needRefresh: boolean;
+    nextDirectSequence: number;
 };
 declare function getEphemeralAnchorOutput(): TransactionOutput;
 
@@ -2990,7 +3086,12 @@ declare class ConnectionManager {
 declare class SigningService {
     private readonly config;
     constructor(config: WalletConfigService);
-    signRefunds(leaves: LeafKeyTweak[], signingCommitments: RequestedSigningCommitments[], receiverIdentityPubkey: Uint8Array): Promise<UserSignedTxSigningJob[]>;
+    private signRefundsInternal;
+    signRefunds(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, cpfpSigningCommitments: RequestedSigningCommitments[], directSigningCommitments: RequestedSigningCommitments[], directFromCpfpSigningCommitments: RequestedSigningCommitments[]): Promise<{
+        cpfpLeafSigningJobs: UserSignedTxSigningJob[];
+        directLeafSigningJobs: UserSignedTxSigningJob[];
+        directFromCpfpLeafSigningJobs: UserSignedTxSigningJob[];
+    }>;
 }
 
 type LeafKeyTweak = {
@@ -2998,19 +3099,17 @@ type LeafKeyTweak = {
     keyDerivation: KeyDerivation;
     newKeyDerivation: KeyDerivation;
 };
-type ClaimLeafData = {
-    keyDerivation: KeyDerivation;
-    tx?: Transaction;
-    refundTx?: Transaction;
-    signingNonceCommitment: SigningCommitmentWithOptionalNonce;
-    vout?: number;
-};
 type LeafRefundSigningData = {
     keyDerivation: KeyDerivation;
     receivingPubkey: Uint8Array;
+    signingNonceCommitment: SigningCommitmentWithOptionalNonce;
+    directSigningNonceCommitment: SigningCommitmentWithOptionalNonce;
     tx: Transaction;
+    directTx?: Transaction;
     refundTx?: Transaction;
-    signingNonceCommitment: SigningCommitmentWithOptionalNonce;
+    directRefundTx?: Transaction;
+    directFromCpfpRefundTx?: Transaction;
+    directFromCpfpRefundSigningNonceCommitment: SigningCommitmentWithOptionalNonce;
     vout: number;
 };
 declare class BaseTransferService {
@@ -3018,12 +3117,12 @@ declare class BaseTransferService {
     protected readonly connectionManager: ConnectionManager;
     protected readonly signingService: SigningService;
     constructor(config: WalletConfigService, connectionManager: ConnectionManager, signingService: SigningService);
-    sendTransferTweakKey(transfer: Transfer$1, leaves: LeafKeyTweak[], refundSignatureMap: Map<string, Uint8Array>): Promise<Transfer$1>;
-    deliverTransferPackage(transfer: Transfer$1, leaves: LeafKeyTweak[], refundSignatureMap: Map<string, Uint8Array>): Promise<Transfer$1>;
+    sendTransferTweakKey(transfer: Transfer$1, leaves: LeafKeyTweak[], cpfpRefundSignatureMap: Map<string, Uint8Array>, directRefundSignatureMap: Map<string, Uint8Array>, directFromCpfpRefundSignatureMap: Map<string, Uint8Array>): Promise<Transfer$1>;
+    deliverTransferPackage(transfer: Transfer$1, leaves: LeafKeyTweak[], cpfpRefundSignatureMap: Map<string, Uint8Array>, directRefundSignatureMap: Map<string, Uint8Array>, directFromCpfpRefundSignatureMap: Map<string, Uint8Array>): Promise<Transfer$1>;
     sendTransferWithKeyTweaks(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array): Promise<Transfer$1>;
     private prepareTransferPackage;
     private finalizeTransfer;
-    signRefunds(leafDataMap: Map<string, ClaimLeafData>, operatorSigningResults: LeafRefundTxSigningResult[], adaptorPubKey?: Uint8Array): Promise<NodeSignatures[]>;
+    signRefunds(leafDataMap: Map<string, LeafRefundSigningData>, operatorSigningResults: LeafRefundTxSigningResult[], cpfpAdaptorPubKey?: Uint8Array, directAdaptorPubKey?: Uint8Array, directFromCpfpAdaptorPubKey?: Uint8Array): Promise<NodeSignatures[]>;
     private prepareSendTransferKeyTweaks;
     private prepareSingleSendTransferKeyTweak;
     protected findShare(shares: VerifiableSecretShare[], operatorID: number): VerifiableSecretShare | undefined;
@@ -3044,22 +3143,30 @@ declare class TransferService extends BaseTransferService {
     sendTransferSignRefund(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date): Promise<{
         transfer: Transfer$1;
         signatureMap: Map<string, Uint8Array>;
+        directSignatureMap: Map<string, Uint8Array>;
+        directFromCpfpSignatureMap: Map<string, Uint8Array>;
         leafDataMap: Map<string, LeafRefundSigningData>;
     }>;
     startSwapSignRefund(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date): Promise<{
         transfer: Transfer$1;
         signatureMap: Map<string, Uint8Array>;
+        directSignatureMap: Map<string, Uint8Array>;
+        directFromCpfpSignatureMap: Map<string, Uint8Array>;
         leafDataMap: Map<string, LeafRefundSigningData>;
     }>;
-    counterSwapSignRefund(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date, adaptorPubKey?: Uint8Array): Promise<{
+    counterSwapSignRefund(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date, cpfpAdaptorPubKey?: Uint8Array, directAdaptorPubKey?: Uint8Array, directFromCpfpAdaptorPubKey?: Uint8Array): Promise<{
         transfer: Transfer$1;
         signatureMap: Map<string, Uint8Array>;
+        directSignatureMap: Map<string, Uint8Array>;
+        directFromCpfpSignatureMap: Map<string, Uint8Array>;
         leafDataMap: Map<string, LeafRefundSigningData>;
         signingResults: LeafRefundTxSigningResult[];
     }>;
-    sendTransferSignRefundInternal(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date, forSwap: boolean, adaptorPubKey?: Uint8Array): Promise<{
+    sendTransferSignRefundInternal(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date, forSwap: boolean, cpfpAdaptorPubKey?: Uint8Array, directAdaptorPubKey?: Uint8Array, directFromCpfpAdaptorPubKey?: Uint8Array): Promise<{
         transfer: Transfer$1;
         signatureMap: Map<string, Uint8Array>;
+        directSignatureMap: Map<string, Uint8Array>;
+        directFromCpfpSignatureMap: Map<string, Uint8Array>;
         leafDataMap: Map<string, LeafRefundSigningData>;
         signingResults: LeafRefundTxSigningResult[];
     }>;
@@ -3071,9 +3178,11 @@ declare class TransferService extends BaseTransferService {
     private finalizeNodeSignatures;
     cancelTransfer(transfer: Transfer$1, operatorAddress: string): Promise<Transfer$1 | undefined>;
     queryPendingTransfersBySender(operatorAddress: string): Promise<QueryTransfersResponse>;
-    refreshTimelockNodes(nodes: TreeNode[], parentNode: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
+    private refreshTimelockNodesInternal;
+    refreshTimelockNodes(node: TreeNode, parentNode: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
     extendTimelock(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
-    refreshTimelockRefundTx(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
+    testonly_expireTimeLockNodeTx(node: TreeNode, parentNode: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
+    testonly_expireTimeLockRefundtx(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
 }
 
 interface WalletLeaf {
@@ -3154,6 +3263,8 @@ declare class SparkWallet extends EventEmitter {
     private handleStreamEvent;
     protected setupBackgroundStream(): Promise<void>;
     getLeaves(isBalanceCheck?: boolean): Promise<TreeNode[]>;
+    private checkExtendLeaves;
+    private verifyKey;
     private selectLeaves;
     private selectLeavesForSwap;
     private areLeavesInefficient;
@@ -3560,12 +3671,14 @@ declare class SparkWallet extends EventEmitter {
      * @param outputIds - Optional array of output IDs to filter by
      * @returns Promise resolving to array of token transactions with their current status
      */
-    queryTokenTransactions({ ownerPublicKeys, issuerPublicKeys, tokenTransactionHashes, tokenIdentifiers, outputIds, }: {
+    queryTokenTransactions({ ownerPublicKeys, issuerPublicKeys, tokenTransactionHashes, tokenIdentifiers, outputIds, pageSize, offset, }: {
         ownerPublicKeys?: string[];
         issuerPublicKeys?: string[];
         tokenTransactionHashes?: string[];
         tokenIdentifiers?: string[];
         outputIds?: string[];
+        pageSize?: number;
+        offset?: number;
     }): Promise<TokenTransactionWithStatus[]>;
     getTokenL1Address(): Promise<string>;
     /**
@@ -3634,13 +3747,6 @@ declare class SparkWallet extends EventEmitter {
      * @returns {Promise<void>} Promise that resolves when the timelock is refreshed
      */
     testOnly_expireTimelock(nodeId: string): Promise<void>;
-    /**
-     * Refresh the timelock of a specific node's refund transaction only.
-     *
-     * @param {string} nodeId - The ID of the node whose refund transaction to refresh
-     * @returns {Promise<void>} Promise that resolves when the refund timelock is refreshed
-     */
-    testOnly_expireTimelockRefundTx(nodeId: string): Promise<void>;
     private cleanup;
     cleanupConnections(): Promise<void>;
     private startPeriodicClaimTransfers;
@@ -3659,6 +3765,8 @@ interface QueryTokenTransactionsParams {
     tokenTransactionHashes?: string[];
     tokenIdentifiers?: string[];
     outputIds?: string[];
+    pageSize: number;
+    offset: number;
 }
 declare class TokenTransactionService {
     protected readonly config: WalletConfigService;
@@ -3700,4 +3808,4 @@ declare class TokenTransactionService {
     private createSignaturesForOperators;
 }
 
-export { AuthenticationError, type Bech32mTokenIdentifier, type Bech32mTokenIdentifierData, type BroadcastConfig, type BroadcastResult, type ConfigOptions, ConfigurationError, ConnectionManager, type CreateLightningInvoiceParams, DEFAULT_FEE_SATS, type DecodedSparkAddressData, ReactNativeSparkSigner as DefaultSparkSigner, type DepositParams, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, type InitWalletResponse, InternalValidationError, LRC_WALLET_NETWORK, LRC_WALLET_NETWORK_TYPE, type LeafInfo, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, type PayLightningInvoiceParams, RPCError, type RawTokenIdentifierHex, ReactNativeSparkSigner, type SparkAddressData, type SparkAddressFormat, SparkSDKError, SparkWallet, type SparkWalletEvents, type SparkWalletProps, type TokenBalanceMap, type TokenMetadataMap, type TokenOutputsMap, TokenTransactionService, type TransferParams, type TxChain, type UserTokenMetadata, type Utxo, ValidationError, type VerifiableSecretShare, WalletConfig, WalletConfigService, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, bigIntToPrivateKey, checkIfSelectedOutputsAreAvailable, checkIfValidSequence, collectResponses, computeTaprootKeyNoScript, computerLagrangeCoefficients, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createRefundTx, createSigningCommitment, createSigningNonce, decodeBech32mTokenIdentifier, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, decodeSparkAddress, encodeBech32mTokenIdentifier, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, encodeSparkAddress, evaluatePolynomial, fieldDiv, filterTokenBalanceForTokenPublicKey, generateAdaptorFromSignature, generatePolynomialForSecretSharing, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNetwork, getNetworkFromAddress, getNetworkFromString, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomBigInt, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getSparkAddressFromTaproot, getTransactionSequence, getTransferPackageSigningPayload, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, isEphemeralAnchorOutput, isTxBroadcast, isValidPublicKey, isValidSparkAddress, lastKeyWithTarget, maybeApplyFee, modInverse, proofOfPossessionMessageHashForDepositAddress, protoToNetwork, recoverSecret, splitSecret, splitSecretWithProofs, subtractPrivateKeys, subtractPublicKeys, sumAvailableTokens, sumOfPrivateKeys, validateOutboundAdaptorSignature, validateShare };
+export { AuthenticationError, type Bech32mTokenIdentifier, type Bech32mTokenIdentifierData, type BroadcastConfig, type BroadcastResult, type ConfigOptions, ConfigurationError, ConnectionManager, type CreateLightningInvoiceParams, DEFAULT_FEE_SATS, DIRECT_TIMELOCK_OFFSET, type DecodedSparkAddressData, ReactNativeSparkSigner as DefaultSparkSigner, type DepositParams, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, INITIAL_DIRECT_SEQUENCE, INITIAL_SEQUENCE, type InitWalletResponse, InternalValidationError, LRC_WALLET_NETWORK, LRC_WALLET_NETWORK_TYPE, type LeafInfo, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, type PayLightningInvoiceParams, RPCError, type RawTokenIdentifierHex, ReactNativeSparkSigner, type SparkAddressData, type SparkAddressFormat, SparkSDKError, SparkWallet, type SparkWalletEvents, type SparkWalletProps, TEST_UNILATERAL_DIRECT_SEQUENCE, TEST_UNILATERAL_SEQUENCE, type TokenBalanceMap, type TokenMetadataMap, type TokenOutputsMap, TokenTransactionService, type TransferParams, type TxChain, type UserTokenMetadata, type Utxo, ValidationError, type VerifiableSecretShare, WalletConfig, WalletConfigService, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, 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, evaluatePolynomial, fieldDiv, filterTokenBalanceForTokenPublicKey, generateAdaptorFromSignature, generatePolynomialForSecretSharing, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNetwork, getNetworkFromAddress, getNetworkFromString, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomBigInt, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getSparkAddressFromTaproot, getTransactionSequence, getTransferPackageSigningPayload, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, isEphemeralAnchorOutput, isTxBroadcast, isValidPublicKey, isValidSparkAddress, lastKeyWithTarget, maybeApplyFee, modInverse, proofOfPossessionMessageHashForDepositAddress, protoToNetwork, recoverSecret, splitSecret, splitSecretWithProofs, subtractPrivateKeys, subtractPublicKeys, sumAvailableTokens, sumOfPrivateKeys, validateOutboundAdaptorSignature, validateShare };