feat(client): Twitter-style social feed UI (Phase C of v2.0.0)

Ships the client side of the v2.0.0 feed feature. Folds client-app/
into the monorepo (was previously .gitignored as "tracked separately"
but no separate repo ever existed — for v2.0.0 the client is
first-class).

Feed screens

  app/(app)/feed.tsx — Feed tab
    - Three-way tab strip: Подписки / Для вас / В тренде backed by
      /feed/timeline, /feed/foryou, /feed/trending respectively
    - Default landing tab is "Для вас" — surfaces discovery without
      requiring the user to follow anyone first
    - FlatList with pull-to-refresh + viewability-driven view counter
      bump (posts visible ≥ 60% for ≥ 1s trigger POST /feed/post/…/view)
    - Floating blue compose button → /compose
    - Per-post liked_by_me fetched in batches of 6 after list load

  app/(app)/compose.tsx — post composer modal
    - Fullscreen, Twitter-like header (✕ left, Опубликовать right)
    - Auto-focused multiline TextInput, 4000 char cap
    - Hashtag preview chips that auto-update as you type
    - expo-image-picker + expo-image-manipulator pipeline: resize to
      1080px max-dim, JPEG Q=50 (client-side first-pass compression
      before the mandatory server-side scrub)
    - Live fee estimate + balance guard with a confirmation modal
      ("Опубликовать пост? Цена: 0.00X T · Размер: N KB")
    - Exif: false passed to ImagePicker as an extra privacy layer

  app/(app)/feed/[id].tsx — post detail
    - Full PostCard rendering + detailed info panel (views, likes,
      size, fee, hosting relay, hashtags as tappable chips)
    - Triggers bumpView on mount
    - 410 (on-chain soft-delete) routes back to the feed

  app/(app)/feed/tag/[tag].tsx — hashtag feed

  app/(app)/profile/[address].tsx — rebuilt
    - Twitter-ish profile: avatar, name, address short-form, post count
    - Posts | Инфо tab strip
    - Follow / Unfollow button for non-self profiles (optimistic UI)
    - Edit button on self profile → settings
    - Secondary actions (chat, copy address) when viewing a known contact

