@buildonspark/spark-sdk 0.1.43 → 0.1.45

package/dist/native/index.d.cts

@@ -215,7 +215,7 @@ declare enum Network$1 {
     SIGNET = 4,
     UNRECOGNIZED = -1
 }
-declare enum TokenTransactionStatus {
+declare enum TokenTransactionStatus$1 {
     TOKEN_TRANSACTION_STARTED = 0,
     TOKEN_TRANSACTION_SIGNED = 1,
     TOKEN_TRANSACTION_REVEALED = 5,
@@ -230,7 +230,7 @@ declare enum TransferStatus {
     TRANSFER_STATUS_SENDER_KEY_TWEAK_PENDING = 1,
     TRANSFER_STATUS_SENDER_KEY_TWEAKED = 2,
     TRANSFER_STATUS_RECEIVER_KEY_TWEAKED = 3,
-    TRANSFER_STATUSR_RECEIVER_REFUND_SIGNED = 4,
+    TRANSFER_STATUS_RECEIVER_REFUND_SIGNED = 4,
     TRANSFER_STATUS_COMPLETED = 5,
     TRANSFER_STATUS_EXPIRED = 6,
     TRANSFER_STATUS_RETURNED = 7,
@@ -394,6 +394,12 @@ interface SigningKeyshare {
     threshold: number;
     /** The public key of the keyshare. */
     publicKey: Uint8Array;
+    /** The public shares of the keyshare. */
+    publicShares: {
+        [key: string]: Uint8Array;
+    };
+    /** The latest update time of the keyshare. */
+    updatedTime: Date | undefined;
 }
 declare const SigningKeyshare: MessageFns$3<SigningKeyshare>;
 /**
@@ -431,6 +437,12 @@ interface NodeSignatureShares {
     refundTxSigningResult: SigningResult | undefined;
     /** The verifying key of the node. */
     verifyingKey: Uint8Array;
+    /** The signing result of the node's transaction. This transaction is to pay to self. */
+    directNodeTxSigningResult: SigningResult | undefined;
+    /** The signing result of the node's direct refund transaction. This transaction is to broadcast for the SO. */
+    directRefundTxSigningResult: SigningResult | undefined;
+    /** The signing result of the node's direct from cpfp refund transaction. This transaction is to broadcast for the SO. */
+    directFromCpfpRefundTxSigningResult: SigningResult | undefined;
 }
 declare const NodeSignatureShares: MessageFns$3<NodeSignatureShares>;
 /**
@@ -440,10 +452,16 @@ declare const NodeSignatureShares: MessageFns$3<NodeSignatureShares>;
 interface NodeSignatures {
     /** The id of the node. */
     nodeId: string;
-    /** The final signature of the node's transaction. This transaction is to pay to self. */
+    /** The final signature of the node's cpfp transaction. This transaction is to pay to self. */
     nodeTxSignature: Uint8Array;
-    /** The final signature of the node's refund transaction. This transaction is to pay to the user. */
+    /** The final signature of the node's cpfp refund transaction. This transaction is to pay to the user. */
     refundTxSignature: Uint8Array;
+    /** The final signature of the node's direct transaction. This transaction is to pay for the watchtower. */
+    directNodeTxSignature: Uint8Array;
+    /** The final signature of the node's direct refund transaction. This transaction is to pay for the watchtower. */
+    directRefundTxSignature: Uint8Array;
+    /** The final signature of the node's direct from cpfp refund transaction. This transaction is to pay for the watchtower. */
+    directFromCpfpRefundTxSignature: Uint8Array;
 }
 declare const NodeSignatures: MessageFns$3<NodeSignatures>;
 /** StartTreeCreationRequest is the request to start the tree creation for a tree root node. */
@@ -452,10 +470,16 @@ interface StartTreeCreationRequest {
     identityPublicKey: Uint8Array;
     /** The on-chain utxo to be used to be spent by the root node. */
     onChainUtxo: UTXO | undefined;
-    /** The signing job for the root node's transaction. */
+    /** The signing job for the root node's cpfp transaction. */
     rootTxSigningJob: SigningJob | undefined;
-    /** The signing job for the root node's refund transaction. */
+    /** The signing job for the root node's cpfp refund transaction. */
     refundTxSigningJob: SigningJob | undefined;
+    /** The signing job for the root node's direct transaction. */
+    directRootTxSigningJob: SigningJob | undefined;
+    /** The signing job for the root node's direct refund transaction */
+    directRefundTxSigningJob: SigningJob | undefined;
+    /** The signing job for the root node's direct refund transaction */
+    directFromCpfpRefundTxSigningJob: SigningJob | undefined;
 }
 declare const StartTreeCreationRequest: MessageFns$3<StartTreeCreationRequest>;
 /** StartTreeCreationResponse is the response to the request to start the tree creation for a tree root node. */
@@ -476,6 +500,12 @@ interface StartDepositTreeCreationRequest {
     rootTxSigningJob: SigningJob | undefined;
     /** The signing job for the root node's refund transaction. */
     refundTxSigningJob: SigningJob | undefined;
+    /** The direct signing job for the root node's transaction. */
+    directRootTxSigningJob: SigningJob | undefined;
+    /** The signing job for the root node's direct refund transaction. */
+    directRefundTxSigningJob: SigningJob | undefined;
+    /** The signing job for the root node's direct from cpfp refund transaction. */
+    directFromCpfpRefundTxSigningJob: SigningJob | undefined;
 }
 declare const StartDepositTreeCreationRequest: MessageFns$3<StartDepositTreeCreationRequest>;
 /** StartDepositTreeCreationResponse is the response to the request to start the tree creation for a tree root node. */
@@ -511,8 +541,20 @@ interface TokenMintInput$1 {
      * random nonce would be favorable to populating this field.
      */
     issuerProvidedTimestamp: number;
+    tokenIdentifier?: Uint8Array | undefined;
 }
 declare const TokenMintInput$1: MessageFns$3<TokenMintInput$1>;
+interface TokenCreateInput$1 {
+    issuerPublicKey: Uint8Array;
+    tokenName: string;
+    tokenTicker: string;
+    decimals: number;
+    /** Decoded uint128 */
+    maxSupply: Uint8Array;
+    isFreezable: boolean;
+    creationEntityPublicKey?: Uint8Array | undefined;
+}
+declare const TokenCreateInput$1: MessageFns$3<TokenCreateInput$1>;
 /**
  * This proto is constructed by the wallet to specify outputs it wants to create
  * as part of a token transaction. Output id and revocation public key should remain unfilled
@@ -524,7 +566,8 @@ interface TokenOutput$2 {
     revocationCommitment?: Uint8Array | undefined;
     withdrawBondSats?: number | undefined;
     withdrawRelativeBlockLocktime?: number | undefined;
-    tokenPublicKey: Uint8Array;
+    tokenPublicKey?: Uint8Array | undefined;
+    tokenIdentifier?: Uint8Array | undefined;
     /** Decoded uint128 */
     tokenAmount: Uint8Array;
 }
