@unlink-xyz/core 0.1.3 → 0.1.4

package/transactions/transact.test.ts

@@ -1,451 +0,0 @@
-import { eddsa, poseidon } from "@railgun-community/circomlibjs";
-import { Interface } from "ethers";
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  vi,
-  type MockInstance,
-} from "vitest";
-
-import {
-  createMockFetch,
-  createMockIndexer,
-} from "../../test-utils/mock-indexer.js";
-import type { ZkAccount } from "../account/zkAccount.js";
-import { ByteLength, ByteUtils } from "../key-derivation/bytes.js";
-import { createMerkleTrees, createStateStore } from "../state/index.js";
-import { createMemoryStorage } from "../storage/index.js";
-import { createDepositClient } from "./deposit.js";
-import { createTransactService, TRANSACT_ABI } from "./transact.js";
-
-const chainId = 1;
-const poolAddress = "0x1111111111111111111111111111111111111111";
-const depositor = "0x2222222222222222222222222222222222222222";
-const token = "0x3333333333333333333333333333333333333333";
-const timestamp = 1_700_000_000_000;
-
-const transactInterface = new Interface([TRANSACT_ABI]);
-const formatUint = (value: bigint) =>
-  ByteUtils.nToHex(value, ByteLength.UINT_256, true);
-
-// Create a mock ZkAccount for testing
-const mockPrivateKey = Buffer.from(new Uint8Array(32).fill(1));
-const mockPublicKey = eddsa.prv2pub(mockPrivateKey);
-const mockNullifyingKey = 987n;
-const mockMpk = poseidon([
-  mockPublicKey[0],
-  mockPublicKey[1],
-  mockNullifyingKey,
-]);
-const mockZkAccount: ZkAccount = {
-  spendingKeyPair: {
-    privateKey: mockPrivateKey,
-    pubkey: mockPublicKey,
-  },
-  viewingKeyPair: {
-    privateKey: Buffer.from(new Uint8Array(32).fill(2)),
-    pubkey: Buffer.from(new Uint8Array(32).fill(3)),
-  },
-  nullifyingKey: mockNullifyingKey,
-  masterPublicKey: mockMpk,
-};
-
-describe.skip("transact service", () => {
-  let state: ReturnType<typeof createStateStore>;
-  let merkleTrees: ReturnType<typeof createMerkleTrees>;
-  let depositClient: ReturnType<typeof createDepositClient>;
-  let transactClient: ReturnType<typeof createTransactService>;
-  let indexer: ReturnType<typeof createMockIndexer>;
-  let fetchMock: ReturnType<typeof createMockFetch>;
-  let dateNowSpy: MockInstance<() => number>;
-
-  const requestAndSyncDeposit = async (note: {
-    mpk: bigint;
-    random: bigint;
-    amount: bigint;
-    token: string;
-  }) => {
-    const relay = await depositClient.request({
-      zkAccount: mockZkAccount,
-      chainId,
-      poolAddress,
-      depositor,
-      note,
-    });
-    indexer.publish(chainId, relay.commitment);
-    return depositClient.syncPendingDeposit(relay.relayId);
-  };
-
-  beforeEach(async () => {
-    const storage = createMemoryStorage();
-    await storage.open();
-    state = createStateStore(storage);
-    merkleTrees = createMerkleTrees();
-    indexer = createMockIndexer();
-    fetchMock = createMockFetch(indexer);
-    depositClient = createDepositClient(state, {
-      merkleTrees,
-      fetch: fetchMock,
-    });
-    transactClient = createTransactService(state, {
-      merkleTrees,
-    });
-    dateNowSpy = vi.spyOn(Date, "now").mockReturnValue(timestamp);
-  });
-
-  afterEach(() => {
-    dateNowSpy?.mockRestore();
-  });
-
-  it("spends a note, persists nullifier, marks note spent, and builds calldata", async () => {
-    // TODO: unskip it, fix it by mocking correctly
-    const mpk = mockMpk;
-    const random1 = 456n;
-    const random2 = 789n;
-    const amount1 = 500n;
-    const amount2 = 300n;
-    const nullifyingKey = mockNullifyingKey;
-    const npk1 = poseidon([mpk, random1]);
-    const npk2 = poseidon([mpk, random2]);
-
-    const deposit1 = await requestAndSyncDeposit({
-      mpk,
-      random: random1,
-      amount: amount1,
-      token,
-    });
-    const nullifier1 = poseidon([nullifyingKey, BigInt(deposit1.index)]);
-    await state.putNote({
-      chainId,
-      index: deposit1.index,
-      token,
-      value: amount1.toString(),
-      commitment: deposit1.commitment,
-      npk: formatUint(npk1),
-      mpk: formatUint(mpk),
-      random: formatUint(random1),
-      nullifier: formatUint(nullifier1),
-    });
-
-    const deposit2 = await requestAndSyncDeposit({
-      mpk,
-      random: random2,
-      amount: amount2,
-      token,
-    });
-    const nullifier2 = poseidon([nullifyingKey, BigInt(deposit2.index)]);
-    await state.putNote({
-      chainId,
-      index: deposit2.index,
-      token,
-      value: amount2.toString(),
-      commitment: deposit2.commitment,
-      npk: formatUint(npk2),
-      mpk: formatUint(mpk),
-      random: formatUint(random2),
-      nullifier: formatUint(nullifier2),
-    });
-
-    // Create 3 outputs - must sum to inputs for circuit balance
-    const output1Random = 111n;
-    const output2Random = 222n;
-    const output3Random = 333n;
-    const output1Npk = poseidon([mpk, output1Random]);
-    const output2Npk = poseidon([mpk, output2Random]);
-    const output3Npk = poseidon([mpk, output3Random]);
-    const output1Amount = 200n;
-    const output2Amount = 300n;
-    const output3Amount = 300n; // Total outputs must equal total inputs (800n)
-    const withdrawalAmount = 100n; // Withdrawal is handled separately by contract
-
-    const relay = await transactClient.transact({
-      zkAccount: mockZkAccount,
-      chainId,
-      poolAddress,
-      token,
-      inputs: [{ index: deposit1.index }, { index: deposit2.index }],
-      withdrawal: {
-        npk: 0n,
-        amount: withdrawalAmount,
-        token,
-      },
-      outputs: [
-        {
-          mpk,
-          random: output1Random,
-          amount: output1Amount,
-          token,
-        },
-        {
-          mpk,
-          random: output2Random,
-          amount: output2Amount,
-          token,
-        },
-        {
-          mpk,
-          random: output3Random,
-          amount: output3Amount,
-          token,
-        },
-      ],
-    });
-    const sync = await transactClient.syncPendingTransact(relay.relayId);
-
-    const expectedCommitment1 = poseidon([
-      output1Npk,
-      BigInt(token),
-      output1Amount,
-    ]);
-    const expectedCommitment2 = poseidon([
-      output2Npk,
-      BigInt(token),
-      output2Amount,
-    ]);
-    const expectedCommitment3 = poseidon([
-      output3Npk,
-      BigInt(token),
-      output3Amount,
-    ]);
-
-    expect(sync.chainId).toBe(chainId);
-    expect(sync.root).toBe(merkleTrees.getRoot(chainId));
-    expect(sync.nullifiers).toEqual([
-      formatUint(nullifier1),
-      formatUint(nullifier2),
-    ]);
-    expect(sync.newCommitments).toEqual([
-      formatUint(expectedCommitment1),
-      formatUint(expectedCommitment2),
-      formatUint(expectedCommitment3),
-    ]);
-    expect(relay.witnesses).toHaveLength(2);
-    const [firstWitness, secondWitness] = relay.witnesses;
-    if (!firstWitness || !secondWitness) {
-      throw new Error("expected witnesses for both inputs");
-    }
-    expect(firstWitness.root).toBe(secondWitness.root);
-    expect(firstWitness.leaf).toBe(BigInt(deposit1.commitment));
-    expect(secondWitness.leaf).toBe(BigInt(deposit2.commitment));
-    expect(Array.isArray(firstWitness.siblings)).toBe(true);
-    expect(Array.isArray(firstWitness.pathIndices)).toBe(true);
-    expect(firstWitness.siblings.length).toBeGreaterThan(0);
-    expect(firstWitness.pathIndices.length).toBeGreaterThan(0);
-
-    const decoded = transactInterface.decodeFunctionData(
-      "transact",
-      relay.calldata,
-    );
-    const txData = decoded[0][0];
-    expect(txData.merkleRoot).toBe(relay.proof.pubSignals[0]);
-    expect(txData.withdrawal.amount).toBe(withdrawalAmount);
-    expect(txData.withdrawal.token).toBe(token);
-
-    const storedNullifier1 = await state.getNullifier(
-      chainId,
-      formatUint(nullifier1),
-    );
-    expect(storedNullifier1?.nullifier).toBe(formatUint(nullifier1));
-    expect(storedNullifier1?.noteIndex).toBe(deposit1.index);
-
-    const storedNullifier2 = await state.getNullifier(
-      chainId,
-      formatUint(nullifier2),
-    );
-    expect(storedNullifier2?.nullifier).toBe(formatUint(nullifier2));
-    expect(storedNullifier2?.noteIndex).toBe(deposit2.index);
-
-    const spentNote1 = await state.getNote(chainId, deposit1.index);
-    expect(spentNote1?.spentAt).toBe(timestamp);
-
-    const spentNote2 = await state.getNote(chainId, deposit2.index);
-    expect(spentNote2?.spentAt).toBe(timestamp);
-
-    const finalLeafCount = merkleTrees.getLeafCount(chainId);
-    const outputLeaf1 = await state.getLeaf(chainId, finalLeafCount - 3);
-    const outputLeaf2 = await state.getLeaf(chainId, finalLeafCount - 2);
-    const outputLeaf3 = await state.getLeaf(chainId, finalLeafCount - 1);
-    expect(outputLeaf1?.commitment).toBe(formatUint(expectedCommitment1));
-    expect(outputLeaf2?.commitment).toBe(formatUint(expectedCommitment2));
-    expect(outputLeaf3?.commitment).toBe(formatUint(expectedCommitment3));
-  });
-
-  it("rejects spending a note that is not in local state", async () => {
-    await expect(
-      transactClient.transact({
-        zkAccount: mockZkAccount,
-        chainId,
-        poolAddress,
-        token,
-        inputs: [{ index: 0 }],
-        withdrawal: {
-          npk: 0n,
-          amount: 10n,
-          token,
-        },
-        outputs: [],
-      }),
-    ).rejects.toThrow("note 0 not found for chain");
-  });
-
-  it("rejects spending a note that is already marked spent", async () => {
-    const mpk = 123n;
-    const random = 456n;
-    const amount = 10n;
-    const nullifyingKey = 222n;
-    const npk = poseidon([mpk, random]);
-
-    const deposit = await requestAndSyncDeposit({
-      mpk,
-      random,
-      amount,
-      token,
-    });
-    const nullifier = poseidon([nullifyingKey, BigInt(deposit.index)]);
-
-    await state.putNote({
-      chainId,
-      index: deposit.index,
-      token,
-      value: amount.toString(),
-      commitment: deposit.commitment,
-      npk: formatUint(npk),
-      mpk: formatUint(mpk),
-      random: formatUint(random),
-      nullifier: formatUint(nullifier),
-    });
-    await state.markNoteSpent(chainId, deposit.index, timestamp - 1);
-
-    await expect(
-      transactClient.transact({
-        zkAccount: mockZkAccount,
-        chainId,
-        poolAddress,
-        token,
-        inputs: [{ index: deposit.index }],
-        withdrawal: {
-          npk: 0n,
-          amount: 0n,
-          token,
-        },
-        outputs: [],
-      }),
-    ).rejects.toThrow(`note ${deposit.index} is already spent`);
-  });
-
-  it.skip("handles multiple output notes and updates local tree state", async () => {
-    // TODO: unskip it, fix it by mocking correctly
-    const mpk = mockMpk;
-    const random1 = 777n;
-    const random2 = 888n;
-    const amount1 = 600n;
-    const amount2 = 400n;
-    const nullifyingKey = mockNullifyingKey;
-    const npk1 = poseidon([mpk, random1]);
-    const npk2 = poseidon([mpk, random2]);
-
-    const deposit1 = await requestAndSyncDeposit({
-      mpk,
-      random: random1,
-      amount: amount1,
-      token,
-    });
-    const nullifier1 = poseidon([nullifyingKey, BigInt(deposit1.index)]);
-    await state.putNote({
-      chainId,
-      index: deposit1.index,
-      token,
-      value: amount1.toString(),
-      commitment: deposit1.commitment,
-      npk: formatUint(npk1),
-      mpk: formatUint(mpk),
-      random: formatUint(random1),
-      nullifier: formatUint(nullifier1),
-    });
-
-    const deposit2 = await requestAndSyncDeposit({
-      mpk,
-      random: random2,
-      amount: amount2,
-      token,
-    });
-    const nullifier2 = poseidon([nullifyingKey, BigInt(deposit2.index)]);
-    await state.putNote({
-      chainId,
-      index: deposit2.index,
-      token,
-      value: amount2.toString(),
-      commitment: deposit2.commitment,
-      npk: formatUint(npk2),
-      mpk: formatUint(mpk),
-      random: formatUint(random2),
-      nullifier: formatUint(nullifier2),
-    });
-
-    const initialLeafCount = merkleTrees.getLeafCount(chainId);
-
-    const output1Random = 101n;
-    const output2Random = 202n;
-    const output3Random = 303n;
-    const output1Npk = poseidon([mpk, output1Random]);
-    const output2Npk = poseidon([mpk, output2Random]);
-    const output3Npk = poseidon([mpk, output3Random]);
-
-    const output1Amount = 300n;
-    const output2Amount = 400n;
-    const output3Amount = 300n; // Total outputs must equal total inputs (1000n)
-
-    const relay = await transactClient.transact({
-      zkAccount: mockZkAccount,
-      chainId,
-      poolAddress,
-      token,
-      inputs: [{ index: deposit1.index }, { index: deposit2.index }],
-      withdrawal: {
-        npk: 0n,
-        amount: 100n, // Withdrawal is handled separately by contract
-        token,
-      },
-      outputs: [
-        { mpk, random: output1Random, amount: output1Amount, token },
-        { mpk, random: output2Random, amount: output2Amount, token },
-        { mpk, random: output3Random, amount: output3Amount, token },
-      ],
-    });
-    const sync = await transactClient.syncPendingTransact(relay.relayId);
-
-    const expectedCommitment1 = poseidon([
-      output1Npk,
-      BigInt(token),
-      output1Amount,
-    ]);
-    const expectedCommitment2 = poseidon([
-      output2Npk,
-      BigInt(token),
-      output2Amount,
-    ]);
-    const expectedCommitment3 = poseidon([
-      output3Npk,
-      BigInt(token),
-      output3Amount,
-    ]);
-
-    expect(sync.newCommitments).toEqual(
-      [expectedCommitment1, expectedCommitment2, expectedCommitment3].map(
-        formatUint,
-      ),
-    );
-    expect(merkleTrees.getLeafCount(chainId)).toBe(initialLeafCount + 3);
-
-    const leafA = await state.getLeaf(chainId, initialLeafCount);
-    const leafB = await state.getLeaf(chainId, initialLeafCount + 1);
-    const leafC = await state.getLeaf(chainId, initialLeafCount + 2);
-    expect(leafA?.commitment).toBe(formatUint(expectedCommitment1));
-    expect(leafB?.commitment).toBe(formatUint(expectedCommitment2));
-    expect(leafC?.commitment).toBe(formatUint(expectedCommitment3));
-    expect(sync.root).toBe(merkleTrees.getRoot(chainId));
-  });
-});