diff --git a/src/components/NetworkSwitcher.tsx b/src/components/NetworkSwitcher.tsx
index 419f3a8..8f694b3 100644
--- a/src/components/NetworkSwitcher.tsx
+++ b/src/components/NetworkSwitcher.tsx
@@ -1,10 +1,65 @@
-import { useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { isValidHttpUrl } from "../config/network";
 import {
   NETWORK_COLORS,
   useNetwork,
   type NetworkConfig,
 } from "../contexts/NetworkContext";
 
+export { isValidHttpUrl };
+
+export interface CustomNetworkFormValues {
+  name: string;
+  rpcUrl: string;
+  horizonUrl: string;
+  passphrase: string;
+}
+
+export type CustomNetworkField = keyof CustomNetworkFormValues;
+
+export type CustomNetworkFormErrors = Partial<
+  Record<CustomNetworkField, string>
+>;
+
+export function validateCustomNetworkForm(
+  values: CustomNetworkFormValues,
+  existingNetworks: ReadonlyArray<Pick<NetworkConfig, "name">>,
+): CustomNetworkFormErrors {
+  const errors: CustomNetworkFormErrors = {};
+
+  const name = values.name.trim();
+  if (!name) {
+    errors.name = "Network name is required.";
+  } else {
+    const normalized = name.toLowerCase();
+    const isDuplicate = existingNetworks.some(
+      (n) => n.name.trim().toLowerCase() === normalized,
+    );
+    if (isDuplicate) {
+      errors.name = "A network with this name already exists.";
+    }
+  }
+
+  const rpcUrl = values.rpcUrl.trim();
+  if (!rpcUrl) {
+    errors.rpcUrl = "RPC URL is required.";
+  } else if (!isValidHttpUrl(rpcUrl)) {
+    errors.rpcUrl = "Enter a valid http(s) RPC URL.";
+  }
+
+  const horizonUrl = values.horizonUrl.trim();
+  if (horizonUrl && !isValidHttpUrl(horizonUrl)) {
+    errors.horizonUrl = "Enter a valid http(s) Horizon URL.";
+  }
+
+  const passphrase = values.passphrase.trim();
+  if (!passphrase) {
+    errors.passphrase = "Network passphrase is required.";
+  }
+
+  return errors;
+}
+
 type HealthState = "checking" | "connected" | "degraded" | "down";
 
 interface Health {
@@ -12,19 +67,51 @@ interface Health {
   latencyMs: number | null;
 }
 
-async function probeNetwork(rpcUrl: string): Promise<Health> {
+type RpcCheckState = "idle" | HealthState;
+
+interface RpcCheck {
+  state: RpcCheckState;
+  latencyMs: number | null;
+}
+
+const PROBE_TIMEOUT_MS = 4000;
+const RPC_CHECK_DEBOUNCE_MS = 300;
+
+const INITIAL_FORM: CustomNetworkFormValues = {
+  name: "",
+  rpcUrl: "",
+  horizonUrl: "",
+  passphrase: "",
+};
+
+async function probeNetwork(
+  rpcUrl: string,
+  externalSignal?: AbortSignal,
+): Promise<Health> {
+  if (externalSignal?.aborted) {
+    return { state: "down", latencyMs: null };
+  }
+  const controller = new AbortController();
+  const onAbort = () => controller.abort();
+  externalSignal?.addEventListener("abort", onAbort, { once: true });
+  const timeoutId = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+
   const start = performance.now();
   try {
     const res = await fetch(rpcUrl, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "getHealth" }),
+      signal: controller.signal,
     });
     const latencyMs = Math.round(performance.now() - start);
     if (!res.ok) return { state: "degraded", latencyMs };
     return { state: latencyMs > 1500 ? "degraded" : "connected", latencyMs };
   } catch {
     return { state: "down", latencyMs: null };
+  } finally {
+    clearTimeout(timeoutId);
+    externalSignal?.removeEventListener("abort", onAbort);
   }
 }
 
@@ -64,24 +151,49 @@ export default function NetworkSwitcher() {
     state: "checking",
     latencyMs: null,
   });
-  const [form, setForm] = useState({
-    name: "",
-    rpcUrl: "",
-    horizonUrl: "",
-    passphrase: "",
+  const [form, setForm] = useState<CustomNetworkFormValues>(INITIAL_FORM);
+  const [touched, setTouched] = useState<
+    Partial<Record<CustomNetworkField, boolean>>
+  >({});
+  const [submitAttempted, setSubmitAttempted] = useState(false);
+  const [rpcCheck, setRpcCheck] = useState<RpcCheck>({
+    state: "idle",
+    latencyMs: null,
   });
-  const [formError, setFormError] = useState<string | null>(null);
-  const [validating, setValidating] = useState(false);
+
   const rootRef = useRef<HTMLDivElement>(null);
+  const rpcCheckAbortRef = useRef<AbortController | null>(null);
+  const rpcCheckTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const cancelPendingRpcCheck = useCallback(() => {
+    if (rpcCheckTimerRef.current != null) {
+      clearTimeout(rpcCheckTimerRef.current);
+      rpcCheckTimerRef.current = null;
+    }
+    if (rpcCheckAbortRef.current != null) {
+      rpcCheckAbortRef.current.abort();
+      rpcCheckAbortRef.current = null;
+    }
+  }, []);
+
+  const resetAddForm = useCallback(() => {
+    cancelPendingRpcCheck();
+    setForm(INITIAL_FORM);
+    setTouched({});
+    setSubmitAttempted(false);
+    setRpcCheck({ state: "idle", latencyMs: null });
+  }, [cancelPendingRpcCheck]);
 
   useEffect(() => {
     let cancelled = false;
+    const controller = new AbortController();
     setHealth({ state: "checking", latencyMs: null });
-    probeNetwork(active.rpcUrl).then((h) => {
-      if (!cancelled) setHealth(h);
+    void probeNetwork(active.rpcUrl, controller.signal).then((h) => {
+      if (!cancelled && !controller.signal.aborted) setHealth(h);
     });
     return () => {
       cancelled = true;
+      controller.abort();
     };
   }, [active.id, active.rpcUrl]);
 
@@ -91,12 +203,17 @@ export default function NetworkSwitcher() {
         e.preventDefault();
         setOpen((o) => !o);
       }
-      if (e.key === "Escape") setOpen(false);
+      if (e.key === "Escape") {
+        setOpen(false);
+        setShowAddForm(false);
+        resetAddForm();
+      }
     }
     function onClickOutside(e: MouseEvent) {
       if (rootRef.current && !rootRef.current.contains(e.target as Node)) {
         setOpen(false);
         setShowAddForm(false);
+        resetAddForm();
       }
     }
     window.addEventListener("keydown", onKey);
@@ -105,24 +222,71 @@ export default function NetworkSwitcher() {
       window.removeEventListener("keydown", onKey);
       window.removeEventListener("mousedown", onClickOutside);
     };
-  }, []);
+  }, [resetAddForm]);
 