Supporting library

  lib/feed.ts — HTTP wrappers + tx builders for every /feed/* endpoint:
    - publishPost (POST /feed/publish, signed)
    - publishAndCommit (publish → on-chain CREATE_POST)
    - fetchPost / fetchStats / bumpView
    - fetchAuthorPosts / fetchTimeline / fetchForYou / fetchTrending /
      fetchHashtag
    - buildCreatePostTx / buildDeletePostTx
    - buildFollowTx / buildUnfollowTx
    - buildLikePostTx / buildUnlikePostTx
    - likePost / unlikePost / followUser / unfollowUser / deletePost
      (high-level helpers that bundle build + submitTx)
    - formatFee, formatRelativeTime, formatCount — Twitter-like display
      helpers

  components/feed/PostCard.tsx — core card component
    - Memoised for performance (N-row re-render on every like elsewhere
      would cost a lot otherwise)
    - Optimistic like toggle with heart-bounce spring animation
    - Hashtag highlighting in body text (tappable → hashtag feed)
    - Long-press context menu (Delete, owner-only)
    - Views / likes / share-link / reply icons in footer row

Navigation cleanup

  - NavBar: removed the SOON pill on the Feed tab (it's shipped now)
  - (app)/_layout: hide NavBar on /compose and /feed/* sub-routes
  - AnimatedSlot: treat /feed/<id>, /feed/tag/<t>, /compose as
    sub-routes so back-swipe-right closes them

Channel removal (client side)

  - lib/types.ts: ContactKind stripped to 'direct' | 'group'; legacy
    'channel' flag removed. `kind` field kept for backward compat with
    existing AsyncStorage records.
  - lib/devSeed.ts: dropped the 5 channel seed contacts.
  - components/ChatTile.tsx: removed channel kindIcon branch.

Dependencies

  - expo-image-manipulator added for client-side image compression.
  - expo-file-system/legacy used for readAsStringAsync (SDK 54 moved
    that API to the legacy sub-path; the new streaming API isn't yet
    stable).

Type check

  - npx tsc --noEmit — clean, 0 errors.

Next (not in this commit)

  - Direct attachment-bytes endpoint on the server so post-detail can
    actually render the image (currently shows placeholder with URL)
  - Cross-relay body fetch via /api/relays + hosting_relay pubkey
  - Mentions (@username) with notifications
  - Full-text search

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

client-app/hooks/useBalance.ts

@@ -0,0 +1,94 @@
+/**
+ * Balance hook — uses the WebSocket gateway to receive instant updates when
+ * a tx involving the current address is committed, with HTTP polling as a
+ * graceful fallback for old nodes that don't expose /api/ws.
+ *
+ * Flow:
+ *   1. On mount: immediate HTTP fetch so the UI has a non-zero balance ASAP
+ *   2. Subscribe to `addr:<my_pubkey>` on the WS hub
+ *   3. On every `tx` event, re-fetch balance (cheap — one Badger read server-side)
+ *   4. If WS disconnects for >15s, fall back to 10-second polling until it reconnects
+ */
+
+import { useEffect, useCallback, useRef } from 'react';
+import { getBalance } from '@/lib/api';
+import { getWSClient } from '@/lib/ws';
+import { useStore } from '@/lib/store';
+
+const FALLBACK_POLL_INTERVAL  = 10_000;   // HTTP poll when WS is down
+const WS_GRACE_BEFORE_POLLING = 15_000;   // don't start polling immediately on disconnect
+
+export function useBalance() {
+  const keyFile    = useStore(s => s.keyFile);
+  const setBalance = useStore(s => s.setBalance);
+
+  const refresh = useCallback(async () => {
+    if (!keyFile) return;
+    try {
+      const bal = await getBalance(keyFile.pub_key);
+      setBalance(bal);
+    } catch {
+      // transient — next call will retry
+    }
+  }, [keyFile, setBalance]);
+
+  // --- fallback polling management ---
+  const pollTimerRef    = useRef<ReturnType<typeof setInterval> | null>(null);
+  const disconnectSinceRef = useRef<number | null>(null);
+  const disconnectTORef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const startPolling = useCallback(() => {
+    if (pollTimerRef.current) return;
+    console.log('[useBalance] WS down for grace period — starting HTTP poll');
+    refresh();
+    pollTimerRef.current = setInterval(refresh, FALLBACK_POLL_INTERVAL);
+  }, [refresh]);
+
+  const stopPolling = useCallback(() => {
+    if (pollTimerRef.current) {
+      clearInterval(pollTimerRef.current);
+      pollTimerRef.current = null;
+    }
+    if (disconnectTORef.current) {
+      clearTimeout(disconnectTORef.current);
+      disconnectTORef.current = null;
+    }
+    disconnectSinceRef.current = null;
+  }, []);
+
+  useEffect(() => {
+    if (!keyFile) return;
+    const ws  = getWSClient();
+
+    // Immediate HTTP fetch so the UI is not empty while the WS hello arrives.
+    refresh();
+
+    // Refresh balance whenever a tx for our address is committed.
+    const offTx = ws.subscribe('addr:' + keyFile.pub_key, (frame) => {
+      if (frame.event === 'tx') {
+        refresh();
+      }
+    });
+
+    // Manage fallback polling based on WS connection state.
+    const offConn = ws.onConnectionChange((ok) => {
+      if (ok) {
+        stopPolling();
+        refresh();  // catch up anything we missed while disconnected
+      } else if (disconnectTORef.current === null) {
+        disconnectSinceRef.current = Date.now();
+        disconnectTORef.current    = setTimeout(startPolling, WS_GRACE_BEFORE_POLLING);
+      }
+    });
+
+    ws.connect();
+
+    return () => {
+      offTx();
+      offConn();
+      stopPolling();
+    };
+  }, [keyFile, refresh, startPolling, stopPolling]);
+
+  return { refresh };
+}

