@buildonspark/spark-sdk 0.3.3 → 0.3.5

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

@@ -5,11 +5,13 @@ import { wordlist } from "@scure/bip39/wordlists/english";
 import { uuidv7 } from "uuidv7";
 import { RPCError } from "../../errors/types.js";
 import {
+  decodeSparkAddress,
+  isLegacySparkAddress,
   KeyDerivation,
   KeyDerivationType,
   SparkWalletEvent,
 } from "../../index.js";
-import { TransferStatus } from "../../proto/spark.js";
+import { InvoiceStatus, TransferStatus } from "../../proto/spark.js";
 import { WalletConfigService } from "../../services/config.js";
 import { ConnectionManager } from "../../services/connection.js";
 import { SigningService } from "../../services/signing.js";
@@ -1209,9 +1211,100 @@ describe.each(walletTypes)("transfer v2", ({ name, Signer, createTree }) => {
 
     await bobTransferService.claimTransfer(transfer!, claimingNodes);
   });
+
+  it(`${name} - test transfer with new spark address`, async () => {
+    const faucet = BitcoinFaucet.getInstance();
+
+    const localOperators = Object.values(getLocalSigningOperators());
+    const { wallet: alice } = await SparkWalletTesting.initialize({
+      options: {
+        network: "LOCAL",
+        coordinatorIdentifier: localOperators[0]!.identifier,
+      },
+      signer: new Signer(),
+    });
+    const depositResp = await alice.getSingleUseDepositAddress();
+
+    if (!depositResp) {
+      throw new RPCError("Deposit address not found", {
+        method: "getDepositAddress",
+      });
+    }
+
+    const signedTx = await faucet.sendToAddress(depositResp, 1_000n);
+
+    await faucet.mineBlocks(1);
+
+    await alice.claimDeposit(signedTx.id);
+
+    const balance = await alice.getBalance();
+    expect(balance.balance).toBe(1_000n);
+
+    const options: ConfigOptions = {
+      network: "LOCAL",
+      coordinatorIdentifier: localOperators[1]!.identifier,
+    };
+    const { wallet: bob } = await SparkWalletTesting.initialize({
+      options,
+      mnemonicOrSeed:
+        "vacant travel foot castle surprise another dress stem slam lemon open anxiety",
+      signer: new Signer(),
+    });
+
+    const bobConfigService = new WalletConfigService(options, bob.getSigner());
+    const bobConnectionManager = new ConnectionManager(bobConfigService);
+    const bobSigningService = new SigningService(bobConfigService);
+
+    const bobTransferService = new TransferService(
+      bobConfigService,
+      bobConnectionManager,
+      bobSigningService,
+    );
+
+    const legacySparkAddress = await bob.getSparkAddress();
+    const newSparkAddress =
+      "sparkl1pgssxlp9dr9ypzqf2havm5weefu6470l062k3ujtw4uu6gjmfgl599rxucvvkr";
+
+    // TODO: Remove this once we upgrade to the new spark address format
+    expect(isLegacySparkAddress(legacySparkAddress)).toBe(true);
+
+    const decodedLegacySparkAddress = decodeSparkAddress(
+      legacySparkAddress,
+      "LOCAL",
+    );
+    const decodedNewSparkAddress = decodeSparkAddress(newSparkAddress, "LOCAL");
+
+    expect(decodedLegacySparkAddress).toMatchObject({
+      ...decodedNewSparkAddress,
+    });
+
+    await alice.transfer({
+      amountSats: 1000,
+      receiverSparkAddress: newSparkAddress,
+    });
+
+    const pendingTransfers = await bob.queryPendingTransfers();
+    expect(pendingTransfers.transfers.length).toBe(1);
+    const transfer = pendingTransfers.transfers[0]!;
+
+    const claimingNodes: LeafKeyTweak[] = transfer!.leaves.map((leaf) => ({
+      leaf: leaf.leaf!,
+      keyDerivation: {
+        type: KeyDerivationType.ECIES,
+        path: leaf.secretCipher,
+      },
+      newKeyDerivation: {
+        type: KeyDerivationType.LEAF,
+        path: leaf.leaf!.id,
+      },
+    }));
+
+    await bobTransferService.claimTransfer(transfer!, claimingNodes);
+  });
 });
 
