1 files changed, 73 insertions, 0 deletions

diff --git a/packages/meshbay-node/src/meshbay_node/bundle_store.py b/packages/meshbay-node/src/meshbay_node/bundle_store.py
index 7f03caa..86b8de4 100644
--- a/packages/meshbay-node/src/meshbay_node/bundle_store.py
+++ b/packages/meshbay-node/src/meshbay_node/bundle_store.py
@@ -30,6 +30,30 @@ CREATE TABLE IF NOT EXISTS gek_bundles (
 );
 """
 
+# Chat epoch keys. Wrapped to the node's own X25519 key, exactly as the node's
+# copy of the group key is — never stored raw.
+#
+# That is the whole basis of the claim chat encryption makes: "unreadable to
+# someone who obtains the node's storage without the keystore password". A
+# plaintext table beside chat.db would collapse it to nothing, silently, and it
+# is the obvious thing to write. `test_chat_key_storage.py` reads the file back
+# and refuses to find the live key in it.
+#
+# Rows are kept, never replaced: opening a new epoch must not make the history
+# of the old one unreadable to the members who could already read it, which is
+# the difference between an epoch and a rotation.
+_SCHEMA_CHAT_EPOCHS = """\
+CREATE TABLE IF NOT EXISTS chat_epochs (
+    group_id    TEXT NOT NULL,
+    epoch       INTEGER NOT NULL,
+    pk_eph_b64  TEXT NOT NULL,
+    nonce_b64   TEXT NOT NULL,
+    wrapped_b64 TEXT NOT NULL,
+    created_at  TEXT NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (group_id, epoch)
+);
+"""
+
 _SCHEMA_KEYPAIR = """\
 CREATE TABLE IF NOT EXISTS keypair_bundles (
     user_id             TEXT PRIMARY KEY,
@@ -50,6 +74,7 @@ class BundleStore:
         self._db = await aiosqlite.connect(str(self._db_path))
         await self._db.execute(_SCHEMA_GEK)
         await self._db.execute(_SCHEMA_KEYPAIR)
+        await self._db.execute(_SCHEMA_CHAT_EPOCHS)
         await self._migrate_keypair_recovery()
         await self._db.commit()
 
@@ -155,6 +180,54 @@ class BundleStore:
         await self._db.commit()
         return cur.rowcount > 0
 
+    # ── Chat epoch keys ──────────────────────────────────────────────────
+
+    async def store_chat_epoch(
+        self,
+        group_id: str,
+        epoch: int,
+        pk_eph_b64: str,
+        nonce_b64: str,
+        wrapped_b64: str,
+    ) -> None:
+        """
+        Record one epoch key, wrapped to the node's own key.
+
+        `INSERT OR IGNORE`, not `REPLACE`: an epoch's key is written once and is
+        then the only way to read the messages sent under it. Overwriting one —
+        which a retry, or two callers racing to open the same epoch, would do —
+        would destroy that history with no error anywhere.
+        """
+        assert self._db
+        await self._db.execute(
+            "INSERT OR IGNORE INTO chat_epochs "
+            "(group_id, epoch, pk_eph_b64, nonce_b64, wrapped_b64) "
+            "VALUES (?, ?, ?, ?, ?)",
+            (group_id, epoch, pk_eph_b64, nonce_b64, wrapped_b64),
+        )
+        await self._db.commit()
+
+    async def fetch_chat_epochs(self, group_id: str) -> list[dict]:
+        """Every epoch this group has had, oldest first."""
+        assert self._db
+        async with self._db.execute(
+            "SELECT epoch, pk_eph_b64, nonce_b64, wrapped_b64 FROM chat_epochs "
+            "WHERE group_id = ? ORDER BY epoch", (group_id,)
+        ) as cur:
+            rows = await cur.fetchall()
+        return [{"epoch": r[0], "pk_eph_b64": r[1], "nonce_b64": r[2],
+                 "wrapped_b64": r[3]} for r in rows]
+
+    async def latest_chat_epoch(self, group_id: str) -> int:
+        """The highest epoch number, or 0 when the group has none yet."""
+        assert self._db
+        async with self._db.execute(
+            "SELECT MAX(epoch) FROM chat_epochs WHERE group_id = ?",
+            (group_id,)
+        ) as cur:
+            row = await cur.fetchone()
+        return int(row[0] or 0)
+
     async def close(self) -> None:
         if self._db:
             await self._db.close()