@buildonspark/spark-sdk 0.5.0 → 0.5.1

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

@@ -237,7 +237,12 @@ describe.each(walletTypes)(
           throw new Error("test: Leaf not found");
         }
         return {
-          leaf: leaf.leaf,
+          leaf: {
+            ...leaf.leaf,
+            refundTx: leaf.intermediateRefundTx,
+            directRefundTx: leaf.intermediateDirectRefundTx,
+            directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx,
+          },
           keyDerivation: {
             type: KeyDerivationType.ECIES,
             path: leaf.secretCipher,
@@ -356,7 +361,12 @@ describe.each(walletTypes)(
           throw new Error("test: Leaf not found");
         }
         return {
-          leaf: leaf.leaf,
+          leaf: {
+            ...leaf.leaf,
+            refundTx: leaf.intermediateRefundTx,
+            directRefundTx: leaf.intermediateDirectRefundTx,
+            directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx,
+          },
           keyDerivation: {
             type: KeyDerivationType.ECIES,
             path: leaf.secretCipher,
@@ -474,7 +484,12 @@ describe.each(walletTypes)(
           throw new Error("test: Leaf not found");
         }
         return {
-          leaf: leaf.leaf,
+          leaf: {
+            ...leaf.leaf,
+            refundTx: leaf.intermediateRefundTx,
+            directRefundTx: leaf.intermediateDirectRefundTx,
+            directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx,
+          },
           keyDerivation: {
             type: KeyDerivationType.ECIES,
             path: leaf.secretCipher,
@@ -598,7 +613,12 @@ describe.each(walletTypes)(
           throw new Error("test: Leaf not found");
         }
         return {
-          leaf: leaf.leaf,
+          leaf: {
+            ...leaf.leaf,
+            refundTx: leaf.intermediateRefundTx,
+            directRefundTx: leaf.intermediateDirectRefundTx,
+            directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx,
+          },
           keyDerivation: {
             type: KeyDerivationType.ECIES,
             path: leaf.secretCipher,

package/src/tests/integration/time-sync.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "@jest/globals";
+import { SparkWalletTestingIntegration } from "../utils/spark-testing-wallet.js";
+
+describe("Server time synchronization", () => {
+  it("should be synced after making a gRPC call", async () => {
+    const { wallet } = await SparkWalletTestingIntegration.initialize({
+      options: { network: "LOCAL" },
+    });
+
+    const connectionManager = wallet.getConnectionManager();
+
+    await wallet.getSparkAddress();
+
+    expect(connectionManager.isTimeSynced()).toBe(true);
+
+    await wallet.cleanupConnections();
+  }, 30000);
+});

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

@@ -100,7 +100,12 @@ describe.each(walletTypes)(
 
       const claimingNodes: LeafKeyTweak[] = receiverTransfer!.leaves.map(
         (leaf) => ({
-          leaf: leaf.leaf!,
+          leaf: {
+            ...leaf.leaf!,
+            refundTx: leaf.intermediateRefundTx,
+            directRefundTx: leaf.intermediateDirectRefundTx,
+            directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx,
+          },
           keyDerivation: {
             type: KeyDerivationType.ECIES,
             path: leaf.secretCipher,
@@ -197,7 +202,12 @@ describe.each(walletTypes)(
 
       const claimingNodes: LeafKeyTweak[] = receiverTransfer!.leaves.map(
         (leaf) => ({
-          leaf: leaf.leaf!,
+          leaf: {
+            ...leaf.leaf!,
+            refundTx: leaf.intermediateRefundTx,
+            directRefundTx: leaf.intermediateDirectRefundTx,
+            directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx,
+          },
           keyDerivation: {
             type: KeyDerivationType.ECIES,
             path: leaf.secretCipher,
@@ -342,7 +352,12 @@ describe.each(walletTypes)(
 
         const claimingNodes: LeafKeyTweak[] = receiverTransfer!.leaves.map(
           (leaf) => ({
-            leaf: rootNode,
+            leaf: {
+              ...rootNode,
+              refundTx: leaf.intermediateRefundTx,
+              directRefundTx: leaf.intermediateDirectRefundTx,
+              directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx,
+            },
             keyDerivation: {
               type: KeyDerivationType.ECIES,
               path: receiverTransfer!.leaves[0]!.secretCipher,
@@ -691,7 +706,12 @@ describe.each(walletTypes)("transfer v2", ({ name, Signer, createTree }) => {
 
     const claimingNodes: LeafKeyTweak[] = receiverTransfer!.leaves.map(
       (leaf) => ({
-        leaf: leaf.leaf!,
+        leaf: {
+          ...leaf.leaf!,
+          refundTx: leaf.intermediateRefundTx,
+          directRefundTx: leaf.intermediateDirectRefundTx,
+          directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx,
+        },
         keyDerivation: {
           type: KeyDerivationType.ECIES,
           path: leaf.secretCipher,
@@ -753,7 +773,12 @@ describe.each(walletTypes)("transfer v2", ({ name, Signer, createTree }) => {
 
     const claimingNodes: LeafKeyTweak[] = receiverTransfer!.leaves.map(
       (leaf) => ({
-        leaf: rootNode,
+        leaf: {
+          ...rootNode,
+          refundTx: leaf.intermediateRefundTx,
+          directRefundTx: leaf.intermediateDirectRefundTx,
+          directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx,
+        },
         keyDerivation: {
           type: KeyDerivationType.ECIES,
           path: receiverTransfer!.leaves[0]!.secretCipher,
@@ -1049,7 +1074,12 @@ describe.each(walletTypes)("transfer v2", ({ name, Signer, createTree }) => {
     const transfer = pendingTransfers.transfers[0]!;
 
     const claimingNodes: LeafKeyTweak[] = transfer!.leaves.map((leaf) => ({
-      leaf: leaf.leaf!,
+      leaf: {
+        ...leaf.leaf!,
+        refundTx: leaf.intermediateRefundTx,
+        directRefundTx: leaf.intermediateDirectRefundTx,
+        directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx,
+      },
       keyDerivation: {
         type: KeyDerivationType.ECIES,
         path: leaf.secretCipher,
@@ -1112,7 +1142,12 @@ describe.each(walletTypes)("transfer v2", ({ name, Signer, createTree }) => {
     const transfer = pendingTransfers.transfers[0]!;
 
     const claimingNodes: LeafKeyTweak[] = transfer!.leaves.map((leaf) => ({
-      leaf: leaf.leaf!,
+      leaf: {
+        ...leaf.leaf!,
+        refundTx: leaf.intermediateRefundTx,
+        directRefundTx: leaf.intermediateDirectRefundTx,
+        directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx,
+      },
       keyDerivation: {
         type: KeyDerivationType.ECIES,
         path: leaf.secretCipher,

package/src/tests/ssp-client-retry.test.ts

@@ -0,0 +1,161 @@
+import { describe, expect, it, jest } from "@jest/globals";
+
+// Re-create the retry logic here for testing (since it's not exported)
+const RETRYABLE_STATUS_CODES = new Set([502, 503, 504]);
+
+type FetchFn = (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>;
+
+function createRetryFetch(
+  baseFetch: FetchFn,
+  maxRetries: number = 5,
+  baseDelayMs: number = 1000,
+): FetchFn {
+  return async (input, init) => {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const response = await baseFetch(input, init);
+
+      if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < maxRetries) {
+        const delay = Math.min(baseDelayMs * Math.pow(2, attempt), 10000);
+        await new Promise((r) => setTimeout(r, delay));
+        continue;
+      }
+
+      return response;
+    }
+
+    throw new Error("Retry loop exited unexpectedly");
+  };
+}
+
+describe("SspClient retry fetch", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it("should return response immediately on 200", async () => {
+    const mockFetch = jest
+      .fn<FetchFn>()
+      .mockResolvedValue(new Response("ok", { status: 200 }));
+
+    const retryFetch = createRetryFetch(mockFetch, 3, 100);
+    const response = await retryFetch("https://example.com", {});
+
+    expect(response.status).toBe(200);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("should retry on 502 and succeed", async () => {
+    const mockFetch = jest
+      .fn<FetchFn>()
+      .mockResolvedValueOnce(new Response("bad gateway", { status: 502 }))
+      .mockResolvedValueOnce(new Response("ok", { status: 200 }));
+
+    const retryFetch = createRetryFetch(mockFetch, 3, 100);
+
+    const promise = retryFetch("https://example.com", {});
+    await jest.runAllTimersAsync();
+    const response = await promise;
+
+    expect(response.status).toBe(200);
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+
+  it("should retry on 503 and succeed", async () => {
+    const mockFetch = jest
+      .fn<FetchFn>()
+      .mockResolvedValueOnce(
+        new Response("service unavailable", { status: 503 }),
+      )
+      .mockResolvedValueOnce(new Response("ok", { status: 200 }));
+
+    const retryFetch = createRetryFetch(mockFetch, 3, 100);
+
+    const promise = retryFetch("https://example.com", {});
+    await jest.runAllTimersAsync();
+    const response = await promise;
+
+    expect(response.status).toBe(200);
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+
+  it("should retry on 504 and succeed", async () => {
+    const mockFetch = jest
+      .fn<FetchFn>()
+      .mockResolvedValueOnce(new Response("gateway timeout", { status: 504 }))
+      .mockResolvedValueOnce(new Response("ok", { status: 200 }));
+
+    const retryFetch = createRetryFetch(mockFetch, 3, 100);
+
+    const promise = retryFetch("https://example.com", {});
+    await jest.runAllTimersAsync();
+    const response = await promise;
+
+    expect(response.status).toBe(200);
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+
+  it("should return 502 after max retries exhausted", async () => {
+    const mockFetch = jest
+      .fn<FetchFn>()
+      .mockResolvedValue(new Response("bad gateway", { status: 502 }));
+
+    const retryFetch = createRetryFetch(mockFetch, 3, 100);
+
+    const promise = retryFetch("https://example.com", {});
+    await jest.runAllTimersAsync();
+    const response = await promise;
+
+    // After maxRetries, it returns the last response
+    expect(response.status).toBe(502);
+    expect(mockFetch).toHaveBeenCalledTimes(4); // 1 initial + 3 retries
+  });
+
+  it("should not retry on 400", async () => {
+    const mockFetch = jest
+      .fn<FetchFn>()
+      .mockResolvedValue(new Response("bad request", { status: 400 }));
+
+    const retryFetch = createRetryFetch(mockFetch, 3, 100);
+    const response = await retryFetch("https://example.com", {});
+
+    expect(response.status).toBe(400);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("should not retry on 500", async () => {
+    const mockFetch = jest
+      .fn<FetchFn>()
+      .mockResolvedValue(new Response("internal error", { status: 500 }));
+
+    const retryFetch = createRetryFetch(mockFetch, 3, 100);
+    const response = await retryFetch("https://example.com", {});
+
+    expect(response.status).toBe(500);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("should retry multiple times before succeeding", async () => {
+    const mockFetch = jest
+      .fn<FetchFn>()
+      .mockResolvedValueOnce(new Response("", { status: 504 }))
+      .mockResolvedValueOnce(new Response("", { status: 503 }))
+      .mockResolvedValueOnce(new Response("", { status: 502 }))
+      .mockResolvedValueOnce(new Response("ok", { status: 200 }));
+
+    const retryFetch = createRetryFetch(mockFetch, 3, 100);
+
+    const promise = retryFetch("https://example.com", {});
+    await jest.runAllTimersAsync();
+    const response = await promise;
+
+    expect(response.status).toBe(200);
+    expect(mockFetch).toHaveBeenCalledTimes(4);
+  });
+});

package/src/tests/token-hashing.test.ts

@@ -4,6 +4,7 @@ import { Network } from "../proto/spark.js";
 import {
   hashTokenTransactionV1,
   hashTokenTransactionV2,
+  sortInvoiceAttachments,
 } from "../utils/token-hashing.js";
 
 // Test constants for consistent test data across all hash tests - matching Go test data
@@ -316,3 +317,94 @@ describe("Hash Token Transaction V2", () => {
     ]);
   });
 });
+
+describe("sortInvoiceAttachments", () => {
+  it("should sort by bech32m string (lexicographic) not by UUID bytes", () => {
+    const attachments = [
+      {
+        sparkInvoice:
+          "sparkl1pgssx2r8ytpwc4exthzsg7ss7a7m69ty8p6s32j0rw65wmd38eamutyezf2ssqgjzqqe4mhekkjh9h58tq0k0522j0uj5zjfdemx76trv5szxvf6psygmq73eyrpps8zctwsyx39pgsy3dytxng6g6dmenc45enqtuc03ml2ryqn5wlxkgtkd4tnckaaj6cjq9h35spgdegtqzfc4uc8c5jcydzhrtv9dznjkwvv66835cxzr60zaczrapxfps6nlk7kqpa4xahmrm4yfm57jxu0l4326rnv4psuwr3ggk582jf9azn",
+      },
+      {
+        sparkInvoice:
+          "sparkl1pgssx2r8ytpwc4exthzsg7ss7a7m69ty8p6s32j0rw65wmd38eamutyezf2ssqgjzqqe4mhekknhnldmyjqdka8ajjdz5zjfdemx76trv5szxv36psygmq73eyrpps8thn0qyx39pgsy3dytxng6g6dmenc45enqtuc03ml2ryqn5wlxkgtkd4tnckaaj6cjq80p5s82syz0gr60at4yv2szssqyr9r8jlh57aa8jan0xskmkv2jqd93zty4vef3lc32ksxfq5c57hpw2j542dnjpjnya3lad2muqcqz26jcj2a9qkf",
+      },
+      {
+        sparkInvoice:
+          "sparkl1pgss9e7ld3nw57ejatjwq64xawwf9akm0yzn09ywfyj5wmr99t5fwrt8zftqsqgjzqqe4mhekk58qsvlkfqd7qlqthvz5zjfdemx76trv5szxve6psygmq73eyrppq8sl80qyx3xpgsy3dytxng6g6dmenc45enqtuc03ml2ryqn5wlxkgtkd4tnckaaj6cjqgq56xjqesr97xccw4u8qn8k68sddsk7rzcs5ctg27pqfu8v0mkfh350tkt4e3g8qr3qyqzcd99recq7ud6yhtvfhtj948a9944zz7q9xxrjhvgp58ut6",
+      },
+    ];
+
+    const sorted = sortInvoiceAttachments(attachments);
+
+    expect(sorted).toEqual([
+      {
+        sparkInvoice:
+          "sparkl1pgss9e7ld3nw57ejatjwq64xawwf9akm0yzn09ywfyj5wmr99t5fwrt8zftqsqgjzqqe4mhekk58qsvlkfqd7qlqthvz5zjfdemx76trv5szxve6psygmq73eyrppq8sl80qyx3xpgsy3dytxng6g6dmenc45enqtuc03ml2ryqn5wlxkgtkd4tnckaaj6cjqgq56xjqesr97xccw4u8qn8k68sddsk7rzcs5ctg27pqfu8v0mkfh350tkt4e3g8qr3qyqzcd99recq7ud6yhtvfhtj948a9944zz7q9xxrjhvgp58ut6",
+      },
+      {
+        sparkInvoice:
+          "sparkl1pgssx2r8ytpwc4exthzsg7ss7a7m69ty8p6s32j0rw65wmd38eamutyezf2ssqgjzqqe4mhekkjh9h58tq0k0522j0uj5zjfdemx76trv5szxvf6psygmq73eyrpps8zctwsyx39pgsy3dytxng6g6dmenc45enqtuc03ml2ryqn5wlxkgtkd4tnckaaj6cjq9h35spgdegtqzfc4uc8c5jcydzhrtv9dznjkwvv66835cxzr60zaczrapxfps6nlk7kqpa4xahmrm4yfm57jxu0l4326rnv4psuwr3ggk582jf9azn",
+      },
+      {
+        sparkInvoice:
+          "sparkl1pgssx2r8ytpwc4exthzsg7ss7a7m69ty8p6s32j0rw65wmd38eamutyezf2ssqgjzqqe4mhekknhnldmyjqdka8ajjdz5zjfdemx76trv5szxv36psygmq73eyrpps8thn0qyx39pgsy3dytxng6g6dmenc45enqtuc03ml2ryqn5wlxkgtkd4tnckaaj6cjq80p5s82syz0gr60at4yv2szssqyr9r8jlh57aa8jan0xskmkv2jqd93zty4vef3lc32ksxfq5c57hpw2j542dnjpjnya3lad2muqcqz26jcj2a9qkf",
+      },
+    ]);
+  });
+
+  it("should verify sorted invoices are in correct order", () => {
+    const attachments = [
+      {
+        sparkInvoice:
+          "sparkl1pgssx2r8ytpwc4exthzsg7ss7a7m69ty8p6s32j0rw65wmd38eamutyezf2ssqgjzqqe4mhekkjh9h58tq0k0522j0uj5zjfdemx76trv5szxvf6psygmq73eyrpps8zctwsyx39pgsy3dytxng6g6dmenc45enqtuc03ml2ryqn5wlxkgtkd4tnckaaj6cjq9h35spgdegtqzfc4uc8c5jcydzhrtv9dznjkwvv66835cxzr60zaczrapxfps6nlk7kqpa4xahmrm4yfm57jxu0l4326rnv4psuwr3ggk582jf9azn",
+      },
+      {
+        sparkInvoice:
+          "sparkl1pgssx2r8ytpwc4exthzsg7ss7a7m69ty8p6s32j0rw65wmd38eamutyezf2ssqgjzqqe4mhekknhnldmyjqdka8ajjdz5zjfdemx76trv5szxv36psygmq73eyrpps8thn0qyx39pgsy3dytxng6g6dmenc45enqtuc03ml2ryqn5wlxkgtkd4tnckaaj6cjq80p5s82syz0gr60at4yv2szssqyr9r8jlh57aa8jan0xskmkv2jqd93zty4vef3lc32ksxfq5c57hpw2j542dnjpjnya3lad2muqcqz26jcj2a9qkf",
+      },
+      {
+        sparkInvoice:
+          "sparkl1pgss9e7ld3nw57ejatjwq64xawwf9akm0yzn09ywfyj5wmr99t5fwrt8zftqsqgjzqqe4mhekk58qsvlkfqd7qlqthvz5zjfdemx76trv5szxve6psygmq73eyrppq8sl80qyx3xpgsy3dytxng6g6dmenc45enqtuc03ml2ryqn5wlxkgtkd4tnckaaj6cjqgq56xjqesr97xccw4u8qn8k68sddsk7rzcs5ctg27pqfu8v0mkfh350tkt4e3g8qr3qyqzcd99recq7ud6yhtvfhtj948a9944zz7q9xxrjhvgp58ut6",
+      },
+    ];
+
+    const sorted = sortInvoiceAttachments(attachments);
+
+    expect(sorted).toEqual([
+      {
+        sparkInvoice:
+          "sparkl1pgss9e7ld3nw57ejatjwq64xawwf9akm0yzn09ywfyj5wmr99t5fwrt8zftqsqgjzqqe4mhekk58qsvlkfqd7qlqthvz5zjfdemx76trv5szxve6psygmq73eyrppq8sl80qyx3xpgsy3dytxng6g6dmenc45enqtuc03ml2ryqn5wlxkgtkd4tnckaaj6cjqgq56xjqesr97xccw4u8qn8k68sddsk7rzcs5ctg27pqfu8v0mkfh350tkt4e3g8qr3qyqzcd99recq7ud6yhtvfhtj948a9944zz7q9xxrjhvgp58ut6",
+      },
+      {
+        sparkInvoice:
+          "sparkl1pgssx2r8ytpwc4exthzsg7ss7a7m69ty8p6s32j0rw65wmd38eamutyezf2ssqgjzqqe4mhekkjh9h58tq0k0522j0uj5zjfdemx76trv5szxvf6psygmq73eyrpps8zctwsyx39pgsy3dytxng6g6dmenc45enqtuc03ml2ryqn5wlxkgtkd4tnckaaj6cjq9h35spgdegtqzfc4uc8c5jcydzhrtv9dznjkwvv66835cxzr60zaczrapxfps6nlk7kqpa4xahmrm4yfm57jxu0l4326rnv4psuwr3ggk582jf9azn",
+      },
+      {
+        sparkInvoice:
+          "sparkl1pgssx2r8ytpwc4exthzsg7ss7a7m69ty8p6s32j0rw65wmd38eamutyezf2ssqgjzqqe4mhekknhnldmyjqdka8ajjdz5zjfdemx76trv5szxv36psygmq73eyrpps8thn0qyx39pgsy3dytxng6g6dmenc45enqtuc03ml2ryqn5wlxkgtkd4tnckaaj6cjq80p5s82syz0gr60at4yv2szssqyr9r8jlh57aa8jan0xskmkv2jqd93zty4vef3lc32ksxfq5c57hpw2j542dnjpjnya3lad2muqcqz26jcj2a9qkf",
+      },
+    ]);
+  });
+
+  it("should return undefined for undefined input", () => {
+    expect(sortInvoiceAttachments(undefined)).toBeUndefined();
+  });
+
+  it("should return empty array for empty input", () => {
+    expect(sortInvoiceAttachments([])).toEqual([]);
+  });
+
+  it("should handle single invoice", () => {
+    const testInvoice = TEST_INVOICE_ATTACHMENTS[0];
+    if (!testInvoice) throw new Error("Test invoice not found");
+
+    const single = [
+      {
+        sparkInvoice: testInvoice.sparkInvoice,
+      },
+    ];
+    const sorted = sortInvoiceAttachments(single);
+    expect(sorted).toEqual(single);
+  });
+});

package/src/utils/token-hashing.ts

@@ -1118,58 +1118,11 @@ export function sortInvoiceAttachments(
     return attachments;
   }
 
-  type Keyed = { id: Uint8Array; attachment: InvoiceAttachment };
-  const keyed: Keyed[] = [];
-
-  for (let i = 0; i < attachments.length; i++) {
-    const attachment = attachments[i];
-    if (!attachment) {
-      throw new SparkValidationError(
-        `invoice attachment at index ${i} cannot be null`,
-        {
-          field: `invoiceAttachments[${i}]`,
-          index: i,
-        },
-      );
-    }
-    const invoice = attachment.sparkInvoice;
-
-    let idBytes: Uint8Array | undefined;
-    try {
-      const decoded = bech32m.decode(invoice as any, 500);
-      const payload = SparkAddress.decode(bech32m.fromWords(decoded.words));
-      if (!payload.sparkInvoiceFields || !payload.sparkInvoiceFields.id) {
-        throw new Error("missing spark invoice fields or id");
-      }
-      idBytes = payload.sparkInvoiceFields.id;
-    } catch (err) {
-      throw new SparkValidationError(`invalid invoice at ${i}`, {
-        field: `invoiceAttachments[${i}].sparkInvoice`,
-        index: i,
-        value: invoice,
-        error: err,
-      });
-    }
-    if (!idBytes || idBytes.length !== 16) {
-      throw new SparkValidationError(`invalid invoice id at ${i}`, {
-        field: `invoiceAttachments[${i}].sparkInvoice`,
-        index: i,
-      });
-    }
-    keyed.push({ id: idBytes, attachment });
-  }
-
-  // Sort by UUID bytes (lexicographically)
-  keyed.sort((a, b) => {
-    for (let j = 0; j < a.id.length && j < b.id.length; j++) {
-      const av = a.id[j] as number;
-      const bv = b.id[j] as number;
-      if (av !== bv) return av - bv;
-    }
-    return a.id.length - b.id.length;
+  return [...attachments].sort((a, b) => {
+    const invoiceA = a.sparkInvoice;
+    const invoiceB = b.sparkInvoice;
+    return invoiceA < invoiceB ? -1 : invoiceA > invoiceB ? 1 : 0;
   });
-
-  return keyed.map((k) => k.attachment);
 }
 
 export async function hashTokenTransactionV3(

package/src/utils/transaction.ts

@@ -292,8 +292,7 @@ interface RefundTxWithSequenceParams extends RefundTxParams {
   enforceTimelocks?: boolean;
 }
 
-interface RefundTxWithSequenceAndConnectorOutputParams
-  extends RefundTxWithSequenceParams {
+interface RefundTxWithSequenceAndConnectorOutputParams extends RefundTxWithSequenceParams {
   connectorOutput: TransactionInput;
 }