@buildonspark/spark-sdk 0.0.15 → 0.0.16

package/src/tests/tokens.test.ts

@@ -0,0 +1,47 @@
+import { numberToBytesBE } from "@noble/curves/abstract/utils";
+import { hashTokenTransaction } from "../utils/token-hashing.js";
+
+describe("hash token transaction", () => {
+  it("should produce the exact same hash", () => {
+    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 = {
+      tokenInput: {
+        $case: "mintInput" as const,
+        mintInput: {
+          issuerPublicKey: tokenPublicKey,
+          issuerProvidedTimestamp: 100,
+        },
+      },
+      outputLeaves: [
+        {
+          id: "db1a4e48-0fc5-4f6c-8a80-d9d6c561a436",
+          ownerPublicKey: identityPubKey,
+          withdrawBondSats: 10000,
+          withdrawLocktime: 100,
+          tokenPublicKey: tokenPublicKey,
+          tokenAmount: numberToBytesBE(tokenAmount, 16),
+          revocationPublicKey: new Uint8Array(0),
+        },
+      ],
+      sparkOperatorIdentityPublicKeys: [],
+    };
+
+    const hash = hashTokenTransaction(tokenTransaction, false);
+
+    expect(Array.from(hash)).toEqual([
+      169, 30, 146, 172, 90, 113, 89, 157, 142, 5, 138, 251, 237, 122, 65, 135,
+      47, 178, 192, 116, 107, 24, 176, 162, 78, 238, 80, 166, 38, 129, 151, 167,
+    ]);
+  });
+});

package/src/tests/transfer.test.ts

