@oxidezap/baileyrs 0.0.8 → 0.0.10

package/lib/Utils/wrap-legacy-store.js

@@ -48,13 +48,15 @@ const STORE_MAP = {
     meta: 'bridge-meta'
 };
 // Stores where bridge data is passthrough binary (no conversion).
-// `sender_key` and `session` are intentionally excluded — both diverge in
-// on-disk format between Rust libsignal (protobuf `SenderKeyRecordStructure`
-// / `RecordStructure`) and JS libsignal (`SenderKeyRecord` UTF-8 JSON /
-// `SessionRecord` plain JS object). They route through converters so the
-// same auth folder remains readable from either implementation, which is
-// the whole point of `wrap-legacy-store`.
-const BINARY_STORES = new Set(['identity']);
+// All Signal-protocol records (`identity`, `session`, `sender_key`) now
+// route through converters because every one of them either:
+//   • has a different key shape between bridge and upstream, OR
+//   • has a different value-byte encoding (proto / JSON / 32-vs-33-byte
+//     prefix), OR
+//   • both.
+// Keeping the empty set as an extension point — future bridge stores that
+// are byte-compatible with upstream can land here without a converter.
+const BINARY_STORES = new Set();
 // Bridge-only stores — raw binary persisted through keys interface.
 // `lid_mapping` is intentionally excluded — it has a converter so the
 // `pn:`/`lid:` prefixed bridge keys translate to upstream's bare-userpart
