@buildonspark/spark-sdk 0.1.44 → 0.1.46

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

@@ -24,109 +24,117 @@ import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
 import { BitcoinFaucet } from "../utils/test-faucet.js";
 import { RPCError } from "../../errors/types.js";
 
+const testLocalOnly = process.env.GITHUB_ACTIONS ? it.skip : it;
+
 describe("Transfer", () => {
   jest.setTimeout(15_000);
-  it("test transfer", async () => {
-    const faucet = BitcoinFaucet.getInstance();
+  testLocalOnly(
+    "test transfer",
+    async () => {
+      const faucet = BitcoinFaucet.getInstance();
 
-    const options: ConfigOptions = {
-      network: "LOCAL",
-    };
+      const options: ConfigOptions = {
+        network: "LOCAL",
+      };
 
-    const { wallet: senderWallet } = await SparkWalletTesting.initialize({
-      options,
-    });
+      const { wallet: senderWallet } = await SparkWalletTesting.initialize({
+        options,
+      });
 
-    const senderConfigService = new WalletConfigService(
-      options,
-      senderWallet.getSigner(),
-    );
-    const senderConnectionManager = new ConnectionManager(senderConfigService);
-    const signingService = new SigningService(senderConfigService);
-    const senderTransferService = new TransferService(
-      senderConfigService,
-      senderConnectionManager,
-      signingService,
-    );
+      const senderConfigService = new WalletConfigService(
+        options,
+        senderWallet.getSigner(),
+      );
+      const senderConnectionManager = new ConnectionManager(
+        senderConfigService,
+      );
+      const signingService = new SigningService(senderConfigService);
+      const senderTransferService = new TransferService(
+        senderConfigService,
+        senderConnectionManager,
+        signingService,
+      );
 
-    const leafPubKey = await senderWallet.getSigner().generatePublicKey();
-    const rootNode = await createNewTree(
-      senderWallet,
-      leafPubKey,
-      faucet,
-      1000n,
-    );
+      const leafPubKey = await senderWallet.getSigner().generatePublicKey();
+      const rootNode = await createNewTree(
+        senderWallet,
+        leafPubKey,
+        faucet,
+        1000n,
+      );
 
-    const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
+      const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
 
-    const { wallet: receiverWallet } = await SparkWalletTesting.initialize({
-      options,
-    });
-    const receiverPubkey = await receiverWallet.getIdentityPublicKey();
+      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 receiverConfigService = new WalletConfigService(
+        options,
+        receiverWallet.getSigner(),
+      );
+      const receiverConnectionManager = new ConnectionManager(
+        receiverConfigService,
+      );
+      const receiverSigningService = new SigningService(receiverConfigService);
 
-    const receiverTransferService = new TransferService(
-      receiverConfigService,
-      receiverConnectionManager,
-      receiverSigningService,
-    );
+      const receiverTransferService = new TransferService(
+        receiverConfigService,
+        receiverConnectionManager,
+        receiverSigningService,
+      );
 
-    const transferNode = {
-      leaf: rootNode,
-      signingPubKey: leafPubKey,
-      newSigningPubKey: newLeafPubKey,
-    };
+      const transferNode = {
+        leaf: rootNode,
+        signingPubKey: leafPubKey,
+        newSigningPubKey: newLeafPubKey,
+      };
 
-    const senderTransfer = await senderTransferService.sendTransfer(
-      [transferNode],
-      hexToBytes(receiverPubkey),
-    );
+      const senderTransfer = await senderTransferService.sendTransfer(
+        [transferNode],
+        hexToBytes(receiverPubkey),
+      );
 
-    const pendingTransfer = await receiverWallet.queryPendingTransfers();
+      const pendingTransfer = await receiverWallet.queryPendingTransfers();
 
-    expect(pendingTransfer.transfers.length).toBe(1);
+      expect(pendingTransfer.transfers.length).toBe(1);
 
-    const receiverTransfer = pendingTransfer.transfers[0];
+      const receiverTransfer = pendingTransfer.transfers[0];
 
-    expect(receiverTransfer!.id).toBe(senderTransfer.id);
+      expect(receiverTransfer!.id).toBe(senderTransfer.id);
 
-    const leafPrivKeyMap = await receiverWallet.verifyPendingTransfer(
-      receiverTransfer!,
-    );
+      const leafPrivKeyMap = await receiverWallet.verifyPendingTransfer(
+        receiverTransfer!,
+      );
 
-    expect(leafPrivKeyMap.size).toBe(1);
+      expect(leafPrivKeyMap.size).toBe(1);
 
-    const leafPrivKeyMapBytes = leafPrivKeyMap.get(rootNode.id);
-    expect(leafPrivKeyMapBytes).toBeDefined();
-    expect(bytesToHex(leafPrivKeyMapBytes!)).toBe(bytesToHex(newLeafPubKey));
+      const leafPrivKeyMapBytes = leafPrivKeyMap.get(rootNode.id);
+      expect(leafPrivKeyMapBytes).toBeDefined();
+      expect(bytesToHex(leafPrivKeyMapBytes!)).toBe(bytesToHex(newLeafPubKey));
 
-    const finalLeafPubKey = await receiverWallet
-      .getSigner()
-      .generatePublicKey(sha256(rootNode.id));
+      const finalLeafPubKey = await receiverWallet
+        .getSigner()
+        .generatePublicKey(sha256(rootNode.id));
 
-    const claimingNode = {
-      leaf: rootNode,
-      signingPubKey: newLeafPubKey,
-      newSigningPubKey: finalLeafPubKey,
-    };
+      const claimingNode = {
+        leaf: rootNode,
+        signingPubKey: newLeafPubKey,
+        newSigningPubKey: finalLeafPubKey,
+      };
 
-    await receiverTransferService.claimTransfer(receiverTransfer!, [
-      claimingNode,
-    ]);
+      await receiverTransferService.claimTransfer(receiverTransfer!, [
+        claimingNode,
+      ]);
 
-    const balance = await receiverWallet.getBalance();
-    expect(balance.balance).toBe(1000n);
-  }, 30000);
+      const balance = await receiverWallet.getBalance();
+      expect(balance.balance).toBe(1000n);
+    },
+    30000,
+  );
 
-  it("test transfer with separate", async () => {
+  testLocalOnly("test transfer with separate", async () => {
     const faucet = BitcoinFaucet.getInstance();
 
     const options: ConfigOptions = {
@@ -262,7 +270,7 @@ describe("Transfer", () => {
     );
   });
 
-  it("cancel transfer", async () => {
+  testLocalOnly("cancel transfer", async () => {
     const faucet = BitcoinFaucet.getInstance();
 
     const options: ConfigOptions = {
@@ -369,202 +377,207 @@ describe("Transfer", () => {
     ]);
   });
 
-  it("test that when the receiver has tweaked the key on some SOs, we can still claim the transfer", async () => {
-    const faucet = BitcoinFaucet.getInstance();
-
-    const options: ConfigOptions = {
-      network: "LOCAL",
-    };
-
-    const { wallet: senderWallet } = await SparkWalletTesting.initialize({
-      options,
-    });
-
-    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 leafPubKey = await senderWallet.getSigner().generatePublicKey();
-    const rootNode = await createNewTree(
-      senderWallet,
-      leafPubKey,
-      faucet,
-      1000n,
-    );
-
-    const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
+  testLocalOnly(
+    "test that when the receiver has tweaked the key on some SOs, we can still claim the transfer",
+    async () => {
+      const faucet = BitcoinFaucet.getInstance();
 
-    const soToRemove =
-      "0000000000000000000000000000000000000000000000000000000000000005";
-    const localSigningOperators = getLocalSigningOperators();
-    const signingOperators = Object.fromEntries(
-      Object.entries(localSigningOperators).filter(
-        ([key]) => key !== soToRemove,
-      ),
-    );
-    const missingOperatorOptions = {
-      ...LOCAL_WALLET_CONFIG,
-      signingOperators,
-    };
-    const mnemonic = generateMnemonic(wordlist);
-    const { wallet: receiverWallet } = await SparkWalletTesting.initialize({
-      options: missingOperatorOptions,
-      mnemonicOrSeed: mnemonic,
-    });
+      const options: ConfigOptions = {
+        network: "LOCAL",
+      };
 
-    const receiverPubkey = await receiverWallet.getIdentityPublicKey();
+      const { wallet: senderWallet } = await SparkWalletTesting.initialize({
+        options,
+      });
 
-    const receiverConfigService = new WalletConfigService(
-      missingOperatorOptions,
-      receiverWallet.getSigner(),
-    );
-    const receiverConnectionManager = new ConnectionManager(
-      receiverConfigService,
-    );
-    const receiverSigningService = new SigningService(receiverConfigService);
-    const receiverTransferService = new TransferService(
-      receiverConfigService,
-      receiverConnectionManager,
-      receiverSigningService,
-    );
+      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 transferNode = {
-      leaf: rootNode,
-      signingPubKey: leafPubKey,
-      newSigningPubKey: newLeafPubKey,
-    };
+      const leafPubKey = await senderWallet.getSigner().generatePublicKey();
+      const rootNode = await createNewTree(
+        senderWallet,
+        leafPubKey,
+        faucet,
+        1000n,
+      );
 
-    const senderTransfer = await senderTransferService.sendTransfer(
-      [transferNode],
-      hexToBytes(receiverPubkey),
-    );
+      const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
 
-    const pendingTransfer = await receiverWallet.queryPendingTransfers();
+      const soToRemove =
+        "0000000000000000000000000000000000000000000000000000000000000005";
+      const localSigningOperators = getLocalSigningOperators();
+      const signingOperators = Object.fromEntries(
+        Object.entries(localSigningOperators).filter(
+          ([key]) => key !== soToRemove,
+        ),
+      );
+      const missingOperatorOptions = {
+        ...LOCAL_WALLET_CONFIG,
+        signingOperators,
+      };
+      const mnemonic = generateMnemonic(wordlist);
+      const { wallet: receiverWallet } = await SparkWalletTesting.initialize({
+        options: missingOperatorOptions,
+        mnemonicOrSeed: mnemonic,
+      });
 
-    expect(pendingTransfer.transfers.length).toBe(1);
+      const receiverPubkey = await receiverWallet.getIdentityPublicKey();
 
-    const receiverTransfer = pendingTransfer.transfers[0];
-
-    expect(receiverTransfer!.id).toBe(senderTransfer.id);
+      const receiverConfigService = new WalletConfigService(
+        missingOperatorOptions,
+        receiverWallet.getSigner(),
+      );
+      const receiverConnectionManager = new ConnectionManager(
+        receiverConfigService,
+      );
+      const receiverSigningService = new SigningService(receiverConfigService);
+      const receiverTransferService = new TransferService(
+        receiverConfigService,
+        receiverConnectionManager,
+        receiverSigningService,
+      );
 
-    const leafPrivKeyMap = await receiverWallet.verifyPendingTransfer(
-      receiverTransfer!,
-    );
+      const transferNode = {
+        leaf: rootNode,
+        signingPubKey: leafPubKey,
+        newSigningPubKey: newLeafPubKey,
+      };
 
-    expect(leafPrivKeyMap.size).toBe(1);
+      const senderTransfer = await senderTransferService.sendTransfer(
+        [transferNode],
+        hexToBytes(receiverPubkey),
+      );
 
-    const leafPrivKeyMapBytes = leafPrivKeyMap.get(rootNode.id);
-    expect(leafPrivKeyMapBytes).toBeDefined();
-    expect(bytesToHex(leafPrivKeyMapBytes!)).toBe(bytesToHex(newLeafPubKey));
+      const pendingTransfer = await receiverWallet.queryPendingTransfers();
 
-    const finalLeafPubKey = await receiverWallet
-      .getSigner()
-      .generatePublicKey(sha256(rootNode.id));
+      expect(pendingTransfer.transfers.length).toBe(1);
 
-    const claimingNode = {
-      leaf: rootNode,
-      signingPubKey: newLeafPubKey,
-      newSigningPubKey: finalLeafPubKey,
-    };
+      const receiverTransfer = pendingTransfer.transfers[0];
 
-    // Tweak the key with only 4 out of the 5 operators
-    await receiverTransferService.claimTransferTweakKeys(receiverTransfer!, [
-      claimingNode,
-    ]);
+      expect(receiverTransfer!.id).toBe(senderTransfer.id);
 
-    const receiverOptions = {
-      ...LOCAL_WALLET_CONFIG,
-    };
+      const leafPrivKeyMap = await receiverWallet.verifyPendingTransfer(
+        receiverTransfer!,
+      );
 
-    const { wallet: receiverWalletWithAllOperators } =
-      await SparkWalletTesting.initialize({
-        options: receiverOptions,
-        mnemonicOrSeed: mnemonic,
-      });
-    const receiverConfigServiceWithAllOperators = new WalletConfigService(
-      receiverOptions,
-      receiverWalletWithAllOperators.getSigner(),
-    );
-    const receiverConnectionManagerWithAllOperators = new ConnectionManager(
-      receiverConfigServiceWithAllOperators,
-    );
-    const receiverSigningServiceWithAllOperators = new SigningService(
-      receiverConfigServiceWithAllOperators,
-    );
+      expect(leafPrivKeyMap.size).toBe(1);
+
+      const leafPrivKeyMapBytes = leafPrivKeyMap.get(rootNode.id);
+      expect(leafPrivKeyMapBytes).toBeDefined();
+      expect(bytesToHex(leafPrivKeyMapBytes!)).toBe(bytesToHex(newLeafPubKey));
+
+      const finalLeafPubKey = await receiverWallet
+        .getSigner()
+        .generatePublicKey(sha256(rootNode.id));
+
+      const claimingNode = {
+        leaf: rootNode,
+        signingPubKey: newLeafPubKey,
+        newSigningPubKey: finalLeafPubKey,
+      };
+
+      // Tweak the key with only 4 out of the 5 operators
+      await receiverTransferService.claimTransferTweakKeys(receiverTransfer!, [
+        claimingNode,
+      ]);
+
+      const receiverOptions = {
+        ...LOCAL_WALLET_CONFIG,
+      };
+
+      const { wallet: receiverWalletWithAllOperators } =
+        await SparkWalletTesting.initialize({
+          options: receiverOptions,
+          mnemonicOrSeed: mnemonic,
+        });
+      const receiverConfigServiceWithAllOperators = new WalletConfigService(
+        receiverOptions,
+        receiverWalletWithAllOperators.getSigner(),
+      );
+      const receiverConnectionManagerWithAllOperators = new ConnectionManager(
+        receiverConfigServiceWithAllOperators,
+      );
+      const receiverSigningServiceWithAllOperators = new SigningService(
+        receiverConfigServiceWithAllOperators,
+      );
 
-    const receiverTransferServiceWithAllOperators = new TransferService(
-      receiverConfigServiceWithAllOperators,
-      receiverConnectionManagerWithAllOperators,
-      receiverSigningServiceWithAllOperators,
-    );
+      const receiverTransferServiceWithAllOperators = new TransferService(
+        receiverConfigServiceWithAllOperators,
+        receiverConnectionManagerWithAllOperators,
+        receiverSigningServiceWithAllOperators,
+      );
 
-    const { wallet: receiverWalletWithMissingOperatorAsCoordinator } =
-      await SparkWalletTesting.initialize({
-        options: {
-          ...LOCAL_WALLET_CONFIG,
-          coodinatorIdentifier: soToRemove,
-        },
-        mnemonicOrSeed: mnemonic,
-      });
+      const { wallet: receiverWalletWithMissingOperatorAsCoordinator } =
+        await SparkWalletTesting.initialize({
+          options: {
+            ...LOCAL_WALLET_CONFIG,
+            coodinatorIdentifier: soToRemove,
+          },
+          mnemonicOrSeed: mnemonic,
+        });
+
+      const pendingTransferWithMissingOperatorAsCoordinator =
+        await receiverWalletWithMissingOperatorAsCoordinator.queryPendingTransfers();
+
+      expect(
+        pendingTransferWithMissingOperatorAsCoordinator.transfers.length,
+      ).toBe(1);
+      expect(
+        pendingTransferWithMissingOperatorAsCoordinator.transfers[0]!.status,
+      ).toBe(TransferStatus.TRANSFER_STATUS_SENDER_KEY_TWEAKED);
+
+      const pendingTransferWithAllOperators =
+        await receiverWalletWithAllOperators.queryPendingTransfers();
+
+      expect(pendingTransferWithAllOperators.transfers.length).toBe(1);
+      expect(pendingTransferWithAllOperators.transfers[0]!.status).toBe(
+        TransferStatus.TRANSFER_STATUS_RECEIVER_KEY_TWEAKED,
+      );
 
-    const pendingTransferWithMissingOperatorAsCoordinator =
-      await receiverWalletWithMissingOperatorAsCoordinator.queryPendingTransfers();
+      const receiverTransferWithAllOperators =
+        pendingTransferWithAllOperators.transfers[0];
 
-    expect(
-      pendingTransferWithMissingOperatorAsCoordinator.transfers.length,
-    ).toBe(1);
-    expect(
-      pendingTransferWithMissingOperatorAsCoordinator.transfers[0]!.status,
-    ).toBe(TransferStatus.TRANSFER_STATUS_SENDER_KEY_TWEAKED);
+      expect(receiverTransferWithAllOperators!.id).toBe(senderTransfer.id);
 
-    const pendingTransferWithAllOperators =
-      await receiverWalletWithAllOperators.queryPendingTransfers();
+      const leafPrivKeyMapWithAllOperators =
+        await receiverWalletWithAllOperators.verifyPendingTransfer(
+          receiverTransferWithAllOperators!,
+        );
 
-    expect(pendingTransferWithAllOperators.transfers.length).toBe(1);
-    expect(pendingTransferWithAllOperators.transfers[0]!.status).toBe(
-      TransferStatus.TRANSFER_STATUS_RECEIVER_KEY_TWEAKED,
-    );
+      expect(leafPrivKeyMapWithAllOperators.size).toBe(1);
 
-    const receiverTransferWithAllOperators =
-      pendingTransferWithAllOperators.transfers[0];
+      const leafPrivKeyMapBytesWithAllOperators =
+        leafPrivKeyMapWithAllOperators.get(rootNode.id);
+      expect(leafPrivKeyMapBytesWithAllOperators).toBeDefined();
+      expect(bytesToHex(leafPrivKeyMapBytesWithAllOperators!)).toBe(
+        bytesToHex(newLeafPubKey),
+      );
 
-    expect(receiverTransferWithAllOperators!.id).toBe(senderTransfer.id);
+      await receiverWalletWithAllOperators
+        .getSigner()
+        .restoreSigningKeysFromLeafs([claimingNode.leaf]);
 
-    const leafPrivKeyMapWithAllOperators =
       await receiverWalletWithAllOperators.verifyPendingTransfer(
-        receiverTransferWithAllOperators!,
+        receiverTransfer!,
       );
 
-    expect(leafPrivKeyMapWithAllOperators.size).toBe(1);
-
-    const leafPrivKeyMapBytesWithAllOperators =
-      leafPrivKeyMapWithAllOperators.get(rootNode.id);
-    expect(leafPrivKeyMapBytesWithAllOperators).toBeDefined();
-    expect(bytesToHex(leafPrivKeyMapBytesWithAllOperators!)).toBe(
-      bytesToHex(newLeafPubKey),
-    );
-
-    await receiverWalletWithAllOperators
-      .getSigner()
-      .restoreSigningKeysFromLeafs([claimingNode.leaf]);
-
-    await receiverWalletWithAllOperators.verifyPendingTransfer(
-      receiverTransfer!,
-    );
-
-    await receiverTransferServiceWithAllOperators.claimTransfer(
-      receiverTransfer!,
-      [claimingNode],
-    );
-  });
+      await receiverTransferServiceWithAllOperators.claimTransfer(
+        receiverTransfer!,
+        [claimingNode],
+      );
+    },
+  );
 
   it("test incoming transfer rpc stream", async () => {
     const faucet = BitcoinFaucet.getInstance();

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

@@ -0,0 +1,54 @@
+import { describe, expect, test } from "@jest/globals";
+import { Network, NetworkType } from "../utils/network.js";
+import {
+  decodeHumanReadableTokenIdentifier,
+  encodeHumanReadableTokenIdentifier,
+} from "../utils/token-identifier.js";
+
+const TEST_TOKEN_IDENTIFIER = new Uint8Array([
+  63, 122, 103, 46, 122, 5, 97, 185, 253, 135, 91, 94, 115, 80, 198, 19, 246,
+  106, 151, 26, 124, 57, 156, 44, 26, 105, 66, 164, 126, 75, 150, 248,
+]);
+
+const getExpectedTokenIdentifier = (network: NetworkType) => {
+  switch (network) {
+    case "MAINNET":
+      return "btk18aaxwtn6q4smnlv8td08x5xxz0mx49c60suectq6d9p2gljtjmuquewrjx";
+    case "TESTNET":
+      return "btkt18aaxwtn6q4smnlv8td08x5xxz0mx49c60suectq6d9p2gljtjmuqclz9p3";
+    case "SIGNET":
+      return "btks18aaxwtn6q4smnlv8td08x5xxz0mx49c60suectq6d9p2gljtjmuqh8f7qe";
+    case "REGTEST":
+      return "btkrt18aaxwtn6q4smnlv8td08x5xxz0mx49c60suectq6d9p2gljtjmuqree9zq";
+    case "LOCAL":
+      return "btkl18aaxwtn6q4smnlv8td08x5xxz0mx49c60suectq6d9p2gljtjmuq2p4x2m";
+  }
+};
+
+describe("token identifier", () => {
+  test("encodeHumanReadableTokenIdentifier", () => {
+    const netKeys = Object.values(Network).filter((v) => isNaN(Number(v)));
+    for (const network of netKeys) {
+      const tokenIdentifier = encodeHumanReadableTokenIdentifier({
+        tokenIdentifier: TEST_TOKEN_IDENTIFIER,
+        network: network as NetworkType,
+      });
+      expect(tokenIdentifier).toBe(
+        getExpectedTokenIdentifier(network as NetworkType),
+      );
+    }
+  });
+
+  test("decodeHumanReadableTokenIdentifier", () => {
+    const netKeys = Object.values(Network).filter((v) => isNaN(Number(v)));
+    for (const network of netKeys) {
+      const identifier = getExpectedTokenIdentifier(network as NetworkType);
+      const decoded = decodeHumanReadableTokenIdentifier(
+        identifier,
+        network as NetworkType,
+      );
+      expect(decoded.tokenIdentifier).toEqual(TEST_TOKEN_IDENTIFIER);
+      expect(decoded.network).toEqual(network as NetworkType);
+    }
+  });
+});