@@ -0,0 +1,371 @@
+import { describe, expect, it } from "@jest/globals";
+import {
+  bytesToHex,
+  equalBytes,
+  hexToBytes,
+} from "@noble/curves/abstract/utils";
+import { generateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english";
+import { sha256 } from "@scure/btc-signer/utils";
+import { WalletConfigService } from "../services/config.js";
+import { ConnectionManager } from "../services/connection.js";
+import { LeafKeyTweak, TransferService } from "../services/transfer.js";
+import { ConfigOptions } from "../services/wallet-config.js";
+import { createNewTree } from "./test-util.js";
+import { SparkWalletTesting } from "./utils/spark-testing-wallet.js";
+import { BitcoinFaucet } from "./utils/test-faucet.js";
+describe("Transfer", () => {
+  // Skip all tests if running in GitHub Actions
+  const testFn = process.env.GITHUB_ACTIONS ? it.skip : it;
+
+  testFn(
+    "test transfer",
+    async () => {
+      const faucet = new BitcoinFaucet(
+        "http://127.0.0.1:18443",
+        "admin1",
+        "123",
+      );
+
+      const options: ConfigOptions = {
+        network: "LOCAL",
+      };
+
+      const { wallet: senderWallet } = await SparkWalletTesting.create({
+        options,
+      });
+
+      const senderConfigService = new WalletConfigService(
+        options,
+        senderWallet.getSigner(),
+      );
+      const senderConnectionManager = new ConnectionManager(
+        senderConfigService,
+      );
+      const senderTransferService = new TransferService(
+        senderConfigService,
+        senderConnectionManager,
+      );
+
+      const leafPubKey = await senderWallet.getSigner().generatePublicKey();
+      const rootNode = await createNewTree(
+        senderWallet,
+        leafPubKey,
+        faucet,
+        1000n,
+      );
+
+      const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
+
+      const { wallet: receiverWallet } = await SparkWalletTesting.create({
+        options,
+      });
+      const receiverPubkey = await receiverWallet.getIdentityPublicKey();
+
+      const receiverConfigService = new WalletConfigService(
+        options,
+        receiverWallet.getSigner(),
+      );
+      const receiverConnectionManager = new ConnectionManager(
+        receiverConfigService,
+      );
+
+      const receiverTransferService = new TransferService(
+        receiverConfigService,
+        receiverConnectionManager,
+      );
+
+      const transferNode = {
+        leaf: rootNode,
+        signingPubKey: leafPubKey,
+        newSigningPubKey: newLeafPubKey,
+      };
+
+      const senderTransfer = await senderTransferService.sendTransfer(
+        [transferNode],
+        hexToBytes(receiverPubkey),
+      );
+
+      const pendingTransfer = await receiverWallet.queryPendingTransfers();
+
+      expect(pendingTransfer.transfers.length).toBe(1);
+
+      const receiverTransfer = pendingTransfer.transfers[0];
+
+      expect(receiverTransfer!.id).toBe(senderTransfer.id);
+
+      const leafPrivKeyMap = await receiverWallet.verifyPendingTransfer(
+        receiverTransfer!,
+      );
+
+      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,
+      };
+
+      await receiverTransferService.claimTransfer(receiverTransfer!, [
+        claimingNode,
+      ]);
+
+      const { wallet: newReceiverWallet } = await SparkWalletTesting.create({
+        options: {
+          network: "LOCAL",
+        },
+      });
+      const newReceiverPubkey = await newReceiverWallet.getIdentityPublicKey();
+
+      await receiverWallet.transfer({
+        amountSats: 1000,
+        receiverSparkAddress: newReceiverPubkey,
+      });
+
+      const newPendingTransfer =
+        await newReceiverWallet.queryPendingTransfers();
+
+      expect(newPendingTransfer.transfers.length).toBe(1);
+      await newReceiverWallet.getBalance();
+    },
+    30000,
+  );
+
+  testFn("test transfer with separate", async () => {
+    const faucet = new BitcoinFaucet("http://127.0.0.1:18443", "admin1", "123");
+
+    const options: ConfigOptions = {
+      network: "LOCAL",
+    };
+    const { wallet: senderWallet } = await SparkWalletTesting.create({
+      options,
+    });
+
+    const senderConfigService = new WalletConfigService(
+      options,
+      senderWallet.getSigner(),
+    );
+    const senderConnectionManager = new ConnectionManager(senderConfigService);
+    const senderTransferService = new TransferService(
+      senderConfigService,
+      senderConnectionManager,
+    );
+
+    const { wallet: receiverWallet } = await SparkWalletTesting.create({
+      options,
+    });
+    const receiverPubkey = await receiverWallet.getIdentityPublicKey();
+
+    const receiverConfigService = new WalletConfigService(
+      options,
+      receiverWallet.getSigner(),
+    );
+    const receiverConnectionManager = new ConnectionManager(
+      receiverConfigService,
+    );
+    const receiverTransferService = new TransferService(
+      receiverConfigService,
+      receiverConnectionManager,
+    );
+
+    const leafPubKey = await senderWallet.getSigner().generatePublicKey();
+
+    const rootNode = await createNewTree(
+      senderWallet,
+      leafPubKey,
+      faucet,
+      100_000n,
+    );
+
+    const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
+
+    const transferNode: LeafKeyTweak = {
+      leaf: rootNode,
+      signingPubKey: leafPubKey,
+      newSigningPubKey: newLeafPubKey,
+    };
+
+    const leavesToTransfer = [transferNode];
+
+    const senderTransfer = await senderTransferService.sendTransfer(
+      leavesToTransfer,
+      hexToBytes(receiverPubkey),
+    );
+
+    // Receiver queries pending transfer
+    const pendingTransfer = await receiverWallet.queryPendingTransfers();
+
+    expect(pendingTransfer.transfers.length).toBe(1);
+
+    const receiverTransfer = pendingTransfer.transfers[0];
+
+    expect(receiverTransfer!.id).toBe(senderTransfer.id);
+
+    const leafPrivKeyMap = await receiverWallet.verifyPendingTransfer(
+      receiverTransfer!,
+    );
+
+    expect(leafPrivKeyMap.size).toBe(1);
+
+    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,
+    };
+
+    const transferService = new TransferService(
+      receiverConfigService,
+      new ConnectionManager(receiverConfigService),
+    );
+
+    await transferService.claimTransferTweakKeys(receiverTransfer!, [
+      claimingNode,
+    ]);
+
+    const newPendingTransfer = await receiverWallet.queryPendingTransfers();
+
+    expect(newPendingTransfer.transfers.length).toBe(1);
+
+    const newReceiverTransfer = newPendingTransfer.transfers[0];
+    expect(newReceiverTransfer!.id).toBe(receiverTransfer!.id);
+
+    const newLeafPubKeyMap = await receiverWallet.verifyPendingTransfer(
+      newReceiverTransfer!,
+    );
+
+    expect(newLeafPubKeyMap.size).toBe(1);
+
+    const newLeafPubKeyMapBytes = newLeafPubKeyMap.get(rootNode.id);
+    expect(newLeafPubKeyMapBytes).toBeDefined();
+    expect(bytesToHex(newLeafPubKeyMapBytes!)).toBe(bytesToHex(newLeafPubKey));
+
+    await transferService.claimTransferSignRefunds(newReceiverTransfer!, [
+      claimingNode,
+    ]);
+
+    const newNewPendingTransfer = await receiverWallet.queryPendingTransfers();
+    expect(newNewPendingTransfer.transfers.length).toBe(1);
+
+    await receiverTransferService.claimTransfer(
+      newNewPendingTransfer.transfers[0]!,
+      [claimingNode],
+    );
+  });
+
+  testFn("cancel transfer", async () => {
+    const faucet = new BitcoinFaucet("http://127.0.0.1:18443", "admin1", "123");
+
+    const options: ConfigOptions = {
+      network: "LOCAL",
+    };
+    const { wallet: senderWallet } = await SparkWalletTesting.create({
+      options,
+    });
+    const mnemonic = generateMnemonic(wordlist);
+
+    const { wallet: receiverWallet } = await SparkWalletTesting.create({
+      options,
+    });
+    const receiverPubkey = await receiverWallet.getIdentityPublicKey();
+
+    const receiverConfigService = new WalletConfigService(
+      options,
+      receiverWallet.getSigner(),
+    );
+    const receiverConnectionManager = new ConnectionManager(
+      receiverConfigService,
+    );
+    const receiverTransferService = new TransferService(
+      receiverConfigService,
+      receiverConnectionManager,
+    );
+
+    const leafPubKey = await senderWallet.getSigner().generatePublicKey();
+    const rootNode = await createNewTree(
+      senderWallet,
+      leafPubKey,
+      faucet,
+      100_000n,
+    );
+
+    const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
+
+    const transferNode: LeafKeyTweak = {
+      leaf: rootNode,
+      signingPubKey: leafPubKey,
+      newSigningPubKey: newLeafPubKey,
+    };
+
+    const senderConfigService = new WalletConfigService(
+      options,
+      senderWallet.getSigner(),
+    );
+    const senderConnectionManager = new ConnectionManager(senderConfigService);
+    const senderTransferService = new TransferService(
+      senderConfigService,
+      senderConnectionManager,
+    );
+
+    const senderTransfer = await senderTransferService.sendTransferSignRefund(
+      [transferNode],
+      hexToBytes(receiverPubkey),
+      new Date(Date.now() + 10 * 60 * 1000),
+    );
+
+    await senderTransferService.cancelSendTransfer(
+      senderTransfer.transfer,
+      senderConfigService.getCoordinatorAddress(),
+    );
+
+    const newSenderTransfer = await senderTransferService.sendTransfer(
+      [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!, newLeafPubKey)).toBe(true);
+
+    const finalLeafPubKey = await receiverWallet
+      .getSigner()
+      .generatePublicKey(sha256(rootNode.id));
+
+    const claimingNode: LeafKeyTweak = {
+      leaf: receiverTransfer!.leaves[0]!.leaf!,
+      signingPubKey: newLeafPubKey,
+      newSigningPubKey: finalLeafPubKey,
+    };
+
+    await receiverTransferService.claimTransfer(receiverTransfer!, [
+      claimingNode,
+    ]);
+  });
+});

