@buildonspark/spark-sdk 0.2.13 → 0.3.0

package/dist/{spark-wallet-D0Df_P_x.d.ts → spark-wallet-DW0_1REx.d.ts}

@@ -1,5 +1,5 @@
-import { B as BitcoinNetwork, M as MayHaveSspClientOptions, t as SspClientOptions, H as HasSspClientOptions, S as SparkSigner, l as KeyDerivation, i as SigningCommitmentWithOptionalNonce, V as VerifiableSecretShare, L as LeavesSwapFeeEstimateOutput, u as StaticDepositQuoteOutput, C as ClaimStaticDepositOutput, W as WalletLeaf, w as WalletTransfer, x as LightningReceiveRequest, y as LightningSendRequest, z as LightningSendFeeEstimateInput, E as ExitSpeed, F as CoopExitFeeQuote, G as CoopExitRequest, I as TransferWithUserRequest } from './client-D7KDa4Ih.js';
-import { N as Network$1, E as Empty, c as SparkServiceClient, R as RequestedSigningCommitments, U as UserSignedTxSigningJob, b as TreeNode, a as Transfer, L as LeafRefundTxSigningResult, d as NodeSignatures, F as FinalizeNodeSignaturesResponse, Q as QueryTransfersResponse, e as SparkInvoiceFields, O as OutputWithPreviousTransactionData } from './spark-C7OG9mGJ.js';
+import { B as BitcoinNetwork, M as MayHaveSspClientOptions, t as SspClientOptions, H as HasSspClientOptions, S as SparkSigner, l as KeyDerivation, i as SigningCommitmentWithOptionalNonce, V as VerifiableSecretShare, W as WalletTransfer, L as LeavesSwapFeeEstimateOutput, u as StaticDepositQuoteOutput, C as ClaimStaticDepositOutput, w as WalletLeaf, x as LightningReceiveRequest, y as LightningSendRequest, z as LightningSendFeeEstimateInput, E as ExitSpeed, F as CoopExitFeeQuote, G as CoopExitRequest, I as TransferWithUserRequest } from './client-DrjQwET9.js';
+import { N as Network$1, E as Empty, d as SparkServiceClient, e as SparkInvoiceFields, R as RequestedSigningCommitments, U as UserSignedTxSigningJob, c as TreeNode, b as Transfer, L as LeafRefundTxSigningResult, f as NodeSignatures, F as FinalizeNodeSignaturesResponse, Q as QueryTransfersResponse, O as OutputWithPreviousTransactionData } from './spark-CLz4-Ln8.js';
 import { SparkTokenServiceClient, TokenMetadata, QueryTokenTransactionsResponse } from './proto/spark_token.js';
 import * as btc from '@scure/btc-signer';
 import { Transaction } from '@scure/btc-signer';
@@ -8,9 +8,9 @@ import { Channel } from 'nice-grpc';
 import { Channel as Channel$1 } from 'nice-grpc-web';
 import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
 import { CallOptions } from 'nice-grpc-common';
+import * as _scure_base from '@scure/base';
 import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
 import { EventEmitter } from 'eventemitter3';
