diff --git a/src/hooks/useTransfers.js b/src/hooks/useTransfers.js
index dea1e61..a3ebcea 100644
--- a/src/hooks/useTransfers.js
+++ b/src/hooks/useTransfers.js
@@ -1,4 +1,3 @@
-
 import { useCallback, useEffect, useState } from 'react';
 import { listTransfers, createTransfer } from '../services/api.js';
 import { ContractViolationError } from '../services/contracts/schema.js';
@@ -47,10 +46,18 @@ export function useTransfers() {
 
   const addTransfer = useCallback(async (payload) => {
     const created = await createTransfer(payload);
-    setTransfers((prev) => [created, ...prev]);
+    setTransfers((prev) => {
+      if (prev.some((t) => t.id === created.id)) return prev;
+      return [created, ...prev];
+    });
     return created;
   }, []);
 
+  const getTransferById = useCallback(
+    (id) => transfers.find((t) => t.id === id) ?? null,
+    [transfers],
+  );
+
   // Existing consumers use reload for both pull-to-refresh and the error-state
   // retry action. Withhold it only while a non-retryable error is displayed.
   const safeReload = error && !retryable ? undefined : reload;
@@ -62,5 +69,6 @@ export function useTransfers() {
     retryable,
     reload: safeReload,
     addTransfer,
+    getTransferById,
   };
 }
diff --git a/src/pages/SendMoney.jsx b/src/pages/SendMoney.jsx
index c1e03f0..182d120 100644
--- a/src/pages/SendMoney.jsx
+++ b/src/pages/SendMoney.jsx
@@ -9,7 +9,11 @@ import Modal from '../components/Modal.jsx';
 import { buildQuote } from '../services/quote.js';
 import { ContractViolationError } from '../services/contracts/schema.js';
 import { getUserErrorMessage, normalizeError } from '../services/errors.js';
