@buildonspark/spark-sdk 0.3.3 → 0.3.5

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

@@ -5,17 +5,17 @@ import {
   bytesToNumberBE,
   equalBytes,
   hexToBytes,
-  numberToVarBytesBE,
 } from "@noble/curves/utils";
 import { validateMnemonic } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english";
 import { Address, OutScript, Transaction } from "@scure/btc-signer";
 import { TransactionInput } from "@scure/btc-signer/psbt";
 import { Mutex } from "async-mutex";
-import { uuidv7, uuidv7obj } from "uuidv7";
+import { uuidv7 } from "uuidv7";
 import {
   ConfigurationError,
   NetworkError,
+  NotImplementedError,
   RPCError,
   ValidationError,
 } from "../errors/types.js";
@@ -40,6 +40,7 @@ import {
   OutputWithPreviousTransactionData,
   QueryNodesRequest,
   QueryNodesResponse,
+  QuerySparkInvoicesResponse,
   SigningJob,
   SubscribeToEventsResponse,
   Transfer,
@@ -118,14 +119,11 @@ import {
 import {
   decodeSparkAddress,
   encodeSparkAddress,
-  encodeSparkAddressWithSignature,
   isSafeForNumber,
   SparkAddressFormat,
-  validateSparkInvoiceFields,
 } from "../utils/address.js";
 import { chunkArray } from "../utils/chunkArray.js";
 import { getFetch } from "../utils/fetch.js";
-import { HashSparkInvoice } from "../utils/invoice-hashing.js";
 import { addPublicKeys } from "../utils/keys.js";
 import { RetryContext, withRetry } from "../utils/retry.js";
 import {
@@ -141,6 +139,7 @@ import type {
   InitWalletResponse,
   InvalidInvoice,
   PayLightningInvoiceParams,
+  SparkWalletEvents,
   SparkWalletProps,
   TokenBalanceMap,
   TokenInvoice,
@@ -150,7 +149,6 @@ import type {
   TransferWithInvoiceOutcome,
   TransferWithInvoiceParams,
   UserTokenMetadata,
-  SparkWalletEvents,
 } from "./types.js";
 import { SparkWalletEvent } from "./types.js";
 
@@ -836,51 +834,8 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
     senderPublicKey?: string;
     expiryTime?: Date;
   }): Promise<SparkAddressFormat> {
-    const MAX_SATS_AMOUNT = 2_100_000_000_000_000; // 21_000_000 BTC * 100_000_000 sats/BTC
-    if (amount && (amount < 0 || amount > MAX_SATS_AMOUNT)) {
-      throw new ValidationError(
-        `Amount must be between 0 and ${MAX_SATS_AMOUNT} sats`,
-        {
-          field: "amount",
-          value: amount,
-          expected: `less than or equal to ${MAX_SATS_AMOUNT}`,
-        },
-      );
-    }
-    const protoPayment = {
-      $case: "satsPayment",
-      satsPayment: {
-        amount: amount,
-      },
-    } as const;
-    const invoiceFields = {
-      version: 1,
-      id: uuidv7obj().bytes,
-      paymentType: protoPayment,
-      memo: memo,
-      senderPublicKey: senderPublicKey
-        ? hexToBytes(senderPublicKey)
-        : undefined,
-      expiryTime: expiryTime ?? undefined,
-    };
-    validateSparkInvoiceFields(invoiceFields);
-
-    const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-    const hash = HashSparkInvoice(
-      invoiceFields,
-      identityPublicKey,
-      this.config.getNetworkType(),
-    );
-    const signature = await this.config.signer.signSchnorrWithIdentityKey(hash);
-
-    return encodeSparkAddressWithSignature(
-      {
-        identityPublicKey: bytesToHex(identityPublicKey),
-        network: this.config.getNetworkType(),
-        sparkInvoiceFields: invoiceFields,
-      },
-      signature,
-    );
+    // TODO: (CNT-493) Re-enable invoice functionality once spark address migration is complete
+    throw new NotImplementedError("Invoice functionality is not enabled");
   }
 
   /**
@@ -907,57 +862,8 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
     senderPublicKey?: string;
     expiryTime?: Date;
   }): Promise<SparkAddressFormat> {
-    const MAX_UINT128 = BigInt(2 ** 128 - 1);
-    if (amount && (amount < 0 || amount > MAX_UINT128)) {
-      throw new ValidationError(`Amount must be between 0 and ${MAX_UINT128}`, {
-        field: "amount",
-        value: amount,
-        expected: `greater than or equal to 0 and less than or equal to ${MAX_UINT128}`,
-      });
-    }
-    let decodedTokenIdentifier: Uint8Array | undefined = undefined;
-    if (tokenIdentifier) {
-      decodedTokenIdentifier = decodeBech32mTokenIdentifier(
-        tokenIdentifier,
-        this.config.getNetworkType(),
-      ).tokenIdentifier;
-    }
-
-    const protoPayment = {
-      $case: "tokensPayment",
-      tokensPayment: {
-        tokenIdentifier: decodedTokenIdentifier ?? undefined,
-        amount: amount ? numberToVarBytesBE(amount) : undefined,
-      },
-    } as const;
-    const invoiceFields = {
-      version: 1,
-      id: uuidv7obj().bytes,
-      paymentType: protoPayment,
-      memo: memo ?? undefined,
-      senderPublicKey: senderPublicKey
-        ? hexToBytes(senderPublicKey)
-        : undefined,
-      expiryTime: expiryTime ?? undefined,
-    };
-    validateSparkInvoiceFields(invoiceFields);
-
-    const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-    const hash = HashSparkInvoice(
-      invoiceFields,
-      identityPublicKey,
-      this.config.getNetworkType(),
-    );
-    const signature = await this.config.signer.signSchnorrWithIdentityKey(hash);
-
-    return encodeSparkAddressWithSignature(
-      {
-        identityPublicKey: bytesToHex(identityPublicKey),
-        network: this.config.getNetworkType(),
-        sparkInvoiceFields: invoiceFields,
-      },
-      signature,
-    );
+    // TODO: (CNT-493) Re-enable invoice functionality once spark address migration is complete
+    throw new NotImplementedError("Invoice functionality is not enabled");
   }
 
   /**
@@ -3370,11 +3276,41 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
         throw new Error("Failed to create lightning invoice");
       }
 
+      const decodedInvoice = decodeInvoice(invoice.invoice.encodedInvoice);
+
+      if (
+        invoice.invoice.paymentHash !== bytesToHex(paymentHash) ||
+        decodedInvoice.paymentHash !== bytesToHex(paymentHash)
+      ) {
+        throw new ValidationError("Payment hash mismatch", {
+          field: "paymentHash",
+          value: invoice.invoice.paymentHash,
+          expected: bytesToHex(paymentHash),
+        });
+      }
+
+      if (decodedInvoice.amountMSats === null && amountSats !== 0) {
+        throw new ValidationError("Amount mismatch", {
+          field: "amountMSats",
+          value: "null",
+          expected: amountSats * 1000,
+        });
+      }
+
+      if (
+        decodedInvoice.amountMSats !== null &&
+        decodedInvoice.amountMSats !== BigInt(amountSats * 1000)
+      ) {
+        throw new ValidationError("Amount mismatch", {
+          field: "amountMSats",
+          value: decodedInvoice.amountMSats,
+          expected: amountSats * 1000,
+        });
+      }
+
       // Validate the spark address embedded in the lightning invoice
       if (includeSparkAddress) {
-        const sparkFallbackAddress = decodeInvoice(
-          invoice.invoice.encodedInvoice,
-        ).fallbackAddress;
+        const sparkFallbackAddress = decodedInvoice.fallbackAddress;
 
         if (!sparkFallbackAddress) {
           throw new ValidationError(
@@ -3400,6 +3336,14 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
             },
           );
         }
+      } else if (decodedInvoice.fallbackAddress !== undefined) {
+        throw new ValidationError(
+          "Spark fallback address found in lightning invoice but includeSparkAddress is false",
+          {
+            field: "sparkFallbackAddress",
+            value: decodedInvoice.fallbackAddress,
+          },
+        );
       }
 
       return invoice;
@@ -3613,116 +3557,8 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
       amount?: bigint;
     }[],
   ): Promise<FulfillSparkInvoiceResponse> {
-    if (!Array.isArray(sparkInvoices) || sparkInvoices.length === 0) {
-      throw new ValidationError("No Spark invoices provided", {
-        field: "sparkInvoices",
-        value: sparkInvoices,
-        expected: "Non-empty array",
-      });
-    }
-    const satsTransactionSuccess: {
-      invoice: SparkAddressFormat;
-      transferResponse: WalletTransfer;
-    }[] = [];
-    const satsTransactionErrors: {
-      invoice: string;
-      error: Error;
-    }[] = [];
-    const tokenTransactionSuccess: {
-      tokenIdentifier: Bech32mTokenIdentifier;
-      txid: string;
-    }[] = [];
-    const tokenTransactionErrors: {
-      tokenIdentifier: Bech32mTokenIdentifier;
-      error: Error;
-    }[] = [];
-
-    const { satsInvoices, tokenInvoices, invalidInvoices } =
-      await this.groupSparkInvoicesByPaymentType(sparkInvoices);
-    if (invalidInvoices.length > 0) {
-      return {
-        satsTransactionSuccess,
-        satsTransactionErrors,
-        tokenTransactionSuccess,
-        tokenTransactionErrors,
-        invalidInvoices,
-      };
-    }
-
-    if (tokenInvoices.size > 0) {
-      await this.syncTokenOutputs();
-      const tokenTransferTasks: Promise<
-        | { ok: true; tokenIdentifier: Bech32mTokenIdentifier; txid: string }
-        | { ok: false; tokenIdentifier: Bech32mTokenIdentifier; error: Error }
-      >[] = [];
-      for (const [identifierHex, decodedInvoices] of tokenInvoices.entries()) {
-        const tokenIdentifier = hexToBytes(identifierHex);
-        const tokenIdB32 = encodeBech32mTokenIdentifier({
-          tokenIdentifier,
-          network: this.config.getNetworkType(),
-        }) as Bech32mTokenIdentifier;
-
-        const receiverOutputs = decodedInvoices.map((d) => ({
-          tokenIdentifier: tokenIdB32,
-          tokenAmount: d.amount!,
-          receiverSparkAddress: d.invoice,
-        }));
-
-        tokenTransferTasks.push(
-          this.tokenTransactionService
-            .tokenTransfer({ tokenOutputs: this.tokenOutputs, receiverOutputs })
-            .then((txid) => ({
-              ok: true as const,
-              tokenIdentifier: tokenIdB32,
-              txid,
-            }))
-            .catch((e: any) => ({
-              ok: false as const,
-              tokenIdentifier: tokenIdB32,
-              error: e instanceof Error ? e : new Error(String(e)),
-            })),
-        );
-      }
-      const results = await Promise.all(tokenTransferTasks);
-      for (const r of results) {
-        if (r.ok) {
-          tokenTransactionSuccess.push({
-            tokenIdentifier: r.tokenIdentifier,
-            txid: r.txid,
-          });
-        } else {
-          tokenTransactionErrors.push({
-            tokenIdentifier: r.tokenIdentifier,
-            error: r.error,
-          });
-        }
-      }
-    }
-
-    if (satsInvoices.length > 0) {
-      const transfers = await this.transferWithInvoice(satsInvoices);
-      for (const transfer of transfers) {
-        if (transfer.ok) {
-          satsTransactionSuccess.push({
-            invoice: transfer.param.sparkInvoice ?? ("" as SparkAddressFormat),
-            transferResponse: transfer.transfer,
-          });
-        } else {
-          satsTransactionErrors.push({
-            invoice: transfer.param.sparkInvoice ?? ("" as SparkAddressFormat),
-            error: transfer.error,
-          });
-        }
-      }
-    }
-
-    return {
-      satsTransactionSuccess,
-      satsTransactionErrors,
-      tokenTransactionSuccess,
-      tokenTransactionErrors,
-      invalidInvoices,
-    };
+    // TODO: (CNT-493) Re-enable invoice functionality once spark address migration is complete
+    throw new NotImplementedError("Invoice functionality is not enabled");
   }
 
   private async groupSparkInvoicesByPaymentType(
@@ -3876,6 +3712,13 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
     return { satsInvoices, tokenInvoices, invalidInvoices };
   }
 
+  public async querySparkInvoices(
+    invoices: string[],
+  ): Promise<QuerySparkInvoicesResponse> {
+    // TODO: (CNT-493) Re-enable invoice functionality once spark address migration is complete
+    throw new NotImplementedError("Invoice functionality is not enabled");
+  }
+
   /**
    * Gets fee estimate for sending Lightning payments.
    *

package/src/tests/address.test.ts

@@ -14,6 +14,7 @@ import {
   encodeSparkAddress,
   encodeSparkAddressWithSignature,
   getNetworkFromSparkAddress,
+  isLegacySparkAddress,
   SparkAddressData,
   SparkAddressFormat,
 } from "../utils/address.js";
@@ -226,12 +227,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,7 +253,67 @@ 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 =
+      "sprt1pgssx5us3wkqjza8g80xz3a9gznx25msq6g3ty8exfym9q3ahcv86vsnzffssqgjzqqejta89sa8su5f05g0vunfzzkj5zr5v4ehgnt9d4hnyggr2wgghtqfpwn5rhnpg7j5pfn92dcqdyg4jrunyjdjsg7muxraxgfn5zcgs8dcr3sxzrqdetshygps36q8rfqg49d0p0447trnpyxh9f76kt9cwrfx4342jym5emx049chkfsz6j9qc0z8cl7ymmsckx42k76c2qm5f5n5kfvyd26x78eyw0ygs502vgwauy8j";
+    const decoded = bech32mDecode(address as SparkAddressFormat);
+    const payload = SparkAddress.decode(bech32m.fromWords(decoded.words));
+
+    const { identityPublicKey, sparkInvoiceFields, signature } = payload;
+
+    const sparkAddressData: SparkAddressData = {
+      identityPublicKey: bytesToHex(identityPublicKey),
+      network: "REGTEST",
+      sparkInvoiceFields: sparkInvoiceFields,
+    };
+    const reEncoded = encodeSparkAddressWithSignature(
+      sparkAddressData,
+      signature,
+    );
+    expect(reEncoded).toBe(address);
+  });
+  test("new spark address decodes and encodes to the same legacy address", () => {
+    const address =
+      "sparkrt1pgssx5us3wkqjza8g80xz3a9gznx25msq6g3ty8exfym9q3ahcv86vsnzffssqgjzqqejta89sa8su5f05g0vunfzzkj5zr5v4ehgnt9d4hnyggr2wgghtqfpwn5rhnpg7j5pfn92dcqdyg4jrunyjdjsg7muxraxgfn5zcgs8dcr3sxzrqdetshygps36q8rfqg49d0p0447trnpyxh9f76kt9cwrfx4342jym5emx049chkfsz6j9qc0z8cl7ymmsckx42k76c2qm5f5n5kfvyd26x78eyw0ygs502vg42n8ls";
+    const decoded = bech32mDecode(address as SparkAddressFormat);
+    const payload = SparkAddress.decode(bech32m.fromWords(decoded.words));
+
+    const { identityPublicKey, sparkInvoiceFields, signature } = payload;
+
+    const sparkAddressData: SparkAddressData = {
+      identityPublicKey: bytesToHex(identityPublicKey),
+      network: "REGTEST",
+      sparkInvoiceFields: sparkInvoiceFields,
+    };
+    const reEncoded = encodeSparkAddressWithSignature(
+      sparkAddressData,
+      signature,
+    );
+    expect(reEncoded).toBe(
+      "sprt1pgssx5us3wkqjza8g80xz3a9gznx25msq6g3ty8exfym9q3ahcv86vsnzffssqgjzqqejta89sa8su5f05g0vunfzzkj5zr5v4ehgnt9d4hnyggr2wgghtqfpwn5rhnpg7j5pfn92dcqdyg4jrunyjdjsg7muxraxgfn5zcgs8dcr3sxzrqdetshygps36q8rfqg49d0p0447trnpyxh9f76kt9cwrfx4342jym5emx049chkfsz6j9qc0z8cl7ymmsckx42k76c2qm5f5n5kfvyd26x78eyw0ygs502vgwauy8j",
+    );
+  });
+  test("legacy known spark address decodes and encodes to the same address", () => {
     const address =
       "sprt1pgss8stv8nfkamyea7mtc8werley55anfnnpgtnglff0wmxwm52mkyk6zfeqsqgjzqqe3dvr6e48l2alnpagf7ny3vlj5pr5v4ehgv3pqwd7wxx3awkku9p3epk73na6hcf9220h8kue2tmlkqx8tcrfpsf5ywsvpzgd9px9qcgvpzy8ecp35fg2yq4r39r4njq3slgcul7laarh9sndex9uejz7vwrcrz4g7n4egvwt5yspvsdyped46sflczvrzh0jzksgqnvaqlk02cz4vkwjrkwuep9zsrz5vmjp7mqxq7762tfjczy07at2fvzd7cgk2sqsxrmqdxnpy464rmq2nzdqzpuhme";
     const decoded = bech32mDecode(address as SparkAddressFormat);
@@ -298,4 +371,72 @@ describe("knownSparkAddress", () => {
       "e5b5d413fc098315df215a0804d9d07ecf56055659d21d9dcc84a280c5466e41f6c0607bda52d32c088ff756a4b04df61165401030f6069a61257551ec0a989a",
     );
   });
+  test("legacy known spark address decodes to expected fields", () => {
+    const address =
+      "sparkrt1pgssx5us3wkqjza8g80xz3a9gznx25msq6g3ty8exfym9q3ahcv86vsnzfmssqgjzqqejtaxmwj8ms9rn58574nvlq4j5zr5v4ehgnt9d4hnyggr2wgghtqfpwn5rhnpg7j5pfn92dcqdyg4jrunyjdjsg7muxraxgfn5rqgandgr3sxzrqdmew8qydzvz3qpylysylkgcaw9vpm2jzspls0qtr5kfmlwz244rvuk25w5w2sgc2pyqsraqdyp8tf57a6cn2egttaas9ms3whssenmjqt8wag3lgyvdzjskfeupt8xwwdx4agxdm9f0wefzj28jmdxqeudwcwdj9vfl9sdr65x06r0tasf5fwz2";
+
+    const decoded = decodeSparkAddress(address, "REGTEST");
+
+    expect(decoded.network).toBe("REGTEST");
+    expect(decoded.identityPublicKey).toBe(
+      "0353908bac090ba741de6147a540a665537006911590f93249b2823dbe187d3213",
+    );
+
+    const f = decoded.sparkInvoiceFields!;
+    expect(f.version).toBe(1);
+    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("093e4813f6463ae2b03b548500fe0f02c74b277f70955a8d9cb2a8ea39504614");
+    expect(
+      f.paymentType && "amount" in f.paymentType
+        ? f.paymentType.amount
+        : undefined,
+    ).toBe(1000n);
+
+    expect(f.memo).toBe("testMemo");
+    expect(f.senderPublicKey).toBe(
+      "0353908bac090ba741de6147a540a665537006911590f93249b2823dbe187d3213",
+    );
+
+    expect(f.expiryTime?.toISOString()).toBe("2025-09-09T18:09:48.419Z");
+
+    expect(decoded.signature).toBe(
+      "9d69a7bbac4d5942d7dec0bb845d784333dc80b3bba88fd046345285939e0567339cd357a8337654bdd948a4a3cb6d3033c6bb0e6c8ac4fcb068f5433f437afb",
+    );
+  });
+  test("encoding and decoding address", () => {
+    const identityPublicKey =
+      "02833069ed82f5ef07e9afa374d749f86c88415e4edc0609d7b0fbeb6de5929c4e";
+    const newSparkAddressFormat =
+      "sparkl1pgss9qesd8kc9a00ql56lgm56aylsmygg90yahqxp8tmp7ltdhje98zwv6zmy8";
+
+    const legacySparkAddressFormat = encodeSparkAddress({
+      identityPublicKey: identityPublicKey,
+      network: "LOCAL",
+    });
+
+    expect(isLegacySparkAddress(legacySparkAddressFormat)).toBe(true);
+    expect(isLegacySparkAddress(newSparkAddressFormat)).toBe(false);
+
+    const decodedLegacySparkAddress = decodeSparkAddress(
+      legacySparkAddressFormat,
+      "LOCAL",
+    );
+    expect(decodedLegacySparkAddress.identityPublicKey).toBe(identityPublicKey);
+    expect(decodedLegacySparkAddress.network).toBe("LOCAL");
+
+    const decodedNewSparkAddress = decodeSparkAddress(
+      newSparkAddressFormat,
+      "LOCAL",
+    );
+    expect(decodedNewSparkAddress.identityPublicKey).toBe(identityPublicKey);
+    expect(decodedNewSparkAddress.network).toBe("LOCAL");
+
+    expect(decodedLegacySparkAddress).toMatchObject(decodedNewSparkAddress);
+  });
 });

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

@@ -1,5 +1,6 @@
 import { describe, expect } from "@jest/globals";
 import { ConfigOptions } from "../../services/wallet-config.js";
+import { isLegacySparkAddress } from "../../utils/address.js";
 import { NetworkType } from "../../utils/network.js";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
 
@@ -32,6 +33,9 @@ describe("address", () => {
           );
           expect(sparkAddress).toEqual(await wallet.getSparkAddress());
 
+          // TODO: Remove this once we upgrade to the new spark address format
+          expect(isLegacySparkAddress(sparkAddress)).toBe(true);
+
           const depositAddresses = await Promise.all([
             wallet.getSingleUseDepositAddress(),
           ]);

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

@@ -1,5 +1,5 @@
 import { afterEach, beforeAll, describe, expect, it } from "@jest/globals";
-import { hexToBytes } from "@noble/curves/utils";
+import { bytesToHex, hexToBytes } from "@noble/curves/utils";
 import { sha256 } from "@noble/hashes/sha2";
 import { equalBytes } from "@scure/btc-signer/utils";
 import { uuidv7 } from "uuidv7";
@@ -55,16 +55,21 @@ const fakeInvoiceCreator = async (): Promise<LightningReceiveRequest> => {
     typename: "LightningReceiveRequest",
     invoice: {
       encodedInvoice:
-        "lnbcrt123450n1pnj6uf4pp5l26hsdxssmr52vd4xmn5xran7puzx34hpr6uevaq7ta0ayzrp8esdqqcqzpgxqyz5vqrzjqtr2vd60g57hu63rdqk87u3clac6jlfhej4kldrrjvfcw3mphcw8sqqqqzp3jlj6zyqqqqqqqqqqqqqq9qsp5w22fd8aqn7sdum7hxdf59ptgk322fkv589ejxjltngvgehlcqcyq9qxpqysgqvykwsxdx64qrj0s5pgcgygmrpj8w25jsjgltwn09yp24l9nvghe3dl3y0ycy70ksrlqmcn42hxn24e0ucuy3g9fjltudvhv4lrhhamgq3stqgp",
+        "lnbcrt1u1p5vxn7cpp5l26hsdxssmr52vd4xmn5xran7puzx34hpr6uevaq7ta0ayzrp8essp5dlpmev9m3yxyak47ncnz9a0jyt2su2hulw4t97etewgkvrtjtl9sxq9z0rgqnp4qtlyk6hxw5h4hrdfdkd4nh2rv0mwyyqvdtakr3dv6m4vvsmfshvg6rzjqgp0s738klwqef7yr8yu54vv3wfuk4psv46x5laf6l6v5x4lwwahvqqqqrusum7gtyqqqqqqqqqqqqqq9qcqzpgdqq9qyyssq0evxvv962npnvsw8zxsghcty5j9du55yhkjm8qnlr760qdjvn0gsnr650wclqcvc90mpm6e493sy8ds4hxk2h0828nwlmdc64mtr87cqp9eq8w",
       bitcoinNetwork: BitcoinNetwork.REGTEST,
-      paymentHash:
-        "2d059c3ede82a107aa1452c0bea47759be3c5c6e5342be6a310f6c3a907d9f4c",
+      paymentHash: bytesToHex(
+        sha256(
+          hexToBytes(
+            "2d059c3ede82a107aa1452c0bea47759be3c5c6e5342be6a310f6c3a907d9f4c",
+          ),
+        ),
+      ),
       amount: {
-        originalValue: 10000,
-        originalUnit: CurrencyUnit.SATOSHI,
-        preferredCurrencyUnit: CurrencyUnit.SATOSHI,
-        preferredCurrencyValueRounded: 10000,
-        preferredCurrencyValueApprox: 10000,
+        originalValue: 100000,
+        originalUnit: CurrencyUnit.MILLISATOSHI,
+        preferredCurrencyUnit: CurrencyUnit.USD,
+        preferredCurrencyValueRounded: 11,
+        preferredCurrencyValueApprox: 11.45475372279496,
       },
       createdAt: new Date().toISOString(),
       expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24).toISOString(),

package/src/tests/integration/token-output.test.ts

@@ -14,7 +14,6 @@ describe.each(walletTypes)(
       const userWallet = await SparkWalletTesting.initialize({
         options: {
           network: "LOCAL",
-          tokenTransactionVersion: "V1",
         },
         signer: new Signer(),
       });