@@ -175,18 +177,24 @@ const converters = {
     },
     tc_token: {
         toBridge(_key, value) {
+            // Rust `TcTokenEntry { token: Vec<u8>, token_timestamp: i64,
+            // sender_timestamp: Option<i64> }`. serde_json maps Vec<u8> to a
+            // numeric array — base64 strings make the deserializer choke
+            // with "invalid type: string ... expected a sequence".
             const tc = value;
             return toJson({
-                token: tc.token ? Buffer.from(tc.token).toString('base64') : '',
-                token_timestamp: tc.timestamp ? parseInt(tc.timestamp) : 0
+                token: tc.token ? bufToNumArray(Buffer.from(tc.token)) : [],
+                token_timestamp: tc.timestamp ? parseInt(tc.timestamp) : 0,
+                sender_timestamp: tc.senderTimestamp ? parseInt(tc.senderTimestamp) : null
             });
         },
         fromBridge(_key, value) {
             try {
                 const j = fromJson(value);
                 return {
-                    token: j.token ? Buffer.from(j.token, 'base64') : Buffer.alloc(0),
-                    timestamp: j.token_timestamp?.toString()
+                    token: Array.isArray(j.token) ? Buffer.from(j.token) : Buffer.alloc(0),
+                    timestamp: j.token_timestamp?.toString(),
+                    senderTimestamp: j.sender_timestamp != null ? j.sender_timestamp.toString() : undefined
                 };
             }
             catch {
@@ -214,42 +222,36 @@ const converters = {
             }
         }
     },
-    // ── lid_mapping ──
-    // Cross-impl converter for LID ↔ PN device mapping table.
-    //   • Bridge: keyed by `lid:{lidUser}` (value=JSON LidPnMappingEntry
-    //     with phone_number/created_at/updated_at/learning_source) AND
-    //     `pn:{pnUser}` (value=raw bytes of the LID user, UTF-8).
-    //   • Upstream (`Signal/lid-mapping.js`): keyed by bare `{pnUser}`
-    //     (value=string LID user) AND `{lidUser}_reverse` (value=string
-    //     PN user). No timestamps.
-    // Translation goes both ways; metadata fields default to "now" /
-    // "wrap-legacy-store" when reading from upstream-only state since the
-    // JS side doesn't track them.
+    // identity: bridge holds 32-byte raw DJB pubkey, upstream holds 33 bytes
+    // (0x05 || 32-byte) — the curve25519-XEdDSA wire form.
+    identity: {
+        toBridge(_key, value) {
+            const buf = toBuf(value);
+            if (!buf)
+                return null;
+            return buf.length === 33 && buf[0] === 0x05 ? new Uint8Array(buf.slice(1)) : buf;
+        },
+        fromBridge(_key, value) {
+            const v = Buffer.isBuffer(value) ? value : Buffer.from(value);
+            return v.length === 32 ? Buffer.concat([Buffer.from([0x05]), v]) : Buffer.from(v);
+        }
+    },
+    // lid_mapping: bridge uses prefixed keys (`lid:{X}` JSON entry,
+    // `pn:{X}` raw LID bytes); upstream uses bare keys (`{pnUser}` string LID,
+    // `{lidUser}_reverse` string PN). No upstream timestamps; we synthesise.
     lid_mapping: {
         toBridge(key, value) {
-            // `value` here is whatever upstream stored: a string
-            // (`pnUser→lidUser` or `lidUser_reverse→pnUser`) — useMultiFile's
-            // BufferJSON.reviver leaves strings as strings.
             try {
-                if (key.startsWith('pn:')) {
-                    // Bridge wants the raw LID user as bytes.
-                    const lid = typeof value === 'string' ? value : Buffer.from(value).toString('utf-8');
-                    if (!lid)
-                        return null;
-                    return new TextEncoder().encode(lid);
-                }
+                const asString = typeof value === 'string' ? value : Buffer.from(value).toString('utf-8');
+                if (!asString)
+                    return null;
+                if (key.startsWith('pn:'))
+                    return new TextEncoder().encode(asString);
                 if (key.startsWith('lid:')) {
-                    // Bridge wants the JSON LidPnMappingEntry. Upstream stored
-                    // only the phone number string; reconstruct a synthetic
-                    // entry — bridge tolerates synthetic timestamps + source.
-                    const lidUser = key.slice(4);
-                    const phoneNumber = typeof value === 'string' ? value : Buffer.from(value).toString('utf-8');
-                    if (!phoneNumber)
-                        return null;
                     const now = Math.floor(Date.now() / 1000);
                     return toJson({
-                        lid: lidUser,
-                        phone_number: phoneNumber,
+                        lid: key.slice(4),
+                        phone_number: asString,
                         created_at: now,
                         updated_at: now,
                         learning_source: 'wrap-legacy-store'
@@ -264,18 +266,10 @@ const converters = {
             }
         },
         fromBridge(key, value) {
-            // `value` here is bridge's Uint8Array. We return a string for
-            // upstream to store — useMultiFile's BufferJSON.replacer keeps
-            // strings as strings, which is what `lid-mapping.js` expects to
-            // read back via `keys.get('lid-mapping', […])`.
             try {
-                if (key.startsWith('pn:')) {
-                    // Bridge wrote raw LID bytes. Upstream wants the string.
+                if (key.startsWith('pn:'))
                     return Buffer.from(value).toString('utf-8');
-                }
                 if (key.startsWith('lid:')) {
-                    // Bridge wrote JSON entry. Upstream wants the phone_number
-                    // string under `{lidUser}_reverse`.
                     const entry = fromJson(value);
                     return entry.phone_number ?? '';
                 }
@@ -288,26 +282,16 @@ const converters = {
             }
         }
     },
-    // ── session ──
-    // Cross-impl converter for pairwise Signal sessions.
-    //   • Rust libsignal (bridge): raw protobuf `RecordStructure` bytes
-    //     (current_session + previous_sessions, each `SessionStructure`).
-    //   • JS  libsignal (upstream): a plain JS object
-    //     `{ _sessions: { [base64BaseKey]: SessionEntry }, version: 'v1' }`
-    //     persisted by upstream's `useMultiFileAuthState` via
-    //     JSON.stringify-with-BufferJSON. The byte fields inside SessionEntry
-    //     are stored as base64 STRINGS (not BufferJSON Buffer wrappers).
-    // We translate at the boundary so the same auth folder works for both.
-    // Note: per-message-counter caches (`messageKeys`) are dropped during
-    // conversion — the two implementations derive them differently (Rust
-    // stores cipher/mac/iv post-split; JS stores the pre-split chain output)
-    // and they're a CACHE, not state — protocol re-derives or asks for retry.
+    // session: bridge=protobuf RecordStructure, upstream=JS object
+    // `{_sessions: {[b64BaseKey]: SessionEntry}, version: 'v1'}` with byte
+    // fields stored as base64 strings inside the entry. messageKeys cache
+    // is lossy in the Rust→JS direction (HKDF is one-way) — see
+    // `bridgeSessionProtoToUpstreamRecord`.
     session: {
         toBridge(_key, value) {
-            // Upstream stored: a plain JS object (NOT bytes). Convert → proto bytes.
             try {
                 if (value == null)
-                    return null; // eslint-disable-line eqeqeq -- intentional null+undefined check
+                    return null;
                 return upstreamSessionRecordToProto(value);
             }
             catch (e) {
@@ -316,7 +300,6 @@ const converters = {
             }
         },
         fromBridge(_key, value) {
-            // Bridge wrote: raw proto bytes. Convert → upstream JS object.
             try {
                 return bridgeSessionProtoToUpstreamRecord(value);
             }
@@ -326,19 +309,11 @@ const converters = {
             }
         }
     },
-    // ── sender_key ──
-    // Cross-impl converter for group sender keys. Both libraries produce
-    // the same logical record (`SenderKeyRecordStructure`) but persist it
-    // under DIFFERENT bytes:
-    //   • Rust libsignal (bridge): raw protobuf bytes
-    //   • JS  libsignal (upstream): UTF-8 JSON of the record array, with
-    //     each Buffer wrapped as `{ type:'Buffer', data:'<base64>' }`
-    //     (BufferJSON.replacer in upstream's `Utils/generics`).
-    // We translate at the boundary so the same on-disk file is readable
-    // by either implementation — the entire point of `wrap-legacy-store`.
+    // sender_key: bridge=protobuf SenderKeyRecordStructure, upstream=
+    // `Buffer.from(JSON.stringify(states, BufferJSON.replacer), 'utf-8')`
+    // — Buffer fields wrapped as `{type:'Buffer', data:'<base64>'}`.
     sender_key: {
         toBridge(_key, value) {
-            // Upstream stored: Buffer of UTF-8 JSON. Convert → proto bytes.
             try {
                 const buf = toBuf(value);
                 if (!buf)
@@ -351,84 +326,69 @@ const converters = {
             }
         },
         fromBridge(_key, value) {
-            // Bridge wrote: raw proto bytes. Convert → upstream JSON Buffer.
             try {
                 return bridgeSenderKeyProtoToJson(value);
             }
             catch (e) {
                 warn('sender_key.fromBridge encode failed:', e);
-                // Fall back to passthrough so we don't drop data on the floor.
                 return Buffer.from(value);
             }
         }
     }
 };
-const bufferReplacerForSenderKey = (_k, v) => {
+// BufferJSON-compatible replacer/reviver matching upstream `Utils/generics`.
+const bufferJsonReplacer = (_k, v) => {
     if (Buffer.isBuffer(v) || v instanceof Uint8Array || v?.type === 'Buffer') {
         const data = v?.data ?? v;
         return { type: 'Buffer', data: Buffer.from(data).toString('base64') };
     }
     return v;
 };
-const bufferReviverForSenderKey = (_k, v) => {
-    if (typeof v === 'object' && v !== null) {
-        const obj = v;
-        if (obj.type === 'Buffer' && typeof obj.data === 'string') {
-            return Buffer.from(obj.data, 'base64');
-        }
+const bufferJsonReviver = (_k, v) => {
+    const obj = v;
+    if (obj && typeof obj === 'object' && obj.type === 'Buffer' && typeof obj.data === 'string') {
+        return Buffer.from(obj.data, 'base64');
     }
     return v;
 };
+const sk_toBytes = (v) => v ? new Uint8Array(Buffer.from(v)) : new Uint8Array();
+const sk_toBuffer = (v) => Buffer.from(v ?? new Uint8Array());
 function bridgeSenderKeyProtoToJson(protoBytes) {
     const struct = proto.SenderKeyRecordStructure.decode(Buffer.from(protoBytes));
     const states = (struct.senderKeyStates ?? []).map(s => ({
         senderKeyId: s.senderKeyId ?? 0,
-        senderChainKey: {
-            iteration: s.senderChainKey?.iteration ?? 0,
-            seed: Buffer.from(s.senderChainKey?.seed ?? new Uint8Array())
-        },
+        senderChainKey: { iteration: s.senderChainKey?.iteration ?? 0, seed: sk_toBuffer(s.senderChainKey?.seed) },
         senderSigningKey: {
-            public: Buffer.from(s.senderSigningKey?.public ?? new Uint8Array()),
-            private: Buffer.from(s.senderSigningKey?.private ?? new Uint8Array())
+            public: sk_toBuffer(s.senderSigningKey?.public),
+            private: sk_toBuffer(s.senderSigningKey?.private)
         },
         senderMessageKeys: (s.senderMessageKeys ?? []).map(mk => ({
             iteration: mk.iteration ?? 0,
-            seed: Buffer.from(mk.seed ?? new Uint8Array())
+            seed: sk_toBuffer(mk.seed)
         }))
     }));
-    return Buffer.from(JSON.stringify(states, bufferReplacerForSenderKey), 'utf-8');
+    return Buffer.from(JSON.stringify(states, bufferJsonReplacer), 'utf-8');
 }
 function upstreamSenderKeyJsonToProto(jsonBuf) {
-    const text = Buffer.from(jsonBuf).toString('utf-8');
-    const states = JSON.parse(text, bufferReviverForSenderKey);
+    const states = JSON.parse(Buffer.from(jsonBuf).toString('utf-8'), bufferJsonReviver);
     const senderKeyStates = states.map(s => ({
         senderKeyId: s.senderKeyId ?? 0,
-        senderChainKey: {
-            iteration: s.senderChainKey?.iteration ?? 0,
-            seed: s.senderChainKey?.seed ? new Uint8Array(Buffer.from(s.senderChainKey.seed)) : new Uint8Array()
-        },
+        senderChainKey: { iteration: s.senderChainKey?.iteration ?? 0, seed: sk_toBytes(s.senderChainKey?.seed) },
         senderSigningKey: {
-            public: s.senderSigningKey?.public ? new Uint8Array(Buffer.from(s.senderSigningKey.public)) : new Uint8Array(),
-            private: s.senderSigningKey?.private ? new Uint8Array(Buffer.from(s.senderSigningKey.private)) : new Uint8Array()
+            public: sk_toBytes(s.senderSigningKey?.public),
+            private: sk_toBytes(s.senderSigningKey?.private)
         },
         senderMessageKeys: (s.senderMessageKeys ?? []).map(mk => ({
             iteration: mk.iteration ?? 0,
-            seed: mk.seed ? new Uint8Array(Buffer.from(mk.seed)) : new Uint8Array()
+            seed: sk_toBytes(mk.seed)
         }))
     }));
-    const struct = proto.SenderKeyRecordStructure.create({ senderKeyStates });
-    return proto.SenderKeyRecordStructure.encode(struct).finish();
+    return proto.SenderKeyRecordStructure.encode(proto.SenderKeyRecordStructure.create({ senderKeyStates })).finish();
 }
-// ── sender_key key translator ──
-// Bridge `cache_key`: `{groupJid}:{user}[:jidDev]@{server}.{signalDev}`
-//   e.g. "120363@g.us:100000037037034@lid.0"
-//   e.g. "120363@g.us:559980000003:5@s.whatsapp.net.0"
-// Upstream `SenderKeyName.serialize()`: `{groupJid}::{signalUser}::{deviceId}`
-//   where signalUser = `${user}` for s.whatsapp.net (domainType 0)
-//                    = `${user}_${domainType}` for LID (1) / hosted (2) / hosted.lid (3)
+// sender_key key translation: bridge `{group}:{user}[:dev]@{server}.{sig}`
+// → upstream `{group}::{signalUser}::{deviceId}`. Group JIDs never contain
+// `:`, so the first `:` separates group from sender address.
 function bridgeSenderKeyToUpstream(bridgeKey) {
-    // Group JIDs are `{digits}@g.us` — they never contain `:` — so the
-    // FIRST `:` in cache_key cleanly separates group from sender address.
     const sep = bridgeKey.indexOf(':');
     if (sep < 0)
         return null;
@@ -437,28 +397,19 @@ function bridgeSenderKeyToUpstream(bridgeKey) {
     const dotIdx = addrStr.lastIndexOf('.');
     if (dotIdx < 0)
         return null;
-    const jidPart = addrStr.slice(0, dotIdx); // strip the always-zero signalDev suffix
+    const jidPart = addrStr.slice(0, dotIdx);
     const atIdx = jidPart.indexOf('@');
     if (atIdx < 0)
         return null;
     const userPart = jidPart.slice(0, atIdx);
     const server = jidPart.slice(atIdx + 1);
-    let user;
-    let jidDev;
-    if (userPart.includes(':')) {
-        const [u, d] = userPart.split(':');
-        user = u;
-        jidDev = parseInt(d, 10) || 0;
-    }
-    else {
-        user = userPart;
-        jidDev = 0;
-    }
+    const [user, jidDev] = userPart.includes(':')
+        ? [userPart.slice(0, userPart.indexOf(':')), parseInt(userPart.slice(userPart.indexOf(':') + 1), 10) || 0]
+        : [userPart, 0];
     const domainType = DOMAIN_TYPE_MAP[server];
     if (domainType === undefined)
         return null;
-    const signalUser = domainType !== 0 ? `${user}_${domainType}` : user;
-    return `${groupJid}::${signalUser}::${jidDev}`;
+    return `${groupJid}::${domainType !== 0 ? `${user}_${domainType}` : user}::${jidDev}`;
 }
 const CHAIN_TYPE_SENDING = 1;
 const CHAIN_TYPE_RECEIVING = 2;
@@ -467,46 +418,28 @@ const BASE_KEY_TYPE_THEIRS = 2;
 const b64 = (b) => b ? Buffer.from(b).toString('base64') : Buffer.alloc(0).toString('base64');
 const fromB64 = (s) => (s ? Buffer.from(s, 'base64') : Buffer.alloc(0));
 /**
- * Derive Rust libsignal's per-message split (cipher_key + mac_key + iv) from
- * the JS libsignal `messageKey` seed. The two impls store the cache at
- * different points in the derivation:
- *
- *   • JS: stores the 32-byte HMAC(chainKey, [1]) seed; splits on decrypt
- *     via `deriveSecrets(seed, ZEROS_32, "WhisperMessageKeys")`.
- *   • Rust: stores the post-split `MessageKeys { cipher_key:[u8;32],
- *     mac_key:[u8;32], iv:[u8;16] }` directly.
- *
- * Both call HKDF-SHA256 with salt=[0u8;32] and info="WhisperMessageKeys"
- * (Rust passes `None` salt which HKDF defines as a zero-byte string of
- * HashLen=32), so the derivation is byte-identical. We can recover Rust's
- * format from JS's seed losslessly. The reverse (Rust → JS) is impossible
- * because HKDF is one-way — those keys are dropped on Rust→JS conversion.
+ * Derive Rust's per-message split (cipher 32 / mac 32 / iv 16) from JS's
+ * 32-byte `messageKey` seed. Both impls compute HKDF-SHA256 with
+ * salt=[0u8;32] and info="WhisperMessageKeys" — Rust's `None` salt
+ * defaults to a zero-byte HashLen string, so the output is byte-identical.
+ * Reverse direction (Rust→JS) is impossible: HKDF is one-way.
  */
 function deriveProtoMessageKey(seed, counter) {
-    // HKDF-Extract: PRK = HMAC-SHA256(salt=ZEROS_32, ikm=seed)
-    const salt = Buffer.alloc(32);
-    const prk = createHmac('sha256', salt).update(seed).digest();
+    const prk = createHmac('sha256', Buffer.alloc(32)).update(seed).digest();
     const info = Buffer.from('WhisperMessageKeys');
-    // HKDF-Expand: T(1)=HMAC(PRK, info||0x01); T(N)=HMAC(PRK, T(N-1)||info||N).
-    // We need 80 bytes total (cipher 32 + mac 32 + iv 16) → 3 chunks.
-    const t1 = createHmac('sha256', prk)
-        .update(Buffer.concat([info, Buffer.from([0x01])]))
-        .digest();
-    const t2 = createHmac('sha256', prk)
-        .update(Buffer.concat([t1, info, Buffer.from([0x02])]))
-        .digest();
-    const t3 = createHmac('sha256', prk)
-        .update(Buffer.concat([t2, info, Buffer.from([0x03])]))
+    const expand = (prev, n) => createHmac('sha256', prk)
+        .update(Buffer.concat([prev, info, Buffer.from([n])]))
         .digest();
+    const t1 = expand(Buffer.alloc(0), 0x01);
+    const t2 = expand(t1, 0x02);
+    const t3 = expand(t2, 0x03);
     return {
         index: counter,
-        cipherKey: new Uint8Array(t1), // 32
-        macKey: new Uint8Array(t2), // 32
-        iv: new Uint8Array(t3.subarray(0, 16)) // first 16 of T(3)
+        cipherKey: new Uint8Array(t1),
+        macKey: new Uint8Array(t2),
+        iv: new Uint8Array(t3.subarray(0, 16))
     };
 }
-/** Convert all entries in a JS chain's messageKeys cache into Rust's
- * post-split `MessageKey` proto form. Empty/missing → empty array. */
 function jsChainMessageKeysToProto(messageKeys) {
     if (!messageKeys)
         return [];
@@ -516,72 +449,49 @@ function jsChainMessageKeysToProto(messageKeys) {
         if (!Number.isFinite(counter))
             continue;
         const seed = fromB64(seedB64);
-        if (seed.length === 0)
-            continue;
-        out.push(deriveProtoMessageKey(seed, counter));
+        if (seed.length > 0)
+            out.push(deriveProtoMessageKey(seed, counter));
     }
     return out;
 }
 function sessionStructureToEntry(session, closedTs) {
     if (!session.senderChain || !session.rootKey)
         return null;
-    // `aliceBaseKey` is populated by Rust libsignal in BOTH directions of
-    // a session: when we're Alice it stores our own ephemeral pubkey, when
-    // we're Bob it stores Alice's ephemeral pubkey from the incoming
-    // PreKeySignalMessage. So presence alone doesn't tell us which side
-    // we are — we use `pendingPreKey` instead (set on Alice until the first
-    // reply from Bob clears it; never set on Bob).
+    // aliceBaseKey is set by Rust on BOTH sides (alice=our ephemeral, bob=
+    // peer's ephemeral). pendingPreKey is the side discriminator (alice
+    // only, cleared on first reply).
     const baseKeyBytes = session.aliceBaseKey ?? session.senderChain.senderRatchetKey;
     if (!baseKeyBytes)
         return null;
     const weAreAlice = !!session.pendingPreKey?.baseKey;
     const baseKeyType = weAreAlice ? BASE_KEY_TYPE_OURS : BASE_KEY_TYPE_THEIRS;
-    // lastRemoteEphemeralKey: the most recent peer ratchet step. Order of
-    // preference:
-    //   1. tail of `receiverChains` — established session, peer has replied
-    //   2. `aliceBaseKey` when we're Bob — peer's original ephemeral was
-    //      our `lastRemoteEphemeralKey` at session creation (matches JS
-    //      `session_builder.initSession` line 128)
-    //   3. empty buffer — degenerate fallback. CANNOT use senderRatchetKey
-    //      as a placeholder: it collides with the SENDER chain in `_chains`,
-    //      and upstream's `maybeStepRatchet` would call
-    //      `delete previousRatchet.chainKey.key` on the sender chain when
-    //      the peer ratchets, corrupting outbound encryption.
+    // lastRemoteEphemeralKey precedence: tail receiverChain → aliceBaseKey
+    // (when bob, matches JS init) → empty. NEVER senderRatchetKey: that
+    // collides with the SENDER chain in `_chains`, and upstream's
+    // `maybeStepRatchet` would `delete previousRatchet.chainKey.key` on
+    // the sender chain when the peer ratchets, corrupting outbound encryption.
     const receiverChains = session.receiverChains ?? [];
     const lastReceiver = receiverChains[receiverChains.length - 1];
-    let lastRemoteEph;
-    if (lastReceiver?.senderRatchetKey && lastReceiver.senderRatchetKey.length > 0) {
-        lastRemoteEph = lastReceiver.senderRatchetKey;
-    }
-    else if (!weAreAlice && session.aliceBaseKey && session.aliceBaseKey.length > 0) {
-        lastRemoteEph = session.aliceBaseKey;
-    }
-    else {
-        lastRemoteEph = new Uint8Array();
-    }
+    const lastRemoteEph = lastReceiver?.senderRatchetKey && lastReceiver.senderRatchetKey.length > 0
+        ? lastReceiver.senderRatchetKey
+        : !weAreAlice && session.aliceBaseKey && session.aliceBaseKey.length > 0
+            ? session.aliceBaseKey
+            : new Uint8Array();
     const senderRatchetPub = session.senderChain.senderRatchetKey ?? new Uint8Array();
     const senderRatchetPriv = session.senderChain.senderRatchetKeyPrivate ?? new Uint8Array();
     const _chains = {};
-    // Sender chain: keyed by our own ratchet pubkey base64.
     if (session.senderChain.chainKey?.key && senderRatchetPub.length > 0) {
         _chains[b64(senderRatchetPub)] = {
-            chainKey: {
-                counter: session.senderChain.chainKey.index ?? 0,
-                key: b64(session.senderChain.chainKey.key)
-            },
+            chainKey: { counter: session.senderChain.chainKey.index ?? 0, key: b64(session.senderChain.chainKey.key) },
             chainType: CHAIN_TYPE_SENDING,
             messageKeys: {}
         };
     }
-    // Receiver chains: keyed by peer ratchet pubkey base64.
     for (const rc of receiverChains) {
         if (!rc.chainKey?.key || !rc.senderRatchetKey || rc.senderRatchetKey.length === 0)
             continue;
         _chains[b64(rc.senderRatchetKey)] = {
-            chainKey: {
-                counter: rc.chainKey.index ?? 0,
-                key: b64(rc.chainKey.key)
-            },
+            chainKey: { counter: rc.chainKey.index ?? 0, key: b64(rc.chainKey.key) },
             chainType: CHAIN_TYPE_RECEIVING,
             messageKeys: {}
         };
@@ -620,16 +530,12 @@ function bridgeSessionProtoToUpstreamRecord(protoBytes) {
     const current = record.currentSession ? sessionStructureToEntry(record.currentSession, -1) : null;
     if (current)
         _sessions[current.indexInfo.baseKey] = current;
-    // Closed sessions: assign descending timestamps so removeOldSessions
-    // has something to sort by. Use `1` as the floor (anything > 0 is
-    // "closed"; -1 is "open").
+    // Synthesize descending close timestamps so removeOldSessions can sort:
+    // front of Rust `previous_sessions` is the most recently archived.
     const previous = record.previousSessions ?? [];
     for (let i = 0; i < previous.length; i++) {
         const entry = sessionStructureToEntry(previous[i], Math.max(1, Date.now() - i));
-        if (!entry)
-            continue;
-        // Don't overwrite an existing baseKey (current takes precedence).
-        if (!_sessions[entry.indexInfo.baseKey])
+        if (entry && !_sessions[entry.indexInfo.baseKey])
             _sessions[entry.indexInfo.baseKey] = entry;
     }
     return { _sessions, version: 'v1' };
@@ -646,25 +552,23 @@ function entryToSessionStructure(entry) {
         chainKey: senderChainEntry
             ? { index: senderChainEntry.chainKey.counter, key: new Uint8Array(fromB64(senderChainEntry.chainKey.key)) }
             : { index: 0, key: new Uint8Array() },
-        // Sender chain has no skipped-key cache in either impl — sending
-        // is sequential — so this stays empty regardless.
-        messageKeys: []
+        messageKeys: [] // sender chain is sequential — no skipped cache either side
     };
     const receiverChains = [];
     for (const [k, ch] of Object.entries(entry._chains)) {
         if (ch.chainType !== CHAIN_TYPE_RECEIVING)
             continue;
-        const ratchetPub = fromB64(k);
         receiverChains.push({
-            senderRatchetKey: new Uint8Array(ratchetPub),
+            senderRatchetKey: new Uint8Array(fromB64(k)),
             chainKey: { index: ch.chainKey.counter, key: new Uint8Array(fromB64(ch.chainKey.key)) },
-            // Recover skipped-key cache: JS holds 32-byte HMAC seeds, Rust
-            // holds the post-HKDF cipher/mac/iv split. HKDF is deterministic,
-            // so JS→Rust is a lossless one-shot derivation. See
-            // `deriveProtoMessageKey` for the algo + cross-impl proof.
+            // JS holds 32-byte HMAC seeds; Rust holds the post-HKDF split.
+            // Lossless JS→Rust derivation via deriveProtoMessageKey.
             messageKeys: jsChainMessageKeysToProto(ch.messageKeys)
         });
     }
+    // `indexInfo.baseKey` IS the alice_base_key in either direction
+    // (alice=our ephemeral, bob=peer's ephemeral). Rust populates it
+    // symmetrically; dropping it would break find_matching_previous_session_index.
     const session = {
         rootKey: new Uint8Array(fromB64(ratchet.rootKey)),
         previousCounter: ratchet.previousCounter,
@@ -672,14 +576,6 @@ function entryToSessionStructure(entry) {
         receiverChains,
         remoteIdentityPublic: new Uint8Array(fromB64(entry.indexInfo.remoteIdentityKey)),
         remoteRegistrationId: entry.registrationId ?? 0,
-        // `indexInfo.baseKey` IS the alice base key from the X3DH handshake
-        // regardless of which side we are: when we're Alice it's our own
-        // ephemeral pubkey, when we're Bob it's the peer's ephemeral pubkey
-        // from the incoming PreKeySignalMessage (`session_builder.js:135`).
-        // Rust libsignal populates `aliceBaseKey` symmetrically, so we
-        // always restore it — losing it would break Rust's
-        // `find_matching_previous_session_index` lookup on subsequent
-        // PreKeySignal arrivals.
         aliceBaseKey: new Uint8Array(fromB64(entry.indexInfo.baseKey))
     };
     if (entry.pendingPreKey?.baseKey) {
@@ -692,42 +588,24 @@ function entryToSessionStructure(entry) {
     return session;
 }
 function upstreamSessionRecordToProto(record) {
-    const r = record;
-    const sessions = r?._sessions ?? {};
+    const sessions = record?._sessions ?? {};
     let currentSession = null;
     const previousSessions = [];
-    // Pick the first OPEN session as `current_session`; everything else
-    // goes to `previous_sessions`. Both libraries should agree there is
-    // at most one open session per peer.
     for (const entry of Object.values(sessions)) {
         const ss = entryToSessionStructure(entry);
-        if (!currentSession && entry.indexInfo.closed === -1) {
+        if (!currentSession && entry.indexInfo.closed === -1)
             currentSession = ss;
-        }
-        else {
+        else
             previousSessions.push(ss);
-        }
     }
-    // `BridgeSessionProto` is a structural mirror of `ISessionStructure`
-    // from `whatsapp-rust-bridge/proto-types`; the differences are nullable
-    // vs optional fields. We cast at the boundary to avoid pulling the full
-    // proto class types into our internal shape.
     const recordOut = proto.RecordStructure.create({
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        currentSession: (currentSession ?? undefined),
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        previousSessions: previousSessions
+        currentSession: currentSession ?? undefined,
+        previousSessions
     });
     return proto.RecordStructure.encode(recordOut).finish();
 }
-// ── session key translator ──
-// Bridge protocol address: `{user}[:jidDev]@{server}.{signalDev}`
-// Upstream session key:    `{signalUser}.{deviceId}` (where deviceId is
-//   the JID device for `:jidDev` cases, else the signal device suffix).
-// `bridgeAddrToBaileysAddr` already does this exact transformation —
-// it's just been unused for the session path because sessions were
-// passthrough binary. Now that sessions go through a converter, we
-// route through `translateKey` → `bridgeAddrToBaileysAddr`.
+// session/identity key translation: bridge `{user}[:dev]@{server}.{sig}`
+// → upstream `{signalUser}.{deviceId}` via `bridgeAddrToBaileysAddr`.
 // ---- Device/Creds ----
 /** Parse a JID string into { user, device, server } */
 function parseJid(jid) {
@@ -1027,21 +905,19 @@ export async function wrapLegacyStore(state, saveCreds, logger) {
         if (storeName === 'sender_key') {
             const translated = bridgeSenderKeyToUpstream(key);
             if (translated == null) {
-                // eslint-disable-line eqeqeq -- intentional null+undefined check
                 warn(`sender_key key translation failed for "${key}", falling back to passthrough`);
                 return key;
             }
             return translated;
         }
-        // Bridge session key is the protocol address (`user[:dev]@server.sig`);
-        // upstream's libsignal looks under `signalUser.deviceId`. Reuses
-        // `bridgeAddrToBaileysAddr` which already does the LID/PN→signalUser
-        // rewrite + JID-device extraction.
-        if (storeName === 'session') {
+        // Bridge session/identity keys are the protocol address
+        // (`user[:dev]@server.sig`); upstream's libsignal looks under
+        // `signalUser.deviceId`. `bridgeAddrToBaileysAddr` does the LID/PN
+        // → signalUser rewrite + JID-device extraction.
+        if (storeName === 'session' || storeName === 'identity') {
             const translated = bridgeAddrToBaileysAddr(key);
             if (translated == null) {
-                // eslint-disable-line eqeqeq -- intentional null+undefined check
-                warn(`session key translation failed for "${key}", falling back to passthrough`);
+                warn(`${storeName} key translation failed for "${key}", falling back to passthrough`);
                 return key;
             }
             return translated;
@@ -1063,7 +939,7 @@ export async function wrapLegacyStore(state, saveCreds, logger) {
     async function readBinary(type, id) {
         try {
             const val = await storeGetOne(type, id);
-            return val != null ? toBuf(val) : null; // eslint-disable-line eqeqeq -- intentional null+undefined check
+            return val != null ? toBuf(val) : null;
         }
         catch (e) {
             warn(`GET ${type}/${id} failed:`, e);
@@ -1114,13 +990,12 @@ export async function wrapLegacyStore(state, saveCreds, logger) {
                 return readBinary(type, key);
             }
             if (route === 'signal') {
-                const val = await readBinary(type, key);
-                if (val)
-                    return val;
-                // Identity fallback: upstream Baileys uses a different address format
-                if (bridgeStore === 'identity')
-                    return identityFallback(key, type);
-                return null;
+                // `BINARY_STORES` is empty as of the move-to-converter
+                // migration — keeping the branch for future passthrough
+                // stores. No identity fallback needed: identity now goes
+                // through the converter, which handles both the address
+                // rewrite and the 32↔33-byte prefix.
+                return readBinary(type, key);
             }
             if (route === 'bridge-only')
                 return readBinary(type, key);
@@ -1129,7 +1004,7 @@ export async function wrapLegacyStore(state, saveCreds, logger) {
                     const upstreamKey = translateKey(bridgeStore, key);
                     const value = await storeGetOne(type, upstreamKey);
                     if (value == null)
-                        return null; // eslint-disable-line eqeqeq -- intentional null+undefined check
+                        return null;
                     return converters[bridgeStore]?.toBridge(key, value) ?? toBuf(value);
                 }
                 catch (e) {
@@ -1202,28 +1077,6 @@ export async function wrapLegacyStore(state, saveCreds, logger) {
             }
         }
     };
-    // Identity key fallback: upstream Baileys uses different address format
-    // (user_domainType.device) and stores 33 bytes (0x05 + 32-byte DJB key)
-    async function identityFallback(key, type) {
-        try {
-            const baileysAddr = bridgeAddrToBaileysAddr(key);
-            if (!baileysAddr)
-                return null;
-            const raw = await storeGetOne('identity-key', baileysAddr);
-            if (!raw || (!Buffer.isBuffer(raw) && !(raw instanceof Uint8Array)))
-                return null;
-            let buf = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
-            if (buf.length === 33 && buf[0] === 0x05)
-                buf = buf.slice(1);
-            const arr = new Uint8Array(buf);
-            await writeBinary(type, key, arr); // persist under bridge key for future reads
-            return arr;
-        }
-        catch (e) {
-            warn(`identity fallback failed for ${key}:`, e);
-            return null;
-        }
-    }
 }
 const bufferReviver = (_, value) => {
     if (value !== null &&