-import { formatAmount, formatCurrencyInput, parseCurrencyInput } from '../utils/format.js';
+import {
+  formatAmount,
+  formatCurrencyInput,
+  parseCurrencyInput,
+} from '../utils/format.js';
 import {
   isPositiveAmount,
   validateRecipient,
@@ -17,6 +21,13 @@ import {
 } from '../utils/validate.js';
 import { useWallet } from '../hooks/useWallet.js';
 import { useTransfers } from '../hooks/useTransfers.js';
+import {
+  fingerprintTransferPayload,
+  idempotencyKeyFor,
+  newTransferIntentNonce,
+  saveTransferOperation,
+  getLatestRecoverableOperation,
+} from '../utils/transferIntent.js';
 import { useOnlineStatus } from '../hooks/useOnlineStatus.js';
 import { useApp } from '../context/AppContext.jsx';
 import { useDebouncedValue } from '../hooks/useDebouncedValue.js';
@@ -36,7 +47,7 @@ import './SendMoney.css';
 export default function SendMoney() {
   const navigate = useNavigate();
   const { wallet, isConnected, connect } = useWallet();
-  const { addTransfer } = useTransfers();
+  const { addTransfer, getTransferById, transfers } = useTransfers();
   const { locale } = useApp();
   const isOnline = useOnlineStatus();
 
@@ -48,6 +59,8 @@ export default function SendMoney() {
   const [submitting, setSubmitting] = useState(false);
   const [submitError, setSubmitError] = useState(null);
   const submissionLock = useRef(false);
+  const intentKeyRef = useRef(null);
+  const intentFingerprintRef = useRef(null);
   const wasOffline = useRef(false);
 
   // True when the form just recovered from a disconnected state. Used to
@@ -59,6 +72,30 @@ export default function SendMoney() {
   const [phase, setPhase] = useState(null);
   const [pendingQuote, setPendingQuote] = useState(null);
   const [submittedTransfer, setSubmittedTransfer] = useState(null);
+
+  // Restore a recoverable transfer intent after navigation/refresh so a retry
+  // cannot mint a second transfer for the same payload. Succeeded intents show
+  // status once; dismissing the dialog marks them acknowledged.
+  useEffect(() => {
+    const recoverable = getLatestRecoverableOperation();
+    if (!recoverable) return;
+    intentKeyRef.current = recoverable.idempotencyKey;
+    intentFingerprintRef.current = recoverable.fingerprint;
+    const existing =
+      (recoverable.transferId && getTransferById(recoverable.transferId)) ||
+      transfers.find((transfer) => transfer.idempotencyKey === recoverable.idempotencyKey);
+    if (existing) {
+      if (recoverable.status !== 'succeeded' || recoverable.transferId !== existing.id) {
+        saveTransferOperation({ ...recoverable, transferId: existing.id, status: 'succeeded' });
+      }
+      setSubmitError(null);
+      setSubmittedTransfer(existing);
+      setPhase('success');
+    } else if (recoverable.status === 'unknown' || recoverable.status === 'submitting') {
+      setSubmitError('Transfer status is unknown. Check Transfers, or re-enter the same details to retry safely.');
+    }
+  }, [getTransferById, transfers]);
+
   const submitButtonRef = useRef(null);
 
   // Debounce the amount so the quote isn't rebuilt on every keystroke.
@@ -193,12 +230,16 @@ export default function SendMoney() {
 
       // Rebuild at confirmation time so the committed amounts match the note:
       // rates are indicative and update at confirmation.
-      const parsedAmount = parseCurrencyInput(amount, { currency: from, locale });
+      const parsedAmount = parseCurrencyInput(amount, {
+        currency: from,
+        locale,
+      });
       if (!parsedAmount.ok) {
         setSubmitError(parsedAmount.error);
         return;
       }
-      const finalQuote = pendingQuote ?? buildQuote(parsedAmount.value, from, to);
+      const finalQuote =
+        pendingQuote ?? buildQuote(parsedAmount.value, from, to);
       if (!finalQuote) {
         setSubmitError(
           'We could not price this transfer. Check the amount and the selected currencies.',
@@ -209,7 +250,7 @@ export default function SendMoney() {
       // Record the fee, rate and expiry alongside the amounts so the receipt
       // can reproduce exactly what was quoted rather than re-deriving it from
       // a rate that may since have moved.
-      const created = await addTransfer({
+      const payload = {
         recipient,
         from,
         to,
@@ -218,6 +259,27 @@ export default function SendMoney() {
         fee: finalQuote.fee,
         rate: finalQuote.rate,
         expiresAt: finalQuote.expiresAt,
+      };
+      // Persist only an opaque fingerprint, never recipient or quote details.
+      const fingerprint = await idempotencyKeyFor(fingerprintTransferPayload(payload));
+      if (intentFingerprintRef.current !== fingerprint || !intentKeyRef.current) {
+        const recoverable = getLatestRecoverableOperation(fingerprint);
+        intentKeyRef.current = recoverable?.idempotencyKey ??
+          (await idempotencyKeyFor(fingerprint, newTransferIntentNonce()));
+        intentFingerprintRef.current = fingerprint;
+      }
+      const idempotencyKey = intentKeyRef.current;
+      saveTransferOperation({
+        idempotencyKey,
+        fingerprint,
+        status: 'submitting',
+      });
+      const created = await addTransfer({ ...payload, idempotencyKey });
+      saveTransferOperation({
+        idempotencyKey,
+        fingerprint,
+        transferId: created?.id,
+        status: 'succeeded',
       });
       setSubmittedTransfer(created ?? finalQuote);
       setPendingQuote(null);
@@ -230,23 +292,42 @@ export default function SendMoney() {
         // The full field-by-field diff goes to the console; the user gets a
         // message that distinguishes "we rejected this" from "try again".
         console.error(err.message);
+        // Nothing was submitted — drop the intent so a corrected payload can
+        // start a fresh one, and a retry of the same payload gets a new key
+        // only if the user edits (same fingerprint reuses the key below).
+        if (intentKeyRef.current) {
+          saveTransferOperation({
+            idempotencyKey: intentKeyRef.current,
+            fingerprint: intentFingerprintRef.current,
+            status: 'failed',
+          });
+        }
         setSubmitError(
           'This transfer was rejected before it was sent because the details did not match the expected format. Nothing was submitted.',
         );
       } else {
         const normalized = normalizeError(err, { source: 'api' });
-      // A transfer can be interrupted mid-signature by a connection drop.
-      // The honest message here is "unknown", not "failed": the backend may
-      // have accepted the transfer even though the response never arrived.
-      // The transfers page reconciles real status on reconnect.
-      // Read the current connectivity directly (not from the render closure)
-      // so that a mid-flight disconnect produces the correct message.
-      const connectedNow = typeof navigator !== 'undefined' && navigator.onLine;
-      setSubmitError(
-        connectedNow
-          ? getUserErrorMessage(normalized)
-          : 'Connection lost while sending. Reconnect to check your transfer status.',
-      );
+        // A transfer can be interrupted mid-signature by a connection drop or
+        // timeout. The honest message here is "unknown", not "failed": the
+        // backend may have accepted the transfer even though the response never
+        // arrived. Keep the intent as `unknown` so refresh/retry reuses the same
+        // idempotency key instead of minting a duplicate.
+        // Read the current connectivity directly (not from the render closure)
+        // so that a mid-flight disconnect produces the correct message.
+        const connectedNow =
+          typeof navigator !== 'undefined' && navigator.onLine;
+        if (intentKeyRef.current) {
+          saveTransferOperation({
+            idempotencyKey: intentKeyRef.current,
+            fingerprint: intentFingerprintRef.current,
+            status: 'unknown',
+          });
+        }
+        setSubmitError(
+          connectedNow
+            ? getUserErrorMessage(normalized)
+            : 'Connection lost while sending. Reconnect to check your transfer status.',
+        );
       }
     } finally {
       submissionLock.current = false;
@@ -254,6 +335,20 @@ export default function SendMoney() {
     }
   }
 
+  function dismissSuccess() {
+    if (intentKeyRef.current) {
+      saveTransferOperation({
+        idempotencyKey: intentKeyRef.current,
+        fingerprint: intentFingerprintRef.current,
+        transferId: submittedTransfer?.id,
+        status: 'dismissed',
+      });
+    }
+    intentKeyRef.current = null;
+    intentFingerprintRef.current = null;
+    setPhase(null);
+  }
+
   const errorCount = Object.keys(errors).length;
 
   return (
@@ -292,8 +387,8 @@ export default function SendMoney() {
               role="status"
               aria-live="polite"
             >
-              ✓ Back online. Your form was not submitted while you were
-              offline — review it and send when ready.
+              ✓ Back online. Your form was not submitted while you were offline
+              — review it and send when ready.
             </div>
           )}
 
@@ -397,7 +492,11 @@ export default function SendMoney() {
       )}
 
       {phase === 'success' && submittedTransfer && (
-        <Modal open onClose={() => setPhase(null)} title="Transfer submitted">
+        <Modal
+          open
+          onClose={dismissSuccess}
+          title="Transfer submitted"
+        >
           <p className="send-result-status" role="status" aria-live="polite">
             Your transfer was submitted successfully. Track its progress under
             Transfers.
@@ -433,7 +532,10 @@ export default function SendMoney() {
             </div>
           </dl>
           <div className="send-dialog-actions">
-            <Button variant="secondary" onClick={() => setPhase(null)}>
+            <Button
+              variant="secondary"
+              onClick={dismissSuccess}
+            >
               Close
             </Button>
             <Button onClick={() => navigate('/transfers')}>
diff --git a/src/services/api.js b/src/services/api.js
index d8d2797..779b4bc 100644
--- a/src/services/api.js
+++ b/src/services/api.js
@@ -6,6 +6,7 @@
 // guess whether a field is present or whether an amount is really a number.
 
 import { ContractViolationError } from './contracts/schema.js';
+import { fingerprintTransferPayload } from '../utils/transferIntent.js';
 import {
   parseTransfer,
   parseTransferList,
@@ -45,7 +46,7 @@ function read() {
   } catch {
     // ignore parse/storage errors
   }
-  return SEED_TRANSFERS;
+  return SEED_TRANSFERS.map((transfer) => ({ ...transfer }));
 }
 
 function write(transfers) {
@@ -106,6 +107,24 @@ export function listTransfers() {
   });
 }
 
+// In-flight create promises keyed by idempotency key so concurrent retries
+// (double-click, timeout replay) share one insert instead of racing two writes.
+const pendingCreates = new Map();
+let transferSequence = 0;
+
+function conflictingIdempotencyKey() {
+  return new ContractViolationError(
+    transferContract,
+    [{
+      path: 'idempotencyKey',
+      code: 'conflicting_payload',
+      expected: 'the original transfer details for this key',
+      received: 'different transfer details',
+    }],
+    { source: 'createTransfer' },
+  );
+}
+
 /**
  * Create a new transfer record.
  *
@@ -113,24 +132,55 @@ export function listTransfers() {
  * payload fails at submission with an actionable diff instead of writing a
  * record that later renders as a plausible-looking wrong number.
  *
+ * When `idempotencyKey` is present, a repeated or concurrent create with the
+ * same key returns the prior transfer instead of inserting a duplicate.
+ *
  * @param {object} payload - transfer details
  * @returns {Promise<object>} the created transfer
  */
 export function createTransfer(payload) {
-  return new Promise((resolve, reject) => {
+  const { idempotencyKey, ...fields } = payload ?? {};
+  const fingerprint = idempotencyKey ? fingerprintTransferPayload(fields) : null;
+
+  if (idempotencyKey && pendingCreates.has(idempotencyKey)) {
+    const pending = pendingCreates.get(idempotencyKey);
+    return pending.fingerprint === fingerprint
+      ? pending.promise
+      : Promise.reject(conflictingIdempotencyKey());
+  }
+
+  const createPromise = new Promise((resolve, reject) => {
     setTimeout(() => {
       try {
+        const existing = read();
+        const transfers = Array.isArray(existing) ? existing : [];
+
+        // Same idempotency key + same logical intent → return the prior record
+        // instead of inserting a duplicate transfer.
+        if (idempotencyKey) {
+          const prior = transfers.find(
+            (t) => t.idempotencyKey === idempotencyKey,
+          );
+          if (prior) {
+            const parsedPrior = parseTransfer(prior, { source: 'createTransfer.idempotent' });
+            if (fingerprintTransferPayload(parsedPrior) !== fingerprint) {
+              throw conflictingIdempotencyKey();
+            }
+            resolve(parsedPrior);
+            return;
+          }
+        }
+
         const transfer = parseTransfer(
           {
-            id: 'tx_' + Date.now(),
+            id: `tx_${Date.now()}_${++transferSequence}`,
             status: 'pending',
             createdAt: new Date().toISOString(),
-            ...payload,
+            ...(idempotencyKey ? { idempotencyKey } : {}),
+            ...fields,
           },
           { source: 'createTransfer' },
         );
-        const existing = read();
-        const transfers = Array.isArray(existing) ? existing : [];
         transfers.push(transfer);
         write(transfers);
         resolve(transfer);
@@ -138,5 +188,10 @@ export function createTransfer(payload) {
         reject(error);
       }
     }, 700);
+  }).finally(() => {
+    if (idempotencyKey) pendingCreates.delete(idempotencyKey);
   });
+
+  if (idempotencyKey) pendingCreates.set(idempotencyKey, { fingerprint, promise: createPromise });
+  return createPromise;
 }
diff --git a/src/services/contracts/transfer.js b/src/services/contracts/transfer.js
index ce4e901..313bdc4 100644
--- a/src/services/contracts/transfer.js
+++ b/src/services/contracts/transfer.js
@@ -68,6 +68,8 @@ export const transferContract = defineContract({
     rate: { type: 'decimal', required: false, min: 0 },
     expiresAt: { type: 'timestamp', required: false },
     failureReason: { type: 'string', required: false, nullable: true },
+    // Client-bound idempotency key; optional for legacy records.
+    idempotencyKey: { type: 'string', required: false, nullable: true },
   },
 });
 
diff --git a/src/utils/transferIntent.js b/src/utils/transferIntent.js
new file mode 100644
index 0000000..ba681dd
--- /dev/null
+++ b/src/utils/transferIntent.js
@@ -0,0 +1,143 @@
+/**
+ * Transfer intent fingerprint + session-scoped operation reference.
+ *
+ * One user intent maps to one idempotency key bound to the exact payload.
+ * Editing the payload produces a new fingerprint and therefore a new intent.
+ * Only a safe operation reference (key + status + transfer id) is persisted
+ * across navigation/refresh — never secrets or raw form state.
+ */
+
+import { parseDecimal } from './money.js';
+
+const OPS_KEY = 'remitflow.transferOps';
+let nonceSequence = 0;
+
+/** @typedef {'submitting'|'unknown'|'succeeded'|'failed'|'dismissed'} OpStatus */
+
+/**
+ * Canonical fingerprint of the transferable payload fields.
+ * @param {{recipient:string,from:string,to:string,sendAmount:number|string,receiveAmount:number|string,fee?:number|string,rate?:number|string}} payload
+ */
+export function fingerprintTransferPayload(payload) {
+  const parts = [
+    String(payload.recipient ?? ''),
+    String(payload.from ?? '').toUpperCase(),
+    String(payload.to ?? '').toUpperCase(),
+    normalizeAmount(payload.sendAmount),
+    normalizeAmount(payload.receiveAmount),
+    normalizeAmount(payload.fee),
+    normalizeAmount(payload.rate),
+  ];
+  return JSON.stringify(parts);
+}
+
+function normalizeAmount(value) {
+  if (value === undefined || value === null || value === '') return '';
+  const parsed = parseDecimal(value);
+  return parsed.ok ? parsed.value : String(value);
+}
+
+/**
+ * Unique nonce for a new user intent. Retries reuse the saved key instead.
+ */
+export function newTransferIntentNonce() {
+  if (globalThis.crypto?.randomUUID) return globalThis.crypto.randomUUID();
+  if (globalThis.crypto?.getRandomValues) {
+    const bytes = new Uint8Array(16);
+    globalThis.crypto.getRandomValues(bytes);
+    return [...bytes].map((byte) => byte.toString(16).padStart(2, '0')).join('');
+  }
+  return `${Date.now().toString(36)}:${++nonceSequence}:${Math.random().toString(36).slice(2)}`;
+}
+
+/**
+ * Hash a payload fingerprint. A fresh nonce makes a new transfer key;
+ * a retry reuses the key saved with its operation reference.
+ * @param {string} fingerprint
+ * @param {string} [nonce]
+ */
+export async function idempotencyKeyFor(fingerprint, nonce) {
+  const input = nonce === undefined ? fingerprint : JSON.stringify([fingerprint, nonce]);
+  if (globalThis.crypto?.subtle) {
+    const data = new TextEncoder().encode(input);
+    const digest = await globalThis.crypto.subtle.digest('SHA-256', data);
+    const hex = [...new Uint8Array(digest)]
+      .map((b) => b.toString(16).padStart(2, '0'))
+      .join('');
+    return `idem_${hex.slice(0, 32)}`;
+  }
+  return `idem_${fnv1a(input)}`;
+}
+
+function fnv1a(input) {
+  let hash = 0x811c9dc5;
+  for (let i = 0; i < input.length; i += 1) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return (hash >>> 0).toString(16).padStart(8, '0');
+}
+
+function readOps() {
+  try {
+    const raw = sessionStorage.getItem(OPS_KEY);
+    if (!raw) return {};
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeOps(ops) {
+  try {
+    sessionStorage.setItem(OPS_KEY, JSON.stringify(ops));
+  } catch {
+    // ignore quota / private mode
+  }
+}
+
+/**
+ * Persist a safe operation reference for navigation/refresh recovery.
+ * @param {{idempotencyKey:string,fingerprint:string,transferId?:string|null,status:OpStatus}} op
+ */
+export function saveTransferOperation(op) {
+  if (!op?.idempotencyKey) return;
+  const ops = readOps();
+  ops[op.idempotencyKey] = {
+    idempotencyKey: op.idempotencyKey,
+    fingerprint: op.fingerprint,
+    transferId: op.transferId ?? null,
+    status: op.status,
+    updatedAt: new Date().toISOString(),
+  };
+  writeOps(ops);
+}
+
+/** @param {string} idempotencyKey */
+export function getTransferOperation(idempotencyKey) {
+  if (!idempotencyKey) return null;
+  return readOps()[idempotencyKey] ?? null;
+}
+
+/**
+ * Latest recoverable intent: in-flight, unknown outcome, or succeeded but not
+ * yet dismissed. Used after navigation/refresh to restore status without
+ * minting a second transfer.
+ */
+export function getLatestRecoverableOperation(fingerprint) {
+  const recoverable = new Set(['submitting', 'unknown', 'succeeded']);
+  const ops = Object.values(readOps());
+  const matches = ops
+    .filter((op) => op && recoverable.has(op.status) &&
+      (fingerprint === undefined || op.fingerprint === fingerprint))
+    .sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)));
+  return matches[0] ?? null;
+}
+
+export function clearTransferOperation(idempotencyKey) {
+  if (!idempotencyKey) return;
+  const ops = readOps();
+  delete ops[idempotencyKey];
+  writeOps(ops);
+}
diff --git a/test/integration/offline-reconnect.test.jsx b/test/integration/offline-reconnect.test.jsx
index 10a8761..10fb5b4 100644
--- a/test/integration/offline-reconnect.test.jsx
+++ b/test/integration/offline-reconnect.test.jsx
@@ -43,6 +43,7 @@ describe('Offline and reconnect state for transfer mutations', () => {
     });
     window.history.pushState({}, '', '/send');
     localStorage.clear();
+    sessionStorage.clear();
   });
 
   afterEach(() => {
diff --git a/test/integration/send-money-form.test.jsx b/test/integration/send-money-form.test.jsx
index 43a7381..a81b8bb 100644
--- a/test/integration/send-money-form.test.jsx
+++ b/test/integration/send-money-form.test.jsx
@@ -61,6 +61,7 @@ describe('Send money form flows', () => {
   beforeEach(() => {
     window.history.pushState({}, '', '/send');
     localStorage.clear();
+    sessionStorage.clear();
   });
 
   afterEach(() => {
diff --git a/test/integration/send-money-idempotency.test.jsx b/test/integration/send-money-idempotency.test.jsx
new file mode 100644
index 0000000..f76d135
--- /dev/null
+++ b/test/integration/send-money-idempotency.test.jsx
@@ -0,0 +1,263 @@
+import { act, render, screen, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import App from '../../src/App.jsx';
+import * as api from '../../src/services/api.js';
+import {
+  fingerprintTransferPayload,
+  getLatestRecoverableOperation,
+  idempotencyKeyFor,
+  saveTransferOperation,
+} from '../../src/utils/transferIntent.js';
+
+async function fillValidForm(user, amount = '25') {
+  await user.type(
+    await screen.findByLabelText(/recipient/i),
+    'amina@example.com',
+  );
+  await user.type(screen.getByLabelText(/^amount$/i), amount);
+}
+
+describe('SendMoney duplicate-submission guard', () => {
+  beforeEach(() => {
+    sessionStorage.clear();
+    localStorage.clear();
+    window.history.pushState({}, '', '/send');
+    vi.restoreAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    sessionStorage.clear();
+  });
+
+  it('double-confirm with the same payload creates only one transfer', async () => {
+    const user = userEvent.setup();
+    render(<App />);
+
+    await fillValidForm(user);
+    await user.click(screen.getByRole('button', { name: /review & send/i }));
+    const dialog = await screen.findByRole('dialog', {
+      name: /confirm your transfer/i,
+    });
+    const confirm = within(dialog).getByRole('button', {
+      name: /confirm transfer/i,
+    });
+
+    // Rapid double activation of Confirm; submissionLock + idempotency key
+    // must keep a single persisted record.
+    act(() => {
+      confirm.click();
+      confirm.click();
+    });
+
+    await screen.findByRole(
+      'dialog',
+      { name: /transfer submitted/i },
+      { timeout: 5000 },
+    );
+
+    const listed = await api.listTransfers();
+    const mine = listed.filter(
+      (t) =>
+        t.recipient === 'amina@example.com' &&
+        Number(t.sendAmount) === 25 &&
+        t.idempotencyKey,
+    );
+    expect(mine.length).toBe(1);
+  });
+
+  it('allows another identical transfer after the first was acknowledged', async () => {
+    const user = userEvent.setup();
+    render(<App />);
+    await fillValidForm(user, '25');
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      await user.click(screen.getByRole('button', { name: /review & send/i }));
+      const confirm = await screen.findByRole('dialog', { name: /confirm your transfer/i });
+      await user.click(within(confirm).getByRole('button', { name: /confirm transfer/i }));
+      const success = await screen.findByRole('dialog', { name: /transfer submitted/i }, { timeout: 5000 });
+      await user.click(within(success).getByRole('button', { name: /^close$/i }));
+    }
+    const listed = await api.listTransfers();
+    const sent = listed.filter((t) => t.recipient === 'amina@example.com' && Number(t.sendAmount) === 25 && t.idempotencyKey);
+    expect(sent).toHaveLength(2);
+    expect(sent[0].idempotencyKey).not.toBe(sent[1].idempotencyKey);
+    expect(sessionStorage.getItem('remitflow.transferOps')).not.toContain('amina@example.com');
+  });
+
+  it('refresh restores in-flight status without creating a second transfer', async () => {
+    const payload = {
+      recipient: 'amina@example.com',
+      from: 'USD',
+      to: 'NGN',
+      sendAmount: 25,
+      receiveAmount: 36642.38,
+      fee: 0.25,
+      rate: 1480.5,
+    };
+    const fingerprint = fingerprintTransferPayload(payload);
+    const idempotencyKey = await idempotencyKeyFor(fingerprint);
+    const prior = await api.createTransfer({ ...payload, idempotencyKey });
+    saveTransferOperation({
+      idempotencyKey,
+      fingerprint,
+      transferId: prior.id,
+      status: 'succeeded',
+    });
+
+    const spy = vi.spyOn(api, 'createTransfer');
+    render(<App />);
+    await screen.findByRole('heading', { name: /send money/i });
+
+    // Reconcile restores the success dialog from the safe operation reference.
+    expect(
+      await screen.findByRole('dialog', { name: /transfer submitted/i }),
+    ).toBeInTheDocument();
+    expect(spy).not.toHaveBeenCalled();
+    const listed = await api.listTransfers();
+    expect(
+      listed.filter((t) => t.idempotencyKey === idempotencyKey),
+    ).toHaveLength(1);
+  });
+
+  it('reconciles an accepted transfer after refresh even without its transfer id', async () => {
+    const payload = {
+      recipient: 'amina@example.com', from: 'USD', to: 'NGN',
+      sendAmount: 25, receiveAmount: 36642.38, fee: 0.25, rate: 1480.5,
+    };
+    const fingerprint = await idempotencyKeyFor(fingerprintTransferPayload(payload));
+    const idempotencyKey = await idempotencyKeyFor(fingerprint, 'prior-intent');
+    await api.createTransfer({ ...payload, idempotencyKey });
+    saveTransferOperation({ idempotencyKey, fingerprint, status: 'unknown' });
+    const spy = vi.spyOn(api, 'createTransfer');
+    render(<App />);
+    expect(await screen.findByRole('dialog', { name: /transfer submitted/i }))
+      .toBeInTheDocument();
+    expect(spy).not.toHaveBeenCalled();
+    expect(getLatestRecoverableOperation()?.status).toBe('succeeded');
+  });
+
+  it('timeout retry with the same intent reuses the idempotency key', async () => {
+    const payload = {
+      recipient: 'amina@example.com',
+      from: 'USD',
+      to: 'NGN',
+      sendAmount: 40,
+      receiveAmount: 50000,
+      fee: 0.4,
+      rate: 1480.5,
+      idempotencyKey: 'idem_timeout_reuse',
+    };
+    const first = await api.createTransfer(payload);
+    // Simulate a client timeout after the server accepted: replay same key.
+    const replay = await api.createTransfer(payload);
+    expect(replay.id).toBe(first.id);
+    const listed = await api.listTransfers();
+    expect(
+      listed.filter((t) => t.idempotencyKey === 'idem_timeout_reuse'),
+    ).toHaveLength(1);
+  });
+
+  it('navigation away and back restores the succeeded intent without a second create', async () => {
+    const user = userEvent.setup();
+    const spy = vi.spyOn(api, 'createTransfer');
+    render(<App />);
+
+    await fillValidForm(user, '30');
+    await user.click(screen.getByRole('button', { name: /review & send/i }));
+    const dialog = await screen.findByRole('dialog', {
+      name: /confirm your transfer/i,
+    });
+    await user.click(
+      within(dialog).getByRole('button', { name: /confirm transfer/i }),
+    );
+    await screen.findByRole(
+      'dialog',
+      { name: /transfer submitted/i },
+      { timeout: 5000 },
+    );
+
+    const callsAfterSubmit = spy.mock.calls.length;
+    expect(callsAfterSubmit).toBeGreaterThanOrEqual(1);
+    expect(getLatestRecoverableOperation()?.status).toBe('succeeded');
+
+    // Navigate to Transfers then back to Send — reconcile must not re-create.
+    await user.click(screen.getByRole('button', { name: /view transfers/i }));
+    await screen.findByRole(
+      'heading',
+      { name: /your transfers/i },
+      {
+        timeout: 5000,
+      },
+    );
+    const sendLinks = screen.getAllByRole('link', { name: /send money/i });
+    await user.click(sendLinks[0]);
+    await screen.findByRole('heading', { name: /send money/i });
+
+    await waitFor(() => {
+      expect(
+        screen.getByRole('dialog', { name: /transfer submitted/i }),
+      ).toBeInTheDocument();
+    });
+    expect(spy).toHaveBeenCalledTimes(callsAfterSubmit);
+  });
+
+  it('edited payload after a prior intent uses a new idempotency key', async () => {
+    const firstKey = await idempotencyKeyFor(
+      fingerprintTransferPayload({
+        recipient: 'amina@example.com',
+        from: 'USD',
+        to: 'NGN',
+        sendAmount: 10,
+        receiveAmount: 1000,
+        fee: 0.1,
+        rate: 100,
+      }),
+    );
+    const secondKey = await idempotencyKeyFor(
+      fingerprintTransferPayload({
+        recipient: 'amina@example.com',
+        from: 'USD',
+        to: 'NGN',
+        sendAmount: 20,
+        receiveAmount: 2000,
+        fee: 0.2,
+        rate: 100,
+      }),
+    );
+    expect(firstKey).not.toEqual(secondKey);
+
+    const a = await api.createTransfer({
+      recipient: 'amina@example.com',
+      from: 'USD',
+      to: 'NGN',
+      sendAmount: 10,
+      receiveAmount: 1000,
+      fee: 0.1,
+      rate: 100,
+      idempotencyKey: firstKey,
+    });
+    const a2 = await api.createTransfer({
+      recipient: 'amina@example.com',
+      from: 'USD',
+      to: 'NGN',
+      sendAmount: 10,
+      receiveAmount: 1000,
+      fee: 0.1,
+      rate: 100,
+      idempotencyKey: firstKey,
+    });
+    expect(a2.id).toBe(a.id);
+    const b = await api.createTransfer({
+      recipient: 'amina@example.com',
+      from: 'USD',
+      to: 'NGN',
+      sendAmount: 20,
+      receiveAmount: 2000,
+      fee: 0.2,
+      rate: 100,
+      idempotencyKey: secondKey,
+    });
+    expect(b.id).not.toBe(a.id);
+  });
+});
diff --git a/test/integration/send-money-precision.test.jsx b/test/integration/send-money-precision.test.jsx
index f5cf076..90e3775 100644
--- a/test/integration/send-money-precision.test.jsx
+++ b/test/integration/send-money-precision.test.jsx
@@ -26,6 +26,7 @@ describe('Send flow — amount parsing regressions', () => {
   beforeEach(() => {
     window.history.pushState({}, '', '/send');
     localStorage.clear();
+    sessionStorage.clear();
     // The mock wallet service rejects 10% of connections at random. Pin it so
     // the send flow is deterministic without standing up a live provider.
     vi.spyOn(Math, 'random').mockReturnValue(0.5);
diff --git a/test/unit/create-transfer-idempotency.test.js b/test/unit/create-transfer-idempotency.test.js
new file mode 100644
index 0000000..afbd01e
--- /dev/null
+++ b/test/unit/create-transfer-idempotency.test.js
@@ -0,0 +1,88 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { createTransfer, listTransfers } from '../../src/services/api.js';
+
+describe('createTransfer idempotency', () => {
+  beforeEach(() => {
+    localStorage.clear();
+    sessionStorage.clear();
+  });
+
+  it('returns the same transfer for a repeated idempotency key', async () => {
+    const payload = {
+      recipient: 'amina@example.com',
+      from: 'USD',
+      to: 'NGN',
+      sendAmount: 50,
+      receiveAmount: 75000,
+      fee: 1,
+      rate: 1500,
+      idempotencyKey: 'idem_test_repeat_1',
+    };
+    const first = await createTransfer(payload);
+    const second = await createTransfer(payload);
+    expect(second.id).toBe(first.id);
+    const all = await listTransfers();
+    expect(
+      all.filter((t) => t.idempotencyKey === 'idem_test_repeat_1'),
+    ).toHaveLength(1);
+  });
+
+  it('dedupes concurrent creates that share an idempotency key', async () => {
+    const payload = {
+      recipient: 'amina@example.com',
+      from: 'USD',
+      to: 'NGN',
+      sendAmount: 50,
+      receiveAmount: 75000,
+      fee: 1,
+      rate: 1500,
+      idempotencyKey: 'idem_concurrent_1',
+    };
+    const [a, b] = await Promise.all([
+      createTransfer(payload),
+      createTransfer(payload),
+    ]);
+    expect(a.id).toBe(b.id);
+    const all = await listTransfers();
+    expect(
+      all.filter((t) => t.idempotencyKey === 'idem_concurrent_1'),
+    ).toHaveLength(1);
+  });
+
+  it('rejects different payloads that reuse a key, even while the first is pending', async () => {
+    const payload = {
+      recipient: 'amina@example.com', from: 'USD', to: 'NGN',
+      sendAmount: 50, receiveAmount: 75000, fee: 1, rate: 1500,
+      idempotencyKey: 'idem_conflict',
+    };
+    const pending = createTransfer(payload);
+    await expect(createTransfer({ ...payload, sendAmount: 51 }))
+      .rejects.toMatchObject({ name: 'ContractViolationError' });
+    const original = await pending;
+    await expect(createTransfer({ ...payload, sendAmount: 51 }))
+      .rejects.toMatchObject({ name: 'ContractViolationError' });
+    const listed = await listTransfers();
+    expect(listed.filter((t) => t.idempotencyKey === payload.idempotencyKey))
+      .toHaveLength(1);
+    expect(original.sendAmount).toBe('50');
+  });
+
+  it('creates a new transfer when the idempotency key changes with the payload', async () => {
+    const base = {
+      recipient: 'amina@example.com',
+      from: 'USD',
+      to: 'NGN',
+      sendAmount: 50,
+      receiveAmount: 75000,
+      fee: 1,
+      rate: 1500,
+    };
+    const a = await createTransfer({ ...base, idempotencyKey: 'idem_a' });
+    const b = await createTransfer({
+      ...base,
+      sendAmount: 51,
+      idempotencyKey: 'idem_b',
+    });
+    expect(b.id).not.toBe(a.id);
+  });
+});
diff --git a/test/unit/transfer-intent.test.js b/test/unit/transfer-intent.test.js
new file mode 100644
index 0000000..6071512
--- /dev/null
+++ b/test/unit/transfer-intent.test.js
@@ -0,0 +1,117 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import {
+  fingerprintTransferPayload,
+  idempotencyKeyFor,
+  newTransferIntentNonce,
+  saveTransferOperation,
+  getTransferOperation,
+  getLatestRecoverableOperation,
+  clearTransferOperation,
+} from '../../src/utils/transferIntent.js';
+
+describe('transferIntent', () => {
+  beforeEach(() => {
+    sessionStorage.clear();
+  });
+
+  it('fingerprints the exact payload and changes when the payload changes', () => {
+    const base = {
+      recipient: 'amina@example.com',
+      from: 'USD',
+      to: 'NGN',
+      sendAmount: 100,
+      receiveAmount: 150000,
+      fee: 1,
+      rate: 1500,
+    };
+    const a = fingerprintTransferPayload(base);
+    const b = fingerprintTransferPayload({ ...base, sendAmount: 101 });
+    expect(a).not.toEqual(b);
+    expect(fingerprintTransferPayload(base)).toEqual(a);
+  });
+
+  it('keeps distinct integer amounts and full decimal precision', () => {
+    const base = {
+      recipient: 'amina@example.com', from: 'USD', to: 'NGN',
+      receiveAmount: 1500, fee: 1, rate: 1500,
+    };
+    const fingerprints = [1, 10, 100, '0.000000001'].map((sendAmount) =>
+      fingerprintTransferPayload({ ...base, sendAmount }),
+    );
+    expect(new Set(fingerprints).size).toBe(4);
+    expect(fingerprintTransferPayload({ ...base, sendAmount: '0.10' }))
+      .toBe(fingerprintTransferPayload({ ...base, sendAmount: 0.1 }));
+  });
+
+  it('derives a stable idempotency key for the same fingerprint', async () => {
+    const fp = 'usd|ngn|100';
+    const k1 = await idempotencyKeyFor(fp);
+    const k2 = await idempotencyKeyFor(fp);
+    expect(k1).toEqual(k2);
+    expect(k1.startsWith('idem_')).toBe(true);
+  });
+
+  it('uses a new key for a separate identical transfer intent', async () => {
+    const fingerprint = 'same recipient and amount';
+    const first = await idempotencyKeyFor(fingerprint, newTransferIntentNonce());
+    const second = await idempotencyKeyFor(fingerprint, newTransferIntentNonce());
+    expect(second).not.toBe(first);
+  });
+
+  it('persists only a safe operation reference across reads', () => {
+    saveTransferOperation({
+      idempotencyKey: 'idem_abc',
+      fingerprint: 'fp',
+      transferId: 'tx_1',
+      status: 'submitting',
+    });
+    expect(getTransferOperation('idem_abc')).toMatchObject({
+      idempotencyKey: 'idem_abc',
+      transferId: 'tx_1',
+      status: 'submitting',
+    });
+    expect(getLatestRecoverableOperation()?.idempotencyKey).toBe('idem_abc');
+    expect(getLatestRecoverableOperation('fp')?.idempotencyKey).toBe('idem_abc');
+    expect(getLatestRecoverableOperation('other')).toBeNull();
+    clearTransferOperation('idem_abc');
+    expect(getTransferOperation('idem_abc')).toBeNull();
+  });
+
+  it('treats a changed payload as a new intent requiring a new key', async () => {
+    const a = await idempotencyKeyFor(
+      fingerprintTransferPayload({
+        recipient: 'a@x.com',
+        from: 'USD',
+        to: 'NGN',
+        sendAmount: 10,
+        receiveAmount: 1000,
+      }),
+    );
+    const b = await idempotencyKeyFor(
+      fingerprintTransferPayload({
+        recipient: 'a@x.com',
+        from: 'USD',
+        to: 'NGN',
+        sendAmount: 11,
+        receiveAmount: 1100,
+      }),
+    );
+    expect(a).not.toEqual(b);
+  });
+
+  it('does not treat dismissed or failed ops as recoverable', () => {
+    saveTransferOperation({
+      idempotencyKey: 'idem_done',
+      fingerprint: 'fp',
+      transferId: 'tx_1',
+      status: 'dismissed',
+    });
+    expect(getLatestRecoverableOperation()).toBeNull();
+    saveTransferOperation({
+      idempotencyKey: 'idem_fail',
+      fingerprint: 'fp2',
+      status: 'failed',
+    });
+    expect(getLatestRecoverableOperation()).toBeNull();
+  });
+});