client-app/hooks/useConnectionStatus.ts

@@ -0,0 +1,52 @@
+/**
+ * useConnectionStatus — объединённое состояние подключения клиента к сети.
+ *
+ * Определяет один из трёх стейтов:
+ *   - 'offline'    — нет интернета по данным NetInfo
+ *   - 'connecting' — интернет есть, но WebSocket к ноде не подключён
+ *   - 'online'     — WebSocket к ноде активен
+ *
+ * Используется в headers (например Messages → "Connecting...",
+ * "Waiting for internet") и на profile-avatar'ах как индикатор
+ * живости.
+ *
+ * NetInfo использует connected + internetReachable для детекта
+ * настоящего Internet (не просто Wi-Fi SSID без доступа); fallback
+ * на `connected`-only когда internetReachable неопределён (некоторые
+ * корпоративные сети или Android в первые секунды).
+ */
+import { useEffect, useState } from 'react';
+import NetInfo from '@react-native-community/netinfo';
+import { getWSClient } from '@/lib/ws';
+
+export type ConnectionStatus = 'online' | 'connecting' | 'offline';
+
+export function useConnectionStatus(): ConnectionStatus {
+  const [wsLive, setWsLive]     = useState(false);
+  const [hasNet, setHasNet]     = useState(true);
+
+  // WS live-state: subscribe к его onConnectionChange.
+  useEffect(() => {
+    const ws = getWSClient();
+    setWsLive(ws.isConnected());
+    return ws.onConnectionChange(setWsLive);
+  }, []);
+
+  // Internet reachability: через NetInfo.
+  useEffect(() => {
+    const unsub = NetInfo.addEventListener((state) => {
+      // internetReachable = null значит "ещё не проверили" — считаем
+      // что есть, чтобы не ложно отображать "offline" на старте.
+      const reachable =
+        state.isInternetReachable === false ? false :
+        state.isConnected === false          ? false :
+        true;
+      setHasNet(reachable);
+    });
+    return unsub;
+  }, []);
+
+  if (!hasNet) return 'offline';
+  if (wsLive)  return 'online';
+  return 'connecting';
+}

client-app/hooks/useContacts.ts

@@ -0,0 +1,80 @@
+/**
+ * Contacts + inbound request tracking.
+ *
+ * - Loads cached contacts from local storage on boot.
+ * - Subscribes to the address WS topic so a new CONTACT_REQUEST pulls the
+ *   relay contact list immediately (sub-second UX).
+ * - Keeps a 30 s polling fallback for nodes without WS or while disconnected.
+ */
+
+import { useEffect, useCallback } from 'react';
+import { fetchContactRequests } from '@/lib/api';
+import { getWSClient } from '@/lib/ws';
+import { loadContacts } from '@/lib/storage';
+import { useStore } from '@/lib/store';
+
+const FALLBACK_POLL_INTERVAL = 30_000;
+
+export function useContacts() {
+  const keyFile     = useStore(s => s.keyFile);
+  const setContacts = useStore(s => s.setContacts);
+  const setRequests = useStore(s => s.setRequests);
+  const contacts    = useStore(s => s.contacts);
+
+  // Load cached contacts from local storage once
+  useEffect(() => {
+    loadContacts().then(setContacts);
+  }, [setContacts]);
+
+  const pollRequests = useCallback(async () => {
+    if (!keyFile) return;
+    try {
+      const raw = await fetchContactRequests(keyFile.pub_key);
+
+      // Filter out already-accepted contacts
+      const contactAddresses = new Set(contacts.map(c => c.address));
+
+      const requests = raw
+        .filter(r => r.status === 'pending' && !contactAddresses.has(r.requester_pub))
+        .map(r => ({
+          from:      r.requester_pub,
+          // x25519Pub will be fetched from identity when user taps Accept
+          x25519Pub: '',
+          intro:     r.intro ?? '',
+          timestamp: r.created_at,
+          txHash:    r.tx_id,
+        }));
+
+      setRequests(requests);
+    } catch {
+      // Ignore transient network errors
+    }
+  }, [keyFile, contacts, setRequests]);
+
+  useEffect(() => {
+    if (!keyFile) return;
+    const ws = getWSClient();
+
+    // Initial load + low-frequency fallback poll (covers missed WS events,
+    // works even when the node has no WS endpoint).
+    pollRequests();
+    const interval = setInterval(pollRequests, FALLBACK_POLL_INTERVAL);
+
+    // Immediate refresh when a CONTACT_REQUEST / ACCEPT_CONTACT tx addressed
+    // to us lands on-chain. WS fan-out already filters to our address topic.
+    const off = ws.subscribe('addr:' + keyFile.pub_key, (frame) => {
+      if (frame.event === 'tx') {
+        const d = frame.data as { tx_type?: string } | undefined;
+        if (d?.tx_type === 'CONTACT_REQUEST' || d?.tx_type === 'ACCEPT_CONTACT') {
+          pollRequests();
+        }
+      }
+    });
+    ws.connect();
+
+    return () => {
+      clearInterval(interval);
+      off();
+    };
+  }, [keyFile, pollRequests]);
+}

