@buildonspark/spark-sdk 0.3.8 → 0.4.0

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/proto-descriptors.ts

@@ -8,7 +8,7 @@
 
 // Base64-encoded FileDescriptorSet
 export const SPARK_DESCRIPTORS_BASE64 =
-  "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";
+  "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";
 
 // Convert back to Uint8Array when needed
 export function getSparkDescriptorBytes(): Uint8Array {