package/src/tests/tree-creation.test.ts

@@ -0,0 +1,56 @@
+// @ts-nocheck
+import { describe, expect, it } from "@jest/globals";
+import { bytesToHex } from "@noble/curves/abstract/utils";
+import { getTxFromRawTxBytes, getTxId } from "../utils/bitcoin.js";
+import { Network } from "../utils/network.js";
+import { createDummyTx } from "../utils/wasm.js";
+import { SparkWalletTesting } from "./utils/spark-testing-wallet.js";
+
+describe("Tree Creation", () => {
+  // Skip all tests if running in GitHub Actions
+  const testFn = process.env.GITHUB_ACTIONS ? it.skip : xit;
+
+  testFn(
+    "test tree creation address generation",
+    async () => {
+      const wallet = new SparkWalletTesting(Network.LOCAL);
+      await wallet.initWallet();
+
+      const pubKey = await wallet.getSigner().generatePublicKey();
+
+      const depositResp = await wallet.generateDepositAddress();
+
+      expect(depositResp.depositAddress).toBeDefined();
+
+      const dummyTx = createDummyTx({
+        address: depositResp.depositAddress!.address,
+        amountSats: 65536n,
+      });
+
+      const depositTxHex = bytesToHex(dummyTx.tx);
+      const depositTx = getTxFromRawTxBytes(dummyTx.tx);
+
+      const vout = 0;
+      const txid = getTxId(depositTx);
+      if (!txid) {
+        throw new Error("txid not found");
+      }
+
+      const treeResp = await wallet.generateDepositAddressForTree(
+        vout,
+        pubKey,
+        depositTx,
+      );
+
+      const treeNodes = await wallet.createTree(
+        vout,
+        treeResp,
+        true,
+        depositTx,
+      );
+
+      console.log("tree nodes:", treeNodes);
+    },
+    30000,
+  );
+});

package/src/tests/utils/spark-testing-wallet.ts

@@ -0,0 +1,37 @@
+import { QueryPendingTransfersResponse, Transfer } from "../../proto/spark.js";
+import { SparkSigner } from "../../signer/signer.js";
+import { SparkWallet, SparkWalletProps } from "../../spark-sdk.js";
+
+interface ISparkWalletTesting extends SparkWallet {
+  getSigner(): SparkSigner;
+  queryPendingTransfers(): Promise<QueryPendingTransfersResponse>;
+  verifyPendingTransfer(transfer: Transfer): Promise<Map<string, Uint8Array>>;
+}
+
+export class SparkWalletTesting
+  extends SparkWallet
+  implements ISparkWalletTesting
+{
+  static async create(props: SparkWalletProps) {
+    const wallet = new SparkWalletTesting(props.options, props.signer);
+    const initResponse = await wallet.initWallet(props.mnemonicOrSeed);
+    return {
+      wallet,
+      mnemonic: initResponse?.mnemonic,
+    };
+  }
+
+  public getSigner(): SparkSigner {
+    return this.config.signer;
+  }
+
+  public async queryPendingTransfers(): Promise<QueryPendingTransfersResponse> {
+    return await this.transferService.queryPendingTransfers();
+  }
+
+  public async verifyPendingTransfer(
+    transfer: Transfer,
+  ): Promise<Map<string, Uint8Array>> {
+    return await this.transferService.verifyPendingTransfer(transfer);
+  }
+}