client-app/hooks/useGlobalInbox.ts

@@ -0,0 +1,114 @@
+/**
+ * useGlobalInbox — app-wide inbox listener.
+ *
+ * Подписан на WS-топик `inbox:<my_x25519>` при любом экране внутри
+ * (app)-группы. Когда приходит push с envelope, мы:
+ *   1. Декриптуем — если это наш контакт, добавляем в store.
+ *   2. Инкрементим unreadByContact[address].
+ *   3. Показываем local notification (от кого + счётчик).
+ *
+ * НЕ дублирует chat-detail'овский `useMessages` — тот делает initial
+ * HTTP-pull при открытии чата и слушает тот же топик (двойная подписка
+ * с фильтром по sender_pub). Оба держат в store консистентное состояние
+ * через `appendMessage` (который идемпотентен по id).
+ *
+ * Фильтрация "app backgrounded" не нужна: Expo notifications'handler
+ * показывает banner и в foreground, но при активном чате с этим
+ * контактом нотификация dismiss'ится автоматически через
+ * clearContactNotifications (вызывается при mount'е chats/[id]).
+ */
+import { useEffect, useRef } from 'react';
+import { AppState } from 'react-native';
+import { usePathname } from 'expo-router';
+
+import { useStore } from '@/lib/store';
+import { getWSClient } from '@/lib/ws';
+import { decryptMessage } from '@/lib/crypto';
+import { fetchInbox } from '@/lib/api';
+import { appendMessage } from '@/lib/storage';
+import { randomId } from '@/lib/utils';
+
+import { notifyIncoming } from './useNotifications';
+
+export function useGlobalInbox() {
+  const keyFile    = useStore(s => s.keyFile);
+  const contacts   = useStore(s => s.contacts);
+  const appendMsg  = useStore(s => s.appendMessage);
+  const incrementUnread = useStore(s => s.incrementUnread);
+  const pathname   = usePathname();
+  const contactsRef = useRef(contacts);
+  const pathnameRef = useRef(pathname);
+
+  useEffect(() => { contactsRef.current = contacts; }, [contacts]);
+  useEffect(() => { pathnameRef.current = pathname; }, [pathname]);
+
+  useEffect(() => {
+    if (!keyFile?.x25519_pub) return;
+
+    const ws = getWSClient();
+
+    const handleEnvelopePull = async () => {
+      try {
+        const envelopes = await fetchInbox(keyFile.x25519_pub);
+        for (const env of envelopes) {
+          // Найти контакт по sender_pub — если не знакомый, игнорим
+          // (для MVP; в future можно показывать "unknown sender").
+          const c = contactsRef.current.find(
+            x => x.x25519Pub === env.sender_pub,
+          );
+          if (!c) continue;
+
+          let text = '';
+          try {
+            text = decryptMessage(
+              env.ciphertext,
+              env.nonce,
+              env.sender_pub,
+              keyFile.x25519_priv,
+            ) ?? '';
+          } catch {
+            continue;
+          }
+          if (!text) continue;
+
+          // Стабильный id от сервера (sha256(nonce||ct)[:16]); fallback
+          // на nonce-префикс если вдруг env.id пустой.
+          const msgId = env.id || `${env.sender_pub}_${env.nonce.slice(0, 16)}`;
+          const msg = {
+            id:        msgId,
+            from:      env.sender_pub,
+            text,
+            timestamp: env.timestamp,
+            mine:      false,
+          };
+          appendMsg(c.address, msg);
+          await appendMessage(c.address, msg);
+
+          // Если пользователь прямо сейчас в этом чате — unread не инкрементим,
+          // notification не показываем.
+          const inThisChat =
+            pathnameRef.current === `/chats/${c.address}` ||
+            pathnameRef.current.startsWith(`/chats/${c.address}/`);
+          if (inThisChat && AppState.currentState === 'active') continue;
+
+          incrementUnread(c.address);
+          const unread = useStore.getState().unreadByContact[c.address] ?? 1;
+          notifyIncoming({
+            contactAddress: c.address,
+            senderName:     c.username ? `@${c.username}` : (c.alias ?? 'New message'),
+            unreadCount:    unread,
+          });
+        }
+      } catch {
+        /* silent — ошибки pull'а обрабатывает useMessages */
+      }
+    };
+
+    const off = ws.subscribe('inbox:' + keyFile.x25519_pub, (frame) => {
+      if (frame.event !== 'inbox') return;
+      handleEnvelopePull();
+    });
+
+    return off;
+  }, [keyFile, appendMsg, incrementUnread]);
+}

