@buildonspark/spark-sdk 0.2.12 → 0.3.0

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

@@ -0,0 +1,83 @@
+import { walletTypes, createDeterministicKeys } from "../test-utils.js";
+import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
+import { WalletConfigService } from "../../services/config.js";
+import { ConnectionManager } from "../../services/connection.js";
+import { TokenTransactionService } from "../../services/token-transactions.js";
+import { ValidationError } from "../../errors/types.js";
+
+describe.each(walletTypes)(
+  "fetch owned token outputs should fail with invalid inputs",
+  ({ Signer }) => {
+    let tokenTransactionService: TokenTransactionService;
+
+    beforeEach(async () => {
+      const userWallet = await SparkWalletTesting.initialize({
+        options: {
+          network: "LOCAL",
+          tokenTransactionVersion: "V1",
+        },
+        signer: new Signer(),
+      });
+      const wallet = userWallet.wallet;
+
+      const userConfig = new WalletConfigService(
+        {
+          network: "LOCAL",
+        },
+        wallet.getSigner(),
+      );
+      const connectionManager = new ConnectionManager(userConfig);
+      tokenTransactionService = new TokenTransactionService(
+        userConfig,
+        connectionManager,
+      );
+    });
+
+    it("should fail with empty owner public keys", async () => {
+      await expect(
+        tokenTransactionService.fetchOwnedTokenOutputs({
+          ownerPublicKeys: [],
+        }),
+      ).rejects.toThrow(ValidationError);
+    });
+
+    it("should fail with malformed owner public key", async () => {
+      const malformedKey = new Uint8Array(32).fill(1);
+
+      await expect(
+        tokenTransactionService.fetchOwnedTokenOutputs({
+          ownerPublicKeys: [malformedKey],
+        }),
+      ).rejects.toThrow(ValidationError);
+    });
+
+    it("should fail with malformed issuer public key", async () => {
+      const { publicKey } = createDeterministicKeys(
+        expect.getState().currentTestName!,
+      );
+      const malformedKey = new Uint8Array(32).fill(1);
+
+      await expect(
+        tokenTransactionService.fetchOwnedTokenOutputs({
+          ownerPublicKeys: [publicKey],
+          issuerPublicKeys: [malformedKey],
+        }),
+      ).rejects.toThrow(ValidationError);
+    });
+
+    it("should fail with malformed token identifier", async () => {
+      const { publicKey } = createDeterministicKeys(
+        expect.getState().currentTestName!,
+      );
+      const malformedIdentifier = new Uint8Array(99).fill(1);
+
+      await expect(
+        tokenTransactionService.fetchOwnedTokenOutputs({
+          ownerPublicKeys: [publicKey],
+          issuerPublicKeys: [publicKey],
+          tokenIdentifiers: [malformedIdentifier],
+        }),
+      ).rejects.toThrow(ValidationError);
+    });
+  },
+);

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

@@ -4,7 +4,11 @@ import { generateMnemonic } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english";
 import { uuidv7 } from "uuidv7";
 import { RPCError } from "../../errors/types.js";
-import { KeyDerivation, KeyDerivationType } from "../../index.js";
+import {
+  KeyDerivation,
+  KeyDerivationType,
+  SparkWalletEvent,
+} from "../../index.js";
 import { TransferStatus } from "../../proto/spark.js";
 import { WalletConfigService } from "../../services/config.js";
 import { ConnectionManager } from "../../services/connection.js";
@@ -305,130 +309,6 @@ describe.each(walletTypes)(
       );
     });
 
