- Warning: this link contains your private note. Anyone
- who opens it can withdraw the funds — share only with
- the intended recipient via a private channel.
+ Warning: this link contains your private note. Anyone who
+ opens it can withdraw the funds — share only with the
+ intended recipient via a private channel.
{shareLink}
@@ -575,24 +461,6 @@ export default function DepositPage() {
)}
-
- {showConfirm && (
- {
- // Discard the staged transaction and notes: nothing was signed or
- // submitted, so these must not leak into a later confirmation.
- setShowConfirm(false);
- setPendingTx(null);
- pendingNotesRef.current = [];
- }}
- onConfirm={signAndSubmit}
- />
- )}
);
}
diff --git a/frontend/src/app/withdraw/page.tsx b/frontend/src/app/withdraw/page.tsx
index 860eafc..807b78d 100644
--- a/frontend/src/app/withdraw/page.tsx
+++ b/frontend/src/app/withdraw/page.tsx
@@ -104,7 +104,7 @@ export default function WithdrawPage() {
if (!hash.startsWith("#note=")) return;
const note = parseNote(decodeURIComponent(hash.slice("#note=".length)));
if (!note) return;
- saveNoteIfNew(note);
+ void saveNoteIfNew(note);
setSelectedCommitments(new Set([note.commitment]));
history.replaceState(null, "", window.location.pathname + window.location.search);
}, []);
@@ -216,7 +216,7 @@ export default function WithdrawPage() {
onStep("submitting");
const relayed = await relayWithdrawal({ poolId, recipient: recipientAddr, publicInputs, proof });
if (relayed) {
- markNoteSpent(note.commitment);
+ await markNoteSpent(note.commitment);
return relayed.hash;
}
@@ -234,7 +234,7 @@ export default function WithdrawPage() {
const signedXdr = await signTransaction(tx.toXDR());
onStep("submitting");
const txHash = await submitTransaction(signedXdr);
- markNoteSpent(note.commitment);
+ await markNoteSpent(note.commitment);
return txHash;
}
@@ -457,7 +457,7 @@ export default function WithdrawPage() {
onImport={(notes) => {
const newSel = new Set(selectedCommitments);
for (const note of notes) {
- saveNoteIfNew(note);
+ void saveNoteIfNew(note);
newSel.add(note.commitment); // always select, even if note already existed in storage
}
setSelectedCommitments(newSel);
diff --git a/frontend/src/circuits/hasher.json b/frontend/src/circuits/hasher.json
index 8878c2c..b592a28 100644
--- a/frontend/src/circuits/hasher.json
+++ b/frontend/src/circuits/hasher.json
@@ -1 +1 @@
-{"noir_version":"1.0.0-beta.9+6abff2f16e1c1314ba30708d1cf032a536de3d19","hash":"7135887383329252322","abi":{"parameters":[{"name":"a","type":{"kind":"field"},"visibility":"private"},{"name":"b","type":{"kind":"field"},"visibility":"private"}],"return_type":{"abi_type":{"kind":"field"},"visibility":"public"},"error_types":{}},"bytecode":"H4sIAAAAAAAA/7WSUQrDIBBE1Zi23z3Jrqtx/etVKjX3P0GpJQaWSH+a5MGwg6CMo1ot3Kqs6tFtPtokmLwv0RUkfIJLmQP4kCdGxsDh5ZiosOeYcoqQ0FPBOSSaYWEQZ8FOzsxp/8/ptgvfbHfR75r13bwWfhDeNr/uG6suVdcf72U2HcA+0BzY53hcLtDi7kb1f0B6o3o+BOgFCPQCAAA=","debug_symbols":"nZPLroMgEIbfZdYuuCiKr3JyYlCxISFoKDRpjO9eNKJ1QRduuA3fzz8wzNDL1j8aZYbxCfXfDK1VWqtHo8dOODWasDovGcRp46yUYQm+4oGahJXGQW281hm8hPbbpuckzNY7YUMUZSBNH/ogOCgt19GSnTRKo5zuLMb8oIsrjtM4LcjOU16efHXhSZonBEcDhBCWUqBpBYzzMwXGbnko0eGhylMKxQ8PZZFHD2VJUwrsxzMQtgtwym/wGKHjFlDO7uRQ8XgLmKNrDv9hJjplL8ULCOoqA7y1JLTLKm6VaLXci3vwpvuqdfeeYiT+hsmOney9lav0FguHfQA=","file_map":{"50":{"source":"use dep::poseidon::poseidon2::Poseidon2;\n\npub fn main(a: Field, b: Field) -> pub Field {\n Poseidon2::hash([a, b], 2)\n}\n","path":"/home/caxton/work/Dshield/circuits/hasher/src/main.nr"},"58":{"source":"use std::default::Default;\nuse std::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n cache: [Field; 3],\n state: [Field; 4],\n cache_size: u32,\n squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2::hash_internal(input, message_size)\n }\n\n pub(crate) fn new(iv: Field) -> Poseidon2 {\n let mut result =\n Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = crate::poseidon2_permutation(self.state, 4);\n }\n\n fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(input: [Field; N], in_len: u32) -> Field {\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = Poseidon2::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n sponge.squeeze()\n }\n}\n\npub struct Poseidon2Hasher {\n _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n fn finish(self) -> Field {\n let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n let mut sponge = Poseidon2::new(iv);\n for i in 0..self._state.len() {\n sponge.absorb(self._state[i]);\n }\n sponge.squeeze()\n }\n\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for Poseidon2Hasher {\n fn default() -> Self {\n Poseidon2Hasher { _state: &[] }\n }\n}\n","path":"/home/caxton/nargo/github.com/noir-lang/poseidon/v0.2.0/src/poseidon2.nr"}},"names":["main"],"brillig_names":[]}
\ No newline at end of file
+{"noir_version":"1.0.0-beta.9+6abff2f16e1c1314ba30708d1cf032a536de3d19","hash":"7135887383329252322","abi":{"parameters":[{"name":"a","type":{"kind":"field"},"visibility":"private"},{"name":"b","type":{"kind":"field"},"visibility":"private"}],"return_type":{"abi_type":{"kind":"field"},"visibility":"public"},"error_types":{}},"bytecode":"H4sIAAAAAAAA/7WSUQrDIBBE1Zi23z3Jrqtx/etVKjX3P0GpJQaWSH+a5MGwg6CMo1ot3Kqs6tFtPtokmLwv0RUkfIJLmQP4kCdGxsDh5ZiosOeYcoqQ0FPBOSSaYWEQZ8FOzsxp/8/ptgvfbHfR75r13bwWfhDeNr/uG6suVdcf72U2HcA+0BzY53hcLtDi7kb1f0B6o3o+BOgFCPQCAAA=","debug_symbols":"nZPLroMgEIbfZdYuuCiKr3JyYlCxISFoKDRpjO9eNKJ1QRduuA3fzz8wzNDL1j8aZYbxCfXfDK1VWqtHo8dOODWasDovGcRp46yUYQm+4oGahJXGQW281hm8hPbbpuckzNY7YUMUZSBNH/ogOCgt19GSnTRKo5zuLMb8oIsrjtM4LcjOU16efHXhSZonBEcDhBCWUqBpBYzzMwXGbnko0eGhylMKxQ8PZZFHD2VJUwrsxzMQtgtwym/wGKHjFlDO7uRQ8XgLmKNrDv9hJjplL8ULCOoqA7y1JLTLKm6VaLXci3vwpvuqdfeeYiT+hsmOney9lav0FguHfQA=","file_map":{"50":{"source":"use dep::poseidon::poseidon2::Poseidon2;\n\npub fn main(a: Field, b: Field) -> pub Field {\n Poseidon2::hash([a, b], 2)\n}\n","path":"/Users/mac/DSHEILD 3/Dshield/circuits/hasher/src/main.nr"},"58":{"source":"use std::default::Default;\nuse std::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n cache: [Field; 3],\n state: [Field; 4],\n cache_size: u32,\n squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2::hash_internal(input, message_size)\n }\n\n pub(crate) fn new(iv: Field) -> Poseidon2 {\n let mut result =\n Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = crate::poseidon2_permutation(self.state, 4);\n }\n\n fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(input: [Field; N], in_len: u32) -> Field {\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = Poseidon2::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n sponge.squeeze()\n }\n}\n\npub struct Poseidon2Hasher {\n _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n fn finish(self) -> Field {\n let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n let mut sponge = Poseidon2::new(iv);\n for i in 0..self._state.len() {\n sponge.absorb(self._state[i]);\n }\n sponge.squeeze()\n }\n\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for Poseidon2Hasher {\n fn default() -> Self {\n Poseidon2Hasher { _state: &[] }\n }\n}\n","path":"/Users/mac/nargo/github.com/noir-lang/poseidon/v0.2.0/src/poseidon2.nr"}},"names":["main"],"brillig_names":[]}
\ No newline at end of file
diff --git a/frontend/src/lib/kyc.test.ts b/frontend/src/lib/kyc.test.ts
index 2a5bc39..d44156f 100644
--- a/frontend/src/lib/kyc.test.ts
+++ b/frontend/src/lib/kyc.test.ts
@@ -1,47 +1,84 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, beforeEach } from "vitest";
import { saveKyc, getKyc, clearKyc, type KycRecord } from "./kyc";
-function makeKyc(overrides: Partial = {}): KycRecord {
+function makeKycRecord(overrides: Partial = {}): KycRecord {
return {
- preimage: "00aabbcc",
- hash: "ddeeff00",
- registeredOnChain: true,
+ preimage: "test-preimage-123",
+ hash: "test-hash-456",
+ registeredOnChain: false,
createdAt: Date.now(),
...overrides,
};
}
+beforeEach(() => {
+ localStorage.clear();
+});
+
describe("saveKyc / getKyc", () => {
it("returns null when nothing saved", () => {
expect(getKyc()).toBeNull();
});
- it("saves and retrieves a KYC record", () => {
- const kyc = makeKyc();
- saveKyc(kyc);
+ it("saves and retrieves a KYC record", async () => {
+ const record = makeKycRecord();
+ await saveKyc(record);
const retrieved = getKyc();
expect(retrieved).not.toBeNull();
- expect(retrieved!.preimage).toBe("00aabbcc");
- expect(retrieved!.hash).toBe("ddeeff00");
- expect(retrieved!.registeredOnChain).toBe(true);
+ expect(retrieved!.preimage).toBe("test-preimage-123");
+ expect(retrieved!.hash).toBe("test-hash-456");
+ expect(retrieved!.registeredOnChain).toBe(false);
});
- it("overwrites previous KYC record", () => {
- saveKyc(makeKyc({ hash: "first" }));
- saveKyc(makeKyc({ hash: "second" }));
- expect(getKyc()!.hash).toBe("second");
+ it("overwrites existing KYC record", async () => {
+ await saveKyc(makeKycRecord({ preimage: "first" }));
+ await saveKyc(makeKycRecord({ preimage: "second" }));
+ const retrieved = getKyc();
+ expect(retrieved!.preimage).toBe("second");
});
});
describe("clearKyc", () => {
- it("removes stored KYC data", () => {
- saveKyc(makeKyc());
+ it("removes KYC record from storage", async () => {
+ await saveKyc(makeKycRecord());
expect(getKyc()).not.toBeNull();
clearKyc();
expect(getKyc()).toBeNull();
});
- it("does not throw when nothing to clear", () => {
+ it("does not throw when clearing non-existent record", () => {
expect(() => clearKyc()).not.toThrow();
});
});
+
+describe("Cross-tab synchronization", () => {
+ it("concurrent saves do not corrupt data", async () => {
+ const record1 = makeKycRecord({ preimage: "concurrent1" });
+ const record2 = makeKycRecord({ preimage: "concurrent2" });
+
+ // Fire both saves simultaneously - last one should win cleanly
+ await Promise.all([saveKyc(record1), saveKyc(record2)]);
+
+ const retrieved = getKyc();
+ expect(retrieved).not.toBeNull();
+ // One of them should have won (not corrupted JSON)
+ expect(["concurrent1", "concurrent2"]).toContain(retrieved!.preimage);
+ });
+
+ it("lock timeout throws error if lock cannot be acquired", async () => {
+ // Manually set a lock with a recent timestamp that won't be considered stale
+ const stubbornLock = JSON.stringify({
+ id: "stuck-lock",
+ timestamp: Date.now() // Fresh timestamp, won't be cleared as stale
+ });
+ localStorage.setItem("dshield_kyc_lock", stubbornLock);
+
+ // Attempt to save should timeout and throw
+ await expect(saveKyc(makeKycRecord())).rejects.toThrow(
+ "Failed to acquire KYC storage lock after timeout"
+ );
+
+ // Clean up
+ localStorage.removeItem("dshield_kyc_lock");
+ }, 10000); // 10 second timeout for this test
+});
diff --git a/frontend/src/lib/kyc.ts b/frontend/src/lib/kyc.ts
index 17d0402..d45a082 100644
--- a/frontend/src/lib/kyc.ts
+++ b/frontend/src/lib/kyc.ts
@@ -1,4 +1,6 @@
const KYC_KEY = "dshield_kyc";
+const KYC_LOCK_KEY = "dshield_kyc_lock";
+const LOCK_TIMEOUT_MS = 5000;
export interface KycRecord {
preimage: string;
@@ -7,8 +9,71 @@ export interface KycRecord {
createdAt: number;
}
-export function saveKyc(record: KycRecord): void {
- localStorage.setItem(KYC_KEY, JSON.stringify(record));
+/**
+ * Acquire a simple advisory lock to serialize cross-tab writes.
+ * Prevents concurrent KYC updates from different tabs/windows.
+ */
+async function acquireLock(): Promise<() => void> {
+ const lockId = Date.now().toString() + Math.random().toString(36);
+ const deadline = Date.now() + LOCK_TIMEOUT_MS;
+
+ while (Date.now() < deadline) {
+ const currentLock = localStorage.getItem(KYC_LOCK_KEY);
+ if (!currentLock) {
+ const lockData = JSON.stringify({ id: lockId, timestamp: Date.now() });
+ localStorage.setItem(KYC_LOCK_KEY, lockData);
+ const verifyLock = localStorage.getItem(KYC_LOCK_KEY);
+ if (verifyLock) {
+ try {
+ const parsed = JSON.parse(verifyLock);
+ if (parsed.id === lockId) {
+ return () => {
+ const currentData = localStorage.getItem(KYC_LOCK_KEY);
+ if (currentData) {
+ try {
+ const current = JSON.parse(currentData);
+ if (current.id === lockId) {
+ localStorage.removeItem(KYC_LOCK_KEY);
+ }
+ } catch {
+ localStorage.removeItem(KYC_LOCK_KEY);
+ }
+ }
+ };
+ }
+ } catch {
+ // Invalid JSON, try again
+ }
+ }
+ } else {
+ try {
+ const lockData = JSON.parse(currentLock);
+ if (lockData.timestamp && Date.now() - lockData.timestamp > LOCK_TIMEOUT_MS) {
+ localStorage.removeItem(KYC_LOCK_KEY);
+ }
+ } catch {
+ // Invalid lock data without timestamp, don't clear immediately
+ }
+ }
+ await new Promise((resolve) => setTimeout(resolve, 10));
+ }
+
+ throw new Error("Failed to acquire KYC storage lock after timeout");
+}
+
+async function withLock(fn: () => T): Promise {
+ const release = await acquireLock();
+ try {
+ return fn();
+ } finally {
+ release();
+ }
+}
+
+export async function saveKyc(record: KycRecord): Promise {
+ return withLock(() => {
+ localStorage.setItem(KYC_KEY, JSON.stringify(record));
+ });
}
export function getKyc(): KycRecord | null {
diff --git a/frontend/src/lib/notes.test.ts b/frontend/src/lib/notes.test.ts
index 2abffee..49aa603 100644
--- a/frontend/src/lib/notes.test.ts
+++ b/frontend/src/lib/notes.test.ts
@@ -206,31 +206,31 @@ describe("saveNote / getNotes", () => {
expect(getNotes()).toEqual([]);
});
- it("saves and retrieves a note", () => {
+ it("saves and retrieves a note", async () => {
const note = makeNote();
- saveNote(note);
+ await saveNote(note);
const notes = getNotes();
expect(notes).toHaveLength(1);
expect(notes[0].commitment).toBe("abcd1234");
expect(notes[0].amount).toBe("1000000");
});
- it("appends multiple notes", () => {
- saveNote(makeNote({ commitment: "aaa" }));
- saveNote(makeNote({ commitment: "bbb" }));
+ it("appends multiple notes", async () => {
+ await saveNote(makeNote({ commitment: "aaa" }));
+ await saveNote(makeNote({ commitment: "bbb" }));
expect(getNotes()).toHaveLength(2);
});
});
describe("saveNoteIfNew", () => {
- it("adds a note that isn't already stored", () => {
- expect(saveNoteIfNew(makeNote({ commitment: "aaa" }))).toBe(true);
+ it("adds a note that isn't already stored", async () => {
+ expect(await saveNoteIfNew(makeNote({ commitment: "aaa" }))).toBe(true);
expect(getNotes()).toHaveLength(1);
});
- it("does not duplicate a note with an existing commitment", () => {
- saveNote(makeNote({ commitment: "aaa" }));
- expect(saveNoteIfNew(makeNote({ commitment: "aaa", secret: "00ff" }))).toBe(
+ it("does not duplicate a note with an existing commitment", async () => {
+ await saveNote(makeNote({ commitment: "aaa" }));
+ expect(await saveNoteIfNew(makeNote({ commitment: "aaa", secret: "00ff" }))).toBe(
false,
);
expect(getNotes()).toHaveLength(1);
@@ -238,41 +238,41 @@ describe("saveNoteIfNew", () => {
});
describe("markNoteSpent", () => {
- it("marks the correct note as spent", () => {
- saveNote(makeNote({ commitment: "aaa" }));
- saveNote(makeNote({ commitment: "bbb" }));
- markNoteSpent("aaa");
+ it("marks the correct note as spent", async () => {
+ await saveNote(makeNote({ commitment: "aaa" }));
+ await saveNote(makeNote({ commitment: "bbb" }));
+ await markNoteSpent("aaa");
const notes = getNotes();
expect(notes[0].spent).toBe(true);
expect(notes[1].spent).toBe(false);
});
- it("does not modify notes with different commitment", () => {
- saveNote(makeNote({ commitment: "aaa" }));
- markNoteSpent("zzz");
+ it("does not modify notes with different commitment", async () => {
+ await saveNote(makeNote({ commitment: "aaa" }));
+ await markNoteSpent("zzz");
expect(getNotes()[0].spent).toBe(false);
});
});
describe("getActiveNotes", () => {
- it("filters out spent notes", () => {
- saveNote(makeNote({ commitment: "aaa" }));
- saveNote(makeNote({ commitment: "bbb" }));
- markNoteSpent("aaa");
+ it("filters out spent notes", async () => {
+ await saveNote(makeNote({ commitment: "aaa" }));
+ await saveNote(makeNote({ commitment: "bbb" }));
+ await markNoteSpent("aaa");
const active = getActiveNotes();
expect(active).toHaveLength(1);
expect(active[0].commitment).toBe("bbb");
});
- it("returns all notes when none are spent", () => {
- saveNote(makeNote({ commitment: "aaa" }));
- saveNote(makeNote({ commitment: "bbb" }));
+ it("returns all notes when none are spent", async () => {
+ await saveNote(makeNote({ commitment: "aaa" }));
+ await saveNote(makeNote({ commitment: "bbb" }));
expect(getActiveNotes()).toHaveLength(2);
});
- it("returns empty array when all are spent", () => {
- saveNote(makeNote({ commitment: "aaa" }));
- markNoteSpent("aaa");
+ it("returns empty array when all are spent", async () => {
+ await saveNote(makeNote({ commitment: "aaa" }));
+ await markNoteSpent("aaa");
expect(getActiveNotes()).toHaveLength(0);
});
});
@@ -341,3 +341,70 @@ describe("generateNoteLink without a Buffer global", () => {
expect(restored!.poolId).toBe(withPool.poolId);
});
});
+
+
+describe("Cross-tab synchronization", () => {
+ it("concurrent saves do not clobber each other", async () => {
+ // Simulate two tabs saving notes concurrently
+ const note1 = makeNote({ commitment: "concurrent1" });
+ const note2 = makeNote({ commitment: "concurrent2" });
+
+ // Fire both saves simultaneously
+ await Promise.all([
+ saveNote(note1),
+ saveNote(note2),
+ ]);
+
+ const notes = getNotes();
+ expect(notes).toHaveLength(2);
+ expect(notes.some((n) => n.commitment === "concurrent1")).toBe(true);
+ expect(notes.some((n) => n.commitment === "concurrent2")).toBe(true);
+ });
+
+ it("concurrent markNoteSpent operations serialize correctly", async () => {
+ await saveNote(makeNote({ commitment: "mark1" }));
+ await saveNote(makeNote({ commitment: "mark2" }));
+
+ // Mark both as spent concurrently
+ await Promise.all([
+ markNoteSpent("mark1"),
+ markNoteSpent("mark2"),
+ ]);
+
+ const notes = getNotes();
+ expect(notes[0].spent).toBe(true);
+ expect(notes[1].spent).toBe(true);
+ });
+
+ it("concurrent save and markNoteSpent do not lose updates", async () => {
+ await saveNote(makeNote({ commitment: "existing" }));
+
+ // One tab saves a new note while another marks existing note as spent
+ await Promise.all([
+ saveNote(makeNote({ commitment: "new" })),
+ markNoteSpent("existing"),
+ ]);
+
+ const notes = getNotes();
+ expect(notes).toHaveLength(2);
+ expect(notes.find((n) => n.commitment === "existing")?.spent).toBe(true);
+ expect(notes.find((n) => n.commitment === "new")).toBeDefined();
+ });
+
+ it("lock timeout throws error if lock cannot be acquired", async () => {
+ // Manually set a lock with a recent timestamp that won't be considered stale
+ const stubbornLock = JSON.stringify({
+ id: "stuck-lock",
+ timestamp: Date.now() // Fresh timestamp, won't be cleared as stale
+ });
+ localStorage.setItem("dshield_notes_lock", stubbornLock);
+
+ // Attempt to save should timeout and throw
+ await expect(
+ saveNote(makeNote({ commitment: "timeout-test" }))
+ ).rejects.toThrow("Failed to acquire storage lock after timeout");
+
+ // Clean up
+ localStorage.removeItem("dshield_notes_lock");
+ }, 10000); // 10 second timeout for this test
+});
diff --git a/frontend/src/lib/notes.ts b/frontend/src/lib/notes.ts
index 0394cee..aefaff2 100644
--- a/frontend/src/lib/notes.ts
+++ b/frontend/src/lib/notes.ts
@@ -12,11 +12,92 @@ export interface ShieldedNote {
}
const STORAGE_KEY = "dshield_notes";
+const STORAGE_LOCK_KEY = "dshield_notes_lock";
+const LOCK_TIMEOUT_MS = 5000;
-export function saveNote(note: ShieldedNote): void {
- const notes = getNotes();
- notes.push(note);
- localStorage.setItem(STORAGE_KEY, JSON.stringify(notes));
+/**
+ * Acquire a simple advisory lock to serialize cross-tab writes.
+ * This prevents two tabs from concurrently performing read-modify-write
+ * on the note store and silently clobbering each other's updates.
+ *
+ * Not cryptographically secure, but sufficient to prevent accidental
+ * data loss from concurrent operations in different tabs/windows.
+ */
+async function acquireLock(): Promise<() => void> {
+ const lockId = Date.now().toString() + Math.random().toString(36);
+ const deadline = Date.now() + LOCK_TIMEOUT_MS;
+
+ while (Date.now() < deadline) {
+ const currentLock = localStorage.getItem(STORAGE_LOCK_KEY);
+ if (!currentLock) {
+ // No lock exists, try to acquire it
+ const lockData = JSON.stringify({ id: lockId, timestamp: Date.now() });
+ localStorage.setItem(STORAGE_LOCK_KEY, lockData);
+ // Verify we actually got the lock (another tab might have written simultaneously)
+ const verifyLock = localStorage.getItem(STORAGE_LOCK_KEY);
+ if (verifyLock) {
+ try {
+ const parsed = JSON.parse(verifyLock);
+ if (parsed.id === lockId) {
+ // Successfully acquired lock
+ return () => {
+ const currentData = localStorage.getItem(STORAGE_LOCK_KEY);
+ if (currentData) {
+ try {
+ const current = JSON.parse(currentData);
+ if (current.id === lockId) {
+ localStorage.removeItem(STORAGE_LOCK_KEY);
+ }
+ } catch {
+ // Corrupted lock data, safe to remove
+ localStorage.removeItem(STORAGE_LOCK_KEY);
+ }
+ }
+ };
+ }
+ } catch {
+ // Invalid JSON, try again
+ }
+ }
+ } else {
+ // Check if the lock is stale (holder crashed or never released)
+ try {
+ const lockData = JSON.parse(currentLock);
+ if (lockData.timestamp && Date.now() - lockData.timestamp > LOCK_TIMEOUT_MS) {
+ // Stale lock, try to clear it
+ localStorage.removeItem(STORAGE_LOCK_KEY);
+ }
+ } catch {
+ // Invalid lock data without timestamp, assume it's not a proper lock from our system
+ // Don't clear it immediately - it might be from a test
+ }
+ }
+ // Wait a bit before retrying
+ await new Promise((resolve) => setTimeout(resolve, 10));
+ }
+
+ throw new Error("Failed to acquire storage lock after timeout");
+}
+
+/**
+ * Execute a function with the storage lock held.
+ * Ensures only one tab can modify the note store at a time.
+ */
+async function withLock(fn: () => T): Promise {
+ const release = await acquireLock();
+ try {
+ return fn();
+ } finally {
+ release();
+ }
+}
+
+export async function saveNote(note: ShieldedNote): Promise {
+ return withLock(() => {
+ const notes = getNotes();
+ notes.push(note);
+ localStorage.setItem(STORAGE_KEY, JSON.stringify(notes));
+ });
}
/**
@@ -24,12 +105,14 @@ export function saveNote(note: ShieldedNote): void {
* Used when importing a pasted note so re-importing doesn't create duplicates.
* Returns true if the note was newly added.
*/
-export function saveNoteIfNew(note: ShieldedNote): boolean {
- const notes = getNotes();
- if (notes.some((n) => n.commitment === note.commitment)) return false;
- notes.push(note);
- localStorage.setItem(STORAGE_KEY, JSON.stringify(notes));
- return true;
+export async function saveNoteIfNew(note: ShieldedNote): Promise {
+ return withLock(() => {
+ const notes = getNotes();
+ if (notes.some((n) => n.commitment === note.commitment)) return false;
+ notes.push(note);
+ localStorage.setItem(STORAGE_KEY, JSON.stringify(notes));
+ return true;
+ });
}
export function getNotes(): ShieldedNote[] {
@@ -39,12 +122,14 @@ export function getNotes(): ShieldedNote[] {
return JSON.parse(raw);
}
-export function markNoteSpent(commitment: string): void {
- const notes = getNotes();
- const updated = notes.map((n) =>
- n.commitment === commitment ? { ...n, spent: true } : n,
- );
- localStorage.setItem(STORAGE_KEY, JSON.stringify(updated));
+export async function markNoteSpent(commitment: string): Promise {
+ return withLock(() => {
+ const notes = getNotes();
+ const updated = notes.map((n) =>
+ n.commitment === commitment ? { ...n, spent: true } : n,
+ );
+ localStorage.setItem(STORAGE_KEY, JSON.stringify(updated));
+ });
}
export function getActiveNotes(): ShieldedNote[] {
diff --git a/frontend/src/lib/sync.ts b/frontend/src/lib/sync.ts
index 430060b..b114e87 100644
--- a/frontend/src/lib/sync.ts
+++ b/frontend/src/lib/sync.ts
@@ -22,7 +22,7 @@ export async function syncSpentNotes(): Promise {
),
]);
if (val && StellarSdk.scValToNative(val) === true) {
- markNoteSpent(note.commitment);
+ await markNoteSpent(note.commitment);
count++;
}
} catch {