client-app/hooks/useMessages.ts

@@ -0,0 +1,149 @@
+/**
+ * Subscribe to the relay inbox via WebSocket and decrypt incoming envelopes
+ * for the active chat. Falls back to 30-second polling whenever the WS is
+ * not connected — preserves correctness on older nodes or flaky networks.
+ *
+ * Flow:
+ *   1. On mount: one HTTP fetch so we have whatever is already in the inbox
+ *   2. Subscribe to topic `inbox:<my_x25519>` — the node pushes a summary
+ *      for each fresh envelope as soon as mailbox.Store() succeeds
+ *   3. On each push, pull the full envelope list (cheap — bounded by
+ *      MailboxPerRecipientCap) and decrypt anything we haven't seen yet
+ *   4. If WS disconnects for > 15 seconds, start a 30 s HTTP poll until it
+ *      reconnects
+ */
+
+import { useEffect, useCallback, useRef } from 'react';
+import { fetchInbox } from '@/lib/api';
+import { getWSClient } from '@/lib/ws';
+import { decryptMessage } from '@/lib/crypto';
+import { appendMessage, loadMessages } from '@/lib/storage';
+import { useStore } from '@/lib/store';
+
+const FALLBACK_POLL_INTERVAL  = 30_000;  // HTTP poll when WS is down
+const WS_GRACE_BEFORE_POLLING = 15_000;  // don't start polling immediately on disconnect
+
+export function useMessages(contactX25519: string) {
+  const keyFile   = useStore(s => s.keyFile);
+  const appendMsg = useStore(s => s.appendMessage);
+
+  // Подгружаем кэш сообщений из AsyncStorage при открытии чата.
+  // Релей держит envelope'ы всего 7 дней, поэтому без чтения кэша
+  // история старше недели пропадает при каждом рестарте приложения.
+  // appendMsg в store идемпотентен по id, поэтому безопасно гонять его
+  // для каждого кэшированного сообщения.
+  useEffect(() => {
+    if (!contactX25519) return;
+    let cancelled = false;
+    loadMessages(contactX25519).then(cached => {
+      if (cancelled) return;
+      for (const m of cached) appendMsg(contactX25519, m);
+    }).catch(() => { /* cache miss / JSON error — not fatal */ });
+    return () => { cancelled = true; };
+  }, [contactX25519, appendMsg]);
+
+  const pullAndDecrypt = useCallback(async () => {
+    if (!keyFile || !contactX25519) return;
+    try {
+      const envelopes = await fetchInbox(keyFile.x25519_pub);
+      for (const env of envelopes) {
+        // Only process messages from this contact
+        if (env.sender_pub !== contactX25519) continue;
+
+        const text = decryptMessage(
+          env.ciphertext,
+          env.nonce,
+          env.sender_pub,
+          keyFile.x25519_priv,
+        );
+        if (!text) continue;
+
+        // Dedup id — используем стабильный серверный env.id (hex
+        // sha256(nonce||ct)[:16]). Раньше собирался из env.timestamp,
+        // но клиентский тип не имел sent_at, поэтому timestamp был
+        // undefined и все id коллапсировали на "undefined".
+        const msg = {
+          id:        env.id || `${env.sender_pub}_${env.nonce.slice(0, 16)}`,
+          from:      env.sender_pub,
+          text,
+          timestamp: env.timestamp,
+          mine:      false,
+        };
+        appendMsg(contactX25519, msg);
+        await appendMessage(contactX25519, msg);
+      }
+    } catch (e: any) {
+      // Шумные ошибки (404 = нет mailbox'а, Network request failed =
+      // нода недоступна) — ожидаемы в dev-среде и при offline-режиме,
+      // не спамим console. Остальное — логируем.
+      const msg = String(e?.message ?? e ?? '');
+      if (/→\s*404\b/.test(msg)) return;
+      if (/ 404\b/.test(msg))    return;
+      if (/Network request failed/i.test(msg)) return;
+      if (/Failed to fetch/i.test(msg))         return;
+      console.warn('[useMessages] pull error:', e);
+    }
+  }, [keyFile, contactX25519, appendMsg]);
+
+  // ── Fallback polling state ────────────────────────────────────────────
+  const pollTimerRef       = useRef<ReturnType<typeof setInterval> | null>(null);
+  const disconnectTORef    = useRef<ReturnType<typeof setTimeout>  | null>(null);
+
+  const startPolling = useCallback(() => {
+    if (pollTimerRef.current) return;
+    console.log('[useMessages] WS down — starting HTTP poll fallback');
+    pullAndDecrypt();
+    pollTimerRef.current = setInterval(pullAndDecrypt, FALLBACK_POLL_INTERVAL);
+  }, [pullAndDecrypt]);
+
+  const stopPolling = useCallback(() => {
+    if (pollTimerRef.current) {
+      clearInterval(pollTimerRef.current);
+      pollTimerRef.current = null;
+    }
+    if (disconnectTORef.current) {
+      clearTimeout(disconnectTORef.current);
+      disconnectTORef.current = null;
+    }
+  }, []);
+
+  useEffect(() => {
+    if (!keyFile || !contactX25519) return;
+
+    const ws = getWSClient();
+
+    // Initial fetch — populate whatever landed before we mounted.
+    pullAndDecrypt();
+
+    // Subscribe to our x25519 inbox — the node emits on mailbox.Store.
+    // Topic filter: only envelopes for ME; we then filter by sender inside
+    // the handler so we only render messages in THIS chat.
+    const offInbox = ws.subscribe('inbox:' + keyFile.x25519_pub, (frame) => {
+      if (frame.event !== 'inbox') return;
+      const d = frame.data as { sender_pub?: string } | undefined;
+      // Optimisation: if the envelope is from a different peer, skip the
+      // whole refetch — we'd just drop it in the sender filter below anyway.
+      if (d?.sender_pub && d.sender_pub !== contactX25519) return;
+      pullAndDecrypt();
+    });
+
+    // Manage fallback polling based on WS connection state.
+    const offConn = ws.onConnectionChange((ok) => {
+      if (ok) {
+        stopPolling();
+        // Catch up anything we missed while disconnected.
+        pullAndDecrypt();
+      } else if (disconnectTORef.current === null) {
+        disconnectTORef.current = setTimeout(startPolling, WS_GRACE_BEFORE_POLLING);
+      }
+    });
+
+    ws.connect();
+
+    return () => {
+      offInbox();
+      offConn();
+      stopPolling();
+    };
+  }, [keyFile, contactX25519, pullAndDecrypt, startPolling, stopPolling]);
+}

