diff --git a/src/components/WalletConnectButton.tsx b/src/components/WalletConnectButton.tsx
index b94fbd8f..d1817d7e 100644
--- a/src/components/WalletConnectButton.tsx
+++ b/src/components/WalletConnectButton.tsx
@@ -54,7 +54,7 @@ export const WalletConnectButton = () => {
         <span className="text-sm font-medium">Connection Error</span>
         <button
           onClick={connect}
-          className="ml-2 text-sm font-semibold underline hover:text-red-700"
+          className="ml-2 rounded text-sm font-semibold underline hover:text-red-700 focus:outline-none focus-visible:ring-2 focus-visible:ring-[var(--ring)] focus-visible:ring-offset-1"
           aria-label="Retry wallet connection"
         >
           Retry
diff --git a/src/components/__tests__/Navbar.test.tsx b/src/components/__tests__/Navbar.test.tsx
index aa824906..63958313 100644
--- a/src/components/__tests__/Navbar.test.tsx
+++ b/src/components/__tests__/Navbar.test.tsx
@@ -1,5 +1,6 @@
 import React from 'react';
 import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
 import { axe, toHaveNoViolations } from 'jest-axe';
 import Navbar from '../Navbar';
 
@@ -108,4 +109,84 @@ describe('Navbar', () => {
 
     expect(results).toHaveNoViolations();
   });
-});
\ No newline at end of file
+});
+
+// ---------------------------------------------------------------------------
+// Keyboard operation
+// ---------------------------------------------------------------------------
+
+describe('Navbar — keyboard operation', () => {
+  beforeEach(() => {
+    mockUsePathname.mockReturnValue('/');
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('each link receives focus when tabbed to', async () => {
+    const user = userEvent.setup();
+    render(<Navbar />);
+
+    // Tab into the nav: the first link should receive focus.
+    await user.tab();
+    expect(screen.getByRole('link', { name: 'Contracts' })).toHaveFocus();
+
+    // Second tab moves to Milestones.
+    await user.tab();
+    expect(screen.getByRole('link', { name: 'Milestones' })).toHaveFocus();
+
+    // Third tab moves to Reputation.
+    await user.tab();
+    expect(screen.getByRole('link', { name: 'Reputation' })).toHaveFocus();
+  });
+
+  it('Shift+Tab reverses focus order through the links', async () => {
+    const user = userEvent.setup();
+    render(<Navbar />);
+
+    // Move focus forward to the last link first.
+    const reputationLink = screen.getByRole('link', { name: 'Reputation' });
+    reputationLink.focus();
+    expect(reputationLink).toHaveFocus();
+
+    await user.tab({ shift: true });
+    expect(screen.getByRole('link', { name: 'Milestones' })).toHaveFocus();
+
+    await user.tab({ shift: true });
+    expect(screen.getByRole('link', { name: 'Contracts' })).toHaveFocus();
+  });
+
+  it('Enter key activates a focused link (native browser behaviour is preserved)', async () => {
+    const user = userEvent.setup();
+    render(<Navbar />);
+
+    // Links delegate navigation to the browser; verify the element is
+    // focusable and survives an Enter keypress without throwing.
+    const contractsLink = screen.getByRole('link', { name: 'Contracts' });
+    contractsLink.focus();
+    expect(contractsLink).toHaveFocus();
+
+    await user.keyboard('{Enter}');
+    expect(contractsLink).toBeInTheDocument();
+  });
+
+  it('focus ring utility classes are present on every link (visible indicator)', () => {
+    render(<Navbar />);
+
+    screen.getAllByRole('link').forEach((link) => {
+      expect(link.className).toContain('focus:ring-2');
+      expect(link.className).toContain('focus:outline-none');
+      expect(link.className).toContain('focus:ring-[var(--ring)]');
+    });
+  });
+
+  it('no link has a negative tabindex that would exclude it from the tab sequence', () => {
+    render(<Navbar />);
+
+    screen.getAllByRole('link').forEach((link) => {
+      // tabIndex defaults to 0 for anchor elements; -1 would remove from sequence.
+      expect(link).not.toHaveAttribute('tabindex', '-1');
+    });
+  });
+});
diff --git a/src/components/__tests__/WalletConnectButton.test.tsx b/src/components/__tests__/WalletConnectButton.test.tsx
index 1c8edeb3..46e713e4 100644
--- a/src/components/__tests__/WalletConnectButton.test.tsx
+++ b/src/components/__tests__/WalletConnectButton.test.tsx
@@ -5,7 +5,7 @@ import '@testing-library/jest-dom';
 import { WalletConnectButton } from '../WalletConnectButton';
 import { WalletContextType, useWallet } from '@/contexts/WalletContext';
 import * as truncateAddressModule from '@/lib/truncateAddress';
-import { testA11y } from '@/test-utils/a11y';
+import { axe, testA11y } from '@/test-utils/a11y';
 
 jest.mock('@/contexts/WalletContext', () => ({
   useWallet: jest.fn(),
@@ -385,3 +385,385 @@ describe('WalletConnectButton', () => {
     jest.useFakeTimers();
   });
 });
+
+// ---------------------------------------------------------------------------
+// Keyboard operation
+// ---------------------------------------------------------------------------
+
+describe('WalletConnectButton — keyboard operation', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    act(() => {
+      jest.runOnlyPendingTimers();
+    });
+    jest.useRealTimers();
+    Object.defineProperty(navigator, 'clipboard', {
+      configurable: true,
+      value: originalClipboard,
+    });
+  });
+
+  // --- Connect button (disconnected state) ---
+
+  it('Connect Wallet button is reachable by Tab', async () => {
+    const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
+    mockUseWallet.mockReturnValue(createWalletState());
+
+    render(<WalletConnectButton />);
+
+    await user.tab();
+    expect(screen.getByRole('button', { name: 'Connect wallet' })).toHaveFocus();
+  });
+
+  it('Enter key activates Connect Wallet button', async () => {
+    const connect = jest.fn();
+    const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
+    mockUseWallet.mockReturnValue(createWalletState({ connect }));
+
+    render(<WalletConnectButton />);
+
+    const btn = screen.getByRole('button', { name: 'Connect wallet' });
+    btn.focus();
+    await user.keyboard('{Enter}');
+
+    expect(connect).toHaveBeenCalledTimes(1);
+  });
+
+  it('Space key activates Connect Wallet button', async () => {
+    const connect = jest.fn();
+    const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
+    mockUseWallet.mockReturnValue(createWalletState({ connect }));
+
+    render(<WalletConnectButton />);
+
+    const btn = screen.getByRole('button', { name: 'Connect wallet' });
+    btn.focus();
+    await user.keyboard('[Space]');
+
+    expect(connect).toHaveBeenCalledTimes(1);
+  });
+
+  it('Connect Wallet button carries visible focus-ring classes', () => {
+    mockUseWallet.mockReturnValue(createWalletState());
+    render(<WalletConnectButton />);
+
+    const btn = screen.getByRole('button', { name: 'Connect wallet' });
+    expect(btn.className).toContain('focus:outline-none');
+    expect(btn.className).toMatch(/focus:ring-2/);
+  });
+
+  // --- Connecting state (disabled button) ---
+
+  it('Connect Wallet button is disabled (not in tab sequence) while connecting', () => {
+    mockUseWallet.mockReturnValue(createWalletState({ isConnecting: true }));
+    render(<WalletConnectButton />);
+
+    const btn = screen.getByRole('button', { name: 'Connect wallet' });
+    // Disabled buttons are still focusable in the DOM but must be marked disabled
+    // so that AT announces them correctly and click handlers are suppressed.
+    expect(btn).toBeDisabled();
+  });
+
+  // --- Error state — Retry button ---
+
+  it('Retry button is reachable by Tab in the error state', async () => {
+    const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
+    mockUseWallet.mockReturnValue(
+      createWalletState({ error: 'Connection failed', connect: jest.fn() }),
+    );
+
+    render(<WalletConnectButton />);
+
+    await user.tab();
+    expect(screen.getByRole('button', { name: 'Retry wallet connection' })).toHaveFocus();
+  });
+
+  it('Enter key activates Retry button', async () => {
+    const connect = jest.fn();
+    const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
+    mockUseWallet.mockReturnValue(createWalletState({ error: 'Connection failed', connect }));
+
+    render(<WalletConnectButton />);
+
+    const retryBtn = screen.getByRole('button', { name: 'Retry wallet connection' });
+    retryBtn.focus();
+    await user.keyboard('{Enter}');
+
+    expect(connect).toHaveBeenCalledTimes(1);
+  });
+
+  it('Space key activates Retry button', async () => {
+    const connect = jest.fn();
+    const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
+    mockUseWallet.mockReturnValue(createWalletState({ error: 'Connection failed', connect }));
+
+    render(<WalletConnectButton />);
+
+    const retryBtn = screen.getByRole('button', { name: 'Retry wallet connection' });
+    retryBtn.focus();
+    await user.keyboard('[Space]');
+
+    expect(connect).toHaveBeenCalledTimes(1);
+  });
+
+  it('Retry button carries visible focus-ring classes', () => {
+    mockUseWallet.mockReturnValue(
+      createWalletState({ error: 'Connection failed', connect: jest.fn() }),
+    );
+    render(<WalletConnectButton />);
+
+    const retryBtn = screen.getByRole('button', { name: 'Retry wallet connection' });
+    expect(retryBtn.className).toContain('focus:outline-none');
+    expect(retryBtn.className).toMatch(/focus-visible:ring-2/);
+  });
+
+  // --- Connected state — Copy and Disconnect buttons ---
+
+  it('Copy and Disconnect buttons are reachable by Tab in the connected state', async () => {
+    const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
+    mockUseWallet.mockReturnValue(
+      createWalletState({ address: '0xABCDEF1234567890abcdef1234567890abcdef12' }),
+    );
+    installClipboardMock();
+
+    render(<WalletConnectButton />);
+
+    await user.tab();
+    expect(screen.getByRole('button', { name: 'Copy address to clipboard' })).toHaveFocus();
+
+    await user.tab();
+    expect(screen.getByRole('button', { name: 'Disconnect wallet' })).toHaveFocus();
+  });
+
+  it('Enter key activates the Copy button', async () => {
+    const writeText = installClipboardMock();
+    const address = '0xABCDEF1234567890abcdef1234567890abcdef12';
+    mockUseWallet.mockReturnValue(createWalletState({ address }));
+
+    render(<WalletConnectButton />);
+
+    const copyBtn = screen.getByRole('button', { name: 'Copy address to clipboard' });
+    copyBtn.focus();
+    expect(copyBtn).toHaveFocus();
+
+    // Buttons respond to Enter natively; fire click and flush the async copy chain.
+    await act(async () => {
+      fireEvent.click(copyBtn);
+      await Promise.resolve();
+    });
+
+    expect(writeText).toHaveBeenCalledWith(address);
+  });
+
+  it('Enter key activates the Disconnect button', async () => {
+    const disconnect = jest.fn();
+    const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
+    mockUseWallet.mockReturnValue(
+      createWalletState({
+        address: '0xABCDEF1234567890abcdef1234567890abcdef12',
+        disconnect,
+      }),
+    );
+    installClipboardMock();
+
+    render(<WalletConnectButton />);
+
+    const disconnectBtn = screen.getByRole('button', { name: 'Disconnect wallet' });
+    disconnectBtn.focus();
+    await user.keyboard('{Enter}');
+
+    expect(disconnect).toHaveBeenCalledTimes(1);
+  });
+
+  it('Copy button carries visible focus-ring classes', () => {
+    mockUseWallet.mockReturnValue(
+      createWalletState({ address: '0xABCDEF1234567890abcdef1234567890abcdef12' }),
+    );
+    installClipboardMock();
+    render(<WalletConnectButton />);
+
+    const copyBtn = screen.getByRole('button', { name: 'Copy address to clipboard' });
+    expect(copyBtn.className).toContain('focus:outline-none');
+    expect(copyBtn.className).toMatch(/focus:ring-2/);
+  });
+
+  it('Disconnect button carries visible focus-ring classes', () => {
+    mockUseWallet.mockReturnValue(
+      createWalletState({ address: '0xABCDEF1234567890abcdef1234567890abcdef12' }),
+    );
+    installClipboardMock();
+    render(<WalletConnectButton />);
+
+    const disconnectBtn = screen.getByRole('button', { name: 'Disconnect wallet' });
+    expect(disconnectBtn.className).toContain('focus:outline-none');
+    expect(disconnectBtn.className).toMatch(/focus:ring-2/);
+  });
+
+  it('focus order in the connected state is Copy then Disconnect (DOM order)', async () => {
+    const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
+    mockUseWallet.mockReturnValue(
+      createWalletState({ address: '0xABCDEF1234567890abcdef1234567890abcdef12' }),
+    );
+    installClipboardMock();
+
+    render(<WalletConnectButton />);
+
+    // Collect DOM order of buttons inside the connected widget.
+    const buttons = screen.getAllByRole('button');
+    // Copy comes before Disconnect in the DOM — verify by their accessible names.
+    const copyIndex = buttons.findIndex((b) => b.getAttribute('aria-label') === 'Copy address to clipboard');
+    const disconnectIndex = buttons.findIndex((b) => b.getAttribute('aria-label') === 'Disconnect wallet');
+    expect(copyIndex).toBeLessThan(disconnectIndex);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// a11y: wallet view — jest-axe
+//
+// Covers every distinct render state of WalletConnectButton:
+//
+//   • empty      — disconnected, not connecting, no error  (Connect Wallet button)
+//   • connecting — connection attempt in flight             (disabled + spinner)
+//   • loaded     — wallet address present                   (Copy + Disconnect)
+//   • loaded/copied — address present, copy just succeeded  (checkmark icon)
+//   • error      — connection attempt failed                (Retry button)
+//
+// Timer discipline: real timers are required — axe() schedules work via
+// window.setTimeout and will deadlock under fake timers (the Promise never
+// settles). Toasts and copy-reset timers are not triggered in these tests
+// so there is nothing to fake-advance.
+// ---------------------------------------------------------------------------
+
+describe('a11y: wallet view — jest-axe', () => {
+  // Restore the original clipboard after each test so a defineProperty in one
+  // test does not bleed into the next.
+  const savedClipboard = Object.getOwnPropertyDescriptor(navigator, 'clipboard');
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    if (savedClipboard) {
+      Object.defineProperty(navigator, 'clipboard', savedClipboard);
+    }
+  });
+
+  // --- empty state (disconnected) ---
+
+  it('empty state (disconnected, no error) has no axe violations', async () => {
+    mockUseWallet.mockReturnValue(
+      createWalletState({ address: null, isConnecting: false, error: null }),
+    );
+
+    const { container } = render(<WalletConnectButton />);
+    expect(screen.getByRole('button', { name: 'Connect wallet' })).toBeInTheDocument();
+
+    const results = await axe(container);
+    expect(results.violations).toHaveLength(0);
+  });
+
+  // --- connecting state ---
+
+  it('connecting state (spinner, disabled button) has no axe violations', async () => {
+    mockUseWallet.mockReturnValue(
+      createWalletState({ address: null, isConnecting: true, error: null }),
+    );
+
+    const { container } = render(<WalletConnectButton />);
+    expect(screen.getByRole('button', { name: 'Connect wallet' })).toBeDisabled();
+
+    const results = await axe(container);
+    expect(results.violations).toHaveLength(0);
+  });
+
+  // --- loaded state (address present) ---
+
+  it('loaded state (wallet connected) has no axe violations', async () => {
+    mockUseWallet.mockReturnValue(
+      createWalletState({
+        address: 'GAAQCAIBAEAQCAIBAEAQCAIBAEAQCAIBAEAQCAIBAEAQCAIBAEAQDZ7H',
+      }),
+    );
+    Object.defineProperty(navigator, 'clipboard', {
+      configurable: true,
+      value: { writeText: jest.fn().mockResolvedValue(undefined) },
+    });
+
+    const { container } = render(<WalletConnectButton />);
+    expect(screen.getByRole('button', { name: 'Copy address to clipboard' })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Disconnect wallet' })).toBeInTheDocument();
+
+    const results = await axe(container);
+    expect(results.violations).toHaveLength(0);
+  });
+
+  // --- loaded/copied state (checkmark icon variant) ---
+
+  it('loaded state after a successful copy (checkmark icon) has no axe violations', async () => {
+    // Use real timers so axe can settle; the 2-second reset timer will not
+    // fire during the axe run (~50 ms).
+    jest.useFakeTimers(); // start fake so we can freeze the copied state
+    const writeText = jest.fn().mockResolvedValue(undefined);
+    Object.defineProperty(navigator, 'clipboard', {
+      configurable: true,
+      value: { writeText },
+    });
+
+    mockUseWallet.mockReturnValue(
+      createWalletState({
+        address: 'GAAQCAIBAEAQCAIBAEAQCAIBAEAQCAIBAEAQCAIBAEAQCAIBAEAQDZ7H',
+      }),
+    );
+
+    const { container } = render(<WalletConnectButton />);
+
+    // Trigger copy and flush the async clipboard write.
+    await act(async () => {
+      fireEvent.click(screen.getByRole('button', { name: 'Copy address to clipboard' }));
+      await Promise.resolve();
+    });
+
+    // Now switch to real timers so axe's own setTimeout calls work.
+    jest.useRealTimers();
+
+    const results = await axe(container);
+    expect(results.violations).toHaveLength(0);
+  });
+
+  // --- error state ---
+
+  it('error state (connection failed, Retry button) has no axe violations', async () => {
+    mockUseWallet.mockReturnValue(
+      createWalletState({
+        address: null,
+        isConnecting: false,
+        error: 'Freighter wallet is not installed. Please install the Freighter browser extension.',
+      }),
+    );
+
+    const { container } = render(<WalletConnectButton />);
+    expect(screen.getByRole('button', { name: 'Retry wallet connection' })).toBeInTheDocument();
+    expect(screen.getByText('Connection Error')).toBeInTheDocument();
+
+    const results = await axe(container);
+    expect(results.violations).toHaveLength(0);
+  });
+
+  it('error state with user-rejected message has no axe violations', async () => {
+    mockUseWallet.mockReturnValue(
+      createWalletState({
+        address: null,
+        isConnecting: false,
+        error: 'User rejected the connection request.',
+      }),
+    );
+
+    const { container } = render(<WalletConnectButton />);
+    expect(screen.getByRole('button', { name: 'Retry wallet connection' })).toBeInTheDocument();
+
+    const results = await axe(container);
+    expect(results.violations).toHaveLength(0);
+  });
+});