add yarn prior to yarn build

Replace all key-store.ts (localStorage) usage with eyre-client.ts:
- accounts.ts: HD derivation delegated to agent, CRUD via poke/scry
- misc.ts: getMnemonic, getPathKey, getAccountIndices via scry
- NetworksContext.tsx: init from getNetworks() instead of localStorage
- Accounts.tsx: network deletion via updateNetworks() poke
- EditNetwork.tsx: network updates via updateNetworks() poke
- key-store.ts: marked deprecated, zero remaining consumers

Private keys and mnemonic no longer stored in browser localStorage.
All wallet state persisted in the %zenith agent on the Urbit ship.

Part of wallet-integration across:
- zenith-desk: Hoon crypto libs + agent endpoints
- zenith-wallet-web (this repo): Eyre channel client + localStorage migration
- zenith-testing: Go integration tests

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

build-glob.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+#
+# Build and deploy zenith-wallet-web as an Urbit glob.
+#
+# Prerequisites:
+#   - yarn installed
+#   - An Urbit ship running with a pier at $PIER_PATH
+#   - The desk 'zenith-wallet' already created on the ship
+#   - IPFS node running (for glob upload)
+#
+# Usage:
+#   PIER_PATH=/path/to/pier ./build-glob.sh
+#
+set -euo pipefail
+
+DESK_NAME="zenith-wallet"
+
+if [ -z "${PIER_PATH:-}" ]; then
+  echo "Error: PIER_PATH must be set to your Urbit pier directory"
+  exit 1
+fi
+
+DESK_PATH="${PIER_PATH}/${DESK_NAME}"
+
+# 1. Build the React app
+echo "==> Building React app..."
+yarn && yarn build
+
+# 2. Lowercase all filenames in build/ (Urbit requires lowercase)
+echo "==> Lowercasing filenames in build/..."
+find build -depth -name '*[A-Z]*' | while read -r f; do
+  dir="$(dirname "$f")"
+  base="$(basename "$f")"
+  lower="$(echo "$base" | tr '[:upper:]' '[:lower:]')"
+  if [ "$base" != "$lower" ]; then
+    mv "$f" "${dir}/${lower}"
+  fi
+done
+
+# 3. Copy build output to the ship's desk
+echo "==> Copying build/ to ${DESK_PATH}..."
+mkdir -p "${DESK_PATH}"
+cp -r build/* "${DESK_PATH}/"
+
+# 4. Copy mark files for non-standard extensions
+echo "==> Copying mark files..."
+mkdir -p "${DESK_PATH}/mar"
+cp urbit-files/mar/*.hoon "${DESK_PATH}/mar/"
+
+# 5. Copy desk.docket-0
+echo "==> Copying desk.docket-0..."
+cp urbit-files/desk.docket-0 "${DESK_PATH}/desk.docket-0"
+
+echo ""
+echo "==> Done! Next steps:"
+echo "  1. In your ship's dojo, run:"
+echo "       |commit %${DESK_NAME}"
+echo "  2. Create the glob:"
+echo "       -garden!make-glob %${DESK_NAME} /build"
+echo "  3. Upload the glob file from .urb/put/ to IPFS"
+echo "  4. Update desk.docket-0 with the IPFS URL and hash"
+echo "  5. Recommit:"
+echo "       |commit %${DESK_NAME}"
+echo "  6. Install the desk:"
+echo "       |install our %${DESK_NAME}"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-wallet",
-  "version": "0.1.7-zenith-0.2.5",
+  "version": "0.1.7-zenith-0.2.3",
   "private": true,
   "dependencies": {
     "@laconic-network/cosmjs-util": "^0.1.0",

src/components/Accounts.tsx

@@ -16,7 +16,7 @@ import { useNetworks } from "../context/NetworksContext";
 import ConfirmDialog from "./ConfirmDialog";
 import { getNamespaces } from "../utils/wallet-connect/helpers";
 import ShowPKDialog from "./ShowPKDialog";
-import { setInternetCredentials } from "../utils/key-store";
+import { updateNetworks } from "../utils/eyre-client";
 import {
   Accordion,
   AccordionSummary,
@@ -110,11 +110,7 @@ const Accounts = () => {
       (networkData) => selectedNetwork!.networkId !== networkData.networkId,
     );
 
-    await setInternetCredentials(
+    await updateNetworks(updatedNetworks);
-      "networks",
-      "_",
-      JSON.stringify(updatedNetworks),
-    );
 
     setSelectedNetwork(updatedNetworks[0]);
     setCurrentIndex(0);

src/context/NetworksContext.tsx

@@ -1,9 +1,8 @@
 import React, { createContext, useContext, useEffect, useState } from 'react';
 
 import { NetworksDataState } from '../types';
-import { retrieveNetworksData } from '../utils/accounts';
+import { getNetworks, updateNetworks } from '../utils/eyre-client';
 import { DEFAULT_NETWORKS, EIP155 } from '../utils/constants';
-import { setInternetCredentials } from '../utils/key-store';
 
 const NetworksContext = createContext<{
   networksData: NetworksDataState[];
@@ -42,15 +41,10 @@ const NetworksProvider = ({ children }: { children: React.ReactNode }) => {
 
   useEffect(() => {
     const fetchData = async () => {
-      let retrievedNetworks = await retrieveNetworksData();
+      let retrievedNetworks = await getNetworks();
 
       if (retrievedNetworks.length === 0) {
-        setInternetCredentials(
+        await updateNetworks(DEFAULT_NETWORKS_DATA);
-          'networks',
-          '_',
-          JSON.stringify(DEFAULT_NETWORKS_DATA),
-        );
-
         retrievedNetworks = DEFAULT_NETWORKS_DATA;
       }
 

src/hooks/useCreateNetwork.ts

@@ -1,6 +1,6 @@
 import { useEffect, useCallback } from "react";
 
-import { addNewNetwork, createWallet, checkNetworkForChainID, isWalletCreated, updateNetworkRpcUrl } from "../utils/accounts";
+import { addNewNetwork, createWallet, checkNetworkForChainID, isWalletCreated } from "../utils/accounts";
 import { useNetworks } from "../context/NetworksContext";
 import { NETWORK_ADDED_RESPONSE, NETWORK_ADD_FAILED_RESPONSE, NETWORK_ALREADY_EXISTS_RESPONSE, REQUEST_ADD_NETWORK } from "../utils/constants";
 import { NetworksFormData } from "../types";
@@ -52,11 +52,6 @@ const useCreateNetwork = () => {
             chainId
           }, sourceOrigin);
         } else {
-          console.log("Network already exists. Updating RPC URL");
-
-          const retrievedNetworksData = await updateNetworkRpcUrl(chainId, networkData.rpcUrl);
-          setNetworksData(retrievedNetworksData);
-
           sendMessage(window.parent, NETWORK_ALREADY_EXISTS_RESPONSE, {
             type: NETWORK_ALREADY_EXISTS_RESPONSE,
             chainId

src/hooks/useExportPrivateKeyEmbed.ts

@@ -1,10 +1,12 @@
 import { useEffect } from 'react';
 
-import { retrieveNetworksData, retrieveAccounts } from '../utils/accounts';
+import { useAccounts } from '../context/AccountsContext';
 import { getPathKey, sendMessage } from '../utils/misc';
 import { ACCOUNT_PK_RESPONSE, REQUEST_ACCOUNT_PK } from '../utils/constants';
 
 const useExportPKEmbed = () => {
+  const {  accounts } = useAccounts();
+
   useEffect(() => {
     const handleMessage = async (event: MessageEvent) => {
       const { type, chainId, address } = event.data;
@@ -12,23 +14,9 @@ const useExportPKEmbed = () => {
       if (type !== REQUEST_ACCOUNT_PK) return;
 
       try {
-        // Look up the network and accounts directly from storage
+        const selectedAccount = accounts.find(account => account.address === address);
-        // rather than relying on the accounts context, which can be
-        // overwritten by HomeScreen's fetchAccounts for a different network.
-        const networksData = await retrieveNetworksData();
-        const targetNetwork = networksData.find(
-          net => `${net.namespace}:${net.chainId}` === chainId,
-        );
-
-        if (!targetNetwork) {
-          throw new Error("Network not found");
-        }
-
-        const networkAccounts = await retrieveAccounts(targetNetwork);
-        const selectedAccount = networkAccounts?.find(account => account.address === address);
-
         if (!selectedAccount) {
-          throw new Error("Account not found");
+          throw new Error("Account not found")
         }
 
         const pathKey = await getPathKey(chainId, selectedAccount.index);
@@ -49,7 +37,7 @@ const useExportPKEmbed = () => {
     return () => {
       window.removeEventListener('message', handleMessage);
     };
-  }, []);
+  }, [accounts]);
 };
 
 export default useExportPKEmbed;

src/screens/EditNetwork.tsx

@@ -10,9 +10,8 @@ import {
 } from "@react-navigation/native-stack";
 import { useNavigation } from "@react-navigation/native";
 
-import { setInternetCredentials } from "../utils/key-store";
 import { StackParamsList } from "../types";
-import { retrieveNetworksData } from "../utils/accounts";
+import { getNetworks, updateNetworks } from "../utils/eyre-client";
 import { useNetworks } from "../context/NetworksContext";
 import {
   COSMOS,
@@ -74,7 +73,7 @@ const EditNetwork = ({ route }: EditNetworkProps) => {
 
   const submit = useCallback(
     async (data: z.infer<typeof networksFormDataSchema>) => {
-      const retrievedNetworksData = await retrieveNetworksData();
+      const retrievedNetworksData = await getNetworks();
       const { type, ...dataWithoutType } = data;
       const newNetworkData = { ...networkData, ...dataWithoutType };
       const index = retrievedNetworksData.findIndex(
@@ -83,11 +82,7 @@ const EditNetwork = ({ route }: EditNetworkProps) => {
 
       retrievedNetworksData.splice(index, 1, newNetworkData);
 
-      await setInternetCredentials(
+      await updateNetworks(retrievedNetworksData);
-        "networks",
-        "_",
-        JSON.stringify(retrievedNetworksData),
-      );
 
       setNetworksData(retrievedNetworksData);
 

src/utils/__tests__/eyre-client.test.ts

@@ -0,0 +1,457 @@
+/**
+ * Tests for eyre-client.ts — the Eyre HTTP client for %zenith agent.
+ *
+ * Mocks: global fetch, EventSource
+ * Strategy: jest.resetModules() + dynamic import per test group for clean
+ * module-level state (channelUid, cachedShipName, messageId, pendingPokes).
+ */
+
+type EyreClient = typeof import('../eyre-client');
+
+// ---------------------------------------------------------------------------
+//  Mock EventSource
+// ---------------------------------------------------------------------------
+
+type ESListener = (ev: MessageEvent) => void;
+type ESErrorListener = (ev: Event) => void;
+
+class MockEventSource {
+  static instance: MockEventSource | null = null;
+
+  url: string;
+  withCredentials: boolean;
+  private listeners: Record<string, Array<ESListener | ESErrorListener>> = {};
+  close = jest.fn();
+
+  constructor(url: string, opts?: { withCredentials?: boolean }) {
+    this.url = url;
+    this.withCredentials = opts?.withCredentials ?? false;
+    MockEventSource.instance = this;
+  }
+
+  addEventListener(type: string, cb: ESListener | ESErrorListener) {
+    (this.listeners[type] ??= []).push(cb);
+  }
+
+  /** Simulate an SSE message event */
+  emit(type: string, data: unknown, lastEventId = '1') {
+    for (const cb of this.listeners[type] ?? []) {
+      (cb as ESListener)({
+        data: JSON.stringify(data),
+        lastEventId,
+      } as MessageEvent);
+    }
+  }
+
+  emitError() {
+    for (const cb of this.listeners['error'] ?? []) {
+      (cb as ESErrorListener)(new Event('error'));
+    }
+  }
+}
+
+// Install MockEventSource globally before any module loads
+(global as any).EventSource = MockEventSource;
+
+// ---------------------------------------------------------------------------
+//  Helpers
+// ---------------------------------------------------------------------------
+
+function mockFetchResponses(
+  ...responses: Array<{ status: number; body?: unknown; text?: string }>
+) {
+  const impl = jest.fn();
+  for (const r of responses) {
+    impl.mockResolvedValueOnce({
+      ok: r.status >= 200 && r.status < 300,
+      status: r.status,
+      statusText: r.status === 404 ? 'Not Found' : 'OK',
+      json: () => Promise.resolve(r.body),
+      text: () => Promise.resolve(r.text ?? ''),
+    });
+  }
+  global.fetch = impl;
+  return impl;
+}
+
+async function loadModule(): Promise<EyreClient> {
+  jest.resetModules();
+  MockEventSource.instance = null;
+  return import('../eyre-client');
+}
+
+// ---------------------------------------------------------------------------
+//  Tests
+// ---------------------------------------------------------------------------
+
+describe('eyre-client', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  // =========================================================================
+  //  scryGet
+  // =========================================================================
+
+  describe('scryGet', () => {
+    it('returns parsed JSON on 200', async () => {
+      const { scryGet } = await loadModule();
+      mockFetchResponses({ status: 200, body: { mnemonic: 'foo bar' } });
+
+      const result = await scryGet('/wallet/mnemonic');
+
+      expect(result).toEqual({ mnemonic: 'foo bar' });
+      expect(global.fetch).toHaveBeenCalledWith(
+        '/~/scry/zenith/wallet/mnemonic.json',
+        { credentials: 'include' },
+      );
+    });
+
+    it('returns null on 404', async () => {
+      const { scryGet } = await loadModule();
+      mockFetchResponses({ status: 404 });
+
+      const result = await scryGet('/wallet/nonexistent');
+
+      expect(result).toBeNull();
+    });
+
+    it('throws on server error', async () => {
+      const { scryGet } = await loadModule();
+      mockFetchResponses({ status: 500 });
+
+      await expect(scryGet('/wallet/broken')).rejects.toThrow(
+        'Scry /wallet/broken failed: 500',
+      );
+    });
+  });
+
+  // =========================================================================
+  //  pokeAction
+  // =========================================================================
+
+  describe('pokeAction', () => {
+    it('sends correct channel PUT body and resolves on ack', async () => {
+      const { pokeAction } = await loadModule();
+
+      // First fetch: getShipName() → /~/host
+      // Second fetch: channel PUT
+      // Third fetch: ack PUT (from EventSource handler)
+      const fetchMock = mockFetchResponses(
+        { status: 200, text: '~sampel-palnet' },
+        { status: 200 },
+        { status: 200 },
+      );
+
+      const pokePromise = pokeAction('json', { action: 'test' });
+
+      // Wait for fetch calls to settle
+      await new Promise((r) => setTimeout(r, 10));
+
+      // Verify channel PUT body
+      expect(fetchMock).toHaveBeenCalledTimes(2);
+      const putCall = fetchMock.mock.calls[1];
+      expect(putCall[0]).toMatch(/^\/~\/channel\/wallet-\d+$/);
+      expect(putCall[1].method).toBe('PUT');
+
+      const putBody = JSON.parse(putCall[1].body);
+      expect(putBody).toHaveLength(1);
+      expect(putBody[0]).toMatchObject({
+        action: 'poke',
+        ship: '~sampel-palnet',
+        app: 'zenith',
+        mark: 'json',
+        json: { action: 'test' },
+      });
+
+      // Simulate poke ack from EventSource
+      const es = MockEventSource.instance!;
+      es.emit('message', { response: 'poke', id: putBody[0].id, ok: 'ok' });
+
+      await expect(pokePromise).resolves.toBeUndefined();
+    });
+
+    it('rejects on poke nack', async () => {
+      const { pokeAction } = await loadModule();
+
+      mockFetchResponses(
+        { status: 200, text: '~zod' },
+        { status: 200 },
+        { status: 200 },
+      );
+
+      const pokePromise = pokeAction('json', { action: 'bad' });
+      await new Promise((r) => setTimeout(r, 10));
+
+      const putBody = JSON.parse(
+        (global.fetch as jest.Mock).mock.calls[1][1].body,
+      );
+      const es = MockEventSource.instance!;
+      es.emit('message', {
+        response: 'poke',
+        id: putBody[0].id,
+        ok: 'err',
+        err: 'Invalid mark',
+      });
+
+      await expect(pokePromise).rejects.toThrow('Invalid mark');
+    });
+
+    it('rejects when channel PUT fails', async () => {
+      const { pokeAction } = await loadModule();
+
+      mockFetchResponses(
+        { status: 200, text: '~zod' },
+        { status: 500 },
+      );
+
+      await expect(
+        pokeAction('json', { action: 'fail' }),
+      ).rejects.toThrow('Channel PUT failed: 500');
+    });
+
+    it('rejects all pending pokes on EventSource error', async () => {
+      const { pokeAction } = await loadModule();
+
+      mockFetchResponses(
+        { status: 200, text: '~zod' },
+        { status: 200 },
+      );
+
+      const pokePromise = pokeAction('json', { action: 'x' });
+      await new Promise((r) => setTimeout(r, 10));
+
+      MockEventSource.instance!.emitError();
+
+      await expect(pokePromise).rejects.toThrow('Eyre channel disconnected');
+    });
+  });
+
+  // =========================================================================
+  //  getWalletData (compatibility layer)
+  // =========================================================================
+
+  describe('getWalletData', () => {
+    it('delegates mnemonicServer to scry /wallet/mnemonic', async () => {
+      const { getWalletData } = await loadModule();
+      mockFetchResponses({ status: 200, body: { mnemonic: 'test phrase' } });
+
+      const result = await getWalletData('mnemonicServer');
+
+      expect(result).toBe('test phrase');
+      expect(global.fetch).toHaveBeenCalledWith(
+        '/~/scry/zenith/wallet/mnemonic.json',
+        { credentials: 'include' },
+      );
+    });
+
+    it('returns null when no mnemonic exists', async () => {
+      const { getWalletData } = await loadModule();
+      mockFetchResponses({ status: 404 });
+
+      expect(await getWalletData('mnemonicServer')).toBeNull();
+    });
+
+    it('delegates networks to scry /wallet/networks', async () => {
+      const { getWalletData } = await loadModule();
+      const networks = [{ networkId: 'zenith-1', networkName: 'Zenith' }];
+      mockFetchResponses({ status: 200, body: networks });
+
+      const result = await getWalletData('networks');
+
+      expect(result).toBe(JSON.stringify(networks));
+      expect(global.fetch).toHaveBeenCalledWith(
+        '/~/scry/zenith/wallet/networks.json',
+        { credentials: 'include' },
+      );
+    });
+
+    it('returns null when no networks exist', async () => {
+      const { getWalletData } = await loadModule();
+      mockFetchResponses({ status: 200, body: [] });
+
+      expect(await getWalletData('networks')).toBeNull();
+    });
+
+    it('delegates accounts/eip155:1/0 to scry /wallet/account/eip155:1/0', async () => {
+      const { getWalletData } = await loadModule();
+      const account = {
+        index: 0,
+        hdPath: "m/44'/60'/0'/0/0",
+        privKey: '0xabc',
+        pubKey: '0xdef',
+        address: '0x123',
+      };
+      mockFetchResponses({ status: 200, body: account });
+
+      const result = await getWalletData('accounts/eip155:1/0');
+
+      expect(result).toBe(
+        `${account.hdPath},${account.privKey},${account.pubKey},${account.address}`,
+      );
+      expect(global.fetch).toHaveBeenCalledWith(
+        '/~/scry/zenith/wallet/account/eip155:1/0.json',
+        { credentials: 'include' },
+      );
+    });
+
+    it('returns null for nonexistent account', async () => {
+      const { getWalletData } = await loadModule();
+      mockFetchResponses({ status: 404 });
+
+      expect(await getWalletData('accounts/eip155:1/99')).toBeNull();
+    });
+
+    it('delegates accountIndices to scry /wallet/accounts', async () => {
+      const { getWalletData } = await loadModule();
+      const accounts = [
+        { index: 0, pubKey: 'a', address: 'b', hdPath: 'c' },
+        { index: 1, pubKey: 'd', address: 'e', hdPath: 'f' },
+      ];
+      mockFetchResponses({ status: 200, body: accounts });
+
+      const result = await getWalletData('accountIndices/cosmos:zenith-1');
+
+      expect(result).toBe('0,1');
+    });
+
+    it('delegates addAccountCounter to scry next-account-id', async () => {
+      const { getWalletData } = await loadModule();
+      mockFetchResponses({ status: 200, body: { id: 3 } });
+
+      const result = await getWalletData('addAccountCounter/cosmos:zenith-1');
+
+      expect(result).toBe('3');
+    });
+
+    it('returns null for unknown key', async () => {
+      const { getWalletData } = await loadModule();
+
+      expect(await getWalletData('unknown-key')).toBeNull();
+    });
+  });
+
+  // =========================================================================
+  //  setWalletData (compatibility layer)
+  // =========================================================================
+
+  describe('setWalletData', () => {
+    it('delegates networks write to poke with update-networks action', async () => {
+      const { setWalletData } = await loadModule();
+      const networks = [{ networkId: 'zenith-1', networkName: 'Zenith' }];
+
+      // getShipName fetch, channel PUT, ack fetch
+      const fetchMock = mockFetchResponses(
+        { status: 200, text: '~zod' },
+        { status: 200 },
+        { status: 200 },
+      );
+
+      const promise = setWalletData('networks', JSON.stringify(networks));
+      await new Promise((r) => setTimeout(r, 10));
+
+      // Verify the poke body
+      const putBody = JSON.parse(fetchMock.mock.calls[1][1].body);
+      expect(putBody[0]).toMatchObject({
+        action: 'poke',
+        mark: 'json',
+        json: { action: 'update-networks', networks },
+      });
+
+      // Ack to resolve
+      MockEventSource.instance!.emit('message', {
+        response: 'poke',
+        id: putBody[0].id,
+        ok: 'ok',
+      });
+
+      await expect(promise).resolves.toBeUndefined();
+    });
+
+    it('throws on direct mnemonic write', async () => {
+      const { setWalletData } = await loadModule();
+
+      await expect(
+        setWalletData('mnemonicServer', 'some words'),
+      ).rejects.toThrow('Cannot set mnemonic directly');
+    });
+
+    it('throws on direct account write', async () => {
+      const { setWalletData } = await loadModule();
+
+      await expect(
+        setWalletData('accounts/eip155:1/0', 'data'),
+      ).rejects.toThrow('Direct write to');
+    });
+
+    it('throws on unknown key', async () => {
+      const { setWalletData } = await loadModule();
+
+      await expect(
+        setWalletData('unknown', 'data'),
+      ).rejects.toThrow('Unknown wallet data key');
+    });
+  });
+
+  // =========================================================================
+  //  deleteWalletData
+  // =========================================================================
+
+  describe('deleteWalletData', () => {
+    it('delegates mnemonicServer delete to resetWallet poke', async () => {
+      const { deleteWalletData } = await loadModule();
+
+      const fetchMock = mockFetchResponses(
+        { status: 200, text: '~zod' },
+        { status: 200 },
+        { status: 200 },
+      );
+
+      const promise = deleteWalletData('mnemonicServer');
+      await new Promise((r) => setTimeout(r, 10));
+
+      const putBody = JSON.parse(fetchMock.mock.calls[1][1].body);
+      expect(putBody[0].json).toEqual({ action: 'reset-wallet' });
+
+      MockEventSource.instance!.emit('message', {
+        response: 'poke',
+        id: putBody[0].id,
+        ok: 'ok',
+      });
+
+      await expect(promise).resolves.toBeUndefined();
+    });
+
+    it('is a no-op for account keys', async () => {
+      const { deleteWalletData } = await loadModule();
+
+      // Should resolve without making any fetch calls
+      await expect(
+        deleteWalletData('accounts/eip155:1/0'),
+      ).resolves.toBeUndefined();
+    });
+  });
+
+  // =========================================================================
+  //  closeChannel
+  // =========================================================================
+
+  describe('closeChannel', () => {
+    it('closes EventSource and rejects pending pokes', async () => {
+      const { pokeAction, closeChannel } = await loadModule();
+
+      mockFetchResponses(
+        { status: 200, text: '~zod' },
+        { status: 200 },
+      );
+
+      const pokePromise = pokeAction('json', { action: 'x' });
+      await new Promise((r) => setTimeout(r, 10));
+
+      closeChannel();
+
+      await expect(pokePromise).rejects.toThrow('Channel closed');
+      expect(MockEventSource.instance!.close).toHaveBeenCalled();
+    });
+  });
+});

