ce11a13874
Two coordinated changes:
1. Desktop client gets a functional Messages section and working pairing
flow, putting it at feature parity with mobile for the v2.2.0 line.
2. Server + both clients teach each other to use the sender's master
Ed25519 (not just their X25519) to address conversations, so a peer
writing from a different linked device still rolls into the same chat.
This is the "new API logic" the desktop scaffold was waiting on.
Server (node/api_relay.go, cmd/node/main.go):
* /relay/inbox items now carry `sender_ed25519_pub` alongside the
per-device `sender_pub`. Empty string for pre-v2.2.0 senders.
* WS `inbox` push summary also includes `sender_ed25519_pub`, so the
client can skip the refetch when the envelope plainly isn't for
the chat they're watching.
* Both existing tests pass.
Mobile client:
* lib/types.ts Envelope grew `sender_ed25519_pub`; fetchInbox normalises
it (default '') for older nodes.
* hooks/useGlobalInbox matches contacts by (master Ed25519 OR legacy
X25519) so an incoming message from a peer's desktop reuses the
existing chat instead of creating a duplicate placeholder.
* hooks/useMessages now takes an optional `contactMasterEd25519` and
exposes a matchesChat() predicate; WS inbox handler uses it too to
avoid spurious refetches.
* chats/[id].tsx passes `contact.address` (master) along with x25519.
Desktop client — all new:
* src/lib/crypto.ts — tweetnacl hex/base64 helpers, generateKeyFile,
encryptMessage/decryptMessage, signBase64, shortAddr. Same signatures
as the mobile lib; uses Chromium's window.crypto, no expo-crypto dep.
* src/lib/tx.ts — buildTransferTx / buildLinkDeviceTx / buildUnlinkDeviceTx
+ submitTx + humanizeTxError, canonical-bytes identical to mobile.
* src/lib/relay.ts — fetchInbox, sendEnvelope, resolveRecipientKeys
(multi-device fan-out with legacy identity.x25519 fallback).
* src/lib/store.ts — zustand state gets messages{}, unread{},
activeChat.
* src/lib/storage.ts — per-chat cache via localStorage (500-msg cap).
* src/hooks/useInboxPoll — 4s polling loop, addresses conversations
by master Ed25519, bumps unread unless chat is active.
* src/sections/messages/* — ChatList (sorted tiles, unread badges),
Conversation (auto-scroll messages + composer + fan-out send,
Enter-to-send / Shift+Enter for newline), EmptyConversation.
* src/auth/Pair.tsx — 6-digit code + device key screen, polls inbox
for a handshake envelope, assembles the KeyFile on arrival.
* Welcome.tsx: Pair button now actually routes to <Pair>; imports
generateKeyFile from lib/crypto (was inlined).
docs/ROADMAP.md delta: alpha5 row flipped to done inline. Alpha6
(feed + wallet) and rc1 (contacts + devices UI + profile) still
pending.
94 lines
3.8 KiB
TypeScript
94 lines
3.8 KiB
TypeScript
// Crypto primitives. Mirrors client-app/lib/crypto.ts function-for-
|
|
// function (same signatures, same hex/base64 formats on the wire) so
|
|
// the two clients decrypt each other's envelopes and sign txs the node
|
|
// accepts interchangeably.
|
|
//
|
|
// The only real difference from mobile: we don't need expo-crypto — the
|
|
// Electron renderer is a Chromium browser, so window.crypto.getRandomValues
|
|
// is always available and we just let tweetnacl pick it up on its own
|
|
// (tweetnacl auto-detects window.crypto when present).
|
|
|
|
import nacl from 'tweetnacl';
|
|
import { decodeUTF8, encodeUTF8 } from 'tweetnacl-util';
|
|
import type { KeyFile } from './types';
|
|
|
|
// ─── Hex / base64 ────────────────────────────────────────────────────────
|
|
|
|
export function hexToBytes(hex: string): Uint8Array {
|
|
if (hex.length % 2 !== 0) throw new Error('odd hex length');
|
|
const b = new Uint8Array(hex.length / 2);
|
|
for (let i = 0; i < b.length; i++) b[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
|
|
return b;
|
|
}
|
|
export function bytesToHex(b: Uint8Array): string {
|
|
return Array.from(b).map(x => x.toString(16).padStart(2, '0')).join('');
|
|
}
|
|
export function bytesToBase64(b: Uint8Array): string {
|
|
let s = '';
|
|
for (let i = 0; i < b.length; i++) s += String.fromCharCode(b[i]);
|
|
return btoa(s);
|
|
}
|
|
export function base64ToBytes(b64: string): Uint8Array {
|
|
const bin = atob(b64.replace(/-/g, '+').replace(/_/g, '/'));
|
|
const out = new Uint8Array(bin.length);
|
|
for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
|
|
return out;
|
|
}
|
|
|
|
// ─── Key generation ──────────────────────────────────────────────────────
|
|
|
|
export function generateKeyFile(): KeyFile {
|
|
const sign = nacl.sign.keyPair();
|
|
const box = nacl.box.keyPair();
|
|
return {
|
|
pub_key: bytesToHex(sign.publicKey),
|
|
priv_key: bytesToHex(sign.secretKey),
|
|
x25519_pub: bytesToHex(box.publicKey),
|
|
x25519_priv: bytesToHex(box.secretKey),
|
|
};
|
|
}
|
|
|
|
// ─── NaCl box (E2E messaging) ────────────────────────────────────────────
|
|
|
|
export function encryptMessage(
|
|
plaintext: string,
|
|
senderSecretHex: string,
|
|
recipientPubHex: string,
|
|
): { nonce: string; ciphertext: string } {
|
|
const nonce = nacl.randomBytes(nacl.box.nonceLength);
|
|
const msg = decodeUTF8(plaintext);
|
|
const box = nacl.box(msg, nonce, hexToBytes(recipientPubHex), hexToBytes(senderSecretHex));
|
|
return { nonce: bytesToHex(nonce), ciphertext: bytesToHex(box) };
|
|
}
|
|
|
|
export function decryptMessage(
|
|
ciphertextHex: string,
|
|
nonceHex: string,
|
|
senderPubHex: string,
|
|
recipientSecHex: string,
|
|
): string | null {
|
|
try {
|
|
const plain = nacl.box.open(
|
|
hexToBytes(ciphertextHex), hexToBytes(nonceHex),
|
|
hexToBytes(senderPubHex), hexToBytes(recipientSecHex),
|
|
);
|
|
return plain ? encodeUTF8(plain) : null;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// ─── Ed25519 signing ─────────────────────────────────────────────────────
|
|
|
|
export function signBase64(data: Uint8Array, privKeyHex: string): string {
|
|
const sig = nacl.sign.detached(data, hexToBytes(privKeyHex));
|
|
return bytesToBase64(sig);
|
|
}
|
|
|
|
// ─── Helpers ─────────────────────────────────────────────────────────────
|
|
|
|
export function shortAddr(hex: string, chars = 8): string {
|
|
if (hex.length <= chars * 2 + 3) return hex;
|
|
return `${hex.slice(0, chars)}…${hex.slice(-chars)}`;
|
|
}
|