@buildonspark/spark-sdk 0.1.46 → 0.2.0

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

@@ -4,9 +4,11 @@ import {
   equalBytes,
   hexToBytes,
 } from "@noble/curves/abstract/utils";
-import { sha256 } from "@noble/hashes/sha2";
 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 { TransferStatus } from "../../proto/spark.js";
 import { WalletConfigService } from "../../services/config.js";
 import { ConnectionManager } from "../../services/connection.js";
@@ -16,123 +18,128 @@ import { TransferService } from "../../services/transfer.js";
 import {
   ConfigOptions,
   getLocalSigningOperators,
-  LOCAL_WALLET_CONFIG,
+  WalletConfig,
 } from "../../services/wallet-config.js";
-import { createNewTree } from "../../tests/test-util.js";
 import { NetworkType } from "../../utils/network.js";
+import { createNewTree } from "../test-utils.js";
 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);
-  testLocalOnly(
-    "test transfer",
-    async () => {
-      const faucet = BitcoinFaucet.getInstance();
-
-      const options: ConfigOptions = {
-        network: "LOCAL",
-      };
-
-      const { wallet: senderWallet } = await SparkWalletTesting.initialize({
-        options,
-      });
+  it("test transfer", async () => {
+    const faucet = BitcoinFaucet.getInstance();
 
-      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 options: ConfigOptions = {
+      network: "LOCAL",
+    };
 
-      const leafPubKey = await senderWallet.getSigner().generatePublicKey();
-      const rootNode = await createNewTree(
-        senderWallet,
-        leafPubKey,
-        faucet,
-        1000n,
-      );
+    const { wallet: senderWallet } = await SparkWalletTesting.initialize({
+      options,
+    });
 
-      const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
+    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 { wallet: receiverWallet } = await SparkWalletTesting.initialize({
-        options,
-      });
-      const receiverPubkey = await receiverWallet.getIdentityPublicKey();
+    const leafId = uuidv7();
+    const rootNode = await createNewTree(senderWallet, leafId, faucet, 1000n);
 
-      const receiverConfigService = new WalletConfigService(
-        options,
-        receiverWallet.getSigner(),
-      );
-      const receiverConnectionManager = new ConnectionManager(
-        receiverConfigService,
-      );
-      const receiverSigningService = new SigningService(receiverConfigService);
+    const newLeafDerivationPath: KeyDerivation = {
+      type: KeyDerivationType.LEAF,
+      path: uuidv7(),
+    };
 
-      const receiverTransferService = new TransferService(
-        receiverConfigService,
-        receiverConnectionManager,
-        receiverSigningService,
-      );
+    const { wallet: receiverWallet } = await SparkWalletTesting.initialize({
+      options,
+    });
+    const receiverPubkey = await receiverWallet.getIdentityPublicKey();
 
-      const transferNode = {
-        leaf: rootNode,
-        signingPubKey: leafPubKey,
-        newSigningPubKey: newLeafPubKey,
-      };
+    const receiverConfigService = new WalletConfigService(
+      options,
+      receiverWallet.getSigner(),
+    );
+    const receiverConnectionManager = new ConnectionManager(
+      receiverConfigService,
+    );
+    const receiverSigningService = new SigningService(receiverConfigService);
 
-      const senderTransfer = await senderTransferService.sendTransfer(
-        [transferNode],
-        hexToBytes(receiverPubkey),
-      );
+    const receiverTransferService = new TransferService(
+      receiverConfigService,
+      receiverConnectionManager,
+      receiverSigningService,
+    );
 
-      const pendingTransfer = await receiverWallet.queryPendingTransfers();
+    const transferNode: LeafKeyTweak = {
+      leaf: rootNode,
+      keyDerivation: {
+        type: KeyDerivationType.LEAF,
+        path: leafId,
+      },
+      newKeyDerivation: newLeafDerivationPath,
+    };
 
-      expect(pendingTransfer.transfers.length).toBe(1);
+    const senderTransfer = await senderTransferService.sendTransfer(
+      [transferNode],
+      hexToBytes(receiverPubkey),
+    );
 
-      const receiverTransfer = pendingTransfer.transfers[0];
+    const pendingTransfer = await receiverWallet.queryPendingTransfers();
 
-      expect(receiverTransfer!.id).toBe(senderTransfer.id);
+    expect(pendingTransfer.transfers.length).toBe(1);
 
-      const leafPrivKeyMap = await receiverWallet.verifyPendingTransfer(
-        receiverTransfer!,
-      );
+    const receiverTransfer = pendingTransfer.transfers[0];
 
-      expect(leafPrivKeyMap.size).toBe(1);
+    expect(receiverTransfer!.id).toBe(senderTransfer.id);
 
-      const leafPrivKeyMapBytes = leafPrivKeyMap.get(rootNode.id);
-      expect(leafPrivKeyMapBytes).toBeDefined();
-      expect(bytesToHex(leafPrivKeyMapBytes!)).toBe(bytesToHex(newLeafPubKey));
+    const leafPrivKeyMap = await receiverWallet.verifyPendingTransfer(
+      receiverTransfer!,
+    );
 
-      const finalLeafPubKey = await receiverWallet
-        .getSigner()
-        .generatePublicKey(sha256(rootNode.id));
+    expect(leafPrivKeyMap.size).toBe(1);
 
-      const claimingNode = {
-        leaf: rootNode,
-        signingPubKey: newLeafPubKey,
-        newSigningPubKey: finalLeafPubKey,
-      };
+    const leafPrivKeyMapBytes = leafPrivKeyMap.get(rootNode.id);
+    expect(leafPrivKeyMapBytes).toBeDefined();
+    expect(bytesToHex(leafPrivKeyMapBytes!)).toBe(
+      bytesToHex(
+        await senderWallet
+          .getSigner()
+          .getPublicKeyFromDerivation(newLeafDerivationPath),
+      ),
+    );
+
+    const claimingNodes: LeafKeyTweak[] = receiverTransfer!.leaves.map(
+      (leaf) => ({
+        leaf: leaf.leaf!,
+        keyDerivation: {
+          type: KeyDerivationType.ECIES,
+          path: leaf.secretCipher,
+        },
+        newKeyDerivation: {
+          type: KeyDerivationType.LEAF,
+          path: leaf.leaf!.id,
+        },
+      }),
+    );
 
-      await receiverTransferService.claimTransfer(receiverTransfer!, [
-        claimingNode,
-      ]);
+    await receiverTransferService.claimTransfer(
+      receiverTransfer!,
+      claimingNodes,
+    );
 
-      const balance = await receiverWallet.getBalance();
-      expect(balance.balance).toBe(1000n);
-    },
-    30000,
-  );
+    const balance = await receiverWallet.getBalance();
+    expect(balance.balance).toBe(1000n);
+  }, 30000);
 
   testLocalOnly("test transfer with separate", async () => {
     const faucet = BitcoinFaucet.getInstance();
@@ -177,21 +184,26 @@ describe("Transfer", () => {
       receiverSigningService,
     );
 
-    const leafPubKey = await senderWallet.getSigner().generatePublicKey();
-
+    const leafId = uuidv7();
     const rootNode = await createNewTree(
       senderWallet,
-      leafPubKey,
+      leafId,
       faucet,
       100_000n,
     );
 
-    const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
+    const newLeafDerivationPath: KeyDerivation = {
+      type: KeyDerivationType.LEAF,
+      path: uuidv7(),
+    };
 
     const transferNode: LeafKeyTweak = {
       leaf: rootNode,
-      signingPubKey: leafPubKey,
-      newSigningPubKey: newLeafPubKey,
+      keyDerivation: {
+        type: KeyDerivationType.LEAF,
+        path: leafId,
+      },
+      newKeyDerivation: newLeafDerivationPath,
     };
 
     const leavesToTransfer = [transferNode];
@@ -218,17 +230,28 @@ describe("Transfer", () => {
 
     const leafPrivKeyMapBytes = leafPrivKeyMap.get(rootNode.id);
     expect(leafPrivKeyMapBytes).toBeDefined();
-    expect(equalBytes(leafPrivKeyMapBytes!, newLeafPubKey)).toBe(true);
-
-    const finalLeafPubKey = await receiverWallet
-      .getSigner()
-      .generatePublicKey(sha256(rootNode.id));
-
-    const claimingNode: LeafKeyTweak = {
-      leaf: receiverTransfer!.leaves[0]!.leaf!,
-      signingPubKey: newLeafPubKey,
-      newSigningPubKey: finalLeafPubKey,
-    };
+    expect(
+      equalBytes(
+        leafPrivKeyMapBytes!,
+        await senderWallet
+          .getSigner()
+          .getPublicKeyFromDerivation(newLeafDerivationPath),
+      ),
+    ).toBe(true);
+
+    const claimingNodes: LeafKeyTweak[] = receiverTransfer!.leaves.map(
+      (leaf) => ({
+        leaf: leaf.leaf!,
+        keyDerivation: {
+          type: KeyDerivationType.ECIES,
+          path: leaf.secretCipher,
+        },
+        newKeyDerivation: {
+          type: KeyDerivationType.LEAF,
+          path: leaf.leaf!.id,
+        },
+      }),
+    );
 
     const transferService = new TransferService(
       receiverConfigService,
@@ -236,9 +259,10 @@ describe("Transfer", () => {
       new SigningService(receiverConfigService),
     );
 
-    await transferService.claimTransferTweakKeys(receiverTransfer!, [
-      claimingNode,
-    ]);
+    await transferService.claimTransferTweakKeys(
+      receiverTransfer!,
+      claimingNodes,
+    );
 
     const newPendingTransfer = await receiverWallet.queryPendingTransfers();
 
@@ -255,18 +279,25 @@ describe("Transfer", () => {
 
     const newLeafPubKeyMapBytes = newLeafPubKeyMap.get(rootNode.id);
     expect(newLeafPubKeyMapBytes).toBeDefined();
-    expect(bytesToHex(newLeafPubKeyMapBytes!)).toBe(bytesToHex(newLeafPubKey));
+    expect(bytesToHex(newLeafPubKeyMapBytes!)).toBe(
+      bytesToHex(
+        await senderWallet
+          .getSigner()
+          .getPublicKeyFromDerivation(newLeafDerivationPath),
+      ),
+    );
 
-    await transferService.claimTransferSignRefunds(newReceiverTransfer!, [
-      claimingNode,
-    ]);
+    await transferService.claimTransferSignRefunds(
+      newReceiverTransfer!,
+      claimingNodes,
+    );
 
     const newNewPendingTransfer = await receiverWallet.queryPendingTransfers();
     expect(newNewPendingTransfer.transfers.length).toBe(1);
 
     await receiverTransferService.claimTransfer(
       newNewPendingTransfer.transfers[0]!,
-      [claimingNode],
+      claimingNodes,
     );
   });
 
@@ -301,20 +332,26 @@ describe("Transfer", () => {
       receiverSigningService,
     );
 
-    const leafPubKey = await senderWallet.getSigner().generatePublicKey();
+    const leafId = uuidv7();
     const rootNode = await createNewTree(
       senderWallet,
-      leafPubKey,
+      leafId,
       faucet,
       100_000n,
     );
 
-    const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
+    const newLeafDerivationPath: KeyDerivation = {
+      type: KeyDerivationType.LEAF,
+      path: uuidv7(),
+    };
 
     const transferNode: LeafKeyTweak = {
       leaf: rootNode,
-      signingPubKey: leafPubKey,
-      newSigningPubKey: newLeafPubKey,
+      keyDerivation: {
+        type: KeyDerivationType.LEAF,
+        path: leafId,
+      },
+      newKeyDerivation: newLeafDerivationPath,
     };
 
     const senderConfigService = new WalletConfigService(
@@ -360,21 +397,33 @@ describe("Transfer", () => {
 
     const leafPubKeyMapBytes = leafPubKeyMap.get(rootNode.id);
     expect(leafPubKeyMapBytes).toBeDefined();
-    expect(equalBytes(leafPubKeyMapBytes!, newLeafPubKey)).toBe(true);
-
-    const finalLeafPubKey = await receiverWallet
-      .getSigner()
-      .generatePublicKey(sha256(rootNode.id));
-
-    const claimingNode: LeafKeyTweak = {
-      leaf: receiverTransfer!.leaves[0]!.leaf!,
-      signingPubKey: newLeafPubKey,
-      newSigningPubKey: finalLeafPubKey,
-    };
+    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!, [
-      claimingNode,
-    ]);
+    await receiverTransferService.claimTransfer(
+      receiverTransfer!,
+      claimingNodes,
+    );
   });
 
   testLocalOnly(
@@ -404,15 +453,13 @@ describe("Transfer", () => {
         senderSigningService,
       );
 
-      const leafPubKey = await senderWallet.getSigner().generatePublicKey();
-      const rootNode = await createNewTree(
-        senderWallet,
-        leafPubKey,
-        faucet,
-        1000n,
-      );
+      const leafId = uuidv7();
+      const rootNode = await createNewTree(senderWallet, leafId, faucet, 1000n);
 
-      const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
+      const newLeafDerivationPath: KeyDerivation = {
+        type: KeyDerivationType.LEAF,
+        path: uuidv7(),
+      };
 
       const soToRemove =
         "0000000000000000000000000000000000000000000000000000000000000005";
@@ -423,7 +470,7 @@ describe("Transfer", () => {
         ),
       );
       const missingOperatorOptions = {
-        ...LOCAL_WALLET_CONFIG,
+        ...WalletConfig.LOCAL,
         signingOperators,
       };
       const mnemonic = generateMnemonic(wordlist);
@@ -448,10 +495,13 @@ describe("Transfer", () => {
         receiverSigningService,
       );
 
-      const transferNode = {
+      const transferNode: LeafKeyTweak = {
         leaf: rootNode,
-        signingPubKey: leafPubKey,
-        newSigningPubKey: newLeafPubKey,
+        keyDerivation: {
+          type: KeyDerivationType.LEAF,
+          path: leafId,
+        },
+        newKeyDerivation: newLeafDerivationPath,
       };
 
       const senderTransfer = await senderTransferService.sendTransfer(
@@ -475,25 +525,36 @@ describe("Transfer", () => {
 
       const leafPrivKeyMapBytes = leafPrivKeyMap.get(rootNode.id);
       expect(leafPrivKeyMapBytes).toBeDefined();
-      expect(bytesToHex(leafPrivKeyMapBytes!)).toBe(bytesToHex(newLeafPubKey));
-
-      const finalLeafPubKey = await receiverWallet
-        .getSigner()
-        .generatePublicKey(sha256(rootNode.id));
+      expect(bytesToHex(leafPrivKeyMapBytes!)).toBe(
+        bytesToHex(
+          await senderWallet
+            .getSigner()
+            .getPublicKeyFromDerivation(newLeafDerivationPath),
+        ),
+      );
 
-      const claimingNode = {
-        leaf: rootNode,
-        signingPubKey: newLeafPubKey,
-        newSigningPubKey: finalLeafPubKey,
-      };
+      const claimingNodes: LeafKeyTweak[] = receiverTransfer!.leaves.map(
+        (leaf) => ({
+          leaf: rootNode,
+          keyDerivation: {
+            type: KeyDerivationType.ECIES,
+            path: receiverTransfer!.leaves[0]!.secretCipher,
+          },
+          newKeyDerivation: {
+            type: KeyDerivationType.LEAF,
+            path: leaf.leaf!.id,
+          },
+        }),
+      );
 
       // Tweak the key with only 4 out of the 5 operators
-      await receiverTransferService.claimTransferTweakKeys(receiverTransfer!, [
-        claimingNode,
-      ]);
+      await receiverTransferService.claimTransferTweakKeys(
+        receiverTransfer!,
+        claimingNodes,
+      );
 
       const receiverOptions = {
-        ...LOCAL_WALLET_CONFIG,
+        ...WalletConfig.LOCAL,
       };
 
       const { wallet: receiverWalletWithAllOperators } =
@@ -521,7 +582,7 @@ describe("Transfer", () => {
       const { wallet: receiverWalletWithMissingOperatorAsCoordinator } =
         await SparkWalletTesting.initialize({
           options: {
-            ...LOCAL_WALLET_CONFIG,
+            ...WalletConfig.LOCAL,
             coodinatorIdentifier: soToRemove,
           },
           mnemonicOrSeed: mnemonic,
@@ -561,20 +622,20 @@ describe("Transfer", () => {
         leafPrivKeyMapWithAllOperators.get(rootNode.id);
       expect(leafPrivKeyMapBytesWithAllOperators).toBeDefined();
       expect(bytesToHex(leafPrivKeyMapBytesWithAllOperators!)).toBe(
-        bytesToHex(newLeafPubKey),
+        bytesToHex(
+          await senderWallet
+            .getSigner()
+            .getPublicKeyFromDerivation(newLeafDerivationPath),
+        ),
       );
 
-      await receiverWalletWithAllOperators
-        .getSigner()
-        .restoreSigningKeysFromLeafs([claimingNode.leaf]);
-
       await receiverWalletWithAllOperators.verifyPendingTransfer(
         receiverTransfer!,
       );
 
       await receiverTransferServiceWithAllOperators.claimTransfer(
         receiverTransfer!,
-        [claimingNode],
+        claimingNodes,
       );
     },
   );
@@ -765,15 +826,13 @@ describe("transfer v2", () => {
       signingService,
     );
 
-    const leafPubKey = await senderWallet.getSigner().generatePublicKey();
-    const rootNode = await createNewTree(
-      senderWallet,
-      leafPubKey,
-      faucet,
-      1000n,
-    );
+    const leafId = uuidv7();
+    const rootNode = await createNewTree(senderWallet, leafId, faucet, 1000n);
 
-    const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
+    const newLeafDerivationPath: KeyDerivation = {
+      type: KeyDerivationType.LEAF,
+      path: uuidv7(),
+    };
 
     const { wallet: receiverWallet } = await SparkWalletTesting.initialize({
       options,
@@ -795,10 +854,13 @@ describe("transfer v2", () => {
       receiverSigningService,
     );
 
-    const transferNode = {
+    const transferNode: LeafKeyTweak = {
       leaf: rootNode,
-      signingPubKey: leafPubKey,
-      newSigningPubKey: newLeafPubKey,
+      keyDerivation: {
+        type: KeyDerivationType.LEAF,
+        path: leafId,
+      },
+      newKeyDerivation: newLeafDerivationPath,
     };
 
     const senderTransfer =
@@ -826,21 +888,32 @@ describe("transfer v2", () => {
 
     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,
-    };
+    expect(bytesToHex(leafPrivKeyMapBytes!)).toBe(
+      bytesToHex(
+        await senderWallet
+          .getSigner()
+          .getPublicKeyFromDerivation(newLeafDerivationPath),
+      ),
+    );
+
+    const claimingNodes: LeafKeyTweak[] = receiverTransfer!.leaves.map(
+      (leaf) => ({
+        leaf: leaf.leaf!,
+        keyDerivation: {
+          type: KeyDerivationType.ECIES,
+          path: leaf.secretCipher,
+        },
+        newKeyDerivation: {
+          type: KeyDerivationType.LEAF,
+          path: leaf.leaf!.id,
+        },
+      }),
+    );
 
-    await receiverTransferService.claimTransfer(receiverTransfer!, [
-      claimingNode,
-    ]);
+    await receiverTransferService.claimTransfer(
+      receiverTransfer!,
+      claimingNodes,
+    );
 
     const balance = await receiverWallet.getBalance();
     expect(balance.balance).toBe(1000n);
@@ -865,19 +938,20 @@ describe("transfer v2", () => {
       senderConnectionManager,
       senderSigningService,
     );
-    const leafPubKey = await senderWallet.getSigner().generatePublicKey();
-    const rootNode = await createNewTree(
-      senderWallet,
-      leafPubKey,
-      faucet,
-      1000n,
-    );
-    const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
+    const leafId = uuidv7();
+    const rootNode = await createNewTree(senderWallet, leafId, faucet, 1000n);
+    const newLeafDerivationPath: KeyDerivation = {
+      type: KeyDerivationType.LEAF,
+      path: uuidv7(),
+    };
     const receiverPubkey = await senderWallet.getIdentityPublicKey();
-    const transferNode = {
+    const transferNode: LeafKeyTweak = {
       leaf: rootNode,
-      signingPubKey: leafPubKey,
-      newSigningPubKey: newLeafPubKey,
+      keyDerivation: {
+        type: KeyDerivationType.LEAF,
+        path: leafId,
+      },
+      newKeyDerivation: newLeafDerivationPath,
     };
     const senderTransfer =
       await senderTransferService.sendTransferWithKeyTweaks(
@@ -892,17 +966,20 @@ describe("transfer v2", () => {
       Date.now(),
     );
 
-    const finalLeafPubKey = await senderWallet
-      .getSigner()
-      .generatePublicKey(sha256(rootNode.id));
-    const claimingNode = {
-      leaf: rootNode,
-      signingPubKey: newLeafPubKey,
-      newSigningPubKey: finalLeafPubKey,
-    };
-    await senderTransferService.claimTransfer(receiverTransfer!, [
-      claimingNode,
-    ]);
+    const claimingNodes: LeafKeyTweak[] = receiverTransfer!.leaves.map(
+      (leaf) => ({
+        leaf: rootNode,
+        keyDerivation: {
+          type: KeyDerivationType.ECIES,
+          path: receiverTransfer!.leaves[0]!.secretCipher,
+        },
+        newKeyDerivation: {
+          type: KeyDerivationType.LEAF,
+          path: leaf.leaf!.id,
+        },
+      }),
+    );
+    await senderTransferService.claimTransfer(receiverTransfer!, claimingNodes);
 
     const balance = await senderWallet.getBalance();
     expect(balance.balance).toBe(1000n);