-import * as _scure_base from '@scure/base';
 
 declare enum Network {
     MAINNET = 0,
@@ -199,6 +199,53 @@ declare class ConnectionManager {
     private createGrpcClient;
 }
 
+declare const AddressNetwork: Record<NetworkType, string>;
+declare const LegacyAddressNetwork: Record<NetworkType, string>;
+type Bech32String = `${string}1${string}`;
+type SparkAddressFormat = `${(typeof AddressNetwork)[keyof typeof AddressNetwork]}1${string}`;
+type LegacySparkAddressFormat = `${(typeof LegacyAddressNetwork)[keyof typeof LegacyAddressNetwork]}1${string}`;
+interface SparkAddressData {
+    identityPublicKey: string;
+    network: NetworkType;
+    sparkInvoiceFields?: SparkInvoiceFields;
+}
+interface DecodedSparkAddressData {
+    identityPublicKey: string;
+    network: NetworkType;
+    sparkInvoiceFields?: {
+        version: number;
+        id: string;
+        paymentType?: {
+            type: "tokens";
+            tokenIdentifier?: string;
+            amount?: bigint;
+        } | {
+            type: "sats";
+            amount?: number;
+        };
+        memo?: string;
+        senderPublicKey?: string;
+        expiryTime?: Date;
+    };
+    signature?: string;
+}
+declare function encodeSparkAddress(payload: SparkAddressData): SparkAddressFormat;
+declare function encodeSparkAddressWithSignature(payload: SparkAddressData, signature?: Uint8Array): SparkAddressFormat;
+declare function decodeSparkAddress(address: string, network: NetworkType): DecodedSparkAddressData;
+declare function getNetworkFromSparkAddress(address: string): NetworkType;
+declare function isLegacySparkAddress(address: string): address is LegacySparkAddressFormat;
+declare function isValidSparkAddress(address: string): boolean;
+declare function isValidPublicKey(publicKey: string): void;
+declare function validateSparkInvoiceFields(sparkInvoiceFields: SparkInvoiceFields): void;
+declare function validateSparkInvoiceSignature(invoice: SparkAddressFormat): void;
+declare function toProtoTimestamp(date: Date): {
+    seconds: number;
+    nanos: number;
+};
+declare function assertBech32(s: string): asserts s is Bech32String;
+declare function bech32mDecode(address: string): _scure_base.Bech32Decoded<string>;
+declare function isSafeForNumber(bi: bigint): boolean;
+
 declare class SigningService {
     private readonly config;
     constructor(config: WalletConfigService);
@@ -235,7 +282,7 @@ declare class BaseTransferService {
     constructor(config: WalletConfigService, connectionManager: ConnectionManager, signingService: SigningService);
     sendTransferTweakKey(transfer: Transfer, leaves: LeafKeyTweak[], cpfpRefundSignatureMap: Map<string, Uint8Array>, directRefundSignatureMap: Map<string, Uint8Array>, directFromCpfpRefundSignatureMap: Map<string, Uint8Array>): Promise<Transfer>;
     deliverTransferPackage(transfer: Transfer, leaves: LeafKeyTweak[], cpfpRefundSignatureMap: Map<string, Uint8Array>, directRefundSignatureMap: Map<string, Uint8Array>, directFromCpfpRefundSignatureMap: Map<string, Uint8Array>): Promise<Transfer>;
-    sendTransferWithKeyTweaks(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array): Promise<Transfer>;
+    sendTransferWithKeyTweaks(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, sparkInvoice?: SparkAddressFormat): Promise<Transfer>;
     private prepareTransferPackage;
     private finalizeTransfer;
     signRefunds(leafDataMap: Map<string, LeafRefundSigningData>, operatorSigningResults: LeafRefundTxSigningResult[], cpfpAdaptorPubKey?: Uint8Array, directAdaptorPubKey?: Uint8Array, directFromCpfpAdaptorPubKey?: Uint8Array): Promise<NodeSignatures[]>;
@@ -300,47 +347,6 @@ declare class TransferService extends BaseTransferService {
     testonly_expireTimeLockRefundtx(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
 }
 
-declare const AddressNetwork: Record<NetworkType, string>;
-type SparkAddressFormat = `${(typeof AddressNetwork)[keyof typeof AddressNetwork]}1${string}`;
-interface SparkAddressData {
-    identityPublicKey: string;
-    network: NetworkType;
-    sparkInvoiceFields?: SparkInvoiceFields;
-}
-interface DecodedSparkAddressData {
-    identityPublicKey: string;
-    network: NetworkType;
-    sparkInvoiceFields?: {
-        version: number;
-        id: string;
-        paymentType?: {
-            type: "tokens";
-            tokenIdentifier?: string;
-            amount?: bigint;
-        } | {
-            type: "sats";
-            amount?: number;
-        };
-        memo?: string;
-        senderPublicKey?: string;
-        expiryTime?: Date;
-    };
-    signature?: string;
-}
-declare function encodeSparkAddress(payload: SparkAddressData): SparkAddressFormat;
-declare function encodeSparkAddressWithSignature(payload: SparkAddressData, signature?: Uint8Array): SparkAddressFormat;
-declare function decodeSparkAddress(address: string, network: NetworkType): DecodedSparkAddressData;
-declare function isValidSparkAddress(address: string): boolean;
-declare function isValidPublicKey(publicKey: string): void;
-declare function validateSparkInvoiceFields(sparkInvoiceFields: SparkInvoiceFields): void;
-declare function validateSparkInvoiceSignature(invoice: SparkAddressFormat): void;
-declare function getNetworkFromSparkAddress(address: SparkAddressFormat): "MAINNET" | "REGTEST" | "SIGNET" | "TESTNET" | "LOCAL";
-declare function toProtoTimestamp(date: Date): {
-    seconds: number;
-    nanos: number;
-};
-declare function bech32mDecode(address: SparkAddressFormat): _scure_base.Bech32Decoded<string>;
-
 type Bech32mTokenIdentifier = `btkn1${string}` | `btknrt1${string}` | `btknt1${string}` | `btkns1${string}` | `btknl1${string}`;
 interface Bech32mTokenIdentifierData {
     tokenIdentifier: Uint8Array;
@@ -368,6 +374,55 @@ type TransferParams = {
     amountSats: number;
     receiverSparkAddress: string;
 };
+type TransferWithInvoiceParams = {
+    amountSats: number;
+    receiverIdentityPubkey: Uint8Array;
+    sparkInvoice?: SparkAddressFormat;
+};
+type TransferWithInvoiceOutcome = {
+    ok: true;
+    transfer: WalletTransfer;
+    param: TransferWithInvoiceParams;
+} | {
+    ok: false;
+    error: Error;
+    param: TransferWithInvoiceParams;
+};
+type FulfillSparkInvoiceResponse = {
+    satsTransactionSuccess: {
+        invoice: SparkAddressFormat;
+        transferResponse: WalletTransfer;
+    }[];
+    tokenTransactionSuccess: {
+        tokenIdentifier: Bech32mTokenIdentifier;
+        invoices: SparkAddressFormat[];
+        txid: string;
+    }[];
+    satsTransactionErrors: {
+        invoice: SparkAddressFormat;
+        error: Error;
+    }[];
+    tokenTransactionErrors: {
+        tokenIdentifier: Bech32mTokenIdentifier;
+        invoices: SparkAddressFormat[];
+        error: Error;
+    }[];
+    invalidInvoices: InvalidInvoice[];
+};
+type TokenInvoice = {
+    invoice: SparkAddressFormat;
+    identifierHex: string;
+    amount: bigint;
+};
+type InvalidInvoice = {
+    invoice: SparkAddressFormat;
+    error: Error;
+};
+type GroupSparkInvoicesResult = {
+    satsInvoices: TransferWithInvoiceParams[];
+    tokenInvoices: Map<string, TokenInvoice[]>;
+    invalidInvoices: InvalidInvoice[];
+};
 type DepositParams = {
     keyDerivation: KeyDerivation;
     verifyingKey: Uint8Array;
@@ -426,17 +481,27 @@ interface SparkWalletProps {
     signer?: SparkSigner;
     options?: ConfigOptions;
 }
+declare const SparkWalletEvent: {
+    readonly All: "*";
+    readonly TransferClaimed: "transfer:claimed";
+    readonly DepositConfirmed: "deposit:confirmed";
+    readonly StreamConnected: "stream:connected";
+    readonly StreamDisconnected: "stream:disconnected";
+    readonly StreamReconnecting: "stream:reconnecting";
+};
+type SparkWalletEventType = (typeof SparkWalletEvent)[keyof typeof SparkWalletEvent];
 interface SparkWalletEvents {
+    [SparkWalletEvent.All]: (eventName: string, ...args: unknown[]) => void;
     /** Emitted when an incoming transfer is successfully claimed. Includes the transfer ID and new total balance. */
-    "transfer:claimed": (transferId: string, updatedBalance: number) => void;
+    [SparkWalletEvent.TransferClaimed]: (transferId: string, updatedBalance: bigint) => void;
     /** Emitted when a deposit is marked as available. Includes the deposit ID and new total balance. */
-    "deposit:confirmed": (depositId: string, updatedBalance: number) => void;
+    [SparkWalletEvent.DepositConfirmed]: (depositId: string, updatedBalance: bigint) => void;
     /** Emitted when the stream is connected */
-    "stream:connected": () => void;
+    [SparkWalletEvent.StreamConnected]: () => void;
     /** Emitted when the stream disconnects and fails to reconnect after max attempts */
-    "stream:disconnected": (reason: string) => void;
+    [SparkWalletEvent.StreamDisconnected]: (reason: string) => void;
     /** Emitted when attempting to reconnect the stream */
-    "stream:reconnecting": (attempt: number, maxAttempts: number, delayMs: number, error: string) => void;
+    [SparkWalletEvent.StreamReconnecting]: (attempt: number, maxAttempts: number, delayMs: number, error: string) => void;
 }
 
 /**
@@ -444,7 +509,7 @@ interface SparkWalletEvents {
  * It provides methods for creating and managing wallets, handling deposits, executing transfers,
  * and interacting with the Lightning Network.
  */
-declare class SparkWallet extends EventEmitter {
+declare class SparkWallet extends EventEmitter<SparkWalletEvents> {
     protected config: WalletConfigService;
     protected connectionManager: ConnectionManager;
     protected transferService: TransferService;
@@ -479,6 +544,7 @@ declare class SparkWallet extends EventEmitter {
     getLeaves(isBalanceCheck?: boolean): Promise<TreeNode[]>;
     private checkExtendLeaves;
     private verifyKey;
+    private popOrThrow;
     private selectLeaves;
     private selectLeavesForSwap;
     private areLeavesInefficient;
@@ -503,14 +569,14 @@ declare class SparkWallet extends EventEmitter {
      * @param {Object} params - Parameters for the sats payment
      * @param {number} params.amount - The amount of sats to receive
      * @param {string} [params.memo] - The memo for the payment
-     * @param {string} [params.senderPublicKey] - The public key of the expected sender
+     * @param {string} [params.senderSparkAddress] - The spark address of the expected sender
      * @param {Date} [params.expiryTime] - The expiry time of the payment
-     * @returns {Promise<SparkAddressFormat>} The Spark address for the sats payment
+     * @returns {Promise<SparkAddressFormat>} The Spark invoice for the sats payment
      */
-    createSatsInvoice({ amount, memo, senderPublicKey, expiryTime, }: {
+    createSatsInvoice({ amount, memo, senderSparkAddress, expiryTime, }: {
         amount?: number;
         memo?: string;
-        senderPublicKey?: string;
+        senderSparkAddress?: SparkAddressFormat;
         expiryTime?: Date;
     }): Promise<SparkAddressFormat>;
     /**
@@ -520,15 +586,15 @@ declare class SparkWallet extends EventEmitter {
      * @param {bigint} [params.amount] - The amount of tokens to receive
      * @param {Bech32mTokenIdentifier} [params.tokenIdentifier] - The token identifier
      * @param {string} [params.memo] - The memo for the payment
-     * @param {string} [params.senderPublicKey] - The public key of the expected sender
+     * @param {string} [params.senderSparkAddress] - The spark address of the expected sender
      * @param {Date} [params.expiryTime] - The expiry time of the payment
-     * @returns {Promise<SparkAddressFormat>} The Spark address for the tokens payment
+     * @returns {Promise<SparkAddressFormat>} The Spark invoice for the tokens payment
      */
-    createTokensInvoice({ amount, tokenIdentifier, memo, senderPublicKey, expiryTime, }: {
+    createTokensInvoice({ amount, tokenIdentifier, memo, senderSparkAddress, expiryTime, }: {
         tokenIdentifier?: Bech32mTokenIdentifier;
         amount?: bigint;
         memo?: string;
-        senderPublicKey?: string;
+        senderSparkAddress?: SparkAddressFormat;
         expiryTime?: Date;
     }): Promise<SparkAddressFormat>;
     /**
@@ -774,6 +840,20 @@ declare class SparkWallet extends EventEmitter {
      * @returns {Promise<WalletTransfer>} The completed transfer details
      */
     transfer({ amountSats, receiverSparkAddress, }: TransferParams): Promise<WalletTransfer>;
+    /**
+     * Transfers with optional invoices.
+     * Does not parse/validate invoices or enforce amount-vs-invoice.
+     * If an invoice is provided, the caller must pass in the correct:
+     *  - amountSats
+     *  - receiverIdentityPubkey
+     *
+     * @param {TransferWithInvoiceParams[]} params - The parameters for the transfers
+     * @returns {Promise<TransferWithInvoiceOutcome[]>} The outcomes of the transfers
+     * @private
+     */
+    private transferWithInvoice;
+    private buildTweaksByAmount;
+    private toSendTweak;
     private checkExtendTimeLockNodes;
     /**
      * Internal method to refresh timelock nodes.
@@ -825,7 +905,8 @@ declare class SparkWallet extends EventEmitter {
     fulfillSparkInvoice(sparkInvoices: {
         invoice: SparkAddressFormat;
         amount?: bigint;
-    }[]): Promise<string>;
+    }[]): Promise<FulfillSparkInvoiceResponse>;
+    private groupSparkInvoicesByPaymentType;
     /**
      * Gets fee estimate for sending Lightning payments.
      *
@@ -1031,6 +1112,7 @@ declare class SparkWallet extends EventEmitter {
     private startPeriodicClaimTransfers;
     private updateLeaves;
     private queryNodes;
+    isOptimizationInProgress(): Promise<boolean>;
     protected getOtelTraceUrls(): string[];
     protected initializeTracer(wallet: SparkWallet): void;
     protected initializeTracerEnv({ spanProcessors, traceUrls, }: {
@@ -1043,4 +1125,4 @@ declare class SparkWallet extends EventEmitter {
     private wrapSparkWalletMethodsWithTracing;
 }
 
-export { type TokenOutputsMap as A, type Bech32mTokenIdentifier as B, ConnectionManager as C, type DecodedSparkAddressData as D, type TokenMetadataMap as E, type SparkWalletProps as F, type SparkWalletEvents as G, SparkWallet as H, type InitWalletResponse as I, LRC_WALLET_NETWORK as L, Network as N, type PayLightningInvoiceParams as P, type RawTokenIdentifierHex as R, type SparkAddressFormat as S, type TransferParams as T, type UserTokenMetadata as U, WalletConfigService as W, WalletConfig as a, type ConfigOptions as b, type SparkAddressData as c, encodeSparkAddressWithSignature as d, encodeSparkAddress as e, decodeSparkAddress as f, isValidPublicKey as g, validateSparkInvoiceSignature as h, isValidSparkAddress as i, getNetworkFromSparkAddress as j, bech32mDecode as k, type NetworkType as l, NetworkToProto as m, getNetwork as n, getNetworkFromAddress as o, protoToNetwork as p, getNetworkFromString as q, type Bech32mTokenIdentifierData as r, encodeBech32mTokenIdentifier as s, toProtoTimestamp as t, decodeBech32mTokenIdentifier as u, validateSparkInvoiceFields as v, getNetworkFromBech32mTokenIdentifier as w, type CreateLightningInvoiceParams as x, type DepositParams as y, type TokenBalanceMap as z };
+export { type SparkWalletEvents as $, getNetworkFromBech32mTokenIdentifier as A, type Bech32mTokenIdentifier as B, ConnectionManager as C, type DecodedSparkAddressData as D, type CreateLightningInvoiceParams as E, type TransferWithInvoiceParams as F, type TransferWithInvoiceOutcome as G, type FulfillSparkInvoiceResponse as H, type TokenInvoice as I, type InvalidInvoice as J, type GroupSparkInvoicesResult as K, type LegacySparkAddressFormat as L, type DepositParams as M, Network as N, type TokenBalanceMap as O, type PayLightningInvoiceParams as P, type TokenOutputsMap as Q, type RawTokenIdentifierHex as R, type SparkAddressFormat as S, type TransferParams as T, type UserTokenMetadata as U, type TokenMetadataMap as V, WalletConfigService as W, type InitWalletResponse as X, type SparkWalletProps as Y, SparkWalletEvent as Z, type SparkWalletEventType as _, WalletConfig as a, SparkWallet as a0, type ConfigOptions as b, type SparkAddressData as c, encodeSparkAddressWithSignature as d, encodeSparkAddress as e, decodeSparkAddress as f, getNetworkFromSparkAddress as g, isValidSparkAddress as h, isLegacySparkAddress as i, isValidPublicKey as j, validateSparkInvoiceSignature as k, assertBech32 as l, bech32mDecode as m, isSafeForNumber as n, type NetworkType as o, NetworkToProto as p, protoToNetwork as q, getNetwork as r, LRC_WALLET_NETWORK as s, toProtoTimestamp as t, getNetworkFromAddress as u, validateSparkInvoiceFields as v, getNetworkFromString as w, type Bech32mTokenIdentifierData as x, encodeBech32mTokenIdentifier as y, decodeBech32mTokenIdentifier as z };

package/dist/{spark-wallet.node-bGmy8-T8.d.ts → spark-wallet.node-CFSOZ0ea.d.cts}

@@ -1,4 +1,4 @@
-import { H as SparkWallet, F as SparkWalletProps } from './spark-wallet-D0Df_P_x.js';
+import { a0 as SparkWallet, Y as SparkWalletProps } from './spark-wallet-DAHB55v6.cjs';
 
 declare class SparkWalletNodeJS extends SparkWallet {
     static initialize({ mnemonicOrSeed, accountNumber, signer, options, }: SparkWalletProps): Promise<{

package/dist/{spark-wallet.node-B3V8_fgw.d.cts → spark-wallet.node-CIqbulUR.d.ts}

@@ -1,4 +1,4 @@
-import { H as SparkWallet, F as SparkWalletProps } from './spark-wallet-Dvh1BLP6.cjs';
+import { a0 as SparkWallet, Y as SparkWalletProps } from './spark-wallet-DW0_1REx.js';
 
 declare class SparkWalletNodeJS extends SparkWallet {
     static initialize({ mnemonicOrSeed, accountNumber, signer, options, }: SparkWalletProps): Promise<{

package/dist/spark_bindings/wasm/index.cjs

@@ -1084,14 +1084,34 @@ function signFrost({
   statechainCommitments,
   adaptorPubKey
 }) {
-  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("signFrost", {
+  const logMsg = JSON.stringify({
     message: (0, import_utils.bytesToHex)(message),
-    keyPackage,
-    nonce,
-    selfCommitment,
-    statechainCommitments
+    keyPackage: {
+      secretKey: (0, import_utils.bytesToHex)(keyPackage.secretKey),
+      publicKey: (0, import_utils.bytesToHex)(keyPackage.publicKey),
+      verifyingKey: (0, import_utils.bytesToHex)(keyPackage.verifyingKey)
+    },
+    nonce: {
+      hiding: (0, import_utils.bytesToHex)(nonce.hiding),
+      binding: (0, import_utils.bytesToHex)(nonce.binding)
+    },
+    selfCommitment: {
+      hiding: (0, import_utils.bytesToHex)(selfCommitment.hiding),
+      binding: (0, import_utils.bytesToHex)(selfCommitment.binding)
+    },
+    statechainCommitments: Object.fromEntries(
+      Object.entries(statechainCommitments ?? {}).map(([k, v]) => [
+        k,
+        {
+          hiding: (0, import_utils.bytesToHex)(v.hiding),
+          binding: (0, import_utils.bytesToHex)(v.binding)
+        }
+      ])
+    ),
+    adaptorPubKey: adaptorPubKey ? (0, import_utils.bytesToHex)(adaptorPubKey) : void 0
   });
-  return wasm_sign_frost(
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("signFrost", logMsg);
+  const result = wasm_sign_frost(
     message,
     createKeyPackage(keyPackage),
     createSigningNonce(nonce),
@@ -1099,6 +1119,11 @@ function signFrost({
     statechainCommitments,
     adaptorPubKey
   );
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace(
+    "signFrost result",
+    (0, import_utils.bytesToHex)(result)
+  );
+  return result;
 }
 function aggregateFrost({
   message,
@@ -1111,18 +1136,40 @@ function aggregateFrost({
   verifyingKey,
   adaptorPubKey
 }) {
-  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("aggregateFrost", {
+  const logMsg = JSON.stringify({
     message: (0, import_utils.bytesToHex)(message),
-    statechainCommitments,
-    selfCommitment,
-    statechainSignatures,
+    statechainCommitments: Object.fromEntries(
+      Object.entries(statechainCommitments ?? {}).map(([k, v]) => [
+        k,
+        {
+          hiding: (0, import_utils.bytesToHex)(v.hiding),
+          binding: (0, import_utils.bytesToHex)(v.binding)
+        }
+      ])
+    ),
+    selfCommitment: {
+      hiding: (0, import_utils.bytesToHex)(selfCommitment.hiding),
+      binding: (0, import_utils.bytesToHex)(selfCommitment.binding)
+    },
+    statechainSignatures: Object.fromEntries(
+      Object.entries(statechainSignatures ?? {}).map(([k, v]) => [
+        k,
+        (0, import_utils.bytesToHex)(v)
+      ])
+    ),
     selfSignature: (0, import_utils.bytesToHex)(selfSignature),
-    statechainPublicKeys,
+    statechainPublicKeys: Object.fromEntries(
+      Object.entries(statechainPublicKeys ?? {}).map(([k, v]) => [
+        k,
+        (0, import_utils.bytesToHex)(v)
+      ])
+    ),
     selfPublicKey: (0, import_utils.bytesToHex)(selfPublicKey),
     verifyingKey: (0, import_utils.bytesToHex)(verifyingKey),
     adaptorPubKey: adaptorPubKey ? (0, import_utils.bytesToHex)(adaptorPubKey) : void 0
   });
-  return wasm_aggregate_frost(
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("aggregateFrost", logMsg);
+  const result = wasm_aggregate_frost(
     message,
     statechainCommitments,
     createSigningCommitment(selfCommitment),
@@ -1133,6 +1180,11 @@ function aggregateFrost({
     verifyingKey,
     adaptorPubKey
   );
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace(
+    "aggregateFrost result",
+    (0, import_utils.bytesToHex)(result)
+  );
+  return result;
 }
 function createDummyTx({
   address,

package/dist/spark_bindings/wasm/index.js

@@ -1016,14 +1016,34 @@ function signFrost({
   statechainCommitments,
   adaptorPubKey
 }) {
-  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("signFrost", {
+  const logMsg = JSON.stringify({
     message: bytesToHex(message),
-    keyPackage,
-    nonce,
-    selfCommitment,
-    statechainCommitments
+    keyPackage: {
+      secretKey: bytesToHex(keyPackage.secretKey),
+      publicKey: bytesToHex(keyPackage.publicKey),
+      verifyingKey: bytesToHex(keyPackage.verifyingKey)
+    },
+    nonce: {
+      hiding: bytesToHex(nonce.hiding),
+      binding: bytesToHex(nonce.binding)
+    },
+    selfCommitment: {
+      hiding: bytesToHex(selfCommitment.hiding),
+      binding: bytesToHex(selfCommitment.binding)
+    },
+    statechainCommitments: Object.fromEntries(
+      Object.entries(statechainCommitments ?? {}).map(([k, v]) => [
+        k,
+        {
+          hiding: bytesToHex(v.hiding),
+          binding: bytesToHex(v.binding)
+        }
+      ])
+    ),
+    adaptorPubKey: adaptorPubKey ? bytesToHex(adaptorPubKey) : void 0
   });
-  return wasm_sign_frost(
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("signFrost", logMsg);
+  const result = wasm_sign_frost(
     message,
     createKeyPackage(keyPackage),
     createSigningNonce(nonce),
@@ -1031,6 +1051,11 @@ function signFrost({
     statechainCommitments,
     adaptorPubKey
   );
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace(
+    "signFrost result",
+    bytesToHex(result)
+  );
+  return result;
 }
 function aggregateFrost({
   message,
@@ -1043,18 +1068,40 @@ function aggregateFrost({
   verifyingKey,
   adaptorPubKey
 }) {
-  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("aggregateFrost", {
+  const logMsg = JSON.stringify({
     message: bytesToHex(message),
-    statechainCommitments,
-    selfCommitment,
-    statechainSignatures,
+    statechainCommitments: Object.fromEntries(
+      Object.entries(statechainCommitments ?? {}).map(([k, v]) => [
+        k,
+        {
+          hiding: bytesToHex(v.hiding),
+          binding: bytesToHex(v.binding)
+        }
+      ])
+    ),
+    selfCommitment: {
+      hiding: bytesToHex(selfCommitment.hiding),
+      binding: bytesToHex(selfCommitment.binding)
+    },
+    statechainSignatures: Object.fromEntries(
+      Object.entries(statechainSignatures ?? {}).map(([k, v]) => [
+        k,
+        bytesToHex(v)
+      ])
+    ),
     selfSignature: bytesToHex(selfSignature),
-    statechainPublicKeys,
+    statechainPublicKeys: Object.fromEntries(
+      Object.entries(statechainPublicKeys ?? {}).map(([k, v]) => [
+        k,
+        bytesToHex(v)
+      ])
+    ),
     selfPublicKey: bytesToHex(selfPublicKey),
     verifyingKey: bytesToHex(verifyingKey),
     adaptorPubKey: adaptorPubKey ? bytesToHex(adaptorPubKey) : void 0
   });
-  return wasm_aggregate_frost(
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("aggregateFrost", logMsg);
+  const result = wasm_aggregate_frost(
     message,
     statechainCommitments,
     createSigningCommitment(selfCommitment),
@@ -1065,6 +1112,11 @@ function aggregateFrost({
     verifyingKey,
     adaptorPubKey
   );
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace(
+    "aggregateFrost result",
+    bytesToHex(result)
+  );
+  return result;
 }
 function createDummyTx({
   address,