@buildonspark/spark-sdk 0.1.47 → 0.2.0

package/dist/native/index.d.cts

@@ -606,6 +606,7 @@ interface TokenTransactionWithStatus$1 {
     tokenTransaction: TokenTransaction$1 | undefined;
     status: TokenTransactionStatus$1;
     confirmationMetadata: TokenTransactionConfirmationMetadata$1 | undefined;
+    tokenTransactionHash: Uint8Array;
 }
 declare const TokenTransactionWithStatus$1: MessageFns$2<TokenTransactionWithStatus$1>;
 interface SignatureWithIndex$1 {
@@ -1014,6 +1015,7 @@ interface RequestedSigningCommitments {
 declare const RequestedSigningCommitments: MessageFns$2<RequestedSigningCommitments>;
 interface GetSigningCommitmentsRequest {
     nodeIds: string[];
+    count: number;
 }
 declare const GetSigningCommitmentsRequest: MessageFns$2<GetSigningCommitmentsRequest>;
 interface GetSigningCommitmentsResponse {
@@ -1287,6 +1289,8 @@ interface QueryStaticDepositAddressesRequest {
     network: Network$1;
     limit: number;
     offset: number;
+    /** Optional filter. When specified, only the DepositAddress with this address is returned. */
+    depositAddress?: string | undefined;
 }
 declare const QueryStaticDepositAddressesRequest: MessageFns$2<QueryStaticDepositAddressesRequest>;
 interface DepositAddressQueryResult {
@@ -1327,6 +1331,39 @@ interface PaymentIntentFields {
     memo?: string | undefined;
 }
 declare const PaymentIntentFields: MessageFns$2<PaymentIntentFields>;
+interface InitiateStaticDepositUtxoRefundRequest {
+    onChainUtxo: UTXO | undefined;
+    /**
+     * A package that is used for signing L1 Bitcoin transactions using FROST.
+     * SE consumes it to return SigningResult structure, that is used by the user to
+     * construct the final signature for the refund Bitcoin transaction.
+     */
+    refundTxSigningJob: SigningJob | undefined;
+    /**
+     * Signature of a user statement that authorises the SE to initiate a static
+     * deposit utxo refund to the user.
+     *
+     * The user statement is constructed by concatenating the following fields in order:
+     * 1. Action name: "claim_static_deposit" (UTF-8 string)
+     * 2. Network: lowercase network name (e.g., "bitcoin", "testnet") (UTF-8 string)
+     * 3. Transaction ID: hex-encoded UTXO transaction ID (UTF-8 string)
+     * 4. Output index: UTXO output index (vout) as 4-byte unsigned integer (little-endian)
+     * 5. Request type: 2 for refund (1-byte unsigned integer, little-endian)
+     * 6. Credit amount: amount of satoshis to credit as 8-byte unsigned integer (little-endian)
+     * 7. Signing payload: sighash of spend transaction (UTF-8 string)
+     *
+     * The concatenated payload is then hashed with SHA-256, and the resulting hash
+     * is signed using ECDSA with the user's identity private key to produce this signature.
+     */
+    userSignature: Uint8Array;
+}
+declare const InitiateStaticDepositUtxoRefundRequest: MessageFns$2<InitiateStaticDepositUtxoRefundRequest>;
+interface InitiateStaticDepositUtxoRefundResponse {
+    /** The FROST signing results which must be aggregated by the user to complete signing */
+    refundTxSigningResult: SigningResult | undefined;
+    depositAddress: DepositAddressQueryResult | undefined;
+}
+declare const InitiateStaticDepositUtxoRefundResponse: MessageFns$2<InitiateStaticDepositUtxoRefundResponse>;
 interface InitiateUtxoSwapRequest {
     onChainUtxo: UTXO | undefined;
     requestType: UtxoSwapRequestType;
@@ -1449,6 +1486,7 @@ 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>;
@@ -1466,7 +1504,21 @@ interface SparkServiceClient<CallOptionsExt = {}> {
     query_unused_deposit_addresses(request: DeepPartial$2<QueryUnusedDepositAddressesRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryUnusedDepositAddressesResponse>;
     query_static_deposit_addresses(request: DeepPartial$2<QueryStaticDepositAddressesRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryStaticDepositAddressesResponse>;
     subscribe_to_events(request: DeepPartial$2<SubscribeToEventsRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<SubscribeToEventsResponse>;
-    /** Claim a deposit to a static address from SSP side */
+    /**
+     * Signs the provided refund transaction which spends the UTXO from a static
+     * deposit address. If successful, the UTXO will no longer be available to claim on
+     * the Spark network, and the refund transaction must be broadcasted on L1 to claim
+     * the funds. Returns an error if the UTXO has already been claimed.
+     */
+    initiate_static_deposit_utxo_refund(request: DeepPartial$2<InitiateStaticDepositUtxoRefundRequest>, options?: CallOptions & CallOptionsExt): Promise<InitiateStaticDepositUtxoRefundResponse>;
+    /**
+     * DEPRECATED: This unified method is being split for better clarity and type safety
+     *
+     * For swap operations: Use spark_ssp_internal.initiate_static_deposit_utxo_swap()
+     * For refund operations: Use initiate_static_deposit_utxo_refund()
+     *
+     * @deprecated
+     */
     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>;
 }
@@ -1641,9 +1693,30 @@ type SigningCommitment = {
     binding: Uint8Array;
     hiding: Uint8Array;
 };
+declare enum KeyDerivationType {
+    LEAF = "leaf",
+    DEPOSIT = "deposit",
+    STATIC_DEPOSIT = "static_deposit",
+    ECIES = "ecies",
+    RANDOM = "random"
+}
+type KeyDerivation = {
+    type: KeyDerivationType.LEAF;
+    path: string;
+} | {
+    type: KeyDerivationType.DEPOSIT;
+} | {
+    type: KeyDerivationType.RANDOM;
+} | {
+    type: KeyDerivationType.STATIC_DEPOSIT;
+    path: number;
+} | {
+    type: KeyDerivationType.ECIES;
+    path: Uint8Array;
+};
 type SignFrostParams = {
     message: Uint8Array;
-    privateAsPubKey: Uint8Array;
+    keyDerivation: KeyDerivation;
     publicKey: Uint8Array;
     verifyingKey: Uint8Array;
     selfCommitment: ISigningCommitment;
@@ -1652,7 +1725,7 @@ type SignFrostParams = {
     } | undefined;
     adaptorPubKey?: Uint8Array | undefined;
 };
-type AggregateFrostParams = Omit<SignFrostParams, "privateAsPubKey"> & {
+type AggregateFrostParams = Omit<SignFrostParams, "keyDerivation"> & {
     selfSignature: Uint8Array;
     statechainSignatures?: {
         [key: string]: Uint8Array;
@@ -1666,7 +1739,6 @@ type SplitSecretWithProofsParams = {
     curveOrder: bigint;
     threshold: number;
     numShares: number;
-    isSecretPubkey?: boolean;
 };
 type DerivedHDKey = {
     hdKey: HDKey;
@@ -1687,17 +1759,283 @@ declare function createSigningCommitment(binding: Uint8Array, hiding: Uint8Array
 declare function encodeSigningCommitmentToBytes(commitment: SigningCommitment): Uint8Array;
 declare function decodeBytesToSigningCommitment(bytes: Uint8Array): SigningCommitment;
 
-type HumanReadableTokenIdentifier = `btk1${string}` | `btkrt1${string}` | `btkt1${string}` | `btks1${string}` | `btkl1${string}`;
-interface HumanReadableTokenIdentifierData {
+type Bech32mTokenIdentifier = `btk1${string}` | `btkrt1${string}` | `btkt1${string}` | `btks1${string}` | `btkl1${string}`;
+interface Bech32mTokenIdentifierData {
     tokenIdentifier: Uint8Array;
     network: NetworkType;
 }
-declare function encodeHumanReadableTokenIdentifier(payload: HumanReadableTokenIdentifierData): HumanReadableTokenIdentifier;
-declare function decodeHumanReadableTokenIdentifier(humanReadableTokenIdentifier: HumanReadableTokenIdentifier, network: NetworkType): HumanReadableTokenIdentifierData;
+declare function encodeBech32mTokenIdentifier(payload: Bech32mTokenIdentifierData): Bech32mTokenIdentifier;
+declare function decodeBech32mTokenIdentifier(bech32mTokenIdentifier: Bech32mTokenIdentifier, network: NetworkType): Bech32mTokenIdentifierData;
+
+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.
+ */
+interface TokenOutputToSpend {
+    prevTokenTransactionHash: Uint8Array;
+    prevTokenTransactionVout: number;
+}
+declare const TokenOutputToSpend: MessageFns$1<TokenOutputToSpend>;
+interface TokenTransferInput {
+    outputsToSpend: TokenOutputToSpend[];
+}
+declare const TokenTransferInput: MessageFns$1<TokenTransferInput>;
+interface TokenMintInput {
+    issuerPublicKey: Uint8Array;
+    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
+ * remain unfilled so that the SE can fill them as part of the
+ * StartTokenTransaction() call.
+ */
+interface TokenOutput {
+    id?: string | undefined;
+    ownerPublicKey: Uint8Array;
+    revocationCommitment?: Uint8Array | undefined;
+    withdrawBondSats?: number | undefined;
+    withdrawRelativeBlockLocktime?: number | undefined;
+    tokenPublicKey?: Uint8Array | undefined;
+    tokenIdentifier?: Uint8Array | undefined;
+    /** Decoded uint128 */
+    tokenAmount: Uint8Array;
+}
+declare const TokenOutput: MessageFns$1<TokenOutput>;
+/**
+ * This proto is constructed by the wallet and is the core transaction data
+ * structure. This proto is deterministically hashed to generate the
+ * token_transaction_hash that is cooperatively signed by the SO group to
+ * confirm a token transaction.
+ */
+interface TokenTransaction {
+    /**
+     * 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.
+     */
+    version: number;
+    tokenInputs?: {
+        $case: "mintInput";
+        mintInput: TokenMintInput;
+    } | {
+        $case: "transferInput";
+        transferInput: TokenTransferInput;
+    } | {
+        $case: "createInput";
+        createInput: TokenCreateInput;
+    } | undefined;
+    tokenOutputs: TokenOutput[];
+    sparkOperatorIdentityPublicKeys: Uint8Array[];
+    /**
+     * Server-set expiry time. The server calculates this by adding the client's
+     * requested validity_duration_seconds to the server's current time when
+     * creating the final transaction.
+     */
+    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 {
+    /**
+     * This is a Schnorr or ECDSA DER signature which can be between 64 and 73
+     * bytes.
+     */
+    signature: Uint8Array;
+    /** The index of the TTXO associated with this signature. */
+    inputIndex: number;
+}
+declare const SignatureWithIndex: MessageFns$1<SignatureWithIndex>;
+/**
+ * A group of signatures for the input TTXOs binding them to the final token
+ * transaction hash. This bundle of signatures is specific to a given operator.
+ */
+interface InputTtxoSignaturesPerOperator {
+    ttxoSignatures: SignatureWithIndex[];
+    operatorIdentityPublicKey: Uint8Array;
+}
+declare const InputTtxoSignaturesPerOperator: MessageFns$1<InputTtxoSignaturesPerOperator>;
+/** === Start Transaction === */
+interface StartTransactionRequest {
+    identityPublicKey: Uint8Array;
+    partialTokenTransaction: TokenTransaction | undefined;
+    /**
+     * 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 transfer transactions this
+     * will be one for each output for the output owner_public_key
+     */
+    partialTokenTransactionOwnerSignatures: SignatureWithIndex[];
+    /**
+     * 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 within [1, 300] seconds.
+     */
+    validityDurationSeconds: number;
+}
+declare const StartTransactionRequest: MessageFns$1<StartTransactionRequest>;
+interface StartTransactionResponse {
+    finalTokenTransaction: TokenTransaction | undefined;
+    keyshareInfo: SigningKeyshare | undefined;
+}
+declare const StartTransactionResponse: MessageFns$1<StartTransactionResponse>;
+interface CommitTransactionRequest {
+    finalTokenTransaction: TokenTransaction | undefined;
+    finalTokenTransactionHash: Uint8Array;
+    inputTtxoSignaturesPerOperator: InputTtxoSignaturesPerOperator[];
+    ownerIdentityPublicKey: Uint8Array;
+}
+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 {
+    issuerPublicKey: Uint8Array;
+    tokenName: string;
+    tokenTicker: string;
+    decimals: number;
+    /** Decoded uint128 */
+    maxSupply: Uint8Array;
+    isFreezable: boolean;
+    creationEntityPublicKey?: Uint8Array | undefined;
+    tokenIdentifier: Uint8Array;
+}
+declare const TokenMetadata: MessageFns$1<TokenMetadata>;
+interface QueryTokenMetadataResponse {
+    tokenMetadata: TokenMetadata[];
+}
+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 | 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;
+    /**
+     * In rare cases the above reconstructed token transaction may not match the original token transaction due to:
+     * a) a pre-empted transfer transaction having its input TTXOs remapped to the newer transaction
+     * b) proto migrations or field deprecations resulting in missing/swapped fields (eg. token public key -> token identifier)
+     * Include the original hash to ensure clients can reconcile this transaction with the original if needed.
+     */
+    tokenTransactionHash: Uint8Array;
+}
+declare const TokenTransactionWithStatus: MessageFns$1<TokenTransactionWithStatus>;
+interface SparkTokenServiceClient<CallOptionsExt = {}> {
+    /**
+     * Start process to create final token transaction with all inputs required
+     * from user and SOs (including revocation secret commitment)
+     */
+    start_transaction(request: DeepPartial$1<StartTransactionRequest>, options?: CallOptions & CallOptionsExt): Promise<StartTransactionResponse>;
+    /**
+     * Complete the transaction and commit it with all SOs. This will be
+     * 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 {
+    $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial$1<T[K]>;
+} & {
+    $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial$1<T[K]>;
+} : Partial<T>;
+interface MessageFns$1<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial$1<T>): T;
+    fromPartial(object: DeepPartial$1<T>): T;
+}
 
 interface SparkKeysGenerator {
     deriveKeysFromSeed(seed: Uint8Array, accountNumber: number): Promise<{
-        masterPublicKey: Uint8Array;
         identityKey: KeyPair;
         signingHDKey: DerivedHDKey;
         depositKey: KeyPair;
@@ -1707,82 +2045,77 @@ interface SparkKeysGenerator {
 interface SparkSigner extends TokenSigner {
     getIdentityPublicKey(): Promise<Uint8Array>;
     getDepositSigningKey(): Promise<Uint8Array>;
-    generateStaticDepositKey(idx: number): Promise<Uint8Array>;
     getStaticDepositSigningKey(idx: number): Promise<Uint8Array>;
     getStaticDepositSecretKey(idx: number): Promise<Uint8Array>;
     generateMnemonic(): Promise<string>;
     mnemonicToSeed(mnemonic: string): Promise<Uint8Array>;
     createSparkWalletFromSeed(seed: Uint8Array | string, accountNumber?: number): Promise<string>;
-    restoreSigningKeysFromLeafs(leafs: TreeNode[]): Promise<void>;
-    getTrackedPublicKeys(): Promise<Uint8Array[]>;
-    generatePublicKey(hash?: Uint8Array): Promise<Uint8Array>;
-    removePublicKey(publicKey: Uint8Array): Promise<void>;
-    getSchnorrPublicKey(publicKey: Uint8Array): Promise<Uint8Array>;
-    signSchnorr(message: Uint8Array, publicKey: Uint8Array): Promise<Uint8Array>;
+    getPublicKeyFromDerivation(keyDerivation?: KeyDerivation): Promise<Uint8Array>;
     signSchnorrWithIdentityKey(message: Uint8Array): Promise<Uint8Array>;
-    subtractPrivateKeysGivenPublicKeys(first: Uint8Array, second: Uint8Array): Promise<Uint8Array>;
+    subtractPrivateKeysGivenDerivationPaths(first: string, second: string): Promise<Uint8Array>;
+    subtractAndSplitSecretWithProofsGivenDerivations(params: Omit<SplitSecretWithProofsParams, "secret"> & {
+        first: KeyDerivation;
+        second?: KeyDerivation | undefined;
+    }): Promise<VerifiableSecretShare[]>;
+    subtractSplitAndEncrypt(params: Omit<SplitSecretWithProofsParams, "secret"> & {
+        first: KeyDerivation;
+        second: KeyDerivation;
+        receiverPublicKey: Uint8Array;
+    }): Promise<{
+        shares: VerifiableSecretShare[];
+        secretCipher: Uint8Array;
+    }>;
     splitSecretWithProofs(params: SplitSecretWithProofsParams): Promise<VerifiableSecretShare[]>;
     signFrost(params: SignFrostParams): Promise<Uint8Array>;
     aggregateFrost(params: AggregateFrostParams): Promise<Uint8Array>;
-    signMessageWithPublicKey(message: Uint8Array, publicKey: Uint8Array, compact?: boolean): Promise<Uint8Array>;
     signMessageWithIdentityKey(message: Uint8Array, compact?: boolean): Promise<Uint8Array>;
     validateMessageWithIdentityKey(message: Uint8Array, signature: Uint8Array): Promise<boolean>;
     signTransactionIndex(tx: Transaction, index: number, publicKey: Uint8Array): void;
-    encryptLeafPrivateKeyEcies(receiverPublicKey: Uint8Array, publicKey: Uint8Array): Promise<Uint8Array>;
     decryptEcies(ciphertext: Uint8Array): Promise<Uint8Array>;
     getRandomSigningCommitment(): Promise<SigningCommitment>;
-    hashRandomPrivateKey(): Promise<Uint8Array>;
-    generateAdaptorFromSignature(signature: Uint8Array): Promise<{
-        adaptorSignature: Uint8Array;
-        adaptorPublicKey: Uint8Array;
-    }>;
     getDepositSigningKey(): Promise<Uint8Array>;
-    getMasterPublicKey(): Promise<Uint8Array>;
 }
 declare class DefaultSparkSigner implements SparkSigner {
-    private masterPublicKey;
     private identityKey;
     private signingKey;
     private depositKey;
     private staticDepositKey;
-    private staticDepositKeyMap;
-    protected publicKeyToPrivateKeyMap: Map<string, string>;
     protected commitmentToNonceMap: Map<SigningCommitment, SigningNonce>;
     private readonly keysGenerator;
     constructor({ sparkKeysGenerator, }?: {
         sparkKeysGenerator?: SparkKeysGenerator;
     });
     private deriveSigningKey;
-    restoreSigningKeysFromLeafs(leafs: TreeNode[]): Promise<void>;
-    getSchnorrPublicKey(publicKey: Uint8Array): Promise<Uint8Array>;
-    signSchnorr(message: Uint8Array, publicKey: Uint8Array): Promise<Uint8Array>;
+    private decryptEciesToPrivateKey;
+    protected getSigningPrivateKeyFromDerivation(keyDerivation: KeyDerivation): Promise<Uint8Array>;
     signSchnorrWithIdentityKey(message: Uint8Array): Promise<Uint8Array>;
     getIdentityPublicKey(): Promise<Uint8Array>;
     getDepositSigningKey(): Promise<Uint8Array>;
-    generateStaticDepositKey(idx: number): Promise<Uint8Array>;
     getStaticDepositSigningKey(idx: number): Promise<Uint8Array>;
     getStaticDepositSecretKey(idx: number): Promise<Uint8Array>;
     generateMnemonic(): Promise<string>;
     mnemonicToSeed(mnemonic: string): Promise<Uint8Array>;
-    getTrackedPublicKeys(): Promise<Uint8Array[]>;
-    generatePublicKey(hash?: Uint8Array): Promise<Uint8Array>;
-    removePublicKey(publicKey: Uint8Array): Promise<void>;
-    subtractPrivateKeysGivenPublicKeys(first: Uint8Array, second: Uint8Array): Promise<Uint8Array>;
-    splitSecretWithProofs({ secret, curveOrder, threshold, numShares, isSecretPubkey, }: SplitSecretWithProofsParams): Promise<VerifiableSecretShare[]>;
-    signFrost({ message, privateAsPubKey, publicKey, verifyingKey, selfCommitment, statechainCommitments, adaptorPubKey, }: SignFrostParams): Promise<Uint8Array>;
+    getPublicKeyFromDerivation(keyDerivation: KeyDerivation): Promise<Uint8Array>;
+    subtractPrivateKeysGivenDerivationPaths(first: string, second: string): Promise<Uint8Array>;
+    subtractAndSplitSecretWithProofsGivenDerivations({ first, second, curveOrder, threshold, numShares, }: Omit<SplitSecretWithProofsParams, "secret"> & {
+        first: KeyDerivation;
+        second: KeyDerivation;
+    }): Promise<VerifiableSecretShare[]>;
+    subtractSplitAndEncrypt({ first, second, curveOrder, threshold, numShares, receiverPublicKey, }: Omit<SplitSecretWithProofsParams, "secret"> & {
+        first: KeyDerivation;
+        second: KeyDerivation;
+        receiverPublicKey: Uint8Array;
+    }): Promise<{
+        shares: VerifiableSecretShare[];
+        secretCipher: Uint8Array;
+    }>;
+    splitSecretWithProofs({ secret, curveOrder, threshold, numShares, }: SplitSecretWithProofsParams): Promise<VerifiableSecretShare[]>;
+    signFrost({ message, keyDerivation, publicKey, verifyingKey, selfCommitment, statechainCommitments, adaptorPubKey, }: SignFrostParams): Promise<Uint8Array>;
     aggregateFrost({ message, publicKey, verifyingKey, selfCommitment, statechainCommitments, adaptorPubKey, selfSignature, statechainSignatures, statechainPublicKeys, }: AggregateFrostParams): Promise<Uint8Array>;
     createSparkWalletFromSeed(seed: Uint8Array | string, accountNumber?: number): Promise<string>;
-    signMessageWithPublicKey(message: Uint8Array, publicKey: Uint8Array, compact?: boolean): Promise<Uint8Array>;
     signMessageWithIdentityKey(message: Uint8Array, compact?: boolean): Promise<Uint8Array>;
-    encryptLeafPrivateKeyEcies(receiverPublicKey: Uint8Array, publicKey: Uint8Array): Promise<Uint8Array>;
     decryptEcies(ciphertext: Uint8Array): Promise<Uint8Array>;
     getRandomSigningCommitment(): Promise<SigningCommitment>;
-    hashRandomPrivateKey(): Promise<Uint8Array>;
-    generateAdaptorFromSignature(signature: Uint8Array): Promise<{
-        adaptorSignature: Uint8Array;
-        adaptorPublicKey: Uint8Array;
-    }>;
-    getMasterPublicKey(): Promise<Uint8Array>;
     validateMessageWithIdentityKey(message: Uint8Array, signature: Uint8Array): Promise<boolean>;
     signPsbt(psbt: Psbt, input: number, sighashTypes?: number[], receipt?: Receipt): Promise<Psbt>;
     private getReceiptPrivateKey;
@@ -2392,7 +2725,7 @@ type TransferParams = {
     receiverSparkAddress: string;
 };
 type DepositParams = {
-    signingPubKey: Uint8Array;
+    keyDerivation: KeyDerivation;
     verifyingKey: Uint8Array;
     depositTx: Transaction;
     vout: number;
@@ -2401,7 +2734,7 @@ type DepositParams = {
  * 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.
+ * rawTokenIdentifier: This is the raw binary token identifier - This is used to encode the bech32m encoded token identifier.
  *
  * tokenPublicKey: This is the hex-encoded public key of the token issuer - Same as issuerPublicKey.
  *
@@ -2431,10 +2764,15 @@ type UserTokenMetadata = {
     /** Maximum supply of tokens that can ever be minted */
     maxSupply: bigint;
 };
-type TokenBalanceMap = Map<HumanReadableTokenIdentifier, {
+type TokenBalanceMap = Map<Bech32mTokenIdentifier, {
     balance: bigint;
     tokenMetadata: UserTokenMetadata;
 }>;
+type RawTokenIdentifierHex = string & {
+    readonly __brand: "RawTokenIdentifierHex";
+};
+type TokenOutputsMap = Map<Bech32mTokenIdentifier, OutputWithPreviousTransactionData$1[]>;
+type TokenMetadataMap = Map<Bech32mTokenIdentifier, TokenMetadata>;
 type InitWalletResponse = {
     mnemonic?: string | undefined;
 };
@@ -2458,7 +2796,7 @@ interface SparkWalletEvents {
 }
 
 declare function sumAvailableTokens(outputs: OutputWithPreviousTransactionData$1[]): bigint;
-declare function checkIfSelectedOutputsAreAvailable(selectedOutputs: OutputWithPreviousTransactionData$1[], tokenOutputs: Map<string, OutputWithPreviousTransactionData$1[]>, tokenPublicKey: Uint8Array): boolean;
+declare function checkIfSelectedOutputsAreAvailable(selectedOutputs: OutputWithPreviousTransactionData$1[], tokenOutputs: TokenOutputsMap, tokenIdentifier: Bech32mTokenIdentifier): boolean;
 declare function filterTokenBalanceForTokenPublicKey(tokenBalances: TokenBalanceMap, publicKey: string): {
     balance: bigint;
 };
@@ -2533,7 +2871,7 @@ declare function constructFeeBumpTx(txHex: string, utxos: Utxo[], feeRate: FeeRa
 declare function getSparkAddressFromTaproot(taprootAddress: string): SparkAddressFormat;
 
 declare class ReactNativeSparkSigner extends DefaultSparkSigner {
-    signFrost({ message, privateAsPubKey, publicKey, verifyingKey, selfCommitment, statechainCommitments, adaptorPubKey, }: SignFrostParams): Promise<Uint8Array>;
+    signFrost({ message, keyDerivation, publicKey, verifyingKey, selfCommitment, statechainCommitments, adaptorPubKey, }: SignFrostParams): Promise<Uint8Array>;
     aggregateFrost({ message, publicKey, verifyingKey, selfCommitment, statechainCommitments, adaptorPubKey, selfSignature, statechainSignatures, statechainPublicKeys, }: AggregateFrostParams): Promise<Uint8Array>;
 }
 
@@ -2571,280 +2909,27 @@ declare enum InterruptTransferRequest_InterruptTransferAction {
 interface CleanUpPreimageShareRequest {
     paymentHash: Uint8Array;
 }
-declare const CleanUpPreimageShareRequest: MessageFns$1<CleanUpPreimageShareRequest>;
+declare const CleanUpPreimageShareRequest: MessageFns<CleanUpPreimageShareRequest>;
 interface InterruptTransferRequest {
     action: InterruptTransferRequest_InterruptTransferAction;
 }
-declare const InterruptTransferRequest: MessageFns$1<InterruptTransferRequest>;
+declare const InterruptTransferRequest: MessageFns<InterruptTransferRequest>;
 interface UpdateNodesStatusRequest {
     nodeIds: string[];
     status: string;
 }
-declare const UpdateNodesStatusRequest: MessageFns$1<UpdateNodesStatusRequest>;
-interface MockServiceClient<CallOptionsExt = {}> {
-    clean_up_preimage_share(request: DeepPartial$1<CleanUpPreimageShareRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
-    interrupt_transfer(request: DeepPartial$1<InterruptTransferRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
-    update_nodes_status(request: DeepPartial$1<UpdateNodesStatusRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
-}
-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 {
-    $case: string;
-} ? {
-    [K in keyof Omit<T, "$case">]?: DeepPartial$1<T[K]>;
-} & {
-    $case: T["$case"];
-} : T extends {} ? {
-    [K in keyof T]?: DeepPartial$1<T[K]>;
-} : Partial<T>;
-interface MessageFns$1<T> {
-    encode(message: T, writer?: BinaryWriter): BinaryWriter;
-    decode(input: BinaryReader | Uint8Array, length?: number): T;
-    fromJSON(object: any): T;
-    toJSON(message: T): unknown;
-    create(base?: DeepPartial$1<T>): T;
-    fromPartial(object: DeepPartial$1<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.
- */
-interface TokenOutputToSpend {
-    prevTokenTransactionHash: Uint8Array;
-    prevTokenTransactionVout: number;
-}
-declare const TokenOutputToSpend: MessageFns<TokenOutputToSpend>;
-interface TokenTransferInput {
-    outputsToSpend: TokenOutputToSpend[];
-}
-declare const TokenTransferInput: MessageFns<TokenTransferInput>;
-interface TokenMintInput {
-    issuerPublicKey: Uint8Array;
-    tokenIdentifier?: Uint8Array | undefined;
-}
-declare const TokenMintInput: MessageFns<TokenMintInput>;
-interface TokenCreateInput {
-    issuerPublicKey: Uint8Array;
-    tokenName: string;
-    tokenTicker: string;
-    decimals: number;
-    /** Decoded uint128 */
-    maxSupply: Uint8Array;
-    isFreezable: boolean;
-    creationEntityPublicKey?: Uint8Array | undefined;
-}
-declare const TokenCreateInput: MessageFns<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
- * remain unfilled so that the SE can fill them as part of the
- * StartTokenTransaction() call.
- */
-interface TokenOutput {
-    id?: string | undefined;
-    ownerPublicKey: Uint8Array;
-    revocationCommitment?: Uint8Array | undefined;
-    withdrawBondSats?: number | undefined;
-    withdrawRelativeBlockLocktime?: number | undefined;
-    tokenPublicKey?: Uint8Array | undefined;
-    tokenIdentifier?: Uint8Array | undefined;
-    /** Decoded uint128 */
-    tokenAmount: Uint8Array;
-}
-declare const TokenOutput: MessageFns<TokenOutput>;
-/**
- * This proto is constructed by the wallet and is the core transaction data
- * structure. This proto is deterministically hashed to generate the
- * token_transaction_hash that is cooperatively signed by the SO group to
- * confirm a token transaction.
- */
-interface TokenTransaction {
-    /**
-     * 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.
-     */
-    version: number;
-    tokenInputs?: {
-        $case: "mintInput";
-        mintInput: TokenMintInput;
-    } | {
-        $case: "transferInput";
-        transferInput: TokenTransferInput;
-    } | {
-        $case: "createInput";
-        createInput: TokenCreateInput;
-    } | undefined;
-    tokenOutputs: TokenOutput[];
-    sparkOperatorIdentityPublicKeys: Uint8Array[];
-    /**
-     * Server-set expiry time. The server calculates this by adding the client's
-     * requested validity_duration_seconds to the server's current time when
-     * creating the final transaction.
-     */
-    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 UpdateNodesStatusRequest: MessageFns<UpdateNodesStatusRequest>;
+/** TriggerTaskRequest is used to trigger a scheduled task immediately in hermetic tests. */
+interface TriggerTaskRequest {
+    taskName: string;
 }
-declare const TokenTransaction: MessageFns<TokenTransaction>;
-interface SignatureWithIndex {
-    /**
-     * This is a Schnorr or ECDSA DER signature which can be between 64 and 73
-     * bytes.
-     */
-    signature: Uint8Array;
-    /** The index of the TTXO associated with this signature. */
-    inputIndex: number;
-}
-declare const SignatureWithIndex: MessageFns<SignatureWithIndex>;
-/**
- * A group of signatures for the input TTXOs binding them to the final token
- * transaction hash. This bundle of signatures is specific to a given operator.
- */
-interface InputTtxoSignaturesPerOperator {
-    ttxoSignatures: SignatureWithIndex[];
-    operatorIdentityPublicKey: Uint8Array;
-}
-declare const InputTtxoSignaturesPerOperator: MessageFns<InputTtxoSignaturesPerOperator>;
-/** === Start Transaction === */
-interface StartTransactionRequest {
-    identityPublicKey: Uint8Array;
-    partialTokenTransaction: TokenTransaction | undefined;
-    /**
-     * 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 transfer transactions this
-     * will be one for each output for the output owner_public_key
-     */
-    partialTokenTransactionOwnerSignatures: SignatureWithIndex[];
-    /**
-     * 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 within [1, 300] seconds.
-     */
-    validityDurationSeconds: number;
-}
-declare const StartTransactionRequest: MessageFns<StartTransactionRequest>;
-interface StartTransactionResponse {
-    finalTokenTransaction: TokenTransaction | undefined;
-    keyshareInfo: SigningKeyshare | undefined;
-}
-declare const StartTransactionResponse: MessageFns<StartTransactionResponse>;
-interface CommitTransactionRequest {
-    finalTokenTransaction: TokenTransaction | undefined;
-    finalTokenTransactionHash: Uint8Array;
-    inputTtxoSignaturesPerOperator: InputTtxoSignaturesPerOperator[];
-    ownerIdentityPublicKey: Uint8Array;
-}
-declare const CommitTransactionRequest: MessageFns<CommitTransactionRequest>;
-interface CommitTransactionResponse {
-}
-declare const CommitTransactionResponse: MessageFns<CommitTransactionResponse>;
-interface QueryTokenMetadataRequest {
-    tokenIdentifiers: Uint8Array[];
-    issuerPublicKeys: Uint8Array[];
-}
-declare const QueryTokenMetadataRequest: MessageFns<QueryTokenMetadataRequest>;
-interface TokenMetadata {
-    issuerPublicKey: Uint8Array;
-    tokenName: string;
-    tokenTicker: string;
-    decimals: number;
-    /** Decoded uint128 */
-    maxSupply: Uint8Array;
-    isFreezable: boolean;
-    creationEntityPublicKey?: Uint8Array | undefined;
-    tokenIdentifier: Uint8Array;
-}
-declare const TokenMetadata: MessageFns<TokenMetadata>;
-interface QueryTokenMetadataResponse {
-    tokenMetadata: TokenMetadata[];
-}
-declare const QueryTokenMetadataResponse: MessageFns<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<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<QueryTokenTransactionsRequest>;
-interface QueryTokenTransactionsResponse {
-    tokenTransactionsWithStatus: TokenTransactionWithStatus[];
-    offset: number;
-}
-declare const QueryTokenTransactionsResponse: MessageFns<QueryTokenTransactionsResponse>;
-interface OutputWithPreviousTransactionData {
-    output: TokenOutput | undefined;
-    previousTransactionHash: Uint8Array;
-    previousTransactionVout: number;
-}
-declare const OutputWithPreviousTransactionData: MessageFns<OutputWithPreviousTransactionData>;
-interface QueryTokenOutputsResponse {
-    outputsWithPreviousTransactionData: OutputWithPreviousTransactionData[];
-}
-declare const QueryTokenOutputsResponse: MessageFns<QueryTokenOutputsResponse>;
-interface SpentTokenOutputMetadata {
-    outputId: string;
-    revocationSecret: Uint8Array;
-}
-declare const SpentTokenOutputMetadata: MessageFns<SpentTokenOutputMetadata>;
-interface TokenTransactionConfirmationMetadata {
-    spentTokenOutputsMetadata: SpentTokenOutputMetadata[];
-}
-declare const TokenTransactionConfirmationMetadata: MessageFns<TokenTransactionConfirmationMetadata>;
-interface TokenTransactionWithStatus {
-    tokenTransaction: TokenTransaction | undefined;
-    status: TokenTransactionStatus;
-    confirmationMetadata: TokenTransactionConfirmationMetadata | undefined;
-}
-declare const TokenTransactionWithStatus: MessageFns<TokenTransactionWithStatus>;
-interface SparkTokenServiceClient<CallOptionsExt = {}> {
-    /**
-     * Start process to create final token transaction with all inputs required
-     * from user and SOs (including revocation secret commitment)
-     */
-    start_transaction(request: DeepPartial<StartTransactionRequest>, options?: CallOptions & CallOptionsExt): Promise<StartTransactionResponse>;
-    /**
-     * Complete the transaction and commit it with all SOs. This will be
-     * coordinated by one SO.
-     */
-    commit_transaction(request: DeepPartial<CommitTransactionRequest>, options?: CallOptions & CallOptionsExt): Promise<CommitTransactionResponse>;
-    query_token_metadata(request: DeepPartial<QueryTokenMetadataRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryTokenMetadataResponse>;
-    query_token_transactions(request: DeepPartial<QueryTokenTransactionsRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryTokenTransactionsResponse>;
-    query_token_outputs(request: DeepPartial<QueryTokenOutputsRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryTokenOutputsResponse>;
+declare const TriggerTaskRequest: MessageFns<TriggerTaskRequest>;
+interface MockServiceClient<CallOptionsExt = {}> {
+    clean_up_preimage_share(request: DeepPartial<CleanUpPreimageShareRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
+    interrupt_transfer(request: DeepPartial<InterruptTransferRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
+    update_nodes_status(request: DeepPartial<UpdateNodesStatusRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
+    /** Triggers the execution of a scheduled task immediately by name. Used by hermetic tests */
+    trigger_task(request: DeepPartial<TriggerTaskRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
 }
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
@@ -2906,18 +2991,18 @@ declare class SigningService {
 
 type LeafKeyTweak = {
     leaf: TreeNode;
-    signingPubKey: Uint8Array;
-    newSigningPubKey: Uint8Array;
+    keyDerivation: KeyDerivation;
+    newKeyDerivation: KeyDerivation;
 };
 type ClaimLeafData = {
-    signingPubKey: Uint8Array;
+    keyDerivation: KeyDerivation;
     tx?: Transaction;
     refundTx?: Transaction;
     signingNonceCommitment: SigningCommitment;
     vout?: number;
 };
 type LeafRefundSigningData = {
-    signingPubKey: Uint8Array;
+    keyDerivation: KeyDerivation;
     receivingPubkey: Uint8Array;
     tx: Transaction;
     refundTx?: Transaction;
@@ -2982,9 +3067,9 @@ 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, signingPubKey: Uint8Array): Promise<FinalizeNodeSignaturesResponse>;
-    extendTimelock(node: TreeNode, signingPubKey: Uint8Array): Promise<FinalizeNodeSignaturesResponse>;
-    refreshTimelockRefundTx(node: TreeNode, signingPubKey: Uint8Array): Promise<FinalizeNodeSignaturesResponse>;
+    refreshTimelockNodes(nodes: TreeNode[], parentNode: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
+    extendTimelock(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
+    refreshTimelockRefundTx(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
 }
 
 interface WalletLeaf {
@@ -3051,8 +3136,8 @@ declare class SparkWallet extends EventEmitter {
     private sparkAddress;
     private streamController;
     protected leaves: TreeNode[];
-    protected tokenOutputs: Map<string, OutputWithPreviousTransactionData$1[]>;
-    protected tokenMetadata: Map<string, TokenMetadata>;
+    protected tokenMetadata: TokenMetadataMap;
+    protected tokenOutputs: TokenOutputsMap;
     private claimTransfersInterval;
     protected wrapWithOtelSpan<T>(name: string, fn: (...args: any[]) => Promise<T>): (...args: any[]) => Promise<T>;
     protected constructor(options?: ConfigOptions, signer?: SparkSigner);
@@ -3150,7 +3235,7 @@ declare class SparkWallet extends EventEmitter {
      *
      * @returns {Promise<Object>} Object containing:
      *   - balance: The wallet's current balance in satoshis
-     *   - tokenBalances: Map of the human readable token identifier to token balances and token info
+     *   - tokenBalances: Map of the bech32m encodedtoken identifier to token balances and token info
      */
     getBalance(): Promise<{
         balance: bigint;
@@ -3438,8 +3523,8 @@ declare class SparkWallet extends EventEmitter {
      * @param {OutputWithPreviousTransactionData[]} [params.selectedOutputs] - Optional specific leaves to use for the transfer
      * @returns {Promise<string>} The transaction ID of the token transfer
      */
-    transferTokens({ tokenPublicKey, tokenAmount, receiverSparkAddress, outputSelectionStrategy, selectedOutputs, }: {
-        tokenPublicKey: string;
+    transferTokens({ tokenIdentifier, tokenAmount, receiverSparkAddress, outputSelectionStrategy, selectedOutputs, }: {
+        tokenIdentifier: Bech32mTokenIdentifier;
         tokenAmount: bigint;
         receiverSparkAddress: string;
         outputSelectionStrategy?: "SMALL_FIRST" | "LARGE_FIRST";
@@ -3456,7 +3541,7 @@ declare class SparkWallet extends EventEmitter {
      * @returns {Promise<string[]>} Array of transaction IDs for the token transfers
      */
     batchTransferTokens(receiverOutputs: {
-        tokenPublicKey: string;
+        tokenIdentifier: Bech32mTokenIdentifier;
         tokenAmount: bigint;
         receiverSparkAddress: string;
     }[], outputSelectionStrategy?: "SMALL_FIRST" | "LARGE_FIRST", selectedOutputs?: OutputWithPreviousTransactionData$1[]): Promise<string>;
@@ -3575,8 +3660,8 @@ declare class TokenTransactionService {
     protected readonly config: WalletConfigService;
     protected readonly connectionManager: ConnectionManager;
     constructor(config: WalletConfigService, connectionManager: ConnectionManager);
-    tokenTransfer(tokenOutputs: Map<string, OutputWithPreviousTransactionData$1[]>, receiverOutputs: {
-        tokenPublicKey: string;
+    tokenTransfer(tokenOutputs: TokenOutputsMap, receiverOutputs: {
+        tokenIdentifier: Bech32mTokenIdentifier;
         tokenAmount: bigint;
         receiverSparkAddress: string;
     }[], outputSelectionStrategy?: "SMALL_FIRST" | "LARGE_FIRST", selectedOutputs?: OutputWithPreviousTransactionData$1[]): Promise<string>;
@@ -3587,7 +3672,7 @@ declare class TokenTransactionService {
     }>): Promise<TokenTransaction$1>;
     constructTransferTokenTransaction(selectedOutputs: OutputWithPreviousTransactionData$1[], tokenOutputData: Array<{
         receiverSparkAddress: Uint8Array;
-        tokenPublicKey: Uint8Array;
+        rawTokenIdentifier: Uint8Array;
         tokenAmount: bigint;
     }>): Promise<TokenTransaction>;
     collectOperatorIdentityPublicKeys(): Uint8Array[];
@@ -3604,7 +3689,6 @@ declare class TokenTransactionService {
     private fetchOwnedTokenOutputsV1;
     private queryTokenTransactionsV0;
     private queryTokenTransactionsV1;
-    syncTokenOutputs(tokenOutputs: Map<string, OutputWithPreviousTransactionData$1[]>): Promise<void>;
     selectTokenOutputs(tokenOutputs: OutputWithPreviousTransactionData$1[], tokenAmount: bigint, strategy: "SMALL_FIRST" | "LARGE_FIRST"): OutputWithPreviousTransactionData$1[];
     private sortTokenOutputsByStrategy;
     private signMessageWithKey;
@@ -3612,4 +3696,4 @@ declare class TokenTransactionService {
     private createSignaturesForOperators;
 }
 
-export { AuthenticationError, 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 HumanReadableTokenIdentifier, type HumanReadableTokenIdentifierData, type InitWalletResponse, InternalValidationError, LRC_WALLET_NETWORK, LRC_WALLET_NETWORK_TYPE, type LeafInfo, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, type PayLightningInvoiceParams, RPCError, ReactNativeSparkSigner, type SparkAddressData, type SparkAddressFormat, SparkSDKError, SparkWallet, type SparkWalletEvents, type SparkWalletProps, type TokenBalanceMap, 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, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, decodeHumanReadableTokenIdentifier, decodeSparkAddress, encodeHumanReadableTokenIdentifier, 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, 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 };