-    testLocalOnly(`${name} - cancel transfer`, async () => {
-      const faucet = BitcoinFaucet.getInstance();
-
-      const options: ConfigOptions = {
-        network: "LOCAL",
-      };
-      const { wallet: senderWallet } = await SparkWalletTesting.initialize({
-        options,
-        signer: new Signer(),
-      });
-      const mnemonic = generateMnemonic(wordlist);
-
-      const { wallet: receiverWallet } = await SparkWalletTesting.initialize({
-        options,
-      });
-      const receiverPubkey = await receiverWallet.getIdentityPublicKey();
-
-      const receiverConfigService = new WalletConfigService(
-        options,
-        receiverWallet.getSigner(),
-      );
-      const receiverConnectionManager = new ConnectionManager(
-        receiverConfigService,
-      );
-      const receiverSigningService = new SigningService(receiverConfigService);
-
-      const receiverTransferService = new TransferService(
-        receiverConfigService,
-        receiverConnectionManager,
-        receiverSigningService,
-      );
-
-      const leafId = uuidv7();
-      const rootNode = await createTree(senderWallet, leafId, faucet, 100_000n);
-
-      const newLeafDerivationPath: KeyDerivation = {
-        type: KeyDerivationType.LEAF,
-        path: uuidv7(),
-      };
-
-      const transferNode: LeafKeyTweak = {
-        leaf: rootNode,
-        keyDerivation: {
-          type: KeyDerivationType.LEAF,
-          path: leafId,
-        },
-        newKeyDerivation: newLeafDerivationPath,
-      };
-
-      const senderConfigService = new WalletConfigService(
-        options,
-        senderWallet.getSigner(),
-      );
-      const senderConnectionManager = new ConnectionManager(
-        senderConfigService,
-      );
-      const senderSigningService = new SigningService(senderConfigService);
-
-      const senderTransferService = new TransferService(
-        senderConfigService,
-        senderConnectionManager,
-        senderSigningService,
-      );
-
-      const senderTransfer = await senderTransferService.sendTransferSignRefund(
-        [transferNode],
-        hexToBytes(receiverPubkey),
-        new Date(Date.now() + 10 * 60 * 1000),
-      );
-
-      await senderTransferService.cancelTransfer(
-        senderTransfer.transfer,
-        senderConfigService.getCoordinatorAddress(),
-      );
-
-      const newSenderTransfer =
-        await senderTransferService.sendTransferWithKeyTweaks(
-          [transferNode],
-          hexToBytes(receiverPubkey),
-        );
-
-      const pendingTransfer = await receiverWallet.queryPendingTransfers();
-      expect(pendingTransfer.transfers.length).toBe(1);
-
-      const receiverTransfer = pendingTransfer.transfers[0];
-      expect(receiverTransfer!.id).toBe(newSenderTransfer.id);
-
-      const leafPubKeyMap = await receiverWallet.verifyPendingTransfer(
-        receiverTransfer!,
-      );
-
-      expect(leafPubKeyMap.size).toBe(1);
-
-      const leafPubKeyMapBytes = leafPubKeyMap.get(rootNode.id);
-      expect(leafPubKeyMapBytes).toBeDefined();
-      expect(
-        equalBytes(
-          leafPubKeyMapBytes!,
-          await senderWallet
-            .getSigner()
-            .getPublicKeyFromDerivation(newLeafDerivationPath),
-        ),
-      ).toBe(true);
-
-      const claimingNodes: LeafKeyTweak[] = receiverTransfer!.leaves.map(
-        (leaf) => ({
-          leaf: receiverTransfer!.leaves[0]!.leaf!,
-          keyDerivation: {
-            type: KeyDerivationType.ECIES,
-            path: leaf.secretCipher,
-          },
-          newKeyDerivation: {
-            type: KeyDerivationType.LEAF,
-            path: leaf.leaf!.id,
-          },
-        }),
-      );
-
-      await receiverTransferService.claimTransfer(
-        receiverTransfer!,
-        claimingNodes,
-      );
-    });
-
     testLocalOnly(
       `${name} - test that when the receiver has tweaked the key on some SOs, we can still claim the transfer`,
       async () => {
@@ -690,7 +570,10 @@ describe.each(walletTypes)(
       ): Promise<{ transferId: string; balance: bigint }> {
         return new Promise((resolve, reject) => {
           const timeout = setTimeout(() => {
-            receiverWallet.removeListener("transfer:claimed", handler);
+            receiverWallet.removeListener(
+              SparkWalletEvent.TransferClaimed,
+              handler,
+            );
             reject(
               new Error(
                 `Timeout waiting for transfer ${transferId} to be claimed`,
@@ -701,12 +584,15 @@ describe.each(walletTypes)(
           const handler = (claimedTransferId: string, balance: bigint) => {
             if (claimedTransferId === transferId) {
               clearTimeout(timeout);
-              receiverWallet.removeListener("transfer:claimed", handler);
+              receiverWallet.removeListener(
+                SparkWalletEvent.TransferClaimed,
+                handler,
+              );
               resolve({ transferId: claimedTransferId, balance });
             }
           };
 
-          receiverWallet.on("transfer:claimed", handler);
+          receiverWallet.on(SparkWalletEvent.TransferClaimed, handler);
         });
       }
 
@@ -1144,7 +1030,7 @@ describe.each(walletTypes)("transfer v2", ({ name, Signer, createTree }) => {
         status: TransferStatus.TRANSFER_STATUS_SENDER_KEY_TWEAKED,
       },
     });
-    expect(claim1.length).toBe(0);
+    expect(claim1.length).toBe(1);
 
     const claim2 = await (sdk2 as any).claimTransfer({
       transfer: {
@@ -1152,16 +1038,19 @@ describe.each(walletTypes)("transfer v2", ({ name, Signer, createTree }) => {
         status: TransferStatus.TRANSFER_STATUS_RECEIVER_KEY_TWEAKED,
       },
     });
-    expect(claim2.length).toBe(0);
+    expect(claim2.length).toBe(1);
 
     const claim3 = await (sdk2 as any).claimTransfer({
       transfer,
     });
 
-    expect(claim3.length).toBe(0);
+    expect(claim3.length).toBe(1);
 
     // Expect 3 because we call claimTransfer 3 times and we expect there to be 0 retries
     expect(claimTransferCoreSpy).toHaveBeenCalledTimes(3);
+
+    const balanceAfterMultipleClaims = await sdk2.getBalance();
+    expect(balanceAfterMultipleClaims.balance).toBe(1000n);
   });
 
   it(`${name} - test querying updated transfer after error`, async () => {
@@ -1321,3 +1210,313 @@ describe.each(walletTypes)("transfer v2", ({ name, Signer, createTree }) => {
     await bobTransferService.claimTransfer(transfer!, claimingNodes);
   });
 });
+
+describe.each(walletTypes)(
+  "fulfill spark invoice",
+  ({ name, Signer, createTree }) => {
+    jest.setTimeout(25_000);
+
+    it(`${name} - test multiple valid transfers with invoice and nil amount invoice`, async () => {
+      const faucet = BitcoinFaucet.getInstance();
+
+      const options: ConfigOptions = {
+        network: "LOCAL",
+      };
+
+      const { wallet: sdk } = await SparkWalletTesting.initialize({
+        options,
+        signer: new Signer(),
+      });
+
+      const depositAddrOne = await sdk.getSingleUseDepositAddress();
+      if (!depositAddrOne) {
+        throw new RPCError("Deposit address not found", {
+          method: "getDepositAddress",
+        });
+      }
+      const depositAddrTwo = await sdk.getSingleUseDepositAddress();
+      if (!depositAddrTwo) {
+        throw new RPCError("Deposit address not found", {
+          method: "getDepositAddress",
+        });
+      }
+      const depositAddrThree = await sdk.getSingleUseDepositAddress();
+      if (!depositAddrThree) {
+        throw new RPCError("Deposit address not found", {
+          method: "getDepositAddress",
+        });
+      }
+
+      const oneThousand = await faucet.sendToAddress(depositAddrOne, 1_000n);
+      const twoThousand = await faucet.sendToAddress(depositAddrTwo, 2_000n);
+      const threeThousand = await faucet.sendToAddress(
+        depositAddrThree,
+        3_000n,
+      );
+
+      await sdk.claimDeposit(oneThousand.id);
+      await sdk.claimDeposit(twoThousand.id);
+      await sdk.claimDeposit(threeThousand.id);
+
+      const balance = await sdk.getBalance();
+      expect(balance.balance).toBe(6_000n);
+
+      const { wallet: sdk2 } = await SparkWalletTesting.initialize({
+        options: {
+          network: "LOCAL",
+        },
+        signer: new Signer(),
+      });
+
+      const receiverConfigService = new WalletConfigService(
+        options,
+        sdk2.getSigner(),
+      );
+      const receiverConnectionManager = new ConnectionManager(
+        receiverConfigService,
+      );
+      const receiverSigningService = new SigningService(receiverConfigService);
+      const receiverTransferService = new TransferService(
+        receiverConfigService,
+        receiverConnectionManager,
+        receiverSigningService,
+      );
+      const tomorrow = new Date(Date.now() + 1000 * 60 * 60 * 24);
+      const invoice1000 = await sdk2.createSatsInvoice({
+        amount: 1_000,
+        memo: "Test invoice",
+        expiryTime: tomorrow,
+      });
+      const invoice2000 = await sdk2.createSatsInvoice({
+        amount: 2_000,
+        memo: "Test invoice",
+        expiryTime: tomorrow,
+      });
+      const invoiceNilAmount = await sdk2.createSatsInvoice({
+        memo: "Test invoice",
+        expiryTime: tomorrow,
+      });
+
+      const transferResults = await sdk.fulfillSparkInvoice([
+        { invoice: invoice1000 },
+        { invoice: invoice2000 },
+        { invoice: invoiceNilAmount, amount: 3_000n },
+      ]);
+
+      const { satsTransactionSuccess, satsTransactionErrors } = transferResults;
+      expect(satsTransactionSuccess.length).toBe(3);
+      expect(satsTransactionErrors.length).toBe(0);
+
+      const pendingTransfers = await sdk2.queryPendingTransfers();
+      expect(pendingTransfers.transfers.length).toBe(3);
+
+      for (const transfer of pendingTransfers.transfers) {
+        const leaves: LeafKeyTweak[] = transfer.leaves.map((leaf) => ({
+          leaf: {
+            ...leaf.leaf!,
+            refundTx: leaf.intermediateRefundTx,
+            directRefundTx: leaf.intermediateDirectRefundTx,
+            directFromCpfpRefundTx: leaf.intermediateDirectFromCpfpRefundTx,
+          },
+          keyDerivation: {
+            type: KeyDerivationType.ECIES,
+            path: leaf.secretCipher,
+          },
+          newKeyDerivation: {
+            type: KeyDerivationType.LEAF,
+            path: leaf.leaf!.id,
+          },
+        }));
+        await receiverTransferService.claimTransferTweakKeys(transfer, leaves);
+        const beforeClaimBalance = await sdk2.getBalance();
+
+        const res = await (sdk2 as any).claimTransfer({ transfer });
+        expect(res.length).toBe(1);
+
+        const newBalance = await sdk2.getBalance();
+        expect(newBalance.balance).toBe(
+          beforeClaimBalance.balance + BigInt(transfer.totalValue),
+        );
+      }
+    });
+
+    it(`${name} - should reject invalid invoice: mismatched sender`, async () => {
+      const faucet = BitcoinFaucet.getInstance();
+
+      const options: ConfigOptions = {
+        network: "LOCAL",
+      };
+
+      const { wallet: sdk } = await SparkWalletTesting.initialize({
+        options,
+        signer: new Signer(),
+      });
+
+      const depositAddr = await sdk.getSingleUseDepositAddress();
+      if (!depositAddr) {
+        throw new RPCError("Deposit address not found", {
+          method: "getDepositAddress",
+        });
+      }
+
+      const oneThousand = await faucet.sendToAddress(depositAddr, 1_000n);
+
+      await sdk.claimDeposit(oneThousand.id);
+      const balance = await sdk.getBalance();
+      expect(balance.balance).toBe(1_000n);
+
+      const { wallet: sdk2 } = await SparkWalletTesting.initialize({
+        options: {
+          network: "LOCAL",
+        },
+        signer: new Signer(),
+      });
+
+      const receiverConfigService = new WalletConfigService(
+        options,
+        sdk2.getSigner(),
+      );
+      const receiverConnectionManager = new ConnectionManager(
+        receiverConfigService,
+      );
+      const receiverSigningService = new SigningService(receiverConfigService);
+      const receiverTransferService = new TransferService(
+        receiverConfigService,
+        receiverConnectionManager,
+        receiverSigningService,
+      );
+      const tomorrow = new Date(Date.now() + 1000 * 60 * 60 * 24);
+      const invoice1000 = await sdk2.createSatsInvoice({
+        amount: 1_000,
+        memo: "Test invoice",
+        expiryTime: tomorrow,
+        senderSparkAddress: await sdk2.getSparkAddress(), // invalid sender public key - receiver as sender
+      });
+
+      const transferResults = await sdk.fulfillSparkInvoice([
+        { invoice: invoice1000 },
+      ]);
+      const { invalidInvoices } = transferResults;
+      expect(invalidInvoices.length).toBe(1);
+    });
+
+    it(`${name} - should reject invalid invoice: expired invoice`, async () => {
+      const faucet = BitcoinFaucet.getInstance();
+
+      const options: ConfigOptions = {
+        network: "LOCAL",
+      };
+
+      const { wallet: sdk } = await SparkWalletTesting.initialize({
+        options,
+        signer: new Signer(),
+      });
+
+      const depositAddr = await sdk.getSingleUseDepositAddress();
+      if (!depositAddr) {
+        throw new RPCError("Deposit address not found", {
+          method: "getDepositAddress",
+        });
+      }
+
+      const oneThousand = await faucet.sendToAddress(depositAddr, 1_000n);
+
+      await sdk.claimDeposit(oneThousand.id);
+      const balance = await sdk.getBalance();
+      expect(balance.balance).toBe(1_000n);
+
+      const { wallet: sdk2 } = await SparkWalletTesting.initialize({
+        options: {
+          network: "LOCAL",
+        },
+        signer: new Signer(),
+      });
+
+      const receiverConfigService = new WalletConfigService(
+        options,
+        sdk2.getSigner(),
+      );
+      const receiverConnectionManager = new ConnectionManager(
+        receiverConfigService,
+      );
+      const receiverSigningService = new SigningService(receiverConfigService);
+      const receiverTransferService = new TransferService(
+        receiverConfigService,
+        receiverConnectionManager,
+        receiverSigningService,
+      );
+      const yesterday = new Date(Date.now() - 1000 * 60 * 60 * 24);
+      const invoice1000 = await sdk.createSatsInvoice({
+        // invalid receiver public key - sdk as receiver
+        amount: 1_000,
+        memo: "Test invoice",
+        expiryTime: yesterday,
+        senderSparkAddress: await sdk.getSparkAddress(),
+      });
+
+      const transferResults = await sdk.fulfillSparkInvoice([
+        { invoice: invoice1000 },
+      ]);
+      const { invalidInvoices } = transferResults;
+      expect(invalidInvoices.length).toBe(1);
+    });
+
+    it(`${name} - should error when paying the same invoice twice`, async () => {
+      const faucet = BitcoinFaucet.getInstance();
+
+      const options: ConfigOptions = {
+        network: "LOCAL",
+      };
+
+      const { wallet: sdk } = await SparkWalletTesting.initialize({
+        options,
+        signer: new Signer(),
+      });
+
+      const depositAddr = await sdk.getSingleUseDepositAddress();
+      if (!depositAddr) {
+        throw new RPCError("Deposit address not found", {
+          method: "getDepositAddress",
+        });
+      }
+      const depositAddrTwo = await sdk.getSingleUseDepositAddress();
+      if (!depositAddrTwo) {
+        throw new RPCError("Deposit address not found", {
+          method: "getDepositAddress",
+        });
+      }
+
+      const deposit = await faucet.sendToAddress(depositAddr, 1_000n);
+      const depositTwo = await faucet.sendToAddress(depositAddrTwo, 1_000n);
+
+      await sdk.claimDeposit(deposit.id);
+      await sdk.claimDeposit(depositTwo.id);
+
+      const balance = await sdk.getBalance();
+      expect(balance.balance).toBe(2_000n);
+
+      const { wallet: sdk2 } = await SparkWalletTesting.initialize({
+        options: {
+          network: "LOCAL",
+        },
+        signer: new Signer(),
+      });
+
+      const tomorrow = new Date(Date.now() + 1000 * 60 * 60 * 24);
+      const invoice1000 = await sdk2.createSatsInvoice({
+        amount: 1_000,
+        memo: "Test invoice",
+        expiryTime: tomorrow,
+        senderSparkAddress: await sdk.getSparkAddress(),
+      });
+
+      await sdk.fulfillSparkInvoice([{ invoice: invoice1000 }]);
+
+      const secondAttempt = await sdk.fulfillSparkInvoice([
+        { invoice: invoice1000 },
+      ]);
+      const { satsTransactionErrors } = secondAttempt;
+      expect(satsTransactionErrors.length).toBe(1);
+    });
+  },
+);

package/src/tests/test-utils.ts

@@ -15,6 +15,7 @@ import { getP2TRAddressFromPublicKey } from "../utils/bitcoin.js";
 import { getNetwork, Network } from "../utils/network.js";
 import { SparkWalletTesting } from "./utils/spark-testing-wallet.js";
 import { BitcoinFaucet } from "./utils/test-faucet.js";
+import { sha256 } from "@noble/hashes/sha2";
 
 export { BitcoinFaucet };
 
@@ -160,3 +161,9 @@ export const walletTypes = [
     createTree: createNewTreeWithoutDirectTx,
   },
 ];
+
+export function createDeterministicKeys(seed: string) {
+  const privateKey = sha256(new TextEncoder().encode(seed));
+  const publicKey = secp256k1.getPublicKey(privateKey, true);
+  return { privateKey, publicKey };
+}

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

@@ -31,11 +31,11 @@ const TEST_OPERATOR_PUB_KEY = new Uint8Array([
 const TEST_INVOICE_ATTACHMENTS = [
   {
     sparkInvoice:
-      "sprt1pgssypkrjhrpzt2hw0ggrmndanmm035ley75nxu3gejaju4wx9nq86lwzfjqsqgjzqqe3zul2fm8a24y576t0ne2ehup5fg2yz4r6hxlhatyu9kpw09s2fk36ta5j0k85qascf6snpuy4sp0rp4ezyspvs4qgmt9d4hnyggzqmpet3s394th85ypaek7eaahc60uj02fnwg5vewew2hrzesra0hqflc0vn",
+      "sparkrt1pgssx5us3wkqjza8g80xz3a9gznx25msq6g3ty8exfym9q3ahcv86vsnzfmssqgjzqqejtaxmwj8ms9rn58574nvlq4j5zr5v4ehgnt9d4hnyggr2wgghtqfpwn5rhnpg7j5pfn92dcqdyg4jrunyjdjsg7muxraxgfn5rqgandgr3sxzrqdmew8qydzvz3qpylysylkgcaw9vpm2jzspls0qtr5kfmlwz244rvuk25w5w2sgc2pyqsraqdyp8tf57a6cn2egttaas9ms3whssenmjqt8wag3lgyvdzjskfeupt8xwwdx4agxdm9f0wefzj28jmdxqeudwcwdj9vfl9sdr65x06r0tasf5fwz2",
   },
   {
     sparkInvoice:
-      "sprt1pgssypkrjhrpzt2hw0ggrmndanmm035ley75nxu3gejaju4wx9nq86lwzf5ssqgjzqqe3zulcs6h42v0kqkdsv9utxyp5fs2yz4r6hxlhatyu9kpw09s2fk36ta5j0k85qascf6snpuy4sp0rp4ezyszq86z5zryd9nxvmt9d4hnyggzqmpet3s394th85ypaek7eaahc60uj02fnwg5vewew2hrzesra0hql7r5ne",
+      "sparkrt1pgssx5us3wkqjza8g80xz3a9gznx25msq6g3ty8exfym9q3ahcv86vsnzfmqsqgjzqqejtavuhf8n5uh9a74zw66kqaz5zr5v4ehgnt9d4hnyggr2wgghtqfpwn5rhnpg7j5pfn92dcqdyg4jrunyjdjsg7muxraxgfn5zcglrwcr3sxzzqt3wrjrgnq5gqf8eyp8ajx8t3tqw65s5q0urczca9jwlmsj4dgm89j4r4rj5zxzsfqyqlgrfqw9ucldgmfzs5zmkekj90thwzmn6ps55gdjnz23aarjkf245608yg0v2x6xdpdrz6m8xjlhtru0kygcu4zhqwlth9duadfqpruuzx4tc7fdckn",
   },
 ];
 
@@ -415,6 +415,7 @@ describe("hash token transaction", () => {
   });
 
   it("should produce the exact same hash for transfer v2 with invoice attachments", () => {
+    // this is a token hashing test. below would be an invalid transaction - outputs and invoices do not match.
     const tokenTransaction = {
       version: 2,
       tokenInputs: {
@@ -447,10 +448,9 @@ describe("hash token transaction", () => {
     };
 
     const hash = hashTokenTransactionV2(tokenTransaction, false);
-
     expect(Array.from(hash)).toEqual([
-      139, 4, 220, 112, 69, 32, 149, 81, 90, 67, 151, 101, 240, 182, 13, 123,
-      70, 4, 153, 159, 172, 225, 15, 120, 71, 219, 154, 27, 72, 167, 2, 149,
+      19, 39, 37, 63, 91, 26, 243, 192, 252, 18, 74, 19, 59, 241, 142, 11, 20,
+      6, 129, 246, 162, 133, 158, 123, 133, 98, 169, 100, 172, 163, 231, 32,
     ]);
   });
 });

package/src/tests/xchain-address.test.ts

@@ -5,17 +5,17 @@ describe("xchain-address", () => {
     [
       "mainnet",
       "bc1pvluhspufxmuus9wh3dshxhxfg3656c9mwfw85scaydyp7sk9800sl4h5ae",
-      "sp1pgssyele0qrcjdheeq2a0zmpwdwvj3r4f4stkuju0fp36g6grapv2w7ltce4pm",
+      "spark1pgssyele0qrcjdheeq2a0zmpwdwvj3r4f4stkuju0fp36g6grapv2w7l8am2cp",
     ],
     [
       "testnet",
       "tb1psw24aa3jkdkndr68gy2gk3ws4hm7dnsccqqtd92fxxqv2jhv5fcqkfyu7v",
-      "spt1pgss9qu4tmmr9vmdx685wsg53dzapt0hum8p3sqqk625jvvqc49wegns9pkyp6",
+      "sparkt1pgss9qu4tmmr9vmdx685wsg53dzapt0hum8p3sqqk625jvvqc49wegnst05852",
     ],
     [
       "regtest",
       "bcrt1p47kh0ff29d3rjw2n43vxqgmrgv9az562x37x6dp4ehyqq7ezyhcqlz5y42",
-      "sprt1pgss9tadw7jj52mz8yu48tzcvq3kxsct69f55drud56rtnwgqpajyf0sp8jkjq",
+      "sparkrt1pgss9tadw7jj52mz8yu48tzcvq3kxsct69f55drud56rtnwgqpajyf0stj62w6",
     ],
   ])(
     "getSparkAddressFromTaproot success (%s)",