src/utils/accounts.ts

@@ -7,106 +7,54 @@ import '@ethersproject/shims';
 import { utils } from 'ethers';
 import { HDNode } from 'ethers/lib/utils';
 
-import {
-  setInternetCredentials,
-  resetInternetCredentials,
-  getInternetCredentials,
-} from './key-store';
 import { Secp256k1HdWallet } from '@cosmjs/amino';
 import { AccountData } from '@cosmjs/proto-signing';
 import { stringToPath } from '@cosmjs/crypto';
 
 import { Account, NetworksDataState, NetworksFormData } from '../types';
-import {
-  getHDPath,
-  getPathKey,
-  resetKeyServers,
-  updateAccountIndices,
-} from './misc';
 import { COSMOS, EIP155 } from './constants';
+import * as eyre from './eyre-client';
+
+function splitNsChain(nsChain: string): [string, string] {
+  const i = nsChain.indexOf(':');
+  return [nsChain.slice(0, i), nsChain.slice(i + 1)];
+}
 
 const createWallet = async (
   networksData: NetworksDataState[],
   recoveryPhrase?: string,
 ): Promise<string> => {
   const mnemonic = recoveryPhrase ? recoveryPhrase : utils.entropyToMnemonic(utils.randomBytes(16));
-
+  await eyre.createWallet(networksData, mnemonic);
-  const hdNode = HDNode.fromMnemonic(mnemonic);
-  await setInternetCredentials('mnemonicServer', 'mnemonic', mnemonic);
-
-  await createWalletFromMnemonic(networksData, hdNode, mnemonic);
-
   return mnemonic;
 };
 
 const createWalletFromMnemonic = async (
   networksData: NetworksDataState[],
-  hdNode: HDNode,
+  _hdNode: HDNode,
   mnemonic: string
 ): Promise<void> => {
-  for (const network of networksData) {
+  // HD derivation delegated to agent — hdNode param unused
-    const hdPath = `m/44'/${network.coinType}'/0'/0/0`;
+  await eyre.createWallet(networksData, mnemonic);
-    const node = hdNode.derivePath(hdPath);
-    let address;
-
-    switch (network.namespace) {
-      case EIP155:
-        address = node.address;
-        break;
-
-      case COSMOS:
-        address = (
-          await getCosmosAccountByHDPath(mnemonic, hdPath, network.addressPrefix)
-        ).data.address;
-        break;
-
-      default:
-        throw new Error('Unsupported namespace');
-    }
-
-    const accountInfo = `${hdPath},${node.privateKey},${node.publicKey},${address}`;
-
-    await Promise.all([
-      setInternetCredentials(
-        `accounts/${network.namespace}:${network.chainId}/0`,
-        '_',
-        accountInfo,
-      ),
-      setInternetCredentials(
-        `addAccountCounter/${network.namespace}:${network.chainId}`,
-        '_',
-        '1',
-      ),
-      setInternetCredentials(
-        `accountIndices/${network.namespace}:${network.chainId}`,
-        '_',
-        '0',
-      ),
-    ]);
-  }
 };
 
 const addAccount = async (
   chainId: string,
 ): Promise<Account | undefined> => {
   try {
-    let selectedNetworkAccount
+    const networksData = await eyre.getNetworks();
-    const networksData = await retrieveNetworksData();
 
-    // Add account to all networks and return account for selected network
+    // Add account to all networks (agent handles derivation + counter)
     for (const network of networksData) {
-      const namespaceChainId = `${network.namespace}:${network.chainId}`;
+      await eyre.addAccount(network.namespace, network.chainId);
-      const id = await getNextAccountId(namespaceChainId);
-      const hdPath = getHDPath(namespaceChainId, `0'/0/${id}`);
-      const account = await addAccountFromHDPath(hdPath, network);
-      await updateAccountCounter(namespaceChainId, id);
-
-      if (network.chainId === chainId) {
-        selectedNetworkAccount = account;
-      }
     }
 
-    return selectedNetworkAccount;
+    // Return the new account for the selected network
+    const selectedNetwork = networksData.find(n => n.chainId === chainId);
+    if (!selectedNetwork) return;
+
+    const accounts = await eyre.getAccounts(selectedNetwork.namespace, chainId);
+    return accounts[accounts.length - 1];
   } catch (error) {
     console.error('Error creating account:', error);
   }
@@ -117,13 +65,8 @@ const addAccountsForNetwork = async (
   numberOfAccounts: number,
 ): Promise<void> => {
   try {
-    const namespaceChainId = `${network.namespace}:${network.chainId}`;
-
     for (let i = 0; i < numberOfAccounts; i++) {
-      const id = await getNextAccountId(namespaceChainId);
+      await eyre.addAccount(network.namespace, network.chainId);
-      const hdPath = getHDPath(namespaceChainId, `0'/0/${id}`);
-      await addAccountFromHDPath(hdPath, network);
-      await updateAccountCounter(namespaceChainId, id);
     }
   } catch (error) {
     console.error('Error creating account:', error);
@@ -135,26 +78,11 @@ const addAccountFromHDPath = async (
   networkData: NetworksDataState,
 ): Promise<Account | undefined> => {
   try {
-    const account = await accountInfoFromHDPath(hdPath, networkData);
+    // Agent derives from stored mnemonic using the given HD path
-    if (!account) {
+    await eyre.addAccountFromPath(networkData.namespace, networkData.chainId, hdPath);
-      throw new Error('Error while creating account');
-    }
 
-    const { privKey, pubKey, address } = account;
+    const accounts = await eyre.getAccounts(networkData.namespace, networkData.chainId);
-
+    return accounts[accounts.length - 1];
-    const namespaceChainId = `${networkData.namespace}:${networkData.chainId}`;
-
-    const index = (await updateAccountIndices(namespaceChainId)).index;
-
-    await Promise.all([
-      setInternetCredentials(
-        `accounts/${namespaceChainId}/${index}`,
-        '_',
-        `${hdPath},${privKey},${pubKey},${address}`,
-      ),
-    ]);
-
-    return { index, pubKey, address, hdPath };
   } catch (error) {
     console.error(error);
   }
@@ -163,160 +91,37 @@ const addAccountFromHDPath = async (
 const addNewNetwork = async (
   newNetworkData: NetworksFormData
 ): Promise<NetworksDataState[]> => {
-  const mnemonicServer = await getInternetCredentials("mnemonicServer");
+  await eyre.addNetwork(newNetworkData);
-  const mnemonic = mnemonicServer;
+  return eyre.getNetworks();
-
+};
-  if (!mnemonic) {
-    throw new Error("Mnemonic not found");
-  }
-
-  const hdNode = HDNode.fromMnemonic(mnemonic);
-
-  const hdPath = `m/44'/${newNetworkData.coinType}'/0'/0/0`;
-  const node = hdNode.derivePath(hdPath);
-  let address;
-
-  switch (newNetworkData.namespace) {
-    case EIP155:
-      address = node.address;
-      break;
-
-    case COSMOS:
-      address = (
-        await getCosmosAccountByHDPath(
-          mnemonic,
-          hdPath,
-          newNetworkData.addressPrefix,
-        )
-      ).data.address;
-      break;
-
-    default:
-      throw new Error("Unsupported namespace");
-  }
-
-  const accountInfo = `${hdPath},${node.privateKey},${node.publicKey},${address}`;
-
-  await Promise.all([
-    setInternetCredentials(
-      `accounts/${newNetworkData.namespace}:${newNetworkData.chainId}/0`,
-      "_",
-      accountInfo,
-    ),
-    setInternetCredentials(
-      `addAccountCounter/${newNetworkData.namespace}:${newNetworkData.chainId}`,
-      "_",
-      "1",
-    ),
-    setInternetCredentials(
-      `accountIndices/${newNetworkData.namespace}:${newNetworkData.chainId}`,
-      "_",
-      "0",
-    ),
-  ]);
-
-  const retrievedNetworksData = await storeNetworkData(newNetworkData);
-
-  // Get number of accounts in first network
-  const nextAccountId = await getNextAccountId(
-    `${retrievedNetworksData[0].namespace}:${retrievedNetworksData[0].chainId}`,
-  );
-
-  const selectedNetwork = retrievedNetworksData.find(
-    (network) => network.chainId === newNetworkData.chainId,
-  );
-
-  await addAccountsForNetwork(selectedNetwork!, nextAccountId - 1);
-
-  return retrievedNetworksData;
-}
 
 const storeNetworkData = async (
   networkData: NetworksFormData,
 ): Promise<NetworksDataState[]> => {
-  const networks = await getInternetCredentials('networks');
+  await eyre.addNetwork(networkData);
-  let retrievedNetworks = [];
+  return eyre.getNetworks();
-  if (networks) {
-    retrievedNetworks = JSON.parse(networks!);
-  }
-  let networkId = 0;
-  if (retrievedNetworks.length > 0) {
-    networkId = retrievedNetworks[retrievedNetworks.length - 1].networkId + 1;
-  }
-
-  const updatedNetworks: NetworksDataState[] = [
-    ...retrievedNetworks,
-    {
-      ...networkData,
-      networkId: String(networkId),
-    },
-  ];
-
-  await setInternetCredentials(
-    'networks',
-    '_',
-    JSON.stringify(updatedNetworks),
-  );
-
-  return updatedNetworks;
 };
 
 const retrieveNetworksData = async (): Promise<NetworksDataState[]> => {
-  const networks = await getInternetCredentials('networks');
+  return eyre.getNetworks();
-
-  if (!networks) {
-    return [];
-  }
-
-  const parsedNetworks: NetworksDataState[] = JSON.parse(networks);
-
-  return parsedNetworks;
 };
 
 export const retrieveAccountsForNetwork = async (
   namespaceChainId: string,
-  accountsIndices: string,
+  _accountsIndices?: string,
 ): Promise<Account[]> => {
-  const accountsIndexArray = accountsIndices.split(',');
+  const [ns, chain] = splitNsChain(namespaceChainId);
-
+  return eyre.getAccounts(ns, chain);
-  const loadedAccounts = await Promise.all(
-    accountsIndexArray.map(async i => {
-      const { address, path, pubKey } = await getPathKey(
-        namespaceChainId,
-        Number(i),
-      );
-
-      const account: Account = {
-        index: Number(i),
-        pubKey,
-        address,
-        hdPath: path,
-      };
-
-      return account;
-    }),
-  );
-
-  return loadedAccounts;
 };
 
 const retrieveAccounts = async (
   currentNetworkData: NetworksDataState,
 ): Promise<Account[] | undefined> => {
-  const accountIndicesServer = await getInternetCredentials(
+  const accounts = await eyre.getAccounts(
-    `accountIndices/${currentNetworkData.namespace}:${currentNetworkData.chainId}`,
+    currentNetworkData.namespace,
+    currentNetworkData.chainId,
   );
-  const accountIndices = accountIndicesServer;
+  return accounts.length > 0 ? accounts : undefined;
-  if (!accountIndices) {
-    return;
-  }
-
-  const loadedAccounts = await retrieveAccountsForNetwork(
-    `${currentNetworkData.namespace}:${currentNetworkData.chainId}`,
-    accountIndices,
-  )
-
-  return loadedAccounts;
 };
 
 const retrieveSingleAccount = async (
@@ -324,37 +129,13 @@ const retrieveSingleAccount = async (
   chainId: string,
   address: string,
 ) => {
-  let loadedAccounts;
+  const accounts = await eyre.getAccounts(namespace, chainId);
-
+  return accounts.find(account => account.address === address);
-  const accountIndicesServer = await getInternetCredentials(
-    `accountIndices/${namespace}:${chainId}`,
-  );
-  const accountIndices = accountIndicesServer;
-
-  if (!accountIndices) {
-    throw new Error('Indices for given chain not found');
-  }
-
-  loadedAccounts = await retrieveAccountsForNetwork(
-    `${namespace}:${chainId}`,
-    accountIndices,
-  );
-
-  if (!loadedAccounts) {
-    throw new Error('Accounts for given chain not found');
-  }
-
-  return loadedAccounts.find(account => account.address === address);
 };
 
 const resetWallet = async () => {
   try {
-    await Promise.all([
+    await eyre.resetWallet();
-      resetInternetCredentials('mnemonicServer'),
-      resetKeyServers(EIP155),
-      resetKeyServers(COSMOS),
-      setInternetCredentials('networks', '_', JSON.stringify([])),
-    ]);
   } catch (error) {
     console.error('Error resetting wallet:', error);
     throw error;
@@ -367,12 +148,13 @@ const accountInfoFromHDPath = async (
 ): Promise<
   { privKey: string; pubKey: string; address: string } | undefined
 > => {
-  const mnemonicStore = await getInternetCredentials('mnemonicServer');
+  // Phase 1: still derives in browser for API compat.
-  if (!mnemonicStore) {
+  // Phase 2: this moves to the agent entirely.
+  const mnemonic = await eyre.getMnemonic();
+  if (!mnemonic) {
     throw new Error('Mnemonic not found!');
   }
 
-  const mnemonic = mnemonicStore;
   const hdNode = HDNode.fromMnemonic(mnemonic);
   const node = hdNode.derivePath(hdPath);
 
@@ -397,36 +179,15 @@ const accountInfoFromHDPath = async (
 };
 
 const getNextAccountId = async (namespaceChainId: string): Promise<number> => {
-  const idStore = await getInternetCredentials(
+  const [ns, chain] = splitNsChain(namespaceChainId);
-    `addAccountCounter/${namespaceChainId}`,
+  return eyre.getNextAccountId(ns, chain);
-  );
-  if (!idStore) {
-    throw new Error('Account id not found');
-  }
-
-  const accountCounter = idStore;
-  const nextCounter = Number(accountCounter);
-  return nextCounter;
 };
 
 const updateAccountCounter = async (
-  namespaceChainId: string,
+  _namespaceChainId: string,
-  id: number,
+  _id: number,
 ): Promise<void> => {
-  const idStore = await getInternetCredentials(
+  // Agent manages account counter atomically via addAccount poke.
-    `addAccountCounter/${namespaceChainId}`,
-  );
-  if (!idStore) {
-    throw new Error('Account id not found');
-  }
-
-  const updatedCounter = String(id + 1);
-  await resetInternetCredentials(`addAccountCounter/${namespaceChainId}`);
-  await setInternetCredentials(
-    `addAccountCounter/${namespaceChainId}`,
-    '_',
-    updatedCounter,
-  );
 };
 
 const getCosmosAccountByHDPath = async (
@@ -448,52 +209,13 @@ const getCosmosAccountByHDPath = async (
 const checkNetworkForChainID = async (
   chainId: string,
 ): Promise<boolean> => {
-  const networks = await getInternetCredentials('networks');
+  const networks = await eyre.getNetworks();
-
+  return networks.some((network) => network.chainId === chainId);
-  if (!networks) {
-    return false;
-  }
-
-  const networksData: NetworksFormData[] = JSON.parse(networks);
-
-  return networksData.some((network) => network.chainId === chainId);
-}
-
-const updateNetworkRpcUrl = async (
-  chainId: string,
-  rpcUrl: string,
-): Promise<NetworksDataState[]> => {
-  const networks = await getInternetCredentials('networks');
-
-  if (!networks) {
-    throw new Error('Networks not found');
-  }
-
-  const networksData: NetworksDataState[] = JSON.parse(networks);
-
-  const networkIndex = networksData.findIndex((network) => network.chainId === chainId);
-
-  if (networkIndex === -1) {
-    throw new Error('Network not found');
-  }
-
-  networksData[networkIndex].rpcUrl = rpcUrl;
-
-  await setInternetCredentials(
-    'networks',
-    '_',
-    JSON.stringify(networksData),
-  );
-
-  return networksData;
 }
 
 const isWalletCreated = async (
 ): Promise<boolean> => {
-  const mnemonicServer = await getInternetCredentials("mnemonicServer");
+  return eyre.walletExists();
-  const mnemonic = mnemonicServer;
-
-  return mnemonic !== null;
 };
 
 export {
@@ -512,6 +234,5 @@ export {
   getCosmosAccountByHDPath,
   addNewNetwork,
   checkNetworkForChainID,
-  isWalletCreated,
+  isWalletCreated
-  updateNetworkRpcUrl
 };

src/utils/eyre-client.ts

@@ -0,0 +1,441 @@
+/**
+ * Eyre HTTP client for communicating with the %zenith agent.
+ *
+ * Replaces localStorage (key-store.ts) with Urbit ship storage via:
+ *   - Scry: GET /~/scry/zenith/{path}.json
+ *   - Poke: PUT /~/channel/{uid} with channel API
+ *
+ * Three layers:
+ *   1. Base helpers      — scryGet(), pokeAction()
+ *   2. Typed API         — getNetworks(), createWallet(), etc.
+ *   3. Compatibility     — getWalletData(), setWalletData(), deleteWalletData()
+ */
+
+import { Account, NetworksDataState, NetworksFormData } from '../types';
+
+// ============================================================
+//  Types
+// ============================================================
+
+export interface AccountWithKeys extends Account {
+  privKey: string;
+}
+
+interface PendingPoke {
+  resolve: () => void;
+  reject: (err: Error) => void;
+}
+
+// ============================================================
+//  Channel state
+// ============================================================
+
+const APP_NAME = 'zenith';
+const POKE_TIMEOUT_MS = 30_000;
+
+let channelUid: string | null = null;
+let eventSource: EventSource | null = null;
+let messageId = 0;
+let cachedShipName: string | null = null;
+const pendingPokes = new Map<number, PendingPoke>();
+
+// ============================================================
+//  1. Base helpers
+// ============================================================
+
+/**
+ * Discover the ship name. Uses /~/host (same as @urbit/http-api),
+ * with fallback to the Eyre auth cookie.
+ */
+async function getShipName(): Promise<string> {
+  if (cachedShipName) return cachedShipName;
+
+  const res = await fetch('/~/host', { credentials: 'include' });
+  if (res.ok) {
+    cachedShipName = await res.text();
+    return cachedShipName;
+  }
+
+  const match = document.cookie.match(/urbauth-(~[a-z-]+)=/);
+  if (match) {
+    cachedShipName = match[1];
+    return cachedShipName;
+  }
+
+  throw new Error('Cannot determine ship name — not authenticated with Eyre');
+}
+
+function getChannelUrl(): string {
+  if (!channelUid) {
+    channelUid = `wallet-${Date.now()}`;
+  }
+  return `/~/channel/${channelUid}`;
+}
+
+/**
+ * Open the SSE event source for receiving poke acks.
+ * Eyre buffers events until the client connects, so it's safe to open
+ * after the first PUT.
+ */
+function openEventSource(): void {
+  if (eventSource) return;
+
+  eventSource = new EventSource(getChannelUrl(), {
+    withCredentials: true,
+  });
+
+  eventSource.addEventListener('message', (ev: MessageEvent) => {
+    const data = JSON.parse(ev.data);
+
+    if (data.response === 'poke') {
+      const pending = pendingPokes.get(data.id);
+      if (pending) {
+        if (data.ok === 'ok') {
+          pending.resolve();
+        } else {
+          pending.reject(new Error(data.err ?? 'Poke rejected by agent'));
+        }
+        pendingPokes.delete(data.id);
+      }
+    }
+
+    // Acknowledge every SSE event to keep the channel alive
+    const ackId = ++messageId;
+    fetch(getChannelUrl(), {
+      method: 'PUT',
+      credentials: 'include',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify([{
+        id: ackId,
+        action: 'ack',
+        'event-id': Number(ev.lastEventId),
+      }]),
+    });
+  });
+
+  eventSource.addEventListener('error', () => {
+    for (const [, pending] of pendingPokes) {
+      pending.reject(new Error('Eyre channel disconnected'));
+    }
+    pendingPokes.clear();
+    eventSource?.close();
+    eventSource = null;
+    channelUid = null;
+  });
+}
+
+/**
+ * Scry the %zenith agent. Returns parsed JSON, or null on 404.
+ *
+ * @param path - Scry path starting with /, e.g. '/wallet/networks'
+ */
+async function scryGet<T>(path: string): Promise<T | null> {
+  const res = await fetch(`/~/scry/${APP_NAME}${path}.json`, {
+    credentials: 'include',
+  });
+  if (res.status === 404) return null;
+  if (!res.ok) {
+    throw new Error(`Scry ${path} failed: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+
+/**
+ * Poke the %zenith agent and wait for the ack/nack.
+ *
+ * @param mark - Poke mark, e.g. 'json' or 'wallet-action'
+ * @param json - Poke payload
+ */
+async function pokeAction(mark: string, json: unknown): Promise<void> {
+  const shipName = await getShipName();
+  const id = ++messageId;
+
+  const ackPromise = new Promise<void>((resolve, reject) => {
+    pendingPokes.set(id, { resolve, reject });
+    setTimeout(() => {
+      if (pendingPokes.has(id)) {
+        pendingPokes.delete(id);
+        reject(new Error(`Poke timed out after ${POKE_TIMEOUT_MS}ms`));
+      }
+    }, POKE_TIMEOUT_MS);
+  });
+
+  const res = await fetch(getChannelUrl(), {
+    method: 'PUT',
+    credentials: 'include',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify([{
+      id,
+      action: 'poke',
+      ship: shipName,
+      app: APP_NAME,
+      mark,
+      json,
+    }]),
+  });
+
+  if (!res.ok) {
+    pendingPokes.delete(id);
+    throw new Error(`Channel PUT failed: ${res.status} ${res.statusText}`);
+  }
+
+  // Open SSE to receive ack (no-op if already open).
+  // Eyre buffers the ack until we connect.
+  openEventSource();
+
+  return ackPromise;
+}
+
+// ============================================================
+//  2. Typed API — Reads (scry)
+// ============================================================
+
+async function walletExists(): Promise<boolean> {
+  const data = await scryGet<{ exists: boolean }>('/wallet/exists');
+  return data?.exists ?? false;
+}
+
+async function getMnemonic(): Promise<string | null> {
+  const data = await scryGet<{ mnemonic: string }>('/wallet/mnemonic');
+  return data?.mnemonic ?? null;
+}
+
+async function getNetworks(): Promise<NetworksDataState[]> {
+  return (await scryGet<NetworksDataState[]>('/wallet/networks')) ?? [];
+}
+
+async function getAccounts(
+  namespace: string,
+  chainId: string,
+): Promise<Account[]> {
+  return (
+    (await scryGet<Account[]>(`/wallet/accounts/${namespace}:${chainId}`)) ?? []
+  );
+}
+
+async function getAccount(
+  namespace: string,
+  chainId: string,
+  index: number,
+): Promise<AccountWithKeys | null> {
+  return scryGet<AccountWithKeys>(
+    `/wallet/account/${namespace}:${chainId}/${index}`,
+  );
+}
+
+async function getNextAccountId(
+  namespace: string,
+  chainId: string,
+): Promise<number> {
+  const data = await scryGet<{ id: number }>(
+    `/wallet/next-account-id/${namespace}:${chainId}`,
+  );
+  return data?.id ?? 0;
+}
+
+// ============================================================
+//  2. Typed API — Writes (poke)
+// ============================================================
+
+async function createWallet(
+  networks: NetworksFormData[],
+  mnemonic?: string,
+): Promise<void> {
+  const payload: Record<string, unknown> = {
+    action: 'create-wallet',
+    networks,
+  };
+  if (mnemonic) {
+    payload.mnemonic = mnemonic;
+  }
+  return pokeAction('json', payload);
+}
+
+async function addAccount(
+  namespace: string,
+  chainId: string,
+): Promise<void> {
+  return pokeAction('json', {
+    action: 'add-account',
+    namespace,
+    'chain-id': chainId,
+  });
+}
+
+async function updateNetworks(
+  networks: NetworksDataState[],
+): Promise<void> {
+  return pokeAction('json', {
+    action: 'update-networks',
+    networks,
+  });
+}
+
+async function addNetwork(network: NetworksFormData): Promise<void> {
+  return pokeAction('json', {
+    action: 'add-network',
+    network,
+  });
+}
+
+async function addAccountFromPath(
+  namespace: string,
+  chainId: string,
+  hdPath: string,
+): Promise<void> {
+  return pokeAction('json', {
+    action: 'add-account-from-path',
+    namespace,
+    'chain-id': chainId,
+    'hd-path': hdPath,
+  });
+}
+
+async function resetWallet(): Promise<void> {
+  return pokeAction('json', { action: 'reset-wallet' });
+}
+
+// ============================================================
+//  3. Drop-in compatibility layer
+//
+//  Maps the old localStorage key patterns to the typed API so
+//  existing callers can migrate incrementally in Phase 2.
+// ============================================================
+
+const ACCOUNTS_RE = /^accounts\/([^/]+)\/(\d+)$/;
+const INDICES_RE = /^accountIndices\/(.+)$/;
+const COUNTER_RE = /^addAccountCounter\/(.+)$/;
+
+function splitNsChain(nsChain: string): [string, string] {
+  const i = nsChain.indexOf(':');
+  return [nsChain.slice(0, i), nsChain.slice(i + 1)];
+}
+
+/**
+ * Drop-in replacement for getInternetCredentials(key).
+ * Returns a string matching the old localStorage value format, or null.
+ */
+async function getWalletData(key: string): Promise<string | null> {
+  if (key === 'mnemonicServer') {
+    return getMnemonic();
+  }
+
+  if (key === 'networks') {
+    const networks = await getNetworks();
+    return networks.length > 0 ? JSON.stringify(networks) : null;
+  }
+
+  const accountMatch = key.match(ACCOUNTS_RE);
+  if (accountMatch) {
+    const [ns, chain] = splitNsChain(accountMatch[1]);
+    const account = await getAccount(ns, chain, Number(accountMatch[2]));
+    if (!account) return null;
+    return `${account.hdPath},${account.privKey},${account.pubKey},${account.address}`;
+  }
+
+  const indicesMatch = key.match(INDICES_RE);
+  if (indicesMatch) {
+    const [ns, chain] = splitNsChain(indicesMatch[1]);
+    const accounts = await getAccounts(ns, chain);
+    if (accounts.length === 0) return null;
+    return accounts.map((a) => a.index).join(',');
+  }
+
+  const counterMatch = key.match(COUNTER_RE);
+  if (counterMatch) {
+    const [ns, chain] = splitNsChain(counterMatch[1]);
+    const id = await getNextAccountId(ns, chain);
+    return String(id);
+  }
+
+  return null;
+}
+
+/**
+ * Drop-in replacement for setInternetCredentials(key, _, value).
+ * Only the `networks` key supports direct writes — account mutations
+ * should use the typed API (createWallet, addAccount).
+ */
+async function setWalletData(key: string, value: string): Promise<void> {
+  if (key === 'networks') {
+    const networks: NetworksDataState[] = JSON.parse(value);
+    return updateNetworks(networks);
+  }
+
+  if (key === 'mnemonicServer') {
+    throw new Error(
+      'Cannot set mnemonic directly — use createWallet() instead',
+    );
+  }
+
+  if (ACCOUNTS_RE.test(key) || INDICES_RE.test(key) || COUNTER_RE.test(key)) {
+    throw new Error(
+      `Direct write to '${key}' not supported — use createWallet() or addAccount()`,
+    );
+  }
+
+  throw new Error(`Unknown wallet data key: ${key}`);
+}
+
+/**
+ * Drop-in replacement for resetInternetCredentials(key).
+ * Individual account key deletion is a no-op — the agent manages
+ * account lifecycle atomically via resetWallet().
+ */
+async function deleteWalletData(key: string): Promise<void> {
+  if (key === 'mnemonicServer') {
+    return resetWallet();
+  }
+  // Account-related keys are managed atomically by the agent.
+  // Individual deletes are no-ops since resetWallet() handles cleanup.
+}
+
+// ============================================================
+//  4. Channel lifecycle
+// ============================================================
+
+function closeChannel(): void {
+  if (eventSource) {
+    eventSource.close();
+    eventSource = null;
+  }
+  for (const [, pending] of pendingPokes) {
+    pending.reject(new Error('Channel closed'));
+  }
+  pendingPokes.clear();
+  channelUid = null;
+}
+
+// ============================================================
+//  Exports
+// ============================================================
+
+export {
+  // Base helpers
+  scryGet,
+  pokeAction,
+
+  // Typed API — reads
+  walletExists,
+  getMnemonic,
+  getNetworks,
+  getAccounts,
+  getAccount,
+  getNextAccountId,
+
+  // Typed API — writes
+  createWallet,
+  addAccount,
+  updateNetworks,
+  addNetwork,
+  addAccountFromPath,
+  resetWallet,
+
+  // Compatibility layer (Phase 1 drop-in for key-store.ts)
+  getWalletData,
+  setWalletData,
+  deleteWalletData,
+
+  // Lifecycle
+  closeChannel,
+};

src/utils/key-store.ts

@@ -1,3 +1,8 @@
+/**
+ * @deprecated Use eyre-client.ts instead. This module will be removed in Phase 2.
+ * All consumers have been migrated to eyre-client.ts typed API.
+ */
+
 const setInternetCredentials = (name:string, username:string, password:string) => {
   localStorage.setItem(name, password);
 };

src/utils/misc.ts

@@ -9,20 +9,23 @@ import { stringToPath } from '@cosmjs/crypto';
 import '@ethersproject/shims';
 
 import {
-  getInternetCredentials,
+  getMnemonic as eyreGetMnemonic,
-  resetInternetCredentials,
+  getAccounts,
-  setInternetCredentials,
+  getAccount,
-} from './key-store';
+} from './eyre-client';
 import { EIP155 } from './constants';
-import { NetworksDataState } from '../types';
+
+function splitNsChain(namespaceChainId: string): [string, string] {
+  const i = namespaceChainId.indexOf(':');
+  return [namespaceChainId.slice(0, i), namespaceChainId.slice(i + 1)];
+}
 
 const getMnemonic = async (): Promise<string> => {
-  const mnemonicStore = await getInternetCredentials('mnemonicServer');
+  const mnemonic = await eyreGetMnemonic();
-  if (!mnemonicStore) {
+  if (!mnemonic) {
     throw new Error('Mnemonic not found!');
   }
 
-  const mnemonic = mnemonicStore;
   return mnemonic;
 };
 
@@ -53,22 +56,19 @@ const getPathKey = async (
   pubKey: string;
   address: string;
 }> => {
-  const pathKeyStore = await getInternetCredentials(
+  const [ns, chain] = splitNsChain(namespaceChainId);
-    `accounts/${namespaceChainId}/${accountId}`,
+  const account = await getAccount(ns, chain, accountId);
-  );
 
-  if (!pathKeyStore) {
+  if (!account) {
-    throw new Error('Error while fetching counter');
+    throw new Error('Error while fetching account');
   }
 
-  const pathKeyVal = pathKeyStore;
+  return {
-  const pathkey = pathKeyVal.split(',');
+    path: account.hdPath,
-  const path = pathkey[0];
+    privKey: account.privKey,
-  const privKey = pathkey[1];
+    pubKey: account.pubKey,
-  const pubKey = pathkey[2];
+    address: account.address,
-  const address = pathkey[3];
+  };
-
-  return { path, privKey, pubKey, address };
 };
 
 const getAccountIndices = async (
@@ -78,75 +78,35 @@ const getAccountIndices = async (
   indices: number[];
   index: number;
 }> => {
-  const counterStore = await getInternetCredentials(
+  const [ns, chain] = splitNsChain(namespaceChainId);
-    `accountIndices/${namespaceChainId}`,
+  const accounts = await getAccounts(ns, chain);
-  );
 
-  if (!counterStore) {
+  if (accounts.length === 0) {
-    throw new Error('Error while fetching counter');
+    throw new Error('Error while fetching accounts');
   }
 
-  let accountIndices = counterStore;
+  const indices = accounts.map(a => a.index);
-  const indices = accountIndices.split(',').map(Number);
+  const maxIndex = Math.max(...indices);
-  const index = indices[indices.length - 1] + 1;
 
-  return { accountIndices, indices, index };
+  return {
+    accountIndices: indices.join(','),
+    indices,
+    index: maxIndex + 1,
+  };
 };
 
 const updateAccountIndices = async (
   namespaceChainId: string,
 ): Promise<{ accountIndices: string; index: number }> => {
-  const accountIndicesData = await getAccountIndices(namespaceChainId);
+  // Agent manages account indices atomically via addAccount poke.
-  const accountIndices = accountIndicesData.accountIndices;
+  // This reads current state for callers that still expect the old return shape.
-  const index = accountIndicesData.index;
+  const data = await getAccountIndices(namespaceChainId);
-  const updatedAccountIndices = `${accountIndices},${index.toString()}`;
+  return { accountIndices: data.accountIndices, index: data.index };
-
-  await resetInternetCredentials(`accountIndices/${namespaceChainId}`);
-  await setInternetCredentials(
-    `accountIndices/${namespaceChainId}`,
-    '_',
-    updatedAccountIndices,
-  );
-
-  return { accountIndices: updatedAccountIndices, index };
 };
 
-const resetKeyServers = async (namespace: string) => {
+const resetKeyServers = async (_namespace: string) => {
-  const networksServer = await getInternetCredentials('networks');
+  // Agent manages account lifecycle atomically via resetWallet poke.
-  if (!networksServer) {
+  // Individual namespace cleanup is a no-op — resetWallet handles it all.
-    throw new Error('Networks not found.');
-  }
-
-  const networksData: NetworksDataState[] = JSON.parse(networksServer);
-  const filteredNetworks = networksData.filter(
-    network => network.namespace === namespace,
-  );
-
-  if (filteredNetworks.length === 0) {
-    throw new Error(`No networks found for namespace ${namespace}.`);
-  }
-
-  filteredNetworks.forEach(async network => {
-    const { chainId } = network;
-    const namespaceChainId = `${namespace}:${chainId}`;
-
-    const idStore = await getInternetCredentials(
-      `accountIndices/${namespaceChainId}`,
-    );
-    if (!idStore) {
-      throw new Error(`Account indices not found for ${namespaceChainId}.`);
-    }
-
-    const accountIds = idStore;
-    const ids = accountIds.split(',').map(Number);
-    const latestId = Math.max(...ids);
-
-    for (let i = 0; i <= latestId; i++) {
-      await resetInternetCredentials(`accounts/${namespaceChainId}/${i}`);
-    }
-    await resetInternetCredentials(`addAccountCounter/${namespaceChainId}`);
-    await resetInternetCredentials(`accountIndices/${namespaceChainId}`);
-  });
 };
 
 const sendMessage = (

urbit-files/desk.docket-0

@@ -0,0 +1,9 @@
+:~  title+'Zenith Wallet'
+    info+'Zenith blockchain wallet with WalletConnect support.'
+    color+0x4f.46e5
+    base+'zenith-wallet'
+    glob-http+['REPLACE_WITH_GLOB_URL' REPLACE_WITH_GLOB_HASH]
+    version+[0 0 1]
+    website+'https://git.vdb.to/LaconicNetwork/zenith-wallet-web'
+    license+'MIT'
+==

urbit-files/mar/ico.hoon

@@ -0,0 +1,14 @@
+::  mark for .ico icon files
+::
+|_  dat=octs
+++  grow
+  |%
+  ++  mime  [/image/x-icon dat]
+  --
+++  grab
+  |%
+  ++  mime  |=([p=mite q=octs] q)
+  ++  noun  |=(=noun ;;(octs noun))
+  --
+++  grad  %mime
+--

urbit-files/mar/map.hoon

@@ -0,0 +1,14 @@
+::  mark for .map files (source maps)
+::
+|_  dat=octs
+++  grow
+  |%
+  ++  mime  [/application/json dat]
+  --
+++  grab
+  |%
+  ++  mime  |=([p=mite q=octs] q)
+  ++  noun  |=(=noun ;;(octs noun))
+  --
+++  grad  %mime
+--

urbit-files/mar/ttf.hoon

@@ -0,0 +1,14 @@
+::  mark for .ttf font files
+::
+|_  dat=octs
+++  grow
+  |%
+  ++  mime  [/font/ttf dat]
+  --
+++  grab
+  |%
+  ++  mime  |=([p=mite q=octs] q)
+  ++  noun  |=(=noun ;;(octs noun))
+  --
+++  grad  %mime
+--

urbit-files/mar/woff.hoon

@@ -0,0 +1,14 @@
+::  mark for .woff font files
+::
+|_  dat=octs
+++  grow
+  |%
+  ++  mime  [/font/woff dat]
+  --
+++  grab
+  |%
+  ++  mime  |=([p=mite q=octs] q)
+  ++  noun  |=(=noun ;;(octs noun))
+  --
+++  grad  %mime
+--

urbit-files/mar/woff2.hoon

@@ -0,0 +1,14 @@
+::  mark for .woff2 font files
+::
+|_  dat=octs
+++  grow
+  |%
+  ++  mime  [/font/woff2 dat]
+  --
+++  grab
+  |%
+  ++  mime  |=([p=mite q=octs] q)
+  ++  noun  |=(=noun ;;(octs noun))
+  --
+++  grad  %mime
+--