diff --git a/docs/form-validation-framework.md b/docs/form-validation-framework.md
new file mode 100644
index 0000000..bf7ef63
--- /dev/null
+++ b/docs/form-validation-framework.md
@@ -0,0 +1,111 @@
+# Shared form validation framework
+
+Closes #183.
+
+Before this, each dashboard form (asset registration, compliance/whitelist
+actions, minting) rolled its own validation and its own error markup —
+one global banner in some forms, an ad-hoc field message in others,
+different icons, different wording for "this field is required." The
+shared framework in `src/features/forms/validation/` gives every form the
+same building blocks so validation logic and error display look and behave
+the same way everywhere.
+
+It does **not** replace the existing per-domain validators
+(`assetCreationRequest.ts`, `whitelist.ts`, `mintRequest.ts`) — those still
+own the business rules for their domain (ticker format, duplicate checks,
+compliance guards, etc). This framework standardizes how *any* form —
+including those — tracks and displays field errors.
+
+## What's in the module
+
+| File | Purpose |
+| --- | --- |
+| `types.ts` | `FieldErrors`, `ValidationRule` — the shared shapes. |
+| `rules.ts` | Composable rule builders (`required`, `minLength`, `maxLength`, `pattern`, `numberInRange`, `notIn`, `oneOf`) plus `validateField` / `validateForm` runners. |
+| `useFormErrors.ts` | React hook that holds a form's `FieldErrors` state and exposes `setFieldError`, `clearFieldError`, `clearAll`, `errorFor`, `hasErrors`. |
+| `FormFieldError.tsx` | Renders a single field's error message under its input (icon + red text, `role="alert"`). Renders nothing when there's no message. |
+| `FormError.tsx` | Renders a form-level banner for errors that aren't tied to one field (e.g. a submit-time or async check failure). |
+
+Everything is re-exported from `src/features/forms/validation/index.ts`.
+
+## Using it in a new form
+
+```tsx
+import { useFormErrors, FormFieldError, FormError, validateForm, required, minLength, pattern } from '@/features/forms/validation';
+
+type Field = 'name' | 'ticker';
+
+function MyForm() {
+  const [name, setName] = useState('');
+  const [ticker, setTicker] = useState('');
+  const [formError, setFormError] = useState('');
+  const fieldErrors = useFormErrors<Field>();
+
+  const handleSubmit = () => {
+    const { errors, isValid } = validateForm<Field>(
+      { name, ticker },
+      {
+        name: [required('Name is required.'), minLength(3, 'Name must be at least 3 characters.')],
+        ticker: [required('Ticker is required.'), pattern(/^[A-Z0-9]{2,10}$/, 'Ticker must be 2-10 letters/numbers.')],
+      },
+    );
+
+    fieldErrors.setErrors(errors);
+    if (!isValid) return;
+
+    // ...submit
+  };
+
+  return (
+    <form>
+      <FormError message={formError} />
+
+      <label htmlFor="my-name">Name</label>
+      <input id="my-name" value={name} onChange={(e) => setName(e.target.value)} />
+      <FormFieldError message={fieldErrors.errorFor('name')} />
+
+      <label htmlFor="my-ticker">Ticker</label>
+      <input id="my-ticker" value={ticker} onChange={(e) => setTicker(e.target.value)} />
+      <FormFieldError message={fieldErrors.errorFor('ticker')} />
+    </form>
+  );
+}
+```
+
+## Adopting it in an existing form with its own validator
+
+If a form already has a domain validator that returns one error code at a
+time (like `validateAssetCreationRequest`), map each error code to the field
+it belongs to and route it through `fieldErrors.setFieldError`, falling back
+to the `FormError` banner for errors that aren't about a single field (e.g.
+"fill in every field"). See `AssetCreationWizard.tsx` for a worked example
+of this pattern (`ERROR_FIELD` map + `applyValidationError`).
+
+## Where it's used today
+
+- **`AssetCreationWizard`** (asset registration) — per-field errors for
+  asset name, ticker, amount, and jurisdiction; a `FormError` banner for
+  non-field-specific failures (e.g. missing fields).
+- **`WhitelistManager`** (compliance/admin) — per-field error under the
+  address input, replacing the previous single ad-hoc error paragraph.
+- **`MintWorkflow`** (minting) — its submit-time and async compliance-check
+  errors now render through the shared `FormError` banner instead of a
+  one-off `<div>`, so the visual style matches every other form.
+
+## Accessibility
+
+- `FormFieldError` and `FormError` both use `role="alert"` so assistive
+  technology announces new errors as they appear.
+- Pass an `id` to `FormFieldError` and wire it to the input's
+  `aria-describedby` (see the examples in `AssetCreationWizard.tsx` and
+  `WhitelistManager.tsx`) so screen readers announce the specific error
+  when the field is focused, not just when it first appears.
+
+## Testing
+
+`rules.test.ts` and `useFormErrors.test.ts` cover the pure logic and the
+hook in isolation (no DOM needed for the rules; `@testing-library/react`'s
+`renderHook` for the hook). Component-level tests for each form continue to
+assert on the rendered error text/role as before — adopting the shared
+framework didn't change any form's public behavior or copy, only how the
+error state and markup are produced internally.
diff --git a/src/features/asset-creation/components/AssetCreationWizard.tsx b/src/features/asset-creation/components/AssetCreationWizard.tsx
index 3a9f427..ad61480 100644
--- a/src/features/asset-creation/components/AssetCreationWizard.tsx
+++ b/src/features/asset-creation/components/AssetCreationWizard.tsx
@@ -4,10 +4,28 @@ import {
   ASSET_CREATION_ERROR_MESSAGES,
   SUPPORTED_JURISDICTIONS,
   ASSET_CLASS_OPTIONS,
+  type AssetCreationErrorCode,
 } from '@/lib/assetCreationRequest';
