@unlink-xyz/core 0.1.2 → 0.1.3-canary.0877bfe

package/transactions/deposit.ts

@@ -1,227 +0,0 @@
-import { Interface } from "ethers";
-import { v4 as uuidv4 } from "uuid";
-
-import { FetchLike } from "../clients/http.js";
-import { CommitmentRecord, createIndexerClient } from "../clients/indexer.js";
-import { serviceConfig } from "../config.js";
-import { ByteLength, ByteUtils } from "../key-derivation/bytes.js";
-import {
-  createMerkleTrees,
-  DEFAULT_JOB_TIMEOUT_MS,
-  LocalMerkleTrees,
-  rebuildTreeFromStore,
-  type PendingDepositJob,
-} from "../state/index.js";
-import { isNotFoundError, sleep } from "../utils/async.js";
-import { parseHexToBigInt } from "../utils/bigint.js";
-import { computeCommitment, deriveNpk, encryptNote } from "../utils/crypto.js";
-import {
-  DEFAULT_POLL_INTERVAL_MS,
-  DEFAULT_POLL_TIMEOUT_MS,
-  MAX_POLL_INTERVAL_MS,
-} from "../utils/polling.js";
-import { ensureAddress, ensureChainId } from "../utils/validators.js";
-import type {
-  DepositRelayResult,
-  DepositRequest,
-  DepositStateStore,
-  DepositSyncResult,
-} from "./types.js";
-
-export const DEPOSIT_ABI = [
-  "function deposit(address _depositor, (uint256 npk, uint256 amount, address token)[] notes, (uint256[3] data)[] ciphertexts)",
-] as const;
-const depositInterface = new Interface(DEPOSIT_ABI);
-
-type DepositClientOptions = {
-  merkleTrees?: LocalMerkleTrees;
-  fetch: FetchLike;
-  pollIntervalMs?: number;
-  pollTimeoutMs?: number;
-};
-
-function validateDepositRequest(request: DepositRequest) {
-  ensureChainId(request.chainId);
-  ensureAddress("pool address", request.poolAddress);
-  ensureAddress("depositor", request.depositor);
-  ensureAddress("token", request.note.token);
-
-  if (request.note.mpk < 0n) {
-    throw new Error("mpk must be non-negative");
-  }
-  if (request.note.random < 0n) {
-    throw new Error("random must be non-negative");
-  }
-  if (request.note.amount < 0n) {
-    throw new Error("amount must be non-negative");
-  }
-  const tokenScalar = BigInt(request.note.token);
-  if (tokenScalar < 0n) {
-    throw new Error("token must map to non-negative scalar");
-  }
-}
-
-export function createDepositClient(
-  stateStore: DepositStateStore,
-  options: DepositClientOptions,
-) {
-  if (!stateStore) {
-    throw new Error("stateStore dependency is required");
-  }
-
-  const merkleTrees = options.merkleTrees ?? createMerkleTrees();
-  const indexerClient = createIndexerClient(serviceConfig.indexerBaseUrl, {
-    fetch: options.fetch,
-  });
-
-  function buildCalldata(request: DepositRequest, npk: bigint) {
-    return depositInterface.encodeFunctionData("deposit", [
-      request.depositor,
-      [
-        // TODO(julienbrs) handle multiple notes
-        {
-          npk: npk,
-          amount: request.note.amount,
-          token: request.note.token,
-        },
-      ],
-      [
-        {
-          data: encryptNote(request.note).data,
-        },
-      ],
-    ]);
-  }
-
-  async function persistDepositSuccess(
-    job: PendingDepositJob,
-    record: CommitmentRecord,
-    indexedRoot: string,
-  ) {
-    await Promise.all([
-      stateStore.putLeaf({
-        chainId: job.chainId,
-        index: record.index,
-        commitment: record.commitment,
-      }),
-      stateStore.putRoot({
-        chainId: job.chainId,
-        root: indexedRoot,
-      }),
-      stateStore.putPendingJob({
-        ...job,
-        status: "succeeded",
-        lastCheckedAt: Date.now(),
-        txHash: record.txHash ?? job.txHash ?? null,
-        predictedCommitment: {
-          ...job.predictedCommitment,
-          index: record.index,
-          root: indexedRoot,
-        },
-      }),
-    ]);
-  }
-
-  return {
-    async request(request: DepositRequest): Promise<DepositRelayResult> {
-      validateDepositRequest(request);
-
-      const npk = deriveNpk(request);
-      const calldata = buildCalldata(request, npk);
-      const commitment = computeCommitment(request, npk);
-      const commitmentHex = ByteUtils.nToHex(
-        commitment,
-        ByteLength.UINT_256,
-        true,
-      );
-      const relayId = uuidv4();
-      const job: PendingDepositJob = {
-        relayId,
-        kind: "deposit",
-        chainId: request.chainId,
-        status: "pending",
-        broadcasterRelayId: null,
-        txHash: null,
-        createdAt: Date.now(),
-        timeoutMs: DEFAULT_JOB_TIMEOUT_MS,
-        predictedCommitment: {
-          hex: commitmentHex,
-        },
-      };
-      await stateStore.putPendingJob(job);
-      return { relayId, calldata, commitment: commitmentHex };
-    },
-
-    async syncPendingDeposit(relayId: string): Promise<DepositSyncResult> {
-      const job = await stateStore.getPendingJob(relayId);
-      if (!job || job.kind !== "deposit") {
-        throw new Error(`unknown deposit relay ${relayId}`);
-      }
-      await rebuildTreeFromStore({
-        chainId: job.chainId,
-        trees: merkleTrees,
-        loadLeaf: stateStore.getLeaf.bind(stateStore),
-      });
-      const commitmentHex = job.predictedCommitment.hex;
-      const record = await waitForCommitment(job.chainId, commitmentHex);
-      const { index, root: indexedRoot } = record;
-
-      const commitmentValue = parseHexToBigInt(commitmentHex);
-      const { index: localIndex, root: localRoot } = merkleTrees.addLeaf(
-        job.chainId,
-        commitmentValue,
-      );
-      // TODO: if local state drift detected, need to re-sync since last correct state
-      if (localIndex !== index) {
-        throw new Error(
-          "local merkle tree desynchronized (index mismatch), local index: " +
-            localIndex +
-            ", indexed index: " +
-            index,
-        );
-      }
-      if (localRoot.toLowerCase() !== indexedRoot.toLowerCase()) {
-        throw new Error(
-          "local merkle tree desynchronized (root mismatch), local root: " +
-            localRoot +
-            ", indexed root: " +
-            indexedRoot,
-        );
-      }
-
-      await persistDepositSuccess(job, record, indexedRoot);
-      return {
-        chainId: job.chainId,
-        index,
-        commitment: record.commitment,
-        root: indexedRoot,
-      };
-    },
-  };
-
-  async function waitForCommitment(
-    chainId: number,
-    commitmentHex: string,
-  ): Promise<CommitmentRecord> {
-    const timeout = options.pollTimeoutMs ?? DEFAULT_POLL_TIMEOUT_MS;
-    const startedAt = Date.now();
-    let delay = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-
-    while (Date.now() - startedAt <= timeout) {
-      try {
-        const record = await indexerClient.getCommitment({
-          chainId,
-          commitment: commitmentHex,
-        });
-        if (record) return record;
-      } catch (err) {
-        if (!isNotFoundError(err)) {
-          throw err;
-        }
-      }
-      await sleep(delay);
-      delay = Math.min(delay * 2, MAX_POLL_INTERVAL_MS);
-    }
-    throw new Error("commitment not found in indexer before timeout");
-  }
-}