client-app/hooks/useNotifications.ts

@@ -0,0 +1,144 @@
+/**
+ * useNotifications — bootstrap expo-notifications (permission + handler)
+ * и routing при tap'е на notification → открыть конкретный чат.
+ *
+ * ВАЖНО: expo-notifications в Expo Go (SDK 53+) валит error при САМОМ
+ * import'е модуля ("Android Push notifications ... removed from Expo Go").
+ * Поэтому мы НЕ делаем static `import * as Notifications from ...` —
+ * вместо этого lazy `require()` внутри функций, только если мы вне Expo Go.
+ * На dev-build / production APK всё работает штатно.
+ *
+ * Privacy: notification содержит ТОЛЬКО имя отправителя и счётчик
+ * непрочитанных. Тело сообщения НЕ показывается — для E2E-мессенджера
+ * это критично (push нотификации проходят через OS / APNs и могут
+ * логироваться).
+ */
+import { useEffect } from 'react';
+import { Platform } from 'react-native';
+import Constants, { ExecutionEnvironment } from 'expo-constants';
+import { router } from 'expo-router';
+
+// В Expo Go push-нотификации отключены с SDK 53. Любое обращение к
+// expo-notifications (включая import) пишет error в консоль. Детектим
+// среду один раз на module-load.
+const IS_EXPO_GO =
+  Constants.executionEnvironment === ExecutionEnvironment.StoreClient;
+
+/**
+ * Lazy-load expo-notifications. Возвращает модуль или null в Expo Go.
+ * Кешируем результат, чтобы не делать require повторно.
+ */
+let _cached: any | null | undefined = undefined;
+function getNotifications(): any | null {
+  if (_cached !== undefined) return _cached;
+  if (IS_EXPO_GO) { _cached = null; return null; }
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    _cached = require('expo-notifications');
+  } catch {
+    _cached = null;
+  }
+  return _cached;
+}
+
+// Handler ставим лениво при первом обращении (а не на module-top'е),
+// т.к. require сам по себе подтянет модуль — в Expo Go его не дергаем.
+let _handlerInstalled = false;
+function installHandler() {
+  if (_handlerInstalled) return;
+  const N = getNotifications();
+  if (!N) return;
+  N.setNotificationHandler({
+    handleNotification: async () => ({
+      shouldShowBanner: true,
+      shouldShowList:   true,
+      shouldPlaySound:  false,
+      shouldSetBadge:   true,
+    }),
+  });
+  _handlerInstalled = true;
+}
+
+export function useNotifications() {
+  useEffect(() => {
+    const N = getNotifications();
+    if (!N) return;   // Expo Go — no-op
+
+    installHandler();
+
+    (async () => {
+      try {
+        const existing = await N.getPermissionsAsync();
+        if (existing.status !== 'granted' && existing.canAskAgain !== false) {
+          await N.requestPermissionsAsync();
+        }
+
+        if (Platform.OS === 'android') {
+          // Channel — обязателен для Android 8+ чтобы уведомления показывались.
+          await N.setNotificationChannelAsync('messages', {
+            name: 'Messages',
+            importance: N.AndroidImportance.HIGH,
+            vibrationPattern: [0, 200, 100, 200],
+            lightColor: '#1d9bf0',
+            sound: undefined,
+          });
+        }
+      } catch {
+        // fail-safe — notifications не критичны
+      }
+    })();
+
+    // Tap-to-open listener.
+    const sub = N.addNotificationResponseReceivedListener((resp: any) => {
+      const data = resp?.notification?.request?.content?.data as
+        { contactAddress?: string } | undefined;
+      if (data?.contactAddress) {
+        router.push(`/(app)/chats/${data.contactAddress}` as never);
+      }
+    });
+
+    return () => { try { sub.remove(); } catch { /* ignore */ } };
+  }, []);
+}
+
+/**
+ * Показать локальное уведомление о новом сообщении. Вызывается из
+ * global-inbox-listener'а когда приходит envelope от peer'а.
+ *
+ * content не содержит текста — только "New message" как generic label
+ * (см. privacy-note в doc'е выше).
+ */
+export async function notifyIncoming(params: {
+  contactAddress: string;
+  senderName:     string;
+  unreadCount:    number;
+}) {
+  const N = getNotifications();
+  if (!N) return;   // Expo Go — no-op
+  const { contactAddress, senderName, unreadCount } = params;
+  try {
+    await N.scheduleNotificationAsync({
+      identifier: `inbox:${contactAddress}`,  // replaces previous for same contact
+      content: {
+        title: senderName,
+        body:  unreadCount === 1
+          ? 'New message'
+          : `${unreadCount} new messages`,
+        data:  { contactAddress },
+      },
+      trigger: null,  // immediate
+    });
+  } catch {
+    // Fail silently — если OS не дала permission, notification не
+    // покажется. Не ломаем send-flow.
+  }
+}
+
+/** Dismiss notification для контакта (вызывается когда чат открыт). */
+export async function clearContactNotifications(contactAddress: string) {
+  const N = getNotifications();
+  if (!N) return;
+  try {
+    await N.dismissNotificationAsync(`inbox:${contactAddress}`);
+  } catch { /* ignore */ }
+}