@@ -535,37 +578,36 @@ declare const TokenOutput$2: MessageFns$3<TokenOutput$2>;
  * is cooperatively signed by the SO group to confirm a token transaction.
  */
 interface TokenTransaction$1 {
-    /**
-     * For mint transactions issuer_public_key will be specified without any outputs_to_spend.
-     * For transfer transactions the token amount in the input leaves must match the token amount in the output leaves.
-     */
     tokenInputs?: {
         $case: "mintInput";
         mintInput: TokenMintInput$1;
     } | {
         $case: "transferInput";
         transferInput: TokenTransferInput$1;
+    } | {
+        $case: "createInput";
+        createInput: TokenCreateInput$1;
     } | undefined;
     tokenOutputs: TokenOutput$2[];
     sparkOperatorIdentityPublicKeys: Uint8Array[];
     network: Network$1;
 }
 declare const TokenTransaction$1: MessageFns$3<TokenTransaction$1>;
-interface SpentTokenOutputMetadata {
+interface SpentTokenOutputMetadata$1 {
     outputId: string;
     revocationSecret: Uint8Array;
 }
-declare const SpentTokenOutputMetadata: MessageFns$3<SpentTokenOutputMetadata>;
-interface TokenTransactionConfirmationMetadata {
-    spentTokenOutputsMetadata: SpentTokenOutputMetadata[];
+declare const SpentTokenOutputMetadata$1: MessageFns$3<SpentTokenOutputMetadata$1>;
+interface TokenTransactionConfirmationMetadata$1 {
+    spentTokenOutputsMetadata: SpentTokenOutputMetadata$1[];
 }
-declare const TokenTransactionConfirmationMetadata: MessageFns$3<TokenTransactionConfirmationMetadata>;
-interface TokenTransactionWithStatus {
+declare const TokenTransactionConfirmationMetadata$1: MessageFns$3<TokenTransactionConfirmationMetadata$1>;
+interface TokenTransactionWithStatus$1 {
     tokenTransaction: TokenTransaction$1 | undefined;
-    status: TokenTransactionStatus;
-    confirmationMetadata: TokenTransactionConfirmationMetadata | undefined;
+    status: TokenTransactionStatus$1;
+    confirmationMetadata: TokenTransactionConfirmationMetadata$1 | undefined;
 }
-declare const TokenTransactionWithStatus: MessageFns$3<TokenTransactionWithStatus>;
+declare const TokenTransactionWithStatus$1: MessageFns$3<TokenTransactionWithStatus$1>;
 interface SignatureWithIndex$1 {
     /** This is a Schnorr or ECDSA DER signature which can be between 64 and 73 bytes. */
     signature: Uint8Array;
@@ -576,7 +618,7 @@ declare const SignatureWithIndex$1: MessageFns$3<SignatureWithIndex$1>;
 interface TokenTransactionSignatures {
     /**
      * Filled by signing the partial token transaction hash with the owner/issuer private key.
-     * For mint transactions this will be one signature for the input issuer_public_key
+     * For mint transactions this will be one signature for the input token_public_key
      * For transfer transactions this will be one for each output for the output owner_public_key
      */
     ownerSignatures: SignatureWithIndex$1[];
@@ -587,6 +629,7 @@ interface StartTokenTransactionRequest {
     partialTokenTransaction: TokenTransaction$1 | undefined;
     /** List of ecdsa signatures authorizing movement of tokens from the token input. */
     tokenTransactionSignatures: TokenTransactionSignatures | undefined;
+    sparkPaymentIntent: string;
 }
 declare const StartTokenTransactionRequest: MessageFns$3<StartTokenTransactionRequest>;
 interface StartTokenTransactionResponse {
@@ -647,6 +690,7 @@ interface FinalizeTokenTransactionRequest {
      */
     revocationSecrets: RevocationSecretWithIndex[];
     identityPublicKey: Uint8Array;
+    sparkPaymentIntent: string;
 }
 declare const FinalizeTokenTransactionRequest: MessageFns$3<FinalizeTokenTransactionRequest>;
 interface FreezeTokensPayload$1 {
@@ -656,6 +700,7 @@ interface FreezeTokensPayload$1 {
     operatorIdentityPublicKey: Uint8Array;
     /** Set to false when requesting a freeze. */
     shouldUnfreeze: boolean;
+    tokenIdentifier?: Uint8Array | undefined;
 }
 declare const FreezeTokensPayload$1: MessageFns$3<FreezeTokensPayload$1>;
 interface FreezeTokensRequest$1 {
@@ -670,43 +715,46 @@ interface FreezeTokensResponse$1 {
     impactedTokenAmount: Uint8Array;
 }
 declare const FreezeTokensResponse$1: MessageFns$3<FreezeTokensResponse$1>;
-interface QueryTokenOutputsRequest {
+interface QueryTokenOutputsRequest$1 {
     ownerPublicKeys: Uint8Array[];
     /** Optionally provide token public keys. If not set return leaves for all tokens. */
     tokenPublicKeys: Uint8Array[];
+    tokenIdentifiers: Uint8Array[];
     /** defaults to mainnet when no network is provided. */
     network: Network$1;
 }
-declare const QueryTokenOutputsRequest: MessageFns$3<QueryTokenOutputsRequest>;
+declare const QueryTokenOutputsRequest$1: MessageFns$3<QueryTokenOutputsRequest$1>;
 /** Request constraints are combined using an AND relation. */
-interface QueryTokenTransactionsRequest {
+interface QueryTokenTransactionsRequest$1 {
     /** Returns transactions that have one of these output ids in the input or output. */
     outputIds: string[];
     /** Returns transactions that have this owner public key as the sender or receiver in one or more of the input/output leaves. */
     ownerPublicKeys: Uint8Array[];
     /** Returns transactions that related to this token public key. */
     tokenPublicKeys: Uint8Array[];
+    /** Returns transactions that related to this token identifier. */
+    tokenIdentifiers: Uint8Array[];
     /** Returns transactions that match the provided transaction hashes. */
     tokenTransactionHashes: Uint8Array[];
     limit: number;
     offset: number;
 }
-declare const QueryTokenTransactionsRequest: MessageFns$3<QueryTokenTransactionsRequest>;
-interface QueryTokenTransactionsResponse {
-    tokenTransactionsWithStatus: TokenTransactionWithStatus[];
+declare const QueryTokenTransactionsRequest$1: MessageFns$3<QueryTokenTransactionsRequest$1>;
+interface QueryTokenTransactionsResponse$1 {
+    tokenTransactionsWithStatus: TokenTransactionWithStatus$1[];
     offset: number;
 }
-declare const QueryTokenTransactionsResponse: MessageFns$3<QueryTokenTransactionsResponse>;
-interface OutputWithPreviousTransactionData {
+declare const QueryTokenTransactionsResponse$1: MessageFns$3<QueryTokenTransactionsResponse$1>;
+interface OutputWithPreviousTransactionData$1 {
     output: TokenOutput$2 | undefined;
     previousTransactionHash: Uint8Array;
     previousTransactionVout: number;
 }
-declare const OutputWithPreviousTransactionData: MessageFns$3<OutputWithPreviousTransactionData>;
-interface QueryTokenOutputsResponse {
-    outputsWithPreviousTransactionData: OutputWithPreviousTransactionData[];
+declare const OutputWithPreviousTransactionData$1: MessageFns$3<OutputWithPreviousTransactionData$1>;
+interface QueryTokenOutputsResponse$1 {
+    outputsWithPreviousTransactionData: OutputWithPreviousTransactionData$1[];
 }
-declare const QueryTokenOutputsResponse: MessageFns$3<QueryTokenOutputsResponse>;
+declare const QueryTokenOutputsResponse$1: MessageFns$3<QueryTokenOutputsResponse$1>;
 /** TreeNode represents a node on the tree. */
 interface TreeNode {
     /** The id of the node. */
@@ -717,7 +765,7 @@ interface TreeNode {
     value: number;
     /** The id of the parent node. */
     parentNodeId?: string | undefined;
-    /** The transaction of the node, this transaction is to pay to the same address as the node. */
+    /** The cpfp transaction of the node, this transaction is to pay to the same address as the node. */
     nodeTx: Uint8Array;
     /** The refund transaction of the node, this transaction is to pay to the user. */
     refundTx: Uint8Array;
@@ -733,6 +781,18 @@ interface TreeNode {
     status: string;
     /** The network of the node. */
     network: Network$1;
+    /** The creation time of the node. */
+    createdTime: Date | undefined;
+    /** The latest update time of the node. */
+    updatedTime: Date | undefined;
+    /** The signing public key of the owner of the node. */
+    ownerSigningPublicKey: Uint8Array;
+    /** The direct transaction of the node, this transaction is for the watchtower to broadcast. */
+    directTx: Uint8Array;
+    /** The refund transaction of the node, this transaction is to pay to the user. */
+    directRefundTx: Uint8Array;
+    /** The refund transaction of the node, this transaction is to pay to the user. */
+    directFromCpfpRefundTx: Uint8Array;
 }
 declare const TreeNode: MessageFns$3<TreeNode>;
 /** FinalizeNodeSignaturesRequest is the request to finalize the signatures for a node. */
@@ -766,6 +826,8 @@ declare const SecretShare$1: MessageFns$3<SecretShare$1>;
 interface LeafRefundTxSigningJob {
     leafId: string;
     refundTxSigningJob: SigningJob | undefined;
+    directRefundTxSigningJob: SigningJob | undefined;
+    directFromCpfpRefundTxSigningJob: SigningJob | undefined;
 }
 declare const LeafRefundTxSigningJob: MessageFns$3<LeafRefundTxSigningJob>;
 interface UserSignedTxSigningJob {
@@ -781,6 +843,8 @@ interface LeafRefundTxSigningResult {
     leafId: string;
     refundTxSigningResult: SigningResult | undefined;
     verifyingKey: Uint8Array;
+    directRefundTxSigningResult: SigningResult | undefined;
+    directFromCpfpRefundTxSigningResult: SigningResult | undefined;
 }
 declare const LeafRefundTxSigningResult: MessageFns$3<LeafRefundTxSigningResult>;
 interface StartUserSignedTransferRequest {
@@ -789,6 +853,8 @@ interface StartUserSignedTransferRequest {
     leavesToSend: UserSignedTxSigningJob[];
     receiverIdentityPublicKey: Uint8Array;
     expiryTime: Date | undefined;
+    directLeavesToSend: UserSignedTxSigningJob[];
+    directFromCpfpLeavesToSend: UserSignedTxSigningJob[];
 }
 declare const StartUserSignedTransferRequest: MessageFns$3<StartUserSignedTransferRequest>;
 interface StartTransferRequest {
@@ -800,6 +866,7 @@ interface StartTransferRequest {
     expiryTime: Date | undefined;
     /** If this field is set, the leaves_to_send and key_tweak_proofs will be ignored. */
     transferPackage: TransferPackage | undefined;
+    sparkPaymentIntent: string;
 }
 declare const StartTransferRequest: MessageFns$3<StartTransferRequest>;
 interface StartTransferResponse {
@@ -813,7 +880,7 @@ declare const StartTransferResponse: MessageFns$3<StartTransferResponse>;
  * the coordinator SO.
  */
 interface TransferPackage {
-    /** The leaves to send, with user signed refunds and signing package. */
+    /** The leaves to send, with user signed cpfp refunds and signing package. */
     leavesToSend: UserSignedTxSigningJob[];
     /** The map of SO identifier to ciphertext of SendLeafTweaks. */
     keyTweakPackage: {
@@ -821,6 +888,10 @@ interface TransferPackage {
     };
     /** The signature of user to prove that the key_tweak_package is not tampered. */
     userSignature: Uint8Array;
+    /** The leaves to send, with user signed direct refunds and signing package. */
+    directLeavesToSend: UserSignedTxSigningJob[];
+    /** The leaves to send, with user signed direct from cpfp refunds and signing package. */
+    directFromCpfpLeavesToSend: UserSignedTxSigningJob[];
 }
 declare const TransferPackage: MessageFns$3<TransferPackage>;
 interface SendLeafKeyTweak {
@@ -833,12 +904,15 @@ interface SendLeafKeyTweak {
     /** Signature over Sha256(leaf_id||transfer_id||secret_cipher) */
     signature: Uint8Array;
     refundSignature: Uint8Array;
+    directRefundSignature: Uint8Array;
+    directFromCpfpRefundSignature: Uint8Array;
 }
 declare const SendLeafKeyTweak: MessageFns$3<SendLeafKeyTweak>;
 interface FinalizeTransferRequest {
     transferId: string;
     ownerIdentityPublicKey: Uint8Array;
     leavesToSend: SendLeafKeyTweak[];
+    sparkPaymentIntent: string;
 }
 declare const FinalizeTransferRequest: MessageFns$3<FinalizeTransferRequest>;
 interface FinalizeTransferWithTransferPackageRequest {
@@ -869,6 +943,8 @@ interface TransferLeaf {
     secretCipher: Uint8Array;
     signature: Uint8Array;
     intermediateRefundTx: Uint8Array;
+    intermediateDirectRefundTx: Uint8Array;
+    intermediateDirectFromCpfpRefundTx: Uint8Array;
 }
 declare const TransferLeaf: MessageFns$3<TransferLeaf>;
 interface TransferFilter {
@@ -890,6 +966,7 @@ interface TransferFilter {
     types: TransferType[];
     /** defaults to mainnet when no network is provided. */
     network: Network$1;
+    statuses: TransferStatus[];
 }
 declare const TransferFilter: MessageFns$3<TransferFilter>;
 interface QueryTransfersResponse {
@@ -921,20 +998,6 @@ interface ClaimTransferSignRefundsResponse {
     signingResults: LeafRefundTxSigningResult[];
 }
 declare const ClaimTransferSignRefundsResponse: MessageFns$3<ClaimTransferSignRefundsResponse>;
-interface AggregateNodesRequest {
-    nodeIds: string[];
-    signingJob: SigningJob | undefined;
-    /** Serves as a temporary identity public key, this should be get from auth process. */
-    ownerIdentityPublicKey: Uint8Array;
-}
-declare const AggregateNodesRequest: MessageFns$3<AggregateNodesRequest>;
-interface AggregateNodesResponse {
-    aggregateSignature: SigningResult | undefined;
-    verifyingKey: Uint8Array;
-    parentNodeTx: Uint8Array;
-    parentNodeVout: number;
-}
-declare const AggregateNodesResponse: MessageFns$3<AggregateNodesResponse>;
 interface StorePreimageShareRequest {
     paymentHash: Uint8Array;
     preimageShare: SecretShare$1 | undefined;
@@ -1010,6 +1073,8 @@ interface CounterLeafSwapRequest {
     transfer: StartTransferRequest | undefined;
     swapId: string;
     adaptorPublicKey: Uint8Array;
+    directAdaptorPublicKey: Uint8Array;
+    directFromCpfpAdaptorPublicKey: Uint8Array;
 }
 declare const CounterLeafSwapRequest: MessageFns$3<CounterLeafSwapRequest>;
 interface CounterLeafSwapResponse {
@@ -1038,6 +1103,9 @@ interface ExtendLeafRequest {
     ownerIdentityPublicKey: Uint8Array;
     nodeTxSigningJob: SigningJob | undefined;
     refundTxSigningJob: SigningJob | undefined;
+    directNodeTxSigningJob: SigningJob | undefined;
+    directRefundTxSigningJob: SigningJob | undefined;
+    directFromCpfpRefundTxSigningJob: SigningJob | undefined;
 }
 declare const ExtendLeafRequest: MessageFns$3<ExtendLeafRequest>;
 interface ExtendLeafSigningResult {
@@ -1049,6 +1117,9 @@ interface ExtendLeafResponse {
     leafId: string;
     nodeTxSigningResult: ExtendLeafSigningResult | undefined;
     refundTxSigningResult: ExtendLeafSigningResult | undefined;
+    directNodeTxSigningResult: ExtendLeafSigningResult | undefined;
+    directRefundTxSigningResult: ExtendLeafSigningResult | undefined;
+    directFromCpfpRefundTxSigningResult: ExtendLeafSigningResult | undefined;
 }
 declare const ExtendLeafResponse: MessageFns$3<ExtendLeafResponse>;
 interface AddressRequestNode {
@@ -1082,12 +1153,18 @@ interface PrepareTreeAddressResponse {
 }
 declare const PrepareTreeAddressResponse: MessageFns$3<PrepareTreeAddressResponse>;
 interface CreationNode {
-    /** This is the tx that spends the parent node's output. */
+    /** This is the cpfp tx that spends the parent node's output. */
     nodeTxSigningJob: SigningJob | undefined;
     /** The refund tx can only exist if there's no children. */
     refundTxSigningJob: SigningJob | undefined;
     /** The children will spend the output of the node's tx. Vout is the index of the child. */
     children: CreationNode[];
+    /** This is the direct tx that spends the parent node's output. */
+    directNodeTxSigningJob: SigningJob | undefined;
+    /** The direct refund tx can only exist if there's no children. */
+    directRefundTxSigningJob: SigningJob | undefined;
+    /** The direct from cpfp refund tx can only exist if there's no children. */
+    directFromCpfpRefundTxSigningJob: SigningJob | undefined;
 }
 declare const CreationNode: MessageFns$3<CreationNode>;
 interface CreateTreeRequest {
@@ -1109,6 +1186,9 @@ interface CreationResponseNode {
     nodeTxSigningResult: SigningResult | undefined;
     refundTxSigningResult: SigningResult | undefined;
     children: CreationResponseNode[];
+    directNodeTxSigningResult: SigningResult | undefined;
+    directRefundTxSigningResult: SigningResult | undefined;
+    directFromCpfpRefundTxSigningResult: SigningResult | undefined;
 }
 declare const CreationResponseNode: MessageFns$3<CreationResponseNode>;
 interface CreateTreeResponse {
@@ -1195,6 +1275,10 @@ interface QueryUnusedDepositAddressesRequest {
     identityPublicKey: Uint8Array;
     /** defaults to mainnet when no network is provided. */
     network: Network$1;
+    /** defaults to 100 if not set. */
+    limit: number;
+    /** defaults to 0 if not set. */
+    offset: number;
 }
 declare const QueryUnusedDepositAddressesRequest: MessageFns$3<QueryUnusedDepositAddressesRequest>;
 interface QueryStaticDepositAddressesRequest {
@@ -1214,6 +1298,8 @@ interface DepositAddressQueryResult {
 declare const DepositAddressQueryResult: MessageFns$3<DepositAddressQueryResult>;
 interface QueryUnusedDepositAddressesResponse {
     depositAddresses: DepositAddressQueryResult[];
+    /** defaults to -1 if there are no more results */
+    offset: number;
 }
 declare const QueryUnusedDepositAddressesResponse: MessageFns$3<QueryUnusedDepositAddressesResponse>;
 interface QueryStaticDepositAddressesResponse {
@@ -1318,6 +1404,11 @@ interface SparkServiceClient$1<CallOptionsExt = {}> {
     start_tree_creation(request: DeepPartial$3<StartTreeCreationRequest>, options?: CallOptions & CallOptionsExt): Promise<StartTreeCreationResponse>;
     finalize_node_signatures(request: DeepPartial$3<FinalizeNodeSignaturesRequest>, options?: CallOptions & CallOptionsExt): Promise<FinalizeNodeSignaturesResponse>;
     start_transfer(request: DeepPartial$3<StartTransferRequest>, options?: CallOptions & CallOptionsExt): Promise<StartTransferResponse>;
+    /**
+     * This is deprecated, please use finalize_transfer_with_transfer_package instead.
+     *
+     * @deprecated
+     */
     finalize_transfer(request: DeepPartial$3<FinalizeTransferRequest>, options?: CallOptions & CallOptionsExt): Promise<FinalizeTransferResponse>;
     finalize_transfer_with_transfer_package(request: DeepPartial$3<FinalizeTransferWithTransferPackageRequest>, options?: CallOptions & CallOptionsExt): Promise<FinalizeTransferResponse>;
     cancel_transfer(request: DeepPartial$3<CancelTransferRequest>, options?: CallOptions & CallOptionsExt): Promise<CancelTransferResponse>;
@@ -1325,7 +1416,6 @@ interface SparkServiceClient$1<CallOptionsExt = {}> {
     query_all_transfers(request: DeepPartial$3<TransferFilter>, options?: CallOptions & CallOptionsExt): Promise<QueryTransfersResponse>;
     claim_transfer_tweak_keys(request: DeepPartial$3<ClaimTransferTweakKeysRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
     claim_transfer_sign_refunds(request: DeepPartial$3<ClaimTransferSignRefundsRequest>, options?: CallOptions & CallOptionsExt): Promise<ClaimTransferSignRefundsResponse>;
-    aggregate_nodes(request: DeepPartial$3<AggregateNodesRequest>, options?: CallOptions & CallOptionsExt): Promise<AggregateNodesResponse>;
     store_preimage_share(request: DeepPartial$3<StorePreimageShareRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
     get_signing_commitments(request: DeepPartial$3<GetSigningCommitmentsRequest>, options?: CallOptions & CallOptionsExt): Promise<GetSigningCommitmentsResponse>;
     cooperative_exit(request: DeepPartial$3<CooperativeExitRequest>, options?: CallOptions & CallOptionsExt): Promise<CooperativeExitResponse>;
@@ -1362,8 +1452,8 @@ interface SparkServiceClient$1<CallOptionsExt = {}> {
     sign_token_transaction(request: DeepPartial$3<SignTokenTransactionRequest>, options?: CallOptions & CallOptionsExt): Promise<SignTokenTransactionResponse>;
     finalize_token_transaction(request: DeepPartial$3<FinalizeTokenTransactionRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
     freeze_tokens(request: DeepPartial$3<FreezeTokensRequest$1>, options?: CallOptions & CallOptionsExt): Promise<FreezeTokensResponse$1>;
-    query_token_outputs(request: DeepPartial$3<QueryTokenOutputsRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryTokenOutputsResponse>;
-    query_token_transactions(request: DeepPartial$3<QueryTokenTransactionsRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryTokenTransactionsResponse>;
+    query_token_outputs(request: DeepPartial$3<QueryTokenOutputsRequest$1>, options?: CallOptions & CallOptionsExt): Promise<QueryTokenOutputsResponse$1>;
+    query_token_transactions(request: DeepPartial$3<QueryTokenTransactionsRequest$1>, options?: CallOptions & CallOptionsExt): Promise<QueryTokenTransactionsResponse$1>;
     return_lightning_payment(request: DeepPartial$3<ReturnLightningPaymentRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
     query_unused_deposit_addresses(request: DeepPartial$3<QueryUnusedDepositAddressesRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryUnusedDepositAddressesResponse>;
     query_static_deposit_addresses(request: DeepPartial$3<QueryStaticDepositAddressesRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryStaticDepositAddressesResponse>;
@@ -1395,10 +1485,6 @@ interface ISigningCommitment {
     hiding: Uint8Array;
     binding: Uint8Array;
 }
-interface DummyTx {
-    tx: Uint8Array;
-    txid: string;
-}
 
 type Polynomial = {
     fieldModulus: bigint;
@@ -1674,6 +1760,43 @@ interface CoopExitFeeEstimatesOutput {
     speedSlow?: CoopExitFeeEstimate | undefined;
 }
 
+interface CoopExitFeeQuote {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when the entity was first created. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The network the coop exit fee quote is on. **/
+    network: BitcoinNetwork;
+    /** The total currency amount of all the nodes user swapped for the coop exit quote. **/
+    totalAmount: CurrencyAmount;
+    /** The fee user pays for the coop exit not including the L1 broadcast fee when exit speed is fast. **/
+    userFeeFast: CurrencyAmount;
+    /** The fee user pays for the coop exit not including the L1 broadcast fee when exit speed is medium. **/
+    userFeeMedium: CurrencyAmount;
+    /** The fee user pays for the coop exit not including the L1 broadcast fee when exit speed is slow. **/
+    userFeeSlow: CurrencyAmount;
+    /** The L1 broadcast fee user pays for the coop exit when exit speed is fast. **/
+    l1BroadcastFeeFast: CurrencyAmount;
+    /** The L1 broadcast fee user pays for the coop exit when exit speed is medium. **/
+    l1BroadcastFeeMedium: CurrencyAmount;
+    /** The L1 broadcast fee user pays for the coop exit when exit speed is slow. **/
+    l1BroadcastFeeSlow: CurrencyAmount;
+    /** The time when the coop exit fee quote expires. **/
+    expiresAt: string;
+    /** The typename of the object **/
+    typename: string;
+}
+
+interface CoopExitFeeQuoteInput {
+    leafExternalIds: string[];
+    withdrawalAddress: string;
+}
+
 declare enum ExitSpeed {
     /**
      * This is an enum value that represents values that could be added in the future.
@@ -1864,10 +1987,10 @@ declare class SspClient {
     getCoopExitFeeEstimate({ leafExternalIds, withdrawalAddress, }: CoopExitFeeEstimatesInput): Promise<CoopExitFeeEstimatesOutput | null>;
     getCurrentUser(): Promise<void>;
     completeCoopExit({ userOutboundTransferExternalId, coopExitRequestId, }: CompleteCoopExitInput): Promise<CoopExitRequest | null>;
-    requestCoopExit({ leafExternalIds, withdrawalAddress, idempotencyKey, exitSpeed, }: RequestCoopExitInput): Promise<CoopExitRequest | null>;
+    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, }: RequestLeavesSwapInput): Promise<LeavesSwapRequest | null>;
+    requestLeaveSwap({ adaptorPubkey, totalAmountSats, targetAmountSats, feeSats, userLeaves, idempotencyKey, targetAmountSatsList, }: RequestLeavesSwapInput): Promise<LeavesSwapRequest | null>;
     completeLeaveSwap({ adaptorSecretKey, userOutboundTransferExternalId, leavesSwapRequestId, }: CompleteLeavesSwapInput): Promise<LeavesSwapRequest | null>;
     getLightningReceiveRequest(id: string): Promise<LightningReceiveRequest | null>;
     getLightningSendRequest(id: string): Promise<LightningSendRequest | null>;
@@ -1887,6 +2010,7 @@ declare class SspClient {
     getChallenge(): Promise<GetChallengeOutput | null>;
     verifyChallenge(signature: string, protectedChallenge: string): Promise<VerifyChallengeOutput | null>;
     authenticate(): Promise<void>;
+    getCoopExitFeeQuote({ leafExternalIds, withdrawalAddress, }: CoopExitFeeQuoteInput): Promise<CoopExitFeeQuote | null>;
 }
 
 interface Leaf {
@@ -2231,6 +2355,16 @@ interface MessageFns$2<T> {
     fromPartial(object: DeepPartial$2<T>): T;
 }
 
+declare enum TokenTransactionStatus {
+    TOKEN_TRANSACTION_STARTED = 0,
+    TOKEN_TRANSACTION_SIGNED = 1,
+    TOKEN_TRANSACTION_REVEALED = 5,
+    TOKEN_TRANSACTION_FINALIZED = 2,
+    TOKEN_TRANSACTION_STARTED_CANCELLED = 3,
+    TOKEN_TRANSACTION_SIGNED_CANCELLED = 4,
+    TOKEN_TRANSACTION_UNKNOWN = 10,
+    UNRECOGNIZED = -1
+}
 /**
  * This proto is constructed by the wallet to specify leaves it wants to spend
  * as part of the token transaction.
@@ -2246,19 +2380,20 @@ interface TokenTransferInput {
 declare const TokenTransferInput: MessageFns$1<TokenTransferInput>;
 interface TokenMintInput {
     issuerPublicKey: Uint8Array;
-    /**
-     * Issuer provided timestamp of when the transaction was signed/constructed.
-     * Helps provide idempotency and ensures that each mint input signature is
-     * unique as long as multiple mint signatures are not happening at the same
-     * time. Also gives a potentially useful data point for when the issuer
-     * authorized from their perspective.  Note that we have no way of proving
-     * this is accurate.
-     * TODO: Consider whether implementing generic idempotency controls and/or a
-     * random nonce would be favorable to populating this field.
-     */
-    issuerProvidedTimestamp: number;
+    tokenIdentifier?: Uint8Array | undefined;
 }
 declare const TokenMintInput: MessageFns$1<TokenMintInput>;
+interface TokenCreateInput {
+    issuerPublicKey: Uint8Array;
+    tokenName: string;
+    tokenTicker: string;
+    decimals: number;
+    /** Decoded uint128 */
+    maxSupply: Uint8Array;
+    isFreezable: boolean;
+    creationEntityPublicKey?: Uint8Array | undefined;
+}
+declare const TokenCreateInput: MessageFns$1<TokenCreateInput>;
 /**
  * This proto is constructed by the wallet to specify outputs it wants to create
  * as part of a token transaction. Output id and revocation public key should
@@ -2271,7 +2406,8 @@ interface TokenOutput$1 {
     revocationCommitment?: Uint8Array | undefined;
     withdrawBondSats?: number | undefined;
     withdrawRelativeBlockLocktime?: number | undefined;
-    tokenPublicKey: Uint8Array;
+    tokenPublicKey?: Uint8Array | undefined;
+    tokenIdentifier?: Uint8Array | undefined;
     /** Decoded uint128 */
     tokenAmount: Uint8Array;
 }
@@ -2295,6 +2431,9 @@ interface TokenTransaction {
     } | {
         $case: "transferInput";
         transferInput: TokenTransferInput;
+    } | {
+        $case: "createInput";
+        createInput: TokenCreateInput;
     } | undefined;
     tokenOutputs: TokenOutput$1[];
     sparkOperatorIdentityPublicKeys: Uint8Array[];
@@ -2305,6 +2444,12 @@ interface TokenTransaction {
      */
     expiryTime: Date | undefined;
     network: Network$1;
+    /**
+     * The timestamp of when the client created the transaction. This is used to
+     * determine which transaction should win in a race condition. Earlier
+     * timestamps win over later ones.
+     */
+    clientCreatedTimestamp: Date | undefined;
 }
 declare const TokenTransaction: MessageFns$1<TokenTransaction>;
 interface SignatureWithIndex {
@@ -2340,7 +2485,7 @@ interface StartTransactionRequest {
     /**
      * How long the transaction should be valid for, in seconds.
      * The server will set the actual expiry_time in the final transaction based
-     * on this duration. Must be between 1 and 300 seconds.
+     * on this duration. Must be within [1, 300] seconds.
      */
     validityDurationSeconds: number;
 }
@@ -2360,6 +2505,82 @@ declare const CommitTransactionRequest: MessageFns$1<CommitTransactionRequest>;
 interface CommitTransactionResponse {
 }
 declare const CommitTransactionResponse: MessageFns$1<CommitTransactionResponse>;
+interface QueryTokenMetadataRequest {
+    tokenIdentifiers: Uint8Array[];
+    issuerPublicKeys: Uint8Array[];
+}
+declare const QueryTokenMetadataRequest: MessageFns$1<QueryTokenMetadataRequest>;
+interface TokenMetadata$1 {
+    issuerPublicKey: Uint8Array;
+    tokenName: string;
+    tokenTicker: string;
+    decimals: number;
+    /** Decoded uint128 */
+    maxSupply: Uint8Array;
+    isFreezable: boolean;
+    creationEntityPublicKey?: Uint8Array | undefined;
+    tokenIdentifier: Uint8Array;
+}
+declare const TokenMetadata$1: MessageFns$1<TokenMetadata$1>;
+interface QueryTokenMetadataResponse {
+    tokenMetadata: TokenMetadata$1[];
+}
+declare const QueryTokenMetadataResponse: MessageFns$1<QueryTokenMetadataResponse>;
+interface QueryTokenOutputsRequest {
+    ownerPublicKeys: Uint8Array[];
+    /** Optionally provide issuer public keys or token identifiers. If both are not set return outputs for all tokens. */
+    issuerPublicKeys: Uint8Array[];
+    tokenIdentifiers: Uint8Array[];
+    /** defaults to mainnet when no network is provided. */
+    network: Network$1;
+}
+declare const QueryTokenOutputsRequest: MessageFns$1<QueryTokenOutputsRequest>;
+/** Request constraints are combined using an AND relation. */
+interface QueryTokenTransactionsRequest {
+    /** Returns transactions that have one of these output ids in the input or output. */
+    outputIds: string[];
+    /** Returns transactions that have this owner public key as the sender or receiver in one or more of the input/output leaves. */
+    ownerPublicKeys: Uint8Array[];
+    /** Returns transactions that related to this token public key. */
+    issuerPublicKeys: Uint8Array[];
+    /** Returns transactions that related to this token identifier. */
+    tokenIdentifiers: Uint8Array[];
+    /** Returns transactions that match the provided transaction hashes. */
+    tokenTransactionHashes: Uint8Array[];
+    limit: number;
+    offset: number;
+}
+declare const QueryTokenTransactionsRequest: MessageFns$1<QueryTokenTransactionsRequest>;
+interface QueryTokenTransactionsResponse {
+    tokenTransactionsWithStatus: TokenTransactionWithStatus[];
+    offset: number;
+}
+declare const QueryTokenTransactionsResponse: MessageFns$1<QueryTokenTransactionsResponse>;
+interface OutputWithPreviousTransactionData {
+    output: TokenOutput$1 | undefined;
+    previousTransactionHash: Uint8Array;
+    previousTransactionVout: number;
+}
+declare const OutputWithPreviousTransactionData: MessageFns$1<OutputWithPreviousTransactionData>;
+interface QueryTokenOutputsResponse {
+    outputsWithPreviousTransactionData: OutputWithPreviousTransactionData[];
+}
+declare const QueryTokenOutputsResponse: MessageFns$1<QueryTokenOutputsResponse>;
+interface SpentTokenOutputMetadata {
+    outputId: string;
+    revocationSecret: Uint8Array;
+}
+declare const SpentTokenOutputMetadata: MessageFns$1<SpentTokenOutputMetadata>;
+interface TokenTransactionConfirmationMetadata {
+    spentTokenOutputsMetadata: SpentTokenOutputMetadata[];
+}
+declare const TokenTransactionConfirmationMetadata: MessageFns$1<TokenTransactionConfirmationMetadata>;
+interface TokenTransactionWithStatus {
+    tokenTransaction: TokenTransaction | undefined;
+    status: TokenTransactionStatus;
+    confirmationMetadata: TokenTransactionConfirmationMetadata | undefined;
+}
+declare const TokenTransactionWithStatus: MessageFns$1<TokenTransactionWithStatus>;
 interface SparkTokenServiceClient<CallOptionsExt = {}> {
     /**
      * Start process to create final token transaction with all inputs required
@@ -2371,6 +2592,9 @@ interface SparkTokenServiceClient<CallOptionsExt = {}> {
      * coordinated by one SO.
      */
     commit_transaction(request: DeepPartial$1<CommitTransactionRequest>, options?: CallOptions & CallOptionsExt): Promise<CommitTransactionResponse>;
+    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>;
 }
 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 {
@@ -2839,6 +3063,8 @@ interface WalletTransferLeaf {
     intermediateRefundTx: string;
 }
 
+type HumanReadableTokenIdentifier = `btk1${string}` | `btkrt1${string}` | `btkt1${string}` | `btks1${string}` | `btkl1${string}`;
+
 type CreateLightningInvoiceParams = {
     amountSats: number;
     memo?: string;
@@ -2857,13 +3083,44 @@ type TransferParams = {
     amountSats: number;
     receiverSparkAddress: string;
 };
-type TokenInfo = {
+/**
+ * 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 human readable token identifier.
+ *
+ * tokenPublicKey: This is the hex-encoded public key of the token issuer - Same as issuerPublicKey.
+ *
+ * @example
+ * ```typescript
+ * const tokenMetadata: TokenMetadata = {
+ *   rawTokenIdentifier: new Uint8Array([1, 2, 3]),
+ *   tokenPublicKey: "0348fbb...",
+ *   tokenName: "SparkToken",
+ *   tokenTicker: "SPK",
+ *   decimals: 8,
+ *   maxSupply: 1000000n
+ * };
+ * ```
+ */
+type TokenMetadata = {
+    /** Raw binary token identifier - This is used to encode the human readable token identifier */
+    rawTokenIdentifier: Uint8Array;
+    /** Hex-encoded public key of the token issuer - Same as issuerPublicKey */
     tokenPublicKey: string;
+    /** Human-readable name of the token (e.g., SparkToken)*/
     tokenName: string;
-    tokenSymbol: string;
-    tokenDecimals: number;
+    /** 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<HumanReadableTokenIdentifier, {
+    balance: bigint;
+    tokenMetadata: TokenMetadata;
+}>;
 type InitWalletResponse = {
     mnemonic?: string | undefined;
 };
@@ -2901,7 +3158,7 @@ declare class SparkWallet extends EventEmitter {
     private sparkAddress;
     private streamController;
     protected leaves: TreeNode[];
-    protected tokenOutputs: Map<string, OutputWithPreviousTransactionData[]>;
+    protected tokenOutputs: Map<string, OutputWithPreviousTransactionData$1[]>;
     private claimTransfersInterval;
     protected wrapWithOtelSpan<T>(name: string, fn: (...args: any[]) => Promise<T>): (...args: any[]) => Promise<T>;
     protected constructor(options?: ConfigOptions, signer?: SparkSigner);
@@ -2992,12 +3249,6 @@ declare class SparkWallet extends EventEmitter {
         transfers: WalletTransfer[];
         offset: number;
     }>;
-    /**
-     * Gets the held token info for the wallet.
-     *
-     * @deprecated The information is returned in getBalance
-     */
-    getTokenInfo(): Promise<TokenInfo[]>;
     /**
      * Gets the current balance of the wallet.
      * You can use the forceRefetch option to synchronize your wallet and claim any
@@ -3005,14 +3256,11 @@ declare class SparkWallet extends EventEmitter {
      *
      * @returns {Promise<Object>} Object containing:
      *   - balance: The wallet's current balance in satoshis
-     *   - tokenBalances: Map of token public keys to token balances and token info
+     *   - tokenBalances: Map of the human readable token identifier to token balances and token info
      */
     getBalance(): Promise<{
         balance: bigint;
-        tokenBalances: Map<string, {
-            balance: bigint;
-            tokenInfo: TokenInfo;
-        }>;
+        tokenBalances: TokenBalanceMap;
     }>;
     private getTokenBalance;
     private getInternalBalance;
@@ -3097,6 +3345,15 @@ declare class SparkWallet extends EventEmitter {
      * @returns {Promise<string[]>} The unused deposit addresses
      */
     getUnusedDepositAddresses(): Promise<string[]>;
+    /**
+     * Gets all unused deposit addresses for the wallet.
+     *
+     * @param {Object} params - Parameters for querying unused deposit addresses
+     * @param {Uint8Array<ArrayBufferLike>} [params.identityPublicKey] - The identity public key
+     * @param {NetworkProto} [params.network] - The network
+     * @returns {Promise<DepositAddressQueryResult[]>} The unused deposit addresses
+     */
+    private queryAllUnusedDepositAddresses;
     /**
      * Claims a deposit to the wallet.
      * Note that if you used advancedDeposit, you don't need to call this function.
@@ -3219,13 +3476,18 @@ declare class SparkWallet extends EventEmitter {
      *
      * @param {Object} params - Parameters for the withdrawal
      * @param {string} params.onchainAddress - The Bitcoin address where the funds should be sent
-     * @param {number} [params.amountSats] - The amount in satoshis to withdraw. If not specified, attempts to withdraw all available funds
+     * @param {CoopExitFeeQuote} params.feeQuote - The fee quote for the withdrawal
+     * @param {ExitSpeed} params.exitSpeed - The exit speed chosen for the withdrawal
+     * @param {number} [params.amountSats] - The amount in satoshis to withdraw. If not specified, attempts to withdraw all available funds and deductFeeFromWithdrawalAmount is set to true.
+     * @param {boolean} [params.deductFeeFromWithdrawalAmount] - Controls how the withdrawal fee is handled. If true, the fee is deducted from the withdrawal amount (amountSats), meaning the recipient will receive amountSats minus the fee. If false, the fee is paid separately from the wallet balance, meaning the recipient will receive the full amountSats.
      * @returns {Promise<CoopExitRequest | null | undefined>} The withdrawal request details, or null/undefined if the request cannot be completed
      */
-    withdraw({ onchainAddress, exitSpeed, amountSats, }: {
+    withdraw({ onchainAddress, exitSpeed, feeQuote, amountSats, deductFeeFromWithdrawalAmount, }: {
         onchainAddress: string;
         exitSpeed: ExitSpeed;
+        feeQuote: CoopExitFeeQuote;
         amountSats?: number;
+        deductFeeFromWithdrawalAmount?: boolean;
     }): Promise<CoopExitRequest | null>;
     /**
      * Internal method to perform a cooperative exit (withdrawal).
@@ -3242,12 +3504,12 @@ declare class SparkWallet extends EventEmitter {
      * @param {Object} params - Input parameters for fee estimation
      * @param {number} params.amountSats - The amount in satoshis to withdraw
      * @param {string} params.withdrawalAddress - The Bitcoin address where the funds should be sent
-     * @returns {Promise<CoopExitFeeEstimatesOutput | null>} Fee estimate for the withdrawal
+     * @returns {Promise<CoopExitFeeQuote | null>} Fee estimate for the withdrawal
      */
-    getWithdrawalFeeEstimate({ amountSats, withdrawalAddress, }: {
+    getWithdrawalFeeQuote({ amountSats, withdrawalAddress, }: {
         amountSats: number;
         withdrawalAddress: string;
-    }): Promise<CoopExitFeeEstimatesOutput | null>;
+    }): Promise<CoopExitFeeQuote | null>;
     /**
      * Gets a transfer that has been sent by the SSP to the wallet.
      *
@@ -3263,7 +3525,7 @@ declare class SparkWallet extends EventEmitter {
      * @param {string} id - The ID of the transfer
      * @returns {Promise<Transfer | undefined>} The transfer
      */
-    getTransfer(id: string): Promise<Transfer$1 | undefined>;
+    getTransfer(id: string): Promise<WalletTransfer | undefined>;
     /**
      * Synchronizes token outputs for the wallet.
      *
@@ -3286,7 +3548,7 @@ declare class SparkWallet extends EventEmitter {
         tokenAmount: bigint;
         receiverSparkAddress: string;
         outputSelectionStrategy?: "SMALL_FIRST" | "LARGE_FIRST";
-        selectedOutputs?: OutputWithPreviousTransactionData[];
+        selectedOutputs?: OutputWithPreviousTransactionData$1[];
     }): Promise<string>;
     /**
      * Transfers tokens with multiple outputs
@@ -3302,16 +3564,19 @@ declare class SparkWallet extends EventEmitter {
         tokenPublicKey: string;
         tokenAmount: bigint;
         receiverSparkAddress: string;
-    }[], outputSelectionStrategy?: "SMALL_FIRST" | "LARGE_FIRST", selectedOutputs?: OutputWithPreviousTransactionData[]): Promise<string>;
+    }[], outputSelectionStrategy?: "SMALL_FIRST" | "LARGE_FIRST", selectedOutputs?: OutputWithPreviousTransactionData$1[]): Promise<string>;
     /**
      * Retrieves token transaction history for specified tokens owned by the wallet.
      * Can optionally filter by specific transaction hashes.
      *
-     * @param tokenPublicKeys - Array of token public keys to query transactions for
+     * @param ownerPublicKeys - Optional array of owner public keys to query transactions for
+     * @param issuerPublicKeys - Optional array of issuer public keys to query transactions for
      * @param tokenTransactionHashes - Optional array of specific transaction hashes to filter by
+     * @param tokenIdentifiers - Optional array of token identifiers to filter by
+     * @param outputIds - Optional array of output IDs to filter by
      * @returns Promise resolving to array of token transactions with their current status
      */
-    queryTokenTransactions(tokenPublicKeys: string[], tokenTransactionHashes?: string[]): Promise<TokenTransactionWithStatus[]>;
+    queryTokenTransactions(ownerPublicKeys?: string[], issuerPublicKeys?: string[], tokenTransactionHashes?: string[], tokenIdentifiers?: string[], outputIds?: string[]): Promise<TokenTransactionWithStatus[]>;
     getTokenL1Address(): Promise<string>;
     /**
      * Signs a message with the identity key.
@@ -3393,11 +3658,6 @@ declare class SparkWallet extends EventEmitter {
     private queryNodes;
 }
 
-declare function getLatestDepositTxId(address: string): Promise<string | null>;
-declare function isTxBroadcast(txid: string, baseUrl: string, network?: any): Promise<boolean>;
-
-declare function createDummyTx(address: string, amountSats: bigint): Promise<DummyTx>;
-
 declare function generateSignatureFromExistingAdaptor(signature: Uint8Array, adaptorPrivateKeyBytes: Uint8Array): Uint8Array;
 declare function generateAdaptorFromSignature(signature: Uint8Array): {
     adaptorSignature: Uint8Array;
@@ -3425,6 +3685,9 @@ declare function subtractPrivateKeys(a: Uint8Array, b: Uint8Array): Uint8Array<A
 declare function sumOfPrivateKeys(keys: Uint8Array[]): Uint8Array<ArrayBufferLike>;
 declare function lastKeyWithTarget(target: Uint8Array, keys: Uint8Array[]): Uint8Array<ArrayBufferLike>;
 
+declare function getLatestDepositTxId(address: string): Promise<string | null>;
+declare function isTxBroadcast(txid: string, baseUrl: string, network?: any): Promise<boolean>;
+
 declare function proofOfPossessionMessageHashForDepositAddress(userPubkey: Uint8Array, operatorPubkey: Uint8Array, depositAddress: string): Uint8Array;
 
 declare function collectResponses<T>(responses: PromiseSettledResult<T>[]): T[];
@@ -3438,11 +3701,9 @@ declare function createSigningCommitment(binding: Uint8Array, hiding: Uint8Array
 declare function encodeSigningCommitmentToBytes(commitment: SigningCommitment): Uint8Array;
 declare function decodeBytesToSigningCommitment(bytes: Uint8Array): SigningCommitment;
 
-declare function calculateAvailableTokenAmount(outputLeaves: OutputWithPreviousTransactionData[]): bigint;
-declare function checkIfSelectedOutputsAreAvailable(selectedOutputs: OutputWithPreviousTransactionData[], tokenOutputs: Map<string, OutputWithPreviousTransactionData[]>, tokenPublicKey: Uint8Array): boolean;
-declare function filterTokenBalanceForTokenPublicKey(tokenBalances: Map<string, {
-    balance: bigint;
-}>, publicKey: string): {
+declare function calculateAvailableTokenAmount(outputLeaves: OutputWithPreviousTransactionData$1[]): bigint;
+declare function checkIfSelectedOutputsAreAvailable(selectedOutputs: OutputWithPreviousTransactionData$1[], tokenOutputs: Map<string, OutputWithPreviousTransactionData$1[]>, tokenPublicKey: Uint8Array): boolean;
+declare function filterTokenBalanceForTokenPublicKey(tokenBalances: TokenBalanceMap, publicKey: string): {
     balance: bigint;
 };
 
@@ -3515,4 +3776,4 @@ declare function constructFeeBumpTx(txHex: string, utxos: Utxo[], feeRate: FeeRa
 
 declare function getSparkAddressFromTaproot(taprootAddress: string): SparkAddressFormat;
 
-export { AuthenticationError, type BroadcastConfig, type BroadcastResult, ConfigurationError, DEFAULT_FEE_SATS, ReactNativeSparkSigner as DefaultSparkSigner, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, InternalValidationError, LRC_WALLET_NETWORK, LRC_WALLET_NETWORK_TYPE, type LeafInfo, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, RPCError, ReactNativeSparkSigner, SparkSDKError, SparkWallet, type TxChain, type Utxo, ValidationError, type VerifiableSecretShare, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, bigIntToPrivateKey, calculateAvailableTokenAmount, checkIfSelectedOutputsAreAvailable, checkIfValidSequence, collectResponses, computeTaprootKeyNoScript, computerLagrangeCoefficients, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createDummyTx, createRefundTx, createSigningCommitment, createSigningNonce, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, 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, lastKeyWithTarget, maybeApplyFee, modInverse, proofOfPossessionMessageHashForDepositAddress, recoverSecret, splitSecret, splitSecretWithProofs, subtractPrivateKeys, subtractPublicKeys, sumOfPrivateKeys, validateOutboundAdaptorSignature, validateShare };
+export { AuthenticationError, type BroadcastConfig, type BroadcastResult, ConfigurationError, DEFAULT_FEE_SATS, ReactNativeSparkSigner as DefaultSparkSigner, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, InternalValidationError, LRC_WALLET_NETWORK, LRC_WALLET_NETWORK_TYPE, type LeafInfo, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, RPCError, ReactNativeSparkSigner, SparkSDKError, SparkWallet, type TxChain, type Utxo, ValidationError, type VerifiableSecretShare, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, bigIntToPrivateKey, calculateAvailableTokenAmount, checkIfSelectedOutputsAreAvailable, checkIfValidSequence, collectResponses, computeTaprootKeyNoScript, computerLagrangeCoefficients, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createRefundTx, createSigningCommitment, createSigningNonce, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, 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, lastKeyWithTarget, maybeApplyFee, modInverse, proofOfPossessionMessageHashForDepositAddress, recoverSecret, splitSecret, splitSecretWithProofs, subtractPrivateKeys, subtractPublicKeys, sumOfPrivateKeys, validateOutboundAdaptorSignature, validateShare };