1 files changed, 117 insertions, 0 deletions
diff --git a/tools/marmot-multidevice-test.js b/tools/marmot-multidevice-test.js
new file mode 100644
index 0000000..264fbcb
--- /dev/null
+++ b/tools/marmot-multidevice-test.js
@@ -0,0 +1,117 @@
+// Multi-device White Noise groups: one account on two coinos devices, against
+// the Rust reference (MDK's `wn`), on public relays with throwaway identities.
+//
+//   bun tools/marmot-multidevice-test.js
+//
+// Needs `wn` (github.com/marmot-protocol/mdk, crates/cli) on PATH or at WN,
+// with its daemon on public relays:
+//   export WN_HOME=… WN_SECRET_STORE=file WN_SOCKET=/tmp/wn.sock
+//   wn daemon start --discovery-relays wss://nos.lol,wss://relay.primal.net \
+//                   --default-account-relays wss://nos.lol,wss://relay.primal.net
+//
+// Covers: both devices publish KeyPackages (one slot each); a wn invitation
+// reaches whichever device(s) wn adds; a group founded on device A adds
+// device B by itself (the admin's sibling add) through our own inbox; wn
+// reads and writes a group holding two leaves of one npub; both devices read.
+import { spawnSync } from 'node:child_process';
+import { finalizeEvent, generateSecretKey, getPublicKey } from 'nostr-tools/pure';
+import { npubEncode } from 'nostr-tools/nip19';
+// MD_DEBUG=1 shows the client's dlog lines (sibling adds and why they skip)
+if (process.env.MD_DEBUG && typeof localStorage === 'undefined') {
+  globalThis.localStorage = { getItem: (k) => (k === 'coinos-debug' ? '1' : null), setItem() {}, removeItem() {} };
+}
+const { marmotClient } = await import('../src/marmot-client.js');
+const { subscribeOn, publishOn } = await import('../src/nostr.js');
+const { unwrapDM } = await import('../src/dm.js');
+
+const WN = process.env.WN || 'wn';
+const RELAYS = (process.env.RELAYS || 'wss://relay.coinos.io,wss://nos.lol,wss://relay.primal.net').split(',');
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+let failed = 0;
+const ok = (cond, label, extra) => { if (cond) console.log('  ok  ' + label); else { failed++; console.log('  FAIL ' + label + (extra ? ' — ' + extra : '')); } };
+function wn(args, { account } = {}) {
+  const r = spawnSync(WN, ['--json', ...(account ? ['--account', account] : []), ...args], { encoding: 'utf8', timeout: 60_000 });
+  const line = (r.stdout || '').trim().split('\n').filter(Boolean).at(-1) || '';
+  try { const j = JSON.parse(line); return j.ok ? j.result : { error: j.error }; } catch { return { error: { message: (r.stderr || r.stdout || 'no output').trim().slice(0, 300) } }; }
+}
+const waitFor = async (fn, label, ms = 45_000) => { const t = Date.now(); while (Date.now() - t < ms) { const v = await fn(); if (v) return v; await sleep(1500); } console.log('  … timed out waiting for ' + label); return null; };
+const memStore = () => { const m = new Map(); return { all: async () => new Map(m), put: async (k, v) => { m.set(k, structuredClone(v)); }, del: async (k) => { m.delete(k); }, wipe: async () => m.clear() }; };
+
+const who = wn(['whoami']);
+if (who.error) { console.log('SKIP: wn daemon not reachable (' + who.error.message + ')'); process.exit(0); }
+
+// one account, two devices
+const sk = generateSecretKey(), pk = getPublicKey(sk);
+const identity = async () => ({ pubkey: pk, signer: sk });
+const log = { A: [], B: [] };
+const mk = (name) => marmotClient({
+  scope: 'test-' + name, pubkey: pk, identity, relays: RELAYS, store: memStore(),
+  on: (type, g, data) => { if (type === 'message') log[name].push(data); if (type === 'joined') console.log(`  [${name}] joined ${g.id.slice(0, 8)} (invited by ${(g.inviter || '').slice(0, 8)})`); },
+});
+const A = mk('A'), B = mk('B');
+// the account's relay lists, so wn can route to us (the sync feature publishes these for a real wallet)
+for (const kind of [10002, 10050]) await publishOn(RELAYS, finalizeEvent({ kind, created_at: Math.floor(Date.now() / 1000), tags: RELAYS.map((r) => [kind === 10002 ? 'r' : 'relay', r]), content: '' }, sk));
+// the DM inbox: every Welcome for our npub goes to both devices, as the app's inbox does
+// no `since`: a gift wrap's created_at is randomized into the past (NIP-59)
+subscribeOn(RELAYS, { kinds: [1059], '#p': [pk] }, async (ev) => {
+  let got; try { got = await unwrapDM(ev, sk); } catch { return; }
+  const rumor = got && got.rumor;
+  if (!rumor || rumor.kind !== 444) return;
+  for (const c of [A, B]) c.welcome(rumor).catch(() => {});
+});
+
+try {
+  await A.start(); await B.start();
+  ok(await A.ready({ interactive: true }), 'device A published a KeyPackage');
+  ok(await B.ready({ interactive: true }), 'device B published a KeyPackage');
+  await sleep(2000);
+  const mine = await A.lookupAll(pk);
+  ok(mine.length === 2 && new Set(mine.map((c) => c.slot)).size === 2, 'the account shows two devices (two slots)', JSON.stringify(mine.map((c) => c.slot.slice(0, 8))));
+
+  // ---- 1. wn invites the account: which devices get in? ----
+  const alice = wn(['create-identity']).account_id;
+  const check = wn(['keys', 'check', pk]);
+  ok(check && !check.error, 'wn finds our relay lists + KeyPackages', JSON.stringify(check).slice(0, 200));
+  const made = wn(['groups', 'create', 'multidev', pk], { account: alice });
+  ok(!made.error, 'wn created a group with our npub', JSON.stringify(made.error || '').slice(0, 200));
+  const wnGroup = made.group_id || made.group?.group_id || made.group_id_hex;
+  const joinedCount = await waitFor(async () => { const n = [A, B].filter((c) => [...c.groups.values()].some((g) => !g.removed)).length; return n ? n : null; }, 'a device joins the wn group', 40_000);
+  await sleep(6000); // a second Welcome may follow
+  const inWn = [A, B].filter((c) => [...c.groups.values()].some((g) => !g.removed)).map((c) => (c === A ? 'A' : 'B'));
+  console.log('  wn invited devices:', inWn.join(',') || 'none', '(MDK adds', inWn.length, 'of our 2 KeyPackages)');
+  ok(inWn.length >= 1, 'at least one device joined the wn group');
+
+  // ---- 2. our group: device A founds it, invites wn, and adds device B on its own ----
+  const g = await A.create({ name: 'two devices', members: [alice] }) // account_id is the hex pubkey.catch((e) => { console.log('  create failed:', e.message); return null; });
+  ok(!!g, 'device A founded a group with the wn account');
+  if (g) {
+    await A.siblingAdds();
+    const gB = await waitFor(async () => [...B.groups.values()].find((x) => x.id === g.id && !x.removed) || null, 'device B joins through the sibling add');
+    ok(!!gB, 'device B joined device A\'s group from our own inbox');
+    if (gB) {
+      ok(gB.inviter === pk, 'the Welcome came from our own account', gB.inviter && gB.inviter.slice(0, 8));
+      B.accept(gB);
+      ok(A.accounts(g).length === 2 && A.accounts(g).includes(pk), 'two accounts, three leaves', `accounts=${A.accounts(g).length}`);
+    }
+    // wn joins and must still work with two leaves of one npub in the tree
+    const seen = await waitFor(async () => JSON.stringify(wn(['chats', 'list'], { account: alice })).includes(g.id) || JSON.stringify(wn(['groups', 'invites'], { account: alice })).includes(g.id) || null, 'wn sees our group');
+    ok(!!seen, 'wn received the Welcome to our group');
+    wn(['groups', 'accept', g.id], { account: alice });
+    await sleep(3000);
+    const show = wn(['groups', 'show', g.id], { account: alice });
+    console.log('  wn groups show:', JSON.stringify(show).slice(0, 400));
+    const posted = wn(['messages', 'send', g.id, 'hello both devices'], { account: alice });
+    ok(!posted.error, 'wn sent into the three-leaf group', JSON.stringify(posted.error || ''));
+    ok(!!await waitFor(async () => log.A.some((m) => m.content === 'hello both devices') || null, 'A reads wn'), 'device A reads wn');
+    ok(!!await waitFor(async () => log.B.some((m) => m.content === 'hello both devices') || null, 'B reads wn'), 'device B reads wn');
+    if (gB) {
+      ok(await B.send(gB, B.event(9, 'from device B', [])), 'device B sent');
+      ok(!!await waitFor(async () => JSON.stringify(wn(['messages', 'list', g.id, '--limit', '20'], { account: alice })).includes('from device B') || null, 'wn reads B'), 'wn reads device B');
+      ok(!!await waitFor(async () => log.A.some((m) => m.content === 'from device B') || null, 'A reads B'), 'device A reads device B');
+    }
+    ok(await A.send(g, A.event(9, 'from device A', [])), 'device A sent');
+    ok(!!await waitFor(async () => JSON.stringify(wn(['messages', 'list', g.id, '--limit', '20'], { account: alice })).includes('from device A') || null, 'wn reads A'), 'wn reads device A');
+  }
+  console.log(failed ? `\n${failed} FAILED` : '\nMULTI-DEVICE OK');
+} catch (e) { console.log('\nCRASH', e.stack || e.message); failed++; }
+finally { A.stop(); B.stop(); await sleep(500); process.exit(failed ? 1 : 0); }