Dshield/frontend/src/lib/deposits.test.ts at dev · ghzhost/Dshield · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
import { describe, it, expect } from "vitest";
import {
  saveDeposit,
  getDeposits,
  getAllCommitments,
  clearDeposits,
  type DepositRecord,
} from "./deposits";

function makeDeposit(overrides: Partial<DepositRecord> = {}): DepositRecord {
  return {
    commitment: "aabbccdd",
    leafIndex: 0,
    timestamp: Date.now(),
    ...overrides,
  };
}

describe("saveDeposit / getDeposits", () => {
  it("returns empty array when nothing saved", () => {
    expect(getDeposits()).toEqual([]);
  });

  it("saves and retrieves a deposit", () => {
    saveDeposit(makeDeposit());
    const deposits = getDeposits();
    expect(deposits).toHaveLength(1);
    expect(deposits[0].commitment).toBe("aabbccdd");
  });

  it("ignores duplicate commitments", () => {
    saveDeposit(makeDeposit({ commitment: "aaa" }));
    saveDeposit(makeDeposit({ commitment: "aaa" }));
    expect(getDeposits()).toHaveLength(1);
  });

  it("sorts by leafIndex", () => {
    saveDeposit(makeDeposit({ commitment: "c", leafIndex: 2 }));
    saveDeposit(makeDeposit({ commitment: "a", leafIndex: 0 }));
    saveDeposit(makeDeposit({ commitment: "b", leafIndex: 1 }));
    const deposits = getDeposits();
    expect(deposits.map((d) => d.leafIndex)).toEqual([0, 1, 2]);
    expect(deposits.map((d) => d.commitment)).toEqual(["a", "b", "c"]);
  });
});

describe("getAllCommitments", () => {
  it("returns empty array when nothing saved", () => {
    expect(getAllCommitments()).toEqual([]);
  });

  it("returns commitments in order", () => {
    saveDeposit(makeDeposit({ commitment: "aaa", leafIndex: 0 }));
    saveDeposit(makeDeposit({ commitment: "bbb", leafIndex: 1 }));
    const commitments = getAllCommitments();
    expect(commitments).toEqual(["aaa", "bbb"]);
  });

  it("fills gaps with zero bytes", () => {
    saveDeposit(makeDeposit({ commitment: "ccc", leafIndex: 2 }));
    const commitments = getAllCommitments();
    const zeroPadding = "0x" + "00".repeat(32);
    expect(commitments).toHaveLength(3);
    expect(commitments[0]).toBe(zeroPadding);
    expect(commitments[1]).toBe(zeroPadding);
    expect(commitments[2]).toBe("ccc");
  });

  it("fills interior gap when deposits at index 0 and 2 but not 1", () => {
    saveDeposit(makeDeposit({ commitment: "first", leafIndex: 0 }));
    saveDeposit(makeDeposit({ commitment: "third", leafIndex: 2 }));
    const commitments = getAllCommitments();
    const zeroPadding = "0x" + "00".repeat(32);
    expect(commitments).toHaveLength(3);
    expect(commitments[0]).toBe("first");
    expect(commitments[1]).toBe(zeroPadding);
    expect(commitments[2]).toBe("third");
  });

  it("scopes strictly to the requested pool", () => {
    saveDeposit(makeDeposit({ commitment: "pa", leafIndex: 0, poolId: "POOL_A" }));
    saveDeposit(makeDeposit({ commitment: "pb", leafIndex: 0, poolId: "POOL_B" }));
    expect(getAllCommitments("POOL_A")).toEqual(["pa"]);
    expect(getAllCommitments("POOL_B")).toEqual(["pb"]);
  });

  it("excludes legacy records without a poolId when a pool is requested", () => {
    // A stale record from a previous deployment must not leak into the tree.
    saveDeposit(makeDeposit({ commitment: "legacy", leafIndex: 0 }));
    saveDeposit(makeDeposit({ commitment: "current", leafIndex: 1, poolId: "POOL_A" }));
    const commitments = getAllCommitments("POOL_A");
    const zeroPadding = "0x" + "00".repeat(32);
    expect(commitments).toEqual([zeroPadding, "current"]);
  });
});

describe("clearDeposits", () => {
  it("clears the entire cache when no pool is given", () => {
    saveDeposit(makeDeposit({ commitment: "a", leafIndex: 0, poolId: "POOL_A" }));
    saveDeposit(makeDeposit({ commitment: "b", leafIndex: 1, poolId: "POOL_B" }));
    const removed = clearDeposits();
    expect(removed).toBe(2);
    expect(getDeposits()).toEqual([]);
  });

  it("clears only the requested pool's records", () => {
    saveDeposit(makeDeposit({ commitment: "a", leafIndex: 0, poolId: "POOL_A" }));
    saveDeposit(makeDeposit({ commitment: "b", leafIndex: 1, poolId: "POOL_B" }));
    const removed = clearDeposits("POOL_A");
    expect(removed).toBe(1);
    const remaining = getDeposits();
    expect(remaining).toHaveLength(1);
    expect(remaining[0].poolId).toBe("POOL_B");
  });

  it("returns 0 when nothing matches", () => {
    saveDeposit(makeDeposit({ commitment: "a", leafIndex: 0, poolId: "POOL_A" }));
    expect(clearDeposits("POOL_X")).toBe(0);
    expect(getDeposits()).toHaveLength(1);
  });
});