@buildonspark/spark-sdk 0.3.9 → 0.4.0

package/dist/tests/test-utils.d.ts

@@ -1,7 +1,7 @@
 import { Q as QueryTransfersResponse, T as Transfer, c as TreeNode } from '../spark-DOpheE8_.js';
-import { b as ConfigOptions } from '../wallet-config-Bmk2eAn8.js';
+import { b as ConfigOptions } from '../wallet-config-Bg3kWltL.js';
 import { S as SparkSigner, D as DefaultSparkSigner } from '../client-BaQf-5gD.js';
-import { S as SparkWalletNodeJS } from '../spark-wallet.node-CmIvxtcC.js';
+import { S as SparkWalletNodeJS } from '../spark-wallet.node-BqmKsGPs.js';
 import { Transaction } from '@scure/btc-signer';
 import { TransactionInput, TransactionOutput } from '@scure/btc-signer/psbt';
 import '@bufbuild/protobuf/wire';
@@ -38,12 +38,26 @@ declare class BitcoinFaucet {
     sendFaucetCoinToP2WPKHAddress(pubKey: Uint8Array): Promise<void>;
     signFaucetCoin(unsignedTx: Transaction, fundingTxOut: TransactionOutput, key: Uint8Array): Promise<Transaction>;
     mineBlocks(numBlocks: number): Promise<any>;
+    mineBlocksAndWaitForMiningToComplete(numBlocks: number): Promise<void>;
     private call;
     generateToAddress(numBlocks: number, address: string): Promise<any>;
     sendToAddressInternal(address: string, amountSats: number): Promise<any>;
     getBlock(blockHash: string): Promise<any>;
+    getBlockCount(): Promise<number>;
+    waitForBlocksMined({ startBlock, expectedIncrease, timeoutMs, intervalMs, }: {
+        startBlock: number;
+        expectedIncrease: number;
+        timeoutMs?: number;
+        intervalMs?: number;
+    }): Promise<number>;
     broadcastTx(txHex: string): Promise<any>;
+    submitPackage(txHexs: string[]): Promise<any>;
     getNewAddress(): Promise<string>;
+    getNewExternalWallet(): Promise<{
+        address: string;
+        key: Uint8Array;
+        pubKey: Uint8Array;
+    }>;
     sendToAddress(address: string, amount: bigint, blocksToGenerate?: number): Promise<Transaction>;
     getRawTransaction(txid: string): Promise<any>;
 }

package/dist/tests/test-utils.js

@@ -1,9 +1,9 @@
 import {
   ConnectionManagerNodeJS,
   SparkWalletNodeJS
-} from "../chunk-MFCM6GUD.js";
-import "../chunk-WRE2T22S.js";
-import "../chunk-S55NZT4P.js";
+} from "../chunk-WICAF6BS.js";
+import "../chunk-LOXWCMZL.js";
+import "../chunk-27ILUWDJ.js";
 import {
   BitcoinFaucet,
   DefaultSparkSigner,
@@ -14,7 +14,7 @@ import {
   WalletConfigService,
   getNetwork,
   getP2TRAddressFromPublicKey
-} from "../chunk-O4C4HGQL.js";
+} from "../chunk-G3LHXHF3.js";
 import "../chunk-NX5KPN5F.js";
 import "../chunk-JLF6WJ7K.js";
 import "../chunk-4YFT7DAE.js";

package/dist/{token-transactions-CV8QD3I7.d.cts → token-transactions-Db8mkjnU.d.cts}

@@ -1,6 +1,6 @@
 import { O as OutputWithPreviousTransactionData } from './spark-DOpheE8_.cjs';
 import { TokenTransaction, QueryTokenTransactionsResponse } from './proto/spark_token.cjs';
