@oxidezap/baileyrs 0.0.7 → 0.0.9

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

@@ -11,9 +11,10 @@
  * ```
  */
 import { Buffer } from 'node:buffer';
+import { createHmac } from 'node:crypto';
 import { mkdir, readFile, stat, unlink, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { proto } from '../../WAProto/index.js';
+import { proto } from 'whatsapp-rust-bridge/proto-types';
 const protoLookup = proto;
 const ADVSignedDeviceIdentity = protoLookup.ADVSignedDeviceIdentity ?? protoLookup.AdvSignedDeviceIdentity;
 function warn(msg, err) {
@@ -46,11 +47,22 @@ const STORE_MAP = {
     mutation_mac: 'bridge-mutation-mac',
     meta: 'bridge-meta'
 };
-// Stores where bridge data is passthrough binary (no conversion)
-const BINARY_STORES = new Set(['identity', 'session', 'sender_key']);
-// Bridge-only stores — raw binary persisted through keys interface
+// Stores where bridge data is passthrough binary (no conversion).
+// 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
+// `{pnUser}` + `{lidUser}_reverse` shape, letting both libraries share
+// the same on-disk LID↔PN mapping table.
 const BRIDGE_ONLY_STORES = new Set([
-    'lid_mapping',
     'signed_prekey',
     'sender_key_devices',
     'base_key',
@@ -203,8 +215,397 @@ const converters = {
                 return [];
             }
         }
+    },
+    // 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) {
+            try {
+                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:')) {
+                    const now = Math.floor(Date.now() / 1000);
+                    return toJson({
+                        lid: key.slice(4),
+                        phone_number: asString,
+                        created_at: now,
+                        updated_at: now,
+                        learning_source: 'wrap-legacy-store'
+                    });
+                }
+                warn(`lid_mapping.toBridge: unknown key prefix in "${key}"`);
+                return null;
+            }
+            catch (e) {
+                warn('lid_mapping.toBridge failed:', e);
+                return null;
+            }
+        },
+        fromBridge(key, value) {
+            try {
+                if (key.startsWith('pn:'))
+                    return Buffer.from(value).toString('utf-8');
+                if (key.startsWith('lid:')) {
+                    const entry = fromJson(value);
+                    return entry.phone_number ?? '';
+                }
+                warn(`lid_mapping.fromBridge: unknown key prefix in "${key}"`);
+                return Buffer.from(value);
+            }
+            catch (e) {
+                warn('lid_mapping.fromBridge failed:', e);
+                return Buffer.from(value);
+            }
+        }
+    },
+    // 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) {
+            try {
+                if (value == null)
+                    return null; // eslint-disable-line eqeqeq
+                return upstreamSessionRecordToProto(value);
+            }
+            catch (e) {
+                warn('session.toBridge encode failed:', e);
+                return null;
+            }
+        },
+        fromBridge(_key, value) {
+            try {
+                return bridgeSessionProtoToUpstreamRecord(value);
+            }
+            catch (e) {
+                warn('session.fromBridge decode failed:', e);
+                return Buffer.from(value);
+            }
+        }
+    },
+    // 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) {
+            try {
+                const buf = toBuf(value);
+                if (!buf)
+                    return null;
+                return upstreamSenderKeyJsonToProto(buf);
+            }
+            catch (e) {
+                warn('sender_key.toBridge decode failed:', e);
+                return null;
+            }
+        },
+        fromBridge(_key, value) {
+            try {
+                return bridgeSenderKeyProtoToJson(value);
+            }
+            catch (e) {
+                warn('sender_key.fromBridge encode failed:', e);
+                return Buffer.from(value);
+            }
+        }
+    }
+};
+// 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 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: sk_toBuffer(s.senderChainKey?.seed) },
+        senderSigningKey: {
+            public: sk_toBuffer(s.senderSigningKey?.public),
+            private: sk_toBuffer(s.senderSigningKey?.private)
+        },
+        senderMessageKeys: (s.senderMessageKeys ?? []).map(mk => ({
+            iteration: mk.iteration ?? 0,
+            seed: sk_toBuffer(mk.seed)
+        }))
+    }));
+    return Buffer.from(JSON.stringify(states, bufferJsonReplacer), 'utf-8');
+}
+function upstreamSenderKeyJsonToProto(jsonBuf) {
+    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: sk_toBytes(s.senderChainKey?.seed) },
+        senderSigningKey: {
+            public: sk_toBytes(s.senderSigningKey?.public),
+            private: sk_toBytes(s.senderSigningKey?.private)
+        },
+        senderMessageKeys: (s.senderMessageKeys ?? []).map(mk => ({
+            iteration: mk.iteration ?? 0,
+            seed: sk_toBytes(mk.seed)
+        }))
+    }));
+    return proto.SenderKeyRecordStructure.encode(proto.SenderKeyRecordStructure.create({ senderKeyStates })).finish();
+}
+// 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) {
+    const sep = bridgeKey.indexOf(':');
+    if (sep < 0)
+        return null;
+    const groupJid = bridgeKey.slice(0, sep);
+    const addrStr = bridgeKey.slice(sep + 1);
+    const dotIdx = addrStr.lastIndexOf('.');
+    if (dotIdx < 0)
+        return null;
+    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);
+    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;
+    return `${groupJid}::${domainType !== 0 ? `${user}_${domainType}` : user}::${jidDev}`;
+}
+const CHAIN_TYPE_SENDING = 1;
+const CHAIN_TYPE_RECEIVING = 2;
+const BASE_KEY_TYPE_OURS = 1;
+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'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) {
+    const prk = createHmac('sha256', Buffer.alloc(32)).update(seed).digest();
+    const info = Buffer.from('WhisperMessageKeys');
+    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),
+        macKey: new Uint8Array(t2),
+        iv: new Uint8Array(t3.subarray(0, 16))
+    };
+}
+function jsChainMessageKeysToProto(messageKeys) {
+    if (!messageKeys)
+        return [];
+    const out = [];
+    for (const [counterStr, seedB64] of Object.entries(messageKeys)) {
+        const counter = parseInt(counterStr, 10);
+        if (!Number.isFinite(counter))
+            continue;
+        const seed = fromB64(seedB64);
+        if (seed.length > 0)
+            out.push(deriveProtoMessageKey(seed, counter));
+    }
+    return out;
+}
+function sessionStructureToEntry(session, closedTs) {
+    if (!session.senderChain || !session.rootKey)
+        return null;
+    // 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 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];
+    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 = {};
+    if (session.senderChain.chainKey?.key && senderRatchetPub.length > 0) {
+        _chains[b64(senderRatchetPub)] = {
+            chainKey: { counter: session.senderChain.chainKey.index ?? 0, key: b64(session.senderChain.chainKey.key) },
+            chainType: CHAIN_TYPE_SENDING,
+            messageKeys: {}
+        };
+    }
+    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) },
+            chainType: CHAIN_TYPE_RECEIVING,
+            messageKeys: {}
+        };
+    }
+    const now = Date.now();
+    const entry = {
+        registrationId: session.remoteRegistrationId ?? 0,
+        currentRatchet: {
+            ephemeralKeyPair: { pubKey: b64(senderRatchetPub), privKey: b64(senderRatchetPriv) },
+            lastRemoteEphemeralKey: b64(lastRemoteEph),
+            previousCounter: session.previousCounter ?? 0,
+            rootKey: b64(session.rootKey)
+        },
+        indexInfo: {
+            baseKey: b64(baseKeyBytes),
+            baseKeyType,
+            closed: closedTs,
+            used: now,
+            created: now,
+            remoteIdentityKey: b64(session.remoteIdentityPublic ?? new Uint8Array())
+        },
+        _chains
+    };
+    if (session.pendingPreKey?.baseKey) {
+        entry.pendingPreKey = {
+            preKeyId: session.pendingPreKey.preKeyId ?? undefined,
+            signedKeyId: session.pendingPreKey.signedPreKeyId ?? undefined,
+            baseKey: b64(session.pendingPreKey.baseKey)
+        };
+    }
+    return entry;
+}
+function bridgeSessionProtoToUpstreamRecord(protoBytes) {
+    const record = proto.RecordStructure.decode(Buffer.from(protoBytes));
+    const _sessions = {};
+    const current = record.currentSession ? sessionStructureToEntry(record.currentSession, -1) : null;
+    if (current)
+        _sessions[current.indexInfo.baseKey] = current;
+    // 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 && !_sessions[entry.indexInfo.baseKey])
+            _sessions[entry.indexInfo.baseKey] = entry;
+    }
+    return { _sessions, version: 'v1' };
+}
+function entryToSessionStructure(entry) {
+    const ratchet = entry.currentRatchet;
+    const senderRatchetPub = fromB64(ratchet.ephemeralKeyPair.pubKey);
+    const senderRatchetPriv = fromB64(ratchet.ephemeralKeyPair.privKey);
+    const senderKeyB64 = senderRatchetPub.toString('base64');
+    const senderChainEntry = entry._chains[senderKeyB64];
+    const senderChain = {
+        senderRatchetKey: new Uint8Array(senderRatchetPub),
+        senderRatchetKeyPrivate: new Uint8Array(senderRatchetPriv),
+        chainKey: senderChainEntry
+            ? { index: senderChainEntry.chainKey.counter, key: new Uint8Array(fromB64(senderChainEntry.chainKey.key)) }
+            : { index: 0, key: new Uint8Array() },
+        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;
+        receiverChains.push({
+            senderRatchetKey: new Uint8Array(fromB64(k)),
+            chainKey: { index: ch.chainKey.counter, key: new Uint8Array(fromB64(ch.chainKey.key)) },
+            // 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,
+        senderChain,
+        receiverChains,
+        remoteIdentityPublic: new Uint8Array(fromB64(entry.indexInfo.remoteIdentityKey)),
+        remoteRegistrationId: entry.registrationId ?? 0,
+        aliceBaseKey: new Uint8Array(fromB64(entry.indexInfo.baseKey))
+    };
+    if (entry.pendingPreKey?.baseKey) {
+        session.pendingPreKey = {
+            preKeyId: entry.pendingPreKey.preKeyId ?? null,
+            signedPreKeyId: entry.pendingPreKey.signedKeyId ?? null,
+            baseKey: new Uint8Array(fromB64(entry.pendingPreKey.baseKey))
+        };
+    }
+    return session;
+}
+function upstreamSessionRecordToProto(record) {
+    const sessions = record?._sessions ?? {};
+    let currentSession = null;
+    const previousSessions = [];
+    for (const entry of Object.values(sessions)) {
+        const ss = entryToSessionStructure(entry);
+        if (!currentSession && entry.indexInfo.closed === -1)
+            currentSession = ss;
+        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
+    });
+    return proto.RecordStructure.encode(recordOut).finish();
+}
+// 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) {
@@ -259,6 +660,21 @@ function credsToDeviceJson(creds) {
         next_pre_key_id: creds.nextPreKeyId ?? 1
     });
 }
+/**
+ * Decode a `[priv(32)…pub(32)]` byte array (the bridge's `kp` shape) back into
+ * the upstream Baileys `{public, private}` keypair. Returns `undefined` for
+ * absent / all-zero arrays so callers can use `??` to keep prior values.
+ */
+function numArrayToKeyPair(arr) {
+    if (!Array.isArray(arr) || arr.length < 64)
+        return undefined;
+    if (arr.every(b => b === 0))
+        return undefined;
+    return {
+        private: new Uint8Array(arr.slice(0, 32)),
+        public: new Uint8Array(arr.slice(32, 64))
+    };
+}
 function updateCredsFromDevice(bytes, creds) {
     try {
         const d = fromJson(bytes);
@@ -293,6 +709,29 @@ function updateCredsFromDevice(bytes, creds) {
                 creds.advSecretKey = buf.toString('base64');
             }
         }
+        // Hydrate the noise / identity / signed pre-key material so the next
+        // `credsToDeviceJson(creds)` round-trip emits real bytes instead of
+        // zero-filled placeholders. Without this, a paired session looks
+        // half-valid on the next process start (`me.id` set, but key slots
+        // all zero) and the bridge's noise handshake gets rejected by the
+        // server with stream-error precondition-required.
+        const noise = numArrayToKeyPair(d.noise_key);
+        if (noise)
+            creds.noiseKey = noise;
+        const identity = numArrayToKeyPair(d.identity_key);
+        if (identity)
+            creds.signedIdentityKey = identity;
+        const signedPreKeyPair = numArrayToKeyPair(d.signed_pre_key);
+        if (signedPreKeyPair &&
+            Array.isArray(d.signed_pre_key_signature) &&
+            d.signed_pre_key_signature.length === 64 &&
+            d.signed_pre_key_signature.some(b => b !== 0)) {
+            creds.signedPreKey = {
+                keyPair: signedPreKeyPair,
+                keyId: d.signed_pre_key_id ?? 1,
+                signature: new Uint8Array(d.signed_pre_key_signature)
+            };
+        }
     }
     catch (e) {
         warn('updateCredsFromDevice failed:', e);
@@ -444,22 +883,58 @@ export async function wrapLegacyStore(state, saveCreds, logger) {
         }, 100);
     };
     /** Route a store to its handler */
-    const resolve = (store) => {
-        if (store === 'device')
+    const resolve = (storeName) => {
+        if (storeName === 'device')
             return 'device';
-        if (BINARY_STORES.has(store))
+        if (BINARY_STORES.has(storeName))
             return 'signal';
-        if (BRIDGE_ONLY_STORES.has(store))
+        if (BRIDGE_ONLY_STORES.has(storeName))
             return 'bridge-only';
-        if (STORE_MAP[store])
+        if (STORE_MAP[storeName])
             return 'converter';
         return 'unknown';
     };
     /** Translate bridge key format to upstream Baileys key format */
-    const translateKey = (store, key) => {
+    const translateKey = (storeName, key) => {
         // Bridge encodes sync_key IDs as hex; upstream stores use base64
-        if (store === 'sync_key')
+        if (storeName === 'sync_key')
             return hexToBase64(key);
+        // Bridge sender_key cache_key uses single-colon separator + signal-
+        // device suffix; upstream's `SenderKeyName.serialize()` uses double
+        // colons and drops the signal device — see bridgeSenderKeyToUpstream.
+        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/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(`${storeName} key translation failed for "${key}", falling back to passthrough`);
+                return key;
+            }
+            return translated;
+        }
+        // Bridge lid_mapping uses prefixed keys (`lid:{X}`, `pn:{X}`) that
+        // upstream's `Signal/lid-mapping.js` doesn't recognize. Map them to
+        // upstream's bare-userpart shape: `pn:{X}` → `{X}`, `lid:{X}` →
+        // `{X}_reverse`.
+        if (storeName === 'lid_mapping') {
+            if (key.startsWith('pn:'))
+                return key.slice(3);
+            if (key.startsWith('lid:'))
+                return `${key.slice(4)}_reverse`;
+            return key;
+        }
         return key;
     };
     /** Read a binary value from the keys store */
@@ -496,8 +971,19 @@ export async function wrapLegacyStore(state, saveCreds, logger) {
             const route = resolve(bridgeStore);
             const type = STORE_MAP[bridgeStore];
             if (route === 'device') {
-                if (key === 'device')
+                if (key === 'device') {
+                    // Fresh/stub creds (baileyrs' `initAuthCreds()` shim, or an
+                    // upstream flow that hadn't finished its first pair) carry
+                    // neither a noise key nor a paired `me.id`. Returning a
+                    // zeroed `credsToDeviceJson` in that state poisons the
+                    // bridge's noise handshake (server responds 428 Precondition
+                    // Required). Signaling `null` instead lets the bridge
+                    // bootstrap its own device identity and write it back
+                    // through `set('device', 'device', …)` on pair-success.
+                    if (!creds.noiseKey && !creds.me?.id)
+                        return null;
                     return credsToDeviceJson(creds);
+                }
                 if (key === 'account') {
                     if (!creds.account)
                         return null;
@@ -506,13 +992,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);
@@ -594,28 +1079,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 &&