chore: initial commit for v0.0.1

DChain single-node blockchain + React Native messenger client.

Core:
- PBFT consensus with multi-sig validator admission + equivocation slashing
- BadgerDB + schema migration scaffold (CurrentSchemaVersion=0)
- libp2p gossipsub (tx/v1, blocks/v1, relay/v1, version/v1)
- Native Go contracts (username_registry) alongside WASM (wazero)
- WebSocket gateway with topic-based fanout + Ed25519-nonce auth
- Relay mailbox with NaCl envelope encryption (X25519 + Ed25519)
- Prometheus /metrics, per-IP rate limit, body-size cap

Deployment:
- Single-node compose (deploy/single/) with Caddy TLS + optional Prometheus
- 3-node dev compose (docker-compose.yml) with mocked internet topology
- 3-validator prod compose (deploy/prod/) for federation
- Auto-update from Gitea via /api/update-check + systemd timer
- Build-time version injection (ldflags → node --version)
- UI / Swagger toggle flags (DCHAIN_DISABLE_UI, DCHAIN_DISABLE_SWAGGER)

Client (client-app/):
- Expo / React Native / NativeWind
- E2E NaCl encryption, typing indicator, contact requests
- Auto-discovery of canonical contracts, chain_id aware, WS reconnect on node switch

Documentation:
- README.md, CHANGELOG.md, CONTEXT.md
- deploy/single/README.md with 6 operator scenarios
- deploy/UPDATE_STRATEGY.md with 4-layer forward-compat design
- docs/contracts/*.md per contract

client-app/lib/store.ts

@@ -0,0 +1,103 @@
+/**
+ * Global app state via Zustand.
+ * Keeps runtime state; persistent data lives in storage.ts.
+ */
+
+import { create } from 'zustand';
+import type { KeyFile, Contact, Chat, Message, ContactRequest, NodeSettings } from './types';
+
+interface AppState {
+  // Identity
+  keyFile:    KeyFile | null;
+  username:   string | null;
+  setKeyFile: (kf: KeyFile | null) => void;
+  setUsername: (u: string | null) => void;
+
+  // Node settings
+  settings:     NodeSettings;
+  setSettings:  (s: Partial<NodeSettings>) => void;
+
+  // Contacts
+  contacts:    Contact[];
+  setContacts: (contacts: Contact[]) => void;
+  upsertContact: (c: Contact) => void;
+
+  // Chats (derived from contacts + messages)
+  chats:    Chat[];
+  setChats: (chats: Chat[]) => void;
+
+  // Active chat messages
+  messages:    Record<string, Message[]>;  // key: contactAddress
+  setMessages: (chatId: string, msgs: Message[]) => void;
+  appendMessage: (chatId: string, msg: Message) => void;
+
+  // Contact requests (pending)
+  requests:    ContactRequest[];
+  setRequests: (reqs: ContactRequest[]) => void;
+
+  // Balance
+  balance:    number;
+  setBalance: (b: number) => void;
+
+  // Loading / error states
+  loading:  boolean;
+  setLoading: (v: boolean) => void;
+  error:    string | null;
+  setError: (e: string | null) => void;
+
+  // Nonce cache (to avoid refetching)
+  nonce:    number;
+  setNonce: (n: number) => void;
+}
+
+export const useStore = create<AppState>((set, get) => ({
+  keyFile:    null,
+  username:   null,
+  setKeyFile: (kf) => set({ keyFile: kf }),
+  setUsername: (u) => set({ username: u }),
+
+  settings: {
+    nodeUrl:    'http://localhost:8081',
+    contractId: '',
+  },
+  setSettings: (s) => set(state => ({ settings: { ...state.settings, ...s } })),
+
+  contacts:    [],
+  setContacts: (contacts) => set({ contacts }),
+  upsertContact: (c) => set(state => {
+    const idx = state.contacts.findIndex(x => x.address === c.address);
+    if (idx >= 0) {
+      const updated = [...state.contacts];
+      updated[idx] = c;
+      return { contacts: updated };
+    }
+    return { contacts: [...state.contacts, c] };
+  }),
+
+  chats:    [],
+  setChats: (chats) => set({ chats }),
+
+  messages:    {},
+  setMessages: (chatId, msgs) => set(state => ({
+    messages: { ...state.messages, [chatId]: msgs },
+  })),
+  appendMessage: (chatId, msg) => set(state => {
+    const current = state.messages[chatId] ?? [];
+    if (current.find(m => m.id === msg.id)) return {};
+    return { messages: { ...state.messages, [chatId]: [...current, msg] } };
+  }),
+
+  requests:    [],
+  setRequests: (reqs) => set({ requests: reqs }),
+
+  balance:    0,
+  setBalance: (b) => set({ balance: b }),
+
+  loading:    false,
+  setLoading: (v) => set({ loading: v }),
+  error:      null,
+  setError:   (e) => set({ error: e }),
+
+  nonce:    0,
+  setNonce: (n) => set({ nonce: n }),
+}));