-describe.each(walletTypes)(
+// TODO: (CNT-493) Re-enable invoice functionality once spark address migration is complete
+describe.skip.each(walletTypes)(
   "fulfill spark invoice",
   ({ name, Signer, createTree }) => {
     jest.setTimeout(25_000);
@@ -1338,6 +1431,19 @@ describe.each(walletTypes)(
           beforeClaimBalance.balance + BigInt(transfer.totalValue),
         );
       }
+
+      const res = await (sdk2 as any).querySparkInvoices([
+        invoice1000,
+        invoice2000,
+        invoiceNilAmount,
+      ]);
+      expect(res.invoiceStatuses.length).toBe(3);
+      expect(res.invoiceStatuses[0].invoice).toBe(invoice1000);
+      expect(res.invoiceStatuses[1].invoice).toBe(invoice2000);
+      expect(res.invoiceStatuses[2].invoice).toBe(invoiceNilAmount);
+      expect(res.invoiceStatuses[0].status).toBe(InvoiceStatus.FINALIZED);
+      expect(res.invoiceStatuses[1].status).toBe(InvoiceStatus.FINALIZED);
+      expect(res.invoiceStatuses[2].status).toBe(InvoiceStatus.FINALIZED);
     });
 
     it(`${name} - should reject invalid invoice: mismatched sender`, async () => {

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

@@ -2,7 +2,6 @@ import { numberToBytesBE } from "@noble/curves/utils";
 import { sha256 } from "@noble/hashes/sha2";
 import { Network } from "../proto/spark.js";
 import {
-  hashTokenTransactionV0,
   hashTokenTransactionV1,
   hashTokenTransactionV2,
 } from "../utils/token-hashing.js";
@@ -62,145 +61,6 @@ const PREV_TX_HASH = Uint8Array.from(
 );
 
 describe("hash token transaction", () => {
-  it("should produce the exact same hash for mint v0 (legacy vector)", () => {
-    const tokenAmount: bigint = 1000n;
-
-    const tokenPublicKey = new Uint8Array([
-      242, 155, 208, 90, 72, 211, 120, 244, 69, 99, 28, 101, 149, 222, 123, 50,
-      252, 63, 99, 54, 137, 226, 7, 224, 163, 122, 93, 248, 42, 159, 173, 45,
-    ]);
-
-    const identityPubKey = new Uint8Array([
-      25, 155, 208, 90, 72, 211, 120, 244, 69, 99, 28, 101, 149, 222, 123, 50,
-      252, 63, 99, 54, 137, 226, 7, 224, 163, 122, 93, 248, 42, 159, 173, 46,
-    ]);
-
-    const tokenTransaction = {
-      tokenInputs: {
-        $case: "mintInput" as const,
-        mintInput: {
-          issuerPublicKey: tokenPublicKey,
-          issuerProvidedTimestamp: 100,
-        },
-      },
-      tokenOutputs: [
-        {
-          id: "db1a4e48-0fc5-4f6c-8a80-d9d6c561a436",
-          ownerPublicKey: identityPubKey,
-          withdrawBondSats: 10000,
-          withdrawRelativeBlockLocktime: 100,
-          tokenPublicKey: tokenPublicKey,
-          tokenAmount: numberToBytesBE(tokenAmount, 16),
-          revocationCommitment: identityPubKey,
-        },
-      ],
-      sparkOperatorIdentityPublicKeys: [],
-      network: Network.REGTEST,
-    };
-
-    const hash = hashTokenTransactionV0(tokenTransaction, false);
-
-    expect(Array.from(hash)).toEqual([
-      66, 235, 134, 101, 172, 110, 147, 77, 122, 48, 86, 240, 239, 9, 163, 82,
-      120, 234, 246, 206, 245, 242, 186, 180, 154, 41, 207, 179, 194, 31, 211,
-      36,
-    ]);
-  });
-
-  it("should produce the exact same hash for mint v0", () => {
-    const tokenTransaction = {
-      tokenInputs: {
-        $case: "mintInput" as const,
-        mintInput: {
-          issuerPublicKey: TEST_TOKEN_PUBLIC_KEY,
-          issuerProvidedTimestamp: TEST_ISSUER_TIMESTAMP,
-        },
-      },
-      tokenOutputs: [
-        {
-          id: TEST_LEAF_ID,
-          ownerPublicKey: TEST_IDENTITY_PUB_KEY,
-          tokenPublicKey: TEST_TOKEN_PUBLIC_KEY,
-          tokenAmount: numberToBytesBE(TEST_TOKEN_AMOUNT, 16),
-          revocationCommitment: TEST_REVOCATION_PUB_KEY,
-          withdrawBondSats: TEST_WITHDRAW_BOND_SATS,
-          withdrawRelativeBlockLocktime: TEST_WITHDRAW_RELATIVE_BLOCK_LOCKTIME,
-        },
-      ],
-      sparkOperatorIdentityPublicKeys: [TEST_OPERATOR_PUB_KEY],
-      network: Network.REGTEST,
-    };
-
-    const hash = hashTokenTransactionV0(tokenTransaction, false);
-
-    expect(Array.from(hash)).toEqual([
-      56, 47, 132, 171, 2, 236, 10, 72, 214, 89, 28, 46, 171, 39, 221, 113, 162,
-      74, 170, 64, 160, 91, 11, 201, 45, 35, 67, 179, 199, 130, 116, 69,
-    ]);
-  });
-
-  it("should produce the exact same hash for create v0", () => {
-    const tokenTransaction = {
-      tokenInputs: {
-        $case: "createInput" as const,
-        createInput: {
-          issuerPublicKey: TEST_TOKEN_PUBLIC_KEY,
-          tokenName: TEST_TOKEN_NAME,
-          tokenTicker: TEST_TOKEN_TICKER,
-          decimals: TEST_DECIMALS,
-          maxSupply: TEST_MAX_SUPPLY,
-          isFreezable: false,
-        },
-      },
-      tokenOutputs: [],
-      sparkOperatorIdentityPublicKeys: [TEST_OPERATOR_PUB_KEY],
-      network: Network.REGTEST,
-    };
-
-    const hash = hashTokenTransactionV0(tokenTransaction, false);
-
-    expect(Array.from(hash)).toEqual([
-      35, 118, 177, 53, 49, 47, 174, 59, 123, 2, 212, 38, 217, 133, 124, 232,
-      93, 185, 248, 87, 146, 123, 157, 10, 6, 111, 79, 183, 185, 175, 45, 224,
-    ]);
-  });
-
-  it("should produce the exact same hash for transfer v0", () => {
-    const tokenTransaction = {
-      tokenInputs: {
-        $case: "transferInput" as const,
-        transferInput: {
-          outputsToSpend: [
-            {
-              prevTokenTransactionHash: PREV_TX_HASH,
-              prevTokenTransactionVout: 0,
-            },
-          ],
-        },
-      },
-      tokenOutputs: [
-        {
-          id: TEST_LEAF_ID,
-          ownerPublicKey: TEST_IDENTITY_PUB_KEY,
-          tokenPublicKey: TEST_TOKEN_PUBLIC_KEY,
-          tokenAmount: numberToBytesBE(1000n, 16),
-          revocationCommitment: TEST_REVOCATION_PUB_KEY,
-          withdrawBondSats: TEST_BOND_SATS,
-          withdrawRelativeBlockLocktime: TEST_LOCKTIME,
-        },
-      ],
-      sparkOperatorIdentityPublicKeys: [TEST_OPERATOR_PUB_KEY],
-      network: Network.REGTEST,
-    };
-
-    const hash = hashTokenTransactionV0(tokenTransaction, false);
-
-    expect(Array.from(hash)).toEqual([
-      68, 88, 168, 87, 42, 251, 11, 182, 69, 202, 46, 202, 39, 234, 196, 201,
-      24, 52, 213, 56, 151, 103, 99, 110, 211, 237, 148, 78, 216, 146, 143, 131,
-    ]);
-  });
-
   it("should produce the exact same hash for mint v1", () => {
     const tokenTransaction = {
       version: 1,
@@ -237,113 +97,6 @@ describe("hash token transaction", () => {
     ]);
   });
 
-  it("should produce the exact same hash for create v1", () => {
-    const tokenTransaction = {
-      version: 1,
-      tokenInputs: {
-        $case: "createInput" as const,
-        createInput: {
-          issuerPublicKey: TEST_TOKEN_PUBLIC_KEY,
-          tokenName: TEST_TOKEN_NAME,
-          tokenTicker: TEST_TOKEN_TICKER,
-          decimals: TEST_DECIMALS,
-          maxSupply: TEST_MAX_SUPPLY,
-          isFreezable: false,
-        },
-      },
-      tokenOutputs: [],
-      sparkOperatorIdentityPublicKeys: [TEST_OPERATOR_PUB_KEY],
-      network: Network.REGTEST,
-      expiryTime: new Date(TEST_EXPIRY_TIME),
-      clientCreatedTimestamp: new Date(TEST_CLIENT_TIMESTAMP),
-      invoiceAttachments: [],
-    };
-
-    const hash = hashTokenTransactionV1(tokenTransaction, false);
-
-    expect(Array.from(hash)).toEqual([
-      201, 249, 88, 215, 6, 7, 221, 209, 103, 153, 36, 41, 19, 60, 80, 144, 153,
-      159, 185, 61, 20, 117, 87, 196, 102, 151, 76, 4, 191, 121, 221, 182,
-    ]);
-  });
-
-  it("should produce the exact same hash for transfer v1", () => {
-    const tokenTransaction = {
-      version: 1,
-      tokenInputs: {
-        $case: "transferInput" as const,
-        transferInput: {
-          outputsToSpend: [
-            {
-              prevTokenTransactionHash: PREV_TX_HASH,
-              prevTokenTransactionVout: 0,
-            },
-          ],
-        },
-      },
-      tokenOutputs: [
-        {
-          id: TEST_LEAF_ID,
-          ownerPublicKey: TEST_IDENTITY_PUB_KEY,
-          tokenPublicKey: TEST_TOKEN_PUBLIC_KEY,
-          tokenAmount: numberToBytesBE(TEST_TOKEN_AMOUNT, 16),
-          revocationCommitment: TEST_REVOCATION_PUB_KEY,
-          withdrawBondSats: TEST_BOND_SATS,
-          withdrawRelativeBlockLocktime: TEST_LOCKTIME,
-        },
-      ],
-      sparkOperatorIdentityPublicKeys: [TEST_OPERATOR_PUB_KEY],
-      network: Network.REGTEST,
-      expiryTime: new Date(TEST_EXPIRY_TIME),
-      clientCreatedTimestamp: new Date(TEST_CLIENT_TIMESTAMP),
-      invoiceAttachments: [],
-    };
-
-    const hash = hashTokenTransactionV1(tokenTransaction, false);
-
-    expect(Array.from(hash)).toEqual([
-      86, 89, 220, 198, 197, 223, 236, 142, 73, 125, 112, 186, 29, 1, 26, 203,
-      126, 154, 255, 176, 237, 210, 171, 98, 211, 130, 138, 113, 128, 129, 227,
-      35,
-    ]);
-  });
-
-  it("should produce the exact same hash for mint v2", () => {
-    const tokenTransaction = {
-      version: 2,
-      tokenInputs: {
-        $case: "mintInput" as const,
-        mintInput: {
-          issuerPublicKey: TEST_TOKEN_PUBLIC_KEY,
-          tokenIdentifier: TEST_TOKEN_IDENTIFIER,
-        },
-      },
-      tokenOutputs: [
-        {
-          id: TEST_LEAF_ID,
-          ownerPublicKey: TEST_IDENTITY_PUB_KEY,
-          withdrawBondSats: TEST_WITHDRAW_BOND_SATS,
-          withdrawRelativeBlockLocktime: TEST_WITHDRAW_RELATIVE_BLOCK_LOCKTIME,
-          tokenPublicKey: TEST_TOKEN_PUBLIC_KEY,
-          tokenAmount: numberToBytesBE(TEST_TOKEN_AMOUNT, 16),
-          revocationCommitment: TEST_REVOCATION_PUB_KEY,
-        },
-      ],
-      sparkOperatorIdentityPublicKeys: [TEST_OPERATOR_PUB_KEY],
-      network: Network.REGTEST,
-      expiryTime: new Date(TEST_EXPIRY_TIME),
-      clientCreatedTimestamp: new Date(TEST_CLIENT_TIMESTAMP),
-      invoiceAttachments: [],
-    };
-
-    const hash = hashTokenTransactionV1(tokenTransaction, false);
-
-    expect(Array.from(hash)).toEqual([
-      2, 4, 36, 141, 246, 170, 160, 204, 181, 102, 122, 220, 56, 182, 138, 153,
-      199, 216, 80, 3, 35, 2, 146, 139, 209, 31, 195, 129, 121, 120, 236, 126,
-    ]);
-  });
-
   it("should produce the exact same hash for create v2", () => {
     const tokenTransaction = {
       version: 2,

package/src/utils/address.ts

@@ -18,6 +18,14 @@ import { NetworkType } from "./network.js";
 const BECH32M_LIMIT = 1024;
 
 const AddressNetwork: Record<NetworkType, string> = {
+  MAINNET: "spark",
+  TESTNET: "sparkt",
+  REGTEST: "sparkrt",
+  SIGNET: "sparks",
+  LOCAL: "sparkl",
+} as const;
+
+const LegacyAddressNetwork: Record<NetworkType, string> = {
   MAINNET: "sp",
   TESTNET: "spt",
   REGTEST: "sprt",
@@ -25,8 +33,11 @@ const AddressNetwork: Record<NetworkType, string> = {
   LOCAL: "spl",
 } as const;
 
+type Bech32String = `${string}1${string}`;
 export type SparkAddressFormat =
   `${(typeof AddressNetwork)[keyof typeof AddressNetwork]}1${string}`;
+export type LegacySparkAddressFormat =
+  `${(typeof LegacyAddressNetwork)[keyof typeof LegacyAddressNetwork]}1${string}`;
 
 export interface SparkAddressData {
   identityPublicKey: string;
@@ -52,14 +63,14 @@ export interface DecodedSparkAddressData {
 
 export function encodeSparkAddress(
   payload: SparkAddressData,
-): SparkAddressFormat {
+): LegacySparkAddressFormat {
   return encodeSparkAddressWithSignature(payload);
 }
 
 export function encodeSparkAddressWithSignature(
   payload: SparkAddressData,
   signature?: Uint8Array,
-): SparkAddressFormat {
+): LegacySparkAddressFormat {
   try {
     isValidPublicKey(payload.identityPublicKey);
     const identityPublicKey = hexToBytes(payload.identityPublicKey);
@@ -88,9 +99,9 @@ export function encodeSparkAddressWithSignature(
     const words = bech32m.toWords(serializedPayload);
 
     return bech32mEncode(
-      AddressNetwork[payload.network],
+      LegacyAddressNetwork[payload.network],
       words,
-    ) as SparkAddressFormat;
+    ) as LegacySparkAddressFormat;
   } catch (error) {
     throw new ValidationError(
       "Failed to encode Spark address",
@@ -108,16 +119,16 @@ export function decodeSparkAddress(
   network: NetworkType,
 ): DecodedSparkAddressData {
   try {
-    const decoded = bech32mDecode(address as SparkAddressFormat);
-
-    if (decoded.prefix !== AddressNetwork[network]) {
+    if (network !== getNetworkFromSparkAddress(address)) {
       throw new ValidationError("Invalid Spark address prefix", {
         field: "address",
         value: address,
-        expected: `prefix='${AddressNetwork[network]}'`,
+        expected: `prefix='${AddressNetwork[network]}' or '${LegacyAddressNetwork[network]}'`,
       });
     }
 
+    const decoded = bech32mDecode(address as Bech32String);
+
     const payload = SparkAddress.decode(bech32m.fromWords(decoded.words));
 
     const { identityPublicKey, sparkInvoiceFields, signature } = payload;
@@ -179,19 +190,40 @@ export function decodeSparkAddress(
   }
 }
 
-export function isValidSparkAddress(address: string) {
+const PrefixToNetwork: Record<string, NetworkType> = Object.fromEntries(
+  Object.entries(AddressNetwork).map(([k, v]) => [v, k as NetworkType]),
+) as Record<string, NetworkType>;
+const LegacyPrefixToNetwork: Record<string, NetworkType> = Object.fromEntries(
+  Object.entries(LegacyAddressNetwork).map(([k, v]) => [v, k as NetworkType]),
+) as Record<string, NetworkType>;
+
+export function getNetworkFromSparkAddress(address: string): NetworkType {
+  const { prefix } = bech32mDecode(address);
+  const network = PrefixToNetwork[prefix] ?? LegacyPrefixToNetwork[prefix];
+  if (!network) {
+    throw new ValidationError("Invalid Spark address prefix", {
+      field: "network",
+      value: address,
+      expected:
+        "prefix='spark1', 'sparkt1', 'sparkrt1', 'sparks1', 'sparkl1' or legacy ('sp1', 'spt1', 'sprt1', 'sps1', 'spl1')",
+    });
+  }
+  return network;
+}
+export function isLegacySparkAddress(
+  address: string,
+): address is LegacySparkAddressFormat {
   try {
-    const network = Object.entries(AddressNetwork).find(([_, prefix]) =>
-      address.startsWith(prefix),
-    )?.[0] as NetworkType | undefined;
+    const { prefix } = bech32mDecode(address);
+    return prefix in LegacyPrefixToNetwork;
+  } catch (error) {
+    return false;
+  }
+}
 
-    if (!network) {
-      throw new ValidationError("Invalid Spark address network", {
-        field: "network",
-        value: address,
-        expected: Object.values(AddressNetwork),
-      });
-    }
+export function isValidSparkAddress(address: string) {
+  try {
+    const network = getNetworkFromSparkAddress(address);
 
     decodeSparkAddress(address, network);
     return true;
@@ -397,27 +429,18 @@ export function validateSparkInvoiceSignature(invoice: SparkAddressFormat) {
   }
 }
 
-export function getNetworkFromSparkAddress(address: SparkAddressFormat) {
-  const { prefix } = bech32mDecode(address as SparkAddressFormat);
-  const network = Object.entries(AddressNetwork).find(
-    ([, p]) => p === prefix,
-  )?.[0] as NetworkType | undefined;
-  if (!network) {
-    throw new ValidationError("Invalid Spark address network", {
-      field: "network",
-      value: address,
-      expected: Object.values(AddressNetwork),
-    });
-  }
-  return network;
-}
-
 export function toProtoTimestamp(date: Date) {
   const ms = date.getTime();
   return { seconds: Math.floor(ms / 1000), nanos: (ms % 1000) * 1_000_000 };
 }
 
-export function bech32mDecode(address: SparkAddressFormat) {
+export function assertBech32(s: string): asserts s is Bech32String {
+  const i = s.lastIndexOf("1");
+  if (i <= 0 || i >= s.length - 1) throw new Error("invalid bech32 string");
+}
+
+export function bech32mDecode(address: string) {
+  assertBech32(address);
   return bech32m.decode(address, BECH32M_LIMIT);
 }