diff --git a/__tests__/components/settings/NotificationPreferences.test.tsx b/__tests__/components/settings/NotificationPreferences.test.tsx
new file mode 100644
index 00000000..5a878083
--- /dev/null
+++ b/__tests__/components/settings/NotificationPreferences.test.tsx
@@ -0,0 +1,117 @@
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { NotificationPreferences } from '@/components/settings/NotificationPreferences';
+import { useNotificationPreferences } from '@/hooks/useNotificationPreferences';
+import { toast } from 'sonner';
+
+jest.mock('@/hooks/useNotificationPreferences');
+jest.mock('sonner', () => ({
+  toast: { error: jest.fn(), success: jest.fn() },
+}));
+
+const mockedHook = useNotificationPreferences as jest.MockedFunction<
+  typeof useNotificationPreferences
+>;
+const togglePreference = jest.fn();
+const savePreferences = jest.fn().mockResolvedValue(true);
+const resetPreferences = jest.fn();
+const retry = jest.fn().mockResolvedValue(undefined);
+
+const groupedPreferences = {
+  deliveries: [
+    {
+      key: 'delivery_created_in_app',
+      category: 'deliveries' as const,
+      label: 'Delivery Created',
+      channel: 'in_app' as const,
+      enabled: true,
+    },
+  ],
+  escrow: [
+    {
+      key: 'escrow_locked_in_app',
+      category: 'escrow' as const,
+      label: 'Escrow Locked',
+      channel: 'in_app' as const,
+      enabled: false,
+    },
+  ],
+  marketing: [],
+  system: [],
+};
+
+function mockHook(
+  overrides: Partial<ReturnType<typeof useNotificationPreferences>> = {},
+) {
+  mockedHook.mockReturnValue({
+    preferences: groupedPreferences,
+    isLoading: false,
+    isSaving: false,
+    error: null,
+    togglePreference,
+    savePreferences,
+    clearError: jest.fn(),
+    resetPreferences,
+    retry,
+    ...overrides,
+  });
+}
+
+describe('NotificationPreferences page contract', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockHook();
+  });
+
+  it('renders grouped categories and their toggles', () => {
+    render(<NotificationPreferences />);
+    expect(screen.getByTestId('category-deliveries')).toBeInTheDocument();
+    expect(screen.getByTestId('category-escrow')).toBeInTheDocument();
+    expect(screen.getByRole('switch', { name: 'Delivery Created notification' })).toBeChecked();
+  });
+
+  it('persists toggle changes when save is selected', async () => {
+    const user = userEvent.setup();
+    render(<NotificationPreferences />);
+
+    await user.click(screen.getByRole('switch', { name: 'Escrow Locked notification' }));
+    expect(togglePreference).toHaveBeenCalledWith('escrow_locked_in_app', true);
+    await user.click(screen.getByRole('button', { name: 'Save Preferences' }));
+    expect(savePreferences).toHaveBeenCalledTimes(1);
+  });
+
+  it('shows a save confirmation toast', async () => {
+    const user = userEvent.setup();
+    render(<NotificationPreferences />);
+    await user.click(screen.getByRole('button', { name: 'Save Preferences' }));
+
+    await waitFor(() =>
+      expect(toast.success).toHaveBeenCalledWith('Notification preferences saved'),
+    );
+  });
+
+  it('resets preferences to the backend defaults', async () => {
+    const user = userEvent.setup();
+    render(<NotificationPreferences />);
+    await user.click(screen.getByRole('button', { name: 'Reset to defaults' }));
+    expect(resetPreferences).toHaveBeenCalledTimes(1);
+  });
+
+  it('shows one empty state when no preferences are loaded', () => {
+    mockHook({
+      preferences: { deliveries: [], escrow: [], marketing: [], system: [] },
+    });
+    render(<NotificationPreferences />);
+    expect(screen.getByText('No notification preferences available.')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Save Preferences' })).toBeDisabled();
+  });
+
+  it('shows an error state and retries loading', async () => {
+    mockHook({ error: 'Unable to load preferences' });
+    const user = userEvent.setup();
+    render(<NotificationPreferences />);
+    expect(screen.getByRole('alert')).toHaveTextContent('Unable to load preferences');
+    await user.click(screen.getByRole('button', { name: 'Retry' }));
+    expect(retry).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/__tests__/hooks/useDriverReviews.test.ts b/__tests__/hooks/useDriverReviews.test.ts
index 66fa8672..8e5e1dd9 100644
--- a/__tests__/hooks/useDriverReviews.test.ts
+++ b/__tests__/hooks/useDriverReviews.test.ts
@@ -3,14 +3,25 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { createElement } from 'react';
 import { useDriverReviews, REVIEWS_PAGE_SIZE } from '@/hooks/useDriverReviews';
 import { driverReviewService } from '@/services/driverReviewService';
-import { DEFAULT_REVIEW_FILTERS } from '@/components/fleet/ReputationReviewGrid';
+import type { DriverReviewFilters } from '@/types/driverReview';
 import { buildReviewsPage, driverReviewFixtures } from '../fixtures/driverReviewFixtures';
 
+const DEFAULT_REVIEW_FILTERS: DriverReviewFilters = {
+  minRating: null,
+  dateRange: 'all',
+  verifiedOnly: false,
+  sort: 'date_desc',
+};
+
 jest.mock('@/services/driverReviewService', () => ({
-  driverReviewService: { getDriverReviews: jest.fn() },
+  driverReviewService: {
+    getDriverReviews: jest.fn(),
+    getDriverReputation: jest.fn(),
+  },
 }));
 
 const getReviews = driverReviewService.getDriverReviews as jest.Mock;
+const getReputation = driverReviewService.getDriverReputation as jest.Mock;
 
 const wrapper = ({ children }: { children: React.ReactNode }) =>
   createElement(
@@ -19,7 +30,17 @@ const wrapper = ({ children }: { children: React.ReactNode }) =>
     children,
   );
 
-beforeEach(() => jest.clearAllMocks());
+beforeEach(() => {
+  jest.clearAllMocks();
+  getReputation.mockResolvedValue({
+    driverId: 'driver-1',
+    score: 92,
+    totalReviews: 24,
+    verifiedReviews: 20,
+    updatedAt: '2026-10-18T00:00:00.000Z',
+    source: 'on_chain',
+  });
+});
 
 describe('useDriverReviews', () => {
   it('fetches the first page through the service with filters and page size', async () => {
@@ -33,6 +54,14 @@ describe('useDriverReviews', () => {
     );
     expect(result.current.reviews).toHaveLength(3);
     expect(result.current.hasNextPage).toBe(false);
+    expect(result.current.reputation?.score).toBe(92);
+    expect(result.current.pagination).toEqual({
+      loaded: 3,
+      total: 3,
+      currentPage: 1,
+      pageSize: REVIEWS_PAGE_SIZE,
+      hasMore: false,
+    });
   });
 
   it('appends the next page when fetchNextPage is called', async () => {
@@ -61,5 +90,21 @@ describe('useDriverReviews', () => {
   it('does not fetch without a driverId', () => {
     renderHook(() => useDriverReviews('', DEFAULT_REVIEW_FILTERS), { wrapper });
     expect(getReviews).not.toHaveBeenCalled();
+    expect(getReputation).not.toHaveBeenCalled();
+  });
+
+  it('fetches the on-chain reputation from its dedicated endpoint service', async () => {
+    getReviews.mockResolvedValueOnce(buildReviewsPage([], 1, false));
+    const { result } = renderHook(
+      () => useDriverReviews('driver-1', DEFAULT_REVIEW_FILTERS),
+      { wrapper },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(getReputation).toHaveBeenCalledWith('driver-1', expect.anything());
+    expect(result.current.reputation).toEqual(
+      expect.objectContaining({ score: 92, source: 'on_chain' }),
+    );
   });
 });
diff --git a/components/deliveries/SignatureCanvas.tsx b/components/deliveries/SignatureCanvas.tsx
new file mode 100644
index 00000000..0450540d
--- /dev/null
+++ b/components/deliveries/SignatureCanvas.tsx
@@ -0,0 +1,117 @@
+'use client';
+
+import { useRef } from 'react';
+import { Eraser, Save } from 'lucide-react';
+import { useSignatureCanvas } from '@/hooks/useSignatureCanvas';
+
+export interface SignatureCanvasProps {
+  onSave: (_dataUrl: string) => void;
+  width?: number;
+  height?: number;
+  disabled?: boolean;
+  className?: string;
+}
+
+/** Canvas signature capture with a keyboard-accessible typed fallback. */
+export function SignatureCanvas({
+  onSave,
+  width = 720,
+  height = 260,
+  disabled = false,
+  className = '',
+}: SignatureCanvasProps) {
+  const canvasRef = useRef<HTMLCanvasElement>(null);
+  const {
+    beginStroke,
+    clear,
+    continueStroke,
+    endStroke,
+    hasSignature,
+    isDrawing,
+    isTooLight,
+    save,
+    setTypedSignature,
+    typedSignature,
+  } = useSignatureCanvas({ canvasRef, onSave, disabled });
+
+  const cannotSave = disabled || !hasSignature || isTooLight;
+
+  return (
+    <section
+      className={`space-y-4 rounded-lg border border-slate-200 bg-white p-4 ${className}`.trim()}
+      aria-labelledby="recipient-signature-heading"
+    >
+      <div>
+        <h2 id="recipient-signature-heading" className="text-sm font-semibold text-slate-900">
+          Recipient signature
+        </h2>
+        <p className="mt-1 text-sm text-slate-600">
+          Sign inside the box using a mouse, stylus, or touch screen.
+        </p>
+      </div>
+
+      <canvas
+        ref={canvasRef}
+        width={width}
+        height={height}
+        aria-label="Recipient signature drawing area"
+        data-drawing={isDrawing}
+        className="block aspect-[18/7] w-full touch-none rounded border border-slate-300 bg-white focus:outline-none focus:ring-2 focus:ring-blue-600 disabled:cursor-not-allowed"
+        onPointerDown={beginStroke}
+        onPointerMove={continueStroke}
+        onPointerUp={endStroke}
+        onPointerCancel={endStroke}
+        onPointerLeave={endStroke}
+        role="img"
+      />
+
+      {hasSignature && isTooLight && (
+        <p role="alert" className="text-sm font-medium text-amber-700">
+          Signature is too light. Add a longer stroke before saving.
+        </p>
+      )}
+
+      <div>
+        <label htmlFor="typed-signature" className="text-sm font-medium text-slate-800">
+          Keyboard signature fallback
+        </label>
+        <p id="typed-signature-help" className="mt-1 text-xs text-slate-500">
+          Type the recipient&apos;s name when drawing is not accessible.
+        </p>
+        <textarea
+          id="typed-signature"
+          value={typedSignature}
+          onChange={(event) => setTypedSignature(event.target.value)}
+          disabled={disabled}
+          aria-describedby="typed-signature-help"
+          rows={2}
+          className="mt-2 w-full resize-none rounded border border-slate-300 px-3 py-2 text-sm text-slate-900 focus:border-blue-600 focus:outline-none focus:ring-2 focus:ring-blue-100 disabled:bg-slate-100"
+          placeholder="Type recipient name"
+        />
+      </div>
+
+      <div className="flex flex-wrap justify-end gap-2">
+        <button
+          type="button"
+          onClick={clear}
+          disabled={disabled || !hasSignature}
+          className="inline-flex min-h-10 items-center justify-center gap-2 rounded border border-slate-300 px-4 py-2 text-sm font-medium text-slate-700 hover:bg-slate-50 disabled:cursor-not-allowed disabled:opacity-50"
+        >
+          <Eraser aria-hidden="true" className="h-4 w-4" />
+          Clear
+        </button>
+        <button
+          type="button"
+          onClick={save}
+          disabled={cannotSave}
+          className="inline-flex min-h-10 items-center justify-center gap-2 rounded bg-blue-600 px-4 py-2 text-sm font-medium text-white hover:bg-blue-700 disabled:cursor-not-allowed disabled:bg-slate-300"
+        >
+          <Save aria-hidden="true" className="h-4 w-4" />
+          Save signature
+        </button>
+      </div>
+    </section>
+  );
+}
+
+export default SignatureCanvas;
diff --git a/components/deliveries/__tests__/SignatureCanvas.test.tsx b/components/deliveries/__tests__/SignatureCanvas.test.tsx
new file mode 100644
index 00000000..edbd785d
--- /dev/null
+++ b/components/deliveries/__tests__/SignatureCanvas.test.tsx
@@ -0,0 +1,197 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { SignatureCanvas } from '@/components/deliveries/SignatureCanvas';
+
+const context = {
+  beginPath: jest.fn(),
+  clearRect: jest.fn(),
+  fillText: jest.fn(),
+  lineTo: jest.fn(),
+  moveTo: jest.fn(),
+  stroke: jest.fn(),
+  fillStyle: '',
+  font: '',
+  lineCap: '',
+  lineJoin: '',
+  lineWidth: 0,
+  strokeStyle: '',
+  textBaseline: '',
+};
+
+function drawSignature(pointerType: 'mouse' | 'touch' = 'mouse') {
+  const canvas = screen.getByLabelText('Recipient signature drawing area');
+  fireEvent.pointerDown(canvas, {
+    button: 0,
+    clientX: 10,
+    clientY: 20,
+    pointerId: 1,
+    pointerType,
+  });
+  fireEvent.pointerMove(canvas, {
+    clientX: 90,
+    clientY: 40,
+    pointerId: 1,
+    pointerType,
+  });
+  fireEvent.pointerUp(canvas, { pointerId: 1, pointerType });
+}
+
+describe('SignatureCanvas', () => {
+  beforeAll(() => {
+    Object.defineProperty(window, 'PointerEvent', {
+      configurable: true,
+      value: MouseEvent,
+    });
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(HTMLCanvasElement.prototype, 'getContext').mockReturnValue(
+      context as unknown as CanvasRenderingContext2D,
+    );
+    jest.spyOn(HTMLCanvasElement.prototype, 'toDataURL').mockReturnValue(
+      'data:image/png;base64,c2lnbmF0dXJl',
+    );
+    jest.spyOn(HTMLCanvasElement.prototype, 'getBoundingClientRect').mockReturnValue({
+      bottom: 260,
+      height: 260,
+      left: 0,
+      right: 720,
+      top: 0,
+      width: 720,
+      x: 0,
+      y: 0,
+      toJSON: () => ({}),
+    });
+  });
+
+  afterEach(() => jest.restoreAllMocks());
+
+  it('renders the drawing area, fallback, and actions', () => {
+    render(<SignatureCanvas onSave={jest.fn()} />);
+
+    expect(screen.getByRole('heading', { name: 'Recipient signature' })).toBeInTheDocument();
+    expect(screen.getByLabelText('Recipient signature drawing area')).toBeInTheDocument();
+    expect(screen.getByLabelText('Keyboard signature fallback')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Clear' })).toBeDisabled();
+    expect(screen.getByRole('button', { name: 'Save signature' })).toBeDisabled();
+  });
+
+  it('captures a mouse stroke on the canvas', () => {
+    render(<SignatureCanvas onSave={jest.fn()} />);
+    drawSignature('mouse');
+
+    expect(context.beginPath).toHaveBeenCalled();
+    expect(context.moveTo).toHaveBeenCalledWith(10, 20);
+    expect(context.lineTo).toHaveBeenCalledWith(90, 40);
+    expect(context.stroke).toHaveBeenCalled();
+  });
+
+  it('captures a touch pointer stroke on the canvas', () => {
+    render(<SignatureCanvas onSave={jest.fn()} />);
+    drawSignature('touch');
+
+    expect(context.lineTo).toHaveBeenCalledWith(90, 40);
+    expect(screen.getByRole('button', { name: 'Save signature' })).toBeEnabled();
+  });
+
+  it('shows a quality warning for a dot without a meaningful stroke', () => {
+    render(<SignatureCanvas onSave={jest.fn()} />);
+    const canvas = screen.getByLabelText('Recipient signature drawing area');
+
+    fireEvent.pointerDown(canvas, { button: 0, clientX: 10, clientY: 10, pointerId: 2 });
+    fireEvent.pointerUp(canvas, { pointerId: 2 });
+
+    expect(screen.getByRole('alert')).toHaveTextContent('Signature is too light');
+    expect(screen.getByRole('button', { name: 'Save signature' })).toBeDisabled();
+  });
+
+  it('removes the quality warning after a meaningful stroke', () => {
+    render(<SignatureCanvas onSave={jest.fn()} />);
+    drawSignature();
+
+    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Save signature' })).toBeEnabled();
+  });
+
+  it('accumulates ink quality across multiple strokes', () => {
+    render(<SignatureCanvas onSave={jest.fn()} />);
+    const canvas = screen.getByLabelText('Recipient signature drawing area');
+
+    fireEvent.pointerDown(canvas, { button: 0, clientX: 10, clientY: 10, pointerId: 1 });
+    fireEvent.pointerMove(canvas, { clientX: 40, clientY: 10, pointerId: 1 });
+    fireEvent.pointerUp(canvas, { pointerId: 1 });
+    expect(screen.getByRole('alert')).toBeInTheDocument();
+
+    fireEvent.pointerDown(canvas, { button: 0, clientX: 40, clientY: 10, pointerId: 2 });
+    fireEvent.pointerMove(canvas, { clientX: 70, clientY: 10, pointerId: 2 });
+    fireEvent.pointerUp(canvas, { pointerId: 2 });
+
+    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Save signature' })).toBeEnabled();
+  });
+
+  it('saves a drawn signature as a PNG data URL', async () => {
+    const onSave = jest.fn();
+    const user = userEvent.setup();
+    render(<SignatureCanvas onSave={onSave} />);
+    drawSignature();
+
+    await user.click(screen.getByRole('button', { name: 'Save signature' }));
+
+    expect(HTMLCanvasElement.prototype.toDataURL).toHaveBeenCalledWith('image/png');
+    expect(onSave).toHaveBeenCalledWith('data:image/png;base64,c2lnbmF0dXJl');
+  });
+
+  it('clears the canvas and resets both actions', async () => {
+    const user = userEvent.setup();
+    render(<SignatureCanvas onSave={jest.fn()} />);
+    drawSignature();
+
+    await user.click(screen.getByRole('button', { name: 'Clear' }));
+
+    expect(context.clearRect).toHaveBeenCalledWith(0, 0, 720, 260);
+    expect(screen.getByRole('button', { name: 'Clear' })).toBeDisabled();
+    expect(screen.getByRole('button', { name: 'Save signature' })).toBeDisabled();
+  });
+
+  it('supports a keyboard-entered recipient signature', async () => {
+    const user = userEvent.setup();
+    render(<SignatureCanvas onSave={jest.fn()} />);
+
+    await user.type(screen.getByLabelText('Keyboard signature fallback'), 'Ada Lovelace');
+
+    expect(screen.getByRole('button', { name: 'Save signature' })).toBeEnabled();
+    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+  });
+
+  it('renders typed text onto the canvas before saving', async () => {
+    const onSave = jest.fn();
+    const user = userEvent.setup();
+    render(<SignatureCanvas onSave={onSave} />);
+    await user.type(screen.getByLabelText('Keyboard signature fallback'), 'Ada Lovelace');
+
+    await user.click(screen.getByRole('button', { name: 'Save signature' }));
+
+    expect(context.fillText).toHaveBeenCalledWith('Ada Lovelace', 24, 130);
+    expect(onSave).toHaveBeenCalledWith('data:image/png;base64,c2lnbmF0dXJl');
+  });
+
+  it('treats one typed character as too light', async () => {
+    const user = userEvent.setup();
+    render(<SignatureCanvas onSave={jest.fn()} />);
+
+    await user.type(screen.getByLabelText('Keyboard signature fallback'), 'A');
+
+    expect(screen.getByRole('alert')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Save signature' })).toBeDisabled();
+  });
+
+  it('disables all interaction when disabled', () => {
+    render(<SignatureCanvas onSave={jest.fn()} disabled />);
+
+    expect(screen.getByLabelText('Keyboard signature fallback')).toBeDisabled();
+    expect(screen.getByRole('button', { name: 'Clear' })).toBeDisabled();
+    expect(screen.getByRole('button', { name: 'Save signature' })).toBeDisabled();
+  });
+});
diff --git a/components/deliveries/__tests__/SignatureCapture.test.tsx b/components/deliveries/__tests__/SignatureCapture.test.tsx
new file mode 100644
index 00000000..8c0b7835
--- /dev/null
+++ b/components/deliveries/__tests__/SignatureCapture.test.tsx
@@ -0,0 +1,156 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { SignatureCanvas } from '@/components/deliveries/SignatureCanvas';
+import { ProofUpload } from '@/features/deliveries/components/ProofUpload';
+import { useProofUpload } from '@/hooks/useProofUpload';
+
+jest.mock('@/hooks/useProofUpload');
+
+const mockedUseProofUpload = useProofUpload as jest.MockedFunction<
+  typeof useProofUpload
+>;
+const drawingContext = {
+  beginPath: jest.fn(),
+  clearRect: jest.fn(),
+  fillText: jest.fn(),
+  lineTo: jest.fn(),
+  moveTo: jest.fn(),
+  stroke: jest.fn(),
+  fillStyle: '',
+  font: '',
+  lineCap: '',
+  lineJoin: '',
+  lineWidth: 0,
+  strokeStyle: '',
+  textBaseline: '',
+};
+
+function draw(pointerType: 'mouse' | 'touch' = 'mouse') {
+  const canvas = screen.getByLabelText('Recipient signature drawing area');
+  fireEvent.pointerDown(canvas, {
+    button: 0,
+    clientX: 10,
+    clientY: 20,
+    pointerId: 1,
+    pointerType,
+  });
+  fireEvent.pointerMove(canvas, {
+    clientX: 100,
+    clientY: 40,
+    pointerId: 1,
+    pointerType,
+  });
+  fireEvent.pointerUp(canvas, { pointerId: 1, pointerType });
+}
+
+describe('SignatureCapture contract', () => {
+  beforeAll(() => {
+    Object.defineProperty(window, 'PointerEvent', {
+      configurable: true,
+      value: MouseEvent,
+    });
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(HTMLCanvasElement.prototype, 'getContext').mockReturnValue(
+      drawingContext as unknown as CanvasRenderingContext2D,
+    );
+    jest.spyOn(HTMLCanvasElement.prototype, 'toDataURL').mockReturnValue(
+      'data:image/png;base64,signature',
+    );
+    jest.spyOn(HTMLCanvasElement.prototype, 'getBoundingClientRect').mockReturnValue({
+      bottom: 160,
+      height: 160,
+      left: 0,
+      right: 360,
+      top: 0,
+      width: 360,
+      x: 0,
+      y: 0,
+      toJSON: () => ({}),
+    });
+  });
+
+  afterEach(() => jest.restoreAllMocks());
+
+  it('renders the canvas at the requested dimensions', () => {
+    render(<SignatureCanvas onSave={jest.fn()} width={360} height={160} />);
+    const canvas = screen.getByLabelText('Recipient signature drawing area');
+    expect(canvas).toHaveAttribute('width', '360');
+    expect(canvas).toHaveAttribute('height', '160');
+  });
+
+  it('tracks drawing state from pointer down through pointer up', () => {
+    render(<SignatureCanvas onSave={jest.fn()} />);
+    const canvas = screen.getByLabelText('Recipient signature drawing area');
+
+    fireEvent.pointerDown(canvas, {
+      button: 0,
+      clientX: 10,
+      clientY: 20,
+      pointerId: 2,
+    });
+    expect(canvas).toHaveAttribute('data-drawing', 'true');
+    fireEvent.pointerUp(canvas, { pointerId: 2 });
+    expect(canvas).toHaveAttribute('data-drawing', 'false');
+  });
+
+  it('clears the complete canvas and resets the signature', async () => {
+    const user = userEvent.setup();
+    render(<SignatureCanvas onSave={jest.fn()} width={360} height={160} />);
+    draw();
+
+    await user.click(screen.getByRole('button', { name: 'Clear' }));
+
+    expect(drawingContext.clearRect).toHaveBeenCalledWith(0, 0, 360, 160);
+    expect(screen.getByRole('button', { name: 'Save signature' })).toBeDisabled();
+  });
+
+  it('returns a PNG data URL when saving', async () => {
+    const onSave = jest.fn();
+    const user = userEvent.setup();
+    render(<SignatureCanvas onSave={onSave} />);
+    draw();
+
+    await user.click(screen.getByRole('button', { name: 'Save signature' }));
+
+    expect(onSave).toHaveBeenCalledWith('data:image/png;base64,signature');
+  });
+
+  it('accepts mobile touch pointer events', () => {
+    render(<SignatureCanvas onSave={jest.fn()} />);
+    draw('touch');
+    expect(drawingContext.stroke).toHaveBeenCalled();
+    expect(screen.getByRole('button', { name: 'Save signature' })).toBeEnabled();
+  });
+
+  it('keeps ProofUpload submission disabled when a photo lacks a signature', () => {
+    mockedUseProofUpload.mockReturnValue({
+      uploadProgress: 0,
+      compressionProgress: 0,
+      isUploading: false,
+      isCompressing: false,
+      uploadedProofs: [],
+      errors: [],
+      stagedPhoto: new File(['photo'], 'proof.png', { type: 'image/png' }),
+      photoPreviewUrl: 'blob:proof-photo',
+      signatureDataUrl: null,
+      canSubmitBundle: false,
+      handleFileCapture: jest.fn(),
+      handleCameraCapture: jest.fn(),
+      clearUploadedProofs: jest.fn(),
+      removeProof: jest.fn(),
+      stagePhoto: jest.fn(),
+      stageCameraCapture: jest.fn(),
+      setSignature: jest.fn(),
+      submitProofBundle: jest.fn().mockResolvedValue(false),
+      resetBundle: jest.fn(),
+    });
+
+    render(<ProofUpload deliveryId="delivery-1" />);
+
+    expect(screen.getByText('Signature not captured.')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Submit delivery proof' })).toBeDisabled();
+  });
+});
diff --git a/components/mobile/QrScannerScreen.tsx b/components/mobile/QrScannerScreen.tsx
new file mode 100644
index 00000000..8a276268
--- /dev/null
+++ b/components/mobile/QrScannerScreen.tsx
@@ -0,0 +1,124 @@
+'use client';
+
+import { useEffect } from 'react';
+import { Camera, CheckCircle2, Keyboard, RefreshCw } from 'lucide-react';
+import { useMobileQrScanner } from '@/hooks/useMobileQrScanner';
+
+export function QrScannerScreen() {
+  const {
+    canvasRef,
+    error,
+    isVerifying,
+    manualCode,
+    permission,
+    result,
+    scanAgain,
+    setManualCode,
+    startCamera,
+    submitManualCode,
+    videoRef,
+  } = useMobileQrScanner();
+
+  useEffect(() => {
+    void startCamera();
+  }, [startCamera]);
+
+  return (
+    <main className="min-h-[100dvh] bg-gray-950 text-white">
+      <div className="mx-auto flex min-h-[100dvh] w-full max-w-md flex-col">
+        <header className="px-4 pb-3 pt-5">
+          <h1 className="text-lg font-semibold">Scan handoff QR</h1>
+        </header>
+
+        <div className="relative flex min-h-[52dvh] flex-1 items-center justify-center overflow-hidden bg-black">
+          <video
+            ref={videoRef}
+            autoPlay
+            muted
+            playsInline
+            data-testid="mobile-qr-video"
+            className="absolute inset-0 h-full w-full object-cover"
+          />
+          <canvas ref={canvasRef} className="hidden" aria-hidden="true" />
+
+          {permission === 'requesting' && (
+            <div role="status" className="z-10 flex items-center gap-2 text-sm text-gray-200">
+              <Camera className="h-5 w-5" /> Requesting camera access...
+            </div>
+          )}
+
+          {permission === 'granted' && !result && (
+            <div
+              data-testid="scan-region"
+              className="relative z-10 aspect-square w-[72%] max-w-72 border-2 border-white/90"
+              aria-label="QR scan region"
+            >
+              <span className="absolute -left-1 -top-1 h-8 w-8 border-l-4 border-t-4 border-green-400" />
+              <span className="absolute -right-1 -top-1 h-8 w-8 border-r-4 border-t-4 border-green-400" />
+              <span className="absolute -bottom-1 -left-1 h-8 w-8 border-b-4 border-l-4 border-green-400" />
+              <span className="absolute -bottom-1 -right-1 h-8 w-8 border-b-4 border-r-4 border-green-400" />
+            </div>
+          )}
+
+          {result && (
+            <section className="relative z-20 mx-5 w-full rounded-lg bg-white p-5 text-gray-900 shadow-xl" aria-label="Scan success">
+              <CheckCircle2 className="h-9 w-9 text-green-600" />
+              <h2 className="mt-3 text-lg font-semibold">Handoff verified</h2>
+              <dl className="mt-4 space-y-2 text-sm">
+                <div className="flex justify-between gap-4"><dt className="text-gray-500">Delivery</dt><dd className="font-medium">{result.deliveryId}</dd></div>
+                {result.status && <div className="flex justify-between gap-4"><dt className="text-gray-500">Status</dt><dd className="font-medium">{result.status}</dd></div>}
+                {result.destination && <div className="flex justify-between gap-4"><dt className="text-gray-500">Destination</dt><dd className="text-right font-medium">{result.destination}</dd></div>}
+              </dl>
+              <button type="button" onClick={scanAgain} className="mt-5 inline-flex w-full items-center justify-center gap-2 rounded-md bg-gray-900 px-4 py-3 text-sm font-semibold text-white">
+                <RefreshCw className="h-4 w-4" /> Scan another
+              </button>
+            </section>
+          )}
+        </div>
+
+        <section className="space-y-4 bg-white px-4 py-5 text-gray-900">
+          {error && (
+            <div role="alert" className="rounded-md border border-red-200 bg-red-50 p-3 text-sm text-red-700">
+              {error}
+            </div>
+          )}
+          {permission !== 'granted' && permission !== 'requesting' && (
+            <button type="button" onClick={() => void startCamera()} className="inline-flex w-full items-center justify-center gap-2 rounded-md border border-gray-300 px-4 py-3 text-sm font-semibold">
+              <Camera className="h-4 w-4" /> Retry camera
+            </button>
+          )}
+
+          <form
+            className="space-y-3"
+            onSubmit={(event) => {
+              event.preventDefault();
+              void submitManualCode();
+            }}
+          >
+            <label htmlFor="manual-qr-code" className="flex items-center gap-2 text-sm font-medium">
+              <Keyboard className="h-4 w-4" /> Manual code
+            </label>
+            <div className="flex gap-2">
+              <input
+                id="manual-qr-code"
+                value={manualCode}
+                onChange={(event) => setManualCode(event.target.value)}
+                placeholder="Enter handoff code"
+                className="min-w-0 flex-1 rounded-md border border-gray-300 px-3 py-3 text-base focus:border-blue-600 focus:outline-none focus:ring-2 focus:ring-blue-100"
+              />
+              <button
+                type="submit"
+                disabled={!manualCode.trim() || isVerifying}
+                className="rounded-md bg-blue-600 px-4 py-3 text-sm font-semibold text-white disabled:bg-gray-300"
+              >
+                {isVerifying ? 'Checking...' : 'Verify'}
+              </button>
+            </div>
+          </form>
+        </section>
+      </div>
+    </main>
+  );
+}
+
+export default QrScannerScreen;
diff --git a/components/mobile/__tests__/QrScannerScreen.test.tsx b/components/mobile/__tests__/QrScannerScreen.test.tsx
new file mode 100644
index 00000000..fe2b9244
--- /dev/null
+++ b/components/mobile/__tests__/QrScannerScreen.test.tsx
@@ -0,0 +1,93 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { QrScannerScreen } from '@/components/mobile/QrScannerScreen';
+import { useMobileQrScanner } from '@/hooks/useMobileQrScanner';
+
+jest.mock('@/hooks/useMobileQrScanner');
+
+const mockedScanner = useMobileQrScanner as jest.MockedFunction<
+  typeof useMobileQrScanner
+>;
+const startCamera = jest.fn().mockResolvedValue(undefined);
+const submitManualCode = jest.fn().mockResolvedValue(true);
+const setManualCode = jest.fn();
+const scanAgain = jest.fn();
+
+function mockScanner(
+  overrides: Partial<ReturnType<typeof useMobileQrScanner>> = {},
+) {
+  mockedScanner.mockReturnValue({
+    canvasRef: { current: null },
+    error: null,
+    isVerifying: false,
+    manualCode: '',
+    permission: 'granted',
+    result: null,
+    scanAgain,
+    setManualCode,
+    startCamera,
+    stopCamera: jest.fn(),
+    submitManualCode,
+    videoRef: { current: null },
+    ...overrides,
+  });
+}
+
+describe('QrScannerScreen', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockScanner();
+  });
+
+  it('requests camera access on mount and renders the scan region', () => {
+    render(<QrScannerScreen />);
+    expect(startCamera).toHaveBeenCalledTimes(1);
+    expect(screen.getByTestId('mobile-qr-video')).toHaveAttribute('playsinline');
+    expect(screen.getByLabelText('QR scan region')).toBeInTheDocument();
+  });
+
+  it('shows permission errors and retries camera access', async () => {
+    mockScanner({ permission: 'denied', error: 'Camera permission was denied.' });
+    const user = userEvent.setup();
+    render(<QrScannerScreen />);
+
+    expect(screen.getByRole('alert')).toHaveTextContent('Camera permission was denied.');
+    await user.click(screen.getByRole('button', { name: 'Retry camera' }));
+    expect(startCamera).toHaveBeenCalledTimes(2);
+  });
+
+  it('shows verified delivery details after a successful scan', () => {
+    mockScanner({
+      result: {
+        success: true,
+        deliveryId: 'DEL-2048',
+        message: 'Verified',
+        status: 'IN_TRANSIT',
+        destination: 'Lagos',
+      },
+    });
+    render(<QrScannerScreen />);
+
+    expect(screen.getByLabelText('Scan success')).toHaveTextContent('Handoff verified');
+    expect(screen.getByText('DEL-2048')).toBeInTheDocument();
+    expect(screen.getByText('IN_TRANSIT')).toBeInTheDocument();
+    expect(screen.getByText('Lagos')).toBeInTheDocument();
+  });
+
+  it('submits the manual fallback code', async () => {
+    mockScanner({ manualCode: 'HANDOFF-123' });
+    const user = userEvent.setup();
+    render(<QrScannerScreen />);
+
+    await user.click(screen.getByRole('button', { name: 'Verify' }));
+    expect(submitManualCode).toHaveBeenCalledTimes(1);
+  });
+
+  it('updates manual code input through the hook', async () => {
+    const user = userEvent.setup();
+    render(<QrScannerScreen />);
+
+    await user.type(screen.getByLabelText('Manual code'), 'A');
+    expect(setManualCode).toHaveBeenCalledWith('A');
+  });
+});
diff --git a/components/settings/NotificationPreferences.tsx b/components/settings/NotificationPreferences.tsx
index eb6d44cf..771fcd39 100644
--- a/components/settings/NotificationPreferences.tsx
+++ b/components/settings/NotificationPreferences.tsx
@@ -52,7 +52,7 @@ function Switch({
   disabled = false,
 }: {
   checked: boolean;
-  onChange: (checked: boolean) => void;
+  onChange: (_checked: boolean) => void;
   label: string;
   disabled?: boolean;
 }) {
@@ -98,16 +98,16 @@ export function NotificationPreferences(): ReactElement {
     error,
     togglePreference,
     savePreferences,
-    clearError,
+    resetPreferences,
+    retry,
   } = useNotificationPreferences();
 
   // Surface load/save errors as toasts, matching repo toast conventions
   useEffect(() => {
     if (error) {
       toast.error(error);
-      clearError();
     }
-  }, [error, clearError]);
+  }, [error]);
 
   const handleSave = async () => {
     const ok = await savePreferences();
@@ -128,9 +128,33 @@ export function NotificationPreferences(): ReactElement {
     );
   }
 
+  if (error) {
+    return (
+      <div
+        className="rounded-lg border border-red-200 bg-red-50 p-5 text-red-800"
+        role="alert"
+      >
+        <div className="flex items-center gap-2 font-medium">
+          <AlertCircle className="h-5 w-5" />
+          {error}
+        </div>
+        <button
+          type="button"
+          onClick={() => void retry()}
+          className="mt-4 rounded-md border border-red-300 bg-white px-4 py-2 text-sm font-semibold"
+        >
+          Retry
+        </button>
+      </div>
+    );
+  }
+
   const categories = (
     Object.keys(CATEGORY_META) as NotificationCategory[]
   ).map((category) => ({ category, ...CATEGORY_META[category] }));
+  const hasPreferences = categories.some(
+    ({ category }) => (preferences[category] ?? []).length > 0,
+  );
 
   return (
     <section
@@ -156,7 +180,11 @@ export function NotificationPreferences(): ReactElement {
       </div>
 
       {/* Categories stack vertically on mobile */}
-      <div className="mt-6 flex flex-col gap-6">
+      {!hasPreferences ? (
+        <p className="mt-6 rounded-md border border-dashed border-gray-300 p-6 text-center text-sm text-gray-500">
+          No notification preferences available.
+        </p>
+      ) : <div className="mt-6 flex flex-col gap-6">
         {categories.map(({ category, label, description, icon }) => {
           const items = preferences[category] ?? [];
 
@@ -211,13 +239,21 @@ export function NotificationPreferences(): ReactElement {
             </div>
           );
         })}
-      </div>
+      </div>}
 
-      <div className="mt-6 flex items-center justify-end">
+      <div className="mt-6 flex items-center justify-end gap-3">
+        <button
+          type="button"
+          onClick={resetPreferences}
+          disabled={isSaving || !hasPreferences}
+          className="rounded-lg border border-gray-300 px-4 py-2 text-sm font-semibold text-gray-700 disabled:cursor-not-allowed disabled:opacity-60"
+        >
+          Reset to defaults
+        </button>
         <button
           type="button"
           onClick={() => void handleSave()}
-          disabled={isSaving}
+          disabled={isSaving || !hasPreferences}
           data-testid="save-preferences"
           className="inline-flex items-center gap-2 rounded-lg bg-indigo-600 px-4 py-2 text-sm font-semibold text-white transition hover:bg-indigo-700 disabled:cursor-not-allowed disabled:opacity-60"
         >
diff --git a/components/settings/__tests__/NotificationPreferences.test.tsx b/components/settings/__tests__/NotificationPreferences.test.tsx
index ea60ec08..f6a8f118 100644
--- a/components/settings/__tests__/NotificationPreferences.test.tsx
+++ b/components/settings/__tests__/NotificationPreferences.test.tsx
@@ -12,12 +12,14 @@
  */
 
 import React from 'react';
-import { render, screen, waitFor, act } from '@testing-library/react';
+import { render, screen, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 
 const mockTogglePreference = jest.fn();
 const mockSavePreferences = jest.fn();
 const mockClearError = jest.fn();
+const mockResetPreferences = jest.fn();
+const mockRetry = jest.fn();
 
 const mockHook = {
   preferences: {
@@ -71,6 +73,8 @@ const mockHook = {
   togglePreference: mockTogglePreference,
   savePreferences: mockSavePreferences,
   clearError: mockClearError,
+  resetPreferences: mockResetPreferences,
+  retry: mockRetry,
 };
 
 jest.mock('sonner', () => ({
@@ -240,7 +244,7 @@ describe('NotificationPreferences Component', () => {
       await waitFor(() => {
         expect(toast.error).toHaveBeenCalledWith('Backend unavailable');
       });
-      expect(mockClearError).toHaveBeenCalled();
+      expect(screen.getByRole('button', { name: 'Retry' })).toBeInTheDocument();
     });
   });
 });
diff --git a/features/deliveries/components/ProofUpload.tsx b/features/deliveries/components/ProofUpload.tsx
index 1f43a1d1..f55f08b0 100644
--- a/features/deliveries/components/ProofUpload.tsx
+++ b/features/deliveries/components/ProofUpload.tsx
@@ -2,7 +2,8 @@
 
 import React, { useRef, useState, useEffect } from 'react';
 import { useProofUpload } from '@/hooks/useProofUpload';
-import { Camera, Upload, CheckCircle, AlertCircle, Loader } from 'lucide-react';
+import { Camera, Upload, CheckCircle, AlertCircle, Loader, PenLine } from 'lucide-react';
+import { SignatureCanvas } from '@/components/deliveries/SignatureCanvas';
 import clsx from 'clsx';
 
 interface ProofUploadProps {
@@ -23,10 +24,17 @@ export function ProofUpload({ deliveryId, maxSizeMB = 5 }: ProofUploadProps) {
     isCompressing,
     uploadedProofs,
     errors,
-    handleFileCapture,
-    handleCameraCapture,
     clearUploadedProofs,
     removeProof,
+    stagedPhoto,
+    photoPreviewUrl,
+    signatureDataUrl,
+    canSubmitBundle,
+    stagePhoto,
+    stageCameraCapture,
+    setSignature,
+    submitProofBundle,
+    resetBundle,
   } = useProofUpload({ deliveryId, maxSizeMB });
 
   const videoRef = useRef<HTMLVideoElement>(null);
@@ -34,6 +42,7 @@ export function ProofUpload({ deliveryId, maxSizeMB = 5 }: ProofUploadProps) {
   const fileInputRef = useRef<HTMLInputElement>(null);
   const [isCameraActive, setIsCameraActive] = useState(false);
   const [cameraError, setCameraError] = useState<string | null>(null);
+  const [activeTab, setActiveTab] = useState<'photo' | 'signature'>('photo');
 
   // Initialize camera
   const startCamera = async () => {
@@ -76,7 +85,7 @@ export function ProofUpload({ deliveryId, maxSizeMB = 5 }: ProofUploadProps) {
         canvasRef.current.width = videoRef.current.videoWidth;
         canvasRef.current.height = videoRef.current.videoHeight;
         context.drawImage(videoRef.current, 0, 0);
-        await handleCameraCapture(canvasRef.current);
+        await stageCameraCapture(canvasRef.current);
       }
     }
   };
@@ -87,7 +96,7 @@ export function ProofUpload({ deliveryId, maxSizeMB = 5 }: ProofUploadProps) {
   ) => {
     const file = event.target.files?.[0];
     if (file) {
-      handleFileCapture(file);
+      stagePhoto(file);
     }
     // Reset input
     if (fileInputRef.current) {
@@ -106,7 +115,7 @@ export function ProofUpload({ deliveryId, maxSizeMB = 5 }: ProofUploadProps) {
     event.stopPropagation();
     const file = event.dataTransfer.files?.[0];
     if (file && file.type.startsWith('image/')) {
-      handleFileCapture(file);
+      stagePhoto(file);
     }
   };
 
@@ -119,6 +128,34 @@ export function ProofUpload({ deliveryId, maxSizeMB = 5 }: ProofUploadProps) {
 
   return (
     <div className="space-y-6">
+      <div className="grid grid-cols-2 border-b border-gray-200" role="tablist">
+        <button
+          type="button"
+          role="tab"
+          aria-selected={activeTab === 'photo'}
+          onClick={() => setActiveTab('photo')}
+          className={clsx('flex items-center justify-center gap-2 border-b-2 px-4 py-3 text-sm font-medium', {
+            'border-blue-600 text-blue-700': activeTab === 'photo',
+            'border-transparent text-gray-500': activeTab !== 'photo',
+          })}
+        >
+          <Camera className="h-4 w-4" /> Photo
+        </button>
+        <button
+          type="button"
+          role="tab"
+          aria-selected={activeTab === 'signature'}
+          onClick={() => setActiveTab('signature')}
+          className={clsx('flex items-center justify-center gap-2 border-b-2 px-4 py-3 text-sm font-medium', {
+            'border-blue-600 text-blue-700': activeTab === 'signature',
+            'border-transparent text-gray-500': activeTab !== 'signature',
+          })}
+        >
+          <PenLine className="h-4 w-4" /> Signature
+        </button>
+      </div>
+
+      <div hidden={activeTab !== 'photo'} className="space-y-6">
       {/* Camera Section */}
       <div className="border rounded-lg overflow-hidden bg-slate-50">
         {isCameraActive ? (
@@ -172,6 +209,7 @@ export function ProofUpload({ deliveryId, maxSizeMB = 5 }: ProofUploadProps) {
       >
         <input
           ref={fileInputRef}
+          aria-label="Delivery photo file"
           type="file"
           accept="image/*"
           onChange={handleFileInputChange}
@@ -242,6 +280,56 @@ export function ProofUpload({ deliveryId, maxSizeMB = 5 }: ProofUploadProps) {
           )}
         </div>
       )}
+      </div>
+
+      <div hidden={activeTab !== 'signature'}>
+        <SignatureCanvas
+          onSave={(dataUrl) => setSignature(dataUrl)}
+          disabled={isUploading}
+        />
+      </div>
+
+      {(photoPreviewUrl || signatureDataUrl) && (
+        <div className="grid gap-4 sm:grid-cols-2" aria-label="Delivery proof preview">
+          <div className="rounded-lg border border-gray-200 p-3">
+            <p className="mb-2 text-sm font-medium text-gray-800">Delivery photo</p>
+            {photoPreviewUrl ? (
+              // eslint-disable-next-line @next/next/no-img-element
+              <img src={photoPreviewUrl} alt="Delivery proof preview" className="h-36 w-full rounded object-cover" />
+            ) : (
+              <p className="text-sm text-amber-700">Add a photo before submitting.</p>
+            )}
+          </div>
+          <div className="rounded-lg border border-gray-200 p-3">
+            <p className="mb-2 text-sm font-medium text-gray-800">Recipient signature</p>
+            {signatureDataUrl ? (
+              // eslint-disable-next-line @next/next/no-img-element
+              <img src={signatureDataUrl} alt="Recipient signature preview" className="h-36 w-full rounded object-contain" />
+            ) : (
+              <p className="text-sm text-gray-500">Signature not captured.</p>
+            )}
+          </div>
+        </div>
+      )}
+
+      <div className="flex gap-3">
+        <button
+          type="button"
+          onClick={() => void submitProofBundle()}
+          disabled={!canSubmitBundle}
+          className="flex-1 rounded-lg bg-green-600 px-4 py-2 font-medium text-white disabled:cursor-not-allowed disabled:bg-gray-300"
+        >
+          {isUploading ? 'Submitting proof...' : 'Submit delivery proof'}
+        </button>
+        <button
+          type="button"
+          onClick={resetBundle}
+          disabled={!stagedPhoto && !signatureDataUrl}
+          className="rounded-lg border border-gray-300 px-4 py-2 font-medium text-gray-700 disabled:cursor-not-allowed disabled:text-gray-300"
+        >
+          Reset
+        </button>
+      </div>
 
       {/* Uploaded Proofs */}
       {uploadedProofs.length > 0 && (
diff --git a/features/deliveries/components/__tests__/ProofUploadSignature.test.tsx b/features/deliveries/components/__tests__/ProofUploadSignature.test.tsx
new file mode 100644
index 00000000..16d075df
--- /dev/null
+++ b/features/deliveries/components/__tests__/ProofUploadSignature.test.tsx
@@ -0,0 +1,112 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { ProofUpload } from '@/features/deliveries/components/ProofUpload';
+import { useProofUpload } from '@/hooks/useProofUpload';
+
+jest.mock('@/hooks/useProofUpload');
+jest.mock('@/components/deliveries/SignatureCanvas', () => ({
+  SignatureCanvas: ({ onSave }: { onSave: (_value: string) => void }) => (
+    <button type="button" onClick={() => onSave('data:image/png;base64,signature')}>
+      Save test signature
+    </button>
+  ),
+}));
+
+const mockedUseProofUpload = useProofUpload as jest.MockedFunction<typeof useProofUpload>;
+
+function mockHook(overrides: Partial<ReturnType<typeof useProofUpload>> = {}) {
+  mockedUseProofUpload.mockReturnValue({
+    uploadProgress: 0,
+    compressionProgress: 0,
+    isUploading: false,
+    isCompressing: false,
+    uploadedProofs: [],
+    errors: [],
+    stagedPhoto: null,
+    photoPreviewUrl: null,
+    signatureDataUrl: null,
+    canSubmitBundle: false,
+    handleFileCapture: jest.fn(),
+    handleCameraCapture: jest.fn(),
+    clearUploadedProofs: jest.fn(),
+    removeProof: jest.fn(),
+    stagePhoto: jest.fn(),
+    stageCameraCapture: jest.fn(),
+    setSignature: jest.fn(),
+    submitProofBundle: jest.fn().mockResolvedValue(true),
+    resetBundle: jest.fn(),
+    ...overrides,
+  });
+}
+
+describe('ProofUpload signature integration', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockHook();
+  });
+
+  it('provides photo and signature tabs', () => {
+    render(<ProofUpload deliveryId="delivery-1" />);
+    expect(screen.getByRole('tab', { name: 'Photo' })).toHaveAttribute('aria-selected', 'true');
+    expect(screen.getByRole('tab', { name: 'Signature' })).toBeInTheDocument();
+  });
+
+  it('saves a captured signature through the hook', async () => {
+    const setSignature = jest.fn();
+    mockHook({ setSignature });
+    const user = userEvent.setup();
+    render(<ProofUpload deliveryId="delivery-1" />);
+
+    await user.click(screen.getByRole('tab', { name: 'Signature' }));
+    await user.click(screen.getByRole('button', { name: 'Save test signature' }));
+
+    expect(setSignature).toHaveBeenCalledWith('data:image/png;base64,signature');
+  });
+
+  it('stages a selected delivery photo', () => {
+    const stagePhoto = jest.fn();
+    mockHook({ stagePhoto });
+    render(<ProofUpload deliveryId="delivery-1" />);
+    const photo = new File(['photo'], 'delivery.png', { type: 'image/png' });
+
+    fireEvent.change(screen.getByLabelText('Delivery photo file'), {
+      target: { files: [photo] },
+    });
+
+    expect(stagePhoto).toHaveBeenCalledWith(photo);
+  });
+
+  it('disables submission until photo and signature exist', () => {
+    render(<ProofUpload deliveryId="delivery-1" />);
+    expect(screen.getByRole('button', { name: 'Submit delivery proof' })).toBeDisabled();
+  });
+
+  it('renders both previews and submits the bundle', async () => {
+    const submitProofBundle = jest.fn().mockResolvedValue(true);
+    mockHook({
+      stagedPhoto: new File(['photo'], 'delivery.png', { type: 'image/png' }),
+      photoPreviewUrl: 'blob:delivery-photo',
+      signatureDataUrl: 'data:image/png;base64,signature',
+      canSubmitBundle: true,
+      submitProofBundle,
+    });
+    const user = userEvent.setup();
+    render(<ProofUpload deliveryId="delivery-1" />);
+
+    expect(screen.getByAltText('Delivery proof preview')).toHaveAttribute('src', 'blob:delivery-photo');
+    expect(screen.getByAltText('Recipient signature preview')).toHaveAttribute(
+      'src',
+      'data:image/png;base64,signature',
+    );
+    await user.click(screen.getByRole('button', { name: 'Submit delivery proof' }));
+    expect(submitProofBundle).toHaveBeenCalledTimes(1);
+  });
+
+  it('handles a signature-only draft with a clear photo prompt', () => {
+    mockHook({ signatureDataUrl: 'data:image/png;base64,signature' });
+    render(<ProofUpload deliveryId="delivery-1" />);
+
+    expect(screen.getByText('Add a photo before submitting.')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Submit delivery proof' })).toBeDisabled();
+  });
+});
diff --git a/hooks/__tests__/useMobileQrScanner.test.ts b/hooks/__tests__/useMobileQrScanner.test.ts
new file mode 100644
index 00000000..d29b7989
--- /dev/null
+++ b/hooks/__tests__/useMobileQrScanner.test.ts
@@ -0,0 +1,91 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { useMobileQrScanner } from '@/hooks/useMobileQrScanner';
+import { qrDecoderService } from '@/services/qrDecoderService';
+import { qrScannerService } from '@/services/qrScannerService';
+
+jest.mock('@/services/qrDecoderService', () => ({
+  qrDecoderService: { decode: jest.fn() },
+}));
+jest.mock('@/services/qrScannerService', () => ({
+  qrScannerService: { verifyQrCode: jest.fn() },
+}));
+
+const decode = qrDecoderService.decode as jest.Mock;
+const verify = qrScannerService.verifyQrCode as jest.Mock;
+const getUserMedia = jest.fn();
+
+describe('useMobileQrScanner', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.useFakeTimers();
+    Object.defineProperty(navigator, 'mediaDevices', {
+      configurable: true,
+      value: { getUserMedia },
+    });
+  });
+
+  afterEach(() => jest.useRealTimers());
+
+  it('maps denied camera permission to a recoverable state', async () => {
+    getUserMedia.mockRejectedValue(new DOMException('Denied', 'NotAllowedError'));
+    const { result } = renderHook(() => useMobileQrScanner());
+
+    await act(async () => result.current.startCamera());
+
+    expect(result.current.permission).toBe('denied');
+    expect(result.current.error).toBe('Camera permission was denied.');
+  });
+
+  it('decodes a live frame and verifies the detected QR value', async () => {
+    const stop = jest.fn();
+    getUserMedia.mockResolvedValue({ getTracks: () => [{ stop }] });
+    decode.mockReturnValue('HANDOFF-QR-1');
+    verify.mockResolvedValue({
+      success: true,
+      deliveryId: 'DEL-1',
+      message: 'Verified',
+    });
+    const { result, unmount } = renderHook(() => useMobileQrScanner());
+    const video = document.createElement('video');
+    const canvas = document.createElement('canvas');
+    Object.defineProperties(video, {
+      readyState: { configurable: true, value: HTMLMediaElement.HAVE_CURRENT_DATA },
+      videoHeight: { configurable: true, value: 480 },
+      videoWidth: { configurable: true, value: 640 },
+    });
+    video.play = jest.fn().mockResolvedValue(undefined);
+    const context = { drawImage: jest.fn() } as unknown as CanvasRenderingContext2D;
+    jest.spyOn(canvas, 'getContext').mockReturnValue(context);
+    result.current.videoRef.current = video;
+    result.current.canvasRef.current = canvas;
+
+    await act(async () => result.current.startCamera());
+    await act(async () => {
+      jest.advanceTimersByTime(250);
+      await Promise.resolve();
+    });
+
+    await waitFor(() => expect(verify).toHaveBeenCalledWith('HANDOFF-QR-1'));
+    expect(result.current.result?.deliveryId).toBe('DEL-1');
+    expect(decode).toHaveBeenCalledWith(context, 640, 480);
+    unmount();
+    expect(stop).toHaveBeenCalled();
+  });
+
+  it('verifies a manually entered code without camera access', async () => {
+    verify.mockResolvedValue({
+      success: true,
+      deliveryId: 'DEL-MANUAL',
+      message: 'Verified',
+    });
+    const { result } = renderHook(() => useMobileQrScanner());
+    act(() => result.current.setManualCode(' MANUAL-1 '));
+
+    await act(async () => {
+      expect(await result.current.submitManualCode()).toBe(true);
+    });
+
+    expect(verify).toHaveBeenCalledWith('MANUAL-1');
+    expect(result.current.result?.deliveryId).toBe('DEL-MANUAL');
+  });
+});
diff --git a/hooks/__tests__/useNotificationPreferences.test.ts b/hooks/__tests__/useNotificationPreferences.test.ts
index 2ddffb2b..6965eee8 100644
--- a/hooks/__tests__/useNotificationPreferences.test.ts
+++ b/hooks/__tests__/useNotificationPreferences.test.ts
@@ -175,4 +175,28 @@ describe('useNotificationPreferences', () => {
 
     expect(result.current.error).toBeNull();
   });
+
+  it('resets local changes to the latest backend values', async () => {
+    const { result } = renderHook(() => useNotificationPreferences());
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    act(() => result.current.togglePreference('delivery_created_in_app', false));
+    expect(result.current.preferences.deliveries[0].enabled).toBe(false);
+
+    act(() => result.current.resetPreferences());
+
+    expect(result.current.preferences.deliveries[0].enabled).toBe(true);
+  });
+
+  it('retries loading after an error', async () => {
+    mockedService.getPreferences
+      .mockRejectedValueOnce(new Error('Offline'))
+      .mockResolvedValueOnce({ success: true, data: mockPreferences });
+    const { result } = renderHook(() => useNotificationPreferences());
+    await waitFor(() => expect(result.current.error).toBe('Offline'));
+
+    await act(async () => result.current.retry());
+
+    expect(result.current.error).toBeNull();
+    expect(result.current.preferences.system).toHaveLength(1);
+  });
 });
diff --git a/hooks/__tests__/useProofBundle.test.ts b/hooks/__tests__/useProofBundle.test.ts
new file mode 100644
index 00000000..f08c9191
--- /dev/null
+++ b/hooks/__tests__/useProofBundle.test.ts
@@ -0,0 +1,79 @@
+import { act, renderHook } from '@testing-library/react';
+import { useProofUpload } from '@/hooks/useProofUpload';
+import { proofService } from '@/services/proofService';
+
+jest.mock('@/services/proofService', () => ({
+  proofService: {
+    uploadProofBundle: jest.fn(),
+    compressImage: jest.fn(),
+    uploadProof: jest.fn(),
+  },
+}));
+jest.mock('@/hooks/useToast', () => ({
+  useToast: () => ({
+    error: jest.fn(),
+    success: jest.fn(),
+    toast: jest.fn(),
+  }),
+}));
+
+const uploadProofBundle = proofService.uploadProofBundle as jest.Mock;
+
+describe('useProofUpload delivery bundle', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('keeps a signature-only proof disabled and explains the missing photo', async () => {
+    const { result } = renderHook(() => useProofUpload({ deliveryId: 'delivery-1' }));
+    act(() => result.current.setSignature('data:image/png;base64,signature'));
+
+    await act(async () => {
+      expect(await result.current.submitProofBundle()).toBe(false);
+    });
+
+    expect(result.current.canSubmitBundle).toBe(false);
+    expect(result.current.errors).toEqual(['Add a delivery photo to submit this signature.']);
+  });
+
+  it('uploads the photo and signature in one API payload', async () => {
+    uploadProofBundle.mockResolvedValue({
+      success: true,
+      message: 'Uploaded',
+      data: {
+        signatureDataUrl: 'data:image/png;base64,signature',
+        photo: {
+          id: 'proof-1',
+          deliveryId: 'delivery-1',
+          filename: 'delivery.png',
+          fileSize: 5,
+          originalSize: 5,
+          isCompressed: false,
+          uploadedAt: '2026-10-18T00:00:00.000Z',
+          status: 'pending',
+        },
+      },
+    });
+    const { result } = renderHook(() => useProofUpload({ deliveryId: 'delivery-1' }));
+    const photo = new File(['photo'], 'delivery.png', { type: 'image/png' });
+    act(() => {
+      result.current.stagePhoto(photo);
+      result.current.setSignature('data:image/png;base64,signature');
+    });
+
+    await act(async () => {
+      expect(await result.current.submitProofBundle()).toBe(true);
+    });
+
+    const formData = uploadProofBundle.mock.calls[0][0] as FormData;
+    expect(formData.get('photo')).toBe(photo);
+    expect(formData.get('signatureDataUrl')).toBe('data:image/png;base64,signature');
+    expect(uploadProofBundle).toHaveBeenCalledWith(
+      expect.any(FormData),
+      'delivery-1',
+      expect.any(Function),
+    );
+    expect(result.current.uploadedProofs[0].status).toBe('completed');
+    expect(result.current.signatureDataUrl).toBeNull();
+  });
+});
diff --git a/hooks/useDriverReviews.ts b/hooks/useDriverReviews.ts
index ff271248..6b749c7d 100644
--- a/hooks/useDriverReviews.ts
+++ b/hooks/useDriverReviews.ts
@@ -1,13 +1,20 @@
 'use client';
 
-import { useInfiniteQuery } from '@tanstack/react-query';
+import { useInfiniteQuery, useQuery } from '@tanstack/react-query';
 import { driverReviewService } from '@/services/driverReviewService';
-import type { DriverReview, DriverReviewFilters } from '@/types/driverReview';
+import type {
+  DriverReputationScore,
+  DriverReview,
+  DriverReviewFilters,
+  DriverReviewsPagination,
+} from '@/types/driverReview';
 
 export const REVIEWS_PAGE_SIZE = 6;
 
 export interface UseDriverReviewsResult {
   reviews: DriverReview[];
+  reputation: DriverReputationScore | null;
+  pagination: DriverReviewsPagination;
   isLoading: boolean;
   error: string | null;
   hasNextPage: boolean;
@@ -36,13 +43,30 @@ export function useDriverReviews(
     getNextPageParam: (last) => (last.hasMore ? last.page + 1 : undefined),
     enabled: Boolean(driverId),
   });
+  const reputationQuery = useQuery({
+    queryKey: ['driver-reputation', driverId],
+    queryFn: ({ signal }) =>
+      driverReviewService.getDriverReputation(driverId, signal),
+    enabled: Boolean(driverId),
+  });
+  const reviews = query.data?.pages.flatMap((page) => page.reviews) ?? [];
+  const total = query.data?.pages[0]?.total ?? 0;
+  const queryError = query.error ?? reputationQuery.error;
 
   return {
-    reviews: query.data?.pages.flatMap((p) => p.reviews) ?? [],
-    isLoading: query.isLoading,
-    error: query.error
-      ? query.error instanceof Error && query.error.message
-        ? query.error.message
+    reviews,
+    reputation: reputationQuery.data ?? null,
+    pagination: {
+      loaded: reviews.length,
+      total,
+      currentPage: query.data?.pages.length ?? 0,
+      pageSize: REVIEWS_PAGE_SIZE,
+      hasMore: Boolean(query.hasNextPage),
+    },
+    isLoading: query.isLoading || reputationQuery.isLoading,
+    error: queryError
+      ? queryError instanceof Error && queryError.message
+        ? queryError.message
         : 'Failed to load reviews'
       : null,
     hasNextPage: Boolean(query.hasNextPage),
@@ -52,6 +76,7 @@ export function useDriverReviews(
     },
     refetch: () => {
       void query.refetch();
+      void reputationQuery.refetch();
     },
   };
 }
diff --git a/hooks/useMobileQrScanner.ts b/hooks/useMobileQrScanner.ts
new file mode 100644
index 00000000..8aa292a6
--- /dev/null
+++ b/hooks/useMobileQrScanner.ts
@@ -0,0 +1,170 @@
+'use client';
+
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { qrDecoderService } from '@/services/qrDecoderService';
+import {
+  qrScannerService,
+  type VerifiedQrDelivery,
+} from '@/services/qrScannerService';
+
+export type CameraPermissionState =
+  | 'requesting'
+  | 'granted'
+  | 'denied'
+  | 'unavailable'
+  | 'error';
+
+const SCAN_INTERVAL_MS = 250;
+
+export function useMobileQrScanner() {
+  const videoRef = useRef<HTMLVideoElement | null>(null);
+  const canvasRef = useRef<HTMLCanvasElement | null>(null);
+  const streamRef = useRef<MediaStream | null>(null);
+  const scanTimerRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const scanningRef = useRef(false);
+  const scanFrameRef = useRef<() => Promise<void>>(async () => undefined);
+  const [permission, setPermission] =
+    useState<CameraPermissionState>('requesting');
+  const [error, setError] = useState<string | null>(null);
+  const [manualCode, setManualCode] = useState('');
+  const [result, setResult] = useState<VerifiedQrDelivery | null>(null);
+  const [isVerifying, setIsVerifying] = useState(false);
+
+  const clearScanTimer = useCallback(() => {
+    if (scanTimerRef.current) clearInterval(scanTimerRef.current);
+    scanTimerRef.current = null;
+  }, []);
+
+  const stopCamera = useCallback(() => {
+    clearScanTimer();
+    streamRef.current?.getTracks().forEach((track) => track.stop());
+    streamRef.current = null;
+    if (videoRef.current) videoRef.current.srcObject = null;
+  }, [clearScanTimer]);
+
+  const verifyCode = useCallback(
+    async (code: string) => {
+      const normalized = code.trim();
+      if (!normalized || scanningRef.current) return false;
+      scanningRef.current = true;
+      setIsVerifying(true);
+      setError(null);
+      try {
+        const delivery = await qrScannerService.verifyQrCode(normalized);
+        setResult(delivery);
+        clearScanTimer();
+        return true;
+      } catch (verificationError) {
+        setError(
+          verificationError instanceof Error
+            ? verificationError.message
+            : 'Unable to verify this handoff code.',
+        );
+        return false;
+      } finally {
+        scanningRef.current = false;
+        setIsVerifying(false);
+      }
+    },
+    [clearScanTimer],
+  );
+
+  const scanFrame = useCallback(async () => {
+    const video = videoRef.current;
+    const canvas = canvasRef.current;
+    if (
+      !video ||
+      !canvas ||
+      video.readyState < HTMLMediaElement.HAVE_CURRENT_DATA ||
+      scanningRef.current
+    ) {
+      return;
+    }
+
+    const width = video.videoWidth;
+    const height = video.videoHeight;
+    if (!width || !height) return;
+    canvas.width = width;
+    canvas.height = height;
+    const context = canvas.getContext('2d', { willReadFrequently: true });
+    if (!context) return;
+    context.drawImage(video, 0, 0, width, height);
+    const code = qrDecoderService.decode(context, width, height);
+    if (code) await verifyCode(code);
+  }, [verifyCode]);
+
+  useEffect(() => {
+    scanFrameRef.current = scanFrame;
+  }, [scanFrame]);
+
+  const startCamera = useCallback(async () => {
+    stopCamera();
+    setPermission('requesting');
+    setError(null);
+    setResult(null);
+    try {
+      if (!navigator.mediaDevices?.getUserMedia) {
+        setPermission('unavailable');
+        setError('Camera access is not available on this device.');
+        return;
+      }
+      const stream = await navigator.mediaDevices.getUserMedia({
+        video: { facingMode: { ideal: 'environment' } },
+        audio: false,
+      });
+      streamRef.current = stream;
+      if (!videoRef.current) {
+        stream.getTracks().forEach((track) => track.stop());
+        return;
+      }
+      videoRef.current.srcObject = stream;
+      await videoRef.current.play();
+      setPermission('granted');
+      scanTimerRef.current = setInterval(
+        () => void scanFrameRef.current(),
+        SCAN_INTERVAL_MS,
+      );
+    } catch (cameraError) {
+      const name = cameraError instanceof DOMException ? cameraError.name : '';
+      if (name === 'NotAllowedError' || name === 'PermissionDeniedError') {
+        setPermission('denied');
+        setError('Camera permission was denied.');
+      } else if (name === 'NotFoundError' || name === 'DevicesNotFoundError') {
+        setPermission('unavailable');
+        setError('No camera was found on this device.');
+      } else {
+        setPermission('error');
+        setError('The camera could not be started.');
+      }
+    }
+  }, [stopCamera]);
+
+  const submitManualCode = useCallback(
+    () => verifyCode(manualCode),
+    [manualCode, verifyCode],
+  );
+
+  const scanAgain = useCallback(() => {
+    setManualCode('');
+    setResult(null);
+    setError(null);
+    void startCamera();
+  }, [startCamera]);
+
+  useEffect(() => stopCamera, [stopCamera]);
+
+  return {
+    canvasRef,
+    error,
+    isVerifying,
+    manualCode,
+    permission,
+    result,
+    scanAgain,
+    setManualCode,
+    startCamera,
+    stopCamera,
+    submitManualCode,
+    videoRef,
+  };
+}
diff --git a/hooks/useNotificationPreferences.ts b/hooks/useNotificationPreferences.ts
index 47bd1d43..25a726fb 100644
--- a/hooks/useNotificationPreferences.ts
+++ b/hooks/useNotificationPreferences.ts
@@ -20,11 +20,15 @@ export interface UseNotificationPreferencesResult {
   /** True while preferences are being persisted to the backend */
   isSaving: boolean;
   /** Update a single preference's enabled state locally */
-  togglePreference: (key: string, enabled: boolean) => void;
+  togglePreference: (_key: string, _enabled: boolean) => void;
   /** Persist all local preference changes to the backend */
   savePreferences: () => Promise<boolean>;
   /** Clear the error message */
   clearError: () => void;
+  /** Restore the preferences returned by the latest successful load */
+  resetPreferences: () => void;
+  /** Retry loading preferences after an error */
+  retry: () => Promise<void>;
 }
 
 const EMPTY_CATEGORIES: NotificationCategory[] = [
@@ -34,6 +38,18 @@ const EMPTY_CATEGORIES: NotificationCategory[] = [
   'system',
 ];
 
+function emptyPreferences(): Record<
+  NotificationCategory,
+  NotificationPreference[]
+> {
+  return {
+    deliveries: [],
+    escrow: [],
+    marketing: [],
+    system: [],
+  };
+}
+
 /**
  * useNotificationPreferences — manages loading, toggling, and persisting
  * notification preferences.
@@ -47,12 +63,10 @@ const EMPTY_CATEGORIES: NotificationCategory[] = [
 export function useNotificationPreferences(): UseNotificationPreferencesResult {
   const [preferences, setPreferences] = useState<
     Record<NotificationCategory, NotificationPreference[]>
-  >({
-    deliveries: [],
-    escrow: [],
-    marketing: [],
-    system: [],
-  });
+  >(emptyPreferences);
+  const [initialPreferences, setInitialPreferences] = useState<
+    Record<NotificationCategory, NotificationPreference[]>
+  >(emptyPreferences);
   const [isLoading, setIsLoading] = useState(true);
   const [isSaving, setIsSaving] = useState(false);
   const [error, setError] = useState<string | null>(null);
@@ -86,6 +100,7 @@ export function useNotificationPreferences(): UseNotificationPreferencesResult {
       }
 
       setPreferences(grouped);
+      setInitialPreferences(grouped);
     } catch (err) {
       setError(
         err instanceof Error
@@ -144,6 +159,10 @@ export function useNotificationPreferences(): UseNotificationPreferencesResult {
   }, [preferences]);
 
   const clearError = useCallback(() => setError(null), []);
+  const resetPreferences = useCallback(() => {
+    setPreferences(initialPreferences);
+    setError(null);
+  }, [initialPreferences]);
 
   // Load preferences from the backend on mount
   useEffect(() => {
@@ -160,6 +179,8 @@ export function useNotificationPreferences(): UseNotificationPreferencesResult {
       togglePreference,
       savePreferences,
       clearError,
+      resetPreferences,
+      retry: loadPreferences,
     }),
     [
       preferences,
@@ -169,6 +190,8 @@ export function useNotificationPreferences(): UseNotificationPreferencesResult {
       togglePreference,
       savePreferences,
       clearError,
+      resetPreferences,
+      loadPreferences,
     ],
   );
 }
diff --git a/hooks/useNotificationSettings.ts b/hooks/useNotificationSettings.ts
new file mode 100644
index 00000000..12faba80
--- /dev/null
+++ b/hooks/useNotificationSettings.ts
@@ -0,0 +1,4 @@
+export {
+  useNotificationPreferences as useNotificationSettings,
+  type UseNotificationPreferencesResult as UseNotificationSettingsResult,
+} from '@/hooks/useNotificationPreferences';
diff --git a/hooks/useProofUpload.ts b/hooks/useProofUpload.ts
index 6f122202..21d8bc11 100644
--- a/hooks/useProofUpload.ts
+++ b/hooks/useProofUpload.ts
@@ -1,6 +1,6 @@
 'use client';
 
-import { useState, useCallback } from 'react';
+import { useState, useCallback, useEffect } from 'react';
 import { proofService, CompressionOptions } from '@/services/proofService';
 import { useToast } from './useToast';
 
@@ -27,6 +27,10 @@ interface UseProofUploadReturn {
   isCompressing: boolean;
   uploadedProofs: UploadedProof[];
   errors: string[];
+  stagedPhoto: File | null;
+  photoPreviewUrl: string | null;
+  signatureDataUrl: string | null;
+  canSubmitBundle: boolean;
 
   handleFileCapture: (_file: File) => Promise<void>;
 
@@ -34,6 +38,11 @@ interface UseProofUploadReturn {
   clearUploadedProofs: () => void;
 
   removeProof: (_filename: string) => void;
+  stagePhoto: (_file: File) => void;
+  stageCameraCapture: (_canvas: HTMLCanvasElement) => Promise<void>;
+  setSignature: (_signatureDataUrl: string | null) => void;
+  submitProofBundle: () => Promise<boolean>;
+  resetBundle: () => void;
 }
 
 /**
@@ -51,21 +60,128 @@ export function useProofUpload({
   const [isCompressing, setIsCompressing] = useState(false);
   const [uploadedProofs, setUploadedProofs] = useState<UploadedProof[]>([]);
   const [errors, setErrors] = useState<string[]>([]);
+  const [stagedPhoto, setStagedPhoto] = useState<File | null>(null);
+  const [photoPreviewUrl, setPhotoPreviewUrl] = useState<string | null>(null);
+  const [signatureDataUrl, setSignatureDataUrl] = useState<string | null>(null);
   const {
     error: toastError,
     success: toastSuccess,
-    loading: toastLoading,
-    info: toastInfo,
-    toast,
   } = useToast();
 
+  useEffect(() => {
+    return () => {
+      if (photoPreviewUrl) URL.revokeObjectURL(photoPreviewUrl);
+    };
+  }, [photoPreviewUrl]);
+
+  const stagePhoto = useCallback(
+    (file: File) => {
+      if (!file.type.startsWith('image/')) {
+        const message = 'Please select an image file';
+        setErrors([message]);
+        toastError?.(message);
+        return;
+      }
+      if (photoPreviewUrl) URL.revokeObjectURL(photoPreviewUrl);
+      setStagedPhoto(file);
+      setPhotoPreviewUrl(URL.createObjectURL(file));
+      setErrors([]);
+    },
+    [photoPreviewUrl, toastError]
+  );
+
+  const stageCameraCapture = useCallback(
+    async (canvas: HTMLCanvasElement) => {
+      const blob = await new Promise<Blob | null>((resolve) => {
+        canvas.toBlob(resolve, 'image/jpeg', 0.95);
+      });
+      if (!blob) {
+        setErrors(['Failed to capture image from camera']);
+        return;
+      }
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      stagePhoto(
+        new File([blob], `proof-${timestamp}.jpg`, { type: 'image/jpeg' })
+      );
+    },
+    [stagePhoto]
+  );
+
+  const setSignature = useCallback((value: string | null) => {
+    setSignatureDataUrl(value);
+    setErrors([]);
+  }, []);
+
+  const resetBundle = useCallback(() => {
+    if (photoPreviewUrl) URL.revokeObjectURL(photoPreviewUrl);
+    setStagedPhoto(null);
+    setPhotoPreviewUrl(null);
+    setSignatureDataUrl(null);
+    setErrors([]);
+  }, [photoPreviewUrl]);
+
+  const submitProofBundle = useCallback(async () => {
+    if (!stagedPhoto && signatureDataUrl) {
+      setErrors(['Add a delivery photo to submit this signature.']);
+      return false;
+    }
+    if (!stagedPhoto || !signatureDataUrl) {
+      setErrors(['A delivery photo and recipient signature are required.']);
+      return false;
+    }
+
+    setIsUploading(true);
+    setUploadProgress(0);
+    setErrors([]);
+    try {
+      const formData = new FormData();
+      formData.append('photo', stagedPhoto);
+      formData.append('signatureDataUrl', signatureDataUrl);
+      const response = await proofService.uploadProofBundle(
+        formData,
+        deliveryId,
+        ({ loaded, total }) => {
+          if (total) setUploadProgress(Math.round((loaded / total) * 100));
+        }
+      );
+      if (!response.success || !response.data) {
+        throw new Error(response.message || 'Proof bundle upload failed');
+      }
+
+      setUploadedProofs((current) => [
+        ...current,
+        {
+          id: response.data?.photo.id,
+          filename: response.data?.photo.filename ?? stagedPhoto.name,
+          fileSize: response.data?.photo.fileSize ?? stagedPhoto.size,
+          originalSize: response.data?.photo.originalSize ?? stagedPhoto.size,
+          isCompressed: response.data?.photo.isCompressed ?? false,
+          status: 'completed',
+          uploadedAt: response.data?.photo.uploadedAt,
+          compressionProgress: 100,
+        },
+      ]);
+      resetBundle();
+      toastSuccess?.('Delivery proof submitted');
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Proof bundle upload failed';
+      setErrors([message]);
+      toastError?.(message);
+      return false;
+    } finally {
+      setIsUploading(false);
+      setUploadProgress(0);
+    }
+  }, [deliveryId, resetBundle, signatureDataUrl, stagedPhoto, toastError, toastSuccess]);
+
   const handleFileCapture = useCallback(
     async (file: File) => {
       // Validate file type
       if (!file.type.startsWith('image/')) {
         const errorMsg = 'Please select an image file';
         setErrors((prev) => [...prev, errorMsg]);
-        toastError(errorMsg);
+        toastError?.(errorMsg);
         return;
       }
 
@@ -148,11 +264,10 @@ export function useProofUpload({
             ? ` (compressed from ${(originalSize / (1024 * 1024)).toFixed(2)}MB to ${(compressedFile.size / (1024 * 1024)).toFixed(2)}MB)`
             : '';
 
-          toast({
-            title: 'Upload Successful',
-            description: `Proof uploaded successfully${compressionMsg}`,
-            variant: 'default',
-          });
+          toastSuccess?.(
+            'Upload Successful',
+            `Proof uploaded successfully${compressionMsg}`
+          );
         } else {
           throw new Error(response.message || 'Upload failed');
         }
@@ -169,11 +284,7 @@ export function useProofUpload({
           )
         );
 
-        toast({
-          title: 'Upload Failed',
-          description: errorMessage,
-          variant: 'destructive',
-        });
+        toastError?.('Upload Failed', errorMessage);
       } finally {
         setIsUploading(false);
         setIsCompressing(false);
@@ -181,7 +292,7 @@ export function useProofUpload({
         setCompressionProgress(0);
       }
     },
-    [deliveryId, maxSizeMB, toast]
+    [deliveryId, maxSizeMB, toastError, toastSuccess]
   );
 
   const handleCameraCapture = useCallback(
@@ -207,14 +318,10 @@ export function useProofUpload({
       } catch (error: any) {
         const errorMessage = error?.message || 'Failed to capture from camera';
         setErrors((prev) => [...prev, errorMessage]);
-        toast({
-          title: 'Camera Capture Failed',
-          description: errorMessage,
-          variant: 'destructive',
-        });
+        toastError?.('Camera Capture Failed', errorMessage);
       }
     },
-    [handleFileCapture, toast]
+    [handleFileCapture, toastError]
   );
 
   const clearUploadedProofs = useCallback(() => {
@@ -233,9 +340,18 @@ export function useProofUpload({
     isCompressing,
     uploadedProofs,
     errors,
+    stagedPhoto,
+    photoPreviewUrl,
+    signatureDataUrl,
+    canSubmitBundle: Boolean(stagedPhoto && signatureDataUrl) && !isUploading,
     handleFileCapture,
     handleCameraCapture,
     clearUploadedProofs,
     removeProof,
+    stagePhoto,
+    stageCameraCapture,
+    setSignature,
+    submitProofBundle,
+    resetBundle,
   };
 }
diff --git a/hooks/useSignatureCanvas.ts b/hooks/useSignatureCanvas.ts
new file mode 100644
index 00000000..2207f014
--- /dev/null
+++ b/hooks/useSignatureCanvas.ts
@@ -0,0 +1,189 @@
+'use client';
+
+import {
+  type PointerEvent as ReactPointerEvent,
+  type RefObject,
+  useCallback,
+  useRef,
+  useState,
+} from 'react';
+import {
+  MIN_SIGNATURE_INK_LENGTH,
+  signatureCaptureService,
+} from '@/services/signatureCaptureService';
+
+interface Point {
+  x: number;
+  y: number;
+}
+
+interface UseSignatureCanvasOptions {
+  canvasRef: RefObject<HTMLCanvasElement | null>;
+  onSave: (_dataUrl: string) => void;
+  disabled?: boolean;
+  minimumInkLength?: number;
+}
+
+function canvasPoint(canvas: HTMLCanvasElement, event: ReactPointerEvent<HTMLCanvasElement>): Point {
+  const rect = canvas.getBoundingClientRect();
+  const scaleX = rect.width > 0 ? canvas.width / rect.width : 1;
+  const scaleY = rect.height > 0 ? canvas.height / rect.height : 1;
+
+  return {
+    x: (event.clientX - rect.left) * scaleX,
+    y: (event.clientY - rect.top) * scaleY,
+  };
+}
+
+function drawingContext(canvas: HTMLCanvasElement): CanvasRenderingContext2D | null {
+  const context = canvas.getContext('2d');
+  if (!context) return null;
+
+  context.lineCap = 'round';
+  context.lineJoin = 'round';
+  context.lineWidth = 2.5;
+  context.strokeStyle = '#111827';
+  return context;
+}
+
+export function useSignatureCanvas({
+  canvasRef,
+  onSave,
+  disabled = false,
+  minimumInkLength = MIN_SIGNATURE_INK_LENGTH,
+}: UseSignatureCanvasOptions) {
+  const [hasSignature, setHasSignature] = useState(false);
+  const [isDrawing, setIsDrawing] = useState(false);
+  const [isTooLight, setIsTooLight] = useState(false);
+  const [typedSignature, setTypedSignatureState] = useState('');
+  const drawingRef = useRef(false);
+  const lastPointRef = useRef<Point | null>(null);
+  const inkLengthRef = useRef(0);
+
+  const updateQuality = useCallback(
+    (inkLength: number, text: string) => {
+      const quality = signatureCaptureService.assessQuality(
+        inkLength,
+        text,
+        minimumInkLength,
+      );
+      setIsTooLight(quality.isTooLight);
+    },
+    [minimumInkLength],
+  );
+
+  const clear = useCallback(() => {
+    const canvas = canvasRef.current;
+    canvas?.getContext('2d')?.clearRect(0, 0, canvas.width, canvas.height);
+    drawingRef.current = false;
+    setIsDrawing(false);
+    lastPointRef.current = null;
+    inkLengthRef.current = 0;
+    setTypedSignatureState('');
+    setHasSignature(false);
+    setIsTooLight(false);
+  }, [canvasRef]);
+
+  const beginStroke = useCallback(
+    (event: ReactPointerEvent<HTMLCanvasElement>) => {
+      if (disabled || event.button > 0) return;
+      const canvas = canvasRef.current;
+      const context = canvas && drawingContext(canvas);
+      if (!canvas || !context) return;
+
+      event.preventDefault();
+      canvas.setPointerCapture?.(event.pointerId);
+      if (typedSignature) {
+        context.clearRect(0, 0, canvas.width, canvas.height);
+        setTypedSignatureState('');
+        inkLengthRef.current = 0;
+      }
+      const point = canvasPoint(canvas, event);
+      context.beginPath();
+      context.moveTo(point.x, point.y);
+      drawingRef.current = true;
+      setIsDrawing(true);
+      lastPointRef.current = point;
+      setHasSignature(true);
+      updateQuality(inkLengthRef.current, '');
+    },
+    [canvasRef, disabled, typedSignature, updateQuality],
+  );
+
+  const continueStroke = useCallback(
+    (event: ReactPointerEvent<HTMLCanvasElement>) => {
+      if (!drawingRef.current || disabled) return;
+      const canvas = canvasRef.current;
+      const context = canvas && drawingContext(canvas);
+      const previous = lastPointRef.current;
+      if (!canvas || !context || !previous) return;
+
+      event.preventDefault();
+      const point = canvasPoint(canvas, event);
+      context.lineTo(point.x, point.y);
+      context.stroke();
+      inkLengthRef.current += Math.hypot(point.x - previous.x, point.y - previous.y);
+      lastPointRef.current = point;
+      updateQuality(inkLengthRef.current, '');
+    },
+    [canvasRef, disabled, updateQuality],
+  );
+
+  const endStroke = useCallback(
+    (event: ReactPointerEvent<HTMLCanvasElement>) => {
+      if (!drawingRef.current) return;
+      canvasRef.current?.releasePointerCapture?.(event.pointerId);
+      drawingRef.current = false;
+      setIsDrawing(false);
+      lastPointRef.current = null;
+      updateQuality(inkLengthRef.current, '');
+    },
+    [canvasRef, updateQuality],
+  );
+
+  const setTypedSignature = useCallback(
+    (value: string) => {
+      const canvas = canvasRef.current;
+      canvas?.getContext('2d')?.clearRect(0, 0, canvas.width, canvas.height);
+      drawingRef.current = false;
+      setIsDrawing(false);
+      lastPointRef.current = null;
+      inkLengthRef.current = 0;
+      setTypedSignatureState(value);
+      setHasSignature(value.trim().length > 0);
+      updateQuality(0, value);
+    },
+    [canvasRef, updateQuality],
+  );
+
+  const save = useCallback(() => {
+    const canvas = canvasRef.current;
+    if (!canvas || !hasSignature || isTooLight || disabled) return;
+
+    if (typedSignature.trim()) {
+      const context = drawingContext(canvas);
+      if (!context) return;
+      context.clearRect(0, 0, canvas.width, canvas.height);
+      context.fillStyle = '#111827';
+      context.font = 'italic 30px cursive';
+      context.textBaseline = 'middle';
+      context.fillText(typedSignature.trim(), 24, canvas.height / 2);
+    }
+
+    const dataUrl = canvas.toDataURL('image/png');
+    if (dataUrl && dataUrl !== 'data:,') onSave(dataUrl);
+  }, [canvasRef, disabled, hasSignature, isTooLight, onSave, typedSignature]);
+
+  return {
+    beginStroke,
+    clear,
+    continueStroke,
+    endStroke,
+    hasSignature,
+    isDrawing,
+    isTooLight,
+    save,
+    setTypedSignature,
+    typedSignature,
+  };
+}
diff --git a/hooks/useToast.ts b/hooks/useToast.ts
index 0e57b985..a0b767ac 100644
--- a/hooks/useToast.ts
+++ b/hooks/useToast.ts
@@ -10,11 +10,11 @@ import { useCallback, useEffect, useState } from 'react';
 import { toastService, ToastConfig, ToastMessage } from '@/lib/toast';
 
 export interface UseToastReturn {
-  success: (message: string, description?: string, duration?: number) => void;
-  error: (message: string, description?: string, duration?: number) => void;
-  info: (message: string, description?: string, duration?: number) => void;
-  loading: (message: string, description?: string) => void;
-  toast: (config: ToastConfig) => void;
+  success: (_message: string, _description?: string, _duration?: number) => void;
+  error: (_message: string, _description?: string, _duration?: number) => void;
+  info: (_message: string, _description?: string, _duration?: number) => void;
+  loading: (_message: string, _description?: string) => void;
+  toast: (_config: ToastConfig) => void;
   isLoading: boolean;
   notifications: ToastMessage[];
   fetchNotifications: () => Promise<void>;
@@ -50,8 +50,8 @@ export function useToast(): UseToastReturn {
           }
         });
       }
-    } catch (err: any) {
-      console.error('Failed to fetch notifications:', err.message);
+    } catch {
+      setNotifications([]);
     } finally {
       setIsLoading(false);
     }
@@ -104,21 +104,20 @@ export function useToast(): UseToastReturn {
   }, []);
 
   const showToast = useCallback((config: ToastConfig) => {
-    const { title, description, variant = 'default', duration } = config;
+    const { message, description, variant, duration } = config;
     switch (variant) {
-      case 'destructive':
       case 'error':
-        toastService.error(title, description, duration);
+        toastService.error(message, description, duration);
         break;
       case 'loading':
-        toastService.loading(title, description);
+        toastService.loading(message, description);
         break;
       case 'success':
-        toastService.success(title, description, duration);
+        toastService.success(message, description, duration);
         break;
       case 'info':
       default:
-        toastService.info(title, description, duration);
+        toastService.info(message, description, duration);
         break;
     }
   }, []);
diff --git a/package.json b/package.json
index 7c7ba41a..9e8467fb 100644
--- a/package.json
+++ b/package.json
@@ -28,6 +28,7 @@
     "cmdk": "^1.1.1",
     "date-fns": "^4.4.0",
     "framer-motion": "^12.38.0",
+    "jsqr": "1.4.0",
     "leaflet": "^1.9.4",
     "lodash.debounce": "^4.0.8",
     "lucide-react": "^1.9.0",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index c5843e07..4bfa96f9 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -56,6 +56,9 @@ importers:
       framer-motion:
         specifier: ^12.38.0
         version: 12.40.0(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      jsqr:
+        specifier: 1.4.0
+        version: 1.4.0
       leaflet:
         specifier: ^1.9.4
         version: 1.9.4
@@ -3003,6 +3006,9 @@ packages:
     engines: {node: '>=6'}
     hasBin: true
 
+  jsqr@1.4.0:
+    resolution: {integrity: sha512-dxLob7q65Xg2DvstYkRpkYtmKm2sPJ9oFhrhmudT1dZvNFFTlroai3AWSpLey/w5vMcLBXRgOJsbXpdN9HzU/A==}
+
   jsx-ast-utils@3.3.5:
     resolution: {integrity: sha512-ZZow9HBI5O6EPgSJLUb8n2NKgmVWTwCvHGwFuJlMjvLFqlGG6pjirPhtdsseaLZjSibD8eegzmYpUZwoIlj2cQ==}
     engines: {node: '>=4.0'}
@@ -7418,6 +7424,8 @@ snapshots:
 
   json5@2.2.3: {}
 
+  jsqr@1.4.0: {}
+
   jsx-ast-utils@3.3.5:
     dependencies:
       array-includes: 3.1.9
diff --git a/services/__tests__/driverReviewService.test.ts b/services/__tests__/driverReviewService.test.ts
new file mode 100644
index 00000000..4bd65f9e
--- /dev/null
+++ b/services/__tests__/driverReviewService.test.ts
@@ -0,0 +1,66 @@
+import axios from 'axios';
+import { driverReviewService } from '@/services/driverReviewService';
+
+jest.mock('axios');
+
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+const apiBase = process.env.NEXT_PUBLIC_API_URL ?? '';
+
+describe('driverReviewService', () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  it('fetches filtered reviews from the fleet reviews endpoint', async () => {
+    mockedAxios.get.mockResolvedValue({
+      data: { reviews: [], page: 1, hasMore: false, total: 0 },
+    });
+    const signal = new AbortController().signal;
+    await driverReviewService.getDriverReviews(
+      'driver-1',
+      {
+        page: 1,
+        pageSize: 6,
+        minRating: 4,
+        dateRange: '30d',
+        verifiedOnly: true,
+        sort: 'rating_desc',
+      },
+      signal,
+    );
+
+    expect(mockedAxios.get).toHaveBeenCalledWith(
+      `${apiBase}/api/fleet/drivers/driver-1/reviews`,
+      {
+        params: {
+          page: 1,
+          pageSize: 6,
+          minRating: 4,
+          dateRange: '30d',
+          verifiedOnly: true,
+          sort: 'rating_desc',
+        },
+        signal,
+      },
+    );
+  });
+
+  it('fetches the on-chain reputation score separately', async () => {
+    mockedAxios.get.mockResolvedValue({
+      data: {
+        driverId: 'driver-1',
+        score: 92,
+        totalReviews: 24,
+        verifiedReviews: 20,
+        updatedAt: '2026-10-18T00:00:00.000Z',
+        source: 'on_chain',
+      },
+    });
+    const signal = new AbortController().signal;
+
+    await driverReviewService.getDriverReputation('driver-1', signal);
+
+    expect(mockedAxios.get).toHaveBeenCalledWith(
+      `${apiBase}/api/fleet/drivers/driver-1/reputation`,
+      { signal },
+    );
+  });
+});
diff --git a/services/__tests__/signatureCaptureService.test.ts b/services/__tests__/signatureCaptureService.test.ts
new file mode 100644
index 00000000..931a44e7
--- /dev/null
+++ b/services/__tests__/signatureCaptureService.test.ts
@@ -0,0 +1,28 @@
+import {
+  MIN_SIGNATURE_INK_LENGTH,
+  signatureCaptureService,
+} from '@/services/signatureCaptureService';
+
+describe('signatureCaptureService', () => {
+  it('rejects ink below the configured quality threshold', () => {
+    expect(
+      signatureCaptureService.assessQuality(MIN_SIGNATURE_INK_LENGTH - 1, ''),
+    ).toEqual({
+      inkLength: MIN_SIGNATURE_INK_LENGTH - 1,
+      isTooLight: true,
+    });
+  });
+
+  it('accepts ink at the configured quality threshold', () => {
+    expect(
+      signatureCaptureService.assessQuality(MIN_SIGNATURE_INK_LENGTH, ''),
+    ).toEqual({
+      inkLength: MIN_SIGNATURE_INK_LENGTH,
+      isTooLight: false,
+    });
+  });
+
+  it('accepts a trimmed typed fallback with at least two characters', () => {
+    expect(signatureCaptureService.assessQuality(0, '  Ada  ').isTooLight).toBe(false);
+  });
+});
diff --git a/services/driverReviewService.ts b/services/driverReviewService.ts
index cdfc5d7b..bfea19f1 100644
--- a/services/driverReviewService.ts
+++ b/services/driverReviewService.ts
@@ -1,5 +1,9 @@
 import axios from 'axios';
-import type { DriverReviewsPage, DriverReviewsQuery } from '@/types/driverReview';
+import type {
+  DriverReputationScore,
+  DriverReviewsPage,
+  DriverReviewsQuery,
+} from '@/types/driverReview';
 
 const API_BASE_URL = process.env.NEXT_PUBLIC_API_URL ?? '';
 
@@ -14,7 +18,7 @@ export const driverReviewService = {
     signal?: AbortSignal,
   ): Promise<DriverReviewsPage> {
     const { data } = await axios.get<DriverReviewsPage>(
-      `${API_BASE_URL}/fleet/drivers/${driverId}/reviews`,
+      `${API_BASE_URL}/api/fleet/drivers/${driverId}/reviews`,
       {
         params: {
           page: query.page,
@@ -29,4 +33,15 @@ export const driverReviewService = {
     );
     return data;
   },
+
+  async getDriverReputation(
+    driverId: string,
+    signal?: AbortSignal,
+  ): Promise<DriverReputationScore> {
+    const { data } = await axios.get<DriverReputationScore>(
+      `${API_BASE_URL}/api/fleet/drivers/${driverId}/reputation`,
+      { signal },
+    );
+    return data;
+  },
 };
diff --git a/services/proofService.ts b/services/proofService.ts
index ac4d572a..ddea9184 100644
--- a/services/proofService.ts
+++ b/services/proofService.ts
@@ -14,6 +14,11 @@ export interface ProofDocument {
   status: 'pending' | 'verified' | 'rejected';
 }
 
+export interface DeliveryProofBundle {
+  photo: ProofDocument;
+  signatureDataUrl: string;
+}
+
 export interface ApiResponse<T> {
   success: boolean;
   message: string;
@@ -24,7 +29,7 @@ export interface CompressionOptions {
   maxSizeMB?: number;
   maxWidthOrHeight?: number;
   useWebWorker?: boolean;
-  onProgress?: (progress: number) => void;
+  onProgress?: (_progress: number) => void;
 }
 
 /**
@@ -100,7 +105,7 @@ export const proofService = {
   async uploadProof(
     formData: FormData,
     deliveryId: string,
-    onUploadProgress?: (progressEvent: any) => void
+    onUploadProgress?: (_progressEvent: any) => void
   ): Promise<ApiResponse<ProofDocument>> {
     try {
       const { data } = await axios.post<ApiResponse<ProofDocument>>(
@@ -119,6 +124,22 @@ export const proofService = {
     }
   },
 
+  async uploadProofBundle(
+    formData: FormData,
+    deliveryId: string,
+    onUploadProgress?: (_progressEvent: { loaded: number; total?: number }) => void
+  ): Promise<ApiResponse<DeliveryProofBundle>> {
+    const { data } = await axios.post<ApiResponse<DeliveryProofBundle>>(
+      `${API_BASE_URL}/api/deliveries/${deliveryId}/proof-bundle`,
+      formData,
+      {
+        headers: { 'Content-Type': 'multipart/form-data' },
+        onUploadProgress,
+      }
+    );
+    return data;
+  },
+
   /**
    * Retrieve proof documents for a delivery
    * @param deliveryId - ID of the delivery
diff --git a/services/qrDecoderService.ts b/services/qrDecoderService.ts
new file mode 100644
index 00000000..43dd9daf
--- /dev/null
+++ b/services/qrDecoderService.ts
@@ -0,0 +1,15 @@
+import jsQR from 'jsqr';
+
+export const qrDecoderService = {
+  decode(
+    context: CanvasRenderingContext2D,
+    width: number,
+    height: number,
+  ): string | null {
+    const image = context.getImageData(0, 0, width, height);
+    const result = jsQR(image.data, image.width, image.height, {
+      inversionAttempts: 'dontInvert',
+    });
+    return result?.data?.trim() || null;
+  },
+};
diff --git a/services/qrScannerService.ts b/services/qrScannerService.ts
index a4d5daa9..f6e6701a 100644
--- a/services/qrScannerService.ts
+++ b/services/qrScannerService.ts
@@ -1,9 +1,21 @@
 import { apiClient } from './api';
 
+export interface VerifiedQrDelivery {
+  success: boolean;
+  deliveryId: string;
+  message: string;
+  status?: string;
+  senderName?: string;
+  driverName?: string;
+  destination?: string;
+}
+
 export const qrScannerService = {
-  verifyQrCode: async (qrData: string) => {
-    const response = await apiClient.post('/logistics/qr/verify', { data: qrData });
+  verifyQrCode: async (qrData: string): Promise<VerifiedQrDelivery> => {
+    const response = await apiClient.post<VerifiedQrDelivery>(
+      '/logistics/qr/verify',
+      { data: qrData },
+    );
     return response.data;
-    
   },
 };
diff --git a/services/signatureCaptureService.ts b/services/signatureCaptureService.ts
new file mode 100644
index 00000000..1db2d824
--- /dev/null
+++ b/services/signatureCaptureService.ts
@@ -0,0 +1,23 @@
+export interface SignatureQuality {
+  isTooLight: boolean;
+  inkLength: number;
+}
+
+export const MIN_SIGNATURE_INK_LENGTH = 48;
+
+/** Pure signature rules shared by the canvas hook and its tests. */
+export const signatureCaptureService = {
+  assessQuality(
+    inkLength: number,
+    typedSignature: string,
+    minimumInkLength = MIN_SIGNATURE_INK_LENGTH,
+  ): SignatureQuality {
+    const normalizedText = typedSignature.trim();
+    const hasTypedSignature = normalizedText.length >= 2;
+
+    return {
+      inkLength,
+      isTooLight: !hasTypedSignature && inkLength < minimumInkLength,
+    };
+  },
+};
diff --git a/types/driverReview.ts b/types/driverReview.ts
index a69d537c..84a382f6 100644
--- a/types/driverReview.ts
+++ b/types/driverReview.ts
@@ -29,3 +29,20 @@ export interface DriverReviewsPage {
   hasMore: boolean;
   total: number;
 }
+
+export interface DriverReputationScore {
+  driverId: string;
+  score: number;
+  totalReviews: number;
+  verifiedReviews: number;
+  updatedAt: string;
+  source: 'on_chain';
+}
+
+export interface DriverReviewsPagination {
+  loaded: number;
+  total: number;
+  currentPage: number;
+  pageSize: number;
+  hasMore: boolean;
+}