-  async function handleAddNetwork(e: React.FormEvent) {
-    e.preventDefault();
-    setFormError(null);
-    if (!form.name.trim() || !form.rpcUrl.trim() || !form.passphrase.trim()) {
-      setFormError("Name, RPC URL, and passphrase are required.");
+  const errors = useMemo(
+    () => validateCustomNetworkForm(form, networks),
+    [form, networks],
+  );
+  const isFormValid = Object.keys(errors).length === 0;
+  const trimmedRpcUrl = form.rpcUrl.trim();
+  const canProbeRpc = showAddForm && Boolean(trimmedRpcUrl) && !errors.rpcUrl;
+
+  const runRpcCheck = useCallback(
+    (url: string) => {
+      cancelPendingRpcCheck();
+      const controller = new AbortController();
+      rpcCheckAbortRef.current = controller;
+      setRpcCheck({ state: "checking", latencyMs: null });
+      void probeNetwork(url, controller.signal).then((result) => {
+        if (!controller.signal.aborted) {
+          setRpcCheck(result);
+        }
+      });
+    },
+    [cancelPendingRpcCheck],
+  );
+
+  useEffect(() => {
+    if (!canProbeRpc) {
+      cancelPendingRpcCheck();
+      setRpcCheck({ state: "idle", latencyMs: null });
       return;
     }
-    setValidating(true);
-    const probed = await probeNetwork(form.rpcUrl.trim());
-    setValidating(false);
-    if (probed.state === "down") {
-      setFormError(
-        "Could not reach this RPC URL. Check the address and try again.",
-      );
+
+    rpcCheckTimerRef.current = setTimeout(() => {
+      rpcCheckTimerRef.current = null;
+      runRpcCheck(trimmedRpcUrl);
+    }, RPC_CHECK_DEBOUNCE_MS);
+
+    return () => {
+      cancelPendingRpcCheck();
+    };
+  }, [canProbeRpc, trimmedRpcUrl, runRpcCheck, cancelPendingRpcCheck]);
+
+  function updateField(field: CustomNetworkField, value: string) {
+    setForm((prev) => ({ ...prev, [field]: value }));
+    setTouched((prev) => (prev[field] ? prev : { ...prev, [field]: true }));
+  }
+
+  function markTouched(field: CustomNetworkField) {
+    setTouched((prev) => (prev[field] ? prev : { ...prev, [field]: true }));
+  }
+
+  function fieldError(field: CustomNetworkField): string | undefined {
+    if (!touched[field] && !submitAttempted) return undefined;
+    return errors[field];
+  }
+
+  function handleAddNetwork(e: React.FormEvent) {
+    e.preventDefault();
+    setSubmitAttempted(true);
+
+    const currentErrors = validateCustomNetworkForm(form, networks);
+    if (Object.keys(currentErrors).length > 0) {
       return;
     }
+
     const network = addCustomNetwork({
       name: form.name.trim(),
       rpcUrl: form.rpcUrl.trim(),
@@ -130,10 +294,15 @@ export default function NetworkSwitcher() {
       passphrase: form.passphrase.trim(),
     });
     setActiveId(network.id);
-    setForm({ name: "", rpcUrl: "", horizonUrl: "", passphrase: "" });
+    resetAddForm();
     setShowAddForm(false);
   }
 
+  const nameError = fieldError("name");
+  const rpcUrlError = fieldError("rpcUrl");
+  const horizonUrlError = fieldError("horizonUrl");
+  const passphraseError = fieldError("passphrase");
+
   return (
     <div ref={rootRef} style={{ position: "relative" }}>
       <button
@@ -170,7 +339,7 @@ export default function NetworkSwitcher() {
             position: "absolute",
             top: "calc(100% + 6px)",
             right: 0,
-            minWidth: 260,
+            minWidth: 280,
             background: "var(--surface)",
             border: "1px solid var(--border)",
             borderRadius: 8,
@@ -250,57 +419,208 @@ export default function NetworkSwitcher() {
             </button>
           ) : (
             <form
+              noValidate
               onSubmit={handleAddNetwork}
               style={{ display: "flex", flexDirection: "column", gap: 6 }}
             >
-              <input
-                placeholder="Name (e.g. Local RPC)"
-                value={form.name}
-                onChange={(e) =>
-                  setForm((f) => ({ ...f, name: e.target.value }))
-                }
-                style={{ fontSize: 12 }}
-              />
-              <input
-                placeholder="RPC URL"
-                value={form.rpcUrl}
-                onChange={(e) =>
-                  setForm((f) => ({ ...f, rpcUrl: e.target.value }))
-                }
-                style={{ fontSize: 12 }}
-              />
-              <input
-                placeholder="Horizon URL (optional)"
-                value={form.horizonUrl}
-                onChange={(e) =>
-                  setForm((f) => ({ ...f, horizonUrl: e.target.value }))
-                }
-                style={{ fontSize: 12 }}
-              />
-              <input
-                placeholder="Network passphrase"
-                value={form.passphrase}
-                onChange={(e) =>
-                  setForm((f) => ({ ...f, passphrase: e.target.value }))
-                }
-                style={{ fontSize: 12 }}
-              />
-              {formError && (
-                <p style={{ color: "#f85149", fontSize: 11, margin: 0 }}>
-                  {formError}
-                </p>
-              )}
+              <div>
+                <input
+                  aria-label="Network name"
+                  aria-invalid={Boolean(nameError)}
+                  aria-describedby={
+                    nameError ? "custom-network-name-error" : undefined
+                  }
+                  placeholder="Name (e.g. Local RPC)"
+                  value={form.name}
+                  onChange={(e) => updateField("name", e.target.value)}
+                  onBlur={() => markTouched("name")}
+                  style={{
+                    fontSize: 12,
+                    width: "100%",
+                    borderColor: nameError ? "#f85149" : undefined,
+                  }}
+                />
+                {nameError && (
+                  <p
+                    id="custom-network-name-error"
+                    role="alert"
+                    style={{
+                      color: "#f85149",
+                      fontSize: 11,
+                      margin: "2px 0 0",
+                    }}
+                  >
+                    {nameError}
+                  </p>
+                )}
+              </div>
+
+              <div>
+                <div style={{ display: "flex", gap: 4 }}>
+                  <input
+                    aria-label="RPC URL"
+                    aria-invalid={Boolean(rpcUrlError)}
+                    aria-describedby={
+                      rpcUrlError ? "custom-network-rpc-error" : undefined
+                    }
+                    placeholder="RPC URL"
+                    value={form.rpcUrl}
+                    onChange={(e) => updateField("rpcUrl", e.target.value)}
+                    onBlur={() => markTouched("rpcUrl")}
+                    style={{
+                      fontSize: 12,
+                      flex: 1,
+                      minWidth: 0,
+                      borderColor: rpcUrlError ? "#f85149" : undefined,
+                    }}
+                  />
+                  <button
+                    type="button"
+                    disabled={!canProbeRpc || rpcCheck.state === "checking"}
+                    onClick={() => runRpcCheck(trimmedRpcUrl)}
+                    style={{
+                      fontSize: 11,
+                      padding: "4px 8px",
+                      background: "transparent",
+                      border: "1px solid var(--border)",
+                      color: "var(--text)",
+                      opacity:
+                        !canProbeRpc || rpcCheck.state === "checking" ? 0.5 : 1,
+                      cursor:
+                        !canProbeRpc || rpcCheck.state === "checking"
+                          ? "not-allowed"
+                          : "pointer",
+                      whiteSpace: "nowrap",
+                    }}
+                  >
+                    Check RPC
+                  </button>
+                </div>
+                {rpcUrlError && (
+                  <p
+                    id="custom-network-rpc-error"
+                    role="alert"
+                    style={{
+                      color: "#f85149",
+                      fontSize: 11,
+                      margin: "2px 0 0",
+                    }}
+                  >
+                    {rpcUrlError}
+                  </p>
+                )}
+                {!rpcUrlError && rpcCheck.state !== "idle" && (
+                  <p
+                    role="status"
+                    aria-live="polite"
+                    data-testid="rpc-reachability-status"
+                    style={{
+                      fontSize: 11,
+                      margin: "2px 0 0",
+                      color:
+                        rpcCheck.state === "connected"
+                          ? "#22c55e"
+                          : rpcCheck.state === "checking"
+                            ? "var(--muted)"
+                            : "#f59e0b",
+                    }}
+                  >
+                    {rpcCheck.state === "checking" && "Checking RPC endpoint…"}
+                    {rpcCheck.state === "connected" &&
+                      `RPC reachable${rpcCheck.latencyMs != null ? ` (${rpcCheck.latencyMs}ms)` : ""}`}
+                    {rpcCheck.state === "degraded" &&
+                      "RPC responded with a non-OK status — you can still save."}
+                    {rpcCheck.state === "down" &&
+                      "Could not reach RPC endpoint — you can still save."}
+                  </p>
+                )}
+              </div>
+
+              <div>
+                <input
+                  aria-label="Horizon URL (optional)"
+                  aria-invalid={Boolean(horizonUrlError)}
+                  aria-describedby={
+                    horizonUrlError ? "custom-network-horizon-error" : undefined
+                  }
+                  placeholder="Horizon URL (optional)"
+                  value={form.horizonUrl}
+                  onChange={(e) => updateField("horizonUrl", e.target.value)}
+                  onBlur={() => markTouched("horizonUrl")}
+                  style={{
+                    fontSize: 12,
+                    width: "100%",
+                    borderColor: horizonUrlError ? "#f85149" : undefined,
+                  }}
+                />
+                {horizonUrlError && (
+                  <p
+                    id="custom-network-horizon-error"
+                    role="alert"
+                    style={{
+                      color: "#f85149",
+                      fontSize: 11,
+                      margin: "2px 0 0",
+                    }}
+                  >
+                    {horizonUrlError}
+                  </p>
+                )}
+              </div>
+
+              <div>
+                <input
+                  aria-label="Network passphrase"
+                  aria-invalid={Boolean(passphraseError)}
+                  aria-describedby={
+                    passphraseError
+                      ? "custom-network-passphrase-error"
+                      : undefined
+                  }
+                  placeholder="Network passphrase"
+                  value={form.passphrase}
+                  onChange={(e) => updateField("passphrase", e.target.value)}
+                  onBlur={() => markTouched("passphrase")}
+                  style={{
+                    fontSize: 12,
+                    width: "100%",
+                    borderColor: passphraseError ? "#f85149" : undefined,
+                  }}
+                />
+                {passphraseError && (
+                  <p
+                    id="custom-network-passphrase-error"
+                    role="alert"
+                    style={{
+                      color: "#f85149",
+                      fontSize: 11,
+                      margin: "2px 0 0",
+                    }}
+                  >
+                    {passphraseError}
+                  </p>
+                )}
+              </div>
+
               <div style={{ display: "flex", gap: 6 }}>
                 <button
                   type="submit"
-                  disabled={validating}
-                  style={{ flex: 1, fontSize: 12 }}
+                  disabled={!isFormValid}
+                  style={{
+                    flex: 1,
+                    fontSize: 12,
+                    opacity: isFormValid ? 1 : 0.5,
+                    cursor: isFormValid ? "pointer" : "not-allowed",
+                  }}
                 >
-                  {validating ? "Validating…" : "Save & switch"}
+                  Save & switch
                 </button>
                 <button
                   type="button"
-                  onClick={() => setShowAddForm(false)}
+                  onClick={() => {
+                    resetAddForm();
+                    setShowAddForm(false);
+                  }}
                   style={{ fontSize: 12 }}
                 >
                   Cancel
diff --git a/src/config/network.ts b/src/config/network.ts
index 0ef20f4..c8f9631 100644
--- a/src/config/network.ts
+++ b/src/config/network.ts
@@ -47,9 +47,35 @@ export function applyNetworkToEnvContent(
 ): string {
   let updated = content.split(DEFAULT_NETWORK.rpcUrl).join(network.rpcUrl);
   if (/^.*PASSPHRASE=.*$/m.test(updated)) {
-    updated = updated.replace(/^(.*PASSPHRASE=).*$/m, `$1${network.passphrase}`);
+    updated = updated.replace(
+      /^(.*PASSPHRASE=).*$/m,
+      `$1${network.passphrase}`,
+    );
   } else {
     updated = `${updated.trimEnd()}\nNETWORK_PASSPHRASE=${network.passphrase}\n`;
   }
   return updated;
 }
+
+export function isValidHttpUrl(value: string): boolean {
+  const trimmed = value.trim();
+  if (!trimmed || /\s/.test(trimmed)) return false;
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return false;
+    }
+    const host = parsed.hostname;
+    if (
+      !host ||
+      host.startsWith(".") ||
+      host.endsWith(".") ||
+      host.includes("..")
+    ) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
diff --git a/src/contexts/NetworkContext.tsx b/src/contexts/NetworkContext.tsx
index 9f2cfc0..d629c78 100644
--- a/src/contexts/NetworkContext.tsx
+++ b/src/contexts/NetworkContext.tsx
@@ -7,7 +7,7 @@ import {
   useState,
   type ReactNode,
 } from "react";
-import { resolveActiveNetwork } from "../config/network";
+import { isValidHttpUrl, resolveActiveNetwork } from "../config/network";
 
 export type NetworkKind = "testnet" | "mainnet" | "futurenet" | "custom";
 
@@ -61,12 +61,72 @@ export const NETWORK_COLORS: Record<NetworkKind, string> = {
 const ACTIVE_KEY = "sb-network-active";
 const CUSTOM_KEY = "sb-network-custom";
 
+let lastCustomId = 0;
+
+function readStorage(key: string): string | null {
+  try {
+    return typeof localStorage !== "undefined" &&
+      typeof localStorage?.getItem === "function"
+      ? localStorage.getItem(key)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeStorage(key: string, value: string): void {
+  try {
+    if (
+      typeof localStorage !== "undefined" &&
+      typeof localStorage?.setItem === "function"
+    ) {
+      localStorage.setItem(key, value);
+    }
+  } catch {
+    // Ignore storage quota or privacy-mode errors.
+  }
+}
+
+function isStoredCustomNetwork(entry: unknown): entry is NetworkConfig {
+  if (!entry || typeof entry !== "object") return false;
+  const candidate = entry as Record<string, unknown>;
+  if (
+    typeof candidate.id !== "string" ||
+    !candidate.id.trim() ||
+    typeof candidate.name !== "string" ||
+    !candidate.name.trim() ||
+    typeof candidate.rpcUrl !== "string" ||
+    !isValidHttpUrl(candidate.rpcUrl) ||
+    typeof candidate.passphrase !== "string" ||
+    !candidate.passphrase.trim()
+  ) {
+    return false;
+  }
+  if (
+    typeof candidate.horizonUrl === "string" &&
+    candidate.horizonUrl.trim() !== "" &&
+    !isValidHttpUrl(candidate.horizonUrl)
+  ) {
+    return false;
+  }
+  return true;
+}
+
 function loadCustomNetworks(): NetworkConfig[] {
   try {
-    const raw = localStorage.getItem(CUSTOM_KEY);
+    const raw = readStorage(CUSTOM_KEY);
     if (!raw) return [];
     const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed : [];
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(isStoredCustomNetwork).map((n) => ({
+      ...n,
+      name: n.name.trim(),
+      rpcUrl: n.rpcUrl.trim(),
+      horizonUrl: typeof n.horizonUrl === "string" ? n.horizonUrl.trim() : "",
+      passphrase: n.passphrase.trim(),
+      kind: "custom",
+      custom: true,
+    }));
   } catch {
     return [];
   }
@@ -88,7 +148,7 @@ export function NetworkProvider({ children }: { children: ReactNode }) {
   const [customNetworks, setCustomNetworks] =
     useState<NetworkConfig[]>(loadCustomNetworks);
   const [activeId, setActiveIdState] = useState<string>(
-    () => localStorage.getItem(ACTIVE_KEY) || defaultNetwork.id,
+    () => readStorage(ACTIVE_KEY) || defaultNetwork.id,
   );
 
   const networks = useMemo(
@@ -102,19 +162,42 @@ export function NetworkProvider({ children }: { children: ReactNode }) {
   );
 
   useEffect(() => {
-    localStorage.setItem(CUSTOM_KEY, JSON.stringify(customNetworks));
+    writeStorage(CUSTOM_KEY, JSON.stringify(customNetworks));
   }, [customNetworks]);
 
   const setActiveId = useCallback((id: string) => {
     setActiveIdState(id);
-    localStorage.setItem(ACTIVE_KEY, id);
+    writeStorage(ACTIVE_KEY, id);
   }, []);
 
   const addCustomNetwork = useCallback(
     (network: Omit<NetworkConfig, "id" | "kind" | "custom">) => {
-      const id = `custom-${Date.now()}`;
+      const name = network.name.trim();
+      const rpcUrl = network.rpcUrl.trim();
+      const horizonUrl = network.horizonUrl.trim();
+      const passphrase = network.passphrase.trim();
+
+      if (!name) {
+        throw new Error("Network name is required.");
+      }
+      if (!isValidHttpUrl(rpcUrl)) {
+        throw new Error("Enter a valid http(s) RPC URL.");
+      }
+      if (horizonUrl && !isValidHttpUrl(horizonUrl)) {
+        throw new Error("Enter a valid http(s) Horizon URL.");
+      }
+      if (!passphrase) {
+        throw new Error("Network passphrase is required.");
+      }
+
+      const nextId = Math.max(Date.now(), lastCustomId + 1);
+      lastCustomId = nextId;
+      const id = `custom-${nextId}`;
       const full: NetworkConfig = {
-        ...network,
+        name,
+        rpcUrl,
+        horizonUrl,
+        passphrase,
         id,
         kind: "custom",
         custom: true,
diff --git a/test/NetworkSwitcher.test.tsx b/test/NetworkSwitcher.test.tsx
new file mode 100644
index 0000000..3651b59
--- /dev/null
+++ b/test/NetworkSwitcher.test.tsx
@@ -0,0 +1,495 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import NetworkSwitcher, {
+  isValidHttpUrl,
+  validateCustomNetworkForm,
+} from "../src/components/NetworkSwitcher";
+import {
+  BUILTIN_NETWORKS,
+  NetworkProvider,
+  useNetwork,
+} from "../src/contexts/NetworkContext";
+
+function ensureLocalStorage(): Storage {
+  if (
+    typeof globalThis.localStorage !== "undefined" &&
+    typeof globalThis.localStorage?.getItem === "function" &&
+    typeof globalThis.localStorage?.clear === "function"
+  ) {
+    return globalThis.localStorage;
+  }
+  const store = new Map<string, string>();
+  const memoryStorage: Storage = {
+    get length() {
+      return store.size;
+    },
+    clear() {
+      store.clear();
+    },
+    getItem(key: string) {
+      return store.has(key) ? store.get(key)! : null;
+    },
+    key(index: number) {
+      return Array.from(store.keys())[index] ?? null;
+    },
+    removeItem(key: string) {
+      store.delete(key);
+    },
+    setItem(key: string, value: string) {
+      store.set(key, String(value));
+    },
+  };
+  Object.defineProperty(globalThis, "localStorage", {
+    value: memoryStorage,
+    configurable: true,
+    writable: true,
+  });
+  return memoryStorage;
+}
+
+const storage = ensureLocalStorage();
+
+function ActiveNetworkReadout() {
+  const { active } = useNetwork();
+  return (
+    <div data-testid="active-network-readout">
+      <span data-testid="active-name">{active.name}</span>
+      <span data-testid="active-rpc">{active.rpcUrl}</span>
+      <span data-testid="active-horizon">{active.horizonUrl}</span>
+      <span data-testid="active-passphrase">{active.passphrase}</span>
+    </div>
+  );
+}
+
+function renderSwitcher() {
+  return render(
+    <NetworkProvider>
+      <NetworkSwitcher />
+      <ActiveNetworkReadout />
+    </NetworkProvider>,
+  );
+}
+
+describe("isValidHttpUrl", () => {
+  it("accepts well-formed http and https URLs", () => {
+    expect(isValidHttpUrl("https://soroban-testnet.stellar.org")).toBe(true);
+    expect(isValidHttpUrl("http://localhost:8000")).toBe(true);
+    expect(isValidHttpUrl("http://127.0.0.1:8000/soroban/rpc")).toBe(true);
+    expect(isValidHttpUrl("http://[::1]:8000")).toBe(true);
+    expect(isValidHttpUrl("  https://rpc.example.com/v1  ")).toBe(true);
+  });
+
+  it("rejects empty, malformed, relative, and non-http(s) URLs", () => {
+    expect(isValidHttpUrl("")).toBe(false);
+    expect(isValidHttpUrl("   ")).toBe(false);
+    expect(isValidHttpUrl("not-a-url")).toBe(false);
+    expect(isValidHttpUrl("/relative/rpc")).toBe(false);
+    expect(isValidHttpUrl("soroban-testnet.stellar.org")).toBe(false);
+    expect(isValidHttpUrl("ftp://rpc.example.com")).toBe(false);
+    expect(isValidHttpUrl("ws://localhost:8000")).toBe(false);
+    expect(isValidHttpUrl("javascript:alert(1)")).toBe(false);
+    expect(isValidHttpUrl("http://")).toBe(false);
+    expect(isValidHttpUrl("https://")).toBe(false);
+    expect(isValidHttpUrl("https://.com")).toBe(false);
+    expect(isValidHttpUrl("https://example..com")).toBe(false);
+    expect(isValidHttpUrl("https://rpc.example.com/with space")).toBe(false);
+  });
+});
+
+describe("validateCustomNetworkForm", () => {
+  it("validates required fields, URL formats, optional Horizon URL, and duplicate names", () => {
+    const emptyErrors = validateCustomNetworkForm(
+      { name: "  ", rpcUrl: "", horizonUrl: "", passphrase: "   " },
+      BUILTIN_NETWORKS,
+    );
+    expect(emptyErrors.name).toMatch(/required/i);
+    expect(emptyErrors.rpcUrl).toMatch(/required/i);
+    expect(emptyErrors.passphrase).toMatch(/required/i);
+    expect(emptyErrors.horizonUrl).toBeUndefined();
+
+    const dupErrors = validateCustomNetworkForm(
+      {
+        name: "  tEsTnEt ",
+        rpcUrl: "http://localhost:8000",
+        horizonUrl: "   ",
+        passphrase: "Local Passphrase",
+      },
+      BUILTIN_NETWORKS,
+    );
+    expect(dupErrors.name).toMatch(/already exists/i);
+    expect(dupErrors.rpcUrl).toBeUndefined();
+    expect(dupErrors.horizonUrl).toBeUndefined();
+    expect(dupErrors.passphrase).toBeUndefined();
+  });
+});
+
+describe("NetworkSwitcher custom network validation", () => {
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    storage.clear();
+    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
+    consoleErrorSpy = vi.spyOn(console, "error");
+  });
+
+  afterEach(() => {
+    expect(consoleErrorSpy).not.toHaveBeenCalled();
+    vi.restoreAllMocks();
+    storage.clear();
+  });
+
+  async function openCustomForm(user: ReturnType<typeof userEvent.setup>) {
+    await user.click(screen.getByRole("button", { name: /testnet/i }));
+    await user.click(
+      screen.getByRole("button", { name: /\+ add custom network/i }),
+    );
+  }
+
+  it("disables save initially without showing premature error alerts", async () => {
+    const user = userEvent.setup({ delay: null });
+    renderSwitcher();
+    await openCustomForm(user);
+
+    const saveBtn = screen.getByRole("button", { name: /save & switch/i });
+    expect(saveBtn).toBeDisabled();
+    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+  });
+
+  it("shows field-level error on blur and all required errors when submitting an untouched form", async () => {
+    const user = userEvent.setup({ delay: null });
+    renderSwitcher();
+    await openCustomForm(user);
+
+    const nameInput = screen.getByPlaceholderText(/name/i);
+    await user.click(nameInput);
+    await user.tab();
+
+    expect(screen.getAllByRole("alert")).toHaveLength(1);
+    expect(screen.getByText(/network name is required/i)).toBeInTheDocument();
+
+    const saveBtn = screen.getByRole("button", { name: /save & switch/i });
+    fireEvent.submit(saveBtn.closest("form")!);
+
+    expect(screen.getAllByRole("alert")).toHaveLength(3);
+    expect(screen.getByText(/network name is required/i)).toBeInTheDocument();
+    expect(screen.getByText(/rpc url is required/i)).toBeInTheDocument();
+    expect(
+      screen.getByText(/network passphrase is required/i),
+    ).toBeInTheDocument();
+  });
+
+  it("submitting a malformed RPC URL shows an inline error and does not save", async () => {
+    const user = userEvent.setup({ delay: null });
+    renderSwitcher();
+    await openCustomForm(user);
+
+    const nameInput = screen.getByPlaceholderText(/name/i);
+    const rpcInput = screen.getByPlaceholderText(/rpc url/i);
+    const passphraseInput = screen.getByPlaceholderText(/network passphrase/i);
+    const saveBtn = screen.getByRole("button", { name: /save & switch/i });
+
+    await user.type(nameInput, "Broken RPC");
+    await user.type(rpcInput, "not-a-url");
+    await user.type(passphraseInput, "Standalone Network ; February 2017");
+
+    expect(saveBtn).toBeDisabled();
+    expect(rpcInput).toHaveAttribute("aria-invalid", "true");
+    expect(screen.getByRole("alert")).toHaveTextContent(
+      /valid http\(s\) rpc url/i,
+    );
+
+    const form = saveBtn.closest("form")!;
+    fireEvent.submit(form);
+
+    expect(screen.getByTestId("active-name")).toHaveTextContent("Testnet");
+    expect(JSON.parse(storage.getItem("sb-network-custom") || "[]")).toEqual(
+      [],
+    );
+
+    await user.clear(rpcInput);
+    await user.type(rpcInput, "ftp://rpc.example.com");
+    expect(saveBtn).toBeDisabled();
+    expect(screen.getByRole("alert")).toHaveTextContent(
+      /valid http\(s\) rpc url/i,
+    );
+  });
+
+  it("rejects missing or whitespace-only name and passphrase with inline field errors", async () => {
+    const user = userEvent.setup({ delay: null });
+    renderSwitcher();
+    await openCustomForm(user);
+
+    const nameInput = screen.getByPlaceholderText(/name/i);
+    const rpcInput = screen.getByPlaceholderText(/rpc url/i);
+    const passphraseInput = screen.getByPlaceholderText(/network passphrase/i);
+    const saveBtn = screen.getByRole("button", { name: /save & switch/i });
+
+    await user.type(nameInput, "   ");
+    await user.type(rpcInput, "http://localhost:8000");
+    await user.type(passphraseInput, "   ");
+
+    expect(saveBtn).toBeDisabled();
+    expect(screen.getByText(/network name is required/i)).toBeInTheDocument();
+    expect(
+      screen.getByText(/network passphrase is required/i),
+    ).toBeInTheDocument();
+
+    fireEvent.submit(saveBtn.closest("form")!);
+    expect(screen.getByTestId("active-name")).toHaveTextContent("Testnet");
+  });
+
+  it("validates optional Horizon URL when provided and allows leaving it blank", async () => {
+    const user = userEvent.setup({ delay: null });
+    renderSwitcher();
+    await openCustomForm(user);
+
+    const nameInput = screen.getByPlaceholderText(/name/i);
+    const rpcInput = screen.getByPlaceholderText(/rpc url/i);
+    const horizonInput = screen.getByPlaceholderText(/horizon url/i);
+    const passphraseInput = screen.getByPlaceholderText(/network passphrase/i);
+    const saveBtn = screen.getByRole("button", { name: /save & switch/i });
+
+    await user.type(nameInput, "Local Dev");
+    await user.type(rpcInput, "http://localhost:8000");
+    await user.type(passphraseInput, "Standalone Network ; February 2017");
+    expect(saveBtn).toBeEnabled();
+
+    await user.type(horizonInput, "bad-horizon-url");
+    expect(saveBtn).toBeDisabled();
+    expect(horizonInput).toHaveAttribute("aria-invalid", "true");
+    expect(screen.getByRole("alert")).toHaveTextContent(
+      /valid http\(s\) horizon url/i,
+    );
+
+    await user.clear(horizonInput);
+    await user.type(horizonInput, "   ");
+    expect(horizonInput).toHaveAttribute("aria-invalid", "false");
+    expect(saveBtn).toBeEnabled();
+
+    await user.click(saveBtn);
+    expect(screen.getByTestId("active-name")).toHaveTextContent("Local Dev");
+    expect(screen.getByTestId("active-horizon")).toHaveTextContent(/^$/);
+  });
+
+  it("prevents duplicate names against built-in and saved custom networks case-insensitively", async () => {
+    const user = userEvent.setup({ delay: null });
+    renderSwitcher();
+    await openCustomForm(user);
+
+    const nameInput = screen.getByPlaceholderText(/name/i);
+    const rpcInput = screen.getByPlaceholderText(/rpc url/i);
+    const passphraseInput = screen.getByPlaceholderText(/network passphrase/i);
+    const saveBtn = screen.getByRole("button", { name: /save & switch/i });
+
+    await user.type(nameInput, "  mAiNnEt  ");
+    await user.type(rpcInput, "http://localhost:8000");
+    await user.type(passphraseInput, "Standalone Network ; February 2017");
+
+    expect(saveBtn).toBeDisabled();
+    expect(screen.getByRole("alert")).toHaveTextContent(/already exists/i);
+
+    await user.clear(nameInput);
+    await user.type(nameInput, "My Staging RPC");
+    expect(saveBtn).toBeEnabled();
+    await user.click(saveBtn);
+
+    await user.click(
+      screen.getByRole("button", { name: /\+ add custom network/i }),
+    );
+    await user.type(screen.getByPlaceholderText(/name/i), "  my staging rpc  ");
+    await user.type(
+      screen.getByPlaceholderText(/rpc url/i),
+      "http://localhost:8001",
+    );
+    await user.type(
+      screen.getByPlaceholderText(/network passphrase/i),
+      "Staging Passphrase",
+    );
+
+    expect(
+      screen.getByRole("button", { name: /save & switch/i }),
+    ).toBeDisabled();
+    expect(screen.getByRole("alert")).toHaveTextContent(/already exists/i);
+
+    // Removing the custom network frees up the name again
+    await user.click(screen.getByRole("button", { name: /cancel/i }));
+    await user.click(screen.getByTitle("Remove custom network"));
+    await user.click(
+      screen.getByRole("button", { name: /\+ add custom network/i }),
+    );
+    await user.type(screen.getByPlaceholderText(/name/i), "My Staging RPC");
+    await user.type(
+      screen.getByPlaceholderText(/rpc url/i),
+      "http://localhost:8001",
+    );
+    await user.type(
+      screen.getByPlaceholderText(/network passphrase/i),
+      "Staging Passphrase",
+    );
+    expect(
+      screen.getByRole("button", { name: /save & switch/i }),
+    ).toBeEnabled();
+  });
+
+  it("saves a valid custom network with trimmed fields and makes it selectable", async () => {
+    const user = userEvent.setup({ delay: null });
+    renderSwitcher();
+    await openCustomForm(user);
+
+    await user.type(screen.getByPlaceholderText(/name/i), "  Local Sandbox  ");
+    await user.type(
+      screen.getByPlaceholderText(/rpc url/i),
+      "  http://localhost:8000/soroban/rpc  ",
+    );
+    await user.type(
+      screen.getByPlaceholderText(/horizon url/i),
+      "  http://localhost:8000  ",
+    );
+    await user.type(
+      screen.getByPlaceholderText(/network passphrase/i),
+      "  Standalone Network ; February 2017  ",
+    );
+
+    const saveBtn = screen.getByRole("button", { name: /save & switch/i });
+    expect(saveBtn).toBeEnabled();
+    await user.click(saveBtn);
+
+    expect(screen.getByTestId("active-name")).toHaveTextContent(
+      /^Local Sandbox$/,
+    );
+    expect(screen.getByTestId("active-rpc")).toHaveTextContent(
+      /^http:\/\/localhost:8000\/soroban\/rpc$/,
+    );
+    expect(screen.getByTestId("active-horizon")).toHaveTextContent(
+      /^http:\/\/localhost:8000$/,
+    );
+    expect(screen.getByTestId("active-passphrase")).toHaveTextContent(
+      /^Standalone Network ; February 2017$/,
+    );
+
+    const stored = JSON.parse(storage.getItem("sb-network-custom") || "[]");
+    expect(stored).toHaveLength(1);
+    expect(stored[0]).toMatchObject({
+      name: "Local Sandbox",
+      rpcUrl: "http://localhost:8000/soroban/rpc",
+      horizonUrl: "http://localhost:8000",
+      passphrase: "Standalone Network ; February 2017",
+    });
+
+    await user.click(screen.getByText("Testnet"));
+    expect(screen.getByTestId("active-name")).toHaveTextContent("Testnet");
+
+    await user.click(screen.getByRole("button", { name: /testnet/i }));
+    await user.click(screen.getByText("Local Sandbox"));
+    expect(screen.getByTestId("active-name")).toHaveTextContent(
+      "Local Sandbox",
+    );
+  });
+
+  it("surfaces RPC reachability check results without blocking save when unreachable or degraded", async () => {
+    global.fetch = vi.fn().mockRejectedValue(new Error("Connection refused"));
+    const user = userEvent.setup({ delay: null });
+    renderSwitcher();
+    await openCustomForm(user);
+
+    await user.type(screen.getByPlaceholderText(/name/i), "Offline Local");
+    await user.type(
+      screen.getByPlaceholderText(/rpc url/i),
+      "http://localhost:8000",
+    );
+    await user.type(
+      screen.getByPlaceholderText(/network passphrase/i),
+      "Standalone Network ; February 2017",
+    );
+
+    await user.click(screen.getByRole("button", { name: /check rpc/i }));
+
+    const status = await screen.findByTestId("rpc-reachability-status");
+    expect(status).toHaveTextContent(/could not reach rpc endpoint/i);
+
+    global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 503 });
+    await user.click(screen.getByRole("button", { name: /check rpc/i }));
+    await waitFor(() => {
+      expect(screen.getByTestId("rpc-reachability-status")).toHaveTextContent(
+        /non-ok status/i,
+      );
+    });
+
+    const saveBtn = screen.getByRole("button", { name: /save & switch/i });
+    expect(saveBtn).toBeEnabled();
+    await user.click(saveBtn);
+
+    expect(screen.getByTestId("active-name")).toHaveTextContent(
+      "Offline Local",
+    );
+  });
+
+  it("surfaces reachable status when RPC health check succeeds", async () => {
+    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
+    const user = userEvent.setup({ delay: null });
+    renderSwitcher();
+    await openCustomForm(user);
+
+    await user.type(
+      screen.getByPlaceholderText(/rpc url/i),
+      "https://rpc.example.com",
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId("rpc-reachability-status")).toHaveTextContent(
+        /rpc reachable/i,
+      );
+    });
+  });
+
+  it("resets form inputs and validation errors when cancelled", async () => {
+    const user = userEvent.setup({ delay: null });
+    renderSwitcher();
+    await openCustomForm(user);
+
+    await user.type(screen.getByPlaceholderText(/rpc url/i), "invalid-url");
+    expect(screen.getByRole("alert")).toBeInTheDocument();
+
+    await user.click(screen.getByRole("button", { name: /cancel/i }));
+    await user.click(
+      screen.getByRole("button", { name: /\+ add custom network/i }),
+    );
+
+    expect(screen.getByPlaceholderText(/rpc url/i)).toHaveValue("");
+    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+  });
+
+  it("ignores malformed custom networks previously stored in localStorage", async () => {
+    storage.setItem(
+      "sb-network-custom",
+      JSON.stringify([
+        {
+          id: "custom-bad-1",
+          kind: "custom",
+          custom: true,
+          name: "",
+          rpcUrl: "not-a-url",
+          horizonUrl: "",
+          passphrase: "",
+        },
+        {
+          id: "custom-good-1",
+          kind: "custom",
+          custom: true,
+          name: "  Valid Stored  ",
+          rpcUrl: "https://valid-rpc.example.com",
+          horizonUrl: "",
+          passphrase: "Stored Passphrase",
+        },
+      ]),
+    );
+
+    const user = userEvent.setup({ delay: null });
+    renderSwitcher();
+    await user.click(screen.getByRole("button", { name: /testnet/i }));
+
+    expect(screen.getByText("Valid Stored")).toBeInTheDocument();
+    expect(screen.queryByText("not-a-url")).not.toBeInTheDocument();
+  });
+});