+import { useFormErrors, FormFieldError, FormError } from '@/features/forms/validation';
 import type { IssuanceRequest } from '@/fixtures/issuer';
 
 type WizardStep = 'form' | 'review' | 'success';
+type AssetCreationField = 'assetName' | 'ticker' | 'amount' | 'jurisdiction';
+
+/**
+ * `validateAssetCreationRequest` reports one error code at a time. Map each
+ * code to the field it belongs to so it renders under the right input via
+ * the shared `FormFieldError`; codes that aren't about a single field (e.g.
+ * several fields left blank) fall back to the form-level `FormError` banner.
+ */
+const ERROR_FIELD: Partial<Record<AssetCreationErrorCode, AssetCreationField>> = {
+  ASSET_NAME_TOO_SHORT: 'assetName',
+  INVALID_TICKER: 'ticker',
+  DUPLICATE_TICKER: 'ticker',
+  NON_POSITIVE_AMOUNT: 'amount',
+  AMOUNT_TOO_LARGE: 'amount',
+  UNSUPPORTED_JURISDICTION: 'jurisdiction',
+};
 
 export interface AssetCreationWizardProps {
   /** Tickers already registered, for duplicate-ticker validation. */
@@ -48,18 +66,34 @@ export default function AssetCreationWizard({
   const [amount, setAmount] = useState('');
   const [jurisdiction, setJurisdiction] = useState<string>(SUPPORTED_JURISDICTIONS[0]);
   const [assetClass, setAssetClass] = useState<string>(ASSET_CLASS_OPTIONS[0]);
-  const [error, setError] = useState('');
+  const [formError, setFormError] = useState('');
   const [lastCreated, setLastCreated] = useState<IssuanceRequest | null>(null);
+  const fieldErrors = useFormErrors<AssetCreationField>();
+
+  /** Routes a validation error code to the right field or the form banner. */
+  const applyValidationError = (code: AssetCreationErrorCode) => {
+    const message = ASSET_CREATION_ERROR_MESSAGES[code];
+    const field = ERROR_FIELD[code];
+    if (field) {
+      fieldErrors.clearAll();
+      fieldErrors.setFieldError(field, message);
+      setFormError('');
+    } else {
+      fieldErrors.clearAll();
+      setFormError(message);
+    }
+  };
 
   const handleReview = () => {
-    setError('');
+    setFormError('');
+    fieldErrors.clearAll();
     const validation = validateAssetCreationRequest(
       { assetName, ticker, amount, jurisdiction, assetClass },
       { existingTickers },
     );
 
     if (!validation.valid) {
-      setError(ASSET_CREATION_ERROR_MESSAGES[validation.error!]);
+      applyValidationError(validation.error!);
       return;
     }
 
@@ -75,7 +109,7 @@ export default function AssetCreationWizard({
     // Re-validate on confirm: existingTickers may have changed while the
     // user sat on the review screen (e.g. another request was created).
     if (!validation.valid || validation.parsedAmount === undefined) {
-      setError(ASSET_CREATION_ERROR_MESSAGES[validation.error!]);
+      applyValidationError(validation.error!);
       setStep('form');
       return;
     }
@@ -102,7 +136,8 @@ export default function AssetCreationWizard({
     setAmount('');
     setJurisdiction(SUPPORTED_JURISDICTIONS[0]);
     setAssetClass(ASSET_CLASS_OPTIONS[0]);
-    setError('');
+    setFormError('');
+    fieldErrors.clearAll();
     setLastCreated(null);
     setStep('form');
   };
@@ -168,11 +203,7 @@ export default function AssetCreationWizard({
           </div>
         </dl>
 
-        {error && (
-          <div role="alert" className="bg-red-50 text-red-600 p-3 rounded mb-4 text-sm">
-            {error}
-          </div>
-        )}
+        <FormError message={formError} />
 
         <p className="text-xs text-slate-500 mb-4">
           Submitting sends this asset for compliance review. This is a protocol-level
@@ -207,11 +238,7 @@ export default function AssetCreationWizard({
         approval — this does not mint supply directly.
       </p>
 
-      {error && (
-        <div role="alert" className="bg-red-50 text-red-600 p-3 rounded mb-4 text-sm">
-          {error}
-        </div>
-      )}
+      <FormError message={formError} />
 
       <div className="space-y-4 mb-6">
         <div>
@@ -225,7 +252,9 @@ export default function AssetCreationWizard({
             placeholder="Manhattan Commercial Real Estate"
             value={assetName}
             onChange={(e) => setAssetName(e.target.value)}
+            aria-describedby={fieldErrors.errorFor('assetName') ? 'ac-asset-name-error' : undefined}
           />
+          <FormFieldError id="ac-asset-name-error" message={fieldErrors.errorFor('assetName')} />
         </div>
 
         <div>
@@ -241,7 +270,9 @@ export default function AssetCreationWizard({
             onChange={(e) => setTicker(e.target.value)}
             autoComplete="off"
             spellCheck={false}
+            aria-describedby={fieldErrors.errorFor('ticker') ? 'ac-ticker-error' : undefined}
           />
+          <FormFieldError id="ac-ticker-error" message={fieldErrors.errorFor('ticker')} />
         </div>
 
         <div>
@@ -275,7 +306,9 @@ export default function AssetCreationWizard({
             onChange={(e) => setAmount(e.target.value)}
             min="0"
             step="any"
+            aria-describedby={fieldErrors.errorFor('amount') ? 'ac-amount-error' : undefined}
           />
+          <FormFieldError id="ac-amount-error" message={fieldErrors.errorFor('amount')} />
         </div>
 
         <div>
@@ -287,6 +320,9 @@ export default function AssetCreationWizard({
             className="w-full border border-slate-300 rounded p-2 focus:ring-2 focus:ring-aegis-brand outline-none bg-white"
             value={jurisdiction}
             onChange={(e) => setJurisdiction(e.target.value)}
+            aria-describedby={
+              fieldErrors.errorFor('jurisdiction') ? 'ac-jurisdiction-error' : undefined
+            }
           >
             {SUPPORTED_JURISDICTIONS.map((option) => (
               <option key={option} value={option}>
@@ -294,6 +330,7 @@ export default function AssetCreationWizard({
               </option>
             ))}
           </select>
+          <FormFieldError id="ac-jurisdiction-error" message={fieldErrors.errorFor('jurisdiction')} />
         </div>
       </div>
 
diff --git a/src/features/compliance/components/WhitelistManager.tsx b/src/features/compliance/components/WhitelistManager.tsx
index 633b0c9..38aadbf 100644
--- a/src/features/compliance/components/WhitelistManager.tsx
+++ b/src/features/compliance/components/WhitelistManager.tsx
@@ -11,8 +11,11 @@ import {
   guardWhitelistAction,
   type WhitelistEntry,
 } from '@/lib/whitelist';
+import { useFormErrors, FormFieldError } from '@/features/forms/validation';
 import { formatTimestamp, truncateAddress } from '@/utils/formatting';
 
+type WhitelistFormField = 'address';
+
 type LoadState = 'loading' | 'loaded' | 'error';
 
 interface PendingAction {
@@ -37,7 +40,7 @@ export default function WhitelistManager() {
 
   const [newAddress, setNewAddress] = useState('');
   const [newNote, setNewNote] = useState('');
-  const [formError, setFormError] = useState<string | null>(null);
+  const fieldErrors = useFormErrors<WhitelistFormField>();
 
   const [pendingAction, setPendingAction] = useState<PendingAction | null>(null);
 
@@ -66,17 +69,17 @@ export default function WhitelistManager() {
 
     const validation = validateWhitelistAddress(address);
     if (!validation.valid) {
-      setFormError(validation.reason);
+      fieldErrors.setFieldError('address', validation.reason);
       return;
     }
 
     const guardReason = guardWhitelistAction(entries, address, 'add');
     if (guardReason) {
-      setFormError(guardReason);
+      fieldErrors.setFieldError('address', guardReason);
       return;
     }
 
-    setFormError(null);
+    fieldErrors.clearAll();
     setPendingAction({ action: 'add', address, note: newNote.trim() || undefined });
   };
 
@@ -124,6 +127,13 @@ export default function WhitelistManager() {
             onChange={(e) => setNewAddress(e.target.value)}
             placeholder="GABC…"
             className="w-full border border-slate-300 rounded p-2 font-mono text-sm focus:ring-2 focus:ring-aegis-brand outline-none"
+            aria-describedby={
+              fieldErrors.errorFor('address') ? 'whitelist-new-address-error' : undefined
+            }
+          />
+          <FormFieldError
+            id="whitelist-new-address-error"
+            message={fieldErrors.errorFor('address')}
           />
         </div>
 
@@ -144,13 +154,6 @@ export default function WhitelistManager() {
           />
         </div>
 
-        {formError && (
-          <p role="alert" className="flex items-center gap-2 text-sm text-red-600">
-            <AlertTriangle size={14} className="shrink-0" aria-hidden="true" />
-            {formError}
-          </p>
-        )}
-
         <button
           type="submit"
           disabled={!newAddress.trim()}
diff --git a/src/features/forms/validation/FormError.tsx b/src/features/forms/validation/FormError.tsx
new file mode 100644
index 0000000..4aef9fe
--- /dev/null
+++ b/src/features/forms/validation/FormError.tsx
@@ -0,0 +1,29 @@
+import { AlertTriangle } from 'lucide-react';
+
+export interface FormErrorProps {
+  /** The error message to display. Renders nothing when `undefined`/empty. */
+  message?: string;
+}
+
+/**
+ * Consistent form-level error banner, for errors that aren't tied to a
+ * single field (e.g. a submit-time failure, a duplicate-ticker rejection,
+ * or an async check like compliance/whitelist status). Pair with
+ * `FormFieldError` for individual field errors so every form in the
+ * dashboard shows errors the same way.
+ *
+ * @see docs/form-validation-framework.md
+ */
+export default function FormError({ message }: FormErrorProps) {
+  if (!message) return null;
+
+  return (
+    <div
+      role="alert"
+      className="mb-4 flex items-start gap-2 rounded bg-red-50 p-3 text-sm text-red-600"
+    >
+      <AlertTriangle size={16} className="mt-0.5 shrink-0" aria-hidden="true" />
+      <span>{message}</span>
+    </div>
+  );
+}
diff --git a/src/features/forms/validation/FormFieldError.tsx b/src/features/forms/validation/FormFieldError.tsx
new file mode 100644
index 0000000..3df004b
--- /dev/null
+++ b/src/features/forms/validation/FormFieldError.tsx
@@ -0,0 +1,27 @@
+import { AlertTriangle } from 'lucide-react';
+
+export interface FormFieldErrorProps {
+  /** The error message to display. Renders nothing when `undefined`/empty. */
+  message?: string;
+  /** id to pair with the input's `aria-describedby`, for screen readers. */
+  id?: string;
+}
+
+/**
+ * Consistent inline field error, used under any labeled input across the
+ * dashboard's forms (asset registration, compliance/whitelist actions,
+ * minting, admin forms). Renders `null` when there's no message so callers
+ * can render it unconditionally.
+ *
+ * @see docs/form-validation-framework.md
+ */
+export default function FormFieldError({ message, id }: FormFieldErrorProps) {
+  if (!message) return null;
+
+  return (
+    <p id={id} role="alert" className="mt-1 flex items-center gap-1.5 text-sm text-red-600">
+      <AlertTriangle size={14} className="shrink-0" aria-hidden="true" />
+      {message}
+    </p>
+  );
+}
diff --git a/src/features/forms/validation/index.ts b/src/features/forms/validation/index.ts
new file mode 100644
index 0000000..536f8d7
--- /dev/null
+++ b/src/features/forms/validation/index.ts
@@ -0,0 +1,15 @@
+export type { FieldErrors, ValidationRule, FieldValidationResult } from './types';
+export {
+  required,
+  minLength,
+  maxLength,
+  pattern,
+  numberInRange,
+  notIn,
+  oneOf,
+  validateField,
+  validateForm,
+} from './rules';
+export { useFormErrors, type UseFormErrors } from './useFormErrors';
+export { default as FormFieldError, type FormFieldErrorProps } from './FormFieldError';
+export { default as FormError, type FormErrorProps } from './FormError';
diff --git a/src/features/forms/validation/rules.test.ts b/src/features/forms/validation/rules.test.ts
new file mode 100644
index 0000000..e4431da
--- /dev/null
+++ b/src/features/forms/validation/rules.test.ts
@@ -0,0 +1,152 @@
+import { describe, expect, it } from 'vitest';
+import {
+  maxLength,
+  minLength,
+  notIn,
+  numberInRange,
+  oneOf,
+  pattern,
+  required,
+  validateField,
+  validateForm,
+} from './rules';
+
+describe('required', () => {
+  it('fails on empty or whitespace-only values', () => {
+    expect(required('req')('')).toBe('req');
+    expect(required('req')('   ')).toBe('req');
+  });
+
+  it('passes when a value is present', () => {
+    expect(required('req')('hello')).toBeUndefined();
+  });
+
+  it('uses a default message when none is given', () => {
+    expect(required()('')).toBe('This field is required.');
+  });
+});
+
+describe('minLength / maxLength', () => {
+  it('minLength fails below the threshold but passes on empty (defers to required)', () => {
+    expect(minLength(3, 'too short')('ab')).toBe('too short');
+    expect(minLength(3, 'too short')('abc')).toBeUndefined();
+    expect(minLength(3, 'too short')('')).toBeUndefined();
+  });
+
+  it('maxLength fails above the threshold but passes on empty', () => {
+    expect(maxLength(3, 'too long')('abcd')).toBe('too long');
+    expect(maxLength(3, 'too long')('abc')).toBeUndefined();
+    expect(maxLength(3, 'too long')('')).toBeUndefined();
+  });
+});
+
+describe('pattern', () => {
+  const ticker = pattern(/^[A-Z0-9]{2,10}$/, 'bad ticker');
+
+  it('fails when the value does not match', () => {
+    expect(ticker('ny-cre!')).toBe('bad ticker');
+  });
+
+  it('passes when the value matches, and passes on empty', () => {
+    expect(ticker('NYCRE')).toBeUndefined();
+    expect(ticker('')).toBeUndefined();
+  });
+});
+
+describe('numberInRange', () => {
+  it('rejects non-numeric input', () => {
+    expect(numberInRange(0)('abc')).toBe('Enter a valid number.');
+  });
+
+  it('enforces the lower bound', () => {
+    expect(numberInRange(1)('0')).toBe('Must be at least 1.');
+    expect(numberInRange(1)('1')).toBeUndefined();
+  });
+
+  it('enforces the upper bound when provided', () => {
+    expect(numberInRange(0, 100)('101')).toBe('Must be no more than 100.');
+    expect(numberInRange(0, 100)('100')).toBeUndefined();
+  });
+
+  it('has no upper bound when max is omitted', () => {
+    expect(numberInRange(0)('1000000')).toBeUndefined();
+  });
+
+  it('passes on empty, deferring to required', () => {
+    expect(numberInRange(0, 100)('')).toBeUndefined();
+  });
+});
+
+describe('notIn', () => {
+  it('rejects case-insensitive, trimmed duplicates', () => {
+    const rule = notIn(['NY-CRE', 'UST-6M'], 'duplicate');
+    expect(rule('ny-cre')).toBe('duplicate');
+    expect(rule('  NY-CRE  ')).toBe('duplicate');
+    expect(rule('NEW-TICKER')).toBeUndefined();
+  });
+});
+
+describe('oneOf', () => {
+  const rule = oneOf(['US', 'EU', 'SG'], 'unsupported');
+
+  it('rejects values not in the option list', () => {
+    expect(rule('FR')).toBe('unsupported');
+  });
+
+  it('accepts values in the option list, and passes on empty', () => {
+    expect(rule('US')).toBeUndefined();
+    expect(rule('')).toBeUndefined();
+  });
+});
+
+describe('validateField', () => {
+  it('returns the first failing rule and stops (does not run later rules)', () => {
+    let secondRuleRan = false;
+    const rules = [
+      required('required'),
+      () => {
+        secondRuleRan = true;
+        return 'second';
+      },
+    ];
+    expect(validateField('', rules)).toBe('required');
+    expect(secondRuleRan).toBe(false);
+  });
+
+  it('returns undefined when every rule passes', () => {
+    expect(validateField('abc', [required(), minLength(2)])).toBeUndefined();
+  });
+});
+
+describe('validateForm', () => {
+  type Field = 'assetName' | 'ticker';
+
+  const schema: Partial<Record<Field, ReturnType<typeof required>[]>> = {
+    assetName: [required('Name required'), minLength(3, 'Name too short')],
+    ticker: [required('Ticker required'), pattern(/^[A-Z0-9]{2,10}$/, 'Bad ticker')],
+  };
+
+  it('collects one error per invalid field and reports isValid: false', () => {
+    const { errors, isValid } = validateForm<Field>({ assetName: 'ab', ticker: '' }, schema);
+    expect(errors).toEqual({ assetName: 'Name too short', ticker: 'Ticker required' });
+    expect(isValid).toBe(false);
+  });
+
+  it('omits passing fields from the errors object entirely', () => {
+    const { errors } = validateForm<Field>(
+      { assetName: 'Manhattan CRE', ticker: '' },
+      schema,
+    );
+    expect('assetName' in errors).toBe(false);
+    expect(errors.ticker).toBe('Ticker required');
+  });
+
+  it('reports isValid: true and an empty errors object when everything passes', () => {
+    const { errors, isValid } = validateForm<Field>(
+      { assetName: 'Manhattan CRE', ticker: 'NYCRE' },
+      schema,
+    );
+    expect(errors).toEqual({});
+    expect(isValid).toBe(true);
+  });
+});
diff --git a/src/features/forms/validation/rules.ts b/src/features/forms/validation/rules.ts
new file mode 100644
index 0000000..a0c5115
--- /dev/null
+++ b/src/features/forms/validation/rules.ts
@@ -0,0 +1,124 @@
+/**
+ * Reusable, composable field validation rules.
+ *
+ * Each helper *returns* a `ValidationRule` (a function), so rules read
+ * declaratively at the call site:
+ *
+ *   validateField(assetName, [required('Asset name is required.'), minLength(3, '...')])
+ *
+ * @see docs/form-validation-framework.md
+ */
+import type { ValidationRule } from './types';
+
+/** Fails when the (trimmed) value is empty. */
+export function required(message = 'This field is required.'): ValidationRule<string> {
+  return (value) => (value.trim() ? undefined : message);
+}
+
+/** Fails when the (trimmed) value is shorter than `min` characters. Passes on empty — pair with `required`. */
+export function minLength(min: number, message?: string): ValidationRule<string> {
+  return (value) => {
+    const v = value.trim();
+    if (!v) return undefined;
+    return v.length < min ? message ?? `Must be at least ${min} characters.` : undefined;
+  };
+}
+
+/** Fails when the (trimmed) value is longer than `max` characters. Passes on empty — pair with `required`. */
+export function maxLength(max: number, message?: string): ValidationRule<string> {
+  return (value) => {
+    const v = value.trim();
+    if (!v) return undefined;
+    return v.length > max ? message ?? `Must be no more than ${max} characters.` : undefined;
+  };
+}
+
+/** Fails when the (trimmed) value doesn't match `regex`. Passes on empty — pair with `required`. */
+export function pattern(regex: RegExp, message: string): ValidationRule<string> {
+  return (value) => {
+    const v = value.trim();
+    if (!v) return undefined;
+    return regex.test(v) ? undefined : message;
+  };
+}
+
+/**
+ * Fails when the value doesn't parse as a finite number in the given range.
+ * `max` is optional (no upper bound if omitted). Passes on empty — pair with `required`.
+ */
+export function numberInRange(
+  min: number,
+  max?: number,
+  message?: string,
+): ValidationRule<string> {
+  return (value) => {
+    const v = value.trim();
+    if (!v) return undefined;
+    const n = Number(v);
+    if (!Number.isFinite(n)) return message ?? 'Enter a valid number.';
+    if (n < min) return message ?? `Must be at least ${min}.`;
+    if (max !== undefined && n > max) return message ?? `Must be no more than ${max}.`;
+    return undefined;
+  };
+}
+
+/** Fails when the (case-insensitive, trimmed) value is already present in `values`. */
+export function notIn(values: string[], message: string): ValidationRule<string> {
+  const lowered = values.map((v) => v.trim().toLowerCase());
+  return (value) => {
+    const v = value.trim().toLowerCase();
+    if (!v) return undefined;
+    return lowered.includes(v) ? message : undefined;
+  };
+}
+
+/** Fails when the (trimmed) value isn't one of `options` (case-sensitive). Passes on empty — pair with `required`. */
+export function oneOf(options: readonly string[], message: string): ValidationRule<string> {
+  return (value) => {
+    const v = value.trim();
+    if (!v) return undefined;
+    return (options as string[]).includes(v) ? undefined : message;
+  };
+}
+
+/**
+ * Runs `rules` in order against `value` and returns the first failure
+ * message, or `undefined` if every rule passes.
+ */
+export function validateField<TValue>(
+  value: TValue,
+  rules: ValidationRule<TValue>[],
+): string | undefined {
+  for (const rule of rules) {
+    const error = rule(value);
+    if (error) return error;
+  }
+  return undefined;
+}
+
+/**
+ * Validates a whole form in one pass. `schema` maps each field name to the
+ * rules that apply to it. Returns a `FieldErrors` object containing only
+ * the fields that failed (fields that passed are omitted, not set to
+ * `undefined`), plus a convenience `isValid` flag.
+ *
+ * `TFields` is the union of field-name string literals (e.g.
+ * `'assetName' | 'ticker'`), not the form's value interface — this keeps the
+ * helper usable with any plain string-keyed form values.
+ */
+export function validateForm<TFields extends string>(
+  values: Record<TFields, string>,
+  schema: Partial<Record<TFields, ValidationRule<string>[]>>,
+): { errors: Partial<Record<TFields, string>>; isValid: boolean } {
+  const errors: Partial<Record<TFields, string>> = {};
+
+  for (const field in schema) {
+    const key = field as TFields;
+    const rules = schema[key];
+    if (!rules) continue;
+    const error = validateField(values[key], rules);
+    if (error) errors[key] = error;
+  }
+
+  return { errors, isValid: Object.keys(errors).length === 0 };
+}
diff --git a/src/features/forms/validation/types.ts b/src/features/forms/validation/types.ts
new file mode 100644
index 0000000..ccaa04e
--- /dev/null
+++ b/src/features/forms/validation/types.ts
@@ -0,0 +1,26 @@
+/**
+ * Shared form validation framework — core types.
+ *
+ * Framework-agnostic (no React) so rules can be unit-tested in isolation,
+ * mirroring the pattern already used by assetCreationRequest.ts, whitelist.ts,
+ * and mintRequest.ts. This module doesn't replace those per-domain validators
+ * — it gives every form in the dashboard the same *shape* for field errors
+ * and the same building blocks for writing new rules, so the display layer
+ * (FormFieldError / FormError) and any future form can rely on one contract.
+ *
+ * @see docs/form-validation-framework.md
+ */
+
+/** Map of field name -> current error message (absent/undefined = no error). */
+export type FieldErrors<TFields extends string = string> = Partial<Record<TFields, string>>;
+
+/**
+ * A single validation rule. Returns an error message when the value is
+ * invalid, or `undefined` when it passes. Rules receive the *whole* field
+ * value already trimmed by the caller where trimming makes sense — rules
+ * themselves stay pure and synchronous.
+ */
+export type ValidationRule<TValue = string> = (value: TValue) => string | undefined;
+
+/** Result of validating a single field: the first failing rule's message, if any. */
+export type FieldValidationResult = string | undefined;
diff --git a/src/features/forms/validation/useFormErrors.test.ts b/src/features/forms/validation/useFormErrors.test.ts
new file mode 100644
index 0000000..b474868
--- /dev/null
+++ b/src/features/forms/validation/useFormErrors.test.ts
@@ -0,0 +1,67 @@
+import { act, renderHook } from '@testing-library/react';
+import { describe, expect, it } from 'vitest';
+import { useFormErrors } from './useFormErrors';
+
+type Fields = 'assetName' | 'ticker';
+
+describe('useFormErrors', () => {
+  it('starts with no errors', () => {
+    const { result } = renderHook(() => useFormErrors<Fields>());
+    expect(result.current.errors).toEqual({});
+    expect(result.current.hasErrors).toBe(false);
+    expect(result.current.errorFor('ticker')).toBeUndefined();
+  });
+
+  it('setFieldError sets a single field and leaves others untouched', () => {
+    const { result } = renderHook(() => useFormErrors<Fields>());
+
+    act(() => result.current.setFieldError('ticker', 'Bad ticker'));
+
+    expect(result.current.errorFor('ticker')).toBe('Bad ticker');
+    expect(result.current.errorFor('assetName')).toBeUndefined();
+    expect(result.current.hasErrors).toBe(true);
+  });
+
+  it('setFieldError with undefined clears that field only', () => {
+    const { result } = renderHook(() => useFormErrors<Fields>());
+
+    act(() => {
+      result.current.setFieldError('ticker', 'Bad ticker');
+      result.current.setFieldError('assetName', 'Too short');
+    });
+    act(() => result.current.setFieldError('ticker', undefined));
+
+    expect(result.current.errorFor('ticker')).toBeUndefined();
+    expect(result.current.errorFor('assetName')).toBe('Too short');
+    expect(result.current.hasErrors).toBe(true);
+  });
+
+  it('clearFieldError removes a single field error', () => {
+    const { result } = renderHook(() => useFormErrors<Fields>());
+
+    act(() => result.current.setFieldError('assetName', 'Too short'));
+    act(() => result.current.clearFieldError('assetName'));
+
+    expect(result.current.errorFor('assetName')).toBeUndefined();
+    expect(result.current.hasErrors).toBe(false);
+  });
+
+  it('setErrors replaces the whole map (e.g. from validateForm)', () => {
+    const { result } = renderHook(() => useFormErrors<Fields>());
+
+    act(() => result.current.setErrors({ ticker: 'Bad ticker', assetName: 'Too short' }));
+
+    expect(result.current.errors).toEqual({ ticker: 'Bad ticker', assetName: 'Too short' });
+    expect(result.current.hasErrors).toBe(true);
+  });
+
+  it('clearAll removes every error', () => {
+    const { result } = renderHook(() => useFormErrors<Fields>());
+
+    act(() => result.current.setErrors({ ticker: 'Bad ticker', assetName: 'Too short' }));
+    act(() => result.current.clearAll());
+
+    expect(result.current.errors).toEqual({});
+    expect(result.current.hasErrors).toBe(false);
+  });
+});
diff --git a/src/features/forms/validation/useFormErrors.ts b/src/features/forms/validation/useFormErrors.ts
new file mode 100644
index 0000000..8934b2c
--- /dev/null
+++ b/src/features/forms/validation/useFormErrors.ts
@@ -0,0 +1,71 @@
+/**
+ * Shared React hook for managing a form's field-level error state.
+ *
+ * Every form that adopts this framework gets the same API for reading and
+ * clearing errors, so `FormFieldError` / `FormError` can be dropped in
+ * without each form re-inventing its own error-state shape.
+ *
+ * @see docs/form-validation-framework.md
+ */
+import { useCallback, useMemo, useState } from 'react';
+import type { FieldErrors } from './types';
+
+export interface UseFormErrors<TFields extends string> {
+  /** Current field -> message map. Only fields with an active error are present. */
+  errors: FieldErrors<TFields>;
+  /** Replaces the entire error map (e.g. with the result of `validateForm`). */
+  setErrors: (errors: FieldErrors<TFields>) => void;
+  /** Sets (or clears, when `message` is undefined) a single field's error. */
+  setFieldError: (field: TFields, message: string | undefined) => void;
+  /** Clears a single field's error, if any. */
+  clearFieldError: (field: TFields) => void;
+  /** Clears every field error. */
+  clearAll: () => void;
+  /** The error message for `field`, or `undefined` if it currently has none. */
+  errorFor: (field: TFields) => string | undefined;
+  /** True when at least one field currently has an error. */
+  hasErrors: boolean;
+}
+
+/**
+ * Manages a `FieldErrors` map for a form with fields `TFields`.
+ *
+ * @example
+ * const form = useFormErrors<'assetName' | 'ticker'>();
+ * const { errors, isValid } = validateForm(values, schema);
+ * form.setErrors(errors);
+ * // ...
+ * <FormFieldError message={form.errorFor('ticker')} />
+ */
+export function useFormErrors<TFields extends string>(): UseFormErrors<TFields> {
+  const [errors, setErrorsState] = useState<FieldErrors<TFields>>({});
+
+  const setErrors = useCallback((next: FieldErrors<TFields>) => {
+    setErrorsState(next);
+  }, []);
+
+  const setFieldError = useCallback((field: TFields, message: string | undefined) => {
+    setErrorsState((prev) => {
+      if (!message) {
+        if (!(field in prev)) return prev;
+        const next = { ...prev };
+        delete next[field];
+        return next;
+      }
+      return { ...prev, [field]: message };
+    });
+  }, []);
+
+  const clearFieldError = useCallback(
+    (field: TFields) => setFieldError(field, undefined),
+    [setFieldError],
+  );
+
+  const clearAll = useCallback(() => setErrorsState({}), []);
+
+  const errorFor = useCallback((field: TFields) => errors[field], [errors]);
+
+  const hasErrors = useMemo(() => Object.keys(errors).length > 0, [errors]);
+
+  return { errors, setErrors, setFieldError, clearFieldError, clearAll, errorFor, hasErrors };
+}
diff --git a/src/features/minting/components/MintWorkflow.tsx b/src/features/minting/components/MintWorkflow.tsx
index f28129b..428b429 100644
--- a/src/features/minting/components/MintWorkflow.tsx
+++ b/src/features/minting/components/MintWorkflow.tsx
@@ -14,6 +14,7 @@ import type {
   TransactionState,
 } from '@/components/transactions/types';
 import { useIdempotentSubmit } from '@/features/forms/idempotency';
+import { FormError } from '@/features/forms/validation';
 import { validateMintRequest, MINT_ERROR_MESSAGES } from '@/lib/mintRequest';
 import {
   buildRecoveryPlan,
@@ -255,11 +256,7 @@ export default function MintWorkflow({
           Recipient compliance is checked before the review screen.
         </p>
 
-        {error && (
-          <div role="alert" className="bg-red-50 text-red-600 p-3 rounded mb-4 text-sm">
-            {error}
-          </div>
-        )}
+        <FormError message={error} />
 
         <div className="space-y-4 mb-6">
           <div>