-import { W as WalletConfigService, C as ConnectionManager, O as TokenOutputsMap, B as Bech32mTokenIdentifier, S as SparkAddressFormat } from './wallet-config-DQw5llqA.cjs';
+import { W as WalletConfigService, C as ConnectionManager, O as TokenOutputsMap, B as Bech32mTokenIdentifier, S as SparkAddressFormat } from './wallet-config-CuZKNo9S.cjs';
 
 declare class SparkSDKError extends Error {
     readonly context: Record<string, unknown>;

package/dist/{token-transactions-Bu023ztN.d.ts → token-transactions-DoMcrxXQ.d.ts}

@@ -1,6 +1,6 @@
 import { O as OutputWithPreviousTransactionData } from './spark-DOpheE8_.js';
 import { TokenTransaction, QueryTokenTransactionsResponse } from './proto/spark_token.js';
-import { W as WalletConfigService, C as ConnectionManager, O as TokenOutputsMap, B as Bech32mTokenIdentifier, S as SparkAddressFormat } from './wallet-config-Bmk2eAn8.js';
+import { W as WalletConfigService, C as ConnectionManager, O as TokenOutputsMap, B as Bech32mTokenIdentifier, S as SparkAddressFormat } from './wallet-config-Bg3kWltL.js';
 
 declare class SparkSDKError extends Error {
     readonly context: Record<string, unknown>;

package/dist/{wallet-config-Bmk2eAn8.d.ts → wallet-config-Bg3kWltL.d.ts}

@@ -118,6 +118,7 @@ declare class WalletConfigService implements HasSspClientOptions {
     getSspIdentityPublicKey(): string;
     getConsoleOptions(): ConsoleOptions;
     getEvents(): Partial<SparkWalletEvents>;
+    getOptimizationOptions(): OptimizationOptions;
 }
 
 /** Challenge represents the core challenge data */
@@ -419,8 +420,11 @@ declare abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     private popOrThrow;
     private selectLeaves;
     private selectLeavesForSwap;
-    private areLeavesInefficient;
-    private optimizeLeaves;
+    optimizeLeaves(multiplicity?: number | undefined): AsyncGenerator<{
+        step: number;
+        total: number;
+        controller: AbortController;
+    }, void, void>;
     private syncWallet;
     private withLeaves;
     /**
@@ -1141,6 +1145,10 @@ type SigningOperator = {
 type ConsoleOptions = {
     otel?: boolean;
 };
+type OptimizationOptions = {
+    readonly auto?: boolean;
+    readonly multiplicity?: number;
+};
 type ConfigOptions = MayHaveSspClientOptions & {
     readonly network?: NetworkType;
     readonly signingOperators?: Readonly<Record<string, SigningOperator>>;
@@ -1156,6 +1164,7 @@ type ConfigOptions = MayHaveSspClientOptions & {
     readonly signerWithPreExistingKeys?: boolean;
     readonly console?: ConsoleOptions;
     readonly events?: Partial<SparkWalletEvents>;
+    readonly optimizationOptions?: OptimizationOptions;
 };
 declare const WalletConfig: {
     LOCAL: Required<ConfigOptions>;

package/dist/{wallet-config-DQw5llqA.d.cts → wallet-config-CuZKNo9S.d.cts}

@@ -118,6 +118,7 @@ declare class WalletConfigService implements HasSspClientOptions {
     getSspIdentityPublicKey(): string;
     getConsoleOptions(): ConsoleOptions;
     getEvents(): Partial<SparkWalletEvents>;
+    getOptimizationOptions(): OptimizationOptions;
 }
 
 /** Challenge represents the core challenge data */
@@ -419,8 +420,11 @@ declare abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     private popOrThrow;
     private selectLeaves;
     private selectLeavesForSwap;
-    private areLeavesInefficient;
-    private optimizeLeaves;
+    optimizeLeaves(multiplicity?: number | undefined): AsyncGenerator<{
+        step: number;
+        total: number;
+        controller: AbortController;
+    }, void, void>;
     private syncWallet;
     private withLeaves;
     /**
@@ -1141,6 +1145,10 @@ type SigningOperator = {
 type ConsoleOptions = {
     otel?: boolean;
 };
+type OptimizationOptions = {
+    readonly auto?: boolean;
+    readonly multiplicity?: number;
+};
 type ConfigOptions = MayHaveSspClientOptions & {
     readonly network?: NetworkType;
     readonly signingOperators?: Readonly<Record<string, SigningOperator>>;
@@ -1156,6 +1164,7 @@ type ConfigOptions = MayHaveSspClientOptions & {
     readonly signerWithPreExistingKeys?: boolean;
     readonly console?: ConsoleOptions;
     readonly events?: Partial<SparkWalletEvents>;
+    readonly optimizationOptions?: OptimizationOptions;
 };
 declare const WalletConfig: {
     LOCAL: Required<ConfigOptions>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buildonspark/spark-sdk",
-  "version": "0.3.9",
+  "version": "0.4.0",
   "author": "",
   "license": "Apache-2.0",
   "main": "./dist/index.js",

package/src/index.react-native.ts

@@ -7,9 +7,15 @@ setCrypto(globalThis.crypto);
 export * from "./errors/index.js";
 export * from "./utils/index.js";
 
-export { ReactNativeSparkSigner } from "./signer/signer.react-native.js";
+export {
+  ReactNativeSparkSigner,
+  ReactNativeTaprootSparkSigner,
+} from "./signer/signer.react-native.js";
 /* Enable some consumers to use named import DefaultSparkSigner regardless of module, see LIG-7662 */
-export { ReactNativeSparkSigner as DefaultSparkSigner } from "./signer/signer.react-native.js";
+export {
+  ReactNativeSparkSigner as DefaultSparkSigner,
+  ReactNativeTaprootSparkSigner as TaprootSparkSigner,
+} from "./signer/signer.react-native.js";
 
 export { SparkWallet } from "./spark-wallet/spark-wallet.react-native.js";
 export * from "./spark-wallet/types.js";

package/src/services/config.ts

@@ -7,6 +7,7 @@ import {
   WalletConfig,
   SigningOperator,
   ConsoleOptions,
+  OptimizationOptions,
 } from "./wallet-config.js";
 import { ConfigurationError } from "../errors/types.js";
 import { SparkWalletEvents } from "../spark-wallet/types.js";
@@ -127,4 +128,8 @@ export class WalletConfigService implements HasSspClientOptions {
   public getEvents(): Partial<SparkWalletEvents> {
     return this.config.events;
   }
+
+  public getOptimizationOptions(): OptimizationOptions {
+    return this.config.optimizationOptions;
+  }
 }

package/src/services/wallet-config.ts

@@ -104,6 +104,11 @@ export type ConsoleOptions = {
   otel?: boolean;
 };
 
+export type OptimizationOptions = {
+  readonly auto?: boolean;
+  readonly multiplicity?: number;
+};
+
 export type ConfigOptions = MayHaveSspClientOptions & {
   readonly network?: NetworkType;
   readonly signingOperators?: Readonly<Record<string, SigningOperator>>;
@@ -119,6 +124,7 @@ export type ConfigOptions = MayHaveSspClientOptions & {
   readonly signerWithPreExistingKeys?: boolean;
   readonly console?: ConsoleOptions;
   readonly events?: Partial<SparkWalletEvents>;
+  readonly optimizationOptions?: OptimizationOptions;
 };
 
 const PROD_PUBKEYS = [
@@ -153,6 +159,10 @@ const BASE_CONFIG: Required<ConfigOptions> = {
     otel: false,
   },
   events: {},
+  optimizationOptions: {
+    auto: true,
+    multiplicity: 0,
+  },
 };
 
 const LOCAL_WALLET_CONFIG: Required<ConfigOptions> = {

package/src/services/xhr-transport.ts

@@ -169,7 +169,17 @@ function headersToMetadata(headers: string): Metadata {
     const parts = line.split(": ");
     const header = parts.shift() ?? "";
     const value = parts.join(": ");
-    metadata.set(header, value);
+
+    if (header.endsWith("-bin")) {
+      try {
+        metadata.set(header, Base64.toUint8Array(value));
+      } catch (e) {
+        console.warn(`Failed to decode binary metadata ${header}:`, e);
+        metadata.set(header, value);
+      }
+    } else {
+      metadata.set(header, value);
+    }
   });
   return metadata;
 }
@@ -202,8 +212,8 @@ function getErrorDetailsFromHttpResponse(
 ): string {
   return (
     `Received HTTP ${statusCode} response: ` +
-    (responseText.length > 1000
-      ? responseText.slice(0, 1000) + "... (truncated)"
+    (responseText?.length > 1000
+      ? responseText?.slice(0, 1000) + "... (truncated)"
       : responseText)
   );
 }

package/src/signer/signer.react-native.ts

@@ -1,7 +1,7 @@
 import { ValidationError } from "../errors/index.js";
 import { NativeSparkFrost } from "../spark_bindings/native/index.js";
 import { IKeyPackage } from "../spark_bindings/types.js";
-import { DefaultSparkSigner } from "./signer.js";
+import { DefaultSparkSigner, TaprootSparkSigner } from "./signer.js";
 import type { AggregateFrostParams, SignFrostParams } from "./types.js";
 
 export class ReactNativeSparkSigner extends DefaultSparkSigner {
@@ -71,3 +71,75 @@ export class ReactNativeSparkSigner extends DefaultSparkSigner {
     });
   }
 }
+
+export class ReactNativeTaprootSparkSigner extends TaprootSparkSigner {
+  constructor(useAddressIndex = false) {
+    super(useAddressIndex);
+  }
+
+  async signFrost({
+    message,
+    keyDerivation,
+    publicKey,
+    verifyingKey,
+    selfCommitment,
+    statechainCommitments,
+    adaptorPubKey,
+  }: SignFrostParams): Promise<Uint8Array> {
+    const signingPrivateKey =
+      await this.getSigningPrivateKeyFromDerivation(keyDerivation);
+
+    if (!signingPrivateKey) {
+      throw new ValidationError("Private key not found for public key", {
+        field: "privateKey",
+      });
+    }
+
+    const commitment = selfCommitment.commitment;
+    const nonce = this.commitmentToNonceMap.get(commitment);
+    if (!nonce) {
+      throw new ValidationError("Nonce not found for commitment", {
+        field: "nonce",
+      });
+    }
+
+    const keyPackage: IKeyPackage = {
+      secretKey: signingPrivateKey,
+      publicKey: publicKey,
+      verifyingKey: verifyingKey,
+    };
+
+    return NativeSparkFrost.signFrost({
+      message,
+      keyPackage,
+      nonce,
+      selfCommitment: commitment,
+      statechainCommitments,
+      adaptorPubKey,
+    });
+  }
+
+  async aggregateFrost({
+    message,
+    publicKey,
+    verifyingKey,
+    selfCommitment,
+    statechainCommitments,
+    adaptorPubKey,
+    selfSignature,
+    statechainSignatures,
+    statechainPublicKeys,
+  }: AggregateFrostParams): Promise<Uint8Array> {
+    return NativeSparkFrost.aggregateFrost({
+      message,
+      statechainSignatures,
+      statechainPublicKeys,
+      verifyingKey,
+      statechainCommitments,
+      selfCommitment: selfCommitment.commitment,
+      selfPublicKey: publicKey,
+      selfSignature,
+      adaptorPubKey,
+    });
+  }
+}

package/src/spark-wallet/spark-wallet.ts

@@ -124,7 +124,6 @@ import {
 import { chunkArray } from "../utils/chunkArray.js";
 import { getFetch } from "../utils/fetch.js";
 import { addPublicKeys } from "../utils/keys.js";
-import { maximizeUnilateralExit } from "../utils/optimize.js";
 import { RetryContext, withRetry } from "../utils/retry.js";
 import {
   Bech32mTokenIdentifier,
@@ -152,6 +151,7 @@ import type {
   UserTokenMetadata,
 } from "./types.js";
 import { SparkWalletEvent } from "./types.js";
+import { optimize, shouldOptimize } from "../utils/optimize.js";
 
 /**
  * The SparkWallet class is the primary interface for interacting with the Spark network.
@@ -299,7 +299,6 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
           await this.claimTransfer({
             transfer: event.transfer.transfer,
             emit: true,
-            optimize: true,
           });
         }
       } else if (isDepositStreamEvent(event)) {
@@ -669,76 +668,101 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     return nodes;
   }
 
-  private areLeavesInefficient() {
-    const totalAmount = this.getInternalBalance();
-
-    if (this.leaves.length <= 1) {
-      return false;
+  public async *optimizeLeaves(
+    multiplicity: number | undefined = undefined,
+  ): AsyncGenerator<
+    {
+      step: number;
+      total: number;
+      controller: AbortController;
+    },
+    void,
+    void
+  > {
+    const multiplicityValue =
+      multiplicity ?? this.config.getOptimizationOptions().multiplicity ?? 0;
+    if (multiplicityValue < 0) {
+      throw new ValidationError("Multiplicity cannot be negative");
+    } else if (multiplicityValue > 5) {
+      throw new ValidationError("Multiplicity cannot be greater than 5");
     }
 
-    const nextLowerPowerOfTwo = 31 - Math.clz32(totalAmount);
+    if (
+      this.optimizationInProgress ||
+      !shouldOptimize(
+        this.leaves.map((leaf) => leaf.value),
+        multiplicityValue,
+      )
+    ) {
+      return;
+    }
 
-    let remainingAmount = totalAmount;
-    let optimalLeavesLength = 0;
+    const controller = new AbortController();
+    const release = await this.leavesMutex.acquire();
+    try {
+      this.optimizationInProgress = true;
 
-    for (let i = nextLowerPowerOfTwo; i >= 0; i--) {
-      const denomination = 2 ** i;
-      while (remainingAmount >= denomination) {
-        remainingAmount -= denomination;
-        optimalLeavesLength++;
+      this.leaves = await this.getLeaves();
+      const swaps = optimize(
+        this.leaves.map((leaf) => leaf.value),
+        multiplicityValue,
+      );
+      if (swaps.length === 0) {
+        return;
       }
-    }
-
-    return this.leaves.length > optimalLeavesLength * 5;
-  }
 
-  private async optimizeLeaves() {
-    if (this.optimizationInProgress || !this.areLeavesInefficient()) {
-      return;
-    }
+      yield {
+        step: 0,
+        total: swaps.length,
+        controller,
+      };
 
-    await this.withLeaves(async () => {
-      this.optimizationInProgress = true;
-      try {
-        this.leaves = await this.getLeaves();
-        const swaps = maximizeUnilateralExit(
-          this.leaves.map((leaf) => leaf.value),
-        );
+      // Build a map from the denomination to the indices
+      const valueToNodes = new Map<number, TreeNode[]>();
+      this.leaves.forEach((leaf) => {
+        if (!valueToNodes.has(leaf.value)) {
+          valueToNodes.set(leaf.value, []);
+        }
+        valueToNodes.get(leaf.value)!.push(leaf);
+      });
 
-        // Build a map from the denomination to the nodes
-        const valueToNodes = new Map<number, TreeNode[]>();
-        this.leaves.forEach((leaf) => {
-          if (!valueToNodes.has(leaf.value)) {
-            valueToNodes.set(leaf.value, []);
-          }
-          valueToNodes.get(leaf.value)!.push(leaf);
-        });
+      // Select the leaves to send for each swap.
+      for (const swap of swaps) {
+        if (controller.signal.aborted) {
+          break;
+        }
 
-        // Select the leaves to send for each swap.
-        for (const swap of swaps) {
-          const leavesToSend: TreeNode[] = [];
-          for (const leafValue of swap.inLeaves) {
-            const nodes = valueToNodes.get(leafValue);
-            if (nodes && nodes.length > 0) {
-              const node = nodes.shift()!;
-              leavesToSend.push(node);
-            } else {
-              throw new InternalValidationError(
-                `No unused leaf with value ${leafValue} found in leaves`,
-              );
-            }
+        const leavesToSend: TreeNode[] = [];
+        for (const leafValue of swap.inLeaves) {
+          const nodes = valueToNodes.get(leafValue);
+          if (nodes && nodes.length > 0) {
+            const node = nodes.shift()!;
+            leavesToSend.push(node);
+          } else {
+            throw new InternalValidationError(
+              `No unused leaf with value ${leafValue} found in leaves`,
+            );
           }
-          await this.requestLeavesSwap({
-            leaves: leavesToSend,
-            targetAmounts: swap.outLeaves,
-          });
         }
 
-        this.leaves = await this.getLeaves();
-      } finally {
-        this.optimizationInProgress = false;
+        // TODO: Parallelize this.
+        await this.requestLeavesSwap({
+          leaves: leavesToSend,
+          targetAmounts: swap.outLeaves,
+        });
+
+        yield {
+          step: swaps.indexOf(swap) + 1,
+          total: swaps.length,
+          controller,
+        };
       }
-    });
+
+      this.leaves = await this.getLeaves();
+    } finally {
+      this.optimizationInProgress = false;
+      release();
+    }
   }
 
   private async syncWallet() {
@@ -750,9 +774,11 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
 
     this.leaves = leaves;
 
-    this.optimizeLeaves().catch((e) => {
-      console.error("Failed to optimize leaves", e);
-    });
+    if (this.config.getOptimizationOptions().auto) {
+      for await (const _ of this.optimizeLeaves()) {
+        // run all optimizer steps, do nothing with them
+      }
+    }
   }
 
   private async withLeaves<T>(operation: () => Promise<T>): Promise<T> {
@@ -1453,7 +1479,6 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
       return await this.claimTransfer({
         transfer: incomingTransfer,
         emit: false,
-        optimize: false,
       });
     } catch (e) {
       console.error("[processSwapBatch] Error details:", {
@@ -2749,7 +2774,7 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
                 transfer.id,
               );
               if (pending) {
-                await this.claimTransfer({ transfer: pending, optimize: true });
+                await this.claimTransfer({ transfer: pending });
               }
             }
             return {
@@ -2959,7 +2984,6 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     result: TreeNode[],
     transfer: Transfer,
     emit?: boolean,
-    optimize?: boolean,
   ): Promise<TreeNode[]> {
     result = await this.checkRenewLeaves(result);
 
@@ -2967,8 +2991,13 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     const uniqueResults = result.filter((node) => !existingIds.has(node.id));
     this.leaves.push(...uniqueResults);
 
-    if (optimize && transfer.type !== TransferType.COUNTER_SWAP) {
-      await this.optimizeLeaves();
+    if (
+      this.config.getOptimizationOptions().auto &&
+      transfer.type !== TransferType.COUNTER_SWAP
+    ) {
+      for await (const _ of this.optimizeLeaves()) {
+        // run all optimizer steps, do nothing with them
+      }
     }
 
     if (emit) {
@@ -2991,11 +3020,9 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
   private async claimTransfer({
     transfer,
     emit,
-    optimize,
   }: {
     transfer: Transfer;
     emit?: boolean;
-    optimize?: boolean;
   }) {
     const onError = async (
       context: RetryContext<TreeNode[], Transfer>,
@@ -3053,12 +3080,7 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
         return [];
       }
 
-      return await this.processClaimedTransferResults(
-        result,
-        transfer,
-        emit,
-        optimize,
-      );
+      return await this.processClaimedTransferResults(result, transfer, emit);
     } catch (error) {
       console.warn(
         `Failed to claim transfer after all retries. Please try reinitializing your wallet in a few minutes. Transfer ID: ${transfer.id}`,
@@ -3107,7 +3129,7 @@ export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
         continue;
       }
       promises.push(
-        this.claimTransfer({ transfer, emit, optimize: true })
+        this.claimTransfer({ transfer, emit })
           .then(() => transfer.id)
           .catch((error) => {
             console.warn(`Failed to claim transfer ${transfer.id}:`, error);