@buildonspark/spark-sdk 0.2.12 → 0.3.0

package/src/spark-wallet/types.ts

@@ -5,6 +5,8 @@ import { ConfigOptions } from "../services/wallet-config.js";
 import type { SparkSigner } from "../signer/signer.js";
 import { KeyDerivation } from "../signer/types.js";
 import { Bech32mTokenIdentifier } from "../utils/token-identifier.js";
+import { SparkAddressFormat } from "../utils/address.js";
+import { WalletTransfer } from "../types/index.js";
 
 export type CreateLightningInvoiceParams = {
   amountSats: number;
@@ -27,6 +29,55 @@ export type TransferParams = {
   receiverSparkAddress: string;
 };
 
+export type TransferWithInvoiceParams = {
+  amountSats: number;
+  receiverIdentityPubkey: Uint8Array;
+  sparkInvoice?: SparkAddressFormat;
+};
+
+export type TransferWithInvoiceOutcome =
+  | { ok: true; transfer: WalletTransfer; param: TransferWithInvoiceParams }
+  | { ok: false; error: Error; param: TransferWithInvoiceParams };
+
+export 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[];
+};
+
+export type TokenInvoice = {
+  invoice: SparkAddressFormat;
+  identifierHex: string;
+  amount: bigint;
+};
+
+export type InvalidInvoice = {
+  invoice: SparkAddressFormat;
+  error: Error;
+};
+
+export type GroupSparkInvoicesResult = {
+  satsInvoices: TransferWithInvoiceParams[];
+  tokenInvoices: Map<string, TokenInvoice[]>;
+  invalidInvoices: InvalidInvoice[];
+};
+
 export type DepositParams = {
   keyDerivation: KeyDerivation;
   verifyingKey: Uint8Array;
@@ -98,17 +149,36 @@ export interface SparkWalletProps {
   options?: ConfigOptions;
 }
 
+export const SparkWalletEvent = {
+  All: "*",
+  TransferClaimed: "transfer:claimed",
+  DepositConfirmed: "deposit:confirmed",
+  StreamConnected: "stream:connected",
+  StreamDisconnected: "stream:disconnected",
+  StreamReconnecting: "stream:reconnecting",
+} as const;
+
+export type SparkWalletEventType =
+  (typeof SparkWalletEvent)[keyof typeof SparkWalletEvent];
+
 export 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": (
+  [SparkWalletEvent.StreamReconnecting]: (
     attempt: number,
     maxAttempts: number,
     delayMs: number,

package/src/spark_bindings/wasm/index.ts

@@ -46,14 +46,35 @@ export function signFrost({
   statechainCommitments,
   adaptorPubKey,
 }: SignFrostParams): Uint8Array {
-  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("signFrost", {
+  const logMsg = JSON.stringify({
     message: bytesToHex(message),
-    keyPackage: keyPackage,
-    nonce: nonce,
-    selfCommitment: selfCommitment,
-    statechainCommitments: 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) : undefined,
   });
-  return wasm_sign_frost(
+
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("signFrost", logMsg);
+  const result = wasm_sign_frost(
     message,
     createKeyPackage(keyPackage),
     createSigningNonce(nonce),
@@ -61,6 +82,12 @@ export function signFrost({
     statechainCommitments,
     adaptorPubKey,
   );
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace(
+    "signFrost result",
+    bytesToHex(result),
+  );
+
+  return result;
 }
 
 export function aggregateFrost({
@@ -74,18 +101,40 @@ export function aggregateFrost({
   verifyingKey,
   adaptorPubKey,
 }: AggregateFrostParams): Uint8Array {
-  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("aggregateFrost", {
+  const logMsg = JSON.stringify({
     message: bytesToHex(message),
-    statechainCommitments: statechainCommitments,
-    selfCommitment: selfCommitment,
-    statechainSignatures: 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,
+    statechainPublicKeys: Object.fromEntries(
+      Object.entries(statechainPublicKeys ?? {}).map(([k, v]) => [
+        k,
+        bytesToHex(v),
+      ]),
+    ),
     selfPublicKey: bytesToHex(selfPublicKey),
     verifyingKey: bytesToHex(verifyingKey),
     adaptorPubKey: adaptorPubKey ? bytesToHex(adaptorPubKey) : undefined,
   });
-  return wasm_aggregate_frost(
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("aggregateFrost", logMsg);
+  const result = wasm_aggregate_frost(
     message,
     statechainCommitments,
     createSigningCommitment(selfCommitment),
@@ -96,6 +145,11 @@ export function aggregateFrost({
     verifyingKey,
     adaptorPubKey,
   );
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace(
+    "aggregateFrost result",
+    bytesToHex(result),
+  );
+  return result;
 }
 
 export function createDummyTx({

package/src/tests/address.test.ts

@@ -226,12 +226,24 @@ describe("Spark Invoice Encode/Decode", () => {
 
 describe("getNetworkFromSparkAddress", () => {
   test("REGTEST", () => {
+    const network = getNetworkFromSparkAddress(
+      "sparkrt1pgssx5us3wkqjza8g80xz3a9gznx25msq6g3ty8exfym9q3ahcv86vsnxxdy83",
+    );
+    expect(network).toBe("REGTEST");
+  });
+  test("Legacy REGTEST", () => {
     const network = getNetworkFromSparkAddress(
       "sprt1pgssx63fa5g6uyv450rajp5ndwy9laxzpsp9e37su58jddmcdsvhgm5n7y0ud6",
     );
     expect(network).toBe("REGTEST");
   });
   test("MAINNET", () => {
+    const network = getNetworkFromSparkAddress(
+      "spark1pgss9qg3vdslzmt2name9v550skuvlu6lj5xt9sly90k7p0gxughlqv023jqmc",
+    );
+    expect(network).toBe("MAINNET");
+  });
+  test("Legacy MAINNET", () => {
     const network = getNetworkFromSparkAddress(
       "sp1pgssxwh6hznfdc3c0cuqrhgttder539d52a0rqcf34amge69huh664gd2ew787",
     );
@@ -240,9 +252,29 @@ describe("getNetworkFromSparkAddress", () => {
 });
 
 describe("knownSparkAddress", () => {
+  test("spark address encodes known identity public key", () => {
+    const address =
+      "sparkrt1pgssx5us3wkqjza8g80xz3a9gznx25msq6g3ty8exfym9q3ahcv86vsnxxdy83";
+    const network = getNetworkFromSparkAddress(address);
+    expect(network).toBe("REGTEST");
+    const decoded = decodeSparkAddress(address, network);
+    expect(decoded.identityPublicKey).toBe(
+      "0353908bac090ba741de6147a540a665537006911590f93249b2823dbe187d3213",
+    );
+  });
+  test("legacy spark address encodes known identity public key", () => {
+    const address =
+      "sprt1pgssx63fa5g6uyv450rajp5ndwy9laxzpsp9e37su58jddmcdsvhgm5n7y0ud6";
+    const network = getNetworkFromSparkAddress(address);
+    expect(network).toBe("REGTEST");
+    const decoded = decodeSparkAddress(address, network);
+    expect(decoded.identityPublicKey).toBe(
+      "036a29ed11ae1195a3c7d906936b885ff4c20c025cc7d0e50f26b7786c19746e93",
+    );
+  });
   test("known spark address decodes and encodes to the same address", () => {
     const address =
-      "sprt1pgss8stv8nfkamyea7mtc8werley55anfnnpgtnglff0wmxwm52mkyk6zfeqsqgjzqqe3dvr6e48l2alnpagf7ny3vlj5pr5v4ehgv3pqwd7wxx3awkku9p3epk73na6hcf9220h8kue2tmlkqx8tcrfpsf5ywsvpzgd9px9qcgvpzy8ecp35fg2yq4r39r4njq3slgcul7laarh9sndex9uejz7vwrcrz4g7n4egvwt5yspvsdyped46sflczvrzh0jzksgqnvaqlk02cz4vkwjrkwuep9zsrz5vmjp7mqxq7762tfjczy07at2fvzd7cgk2sqsxrmqdxnpy464rmq2nzdqzpuhme";
+      "sparkrt1pgssx5us3wkqjza8g80xz3a9gznx25msq6g3ty8exfym9q3ahcv86vsnzffssqgjzqqejta89sa8su5f05g0vunfzzkj5zr5v4ehgnt9d4hnyggr2wgghtqfpwn5rhnpg7j5pfn92dcqdyg4jrunyjdjsg7muxraxgfn5zcgs8dcr3sxzrqdetshygps36q8rfqg49d0p0447trnpyxh9f76kt9cwrfx4342jym5emx049chkfsz6j9qc0z8cl7ymmsckx42k76c2qm5f5n5kfvyd26x78eyw0ygs502vg42n8ls";
     const decoded = bech32mDecode(address as SparkAddressFormat);
     const payload = SparkAddress.decode(bech32m.fromWords(decoded.words));
 
@@ -262,40 +294,39 @@ describe("knownSparkAddress", () => {
 
   test("known spark address decodes to expected fields", () => {
     const address =
-      "sprt1pgss8stv8nfkamyea7mtc8werley55anfnnpgtnglff0wmxwm52mkyk6zfeqsqgjzqqe3dvr6e48l2alnpagf7ny3vl35fg2yq4r39r4njq3slgcul7laarh9sndex9uejz7vwrcrz4g7n4egvwt5yspvs4qgar9wd6ryggrn0n3350t44hpgvwgdh5vlw47zf2jnaeahx2j7lasp367q6gvzdpr5rqgjrfgf3gxzrqg3p7wqvdyped46sflczvrzh0jzksgqnvaqlk02cz4vkwjrkwuep9zsrz5vmjp7mqxq7762tfjczy07at2fvzd7cgk2sqsxrmqdxnpy464rmq2nzdqneal34";
-
+      "sparkrt1pgssx5us3wkqjza8g80xz3a9gznx25msq6g3ty8exfym9q3ahcv86vsnzfmssqgjzqqejtaxmwj8ms9rn58574nvlq4j5zr5v4ehgnt9d4hnyggr2wgghtqfpwn5rhnpg7j5pfn92dcqdyg4jrunyjdjsg7muxraxgfn5rqgandgr3sxzrqdmew8qydzvz3qpylysylkgcaw9vpm2jzspls0qtr5kfmlwz244rvuk25w5w2sgc2pyqsraqdyp8tf57a6cn2egttaas9ms3whssenmjqt8wag3lgyvdzjskfeupt8xwwdx4agxdm9f0wefzj28jmdxqeudwcwdj9vfl9sdr65x06r0tasf5fwz2";
     const decoded = decodeSparkAddress(address, "REGTEST");
 
     expect(decoded.network).toBe("REGTEST");
     expect(decoded.identityPublicKey).toBe(
-      "03c16c3cd36eec99efb6bc1dd91ff24a53b34ce6142e68fa52f76ccedd15bb12da",
+      "0353908bac090ba741de6147a540a665537006911590f93249b2823dbe187d3213",
     );
 
     const f = decoded.sparkInvoiceFields!;
     expect(f.version).toBe(1);
-    expect(f.id).toBe("0198b583-d66a-7fab-bf98-7a84fa648b3f");
+    expect(f.id).toBe("01992fa6-dba4-7dc0-a39d-0f4f566cf82b");
 
     expect(f.paymentType?.type).toBe("tokens");
     expect(
       f.paymentType && "tokenIdentifier" in f.paymentType
         ? f.paymentType.tokenIdentifier
         : undefined,
-    ).toBe("2a3894759c81187d18e7fdfef4772c26dc98bccc85e6387818aa8f4eb9431cba");
+    ).toBe("093e4813f6463ae2b03b548500fe0f02c74b277f70955a8d9cb2a8ea39504614");
     expect(
       f.paymentType && "amount" in f.paymentType
         ? f.paymentType.amount
         : undefined,
-    ).toBe(100n);
+    ).toBe(1000n);
 
-    expect(f.memo).toBe("test");
+    expect(f.memo).toBe("testMemo");
     expect(f.senderPublicKey).toBe(
-      "039be718d1ebad6e1431c86de8cfbabe125529f73db9952f7fb00c75e0690c1342",
+      "0353908bac090ba741de6147a540a665537006911590f93249b2823dbe187d3213",
     );
 
-    expect(f.expiryTime?.toISOString()).toBe("2025-08-17T00:57:52.969Z");
+    expect(f.expiryTime?.toISOString()).toBe("2025-09-09T18:09:48.419Z");
 
     expect(decoded.signature).toBe(
-      "e5b5d413fc098315df215a0804d9d07ecf56055659d21d9dcc84a280c5466e41f6c0607bda52d32c088ff756a4b04df61165401030f6069a61257551ec0a989a",
+      "9d69a7bbac4d5942d7dec0bb845d784333dc80b3bba88fd046345285939e0567339cd357a8337654bdd948a4a3cb6d3033c6bb0e6c8ac4fcb068f5433f437afb",
     );
   });
 });

package/src/tests/bufbuild-reflection.test.ts

@@ -0,0 +1,151 @@
+/**
+ * Test @bufbuild/protobuf reflection capabilities for automatic field number extraction
+ */
+
+import { describe, expect, it } from "@jest/globals";
+import { SparkInvoiceFields, SatsPayment } from "../proto/spark.js";
+import {
+  getFieldNumbers,
+  listMessageTypes,
+} from "../spark-wallet/proto-reflection.js";
+
+// Try importing @bufbuild/protobuf reflection
+// This is just a test to see what's available
+describe("@bufbuild/protobuf Reflection Test", () => {
+  it("should explore available reflection APIs", () => {
+    console.log("=== @bufbuild/protobuf Reflection Exploration ===");
+
+    // Create a simple test message
+    const satsPayment: SatsPayment = { amount: 1000 };
+    const sparkFields: SparkInvoiceFields = {
+      version: 1,
+      id: new Uint8Array([
+        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+      ]),
+      paymentType: {
+        $case: "satsPayment",
+        satsPayment,
+      },
+    };
+
+    console.log("SatsPayment:", satsPayment);
+    console.log("SatsPayment constructor:", satsPayment.constructor);
+    console.log("SatsPayment prototype:", Object.getPrototypeOf(satsPayment));
+
+    console.log("SparkInvoiceFields:", sparkFields);
+    console.log("SparkInvoiceFields constructor:", sparkFields.constructor);
+    console.log(
+      "SparkInvoiceFields prototype:",
+      Object.getPrototypeOf(sparkFields),
+    );
+
+    // Check if there are any special properties or methods on the objects
+    const satsPaymentProps = Object.getOwnPropertyNames(satsPayment);
+    const sparkFieldsProps = Object.getOwnPropertyNames(sparkFields);
+
+    console.log("SatsPayment own properties:", satsPaymentProps);
+    console.log("SparkInvoiceFields own properties:", sparkFieldsProps);
+
+    // Check for any potential descriptor or reflection properties
+    const satsPaymentDescriptor =
+      (satsPayment as any).$typeName ||
+      (satsPayment as any).descriptor ||
+      (satsPayment as any).$type;
+    const sparkFieldsDescriptor =
+      (sparkFields as any).$typeName ||
+      (sparkFields as any).descriptor ||
+      (sparkFields as any).$type;
+
+    console.log("SatsPayment descriptor:", satsPaymentDescriptor);
+    console.log("SparkInvoiceFields descriptor:", sparkFieldsDescriptor);
+
+    // This test just logs information - it doesn't assert anything yet
+    expect(true).toBe(true);
+  });
+
+  it("should try importing @bufbuild/protobuf directly", async () => {
+    try {
+      // Try to import @bufbuild/protobuf runtime
+      const bufBuild = await import("@bufbuild/protobuf");
+      console.log("@bufbuild/protobuf exports:", Object.keys(bufBuild));
+
+      // Look for reflection-related exports
+      const reflectionKeys = Object.keys(bufBuild).filter(
+        (key) =>
+          key.toLowerCase().includes("reflect") ||
+          key.toLowerCase().includes("descriptor") ||
+          key.toLowerCase().includes("field") ||
+          key.toLowerCase().includes("message"),
+      );
+      console.log("Potential reflection keys:", reflectionKeys);
+
+      // Try to create a registry - this could give us reflection capabilities!
+      const { createFileRegistry } = bufBuild;
+      console.log("createFileRegistry function:", createFileRegistry);
+
+      // Can we create a registry and load our proto descriptors?
+      if (createFileRegistry) {
+        const registry = createFileRegistry();
+        console.log("Created registry:", registry);
+        console.log("Registry methods:", Object.getOwnPropertyNames(registry));
+      }
+    } catch (error) {
+      console.log("Failed to import @bufbuild/protobuf:", error);
+    }
+  });
+
+  it("should explore descriptor-based reflection", async () => {
+    try {
+      // Try importing descriptor types
+      const descriptorModule = await import(
+        "../proto/google/protobuf/descriptor.js"
+      );
+      console.log("Descriptor module exports:", Object.keys(descriptorModule));
+
+      // Check if we can access FileDescriptorSet
+      const { FileDescriptorSet } = descriptorModule;
+      if (FileDescriptorSet) {
+        console.log("FileDescriptorSet available!");
+        console.log(
+          "FileDescriptorSet methods:",
+          Object.getOwnPropertyNames(FileDescriptorSet),
+        );
+      }
+    } catch (error) {
+      console.log("Failed to import descriptors:", error);
+    }
+  });
+
+  it("should automatically extract field numbers using reflection", async () => {
+    console.log("=== Automatic Field Number Extraction ===");
+
+    try {
+      // List all available message types
+      const messageTypes = listMessageTypes();
+      console.log("Available message types:", messageTypes);
+
+      // Test automatic field number extraction for SparkInvoiceFields
+      const sparkFieldNumbers = getFieldNumbers("spark.SparkInvoiceFields");
+      console.log("SparkInvoiceFields field numbers:", sparkFieldNumbers);
+
+      // Test for SatsPayment
+      const satsPaymentNumbers = getFieldNumbers("spark.SatsPayment");
+      console.log("SatsPayment field numbers:", satsPaymentNumbers);
+
+      // No structural inference. Use explicit message name.
+      const satsPayment: SatsPayment = { amount: 1000 };
+      console.log(
+        "Explicit SatsPayment field numbers:",
+        getFieldNumbers("spark.SatsPayment"),
+      );
+
+      // Verify the field numbers are correct
+      expect(sparkFieldNumbers.version).toBe(1);
+      expect(sparkFieldNumbers.id).toBe(2);
+      expect(satsPaymentNumbers.amount).toBe(1);
+    } catch (error) {
+      console.error("Reflection test failed:", error);
+      // Don't fail the test, just log the error for debugging
+    }
+  });
+});

package/src/tests/cross-language-hash.test.ts

@@ -0,0 +1,79 @@
+// sdks/js/packages/spark-sdk/src/tests/cross-language-hash.test.ts
+/**
+ * Cross-language hash compatibility test for SparkInvoiceFields.
+ * This test validates that our JavaScript protoreflecthash implementation
+ * produces identical hashes to the Go implementation for the same data.
+ */
+
+import { describe, expect, it } from "@jest/globals";
+import fs from "fs";
+import { SparkInvoiceFields } from "../proto/spark.js";
+import { createProtoHasher } from "../spark-wallet/proto-hash.js";
+import { getFieldNumbers } from "../spark-wallet/proto-reflection.js";
+
+function toHex(bytes: Uint8Array): string {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+describe("Cross-Language Hash Compatibility", () => {
+  const hasher = createProtoHasher();
+
+  // Load canonical protobuf JSON test cases from the repo
+  const candidates = [
+    new URL(
+      "../../../../../../spark/testdata/cross_language_hash_cases_proto.json",
+      import.meta.url,
+    ),
+  ];
+
+  let jsonData: any | null = null;
+  for (const u of candidates) {
+    try {
+      const raw = fs.readFileSync(u, "utf8");
+      jsonData = JSON.parse(raw);
+      break;
+    } catch {
+      // try next
+    }
+  }
+
+  if (!jsonData) {
+    it("skips when proto-JSON dataset is absent", () => {
+      expect(true).toBe(true);
+    });
+    return;
+  }
+
+  const allCases = (jsonData.testCases || []) as any[];
+
+  it("should extract correct field numbers from SparkInvoiceFields", () => {
+    const fieldNumbers = getFieldNumbers("spark.SparkInvoiceFields");
+    expect(fieldNumbers.version).toBe(1);
+    expect(fieldNumbers.id).toBe(2);
+  });
+
+  for (const tc of allCases) {
+    it(`matches expected hash for ${tc.name}`, async () => {
+      const msg = SparkInvoiceFields.fromJSON(tc.sparkInvoiceFields);
+      const hash = await hasher.hashProto(msg, "spark.SparkInvoiceFields");
+      const hex = toHex(hash);
+
+      // Always 32 bytes and deterministic.
+      expect(hash).toHaveLength(32);
+      const hash2 = await hasher.hashProto(msg, "spark.SparkInvoiceFields");
+      expect(hash).toEqual(hash2);
+
+      // Compare against expected hash from JSON
+      expect(hex.toLowerCase()).toBe(String(tc.expectedHash).toLowerCase());
+    });
+  }
+
+  it("errors on nil/undefined messages", async () => {
+    await expect(hasher.hashProto(null as any)).rejects.toThrow(
+      /cannot hash nil/i,
+    );
+    await expect(hasher.hashProto(undefined as any)).rejects.toThrow(
+      /cannot hash nil/i,
+    );
+  });
+});

package/src/tests/integration/address.test.ts

@@ -12,7 +12,7 @@ describe("address", () => {
   ])(
     ".seedOrMnemonic(%s)",
     (seedOrMnemonic) => {
-      test.concurrent.each([["LOCAL", "spl", "bcrt"]])(
+      test.each([["LOCAL", "sparkl", "bcrt"]])(
         `.network(%s)`,
         async (network, sparkAddressPrefix, blockchainAddressPrefix) => {
           const options: ConfigOptions = {
@@ -32,13 +32,8 @@ describe("address", () => {
           );
           expect(sparkAddress).toEqual(await wallet.getSparkAddress());
 
-          // Make multiple concurrent calls to getSingleUseDepositAddress
           const depositAddresses = await Promise.all([
             wallet.getSingleUseDepositAddress(),
-            wallet.getSingleUseDepositAddress(),
-            wallet.getSingleUseDepositAddress(),
-            wallet.getSingleUseDepositAddress(),
-            wallet.getSingleUseDepositAddress(),
           ]);
 
           // Verify each address is unique and valid
@@ -49,7 +44,7 @@ describe("address", () => {
             );
             addressMap.set(depositAddress, depositAddress);
           }
-          expect(addressMap.size).toBe(5);
+          expect(addressMap.size).toBe(1);
 
           // Create a new wallet with the same seed or mnemonic
           const { wallet: wallet2, ...rest2 } =
@@ -67,10 +62,6 @@ describe("address", () => {
           // New wallet should continue to generate unique addresses
           const depositAddresses2 = await Promise.all([
             wallet2.getSingleUseDepositAddress(),
-            wallet2.getSingleUseDepositAddress(),
-            wallet2.getSingleUseDepositAddress(),
-            wallet2.getSingleUseDepositAddress(),
-            wallet2.getSingleUseDepositAddress(),
           ]);
 
           // Verify each address is unique and valid
@@ -80,7 +71,7 @@ describe("address", () => {
             );
             addressMap.set(depositAddress, depositAddress);
           }
-          expect(addressMap.size).toBe(10);
+          expect(addressMap.size).toBe(2);
         },
         30000,
       );

package/src/tests/integration/ssp/static_deposit.test.ts

@@ -266,19 +266,25 @@ describe("SSP static deposit address integration", () => {
 
       for (let i = 0; i < 98; i++) {
         await faucet.sendToAddress(depositAddress, THIRD_DEPOSIT_AMOUNT);
-        await faucet.mineBlocks(6);
-        await new Promise((resolve) => setTimeout(resolve, 100));
       }
 
       await faucet.mineBlocks(6);
-      await new Promise((resolve) => setTimeout(resolve, 1000));
 
-      const utxosExcludeClaimed = await userWallet.getUtxosForDepositAddress(
-        depositAddress,
-        100,
-        0,
-        true,
-      );
+      let utxosExcludeClaimed: any[] = [];
+      const utxosExcludeClaimedExpected = 98;
+      const maxAttempts = 10;
+      for (let attempt = 1; attempt <= 10; attempt++) {
+        utxosExcludeClaimed = await userWallet.getUtxosForDepositAddress(
+          depositAddress,
+          100,
+          0,
+          true,
+        );
+        if (utxosExcludeClaimed.length === utxosExcludeClaimedExpected) break;
+        if (attempt < maxAttempts)
+          await new Promise((r) => setTimeout(r, 5000));
+      }
+
       expect(utxosExcludeClaimed.length).toBe(98);
 
       const utxos = await userWallet.getUtxosForDepositAddress(

package/src/tests/integration/static_deposit.test.ts

@@ -52,6 +52,32 @@ describe("SSP static deposit address integration", () => {
       ).rejects.toThrow();
     }, 600000);
 
+    it("should refund and broadcast a static deposit refund transaction", async () => {
+      const {
+        wallet: userWallet,
+        depositAddress,
+        signedTx,
+        vout,
+        faucet,
+      } = await initWallet(DEPOSIT_AMOUNT, "LOCAL");
+
+      // Wait for the transaction to be mined
+      await faucet.mineBlocks(6);
+
+      const transactionId = signedTx.id;
+
+      const txId = await userWallet.refundAndBroadcastStaticDeposit({
+        depositTransactionId: transactionId,
+        outputIndex: vout!,
+        destinationAddress: depositAddress,
+        satsPerVbyteFee: 2,
+      });
+
+      await faucet.mineBlocks(6);
+
+      expect(txId).toBeDefined();
+    }, 600000);
+
     it("should fail due to low fee", async () => {
       console.log("Initializing wallet for low-fee refund test...");
       const {