package/transactions/index.ts

@@ -1,20 +0,0 @@
-export { createDepositClient } from "./deposit.js";
-export { createTransactService } from "./transact.js";
-export { createJobReconciler } from "./reconcile.js";
-export { createNoteSyncService } from "./note-sync.js";
-export type { NoteSyncStateStore } from "./note-sync.js";
-export type {
-  DepositRelayResult,
-  DepositNoteInput,
-  DepositRequest,
-  DepositSyncResult,
-  DepositStateStore,
-  Proof,
-  OutputNoteInput,
-  SpendNoteReference,
-  TransactRelayResult,
-  TransactRequest,
-  TransactSyncResult,
-  TransactStateStore,
-  WithdrawalNoteInput,
-} from "./types.js";

package/transactions/note-sync.test.ts

@@ -1,155 +0,0 @@
-import "fake-indexeddb/auto";
-
-import { poseidon } from "@railgun-community/circomlibjs";
-import { createMemoryStorage, createStateStore, ZkAccount } from "@unlink/core";
-import { describe, expect, it } from "vitest";
-
-import {
-  createMockFetch,
-  createMockIndexer,
-} from "../../test-utils/mock-indexer.js";
-import { ByteLength, ByteUtils } from "../key-derivation/bytes.js";
-import { formatUint256 } from "../utils/bigint.js";
-import { encryptNote } from "../utils/crypto.js";
-import { createNoteSyncService } from "./note-sync.js";
-
-const chainId = 1;
-const token = "0x1111111111111111111111111111111111111111";
-const random = 0x5n;
-const amount = 10n;
-const masterPublicKey = 0x1234567890abcdefn;
-const account: ZkAccount = {
-  spendingKeyPair: {
-    privateKey: new Uint8Array(32),
-    pubkey: [0n, 0n],
-  },
-  viewingKeyPair: {
-    privateKey: new Uint8Array(32),
-    pubkey: new Uint8Array(32),
-  },
-  nullifyingKey: 777n,
-  masterPublicKey,
-};
-
-function cipherToHexSet(ciphertext: ReturnType<typeof encryptNote>) {
-  return ciphertext.data.map((value) => formatUint256(value)) as [
-    string,
-    string,
-    string,
-  ];
-}
-
-function ciphertextToBytes(ciphertext: ReturnType<typeof encryptNote>) {
-  const payload = new Uint8Array(ByteLength.UINT_256 * ciphertext.data.length);
-  ciphertext.data.forEach((value, index) => {
-    const start = index * ByteLength.UINT_256;
-    payload.set(ByteUtils.hexStringToBytes(formatUint256(value)), start);
-  });
-  return payload;
-}
-
-describe("note sync service", () => {
-  it("stores decryptable notes", async () => {
-    const storage = createMemoryStorage();
-    await storage.open();
-    const state = createStateStore(storage);
-    const indexer = createMockIndexer();
-    const fetchMock = createMockFetch(indexer);
-    const service = createNoteSyncService(state, { fetch: fetchMock });
-
-    const npk = poseidon([masterPublicKey, random]);
-    const commitmentValue = poseidon([npk, BigInt(token), amount]);
-    const commitmentHex = formatUint256(commitmentValue);
-    const ciphertext = encryptNote({
-      mpk: masterPublicKey,
-      random,
-      amount,
-      token,
-    });
-    const ciphertextHex = cipherToHexSet(ciphertext);
-
-    indexer.publish(chainId, commitmentHex, ciphertextHex);
-    const syncedNotes = await service.sync(chainId, account);
-
-    expect(syncedNotes).toHaveLength(1);
-    const storedNote = await state.getNote(chainId, 0);
-    expect(storedNote?.commitment).toBe(commitmentHex);
-    expect(storedNote?.mpk).toBe(formatUint256(masterPublicKey));
-    expect(storedNote?.token).toBe(token);
-    expect(storedNote?.value).toBe(amount.toString());
-
-    const storedCiphertext = await state.getCiphertext(chainId, 0);
-    expect(storedCiphertext).not.toBeNull();
-    expect(storedCiphertext).toEqual(ciphertextToBytes(ciphertext));
-
-    const leaf = await state.getLeaf(chainId, 0);
-    expect(leaf?.commitment).toBe(commitmentHex);
-
-    expect(syncedNotes[0]?.commitment).toBe(commitmentHex);
-  });
-
-  it("ignores ciphertexts for other accounts", async () => {
-    const storage = createMemoryStorage();
-    await storage.open();
-    const state = createStateStore(storage);
-    const indexer = createMockIndexer();
-    const fetchMock = createMockFetch(indexer);
-    const service = createNoteSyncService(state, { fetch: fetchMock });
-
-    const otherMpk = masterPublicKey + 1n;
-    const npk = poseidon([otherMpk, random]);
-    const commitmentValue = poseidon([npk, BigInt(token), amount]);
-    const commitmentHex = formatUint256(commitmentValue);
-    const ciphertext = encryptNote({
-      mpk: otherMpk,
-      random,
-      amount,
-      token,
-    });
-    const ciphertextHex = cipherToHexSet(ciphertext);
-
-    indexer.publish(chainId, commitmentHex, ciphertextHex);
-    const syncedNotes = await service.sync(chainId, account);
-
-    expect(syncedNotes).toHaveLength(0);
-    expect(await state.getNote(chainId, 0)).toBeNull();
-    expect(await state.getCiphertext(chainId, 0)).toBeNull();
-  });
-
-  it("marks notes as spent when nullifier exists on-chain", async () => {
-    const storage = createMemoryStorage();
-    await storage.open();
-    const state = createStateStore(storage);
-    const indexer = createMockIndexer();
-    const fetchMock = createMockFetch(indexer);
-    const service = createNoteSyncService(state, { fetch: fetchMock });
-
-    const npk = poseidon([masterPublicKey, random]);
-    const commitmentValue = poseidon([npk, BigInt(token), amount]);
-    const commitmentHex = formatUint256(commitmentValue);
-    const ciphertext = encryptNote({
-      mpk: masterPublicKey,
-      random,
-      amount,
-      token,
-    });
-    const ciphertextHex = cipherToHexSet(ciphertext);
-
-    // Compute the nullifier that would be created for this note
-    const nullifier = poseidon([account.nullifyingKey, BigInt(0)]);
-    const nullifierHex = formatUint256(nullifier);
-
-    // Publish commitment and mark nullifier as spent on-chain
-    indexer.publish(chainId, commitmentHex, ciphertextHex);
-    indexer.spendNullifier(chainId, nullifierHex);
-
-    // Sync and verify note is marked as spent
-    const syncedNotes = await service.sync(chainId, account);
-    expect(syncedNotes).toHaveLength(1);
-
-    const storedNote = await state.getNote(chainId, 0);
-    expect(storedNote?.commitment).toBe(commitmentHex);
-    expect(storedNote?.spentAt).toBeDefined();
-    expect(storedNote?.spentAt).toBeGreaterThan(0);
-  });
-});