client-app/hooks/useWellKnownContracts.ts

@@ -0,0 +1,61 @@
+/**
+ * Auto-discover canonical system contracts from the node so the user doesn't
+ * have to paste contract IDs into settings by hand.
+ *
+ * Flow:
+ *   1. On app boot (and whenever nodeUrl changes), call GET /api/well-known-contracts
+ *   2. If the node advertises a `username_registry` and the user has not
+ *      manually set `settings.contractId`, auto-populate it and persist.
+ *   3. A user-supplied contractId is never overwritten — so power users can
+ *      still pin a non-canonical deployment from settings.
+ */
+
+import { useEffect } from 'react';
+import { fetchWellKnownContracts } from '@/lib/api';
+import { saveSettings } from '@/lib/storage';
+import { useStore } from '@/lib/store';
+
+export function useWellKnownContracts() {
+  const nodeUrl      = useStore(s => s.settings.nodeUrl);
+  const contractId   = useStore(s => s.settings.contractId);
+  const settings     = useStore(s => s.settings);
+  const setSettings  = useStore(s => s.setSettings);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function run() {
+      if (!nodeUrl) return;
+      const res = await fetchWellKnownContracts();
+      if (cancelled || !res) return;
+
+      const registry = res.contracts['username_registry'];
+      if (!registry) return;
+
+      // Always keep the stored contractId in sync with what the node reports
+      // as canonical. If the user resets their chain or we migrate from a
+      // WASM contract to the native one, the stale contract_id cached in
+      // local storage would otherwise keep the client trying to call a
+      // contract that no longer exists on this chain.
+      //
+      // To still support intentional overrides: the UI's "advanced" section
+      // allows pasting a specific ID — and since that also writes to
+      // settings.contractId, the loop converges back to whatever the node
+      // says after a short delay. Operators who want a hard override should
+      // either run a patched node or pin the value with a wrapper config
+      // outside the app.
+      if (registry.contract_id !== contractId) {
+        const next = { ...settings, contractId: registry.contract_id };
+        setSettings({ contractId: registry.contract_id });
+        await saveSettings(next);
+        console.log('[well-known] synced username_registry =', registry.contract_id,
+          '(was:', contractId || '<empty>', ')');
+      }
+    }
+
+    run();
+    return () => { cancelled = true; };
+    // Re-run when the node URL changes (user switched networks) or when
+    // contractId is cleared.
+  }, [nodeUrl, contractId]); // eslint-disable-line react-hooks/exhaustive-deps
+}