From bf9a8bbaf76f5360194823fc06077a9d4229f80a Mon Sep 17 00:00:00 2001
From: flarcos <onadekogbolahan@gmail.com>
Date: Sat, 12 Sep 2026 17:12:16 +0100
Subject: [PATCH 01/10] Add Soran names to payments and history

---
 @shared/api/internal.ts                       |  21 +
 @shared/api/types/message-request.ts          |  13 +
 @shared/api/types/soran.ts                    |  25 ++
 @shared/api/types/types.ts                    |   1 +
 @shared/constants/services.ts                 |   2 +
 extension/e2e-tests/accountHistory.test.ts    |   4 +-
 .../__tests__/soranPaymentNames.test.ts       | 139 ++++++
 .../handlers/soranPaymentNames.ts             |  89 ++++
 .../messageListener/popupMessageListener.ts   |  12 +
 extension/src/constants/localStorageTypes.ts  |   2 +
 .../useSubmitTxData.telemetry.test.tsx        | 102 ++++-
 .../hooks/useSubmitTxData.tsx                 |  70 ++++
 .../__tests__/SoranHistoryDisplay.test.tsx    | 116 ++++++
 .../accountHistory/HistoryItem/index.tsx      |  23 +
 .../accountHistory/HistoryItem/styles.scss    |   9 +
 .../TransactionDetail/index.tsx               |  58 ++-
 .../TransactionDetail/styles.scss             |  33 ++
 .../__tests__/HardwareSign.test.tsx           |  43 +-
 .../hardwareConnect/HardwareSign/index.tsx    |  27 ++
 .../SendAmount/hooks/useSimulateTxData.tsx    |  46 +-
 .../components/send/SendAmount/index.tsx      |  16 +-
 .../__tests__/useSendToData.soran.test.tsx    | 174 ++++++++
 .../send/SendTo/hooks/useSendToData.tsx       | 165 +++++---
 .../popup/components/send/SendTo/index.tsx    |  58 +--
 .../hooks/useSimulateTxData.ts                |  31 ++
 .../fixtures/soran-destinations.json          | 262 ++++++++++++
 .../src/popup/helpers/__tests__/soran.test.ts | 189 +++++++++
 .../helpers/__tests__/soranAdversary.test.tsx | 394 ++++++++++++++++++
 .../helpers/__tests__/soranHistory.test.ts    |  66 +++
 .../helpers/__tests__/soranPrimary.test.ts    | 217 ++++++++++
 .../__tests__/soranTransaction.test.ts        | 274 ++++++++++++
 extension/src/popup/helpers/soran.ts          | 261 ++++++++++++
 extension/src/popup/helpers/soranHistory.ts   |  38 ++
 extension/src/popup/helpers/soranPrimary.ts   | 217 ++++++++++
 .../src/popup/helpers/soranTransaction.ts     | 148 +++++++
 .../__tests__/useSoranHistoryName.test.tsx    | 100 +++++
 .../src/popup/hooks/useSoranHistoryName.ts    |  91 ++++
 .../src/popup/locales/en/translation.json     |  15 +
 .../src/popup/locales/pt/translation.json     |  15 +
 .../__tests__/useGetHistoryData.test.tsx      |  19 +
 .../hooks/useGetHistoryData.tsx               |   5 +-
 .../popup/views/__tests__/Account.test.tsx    |   2 +-
 42 files changed, 3475 insertions(+), 117 deletions(-)
 create mode 100644 @shared/api/types/soran.ts
 create mode 100644 extension/src/background/messageListener/handlers/__tests__/soranPaymentNames.test.ts
 create mode 100644 extension/src/background/messageListener/handlers/soranPaymentNames.ts
 create mode 100644 extension/src/popup/components/__tests__/SoranHistoryDisplay.test.tsx
 create mode 100644 extension/src/popup/components/send/SendTo/hooks/__tests__/useSendToData.soran.test.tsx
 create mode 100644 extension/src/popup/helpers/__tests__/fixtures/soran-destinations.json
 create mode 100644 extension/src/popup/helpers/__tests__/soran.test.ts
 create mode 100644 extension/src/popup/helpers/__tests__/soranAdversary.test.tsx
 create mode 100644 extension/src/popup/helpers/__tests__/soranHistory.test.ts
 create mode 100644 extension/src/popup/helpers/__tests__/soranPrimary.test.ts
 create mode 100644 extension/src/popup/helpers/__tests__/soranTransaction.test.ts
 create mode 100644 extension/src/popup/helpers/soran.ts
 create mode 100644 extension/src/popup/helpers/soranHistory.ts
 create mode 100644 extension/src/popup/helpers/soranPrimary.ts
 create mode 100644 extension/src/popup/helpers/soranTransaction.ts
 create mode 100644 extension/src/popup/hooks/__tests__/useSoranHistoryName.test.tsx
 create mode 100644 extension/src/popup/hooks/useSoranHistoryName.ts

diff --git a/@shared/api/internal.ts b/@shared/api/internal.ts
index d84f8b89ef..60ad7b6a9b 100644
--- a/@shared/api/internal.ts
+++ b/@shared/api/internal.ts
@@ -1,3 +1,4 @@
+import { SoranPaymentName, SoranPaymentReference } from "./types/soran";
 import { captureException } from "@sentry/browser";
 import {
   Address,
@@ -2875,3 +2876,23 @@ export const cacheSwapTopTokens = async (
     throw new Error(error);
   }
 };
+
+export const saveSoranPaymentName = (
+  activePublicKey: string,
+  payment: SoranPaymentName,
+): Promise<{ saved: boolean }> =>
+  sendMessageToBackground({
+    activePublicKey,
+    payment,
+    type: SERVICE_TYPES.SAVE_SORAN_PAYMENT_NAME,
+  });
+
+export const getSoranPaymentName = (
+  activePublicKey: string,
+  payment: SoranPaymentReference,
+): Promise<{ name: string | null }> =>
+  sendMessageToBackground({
+    activePublicKey,
+    payment,
+    type: SERVICE_TYPES.GET_SORAN_PAYMENT_NAME,
+  });
diff --git a/@shared/api/types/message-request.ts b/@shared/api/types/message-request.ts
index 53db55f049..4d321e5a84 100644
--- a/@shared/api/types/message-request.ts
+++ b/@shared/api/types/message-request.ts
@@ -1,3 +1,4 @@
+import { SoranPaymentName, SoranPaymentReference } from "./soran";
 import { Transaction } from "stellar-sdk";
 import browser from "webextension-polyfill";
 
@@ -261,6 +262,16 @@ export interface SignFreighterSorobanTransactionMessage extends BaseMessage {
   transactionXDR: string;
 }
 
+export interface SaveSoranPaymentNameMessage extends BaseMessage {
+  type: SERVICE_TYPES.SAVE_SORAN_PAYMENT_NAME;
+  payment: SoranPaymentName;
+}
+
+export interface GetSoranPaymentNameMessage extends BaseMessage {
+  type: SERVICE_TYPES.GET_SORAN_PAYMENT_NAME;
+  payment: SoranPaymentReference;
+}
+
 export interface AddRecentAddressMessage extends BaseMessage {
   type: SERVICE_TYPES.ADD_RECENT_ADDRESS;
   address: string;
@@ -543,6 +554,8 @@ export type ServiceMessageRequest =
   | RejectTransactionMessage
   | SignFreighterTransactionMessage
   | SignFreighterSorobanTransactionMessage
+  | SaveSoranPaymentNameMessage
+  | GetSoranPaymentNameMessage
   | AddRecentAddressMessage
   | LoadRecentAddressesMessage
   | LoadLastAccountUsedMessage
diff --git a/@shared/api/types/soran.ts b/@shared/api/types/soran.ts
new file mode 100644
index 0000000000..34b23c7a52
--- /dev/null
+++ b/@shared/api/types/soran.ts
@@ -0,0 +1,25 @@
+/** Local annotation of the exact route used by a successful Freighter send. */
+export interface SoranPaymentReference {
+  networkPassphrase: string;
+  transactionHash: string;
+  destination: string;
+  memo: string;
+  memoType: string;
+}
+
+export interface SoranPaymentName extends SoranPaymentReference {
+  name: string;
+}
+
+export const soranPaymentKey = (
+  publicKey: string,
+  payment: SoranPaymentReference,
+) =>
+  JSON.stringify([
+    publicKey,
+    payment.networkPassphrase,
+    payment.transactionHash,
+    payment.destination,
+    payment.memoType || "none",
+    payment.memo || "",
+  ]);
diff --git a/@shared/api/types/types.ts b/@shared/api/types/types.ts
index 9abb6aad50..17e17baa59 100644
--- a/@shared/api/types/types.ts
+++ b/@shared/api/types/types.ts
@@ -379,6 +379,7 @@ export type HorizonOperation = Horizon.ServerApi.OperationRecord & {
       [key: string]: any;
     };
   };
+  from_muxed?: string;
   to_muxed?: string;
   to?: string;
   from?: string;
diff --git a/@shared/constants/services.ts b/@shared/constants/services.ts
index 9c967543a3..76bdfad7e6 100644
--- a/@shared/constants/services.ts
+++ b/@shared/constants/services.ts
@@ -1,4 +1,6 @@
 export enum SERVICE_TYPES {
+  SAVE_SORAN_PAYMENT_NAME = "SAVE_SORAN_PAYMENT_NAME",
+  GET_SORAN_PAYMENT_NAME = "GET_SORAN_PAYMENT_NAME",
   CREATE_ACCOUNT = "CREATE_ACCOUNT",
   FUND_ACCOUNT = "FUND_ACCOUNT",
   ADD_ACCOUNT = "ADD_ACCOUNT",
diff --git a/extension/e2e-tests/accountHistory.test.ts b/extension/e2e-tests/accountHistory.test.ts
index e77865a36e..b37243fee9 100644
--- a/extension/e2e-tests/accountHistory.test.ts
+++ b/extension/e2e-tests/accountHistory.test.ts
@@ -436,7 +436,7 @@ test("History row displays muxed address extracted from XDR for payment", async
   await page.getByTestId("history-item").nth(0).click();
 
   // Verify muxed address is displayed (from to_muxed field in API response)
-  const dstAmount = page.getByTestId("KeyIdenticonKey");
+  const dstAmount = page.getByTestId("AssetDiff__to-from-address");
   await expect(dstAmount).toBeVisible({ timeout: 10000 });
   expect(await dstAmount.textContent()).toContain(TEST_M_ADDRESS.slice(0, 4));
 
@@ -618,7 +618,7 @@ test("History row displays regular G address when no muxed address in XDR", asyn
   await page.getByTestId("history-item").first().click();
 
   // Verify G address is displayed
-  const dstAmount = page.getByTestId("KeyIdenticonKey");
+  const dstAmount = page.getByTestId("AssetDiff__to-from-address");
   await expect(dstAmount).toBeVisible({ timeout: 10000 });
   expect(await dstAmount.textContent()).toContain(G_ADDRESS.slice(0, 4));
 
diff --git a/extension/src/background/messageListener/handlers/__tests__/soranPaymentNames.test.ts b/extension/src/background/messageListener/handlers/__tests__/soranPaymentNames.test.ts
new file mode 100644
index 0000000000..4ee0f9ef1c
--- /dev/null
+++ b/extension/src/background/messageListener/handlers/__tests__/soranPaymentNames.test.ts
@@ -0,0 +1,139 @@
+import { Networks, Keypair } from "stellar-sdk";
+import { SERVICE_TYPES } from "@shared/constants/services";
+import { SORAN_PAYMENT_NAMES } from "constants/localStorageTypes";
+import { dataStorageAccess } from "background/helpers/dataStorageAccess";
+import {
+  saveSoranPaymentName,
+  getSoranPaymentName,
+} from "../soranPaymentNames";
+
+const account = Keypair.random().publicKey();
+const destination = Keypair.random().publicKey();
+const payment = {
+  networkPassphrase: Networks.TESTNET,
+  transactionHash: "a".repeat(64),
+  destination,
+  memo: "hello",
+  memoType: "text",
+  name: "alice.nova",
+};
+const saveRequest = {
+  activePublicKey: account,
+  payment,
+  type: SERVICE_TYPES.SAVE_SORAN_PAYMENT_NAME as const,
+};
+const readRequest = {
+  activePublicKey: account,
+  payment,
+  type: SERVICE_TYPES.GET_SORAN_PAYMENT_NAME as const,
+};
+let data: Record<string, unknown>;
+let localStore: ReturnType<typeof dataStorageAccess>;
+beforeEach(() => {
+  data = {};
+  localStore = {
+    getItem: jest.fn(async (key) => data[key]),
+    setItem: jest.fn(async (key, value) => {
+      data[key] = value;
+    }),
+    remove: jest.fn(),
+    clear: jest.fn(),
+  };
+});
+it("saves the original name immutably and keeps accounts and complete routes separate", async () => {
+  expect(
+    await saveSoranPaymentName({ request: saveRequest, localStore }),
+  ).toEqual({ saved: true });
+  await saveSoranPaymentName({
+    request: { ...saveRequest, payment: { ...payment, name: "changed.nova" } },
+    localStore,
+  });
+  expect(
+    await getSoranPaymentName({ request: readRequest, localStore }),
+  ).toEqual({ name: "alice.nova" });
+  for (const change of [
+    { memo: "other" },
+    { memoType: "id" },
+    { transactionHash: "b".repeat(64) },
+    { destination: account },
+    { networkPassphrase: Networks.PUBLIC },
+  ]) {
+    expect(
+      await getSoranPaymentName({
+        request: { ...readRequest, payment: { ...payment, ...change } },
+        localStore,
+      }),
+    ).toEqual({ name: null });
+  }
+  expect(
+    await getSoranPaymentName({
+      request: { ...readRequest, activePublicKey: destination },
+      localStore,
+    }),
+  ).toEqual({ name: null });
+});
+it("normalizes the no-memo representation", async () => {
+  await saveSoranPaymentName({
+    request: {
+      ...saveRequest,
+      payment: { ...payment, memo: "", memoType: "" },
+    },
+    localStore,
+  });
+  expect(
+    await getSoranPaymentName({
+      request: {
+        ...readRequest,
+        payment: { ...payment, memo: "", memoType: "none" },
+      },
+      localStore,
+    }),
+  ).toEqual({ name: "alice.nova" });
+});
+it.each([
+  { name: "ALICE.NOVA" },
+  { name: "<script>.nova" },
+  { transactionHash: "bad" },
+  { destination: "bad" },
+  { memo: "x".repeat(129) },
+  { networkPassphrase: Networks.PUBLIC },
+])("rejects invalid annotations %#", async (change) => {
+  expect(
+    await saveSoranPaymentName({
+      request: { ...saveRequest, payment: { ...payment, ...change } },
+      localStore,
+    }),
+  ).toEqual({ saved: false });
+  expect(localStore.setItem).not.toHaveBeenCalled();
+});
+it("serializes concurrent writes and bounds retained history", async () => {
+  data[SORAN_PAYMENT_NAMES] = Array.from({ length: 1000 }, (_, i) => ({
+    key: `old-${i}`,
+    name: "old.nova",
+  }));
+  await Promise.all([
+    saveSoranPaymentName({ request: saveRequest, localStore }),
+    saveSoranPaymentName({
+      request: {
+        ...saveRequest,
+        payment: { ...payment, transactionHash: "b".repeat(64) },
+      },
+      localStore,
+    }),
+  ]);
+  expect(data[SORAN_PAYMENT_NAMES]).toHaveLength(1000);
+  expect((data[SORAN_PAYMENT_NAMES] as unknown[]).slice(-2)).toEqual([
+    expect.objectContaining({ name: "alice.nova" }),
+    expect.objectContaining({ name: "alice.nova" }),
+  ]);
+});
+it("contains storage failures without failing a successful payment", async () => {
+  jest.mocked(localStore.setItem).mockRejectedValue(new Error("disk error"));
+  expect(
+    await saveSoranPaymentName({ request: saveRequest, localStore }),
+  ).toEqual({ saved: false });
+  jest.mocked(localStore.getItem).mockRejectedValue(new Error("disk error"));
+  expect(
+    await getSoranPaymentName({ request: readRequest, localStore }),
+  ).toEqual({ name: null });
+});
diff --git a/extension/src/background/messageListener/handlers/soranPaymentNames.ts b/extension/src/background/messageListener/handlers/soranPaymentNames.ts
new file mode 100644
index 0000000000..494447e9d2
--- /dev/null
+++ b/extension/src/background/messageListener/handlers/soranPaymentNames.ts
@@ -0,0 +1,89 @@
+import { Networks, StrKey } from "stellar-sdk";
+import {
+  GetSoranPaymentNameMessage,
+  SaveSoranPaymentNameMessage,
+} from "@shared/api/types/message-request";
+import {
+  soranPaymentKey,
+  SoranPaymentReference,
+} from "@shared/api/types/soran";
+import { DataStorageAccess } from "background/helpers/dataStorageAccess";
+import { SORAN_PAYMENT_NAMES } from "constants/localStorageTypes";
+
+const MAX_RECORDS = 1000;
+const canonicalName =
+  /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+const validReference = (publicKey: unknown, payment: SoranPaymentReference) =>
+  typeof publicKey === "string" &&
+  StrKey.isValidEd25519PublicKey(publicKey) &&
+  payment &&
+  payment.networkPassphrase === Networks.TESTNET &&
+  typeof payment.transactionHash === "string" &&
+  /^[a-f0-9]{64}$/.test(payment.transactionHash) &&
+  typeof payment.destination === "string" &&
+  (StrKey.isValidEd25519PublicKey(payment.destination) ||
+    StrKey.isValidContract(payment.destination) ||
+    StrKey.isValidMed25519PublicKey(payment.destination)) &&
+  typeof payment.memo === "string" &&
+  payment.memo.length <= 128 &&
+  ["", "none", "text", "id", "hash", "return"].includes(payment.memoType);
+
+type StoredName = { key: string; name: string };
+// Serialize writes so concurrent confirmations cannot overwrite each other.
+let writes: Promise<unknown> = Promise.resolve();
+export const saveSoranPaymentName = ({
+  request,
+  localStore,
+}: {
+  request: SaveSoranPaymentNameMessage;
+  localStore: DataStorageAccess;
+}): Promise<{ saved: boolean }> => {
+  const result = writes.then(async () => {
+    try {
+      const { payment, activePublicKey } = request;
+      if (
+        !validReference(activePublicKey, payment) ||
+        typeof payment.name !== "string" ||
+        !canonicalName.test(payment.name)
+      )
+        return { saved: false };
+      const key = soranPaymentKey(activePublicKey!, payment);
+      const stored: StoredName[] =
+        (await localStore.getItem(SORAN_PAYMENT_NAMES)) || [];
+      // A historical annotation is immutable once saved.
+      if (!stored.some((item) => item.key === key)) {
+        await localStore.setItem(
+          SORAN_PAYMENT_NAMES,
+          [...stored, { key, name: payment.name }].slice(-MAX_RECORDS),
+        );
+      }
+      return { saved: true };
+    } catch {
+      return { saved: false };
+    }
+  });
+  writes = result;
+  return result;
+};
+
+export const getSoranPaymentName = async ({
+  request,
+  localStore,
+}: {
+  request: GetSoranPaymentNameMessage;
+  localStore: DataStorageAccess;
+}): Promise<{ name: string | null }> => {
+  try {
+    if (!validReference(request.activePublicKey, request.payment))
+      return { name: null };
+    const key = soranPaymentKey(request.activePublicKey!, request.payment);
+    const stored: StoredName[] =
+      (await localStore.getItem(SORAN_PAYMENT_NAMES)) || [];
+    const name = stored.find((item) => item.key === key)?.name;
+    return {
+      name: typeof name === "string" && canonicalName.test(name) ? name : null,
+    };
+  } catch {
+    return { name: null };
+  }
+};
diff --git a/extension/src/background/messageListener/popupMessageListener.ts b/extension/src/background/messageListener/popupMessageListener.ts
index 68a66236a0..5b1d3f60a4 100644
--- a/extension/src/background/messageListener/popupMessageListener.ts
+++ b/extension/src/background/messageListener/popupMessageListener.ts
@@ -1,3 +1,7 @@
+import {
+  saveSoranPaymentName,
+  getSoranPaymentName,
+} from "./handlers/soranPaymentNames";
 import browser from "webextension-polyfill";
 import { Store } from "redux";
 import {
@@ -417,6 +421,14 @@ export const popupMessageListener = (
         sessionStore,
       });
     }
+    case SERVICE_TYPES.SAVE_SORAN_PAYMENT_NAME:
+      if (!isFromExtensionPage && !isFromDevServer)
+        return { error: "Unauthorized" };
+      return saveSoranPaymentName({ request, localStore });
+    case SERVICE_TYPES.GET_SORAN_PAYMENT_NAME:
+      if (!isFromExtensionPage && !isFromDevServer)
+        return { error: "Unauthorized" };
+      return getSoranPaymentName({ request, localStore });
     case SERVICE_TYPES.ADD_RECENT_ADDRESS: {
       return addRecentAddress({
         request,
diff --git a/extension/src/constants/localStorageTypes.ts b/extension/src/constants/localStorageTypes.ts
index 3bca199400..7b4910d0f2 100644
--- a/extension/src/constants/localStorageTypes.ts
+++ b/extension/src/constants/localStorageTypes.ts
@@ -36,3 +36,5 @@ export const METRICS_USER_ID = "metrics_user_id";
 export const RECENT_PROTOCOLS = "recentProtocols";
 export const HAS_SEEN_DISCOVER_WELCOME = "hasSeenDiscoverWelcome";
 export const AUTO_LOCK_TIMEOUT_MINUTES_ID = "autoLockTimeoutMinutes";
+
+export const SORAN_PAYMENT_NAMES = "soranPaymentNames";
diff --git a/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/__tests__/useSubmitTxData.telemetry.test.tsx b/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/__tests__/useSubmitTxData.telemetry.test.tsx
index 8dffcf2a9f..7706272964 100644
--- a/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/__tests__/useSubmitTxData.telemetry.test.tsx
+++ b/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/__tests__/useSubmitTxData.telemetry.test.tsx
@@ -16,6 +16,7 @@ import {
 } from "@shared/constants/stellar";
 import { CUSTOM_NETWORK } from "@shared/helpers/stellar";
 import { ActionStatus } from "@shared/api/types";
+import * as Soran from "popup/helpers/soran";
 import * as ApiInternal from "@shared/api/internal";
 import { makeDummyStore } from "popup/__testHelpers__";
 import { initialState as txSubmissionInitialState } from "popup/ducks/transactionSubmission";
@@ -164,7 +165,10 @@ const makeState = ({
 const renderSubmitHook = (
   state: ReturnType<typeof makeState>,
   networkDetails: NetworkDetails = MAINNET_NETWORK_DETAILS,
-  { isHardwareWallet = false }: { isHardwareWallet?: boolean } = {},
+  {
+    isHardwareWallet = false,
+    transactionXdr = buildSwapXdr(),
+  }: { isHardwareWallet?: boolean; transactionXdr?: string } = {},
 ) => {
   const store = makeDummyStore(state);
   const wrapper = ({ children }: { children: React.ReactNode }) => (
@@ -176,7 +180,7 @@ const renderSubmitHook = (
         isHardwareWallet,
         networkDetails,
         publicKey: PUBLIC_KEY,
-        xdr: buildSwapXdr(),
+        xdr: transactionXdr,
       }),
     { wrapper },
   );
@@ -800,3 +804,97 @@ describe("useSubmitTxData terminal-event telemetry", () => {
     });
   });
 });
+
+describe("Soran payment revalidation", () => {
+  afterEach(() => jest.restoreAllMocks());
+
+  it.each([false, true])(
+    "blocks changed instructions before submission (hardware: %s)",
+    async (isHardwareWallet) => {
+      const state = makeState({ asset: "native" });
+      state.transactionSubmission.transactionData.federationAddress =
+        "alice.nova";
+      const verify = jest
+        .spyOn(Soran, "verifySoranDestination")
+        .mockRejectedValue(
+          new Error(
+            "Soran payment details changed. Select the recipient again.",
+          ),
+        );
+      const sign = jest.spyOn(ApiInternal, "signFreighterTransaction");
+      const submit = jest.spyOn(ApiInternal, "submitFreighterTransaction");
+      const { result, store } = renderSubmitHook(
+        state,
+        MAINNET_NETWORK_DETAILS,
+        { isHardwareWallet },
+      );
+      await act(async () => {
+        await result.current.fetchData({ isSwap: false });
+      });
+      expect(verify).toHaveBeenCalledWith(
+        "alice.nova",
+        {
+          address: DESTINATION,
+          memo: "",
+          memoType: "",
+        },
+        MAINNET_NETWORK_DETAILS,
+      );
+      expect(sign).not.toHaveBeenCalled();
+      expect(submit).not.toHaveBeenCalled();
+      expect(store.getState().transactionSubmission.submitStatus).toBe(
+        ActionStatus.ERROR,
+      );
+    },
+  );
+});
+
+describe("Soran successful-payment annotations", () => {
+  afterEach(() => jest.restoreAllMocks());
+  it.each([true, false])(
+    "records only successful sends (success: %s)",
+    async (success) => {
+      const payment = new TransactionBuilder(new Account(PUBLIC_KEY, "0"), {
+        fee: "100",
+        networkPassphrase: PASSPHRASE,
+      })
+        .addOperation(
+          Operation.payment({
+            destination: DESTINATION,
+            asset: Asset.native(),
+            amount: "100",
+          }),
+        )
+        .setTimeout(0)
+        .build();
+      const state = makeState({ asset: "native" });
+      state.transactionSubmission.transactionData.federationAddress =
+        "alice.nova";
+      jest.spyOn(Soran, "verifySoranDestination").mockResolvedValue(undefined);
+      jest
+        .spyOn(ApiInternal, "signFreighterTransaction")
+        .mockResolvedValue({ signedTransaction: payment.toXDR() });
+      const save = jest
+        .spyOn(ApiInternal, "saveSoranPaymentName")
+        .mockResolvedValue({ saved: true });
+      if (success) mockSubmitOk(buildResultXdr("880000000"));
+      else mockSubmitRejected({ status: 400, detail: "failed" });
+      const { result } = renderSubmitHook(state, MAINNET_NETWORK_DETAILS, {
+        transactionXdr: payment.toXDR(),
+      });
+      await act(async () => {
+        await result.current.fetchData({ isSwap: false });
+      });
+      if (success)
+        expect(save).toHaveBeenCalledWith(
+          PUBLIC_KEY,
+          expect.objectContaining({
+            name: "alice.nova",
+            destination: DESTINATION,
+            transactionHash: Buffer.from(payment.hash()).toString("hex"),
+          }),
+        );
+      else expect(save).not.toHaveBeenCalled();
+    },
+  );
+});
diff --git a/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/useSubmitTxData.tsx b/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/useSubmitTxData.tsx
index 102afe4284..12d6afc096 100644
--- a/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/useSubmitTxData.tsx
+++ b/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/useSubmitTxData.tsx
@@ -1,3 +1,5 @@
+import { assertSoranTransactionRoute } from "popup/helpers/soranTransaction";
+import { saveSoranPaymentName } from "@shared/api/internal";
 import { useReducer } from "react";
 import { useDispatch, useSelector } from "react-redux";
 import { captureException } from "@sentry/browser";
@@ -15,6 +17,7 @@ import {
 import { AccountBalances, useGetBalances } from "helpers/hooks/useGetBalances";
 import { useGetCollectibles } from "helpers/hooks/useGetCollectibles";
 import { NetworkDetails } from "@shared/constants/stellar";
+import { isSoranName, verifySoranDestination } from "popup/helpers/soran";
 import { emitMetric } from "helpers/metrics";
 import { METRIC_NAMES } from "popup/constants/metricsNames";
 import {
@@ -131,6 +134,8 @@ function useSubmitTxData({
       amount,
       destination,
       federationAddress,
+      memo,
+      memoType,
       destinationAsset,
       destinationAmount,
       isCollectible,
@@ -149,6 +154,58 @@ function useSubmitTxData({
         status: "success",
       } as SubmitTxData;
 
+      const isSoranPayment = !isSwap && isSoranName(federationAddress || "");
+      const expectedSoranRoute = {
+        address: destination,
+        memo: memo || "",
+        memoType: memoType || "",
+      };
+      const soranContext = {
+        publicKey,
+        asset,
+        isCollectible,
+        collectionAddress: collectibleData.collectionAddress,
+        tokenId: collectibleData.tokenId,
+      };
+      const validateSoranEnvelope = (envelope: string) => {
+        try {
+          return assertSoranTransactionRoute(
+            envelope,
+            expectedSoranRoute,
+            networkDetails,
+            soranContext,
+          );
+        } catch (error) {
+          reduxDispatch(
+            setSubmitError({ errorMessage: (error as Error).message }),
+          );
+          throw error;
+        }
+      };
+      if (isSoranPayment) {
+        try {
+          await verifySoranDestination(
+            federationAddress,
+            {
+              address: destination,
+              memo: memo || "",
+              memoType: memoType || "",
+            },
+            networkDetails,
+          );
+          validateSoranEnvelope(
+            isHardwareWallet
+              ? transactionSimulation.preparedTransaction || ""
+              : xdr,
+          );
+        } catch (error) {
+          reduxDispatch(
+            setSubmitError({ errorMessage: (error as Error).message }),
+          );
+          throw error;
+        }
+      }
+
       // Asset identities for the volume telemetry. Classified up front (the
       // price snapshot they feed starts after signing, below). Skipped
       // entirely for collectible sends (unpriced, out of scope) and for custom
@@ -318,6 +375,11 @@ function useSubmitTxData({
           })
         : null;
 
+      // Validate the signer/device output as well as the unsigned input. This
+      // is the exact envelope submitted and the source of the history reference.
+      const soranPaymentReference = isSoranPayment
+        ? validateSoranEnvelope(signedXDR)
+        : undefined;
       const submitResp = await reduxDispatch(
         submitFreighterTransaction({
           publicKey,
@@ -327,6 +389,14 @@ function useSubmitTxData({
       );
 
       if (submitFreighterTransaction.fulfilled.match(submitResp)) {
+        if (soranPaymentReference) {
+          // Recording a local label must never turn a confirmed payment into
+          // a failed send or prompt the user to submit it again.
+          void saveSoranPaymentName(publicKey, {
+            name: federationAddress!.trim().toLowerCase(),
+            ...soranPaymentReference,
+          }).catch(() => undefined);
+        }
         // NB: `transaction.submitted` is intentionally NOT emitted here. It is a
         // dApp *sign-and-submit* event, and the extension dApp API only
         // signs-and-returns (no submit path), so there's no conformant emit.
diff --git a/extension/src/popup/components/__tests__/SoranHistoryDisplay.test.tsx b/extension/src/popup/components/__tests__/SoranHistoryDisplay.test.tsx
new file mode 100644
index 0000000000..6a13dfc1b5
--- /dev/null
+++ b/extension/src/popup/components/__tests__/SoranHistoryDisplay.test.tsx
@@ -0,0 +1,116 @@
+import React from "react";
+import { render, screen } from "@testing-library/react";
+import { TESTNET_NETWORK_DETAILS } from "@shared/constants/stellar";
+import { HistoryItem } from "popup/components/accountHistory/HistoryItem";
+import { TransactionDetail } from "popup/components/accountHistory/TransactionDetail";
+import { useSoranHistoryName } from "popup/hooks/useSoranHistoryName";
+import type { OperationDataRow } from "popup/views/AccountHistory/hooks/useGetHistoryData";
+
+jest.mock("react-i18next", () => ({
+  useTranslation: () => ({
+    t: (key: string, options?: { name?: string }) =>
+      key.replace("{{name}}", options?.name || ""),
+    i18n: { resolvedLanguage: "en-GB" },
+  }),
+}));
+
+jest.mock("popup/hooks/useSoranHistoryName", () => ({
+  useSoranHistoryName: jest.fn(),
+}));
+const names = jest.mocked(useSoranHistoryName);
+const destination = "GBES5UHJYI445RV4XBGWHZOMBW4RYXBHOX47ZNZAJZAH2WP42ZEP2DYQ";
+const operation: OperationDataRow = {
+  id: "123",
+  action: "Sent",
+  actionIcon: "sent",
+  amount: "-10 XLM",
+  date: "Sep 12",
+  rowIcon: <span />,
+  rowText: "XLM",
+  metadata: {
+    isPayment: true,
+    isReceiving: false,
+    to: destination,
+    from: "sender",
+    destAssetCode: "XLM",
+    nonLabelAmount: "10",
+    createdAt: "2026-09-12T09:58:00Z",
+    feeCharged: "100",
+    memo: "hello",
+  },
+};
+beforeEach(() =>
+  names.mockReturnValue({
+    currentName: "current.nova",
+    usedName: "original.nova",
+  }),
+);
+it("labels a historical name separately while retaining the address and memo", () => {
+  render(
+    <TransactionDetail
+      activeOperation={operation}
+      networkDetails={TESTNET_NETWORK_DETAILS}
+    />,
+  );
+  expect(
+    screen.getByTestId("transaction-current-soran-name"),
+  ).toHaveTextContent("current.nova");
+  expect(screen.getByTestId("transaction-used-soran-name")).toHaveTextContent(
+    "original.nova",
+  );
+  expect(screen.getByText("Current account name")).toBeInTheDocument();
+  expect(screen.getByTestId("AssetDiff__to-from-address")).toHaveTextContent(
+    "GBES",
+  );
+  expect(screen.getByText("hello")).toBeInTheDocument();
+  expect(
+    screen.getByTestId("TransactionDetailModal__subtitle-date"),
+  ).not.toHaveTextContent("undefined");
+});
+it("shows only the current name for older payments", () => {
+  names.mockReturnValue({ currentName: "current.nova", usedName: undefined });
+  render(
+    <TransactionDetail
+      activeOperation={operation}
+      networkDetails={TESTNET_NETWORK_DETAILS}
+    />,
+  );
+  expect(
+    screen.getByTestId("transaction-current-soran-name"),
+  ).toBeInTheDocument();
+  expect(
+    screen.queryByTestId("transaction-used-soran-name"),
+  ).not.toBeInTheDocument();
+});
+it("renders the original name with explicit provenance in history rows", () => {
+  render(
+    <HistoryItem
+      operation={operation}
+      networkDetails={TESTNET_NETWORK_DETAILS}
+      publicKey="payer"
+      accountBalances={{} as never}
+      setActiveHistoryDetailId={() => undefined}
+    />,
+  );
+  expect(screen.getByTestId("history-item-soran-name")).toHaveTextContent(
+    "Sent using original.nova",
+  );
+});
+it("keeps address details usable without a name", () => {
+  names.mockReturnValue({ currentName: undefined, usedName: undefined });
+  render(
+    <TransactionDetail
+      activeOperation={operation}
+      networkDetails={TESTNET_NETWORK_DETAILS}
+    />,
+  );
+  expect(screen.getByTestId("AssetDiff__to-from-address")).toHaveTextContent(
+    "GBES",
+  );
+  expect(
+    screen.queryByTestId("transaction-current-soran-name"),
+  ).not.toBeInTheDocument();
+  expect(
+    screen.queryByTestId("transaction-used-soran-name"),
+  ).not.toBeInTheDocument();
+});
diff --git a/extension/src/popup/components/accountHistory/HistoryItem/index.tsx b/extension/src/popup/components/accountHistory/HistoryItem/index.tsx
index 7ad2a8ab30..319567d067 100644
--- a/extension/src/popup/components/accountHistory/HistoryItem/index.tsx
+++ b/extension/src/popup/components/accountHistory/HistoryItem/index.tsx
@@ -1,3 +1,5 @@
+import { useTranslation } from "react-i18next";
+import { useSoranHistoryName } from "popup/hooks/useSoranHistoryName";
 import React from "react";
 import { Icon, Text } from "@stellar/design-system";
 
@@ -70,8 +72,14 @@ interface HistoryItemProps {
 
 export const HistoryItem = ({
   operation,
+  networkDetails,
   setActiveHistoryDetailId,
 }: HistoryItemProps) => {
+  const { t } = useTranslation();
+  const { currentName, usedName } = useSoranHistoryName(
+    operation,
+    networkDetails,
+  );
   return (
     <div
       data-testid="history-item"
@@ -101,6 +109,21 @@ export const HistoryItem = ({
                 <ActionIcon actionType={operation.actionIcon} />
                 {operation.action}
               </Text>
+              {(usedName || currentName) && (
+                <div
+                  className="HistoryItem__soran-name"
+                  title={
+                    usedName
+                      ? t("Name used for this payment")
+                      : t("Current Soran name")
+                  }
+                  data-testid="history-item-soran-name"
+                >
+                  {usedName
+                    ? t("Sent using {{name}}", { name: usedName })
+                    : currentName}
+                </div>
+              )}
             </Text>
           </div>
           <div
diff --git a/extension/src/popup/components/accountHistory/HistoryItem/styles.scss b/extension/src/popup/components/accountHistory/HistoryItem/styles.scss
index 44a93be1cc..65f025d77f 100644
--- a/extension/src/popup/components/accountHistory/HistoryItem/styles.scss
+++ b/extension/src/popup/components/accountHistory/HistoryItem/styles.scss
@@ -3,7 +3,14 @@
 .HistoryItem {
   cursor: pointer;
 
+  &__soran-name {
+    font-size: pxToRem(12px);
+    color: var(--sds-clr-gray-11);
+    overflow-wrap: anywhere;
+  }
+
   &__row {
+    min-width: 0;
     width: 100%;
     display: flex;
     flex: 1;
@@ -18,6 +25,7 @@
   }
 
   &__description {
+    min-width: 0;
     flex: 1;
     color: var(--sds-clr-gray-12);
 
@@ -55,6 +63,7 @@
   }
 
   &__icon {
+    flex-shrink: 0;
     position: relative;
     display: flex;
     align-items: center;
diff --git a/extension/src/popup/components/accountHistory/TransactionDetail/index.tsx b/extension/src/popup/components/accountHistory/TransactionDetail/index.tsx
index c8d7b38d39..7c553ae200 100644
--- a/extension/src/popup/components/accountHistory/TransactionDetail/index.tsx
+++ b/extension/src/popup/components/accountHistory/TransactionDetail/index.tsx
@@ -1,3 +1,5 @@
+import { useSoranHistoryName } from "popup/hooks/useSoranHistoryName";
+import { formatHistoryTimestamp } from "popup/helpers/soranHistory";
 import React, { ReactNode } from "react";
 import { useTranslation } from "react-i18next";
 import { Button, Icon, Text } from "@stellar/design-system";
@@ -33,7 +35,11 @@ export const TransactionDetail = ({
   activeOperation: OperationDataRow | null;
   networkDetails: NetworkDetails;
 }) => {
-  const { t } = useTranslation();
+  const { t, i18n } = useTranslation();
+  const { currentName, usedName } = useSoranHistoryName(
+    activeOperation,
+    networkDetails,
+  );
   // Get memo disabled state using the helper
   // For history, we don't have contractId, so we pass undefined
   // The helper will still correctly disable memo for M addresses
@@ -57,22 +63,6 @@ export const TransactionDetail = ({
     return <></>;
   }
 
-  const createdAtDateInstance = new Date(
-    Date.parse(activeOperation.metadata.createdAt),
-  );
-  const createdAtLocalStrArr = createdAtDateInstance
-    .toLocaleString()
-    .split(" ");
-  const createdAtTime = `${createdAtLocalStrArr[1]
-    .split(":")
-    .slice(0, 2)
-    .join(":")} ${createdAtLocalStrArr[2]}`;
-  const createdAtDateStr = createdAtDateInstance
-    .toDateString()
-    .split(" ")
-    .slice(1)
-    .join(" ");
-
   const stellarExpertUrl = getStellarExpertUrl(networkDetails);
   const { feeCharged, memo } = activeOperation.metadata;
 
@@ -238,7 +228,24 @@ export const TransactionDetail = ({
               className="AssetDiff__value"
               data-testid="AssetDiff__to-from-address"
             >
-              <KeyIdenticon publicKey={toFromAddress} isSmall />
+              <div className="TransactionDetailModal__counterparty">
+                {currentName && (
+                  <>
+                    <div className="TransactionDetailModal__soran-caption">
+                      {toFromAddress.startsWith("G") && memo
+                        ? t("Current account name")
+                        : t("Current Soran name")}
+                    </div>
+                    <div
+                      className="TransactionDetailModal__soran-name"
+                      data-testid="transaction-current-soran-name"
+                    >
+                      {currentName}
+                    </div>
+                  </>
+                )}
+                <KeyIdenticon publicKey={toFromAddress} isSmall isCopyAllowed />
+              </div>
             </div>
           </div>
         )}
@@ -330,7 +337,10 @@ export const TransactionDetail = ({
                   className="TransactionDetailModal__subtitle-date"
                   data-testid="TransactionDetailModal__subtitle-date"
                 >
-                  {createdAtDateStr} &bull; {createdAtTime}
+                  {formatHistoryTimestamp(
+                    activeOperation.metadata.createdAt,
+                    i18n?.resolvedLanguage,
+                  )}
                 </div>
               </>
             </Text>
@@ -353,6 +363,16 @@ export const TransactionDetail = ({
       data-testid="TransactionDetailModal"
     >
       {renderBody(activeOperation)}
+      {usedName && (
+        <div
+          className="TransactionDetailModal__saved-name"
+          data-testid="transaction-used-soran-name"
+        >
+          <span>{t("Name used for this payment")}</span>
+          <strong>{usedName}</strong>
+          <span>{t("Saved on this device when you sent the payment.")}</span>
+        </div>
+      )}
       <div className="TransactionDetailModal__metadata">
         <div className="Metadata">
           <div className="Metadata__label">
diff --git a/extension/src/popup/components/accountHistory/TransactionDetail/styles.scss b/extension/src/popup/components/accountHistory/TransactionDetail/styles.scss
index 7a503938ec..fce79713c2 100644
--- a/extension/src/popup/components/accountHistory/TransactionDetail/styles.scss
+++ b/extension/src/popup/components/accountHistory/TransactionDetail/styles.scss
@@ -70,6 +70,39 @@
 }
 
 .TransactionDetailModal {
+  &__counterparty {
+    display: flex;
+    flex-direction: column;
+    align-items: flex-end;
+    gap: pxToRem(4px);
+    min-width: 0;
+  }
+
+  &__soran-name {
+    overflow-wrap: anywhere;
+  }
+  &__soran-caption {
+    font-size: pxToRem(12px);
+    color: var(--sds-clr-gray-11);
+  }
+
+  &__saved-name {
+    display: flex;
+    flex-direction: column;
+    gap: pxToRem(4px);
+    margin-top: pxToRem(12px);
+    padding: pxToRem(12px) pxToRem(16px);
+    background: var(--sds-clr-gray-03);
+    border-radius: pxToRem(16px);
+    overflow-wrap: anywhere;
+    font-size: pxToRem(12px);
+    color: var(--sds-clr-gray-11);
+    strong {
+      color: var(--sds-clr-gray-12);
+      font-weight: 500;
+    }
+  }
+
   width: 100%;
   height: auto;
   max-width: 53rem;
diff --git a/extension/src/popup/components/hardwareConnect/HardwareSign/__tests__/HardwareSign.test.tsx b/extension/src/popup/components/hardwareConnect/HardwareSign/__tests__/HardwareSign.test.tsx
index b11277f8e4..4e71d587ad 100644
--- a/extension/src/popup/components/hardwareConnect/HardwareSign/__tests__/HardwareSign.test.tsx
+++ b/extension/src/popup/components/hardwareConnect/HardwareSign/__tests__/HardwareSign.test.tsx
@@ -9,6 +9,7 @@ import {
   TransactionBuilder,
 } from "stellar-sdk";
 
+import * as Soran from "popup/helpers/soran";
 import { HardwareSign } from "popup/components/hardwareConnect/HardwareSign";
 import { Wrapper } from "popup/__testHelpers__";
 import { WalletType } from "@shared/constants/hardwareWallet";
@@ -399,7 +400,7 @@ describe("HardwareSign internal transaction telemetry", () => {
       .build()
       .toXDR();
 
-  const renderInternalTransaction = () =>
+  const renderInternalTransaction = (soranDestination?: string) =>
     render(
       <Wrapper
         routes={["/"]}
@@ -415,6 +416,12 @@ describe("HardwareSign internal transaction telemetry", () => {
           },
           transactionSubmission: {
             ...transactionSubmissionInitialState,
+            transactionData: {
+              ...transactionSubmissionInitialState.transactionData,
+              asset: "native",
+              destination: soranDestination || "",
+              federationAddress: soranDestination ? "alice.nova" : "",
+            },
             hardwareWalletData: {
               ...transactionSubmissionInitialState.hardwareWalletData,
               transactionXDR: buildTxXdr(),
@@ -434,6 +441,40 @@ describe("HardwareSign internal transaction telemetry", () => {
     mockHardwareSign.mockResolvedValue(Buffer.alloc(64, 7));
   });
 
+  it("blocks a mismatched Soran envelope before contacting the hardware device", async () => {
+    const verify = jest
+      .spyOn(Soran, "verifySoranDestination")
+      .mockResolvedValue(undefined);
+    try {
+      renderInternalTransaction(TEST_PUBLIC_KEY);
+      await waitFor(() =>
+        expect(
+          screen.getByText(
+            /Transaction does not match the Soran payment details/,
+          ),
+        ).toBeDefined(),
+      );
+      expect(verify).toHaveBeenCalled();
+      expect(mockGetWalletPublicKey).not.toHaveBeenCalled();
+      expect(mockHardwareSign).not.toHaveBeenCalled();
+    } finally {
+      verify.mockRestore();
+    }
+  });
+
+  it("allows a matching Soran envelope to reach the device", async () => {
+    const verify = jest
+      .spyOn(Soran, "verifySoranDestination")
+      .mockResolvedValue(undefined);
+    try {
+      renderInternalTransaction(OTHER_PUBLIC_KEY);
+      await waitFor(() => expect(mockHardwareSign).toHaveBeenCalled());
+      expect(verify).toHaveBeenCalled();
+    } finally {
+      verify.mockRestore();
+    }
+  });
+
   it("reports an internal approval with no origin once the device signs", async () => {
     renderInternalTransaction();
 
diff --git a/extension/src/popup/components/hardwareConnect/HardwareSign/index.tsx b/extension/src/popup/components/hardwareConnect/HardwareSign/index.tsx
index 3985211faf..84944702f3 100644
--- a/extension/src/popup/components/hardwareConnect/HardwareSign/index.tsx
+++ b/extension/src/popup/components/hardwareConnect/HardwareSign/index.tsx
@@ -1,3 +1,5 @@
+import { isSoranName, verifySoranDestination } from "popup/helpers/soran";
+import { assertSoranTransactionRoute } from "popup/helpers/soranTransaction";
 import React, { useState, useEffect, useRef } from "react";
 import { useDispatch, useSelector } from "react-redux";
 import { useTranslation } from "react-i18next";
@@ -72,6 +74,7 @@ export const HardwareSign = ({
     useSelector(settingsSelector);
   const {
     hardwareWalletData: { transactionXDR, shouldSubmit },
+    transactionData,
   } = useSelector(transactionSubmissionSelector);
   const bipPath = useSelector(bipPathSelector);
   const activePublicKey = useSelector(publicKeySelector);
@@ -157,6 +160,30 @@ export const HardwareSign = ({
     setIsDetecting(true);
     setConnectError("");
     try {
+      if (
+        isInternal &&
+        !isSignMessage &&
+        !isSignSorobanAuthorization &&
+        isSoranName(transactionData.federationAddress || "")
+      ) {
+        const expected = {
+          address: transactionData.destination,
+          memo: transactionData.memo || "",
+          memoType: transactionData.memoType || "",
+        };
+        await verifySoranDestination(
+          transactionData.federationAddress,
+          expected,
+          networkDetails,
+        );
+        assertSoranTransactionRoute(transactionXDR, expected, networkDetails, {
+          publicKey: activePublicKey,
+          asset: transactionData.asset,
+          isCollectible: transactionData.isCollectible,
+          collectionAddress: transactionData.collectibleData.collectionAddress,
+          tokenId: transactionData.collectibleData.tokenId,
+        });
+      }
       const publicKey = await getWalletPublicKey[walletType](bipPath);
 
       // A transaction signed by the wrong device fails on its own — the
diff --git a/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx b/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx
index e170051767..62df522e22 100644
--- a/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx
+++ b/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx
@@ -1,3 +1,7 @@
+import {
+  assertSoranTransactionRoute,
+  unsupportedSoranMuxed,
+} from "popup/helpers/soranTransaction";
 import { useReducer } from "react";
 import { splitCanonical } from "@shared/helpers/stellar";
 import { useTranslation } from "react-i18next";
@@ -18,6 +22,7 @@ import { emitMetric } from "helpers/metrics";
 import { scrubStrKeys } from "helpers/stellarStrKey";
 import { METRIC_NAMES } from "popup/constants/metricsNames";
 import { NetworkDetails } from "@shared/constants/stellar";
+import { isSoranName, verifySoranDestination } from "popup/helpers/soran";
 import {
   getNativeContractId,
   isNativeAssetId,
@@ -193,6 +198,7 @@ export const getOperation = (
   isSwap: boolean,
   isFunded: boolean,
   publicKey: string,
+  preserveMuxedDestination = false,
 ) => {
   // path payment or swap
   if (isPathPayment || isSwap) {
@@ -214,6 +220,7 @@ export const getOperation = (
   if (!isFunded && isNativeAsset(sourceAsset)) {
     let createAccountDestination = destination;
     if (isMuxedAccount(destination)) {
+      if (preserveMuxedDestination) throw unsupportedSoranMuxed();
       // encode muxed account to address
       createAccountDestination = extractBaseAddress(destination);
     }
@@ -249,6 +256,7 @@ const getBuiltTx = async (
   networkDetails: NetworkDetails,
   memo?: string,
   memoType?: string,
+  preserveMuxedDestination = false,
 ) => {
   const {
     sourceAsset,
@@ -280,6 +288,7 @@ const getBuiltTx = async (
       isSwap,
       isFunded,
       publicKey,
+      preserveMuxedDestination,
     );
     const transaction = new TransactionBuilder(sourceAccount, {
       fee: xlmToStroop(fee).toFixed(),
@@ -450,6 +459,25 @@ function useSimulateTxData({
       );
       const currentMemo = currentTransactionData.memo || memo;
       const currentMemoType = currentTransactionData.memoType || memoType;
+      const soranName = currentTransactionData.federationAddress || "";
+      const isSoranPayment = isSoranName(soranName);
+      if (isSoranPayment) {
+        await verifySoranDestination(
+          soranName,
+          {
+            address: destination,
+            memo: currentMemo || "",
+            memoType: currentMemoType || "",
+          },
+          networkDetails,
+        );
+        // The token transfer backend cannot preserve typed transaction memos.
+        if (simParams.type === "soroban" && currentMemo) {
+          throw new Error(
+            t("This token transfer cannot preserve the Soran memo"),
+          );
+        }
+      }
       const currentAmount = currentTransactionData.amount || amount;
       const currentAsset = currentTransactionData.asset || asset;
       const currentTransactionFee = getCurrentTransactionFee({
@@ -544,6 +572,7 @@ function useSimulateTxData({
             sorobanMemo = "";
           }
         } catch (error) {
+          if (isSoranPayment) throw error;
           // If we can't determine muxed destination, use original destination
           console.error("Error determining muxed destination:", error);
         }
@@ -598,7 +627,9 @@ function useSimulateTxData({
           memo: simParamsMemo,
         } = simParams;
         // Use memo from Redux state if simParams doesn't have one, otherwise use simParams memo
-        const memoToUse = simParamsMemo || currentMemo;
+        const memoToUse = isSoranPayment
+          ? currentMemo
+          : simParamsMemo || currentMemo;
         // Use currentTransactionFee (fresh from Redux) instead of simResponse.recommendedFee
         // For classic transactions, simResponse.recommendedFee is just the recommendedFee we passed in
         const feeToUse = currentTransactionFee || simResponse.recommendedFee;
@@ -621,6 +652,7 @@ function useSimulateTxData({
           networkDetails,
           memoToUse,
           currentMemoType,
+          isSoranPayment,
         );
         const xdr = transaction.build().toXdr();
         payload.transactionXdr = xdr;
@@ -642,6 +674,18 @@ function useSimulateTxData({
         });
       }
 
+      if (isSoranPayment) {
+        assertSoranTransactionRoute(
+          payload.transactionXdr,
+          {
+            address: destination,
+            memo: currentMemo || "",
+            memoType: currentMemoType || "",
+          },
+          networkDetails,
+          { publicKey, asset: currentAsset },
+        );
+      }
       dispatch({ type: "FETCH_DATA_SUCCESS", payload });
       return { ok: true, data: payload } as SimulateResult;
     } catch (error) {
diff --git a/extension/src/popup/components/send/SendAmount/index.tsx b/extension/src/popup/components/send/SendAmount/index.tsx
index 974477efee..4a91a35b0d 100644
--- a/extension/src/popup/components/send/SendAmount/index.tsx
+++ b/extension/src/popup/components/send/SendAmount/index.tsx
@@ -9,6 +9,7 @@ import { useTranslation } from "react-i18next";
 import { LoadingBackground } from "popup/basics/LoadingBackground";
 import { View } from "popup/basics/layout/View";
 import { METRIC_NAMES } from "popup/constants/metricsNames";
+import { isSoranName } from "popup/helpers/soran";
 import { AppDispatch } from "popup/App";
 import { isNativeAssetId } from "@shared/helpers/assetIdentity";
 import {
@@ -305,6 +306,12 @@ export const SendAmount = ({
 
   // Get memo disabled state using the helper
   const memoDisabledState = React.useMemo(() => {
+    if (isSoranName(federationAddress || "")) {
+      return {
+        isMemoDisabled: true,
+        memoDisabledMessage: t("The memo is set by the Soran name"),
+      };
+    }
     if (!destination) {
       return { isMemoDisabled: false, memoDisabledMessage: undefined };
     }
@@ -315,7 +322,14 @@ export const SendAmount = ({
       networkDetails,
       t,
     });
-  }, [destination, contractId, contractSupportsMuxed, networkDetails, t]);
+  }, [
+    destination,
+    contractId,
+    contractSupportsMuxed,
+    networkDetails,
+    federationAddress,
+    t,
+  ]);
 
   const { isMemoDisabled, memoDisabledMessage } = memoDisabledState;
 
diff --git a/extension/src/popup/components/send/SendTo/hooks/__tests__/useSendToData.soran.test.tsx b/extension/src/popup/components/send/SendTo/hooks/__tests__/useSendToData.soran.test.tsx
new file mode 100644
index 0000000000..fa35e8cdc9
--- /dev/null
+++ b/extension/src/popup/components/send/SendTo/hooks/__tests__/useSendToData.soran.test.tsx
@@ -0,0 +1,174 @@
+import { act, renderHook } from "@testing-library/react";
+import { Account, MuxedAccount, Federation } from "stellar-sdk";
+import { TESTNET_NETWORK_DETAILS } from "@shared/constants/stellar";
+import { getAddressFromInput, useSendToData } from "../useSendToData";
+import { resolveSoranName } from "popup/helpers/soran";
+import { FederationMemoType } from "popup/helpers/federationMemo";
+import { RequestState } from "constants/request";
+
+const mockFetchBalances = jest.fn().mockResolvedValue({ isFunded: true });
+jest.mock("helpers/hooks/useGetBalances", () => ({
+  useGetBalances: () => ({ fetchData: mockFetchBalances }),
+}));
+jest.mock("helpers/hooks/useGetAppData", () => ({
+  AppDataType: { RESOLVED: "resolved", REROUTE: "re-route" },
+  useGetAppData: () => ({
+    fetchData: async () => ({
+      type: "resolved",
+      account: {
+        publicKey: "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF",
+        applicationState: "APPLICATION_READY",
+      },
+      settings: {
+        networkDetails: require("@shared/constants/stellar")
+          .TESTNET_NETWORK_DETAILS,
+      },
+    }),
+  }),
+}));
+jest.mock("@shared/api/internal", () => ({
+  loadRecentAddresses: async () => ({ recentAddresses: ["alice.nova"] }),
+}));
+jest.mock("popup/helpers/account", () => ({
+  getBaseAccount: async (address: string) => address,
+}));
+jest.mock("popup/helpers/soroban", () => ({
+  isContractId: (address: string) => address.startsWith("C"),
+}));
+jest.mock("popup/helpers/soran", () => ({
+  ...jest.requireActual("popup/helpers/soran"),
+  resolveSoranName: jest.fn(),
+}));
+jest.mock("popup/helpers/localizationConfig", () => ({
+  __esModule: true,
+  default: { t: (key: string) => key },
+}));
+
+const G = "GBHKTFVBDUA6RYP5JM4SPZ76OXYAAHV4QHUOFV4S4TK342FMVGPHA2WN";
+const payment = {
+  name: "alice.nova",
+  address: G,
+  memo: "12345",
+  memoType: FederationMemoType.Id,
+};
+const resolve = jest.mocked(resolveSoranName);
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  resolve.mockResolvedValue(payment);
+});
+afterEach(() => jest.restoreAllMocks());
+
+it("carries the canonical name and typed memo into send data", async () => {
+  const result = await getAddressFromInput(
+    " Alice.Nova ",
+    TESTNET_NETWORK_DETAILS,
+  );
+  expect(result).toEqual({
+    validatedAddress: G,
+    fedAddress: "alice.nova",
+    federationMemo: "12345",
+    federationMemoType: "id",
+  });
+  expect(resolve).toHaveBeenCalledWith(" Alice.Nova ", TESTNET_NETWORK_DETAILS);
+});
+it("leaves literal addresses unchanged", async () => {
+  expect(await getAddressFromInput(G)).toEqual({
+    validatedAddress: G,
+    fedAddress: "",
+    federationMemo: "",
+    federationMemoType: "",
+  });
+  expect(resolve).not.toHaveBeenCalled();
+});
+it("keeps federation resolution working", async () => {
+  jest
+    .spyOn(Federation.Server, "resolve")
+    .mockResolvedValue({ account_id: G, memo: "12345", memo_type: "id" });
+  expect(await getAddressFromInput("alice*example.com")).toMatchObject({
+    validatedAddress: G,
+    fedAddress: "alice*example.com",
+    federationMemo: "12345",
+    federationMemoType: "id",
+  });
+  expect(resolve).not.toHaveBeenCalled();
+});
+it("surfaces lookup failure without fetching a fallback destination", async () => {
+  resolve.mockRejectedValue(new Error("Lookup unavailable"));
+  const { result } = renderHook(() => useSendToData());
+  await act(async () => {
+    await result.current.fetchData("alice.nova", {});
+  });
+  expect(result.current.state.state).toBe(RequestState.ERROR);
+  expect(mockFetchBalances).not.toHaveBeenCalled();
+});
+it("blocks a Soran self-send", async () => {
+  resolve.mockResolvedValue({
+    ...payment,
+    address: "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF",
+  });
+  const { result } = renderHook(() => useSendToData());
+  await act(async () => {
+    await result.current.fetchData("alice.nova", {});
+  });
+  expect(result.current.state.error).toEqual(
+    new Error("You cannot send to yourself"),
+  );
+  expect(mockFetchBalances).not.toHaveBeenCalled();
+});
+it("rejects collectible sends that cannot preserve a required memo", async () => {
+  const { result } = renderHook(() => useSendToData({ isCollectible: true }));
+  await act(async () => {
+    await result.current.fetchData("alice.nova", {});
+  });
+  expect(result.current.state.error).toEqual(
+    new Error("This token transfer cannot preserve the Soran memo"),
+  );
+  expect(mockFetchBalances).not.toHaveBeenCalled();
+});
+it("ignores an older lookup that completes after the next recipient", async () => {
+  let finishFirst!: (value: typeof payment) => void;
+  resolve.mockImplementationOnce(
+    () =>
+      new Promise((done) => {
+        finishFirst = done;
+      }),
+  );
+  const { result } = renderHook(() => useSendToData());
+  let first!: Promise<unknown>;
+  await act(async () => {
+    first = result.current.fetchData("alice.nova", {});
+  });
+  await act(async () => {
+    await result.current.fetchData(G, {});
+  });
+  await act(async () => {
+    finishFirst(payment);
+    await first;
+  });
+  expect(result.current.state.data).toMatchObject({
+    validatedAddress: G,
+    fedAddress: "",
+    federationMemo: "",
+  });
+});
+
+it("rejects collectible muxed destinations before balance loading", async () => {
+  resolve.mockResolvedValue({
+    ...payment,
+    address: new MuxedAccount(new Account(G, "0"), "42").accountId(),
+    memo: "",
+    memoType: "",
+  });
+  const { result } = renderHook(() => useSendToData({ isCollectible: true }));
+  await act(async () => {
+    await result.current.fetchData("alice.nova", {});
+  });
+  expect(result.current.state.state).toBe(RequestState.ERROR);
+  expect(result.current.state.error).toEqual(
+    new Error(
+      "This transfer cannot preserve the Soran muxed address. Choose another recipient.",
+    ),
+  );
+  expect(mockFetchBalances).not.toHaveBeenCalled();
+});
diff --git a/extension/src/popup/components/send/SendTo/hooks/useSendToData.tsx b/extension/src/popup/components/send/SendTo/hooks/useSendToData.tsx
index b2f210a291..09cde809a1 100644
--- a/extension/src/popup/components/send/SendTo/hooks/useSendToData.tsx
+++ b/extension/src/popup/components/send/SendTo/hooks/useSendToData.tsx
@@ -1,9 +1,10 @@
-import { useReducer } from "react";
+import { unsupportedSoranMuxed } from "popup/helpers/soranTransaction";
+import { useReducer, useRef } from "react";
 import { Federation, StrKey } from "stellar-sdk";
 import { FormikErrors } from "formik";
-import debounce from "lodash/debounce";
 import { captureException } from "@sentry/browser";
 import i18n from "popup/helpers/localizationConfig";
+import { isSoranName, resolveSoranName } from "popup/helpers/soran";
 import { FederationMemoType } from "popup/helpers/federationMemo";
 
 import { initialState, isError, reducer } from "helpers/request";
@@ -35,7 +36,22 @@ interface ResolvedSendToData {
 
 type SendToData = NeedsReRoute | ResolvedSendToData;
 
-export const getAddressFromInput = async (userInput: string) => {
+export const getAddressFromInput = async (
+  userInput: string,
+  networkDetails?: NetworkDetails,
+) => {
+  // The existing name/memo fields also carry canonical Soran payment instructions.
+  if (isSoranName(userInput)) {
+    if (!networkDetails)
+      throw new Error(i18n.t("Soran lookup requires a Soroban RPC URL"));
+    const result = await resolveSoranName(userInput, networkDetails);
+    return {
+      validatedAddress: result.address,
+      fedAddress: result.name,
+      federationMemo: result.memo,
+      federationMemoType: result.memoType,
+    };
+  }
   if (isFederationAddress(userInput)) {
     let fedResp;
     try {
@@ -73,7 +89,7 @@ export const getAddressFromInput = async (userInput: string) => {
   };
 };
 
-function useSendToData() {
+function useSendToData({ isCollectible = false } = {}) {
   const [state, dispatch] = useReducer(
     reducer<SendToData, unknown>,
     initialState,
@@ -84,71 +100,85 @@ function useSendToData() {
     includeIcons: false,
   });
 
-  const debouncedFetch = debounce(
-    async (
-      userInput: string,
-      publicKey: string,
-      applicationState: APPLICATION_STATE,
-      networkDetails: NetworkDetails,
-      _isMainnet: boolean,
-    ) => {
-      try {
-        const {
-          validatedAddress,
-          fedAddress,
-          federationMemo,
-          federationMemoType,
-        } = await getAddressFromInput(userInput);
-
-        // Block self-sends. isSameAccount resolves muxed (M...) addresses to
-        // their base (G...) account, so sending to one of your own muxed
-        // addresses is caught too - as is a federation address that resolves to
-        // your own account (validatedAddress is the resolved G... here).
-        if (isSameAccount(validatedAddress, publicKey)) {
-          throw new Error(i18n.t("You cannot send to yourself"));
-        }
+  const requestIdRef = useRef(0);
+  const resolveInput = async (
+    requestId: number,
+    userInput: string,
+    publicKey: string,
+    applicationState: APPLICATION_STATE,
+    networkDetails: NetworkDetails,
+    _isMainnet: boolean,
+  ) => {
+    try {
+      const {
+        validatedAddress,
+        fedAddress,
+        federationMemo,
+        federationMemoType,
+      } = await getAddressFromInput(userInput, networkDetails);
+
+      if (
+        isCollectible &&
+        isSoranName(userInput) &&
+        StrKey.isValidMed25519PublicKey(validatedAddress)
+      ) {
+        throw unsupportedSoranMuxed();
+      }
+      if (isCollectible && isSoranName(userInput) && federationMemo) {
+        throw new Error(
+          i18n.t("This token transfer cannot preserve the Soran memo"),
+        );
+      }
+
+      // Block self-sends. isSameAccount resolves muxed (M...) addresses to
+      // their base (G...) account, so sending to one of your own muxed
+      // addresses is caught too - as is a federation address that resolves to
+      // your own account (validatedAddress is the resolved G... here).
+      if (isSameAccount(validatedAddress, publicKey)) {
+        throw new Error(i18n.t("You cannot send to yourself"));
+      }
+
+      const { recentAddresses } = await loadRecentAddresses({
+        activePublicKey: publicKey,
+      });
+
+      const payload = {
+        type: AppDataType.RESOLVED,
+        recentAddresses,
+        validatedAddress,
+        fedAddress,
+        federationMemo,
+        federationMemoType,
+        applicationState,
+        publicKey,
+        networkDetails,
+      } as ResolvedSendToData;
 
-        const { recentAddresses } = await loadRecentAddresses({
-          activePublicKey: publicKey,
-        });
-
-        const payload = {
-          type: AppDataType.RESOLVED,
-          recentAddresses,
-          validatedAddress,
-          fedAddress,
-          federationMemo,
-          federationMemoType,
-          applicationState,
-          publicKey,
+      let destinationAccount = await getBaseAccount(validatedAddress);
+      if (destinationAccount && !isContractId(destinationAccount)) {
+        const destinationBalances = await fetchBalances(
+          destinationAccount,
+          _isMainnet,
           networkDetails,
-        } as ResolvedSendToData;
-
-        let destinationAccount = await getBaseAccount(validatedAddress);
-        if (destinationAccount && !isContractId(destinationAccount)) {
-          const destinationBalances = await fetchBalances(
-            destinationAccount,
-            _isMainnet,
-            networkDetails,
-            true,
-            true,
-          );
-          if (isError<AccountBalances>(destinationBalances)) {
-            throw new Error(destinationBalances.message);
-          }
-
-          payload.destinationBalances = destinationBalances;
+          true,
+          true,
+        );
+        if (isError<AccountBalances>(destinationBalances)) {
+          throw new Error(destinationBalances.message);
         }
 
+        payload.destinationBalances = destinationBalances;
+      }
+
+      if (requestId === requestIdRef.current)
         dispatch({ type: "FETCH_DATA_SUCCESS", payload });
-        return payload;
-      } catch (error) {
+      return payload;
+    } catch (error) {
+      if (requestId === requestIdRef.current)
         dispatch({ type: "FETCH_DATA_ERROR", payload: error });
-        return error;
-      }
-    },
-    0,
-  );
+      return error;
+    }
+  };
 
   const fetchData = async (
     userInput: string,
@@ -156,8 +186,10 @@ function useSendToData() {
       destination: string;
     }>,
   ) => {
+    const requestId = ++requestIdRef.current;
     dispatch({ type: "FETCH_DATA_START" });
     const appData = await fetchAppData(true);
+    if (requestId !== requestIdRef.current) return;
     if (isError(appData)) {
       throw new Error(appData.message);
     }
@@ -188,7 +220,8 @@ function useSendToData() {
     }
 
     if (userInput) {
-      return debouncedFetch(
+      return resolveInput(
+        requestId,
         userInput,
         publicKey,
         applicationState,
@@ -211,7 +244,9 @@ function useSendToData() {
       publicKey,
       networkDetails,
     } as ResolvedSendToData;
-    dispatch({ type: "FETCH_DATA_SUCCESS", payload });
+    if (requestId === requestIdRef.current) {
+      dispatch({ type: "FETCH_DATA_SUCCESS", payload });
+    }
     return payload;
   };
 
diff --git a/extension/src/popup/components/send/SendTo/index.tsx b/extension/src/popup/components/send/SendTo/index.tsx
index 6f3acad19c..ea6d536359 100644
--- a/extension/src/popup/components/send/SendTo/index.tsx
+++ b/extension/src/popup/components/send/SendTo/index.tsx
@@ -41,10 +41,11 @@ import {
   saveRecipientName,
   transactionDataSelector,
 } from "popup/ducks/transactionSubmission";
+import { isSoranName, normalizeSoranName } from "popup/helpers/soran";
 import type { FederationMemoType } from "popup/helpers/federationMemo";
 
 import { RequestState } from "constants/request";
-import { useSendToData, getAddressFromInput } from "./hooks/useSendToData";
+import { useSendToData } from "./hooks/useSendToData";
 
 import { openTab } from "popup/helpers/navigate";
 import { newTabHref } from "helpers/urls";
@@ -134,7 +135,7 @@ export const SendTo = ({
   );
   const allAccounts = useSelector(allAccountsSelector);
   const activePublicKey = useSelector(publicKeySelector);
-  const { state: sendDataState, fetchData } = useSendToData();
+  const { state: sendDataState, fetchData } = useSendToData({ isCollectible });
   const [debouncedDestination, setDebouncedDestination] = useState(
     federationAddress || destination || "",
   );
@@ -177,7 +178,8 @@ export const SendTo = ({
     onSubmit: () => {
       if (
         sendDataState.state === RequestState.SUCCESS &&
-        sendDataState.data.type === AppDataType.RESOLVED
+        sendDataState.data.type === AppDataType.RESOLVED &&
+        isCurrentResolution
       ) {
         handleContinue(
           sendDataState.data.validatedAddress,
@@ -193,7 +195,8 @@ export const SendTo = ({
     validate: (values) => {
       if (
         isValidPublicKey(values.destination) ||
-        isContractId(values.destination)
+        isContractId(values.destination) ||
+        isSoranName(values.destination)
       ) {
         return {};
       }
@@ -239,6 +242,15 @@ export const SendTo = ({
     ? sendDataState.data
     : null;
 
+  const isCurrentResolution = Boolean(
+    resolvedSendData &&
+    !isLoading &&
+    isSearchSettled &&
+    (resolvedSendData.fedAddress || resolvedSendData.validatedAddress) ===
+      (normalizeSoranName(formik.values.destination) ||
+        formik.values.destination),
+  );
+
   // Track whether any successful fetch has completed (used for initial spinner).
   const hasLoadedOnceRef = useRef(false);
   if (resolvedSendData) {
@@ -299,7 +311,7 @@ export const SendTo = ({
             autoComplete="off"
             id="destination-input"
             name="destination"
-            placeholder={t("Enter address")}
+            placeholder={t("Enter address or Soran name")}
             onChange={formik.handleChange}
             value={formik.values.destination}
             leftElement={<Icon.UserCircle />}
@@ -321,7 +333,7 @@ export const SendTo = ({
             debouncedDestination !== "" &&
             isSearchSettled && (
               <div>
-                {formik.isValid && resolvedSendData ? (
+                {formik.isValid && resolvedSendData && isCurrentResolution ? (
                   <>
                     {shouldShowAccountDoesntExistWarning({
                       assetCanonical: asset,
@@ -355,6 +367,8 @@ export const SendTo = ({
                         />
                       </div>
                       <span>
+                        {isSoranName(resolvedSendData.fedAddress) &&
+                          `${resolvedSendData.fedAddress} · `}
                         {truncatedPublicKey(resolvedSendData.validatedAddress)}
                       </span>
                     </button>
@@ -380,30 +394,26 @@ export const SendTo = ({
                     type="button"
                     data-testid="recent-address-button"
                     onClick={async () => {
-                      const addressFromInput =
-                        await getAddressFromInput(address);
-                      // A recent that resolves to the active account (e.g. a
-                      // federation address the synchronous list filter can't
-                      // resolve) is a self-send. Don't continue - surface the
-                      // error through the normal input flow instead.
+                      // Re-enter the normal resolution flow, including errors and network checks.
+                      if (isSoranName(address)) {
+                        formik.setFieldValue("destination", address);
+                        return;
+                      }
+                      const result = await fetchData(address, {});
                       if (
-                        isSameAccount(
-                          addressFromInput.validatedAddress,
-                          activePublicKey,
-                        )
+                        !isResolvedSuggestionData(result) ||
+                        isSameAccount(result.validatedAddress, activePublicKey)
                       ) {
                         formik.setFieldValue("destination", address);
                         return;
                       }
                       emitMetric(METRIC_NAMES.paymentRecipientRecentSelected);
-                      await fetchData(address, {});
                       handleContinue(
-                        addressFromInput.validatedAddress,
-                        addressFromInput.fedAddress,
+                        result.validatedAddress,
+                        result.fedAddress,
                         {
-                          federationMemo: addressFromInput.federationMemo,
-                          federationMemoType:
-                            addressFromInput.federationMemoType,
+                          federationMemo: result.federationMemo,
+                          federationMemoType: result.federationMemoType,
                         },
                       );
                     }}
@@ -413,7 +423,7 @@ export const SendTo = ({
                       <IdenticonImg publicKey={address} />
                     </div>
                     <span>
-                      {isFederationAddress(address)
+                      {isFederationAddress(address) || isSoranName(address)
                         ? address
                         : truncatedPublicKey(address)}
                     </span>
@@ -463,7 +473,7 @@ export const SendTo = ({
       <View.Footer>
         {!isLoading &&
         !hasError &&
-        isSearchSettled &&
+        isCurrentResolution &&
         formik.values.destination &&
         formik.isValid ? (
           <Button
diff --git a/extension/src/popup/components/sendCollectible/SelectedCollectible/hooks/useSimulateTxData.ts b/extension/src/popup/components/sendCollectible/SelectedCollectible/hooks/useSimulateTxData.ts
index 66ddba402a..f3ac4e335b 100644
--- a/extension/src/popup/components/sendCollectible/SelectedCollectible/hooks/useSimulateTxData.ts
+++ b/extension/src/popup/components/sendCollectible/SelectedCollectible/hooks/useSimulateTxData.ts
@@ -1,3 +1,9 @@
+import {
+  assertSoranTransactionRoute,
+  unsupportedSoranMuxed,
+} from "popup/helpers/soranTransaction";
+import { isSoranName, verifySoranDestination } from "popup/helpers/soran";
+import { StrKey } from "stellar-sdk";
 import { useReducer } from "react";
 import { useDispatch, useSelector, useStore } from "react-redux";
 import BigNumber from "bignumber.js";
@@ -107,6 +113,17 @@ function useSimulateTxData({
       const currentTransactionData = transactionDataSelector(
         store.getState() as AppState,
       );
+      const soranName = currentTransactionData.federationAddress || "";
+      const isSoranPayment = isSoranName(soranName);
+      if (isSoranPayment) {
+        if (StrKey.isValidMed25519PublicKey(destination))
+          throw unsupportedSoranMuxed();
+        await verifySoranDestination(
+          soranName,
+          { address: destination, memo: "", memoType: "" },
+          networkDetails,
+        );
+      }
       const currentTransactionFee = getCurrentTransactionFee({
         currentTransactionFee: currentTransactionData.transactionFee,
         fallbackTransactionFee: transactionFee,
@@ -168,6 +185,20 @@ function useSimulateTxData({
         networkDetails,
       );
 
+      if (isSoranPayment) {
+        assertSoranTransactionRoute(
+          payload.transactionXdr,
+          { address: destination, memo: "", memoType: "" },
+          networkDetails,
+          {
+            publicKey,
+            asset: currentTransactionData.asset,
+            isCollectible: true,
+            collectionAddress: collectibleData.collectionAddress,
+            tokenId: collectibleData.tokenId,
+          },
+        );
+      }
       dispatch({ type: "FETCH_DATA_SUCCESS", payload });
       return { ok: true, data: payload } as SimulateResult;
     } catch (error) {
diff --git a/extension/src/popup/helpers/__tests__/fixtures/soran-destinations.json b/extension/src/popup/helpers/__tests__/fixtures/soran-destinations.json
new file mode 100644
index 0000000000..ebafa5c6de
--- /dev/null
+++ b/extension/src/popup/helpers/__tests__/fixtures/soran-destinations.json
@@ -0,0 +1,262 @@
+{
+  "source": "https://docs.soran.domains/reference/vectors/lookup-returns-v1.json",
+  "valid": [
+    {
+      "id": "direct-g-none",
+      "returnType": "PaymentDestination",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAQAAAA8AAAAETm9uZQ==",
+      "expectedDestination": {
+        "address": "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF",
+        "memo": "",
+        "memoType": ""
+      }
+    },
+    {
+      "id": "direct-g-id-zero",
+      "returnType": "PaymentDestination",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAgAAAA8AAAACSWQAAAAAAAUAAAAAAAAAAA==",
+      "expectedDestination": {
+        "address": "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF",
+        "memo": "0",
+        "memoType": "id"
+      }
+    },
+    {
+      "id": "direct-g-id-77",
+      "returnType": "PaymentDestination",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAgAAAA8AAAACSWQAAAAAAAUAAAAAAAAATQ==",
+      "expectedDestination": {
+        "address": "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF",
+        "memo": "77",
+        "memoType": "id"
+      }
+    },
+    {
+      "id": "direct-g-id-max",
+      "returnType": "PaymentDestination",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAgAAAA8AAAACSWQAAAAAAAX//////////w==",
+      "expectedDestination": {
+        "address": "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF",
+        "memo": "18446744073709551615",
+        "memoType": "id"
+      }
+    },
+    {
+      "id": "direct-g-text",
+      "returnType": "PaymentDestination",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAgAAAA8AAAAEVGV4dAAAAA4AAAAKaW52b2ljZS03NwAA",
+      "expectedDestination": {
+        "address": "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF",
+        "memo": "invoice-77",
+        "memoType": "text"
+      }
+    },
+    {
+      "id": "direct-g-text-utf8-boundary",
+      "returnType": "PaymentDestination",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAgAAAA8AAAAEVGV4dAAAAA4AAAAc8J+YgPCfmIDwn5iA8J+YgPCfmIDwn5iA8J+YgA==",
+      "expectedDestination": {
+        "address": "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF",
+        "memo": "😀😀😀😀😀😀😀",
+        "memoType": "text"
+      }
+    },
+    {
+      "id": "direct-g-text-leading-bom",
+      "returnType": "PaymentDestination",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAgAAAA8AAAAEVGV4dAAAAA4AAAAH77u/bWVtbwA=",
+      "expectedDestination": {
+        "address": "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF",
+        "memo": "memo",
+        "memoType": "text"
+      }
+    },
+    {
+      "id": "direct-g-hash",
+      "returnType": "PaymentDestination",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAgAAAA8AAAAESGFzaAAAAA0AAAAgAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=",
+      "expectedDestination": {
+        "address": "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF",
+        "memo": "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=",
+        "memoType": "hash"
+      }
+    },
+    {
+      "id": "direct-c-none",
+      "returnType": "PaymentDestination",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAeTogbACVb7Sujx9sTA+Z1uESOygZh8SGNCzvHzpGhx4AAAADwAAAARtZW1vAAAAEAAAAAEAAAABAAAADwAAAAROb25l",
+      "expectedDestination": {
+        "address": "CDSORANQAJK35UV2HR63CMB6M5NYISHMUBTB6EQY2CZ3Y7HJDIOHRJWA",
+        "memo": "",
+        "memoType": ""
+      }
+    },
+    {
+      "id": "muxed-0",
+      "returnType": "PaymentDestination",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAVNdXhlZAAAAAAAABEAAAABAAAAAgAAAA8AAAAHYWNjb3VudAAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAACaWQAAAAAAAUAAAAAAAAAAA==",
+      "expectedMuxed": {
+        "account": "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF",
+        "id": "0"
+      }
+    },
+    {
+      "id": "muxed-420",
+      "returnType": "PaymentDestination",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAVNdXhlZAAAAAAAABEAAAABAAAAAgAAAA8AAAAHYWNjb3VudAAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAACaWQAAAAAAAUAAAAAAAABpA==",
+      "expectedMuxed": {
+        "account": "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF",
+        "id": "420"
+      }
+    },
+    {
+      "id": "muxed-18446744073709551615",
+      "returnType": "PaymentDestination",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAVNdXhlZAAAAAAAABEAAAABAAAAAgAAAA8AAAAHYWNjb3VudAAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAACaWQAAAAAAAX//////////w==",
+      "expectedMuxed": {
+        "account": "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF",
+        "id": "18446744073709551615"
+      }
+    }
+  ],
+  "invalid": [
+    {
+      "id": "missing-destination",
+      "returnType": "PaymentDestination",
+      "reason": "Void is not a payment instruction",
+      "xdrBase64": "AAAAAQ=="
+    },
+    {
+      "id": "unknown-destination",
+      "returnType": "PaymentDestination",
+      "reason": "Unknown enum tag",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAVPdGhlcgAAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAQAAAA8AAAAETm9uZQ=="
+    },
+    {
+      "id": "string-tag",
+      "returnType": "PaymentDestination",
+      "reason": "Variant tag must be an XDR Symbol",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADgAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAQAAAA8AAAAETm9uZQ=="
+    },
+    {
+      "id": "missing-payload",
+      "returnType": "PaymentDestination",
+      "reason": "Direct needs one payload",
+      "xdrBase64": "AAAAEAAAAAEAAAABAAAADwAAAAZEaXJlY3QAAA=="
+    },
+    {
+      "id": "extra-payload",
+      "returnType": "PaymentDestination",
+      "reason": "Direct cannot have extra values",
+      "xdrBase64": "AAAAEAAAAAEAAAADAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAQAAAA8AAAAETm9uZQAAAAMAAAAA"
+    },
+    {
+      "id": "void-memo",
+      "returnType": "PaymentDestination",
+      "reason": "Void is not explicit Memo::None",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAAAE="
+    },
+    {
+      "id": "none-with-value",
+      "returnType": "PaymentDestination",
+      "reason": "None cannot carry a value",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAgAAAA8AAAAETm9uZQAAAAMAAAAA"
+    },
+    {
+      "id": "id-u32",
+      "returnType": "PaymentDestination",
+      "reason": "Id must use u64 even for small values",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAgAAAA8AAAACSWQAAAAAAAMAAABN"
+    },
+    {
+      "id": "id-negative",
+      "returnType": "PaymentDestination",
+      "reason": "Negative IDs are invalid",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAgAAAA8AAAACSWQAAAAAAAb//////////w=="
+    },
+    {
+      "id": "text-empty",
+      "returnType": "PaymentDestination",
+      "reason": "Text must contain at least one byte",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAgAAAA8AAAAEVGV4dAAAAA4AAAAA"
+    },
+    {
+      "id": "text-too-long",
+      "returnType": "PaymentDestination",
+      "reason": "Text exceeds 28 UTF-8 bytes",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAgAAAA8AAAAEVGV4dAAAAA4AAAAg8J+YgPCfmIDwn5iA8J+YgPCfmIDwn5iA8J+YgPCfmIA="
+    },
+    {
+      "id": "text-invalid-utf8",
+      "returnType": "PaymentDestination",
+      "reason": "Text must be valid UTF-8",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAgAAAA8AAAAEVGV4dAAAAA4AAAAB/wAAAA=="
+    },
+    {
+      "id": "hash-too-short",
+      "returnType": "PaymentDestination",
+      "reason": "Hash must contain 32 bytes",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAgAAAA8AAAAESGFzaAAAAA0AAAAfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
+    },
+    {
+      "id": "contract-with-memo",
+      "returnType": "PaymentDestination",
+      "reason": "C destinations support None only",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAeTogbACVb7Sujx9sTA+Z1uESOygZh8SGNCzvHzpGhx4AAAADwAAAARtZW1vAAAAEAAAAAEAAAACAAAADwAAAAJJZAAAAAAABQAAAAAAAABN"
+    },
+    {
+      "id": "string-address",
+      "returnType": "PaymentDestination",
+      "reason": "Address must use XDR Address, not an address-shaped string",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAAOAAAAOEdBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBV0hGAAAADwAAAARtZW1vAAAAEAAAAAEAAAABAAAADwAAAAROb25l"
+    },
+    {
+      "id": "extra-field",
+      "returnType": "PaymentDestination",
+      "reason": "Direct requires exactly address and memo",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAwAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAFZXh0cmEAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAQAAAA8AAAAETm9uZQ=="
+    },
+    {
+      "id": "duplicate-field",
+      "returnType": "PaymentDestination",
+      "reason": "Duplicate field names are invalid",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAwAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAQAAAA8AAAAETm9uZQ=="
+    },
+    {
+      "id": "unordered-fields",
+      "returnType": "PaymentDestination",
+      "reason": "Field-symbol map must use canonical order",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAEbWVtbwAAABAAAAABAAAAAQAAAA8AAAAETm9uZQAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="
+    },
+    {
+      "id": "string-field-key",
+      "returnType": "PaymentDestination",
+      "reason": "Field key must be an XDR Symbol",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA4AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAQAAAA8AAAAETm9uZQ=="
+    },
+    {
+      "id": "muxed-contract-base",
+      "returnType": "PaymentDestination",
+      "reason": "Muxed base must be a G account",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAVNdXhlZAAAAAAAABEAAAABAAAAAgAAAA8AAAAHYWNjb3VudAAAAAASAAAAAeTogbACVb7Sujx9sTA+Z1uESOygZh8SGNCzvHzpGhx4AAAADwAAAAJpZAAAAAAABQAAAAAAAAGk"
+    },
+    {
+      "id": "muxed-u32-id",
+      "returnType": "PaymentDestination",
+      "reason": "Routing ID must use u64",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAVNdXhlZAAAAAAAABEAAAABAAAAAgAAAA8AAAAHYWNjb3VudAAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAACaWQAAAAAAAMAAAGk"
+    },
+    {
+      "id": "muxed-separate-memo",
+      "returnType": "PaymentDestination",
+      "reason": "Muxed has no separate memo field",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAVNdXhlZAAAAAAAABEAAAABAAAAAwAAAA8AAAAHYWNjb3VudAAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAACaWQAAAAAAAUAAAAAAAABpAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAQAAAA8AAAAETm9uZQ=="
+    },
+    {
+      "id": "truncated-xdr",
+      "returnType": "PaymentDestination",
+      "reason": "Truncated XDR is invalid",
+      "xdrBase64": "AAAAEAAAAAEAAAACAAAADwAAAAZEaXJlY3QAAAAAABEAAAABAAAAAgAAAA8AAAAHYWRkcmVzcwAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAEbWVtbwAAABAAAAABAAAAAQAAAA8AAAAE"
+    }
+  ]
+}
diff --git a/extension/src/popup/helpers/__tests__/soran.test.ts b/extension/src/popup/helpers/__tests__/soran.test.ts
new file mode 100644
index 0000000000..b6740e4765
--- /dev/null
+++ b/extension/src/popup/helpers/__tests__/soran.test.ts
@@ -0,0 +1,189 @@
+import { Address, MuxedAccount, nativeToScVal, rpc, xdr } from "stellar-sdk";
+import {
+  TESTNET_NETWORK_DETAILS,
+  MAINNET_NETWORK_DETAILS,
+} from "@shared/constants/stellar";
+import {
+  decodeSoranDestination,
+  normalizeSoranName,
+  resolveSoranName,
+  verifySoranDestination,
+  SORAN_TESTNET_LOOKUP,
+} from "../soran";
+import fixtures from "./fixtures/soran-destinations.json";
+
+jest.mock("../localizationConfig", () => ({
+  __esModule: true,
+  default: { t: (key: string) => key },
+}));
+
+const value = (id: string) =>
+  xdr.ScVal.fromXDR(
+    fixtures.valid.find((item) => item.id === id)!.xdrBase64,
+    "base64",
+  );
+
+describe("Soran destination conformance", () => {
+  it.each(fixtures.valid)(
+    "decodes $id without losing routing information",
+    (fixture) => {
+      const destination = decodeSoranDestination(
+        xdr.ScVal.fromXDR(fixture.xdrBase64, "base64"),
+      );
+      if (fixture.expectedMuxed) {
+        const muxed = MuxedAccount.fromAddress(destination.address, "0");
+        expect(muxed.baseAccount().accountId()).toBe(
+          fixture.expectedMuxed.account,
+        );
+        expect(muxed.id()).toBe(fixture.expectedMuxed.id);
+        expect(destination.memo).toBe("");
+        expect(destination.memoType).toBe("");
+      } else {
+        expect(destination).toEqual(fixture.expectedDestination);
+      }
+    },
+  );
+  it.each(fixtures.invalid)("rejects $id", (fixture) => {
+    expect(() =>
+      decodeSoranDestination(xdr.ScVal.fromXDR(fixture.xdrBase64, "base64")),
+    ).toThrow();
+  });
+});
+
+describe("Soran name normalization", () => {
+  it.each([" Alice.Nova ", "ALICE.NOVA", "alice.nova"])(
+    "normalizes %s",
+    (input) => {
+      expect(normalizeSoranName(input)).toBe("alice.nova");
+    },
+  );
+  it.each([
+    "alice",
+    "alice..nova",
+    "a.b.c",
+    "-alice.nova",
+    "alice-.nova",
+    "alice._nova",
+    "al ice.nova",
+    "аlice.nova",
+    "K.nova",
+    "https://alice.nova",
+    `${"a".repeat(64)}.nova`,
+    "alice*example.com",
+  ])("rejects %s", (input) => {
+    expect(normalizeSoranName(input)).toBeNull();
+  });
+  it("accepts boundary label lengths and interior hyphens", () => {
+    expect(normalizeSoranName(`a.${"b".repeat(63)}`)).not.toBeNull();
+    expect(normalizeSoranName("a-b.nova")).toBe("a-b.nova");
+  });
+});
+
+describe("direct Soroban reads", () => {
+  const registry = "CCSORANDPQINYOYB5SVO45WJP2LBBYKC72HHUIRVXB4J6RUZKDAUW7G4";
+  const success = (retval: xdr.ScVal) =>
+    ({
+      id: "read",
+      latestLedger: 1,
+      events: [],
+      transactionData: {},
+      minResourceFee: "0",
+      result: { retval, auth: [] },
+    }) as unknown as rpc.Api.SimulateTransactionResponse;
+  let simulate: jest.SpyInstance;
+  let send: jest.SpyInstance;
+  beforeEach(() => {
+    simulate = jest
+      .spyOn(rpc.Server.prototype, "simulateTransaction")
+      .mockImplementation(async (transaction) => {
+        const operation = transaction.operations[0];
+        if (
+          operation.type !== "invokeHostFunction" ||
+          operation.func.type !== "hostFunctionTypeInvokeContract"
+        )
+          throw new Error("unexpected operation");
+        const args = operation.func.invokeContract;
+        expect(Address.fromScAddress(args.contractAddress).toString()).toBe(
+          SORAN_TESTNET_LOOKUP,
+        );
+        const method = args.functionName.toString();
+        if (method === "registry")
+          return success(new Address(registry).toScVal());
+        if (method === "version" || method === "destination_version")
+          return success(nativeToScVal(2, { type: "u32" }));
+        expect(method).toBe("resolve_destination");
+        expect(args.args).toEqual([
+          nativeToScVal("alice.nova", { type: "string" }),
+        ]);
+        expect(transaction.signatures).toHaveLength(0);
+        return success(value("direct-g-id-max"));
+      });
+    send = jest.spyOn(rpc.Server.prototype, "sendTransaction");
+  });
+  afterEach(() => jest.restoreAllMocks());
+  it("reads the selected RPC without signing or submitting", async () => {
+    const result = await resolveSoranName(
+      " Alice.Nova ",
+      TESTNET_NETWORK_DETAILS,
+    );
+    expect(result).toMatchObject({
+      name: "alice.nova",
+      memo: "18446744073709551615",
+      memoType: "id",
+    });
+    expect(simulate).toHaveBeenCalledTimes(4);
+    expect(simulate.mock.calls.every((call) => call[3] === false)).toBe(true);
+    expect(send).not.toHaveBeenCalled();
+  });
+  it("rejects unsupported networks before any RPC call", async () => {
+    await expect(
+      resolveSoranName("alice.nova", MAINNET_NETWORK_DETAILS),
+    ).rejects.toThrow("only available on Testnet");
+    expect(simulate).not.toHaveBeenCalled();
+  });
+  it("requires an RPC URL", async () => {
+    await expect(
+      resolveSoranName("alice.nova", {
+        ...TESTNET_NETWORK_DETAILS,
+        sorobanRpcUrl: undefined,
+      }),
+    ).rejects.toThrow("RPC URL");
+    expect(simulate).not.toHaveBeenCalled();
+  });
+  it("rejects an incorrect registry anchor", async () => {
+    simulate.mockResolvedValueOnce(
+      success(new Address(SORAN_TESTNET_LOOKUP).toScVal()),
+    );
+    await expect(
+      resolveSoranName("alice.nova", TESTNET_NETWORK_DETAILS),
+    ).rejects.toThrow("Unable to resolve");
+    expect(simulate).toHaveBeenCalledTimes(3);
+  });
+  it.each([
+    { error: "Error(Contract, #7)" },
+    { error: "transport unavailable" },
+    { restorePreamble: { minResourceFee: "100", transactionData: {} } },
+  ])("fails closed on unavailable state: %j", async (result) => {
+    simulate.mockResolvedValueOnce({
+      ...success(value("direct-g-none")),
+      ...result,
+    });
+    await expect(
+      resolveSoranName("alice.nova", TESTNET_NETWORK_DETAILS),
+    ).rejects.toThrow("Unable to resolve");
+    expect(simulate).toHaveBeenCalledTimes(3);
+  });
+  it("rejects a required memo that was removed before sending", async () => {
+    await expect(
+      verifySoranDestination(
+        "alice.nova",
+        {
+          address: "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF",
+          memo: "",
+          memoType: "",
+        },
+        TESTNET_NETWORK_DETAILS,
+      ),
+    ).rejects.toThrow("payment details changed");
+  });
+});
diff --git a/extension/src/popup/helpers/__tests__/soranAdversary.test.tsx b/extension/src/popup/helpers/__tests__/soranAdversary.test.tsx
new file mode 100644
index 0000000000..1cef5023a3
--- /dev/null
+++ b/extension/src/popup/helpers/__tests__/soranAdversary.test.tsx
@@ -0,0 +1,394 @@
+/** Regression coverage for the Soran adversarial review.
+ * All signing, RPC, submission, and storage use mocks; no wallet state is changed.
+ */
+import React from "react";
+import browser from "webextension-polyfill";
+import { ActionStatus } from "@shared/api/types";
+import { act, renderHook } from "@testing-library/react";
+import { Provider } from "react-redux";
+import {
+  Account,
+  Address,
+  Asset,
+  Keypair,
+  MuxedAccount,
+  Operation,
+  TransactionBuilder,
+  nativeToScVal,
+  rpc,
+} from "stellar-sdk";
+import { TESTNET_NETWORK_DETAILS } from "@shared/constants/stellar";
+import { SERVICE_TYPES } from "@shared/constants/services";
+import { popupMessageListener } from "background/messageListener/popupMessageListener";
+import { getOperation } from "popup/components/send/SendAmount/hooks/useSimulateTxData";
+import { useSimulateTxData as useCollectibleSimulation } from "popup/components/sendCollectible/SelectedCollectible/hooks/useSimulateTxData";
+import { useSubmitTxData } from "popup/components/InternalTransaction/SubmitTransaction/hooks/useSubmitTxData";
+import { initialState as submissionInitialState } from "popup/ducks/transactionSubmission";
+import { makeDummyStore } from "popup/__testHelpers__";
+import * as api from "@shared/api/internal";
+import * as soran from "popup/helpers/soran";
+
+jest.mock("webextension-polyfill", () => ({
+  __esModule: true,
+  default: {
+    runtime: {
+      id: "trusted",
+      getURL: (path: string) => `chrome-extension://trusted/${path}`,
+    },
+  },
+}));
+
+jest.mock("popup/helpers/blockaid", () => ({
+  useScanTx: () => ({ scanTx: jest.fn().mockResolvedValue({}) }),
+}));
+jest.mock("helpers/metrics", () => ({
+  ...jest.requireActual("helpers/metrics"),
+  emitMetric: jest.fn(),
+}));
+jest.mock("helpers/hooks/useGetBalances", () => ({
+  useGetBalances: () => ({
+    fetchData: jest.fn().mockResolvedValue({ balances: [] }),
+  }),
+}));
+jest.mock("helpers/hooks/useGetCollectibles", () => ({
+  useGetCollectibles: () => ({ fetchData: jest.fn().mockResolvedValue({}) }),
+}));
+
+const payer = Keypair.random().publicKey();
+const recipient = Keypair.random().publicKey();
+const wrongRecipient = Keypair.random().publicKey();
+const muxed = new MuxedAccount(
+  new Account(recipient, "0"),
+  "18446744073709551615",
+).accountId();
+const network = TESTNET_NETWORK_DETAILS;
+const buildPayment = (destination: string) =>
+  new TransactionBuilder(new Account(payer, "0"), {
+    fee: "100",
+    networkPassphrase: network.networkPassphrase,
+  })
+    .addOperation(
+      Operation.payment({ destination, asset: Asset.native(), amount: "10" }),
+    )
+    .setTimeout(0)
+    .build()
+    .toXDR();
+const mockLookup = (address: string) => {
+  const symbol = (tag: string) => nativeToScVal(tag, { type: "symbol" });
+  let destination;
+  if (address.startsWith("M")) {
+    const route = MuxedAccount.fromAddress(address, "0");
+    destination = nativeToScVal([
+      symbol("Muxed"),
+      nativeToScVal(
+        {
+          account: new Address(route.baseAccount().accountId()).toScVal(),
+          id: nativeToScVal(BigInt(route.id()), { type: "u64" }),
+        },
+        { type: { account: ["symbol", null], id: ["symbol", null] } },
+      ),
+    ]);
+  } else {
+    destination = nativeToScVal([
+      symbol("Direct"),
+      nativeToScVal(
+        {
+          address: new Address(address).toScVal(),
+          memo: nativeToScVal([symbol("None")]),
+        },
+        { type: { address: ["symbol", null], memo: ["symbol", null] } },
+      ),
+    ]);
+  }
+  jest
+    .spyOn(rpc.Server.prototype, "simulateTransaction")
+    .mockImplementation(async (tx) => {
+      const op = tx.operations[0] as any;
+      const method = op.func.invokeContract.functionName.toString();
+      const retval =
+        method === "registry"
+          ? new Address(
+              "CCSORANDPQINYOYB5SVO45WJP2LBBYKC72HHUIRVXB4J6RUZKDAUW7G4",
+            ).toScVal()
+          : method === "resolve_destination"
+            ? destination
+            : nativeToScVal(2, { type: "u32" });
+      return {
+        id: "read",
+        latestLedger: 1,
+        events: [],
+        transactionData: {},
+        minResourceFee: "0",
+        result: { retval, auth: [] },
+      } as any;
+    });
+};
+const state = (destination: string, extra = {}) => ({
+  auth: {
+    publicKey: payer,
+    allAccounts: [
+      { publicKey: destination, name: "skip-recents", imported: false },
+    ],
+  },
+  cache: { balanceData: {}, tokenPrices: {} },
+  transactionSubmission: {
+    ...submissionInitialState,
+    transactionData: {
+      ...submissionInitialState.transactionData,
+      asset: "native",
+      amount: "10",
+      destination,
+      federationAddress: "alice.nova",
+      ...extra,
+    },
+  },
+});
+const wrapper =
+  (store: ReturnType<typeof makeDummyStore>) =>
+  ({ children }: { children: React.ReactNode }) => (
+    <Provider store={store}>{children}</Provider>
+  );
+afterEach(() => jest.restoreAllMocks());
+
+it.each([
+  "https://unrelated.example/",
+  "http://localhost:9000.evil.example/",
+  "http://localhost:9000@evil.example/",
+  "chrome-extension://other/index.html",
+])("rejects history-label access from %s", async (url) => {
+  const data: Record<string, unknown> = {};
+  const localStore = {
+    getItem: jest.fn(async (key: string) => data[key]),
+    setItem: jest.fn(async (key: string, value: unknown) => {
+      data[key] = value;
+    }),
+  } as any;
+  const sessionStore = {
+    getState: () => ({ session: { publicKey: payer } }),
+  } as any;
+  const payment = {
+    networkPassphrase: network.networkPassphrase,
+    transactionHash: "a".repeat(64),
+    destination: recipient,
+    memo: "hello",
+    memoType: "text",
+    name: "forged.nova",
+  };
+  const unrelatedPage = {
+    tab: { id: 10 },
+    id: "trusted",
+    url,
+  } as any;
+  const invoke = (type: SERVICE_TYPES, payload: typeof payment) =>
+    popupMessageListener(
+      { type, activePublicKey: payer, payment: payload } as any,
+      sessionStore,
+      localStore,
+      {} as any,
+      {} as any,
+      unrelatedPage,
+    );
+  expect(await invoke(SERVICE_TYPES.SAVE_SORAN_PAYMENT_NAME, payment)).toEqual({
+    error: "Unauthorized",
+  });
+  expect(await invoke(SERVICE_TYPES.GET_SORAN_PAYMENT_NAME, payment)).toEqual({
+    error: "Unauthorized",
+  });
+  expect(localStore.getItem).not.toHaveBeenCalled();
+  expect(localStore.setItem).not.toHaveBeenCalled();
+  // Control: another protected handler rejects exactly this sender.
+  expect(
+    await popupMessageListener(
+      {
+        type: SERVICE_TYPES.GET_ANALYTICS_USER_ID,
+        activePublicKey: payer,
+      } as any,
+      sessionStore,
+      localStore,
+      {} as any,
+      {} as any,
+      unrelatedPage,
+    ),
+  ).toEqual({ error: "Unauthorized" });
+});
+
+it("rejects account creation that would drop a Soran muxed ID", async () => {
+  mockLookup(muxed);
+  expect(await soran.resolveSoranName("mux.nova", network)).toMatchObject({
+    address: muxed,
+    memo: "",
+  });
+  expect(() =>
+    getOperation(
+      Asset.native(),
+      Asset.native(),
+      "10",
+      "",
+      muxed,
+      "1",
+      [],
+      false,
+      false,
+      false,
+      payer,
+      true,
+    ),
+  ).toThrow(/cannot preserve/);
+});
+
+it("rejects a collectible muxed route before requesting simulation", async () => {
+  mockLookup(muxed);
+  expect(await soran.resolveSoranName("mux.nova", network)).toMatchObject({
+    address: muxed,
+    memo: "",
+  });
+  const simulate = jest
+    .spyOn(api, "simulateSendCollectible")
+    .mockResolvedValue({
+      ok: true,
+      response: {
+        simulationResponse: { minResourceFee: "100" },
+        preparedTransaction: "mock-xdr",
+      },
+    } as any);
+  const store = makeDummyStore(
+    state(muxed, {
+      isCollectible: true,
+      collectibleData: {
+        collectionAddress:
+          "CCVKI6UYJDO34LO4D653IXCTPBGJOHJSJGSIOB4A46IH4ULNHS2MPQL7",
+        tokenId: 42,
+      },
+    }),
+  );
+  const { result } = renderHook(
+    () =>
+      useCollectibleSimulation({
+        publicKey: payer,
+        destination: muxed,
+        networkDetails: network,
+      }),
+    { wrapper: wrapper(store) },
+  );
+  let response: unknown;
+  await act(async () => {
+    response = await result.current.fetchData();
+  });
+  expect(response).toMatchObject({ ok: false });
+  expect(simulate).not.toHaveBeenCalled();
+});
+
+it.each(["unsigned", "signed", "hardware"])(
+  "blocks an altered recipient in the %s envelope",
+  async (stage) => {
+    const wrongXdr = buildPayment(wrongRecipient);
+    mockLookup(recipient);
+    jest.spyOn(soran, "verifySoranDestination");
+    const sign = jest
+      .spyOn(api, "signFreighterTransaction")
+      .mockResolvedValue({ signedTransaction: wrongXdr });
+    jest.spyOn(api, "getTokenPrices").mockResolvedValue({});
+    jest.spyOn(api, "saveSoranPaymentName").mockResolvedValue({ saved: true });
+    const priorFetch = global.fetch;
+    const fetchMock = jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ successful: true, hash: "b".repeat(64) }),
+    });
+    global.fetch = fetchMock as any;
+    try {
+      const initial = state(recipient);
+      initial.transactionSubmission.transactionSimulation = {
+        ...submissionInitialState.transactionSimulation,
+        preparedTransaction: wrongXdr,
+      };
+      const store = makeDummyStore(initial);
+      const { result } = renderHook(
+        () =>
+          useSubmitTxData({
+            publicKey: payer,
+            networkDetails: network,
+            isHardwareWallet: stage === "hardware",
+            xdr: stage === "signed" ? buildPayment(recipient) : wrongXdr,
+          }),
+        { wrapper: wrapper(store) },
+      );
+      await act(async () => {
+        await result.current.fetchData({ isSwap: false });
+      });
+      expect(soran.verifySoranDestination).toHaveBeenCalledWith(
+        "alice.nova",
+        { address: recipient, memo: "", memoType: "" },
+        network,
+      );
+      if (stage === "signed") expect(sign).toHaveBeenCalledTimes(1);
+      else expect(sign).not.toHaveBeenCalled();
+      expect(
+        fetchMock.mock.calls.find(([url]) => String(url).includes("submit-tx")),
+      ).toBeUndefined();
+      expect(api.saveSoranPaymentName).not.toHaveBeenCalled();
+      expect(store.getState().transactionSubmission.submitStatus).toBe(
+        ActionStatus.ERROR,
+      );
+    } finally {
+      global.fetch = priorFetch;
+    }
+  },
+);
+
+it.each(["popup", "fullscreen", "dev server"])(
+  "allows saved-name access from the trusted %s",
+  async (surface) => {
+    const data: Record<string, unknown> = {};
+    const localStore = {
+      getItem: jest.fn(async (key: string) => data[key]),
+      setItem: jest.fn(async (key: string, value: unknown) => {
+        data[key] = value;
+      }),
+    } as any;
+    const sessionStore = {
+      getState: () => ({ session: { publicKey: payer } }),
+    } as any;
+    const getURL = jest
+      .spyOn(browser.runtime, "getURL")
+      .mockImplementation((path) => `chrome-extension://trusted/${path}`);
+    try {
+      const sender = {
+        id: browser.runtime.id,
+        ...(surface === "popup"
+          ? {}
+          : {
+              tab: { id: 10 },
+              url:
+                surface === "fullscreen"
+                  ? "chrome-extension://trusted/index.html"
+                  : "http://localhost:9000/",
+            }),
+      };
+      const payment = {
+        name: "alice.nova",
+        destination: recipient,
+        transactionHash: "c".repeat(64),
+        memo: "",
+        memoType: "none",
+        networkPassphrase: network.networkPassphrase,
+      };
+      const invoke = (type: SERVICE_TYPES) =>
+        popupMessageListener(
+          { type, activePublicKey: payer, payment } as any,
+          sessionStore,
+          localStore,
+          {} as any,
+          {} as any,
+          sender as any,
+        );
+      expect(await invoke(SERVICE_TYPES.SAVE_SORAN_PAYMENT_NAME)).toEqual({
+        saved: true,
+      });
+      expect(await invoke(SERVICE_TYPES.GET_SORAN_PAYMENT_NAME)).toEqual({
+        name: "alice.nova",
+      });
+    } finally {
+      getURL.mockRestore();
+    }
+  },
+);
diff --git a/extension/src/popup/helpers/__tests__/soranHistory.test.ts b/extension/src/popup/helpers/__tests__/soranHistory.test.ts
new file mode 100644
index 0000000000..db0819ca18
--- /dev/null
+++ b/extension/src/popup/helpers/__tests__/soranHistory.test.ts
@@ -0,0 +1,66 @@
+import {
+  formatHistoryTimestamp,
+  getHistoryCounterparty,
+} from "../soranHistory";
+import type { OperationDataRow } from "popup/views/AccountHistory/hooks/useGetHistoryData";
+const operation = (metadata: Record<string, unknown>) =>
+  ({ metadata }) as OperationDataRow;
+it("selects the complete counterparty for sent and received payments", () => {
+  expect(
+    getHistoryCounterparty(
+      operation({ isPayment: true, from: "sender", to: "muxed" }),
+    ),
+  ).toEqual({ address: "muxed", isReceiving: false });
+  expect(
+    getHistoryCounterparty(
+      operation({
+        isPayment: true,
+        from: "muxed",
+        to: "me",
+        isReceiving: true,
+      }),
+    ),
+  ).toEqual({ address: "muxed", isReceiving: true });
+});
+it("uses one unambiguous contract transfer and omits multi-party calls, swaps and failures", () => {
+  const diff = { destination: "contract", isCredit: false };
+  expect(
+    getHistoryCounterparty(
+      operation({
+        isInvokeHostFn: true,
+        hasAssetDiffs: true,
+        assetDiffs: [diff],
+      }),
+    ),
+  ).toEqual({ address: "contract", isReceiving: false });
+  expect(
+    getHistoryCounterparty(
+      operation({
+        isInvokeHostFn: true,
+        hasAssetDiffs: true,
+        assetDiffs: [diff, diff],
+      }),
+    ),
+  ).toBeUndefined();
+  expect(
+    getHistoryCounterparty(
+      operation({ isSwap: true, isPayment: true, to: "other" }),
+    ),
+  ).toBeUndefined();
+  expect(
+    getHistoryCounterparty(
+      operation({ transactionFailed: true, isPayment: true, to: "other" }),
+    ),
+  ).toBeUndefined();
+});
+it.each(["en-GB", "en-US", "pt-BR"])(
+  "formats valid dates in %s without assuming AM/PM",
+  (locale) => {
+    const result = formatHistoryTimestamp("2026-09-12T09:58:00Z", locale);
+    expect(result).toContain("2026");
+    expect(result).toContain(" • ");
+    expect(result).not.toMatch(/undefined|Invalid|NaN/);
+  },
+);
+it("handles an unavailable timestamp", () =>
+  expect(formatHistoryTimestamp("bad")).toBe("—"));
diff --git a/extension/src/popup/helpers/__tests__/soranPrimary.test.ts b/extension/src/popup/helpers/__tests__/soranPrimary.test.ts
new file mode 100644
index 0000000000..44f2c07f95
--- /dev/null
+++ b/extension/src/popup/helpers/__tests__/soranPrimary.test.ts
@@ -0,0 +1,217 @@
+import {
+  Account,
+  Address,
+  MuxedAccount,
+  nativeToScVal,
+  rpc,
+  scValToNative,
+  xdr,
+} from "stellar-sdk";
+import {
+  TESTNET_NETWORK_DETAILS,
+  MAINNET_NETWORK_DETAILS,
+} from "@shared/constants/stellar";
+import {
+  decodeSoranPrimaryBatch,
+  encodeSoranIdentity,
+  getSoranPrimaryName,
+  readSoranPrimaryNames,
+} from "../soranPrimary";
+
+jest.mock("../localizationConfig", () => ({
+  __esModule: true,
+  default: { t: (key: string) => key },
+}));
+const G = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";
+const muxed = (id: string) =>
+  new MuxedAccount(new Account(G, "0"), id).accountId();
+const sym = (tag: string) => nativeToScVal(tag, { type: "symbol" });
+const item = (tag: string, ...args: xdr.ScVal[]) =>
+  nativeToScVal([sym(tag), ...args]);
+const named = (name: string) =>
+  item("Name", nativeToScVal(name, { type: "string" }));
+const batch = (results: xdr.ScVal[]) =>
+  nativeToScVal(
+    {
+      ledger: nativeToScVal(100, { type: "u32" }),
+      results: nativeToScVal(results),
+      timestamp: nativeToScVal(BigInt(1000), { type: "u64" }),
+    },
+    {
+      type: {
+        ledger: ["symbol", null],
+        results: ["symbol", null],
+        timestamp: ["symbol", null],
+      },
+    },
+  );
+const success = (retval: xdr.ScVal) =>
+  ({
+    id: "read",
+    latestLedger: 1,
+    events: [],
+    transactionData: {},
+    minResourceFee: "0",
+    result: { retval, auth: [] },
+  }) as unknown as rpc.Api.SimulateTransactionResponse;
+
+it("encodes G and the full uint64 muxed identity distinctly", () => {
+  expect(scValToNative(encodeSoranIdentity(G))).toEqual(["Direct", G]);
+  expect(
+    scValToNative(encodeSoranIdentity(muxed("18446744073709551615"))),
+  ).toEqual(["Muxed", { account: G, id: BigInt("18446744073709551615") }]);
+  expect(() => encodeSoranIdentity("bad")).toThrow();
+});
+
+it("preserves ordered names, absence, and unknown per-item failures", () => {
+  expect(
+    decodeSoranPrimaryBatch(
+      batch([
+        named("alice.anynamespace"),
+        item("None"),
+        item("Failed", nativeToScVal(999, { type: "u32" })),
+      ]),
+      3,
+    ),
+  ).toEqual([
+    {
+      status: "name",
+      name: "alice.anynamespace",
+      ledger: 100,
+      timestamp: "1000",
+    },
+    { status: "none", ledger: 100, timestamp: "1000" },
+    { status: "failed", code: 999 },
+  ]);
+});
+it.each([
+  item("Name", nativeToScVal("Alice.nova", { type: "string" })),
+  item("Name", nativeToScVal("аlice.nova", { type: "string" })),
+  item("Name", sym("alice.nova")),
+  item("None", sym("extra")),
+  item("Failed", nativeToScVal(0, { type: "u32" })),
+  item("Failed", nativeToScVal(5, { type: "u64" })),
+  nativeToScVal(null),
+  item("Unknown"),
+])("rejects malformed result %#", (value) => {
+  expect(() => decodeSoranPrimaryBatch(batch([value]), 1)).toThrow();
+});
+it("rejects partial result counts", () => {
+  expect(() => decodeSoranPrimaryBatch(batch([item("None")]), 2)).toThrow();
+});
+
+describe("Universal Lookup batches", () => {
+  let simulate: jest.SpyInstance;
+  let primary: jest.Mock;
+  let capability: number;
+  beforeEach(() => {
+    capability = 3;
+    primary = jest.fn((identities: unknown[]) =>
+      success(batch(identities.map(() => named("alice.nova")))),
+    );
+    simulate = jest
+      .spyOn(rpc.Server.prototype, "simulateTransaction")
+      .mockImplementation(async (transaction) => {
+        expect(transaction.signatures).toHaveLength(0);
+        const op = transaction.operations[0];
+        if (
+          op.type !== "invokeHostFunction" ||
+          op.func.type !== "hostFunctionTypeInvokeContract"
+        )
+          throw new Error("bad invocation");
+        const invocation = op.func.invokeContract;
+        const method = invocation.functionName.toString();
+        if (method === "registry")
+          return success(
+            new Address(
+              "CCSORANDPQINYOYB5SVO45WJP2LBBYKC72HHUIRVXB4J6RUZKDAUW7G4",
+            ).toScVal(),
+          );
+        if (method === "primary_names")
+          return primary(scValToNative(invocation.args[0]));
+        const value =
+          method === "batch_read_version"
+            ? capability
+            : method === "primary_batch_limit"
+              ? 16
+              : method === "muxed_identity_version"
+                ? 1
+                : 2;
+        return success(nativeToScVal(value, { type: "u32" }));
+      });
+  });
+  afterEach(() => jest.restoreAllMocks());
+  it("uses the deployed batch limit and only unsigned simulations", async () => {
+    const send = jest.spyOn(rpc.Server.prototype, "sendTransaction");
+    expect(
+      await readSoranPrimaryNames(Array(17).fill(G), TESTNET_NETWORK_DETAILS),
+    ).toHaveLength(17);
+    expect(primary.mock.calls.map(([rows]) => rows.length)).toEqual([16, 1]);
+    expect(simulate.mock.calls.every((args) => args[3] === false)).toBe(true);
+    expect(send).not.toHaveBeenCalled();
+  });
+  it("halves only leading host budget errors", async () => {
+    primary.mockImplementation((rows) =>
+      rows.length > 1
+        ? { error: "HostError: Error(Budget, ExceededLimit)\nEvent log..." }
+        : success(batch([item("None")])),
+    );
+    expect(
+      (
+        await readSoranPrimaryNames(
+          [G, muxed("1"), muxed("2")],
+          TESTNET_NETWORK_DETAILS,
+        )
+      ).map((r) => r.status),
+    ).toEqual(["none", "none", "none"]);
+    expect(primary.mock.calls.map(([rows]) => rows.length)).toEqual([
+      3, 2, 1, 1, 1,
+    ]);
+  });
+  it.each([
+    { error: "HostError: Error(Contract, #12)\nBudget, ExceededLimit" },
+    { error: "transport unavailable" },
+    { error: "HostError: Error(Budget, ExceededLimit)" },
+  ])("preserves singleton/top-level failures", async (error) => {
+    primary.mockReturnValue(error);
+    expect(await readSoranPrimaryNames([G], TESTNET_NETWORK_DETAILS)).toEqual([
+      { status: "failed" },
+    ]);
+    expect(primary).toHaveBeenCalledTimes(1);
+  });
+  it("rejects unsupported networks and capabilities", async () => {
+    await expect(
+      readSoranPrimaryNames([G], MAINNET_NETWORK_DETAILS),
+    ).rejects.toThrow();
+    expect(simulate).not.toHaveBeenCalled();
+    capability = 1;
+    await expect(
+      readSoranPrimaryNames([G], TESTNET_NETWORK_DETAILS),
+    ).rejects.toThrow();
+    expect(primary).not.toHaveBeenCalled();
+  });
+  it("coalesces duplicates and caches full identities separately", async () => {
+    const network = {
+      ...TESTNET_NETWORK_DETAILS,
+      sorobanRpcUrl: "https://cache-test.invalid",
+    };
+    const a = getSoranPrimaryName(G, network);
+    expect(getSoranPrimaryName(G, network)).toBe(a);
+    const b = getSoranPrimaryName(muxed("42"), network);
+    await Promise.all([a, b]);
+    expect(primary).toHaveBeenCalledTimes(1);
+    expect(primary.mock.calls[0][0]).toEqual([
+      ["Direct", G],
+      ["Muxed", { account: G, id: BigInt(42) }],
+    ]);
+    expect(await getSoranPrimaryName(G, network)).toMatchObject({
+      status: "name",
+    });
+    expect(primary).toHaveBeenCalledTimes(1);
+    await getSoranPrimaryName(G, {
+      ...network,
+      sorobanRpcUrl: "https://another-test.invalid",
+    });
+    expect(primary).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/extension/src/popup/helpers/__tests__/soranTransaction.test.ts b/extension/src/popup/helpers/__tests__/soranTransaction.test.ts
new file mode 100644
index 0000000000..f0348a4d8f
--- /dev/null
+++ b/extension/src/popup/helpers/__tests__/soranTransaction.test.ts
@@ -0,0 +1,274 @@
+import {
+  Account,
+  Address,
+  Asset,
+  Contract,
+  Keypair,
+  Memo,
+  MuxedAccount,
+  Operation,
+  TransactionBuilder,
+  nativeToScVal,
+  xdr,
+} from "stellar-sdk";
+import { TESTNET_NETWORK_DETAILS as network } from "@shared/constants/stellar";
+import { assertSoranTransactionRoute } from "../soranTransaction";
+
+const payer = Keypair.random().publicKey();
+const recipient = Keypair.random().publicKey();
+const other = Keypair.random().publicKey();
+const muxed = new MuxedAccount(
+  new Account(recipient, "0"),
+  "18446744073709551615",
+).accountId();
+const contract = Asset.native().contractId(network.networkPassphrase);
+const context = { publicKey: payer, asset: "native" };
+const route = (address = recipient, memo = "", memoType = "") => ({
+  address,
+  memo,
+  memoType,
+});
+const payment = (destination = recipient, source?: string) =>
+  Operation.payment({
+    destination,
+    source,
+    asset: Asset.native(),
+    amount: "1",
+  });
+const build = (
+  op = payment(),
+  memo: Memo = Memo.none(),
+  source = payer,
+  extra?: xdr.Operation,
+) => {
+  const builder = new TransactionBuilder(new Account(source, "0"), {
+    fee: "100",
+    networkPassphrase: network.networkPassphrase,
+  })
+    .addOperation(op)
+    .addMemo(memo)
+    .setTimeout(0);
+  if (extra) builder.addOperation(extra);
+  return builder.build();
+};
+const transfer = (
+  to = recipient,
+  from = payer,
+  id = contract,
+  fn = "transfer",
+  value = nativeToScVal(BigInt(10), { type: "i128" }),
+) =>
+  new Contract(id).call(
+    fn,
+    new Address(from).toScVal(),
+    new Address(to).toScVal(),
+    value,
+  );
+
+it.each([recipient, muxed])(
+  "accepts a complete classic destination and derives the history hash: %s",
+  (destination) => {
+    const tx = build(payment(destination));
+    expect(
+      assertSoranTransactionRoute(
+        tx.toXDR(),
+        route(destination),
+        network,
+        context,
+      ),
+    ).toEqual({
+      destination,
+      memo: "",
+      memoType: "none",
+      networkPassphrase: network.networkPassphrase,
+      transactionHash: Buffer.from(tx.hash()).toString("hex"),
+    });
+  },
+);
+it.each([
+  ["text", "hello", Memo.text("hello"), Memo.text("other")],
+  ["id", "18446744073709551615", Memo.id("18446744073709551615"), Memo.id("0")],
+  [
+    "hash",
+    Buffer.alloc(32, 7).toString("base64"),
+    Memo.hash(Buffer.alloc(32, 7)),
+    Memo.hash(Buffer.alloc(32, 8)),
+  ],
+] as const)("preserves the exact %s memo", (type, value, memo, alteredMemo) => {
+  expect(() =>
+    assertSoranTransactionRoute(
+      build(payment(), memo).toXDR(),
+      route(recipient, value, type),
+      network,
+      context,
+    ),
+  ).not.toThrow();
+  expect(() =>
+    assertSoranTransactionRoute(
+      build().toXDR(),
+      route(recipient, value, type),
+      network,
+      context,
+    ),
+  ).toThrow(/does not match/);
+  expect(() =>
+    assertSoranTransactionRoute(
+      build(payment(), alteredMemo).toXDR(),
+      route(recipient, value, type),
+      network,
+      context,
+    ),
+  ).toThrow(/does not match/);
+});
+it.each([
+  ["different recipient", () => build(payment(other))],
+  ["different source", () => build(payment(), Memo.none(), other)],
+  ["operation source override", () => build(payment(recipient, other))],
+  [
+    "additional operation",
+    () => build(payment(), Memo.none(), payer, payment(other)),
+  ],
+  ["unexpected memo", () => build(payment(), Memo.text("extra"))],
+  ["wrong memo type", () => build(payment(), Memo.text("123"))],
+] as const)("rejects %s", (_, tx) => {
+  expect(() =>
+    assertSoranTransactionRoute(tx().toXDR(), route(), network, context),
+  ).toThrow(/does not match/);
+});
+it("rejects a typed memo with the right value but wrong type", () => {
+  expect(() =>
+    assertSoranTransactionRoute(
+      build(payment(), Memo.text("123")).toXDR(),
+      route(recipient, "123", "id"),
+      network,
+      context,
+    ),
+  ).toThrow();
+});
+it("rejects muxed ID loss or substitution, including createAccount", () => {
+  for (const op of [
+    payment(recipient),
+    payment(new MuxedAccount(new Account(recipient, "0"), "1").accountId()),
+    Operation.createAccount({ destination: recipient, startingBalance: "10" }),
+  ]) {
+    expect(() =>
+      assertSoranTransactionRoute(
+        build(op).toXDR(),
+        route(muxed),
+        network,
+        context,
+      ),
+    ).toThrow();
+  }
+  expect(() =>
+    assertSoranTransactionRoute(
+      build(
+        Operation.createAccount({
+          destination: recipient,
+          startingBalance: "10",
+        }),
+      ).toXDR(),
+      route(),
+      network,
+      context,
+    ),
+  ).not.toThrow();
+});
+it.each([recipient, muxed])(
+  "accepts contract transfer preserving destination %s",
+  (destination) => {
+    expect(() =>
+      assertSoranTransactionRoute(
+        build(transfer(destination)).toXDR(),
+        route(destination),
+        network,
+        context,
+      ),
+    ).not.toThrow();
+  },
+);
+it.each([
+  ["different destination", () => transfer(other)],
+  ["different sender", () => transfer(recipient, other)],
+  [
+    "different contract",
+    () =>
+      transfer(
+        recipient,
+        payer,
+        new Asset("USD", other).contractId(network.networkPassphrase),
+      ),
+  ],
+  ["different method", () => transfer(recipient, payer, contract, "approve")],
+  [
+    "wrong amount type",
+    () =>
+      transfer(
+        recipient,
+        payer,
+        contract,
+        "transfer",
+        nativeToScVal(10, { type: "u32" }),
+      ),
+  ],
+] as const)("rejects contract %s", (_, op) => {
+  expect(() =>
+    assertSoranTransactionRoute(build(op()).toXDR(), route(), network, context),
+  ).toThrow();
+});
+it("checks a collectible's contract, token ID, and full route", () => {
+  const nftContext = {
+    ...context,
+    isCollectible: true,
+    collectionAddress: contract,
+    tokenId: 42,
+  };
+  const nft = (to: string, tokenId: number) =>
+    build(
+      transfer(
+        to,
+        payer,
+        contract,
+        "transfer",
+        nativeToScVal(tokenId, { type: "u32" }),
+      ),
+    ).toXDR();
+  expect(() =>
+    assertSoranTransactionRoute(
+      nft(recipient, 42),
+      route(),
+      network,
+      nftContext,
+    ),
+  ).not.toThrow();
+  expect(() =>
+    assertSoranTransactionRoute(
+      nft(recipient, 43),
+      route(),
+      network,
+      nftContext,
+    ),
+  ).toThrow();
+  expect(() =>
+    assertSoranTransactionRoute(
+      nft(muxed, 42),
+      route(muxed),
+      network,
+      nftContext,
+    ),
+  ).toThrow();
+});
+it("rejects malformed envelopes and fee bumps", () => {
+  expect(() =>
+    assertSoranTransactionRoute("invalid", route(), network, context),
+  ).toThrow(/does not match/);
+  const bump = TransactionBuilder.buildFeeBumpTransaction(
+    payer,
+    "100",
+    build(),
+    network.networkPassphrase,
+  );
+  expect(() =>
+    assertSoranTransactionRoute(bump.toXDR(), route(), network, context),
+  ).toThrow();
+});
diff --git a/extension/src/popup/helpers/soran.ts b/extension/src/popup/helpers/soran.ts
new file mode 100644
index 0000000000..e936c4bd86
--- /dev/null
+++ b/extension/src/popup/helpers/soran.ts
@@ -0,0 +1,261 @@
+import {
+  Account,
+  Address,
+  BASE_FEE,
+  Contract,
+  MuxedAccount,
+  Networks,
+  StrKey,
+  TransactionBuilder,
+  nativeToScVal,
+  rpc,
+  scValToNative,
+  xdr,
+} from "stellar-sdk";
+import { NetworkDetails } from "@shared/constants/stellar";
+import { FederationMemoType } from "./federationMemo";
+import i18n from "./localizationConfig";
+
+// https://docs.soran.domains/api/onchain-resolution
+export const SORAN_TESTNET_LOOKUP =
+  "CDSORANQAJK35UV2HR63CMB6M5NYISHMUBTB6EQY2CZ3Y7HJDIOHRJWA";
+const SORAN_TESTNET_REGISTRY =
+  "CCSORANDPQINYOYB5SVO45WJP2LBBYKC72HHUIRVXB4J6RUZKDAUW7G4";
+const READ_SOURCE = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";
+const RPC_TIMEOUT_SECONDS = 20;
+const READ_TIMEOUT_SECONDS = 30;
+const DESTINATION_ABI = 2;
+const MAX_MEMO_BYTES = 28;
+const HASH_BYTES = 32;
+const NAME_LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+
+export interface SoranDestination {
+  address: string;
+  memo: string;
+  memoType: FederationMemoType | "";
+}
+
+export const normalizeSoranName = (input: string): string | null => {
+  const trimmed = input.trim();
+  if (/[^\x20-\x7e]/.test(trimmed)) return null;
+  const name = trimmed.toLowerCase();
+  const labels = name.split(".");
+  return labels.length === 2 && labels.every((label) => NAME_LABEL.test(label))
+    ? name
+    : null;
+};
+
+export const isSoranName = (input: string) =>
+  normalizeSoranName(input) !== null;
+
+const invalidDestination = () => new Error("Invalid Soran destination ABI");
+export const decodeUtf8 = (bytes: Uint8Array) =>
+  new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+
+const symbol = (value: xdr.ScVal): string => {
+  if (value.type !== "scvSymbol") throw invalidDestination();
+  return decodeUtf8(value.sym.bytes);
+};
+
+export const variant = (value: xdr.ScVal): [string, xdr.ScVal[]] => {
+  if (value.type !== "scvVec" || !value.value?.length) {
+    throw invalidDestination();
+  }
+  return [symbol(value.value[0]), value.value.slice(1)];
+};
+
+export const fields = (value: xdr.ScVal, expected: string[]) => {
+  if (value.type !== "scvMap" || !value.value) throw invalidDestination();
+  const entries = value.value;
+  if (
+    entries.length !== expected.length ||
+    entries.some((entry, index) => symbol(entry.key) !== expected[index])
+  ) {
+    throw invalidDestination();
+  }
+  return Object.fromEntries(
+    entries.map((entry) => [symbol(entry.key), entry.val]),
+  );
+};
+
+const decodeAddress = (value: xdr.ScVal, classicOnly = false) => {
+  if (value.type !== "scvAddress") throw invalidDestination();
+  const address = Address.fromScVal(value).toString();
+  if (
+    !StrKey.isValidEd25519PublicKey(address) &&
+    (classicOnly || !StrKey.isValidContract(address))
+  ) {
+    throw invalidDestination();
+  }
+  return address;
+};
+
+export const decodeSoranDestination = (value: xdr.ScVal): SoranDestination => {
+  const [tag, args] = variant(value);
+  if (args.length !== 1) throw invalidDestination();
+  if (tag === "Muxed") {
+    const payment = fields(args[0], ["account", "id"]);
+    const account = decodeAddress(payment.account, true);
+    if (payment.id.type !== "scvU64") throw invalidDestination();
+    return {
+      address: new MuxedAccount(
+        new Account(account, "0"),
+        String(scValToNative(payment.id)),
+      ).accountId(),
+      memo: "",
+      memoType: "",
+    };
+  }
+  if (tag !== "Direct") throw invalidDestination();
+  const payment = fields(args[0], ["address", "memo"]);
+  const address = decodeAddress(payment.address);
+  const [memoTag, memoArgs] = variant(payment.memo);
+  if (memoTag === "None" && memoArgs.length === 0) {
+    return { address, memo: "", memoType: "" };
+  }
+  if (!StrKey.isValidEd25519PublicKey(address) || memoArgs.length !== 1) {
+    throw invalidDestination();
+  }
+  const memo = memoArgs[0];
+  if (memoTag === "Id" && memo.type === "scvU64") {
+    return {
+      address,
+      memo: String(scValToNative(memo)),
+      memoType: FederationMemoType.Id,
+    };
+  }
+  if (memoTag === "Text" && memo.type === "scvString") {
+    if (!memo.str.bytes.length || memo.str.bytes.length > MAX_MEMO_BYTES) {
+      throw invalidDestination();
+    }
+    return {
+      address,
+      memo: decodeUtf8(memo.str.bytes),
+      memoType: FederationMemoType.Text,
+    };
+  }
+  if (
+    memoTag === "Hash" &&
+    memo.type === "scvBytes" &&
+    memo.value.value.length === HASH_BYTES
+  ) {
+    return {
+      address,
+      memo: Buffer.from(memo.value.value).toString("base64"),
+      memoType: FederationMemoType.Hash,
+    };
+  }
+  throw invalidDestination();
+};
+
+// Unsigned simulations only. Never submit or restore state from a display lookup.
+export const createSoranReader = (networkDetails: NetworkDetails) => {
+  if (
+    networkDetails.networkPassphrase !== Networks.TESTNET ||
+    !networkDetails.sorobanRpcUrl
+  ) {
+    throw new Error("Unsupported Soran network");
+  }
+  const server = new rpc.Server(networkDetails.sorobanRpcUrl, {
+    timeout: RPC_TIMEOUT_SECONDS,
+  });
+  return async (method: string, args: xdr.ScVal[] = []) => {
+    const tx = new TransactionBuilder(new Account(READ_SOURCE, "0"), {
+      fee: BASE_FEE,
+      networkPassphrase: networkDetails.networkPassphrase,
+    })
+      .addOperation(new Contract(SORAN_TESTNET_LOOKUP).call(method, ...args))
+      .setTimeout(READ_TIMEOUT_SECONDS)
+      .build();
+    const result = await server.simulateTransaction(
+      tx,
+      undefined,
+      undefined,
+      false,
+    );
+    if (
+      rpc.Api.isSimulationRestore(result) ||
+      !rpc.Api.isSimulationSuccess(result) ||
+      !result.result
+    ) {
+      throw new Error(
+        rpc.Api.isSimulationError(result)
+          ? result.error
+          : "Soran contract read unavailable",
+      );
+    }
+    return result.result.retval;
+  };
+};
+
+export const verifySoranDeployment = async (
+  view: ReturnType<typeof createSoranReader>,
+) => {
+  const [registry, version] = await Promise.all([
+    view("registry"),
+    view("version"),
+  ]);
+  if (
+    decodeAddress(registry) !== SORAN_TESTNET_REGISTRY ||
+    version.type !== "scvU32" ||
+    scValToNative(version) !== 2
+  ) {
+    throw new Error("Unsupported Soran deployment");
+  }
+};
+
+export const resolveSoranName = async (
+  input: string,
+  networkDetails: NetworkDetails,
+): Promise<SoranDestination & { name: string }> => {
+  const name = normalizeSoranName(input);
+  if (!name) throw new Error(i18n.t("Invalid Soran name"));
+  if (networkDetails.networkPassphrase !== Networks.TESTNET) {
+    throw new Error(i18n.t("Soran names are only available on Testnet"));
+  }
+  if (!networkDetails.sorobanRpcUrl) {
+    throw new Error(i18n.t("Soran lookup requires a Soroban RPC URL"));
+  }
+  try {
+    const view = createSoranReader(networkDetails);
+    const [registry, version, destinationVersion] = await Promise.all([
+      view("registry"),
+      view("version"),
+      view("destination_version"),
+    ]);
+    if (
+      decodeAddress(registry) !== SORAN_TESTNET_REGISTRY ||
+      version.type !== "scvU32" ||
+      scValToNative(version) !== DESTINATION_ABI ||
+      destinationVersion.type !== "scvU32" ||
+      scValToNative(destinationVersion) !== DESTINATION_ABI
+    ) {
+      throw new Error("Unsupported Soran deployment");
+    }
+    const result = await view("resolve_destination", [
+      nativeToScVal(name, { type: "string" }),
+    ]);
+    return { name, ...decodeSoranDestination(result) };
+  } catch {
+    throw new Error(
+      i18n.t("Unable to resolve Soran name. Check the name and try again."),
+    );
+  }
+};
+
+export const verifySoranDestination = async (
+  name: string,
+  expected: Omit<SoranDestination, "memoType"> & { memoType: string },
+  networkDetails: NetworkDetails,
+) => {
+  const current = await resolveSoranName(name, networkDetails);
+  if (
+    current.address !== expected.address ||
+    current.memo !== expected.memo ||
+    current.memoType !== expected.memoType
+  ) {
+    throw new Error(
+      i18n.t("Soran payment details changed. Select the recipient again."),
+    );
+  }
+};
diff --git a/extension/src/popup/helpers/soranHistory.ts b/extension/src/popup/helpers/soranHistory.ts
new file mode 100644
index 0000000000..82e4847a1b
--- /dev/null
+++ b/extension/src/popup/helpers/soranHistory.ts
@@ -0,0 +1,38 @@
+import type { OperationDataRow } from "popup/views/AccountHistory/hooks/useGetHistoryData";
+
+/** Only unambiguous counterparties get a name. Swaps/multi-party calls do not. */
+export const getHistoryCounterparty = (operation: OperationDataRow | null) => {
+  const metadata = operation?.metadata;
+  if (!metadata || metadata.transactionFailed || metadata.isSwap)
+    return undefined;
+  if (metadata.isInvokeHostFn && metadata.hasAssetDiffs) {
+    if (metadata.assetDiffs?.length !== 1) return undefined;
+    const diff = metadata.assetDiffs[0];
+    return diff.destination
+      ? {
+          address: diff.destination as string,
+          isReceiving: Boolean(diff.isCredit),
+        }
+      : undefined;
+  }
+  if (
+    metadata.isPayment ||
+    metadata.isCollectibleTransfer ||
+    metadata.type === "create_account"
+  ) {
+    const address = metadata.isReceiving ? metadata.from : metadata.to;
+    return address
+      ? {
+          address: address as string,
+          isReceiving: Boolean(metadata.isReceiving),
+        }
+      : undefined;
+  }
+  return undefined;
+};
+
+export const formatHistoryTimestamp = (createdAt: string, locale?: string) => {
+  const date = new Date(createdAt);
+  if (Number.isNaN(date.getTime())) return "—";
+  return `${date.toLocaleDateString(locale, { year: "numeric", month: "short", day: "numeric" })} • ${date.toLocaleTimeString(locale, { hour: "2-digit", minute: "2-digit" })}`;
+};
diff --git a/extension/src/popup/helpers/soranPrimary.ts b/extension/src/popup/helpers/soranPrimary.ts
new file mode 100644
index 0000000000..c5ff30c59b
--- /dev/null
+++ b/extension/src/popup/helpers/soranPrimary.ts
@@ -0,0 +1,217 @@
+import {
+  Address,
+  MuxedAccount,
+  StrKey,
+  nativeToScVal,
+  scValToNative,
+  xdr,
+} from "stellar-sdk";
+import { NetworkDetails } from "@shared/constants/stellar";
+import {
+  createSoranReader,
+  decodeUtf8,
+  fields,
+  normalizeSoranName,
+  variant,
+  verifySoranDeployment,
+  SORAN_TESTNET_LOOKUP,
+} from "./soran";
+
+export type SoranPrimaryResult =
+  | { status: "name"; name: string; ledger: number; timestamp: string }
+  | { status: "none"; ledger: number; timestamp: string }
+  | { status: "failed"; code?: number };
+
+export const encodeSoranIdentity = (address: string): xdr.ScVal => {
+  if (StrKey.isValidMed25519PublicKey(address)) {
+    const muxed = MuxedAccount.fromAddress(address, "0");
+    return nativeToScVal([
+      nativeToScVal("Muxed", { type: "symbol" }),
+      nativeToScVal(
+        {
+          account: new Address(muxed.baseAccount().accountId()).toScVal(),
+          id: nativeToScVal(BigInt(muxed.id()), { type: "u64" }),
+        },
+        { type: { account: ["symbol", null], id: ["symbol", null] } },
+      ),
+    ]);
+  }
+  if (
+    !StrKey.isValidEd25519PublicKey(address) &&
+    !StrKey.isValidContract(address)
+  ) {
+    throw new Error("Invalid Soran identity");
+  }
+  return nativeToScVal([
+    nativeToScVal("Direct", { type: "symbol" }),
+    new Address(address).toScVal(),
+  ]);
+};
+
+export const decodeSoranPrimaryBatch = (
+  value: xdr.ScVal,
+  count: number,
+): SoranPrimaryResult[] => {
+  const batch = fields(value, ["ledger", "results", "timestamp"]);
+  if (
+    batch.ledger.type !== "scvU32" ||
+    batch.timestamp.type !== "scvU64" ||
+    batch.results.type !== "scvVec" ||
+    !batch.results.value ||
+    batch.results.value.length !== count
+  ) {
+    throw new Error("Invalid Soran batch ABI");
+  }
+  const observation = {
+    ledger: Number(scValToNative(batch.ledger)),
+    timestamp: String(scValToNative(batch.timestamp)),
+  };
+  return batch.results.value.map((value) => {
+    const [tag, args] = variant(value);
+    if (tag === "None" && args.length === 0)
+      return { status: "none", ...observation };
+    if (
+      tag === "Failed" &&
+      args.length === 1 &&
+      args[0].type === "scvU32" &&
+      scValToNative(args[0]) > 0
+    ) {
+      return { status: "failed", code: Number(scValToNative(args[0])) };
+    }
+    if (tag === "Name" && args.length === 1 && args[0].type === "scvString") {
+      const name = decodeUtf8(args[0].str.bytes);
+      if (normalizeSoranName(name) === name)
+        return { status: "name", name, ...observation };
+    }
+    throw new Error("Invalid Soran primary name ABI");
+  });
+};
+
+export const readSoranPrimaryNames = async (
+  addresses: string[],
+  network: NetworkDetails,
+): Promise<SoranPrimaryResult[]> => {
+  if (!addresses.length) return [];
+  const view = createSoranReader(network);
+  await verifySoranDeployment(view);
+  const [version, limitValue, muxedVersion] = await Promise.all([
+    view("batch_read_version"),
+    view("primary_batch_limit"),
+    addresses.some((address) => StrKey.isValidMed25519PublicKey(address))
+      ? view("muxed_identity_version")
+      : undefined,
+  ]);
+  const limit = Number(scValToNative(limitValue));
+  if (
+    version.type !== "scvU32" ||
+    scValToNative(version) !== 3 ||
+    limitValue.type !== "scvU32" ||
+    !Number.isInteger(limit) ||
+    limit < 1 ||
+    limit > 16 ||
+    (muxedVersion &&
+      (muxedVersion.type !== "scvU32" || scValToNative(muxedVersion) !== 1))
+  ) {
+    throw new Error("Unsupported Soran batch capability");
+  }
+  const readBatch = async (batch: string[]): Promise<SoranPrimaryResult[]> => {
+    try {
+      const result = await view("primary_names", [
+        nativeToScVal(batch.map(encodeSoranIdentity)),
+      ]);
+      return decodeSoranPrimaryBatch(result, batch.length);
+    } catch (error) {
+      // Only a leading host budget error permits subdivision. Contract/item,
+      // transport, restoration and decoding errors remain failures.
+      if (
+        batch.length > 1 &&
+        error instanceof Error &&
+        /^HostError: Error\(Budget, ExceededLimit\)/.test(error.message)
+      ) {
+        const midpoint = Math.ceil(batch.length / 2);
+        return [
+          ...(await readBatch(batch.slice(0, midpoint))),
+          ...(await readBatch(batch.slice(midpoint))),
+        ];
+      }
+      return batch.map(() => ({ status: "failed" }));
+    }
+  };
+  const result: SoranPrimaryResult[] = [];
+  for (let offset = 0; offset < addresses.length; offset += limit) {
+    result.push(...(await readBatch(addresses.slice(offset, offset + limit))));
+  }
+  return result;
+};
+
+// Coalesce rows rendered together, retain full M identities, and bound memory.
+// Failed reads have a short retry delay; they are never cached as "no name".
+const cache = new Map<
+  string,
+  { expires: number; value: Promise<SoranPrimaryResult> }
+>();
+const pending = new Map<
+  string,
+  {
+    network: NetworkDetails;
+    rows: Map<string, Array<(result: SoranPrimaryResult) => void>>;
+  }
+>();
+const CACHE_LIMIT = 512;
+const CACHE_TTL_MS = 60_000;
+const FAILURE_TTL_MS = 5_000;
+export const getSoranPrimaryName = (
+  address: string,
+  network: NetworkDetails,
+): Promise<SoranPrimaryResult> => {
+  try {
+    encodeSoranIdentity(address);
+  } catch {
+    return Promise.resolve({ status: "failed" });
+  }
+  const groupKey = JSON.stringify([
+    network.networkPassphrase,
+    network.sorobanRpcUrl,
+    SORAN_TESTNET_LOOKUP,
+  ]);
+  const key = JSON.stringify([groupKey, address]);
+  const cached = cache.get(key);
+  if (cached && cached.expires > Date.now()) return cached.value;
+  const value = new Promise<SoranPrimaryResult>((resolve) => {
+    let group = pending.get(groupKey);
+    if (!group) {
+      group = { network, rows: new Map() };
+      pending.set(groupKey, group);
+      setTimeout(async () => {
+        const current = pending.get(groupKey)!;
+        pending.delete(groupKey);
+        const addresses = [...current.rows.keys()];
+        let results: SoranPrimaryResult[];
+        try {
+          results = await readSoranPrimaryNames(addresses, current.network);
+        } catch {
+          results = addresses.map(() => ({ status: "failed" }));
+        }
+        addresses.forEach((identity, index) =>
+          current.rows
+            .get(identity)!
+            .forEach((resolve) => resolve(results[index])),
+        );
+      }, 20);
+    }
+    const resolvers = group.rows.get(address) || [];
+    resolvers.push(resolve);
+    group.rows.set(address, resolvers);
+  });
+  cache.delete(key);
+  cache.set(key, { expires: Infinity, value });
+  if (cache.size > CACHE_LIMIT) cache.delete(cache.keys().next().value!);
+  void value.then((result) => {
+    const entry = cache.get(key);
+    if (entry?.value === value)
+      entry.expires =
+        Date.now() +
+        (result.status === "failed" ? FAILURE_TTL_MS : CACHE_TTL_MS);
+  });
+  return value;
+};
diff --git a/extension/src/popup/helpers/soranTransaction.ts b/extension/src/popup/helpers/soranTransaction.ts
new file mode 100644
index 0000000000..4eb7b8a371
--- /dev/null
+++ b/extension/src/popup/helpers/soranTransaction.ts
@@ -0,0 +1,148 @@
+import {
+  Address,
+  Asset,
+  Memo,
+  StrKey,
+  Transaction,
+  TransactionBuilder,
+  scValToNative,
+} from "stellar-sdk";
+import { NetworkDetails } from "@shared/constants/stellar";
+import { isNativeAssetId } from "@shared/helpers/assetIdentity";
+import { buildMemoFromFederation } from "./federationMemo";
+import { SoranDestination } from "./soran";
+import i18n from "./localizationConfig";
+
+export interface SoranTransactionContext {
+  publicKey: string;
+  asset: string;
+  isCollectible?: boolean;
+  collectionAddress?: string;
+  tokenId?: number | null;
+}
+
+const mismatch = () =>
+  new Error(
+    i18n.t(
+      "Transaction does not match the Soran payment details. Select the recipient again.",
+    ),
+  );
+export const unsupportedSoranMuxed = () =>
+  new Error(
+    i18n.t(
+      "This transfer cannot preserve the Soran muxed address. Choose another recipient.",
+    ),
+  );
+
+const expectedContract = (
+  context: SoranTransactionContext,
+  passphrase: string,
+) => {
+  if (context.isCollectible) return context.collectionAddress;
+  if (isNativeAssetId(context.asset))
+    return Asset.native().contractId(passphrase);
+  const [code, issuer] = context.asset.split(":");
+  return StrKey.isValidContract(issuer || "")
+    ? issuer
+    : new Asset(code, issuer).contractId(passphrase);
+};
+
+/** Bind the actual envelope to a verified route, not just to the UI's label.
+ * Only Freighter's single-operation payment/transfer shapes are accepted.
+ * Return the hash and route of the validated envelope for local history.
+ */
+export const assertSoranTransactionRoute = (
+  transactionXdr: string,
+  expected: Omit<SoranDestination, "memoType"> & { memoType: string },
+  network: NetworkDetails,
+  context: SoranTransactionContext,
+) => {
+  try {
+    const tx = TransactionBuilder.fromXDR(
+      transactionXdr,
+      network.networkPassphrase,
+    );
+    // Internal sends do not use fee-bump wrappers or multiple operations.
+    if (
+      !(tx instanceof Transaction) ||
+      tx.operations.length !== 1 ||
+      tx.source !== context.publicKey
+    )
+      throw mismatch();
+    if (!["", "text", "id", "hash"].includes(expected.memoType))
+      throw mismatch();
+    const memo = expected.memoType
+      ? buildMemoFromFederation(expected.memo, expected.memoType)
+      : Memo.none();
+    if (
+      (!expected.memoType && expected.memo) ||
+      tx.memo.toXDRObject().toXDR("base64") !==
+        memo.toXDRObject().toXDR("base64")
+    )
+      throw mismatch();
+    const op = tx.operations[0];
+    if (op.source && op.source !== context.publicKey) throw mismatch();
+    let destination: string;
+    if (op.type === "invokeHostFunction") {
+      if (
+        expected.memo ||
+        expected.memoType ||
+        op.func.type !== "hostFunctionTypeInvokeContract"
+      )
+        throw mismatch();
+      const invocation = op.func.invokeContract;
+      if (
+        Address.fromScAddress(invocation.contractAddress).toString() !==
+          expectedContract(context, network.networkPassphrase) ||
+        invocation.functionName.toString() !== "transfer" ||
+        invocation.args.length !== 3
+      )
+        throw mismatch();
+      const [from, to, value] = invocation.args;
+      if (Address.fromScVal(from).toString() !== context.publicKey)
+        throw mismatch();
+      destination = Address.fromScVal(to).toString();
+      if (context.isCollectible) {
+        if (
+          StrKey.isValidMed25519PublicKey(expected.address) ||
+          value.type !== "scvU32" ||
+          scValToNative(value) !== context.tokenId
+        )
+          throw mismatch();
+      } else if (value.type !== "scvI128" || scValToNative(value) <= BigInt(0))
+        throw mismatch();
+    } else {
+      // Contract assets and collectibles must never be replaced with a classic payment.
+      if (
+        context.isCollectible ||
+        StrKey.isValidContract(context.asset.split(":")[1] || "")
+      )
+        throw mismatch();
+      switch (op.type) {
+        case "payment":
+        case "pathPaymentStrictSend":
+        case "pathPaymentStrictReceive":
+          destination = op.destination;
+          break;
+        case "createAccount":
+          if (StrKey.isValidMed25519PublicKey(expected.address))
+            throw mismatch();
+          destination = op.destination;
+          break;
+        default:
+          throw mismatch();
+      }
+    }
+    if (destination !== expected.address) throw mismatch();
+    return {
+      transactionHash: Buffer.from(tx.hash()).toString("hex"),
+      destination,
+      memo: expected.memo,
+      memoType: expected.memoType || "none",
+      networkPassphrase: network.networkPassphrase,
+    };
+  } catch {
+    // Do not surface untrusted XDR, addresses or decoder exceptions in errors.
+    throw mismatch();
+  }
+};
diff --git a/extension/src/popup/hooks/__tests__/useSoranHistoryName.test.tsx b/extension/src/popup/hooks/__tests__/useSoranHistoryName.test.tsx
new file mode 100644
index 0000000000..d424ef4600
--- /dev/null
+++ b/extension/src/popup/hooks/__tests__/useSoranHistoryName.test.tsx
@@ -0,0 +1,100 @@
+import { act, renderHook, waitFor } from "@testing-library/react";
+import {
+  TESTNET_NETWORK_DETAILS,
+  MAINNET_NETWORK_DETAILS,
+} from "@shared/constants/stellar";
+import type { OperationDataRow } from "popup/views/AccountHistory/hooks/useGetHistoryData";
+import { getSoranPrimaryName } from "popup/helpers/soranPrimary";
+import { getSoranPaymentName } from "@shared/api/internal";
+import { useSoranHistoryName } from "../useSoranHistoryName";
+jest.mock("popup/helpers/soranPrimary", () => ({
+  getSoranPrimaryName: jest.fn(),
+}));
+jest.mock("@shared/api/internal", () => ({ getSoranPaymentName: jest.fn() }));
+const primary = jest.mocked(getSoranPrimaryName);
+const saved = jest.mocked(getSoranPaymentName);
+const operation = (destination = "recipient", extra = {}) =>
+  ({
+    id: "op",
+    metadata: {
+      publicKey: "payer",
+      isPayment: true,
+      isReceiving: false,
+      to: destination,
+      from: "sender",
+      transactionHash: "hash",
+      memo: "hello",
+      memoType: "text",
+      ...extra,
+    },
+  }) as unknown as OperationDataRow;
+beforeEach(() => {
+  jest.resetAllMocks();
+  primary.mockResolvedValue({
+    status: "name",
+    name: "current.nova",
+    ledger: 1,
+    timestamp: "1",
+  });
+  saved.mockResolvedValue({ name: "original.nova" });
+});
+it("keeps the current name distinct from the saved exact payment route", async () => {
+  const { result } = renderHook(() =>
+    useSoranHistoryName(operation(), TESTNET_NETWORK_DETAILS),
+  );
+  await waitFor(() =>
+    expect(result.current).toEqual({
+      currentName: "current.nova",
+      usedName: "original.nova",
+    }),
+  );
+  expect(saved).toHaveBeenCalledWith("payer", {
+    networkPassphrase: TESTNET_NETWORK_DETAILS.networkPassphrase,
+    transactionHash: "hash",
+    destination: "recipient",
+    memo: "hello",
+    memoType: "text",
+  });
+});
+it("discards stale responses immediately after a counterparty or network changes", async () => {
+  let finish: (value: Awaited<ReturnType<typeof getSoranPrimaryName>>) => void;
+  primary.mockReturnValueOnce(
+    new Promise((resolve) => {
+      finish = resolve;
+    }),
+  );
+  const { result, rerender } = renderHook(
+    ({ op, network }) => useSoranHistoryName(op, network),
+    { initialProps: { op: operation(), network: TESTNET_NETWORK_DETAILS } },
+  );
+  rerender({ op: operation("another"), network: MAINNET_NETWORK_DETAILS });
+  await act(async () => {
+    finish!({ status: "name", name: "stale.nova", ledger: 1, timestamp: "1" });
+  });
+  expect(result.current.currentName).toBeUndefined();
+  expect(primary).toHaveBeenCalledTimes(1);
+});
+it("uses the sender for incoming payments and does not claim a locally used name", async () => {
+  const { result } = renderHook(() =>
+    useSoranHistoryName(
+      operation("me", { isReceiving: true }),
+      TESTNET_NETWORK_DETAILS,
+    ),
+  );
+  await waitFor(() => expect(result.current.currentName).toBe("current.nova"));
+  expect(primary).toHaveBeenCalledWith("sender", TESTNET_NETWORK_DETAILS);
+  expect(saved).not.toHaveBeenCalled();
+  expect(result.current.usedName).toBeUndefined();
+});
+it("falls back to address-only when lookup or local storage is unavailable", async () => {
+  primary.mockResolvedValue({ status: "failed" });
+  saved.mockRejectedValue(new Error("storage error"));
+  const { result } = renderHook(() =>
+    useSoranHistoryName(operation(), TESTNET_NETWORK_DETAILS),
+  );
+  await act(async () => {});
+  expect(result.current).toEqual({
+    currentName: undefined,
+    usedName: undefined,
+  });
+});
diff --git a/extension/src/popup/hooks/useSoranHistoryName.ts b/extension/src/popup/hooks/useSoranHistoryName.ts
new file mode 100644
index 0000000000..46c10bf4d6
--- /dev/null
+++ b/extension/src/popup/hooks/useSoranHistoryName.ts
@@ -0,0 +1,91 @@
+import { useEffect, useState } from "react";
+import { Networks } from "stellar-sdk";
+import { getSoranPaymentName } from "@shared/api/internal";
+import { NetworkDetails } from "@shared/constants/stellar";
+import type { OperationDataRow } from "popup/views/AccountHistory/hooks/useGetHistoryData";
+import { getHistoryCounterparty } from "popup/helpers/soranHistory";
+import { getSoranPrimaryName } from "popup/helpers/soranPrimary";
+
+export const useSoranHistoryName = (
+  operation: OperationDataRow | null,
+  network: NetworkDetails,
+) => {
+  const counterparty = getHistoryCounterparty(operation);
+  const address = counterparty?.address;
+  const metadata = operation?.metadata;
+  const publicKey = metadata?.publicKey;
+  const transactionHash = metadata?.transactionHash;
+  const memo = metadata?.memo || "";
+  const memoType = metadata?.memoType || (memo ? undefined : "none");
+  const isReceiving = counterparty?.isReceiving;
+  const { networkPassphrase, sorobanRpcUrl } = network;
+  const key = JSON.stringify([
+    address,
+    isReceiving,
+    publicKey,
+    transactionHash,
+    memo,
+    memoType,
+    networkPassphrase,
+    sorobanRpcUrl,
+  ]);
+  const [current, setCurrent] = useState<{ key: string; name?: string }>();
+  const [used, setUsed] = useState<{ key: string; name?: string }>();
+
+  useEffect(() => {
+    if (!address || networkPassphrase !== Networks.TESTNET || !sorobanRpcUrl)
+      return;
+    let cancelled = false;
+    let timer: ReturnType<typeof setTimeout>;
+    const refresh = async () => {
+      const result = await getSoranPrimaryName(address, network);
+      if (cancelled) return;
+      setCurrent({
+        key,
+        name: result.status === "name" ? result.name : undefined,
+      });
+      timer = setTimeout(refresh, result.status === "failed" ? 10_000 : 61_000);
+    };
+    void refresh();
+    return () => {
+      cancelled = true;
+      clearTimeout(timer);
+    };
+  }, [key, address, networkPassphrase, sorobanRpcUrl, network]);
+
+  useEffect(() => {
+    if (!address || isReceiving || !publicKey || !transactionHash || !memoType)
+      return;
+    let cancelled = false;
+    void getSoranPaymentName(publicKey, {
+      networkPassphrase,
+      transactionHash,
+      destination: address,
+      memo,
+      memoType,
+    })
+      .then(({ name }) => {
+        if (!cancelled) setUsed({ key, name: name || undefined });
+      })
+      .catch(() => {
+        if (!cancelled) setUsed({ key });
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    key,
+    address,
+    isReceiving,
+    publicKey,
+    transactionHash,
+    networkPassphrase,
+    memo,
+    memoType,
+  ]);
+
+  return {
+    currentName: current?.key === key ? current.name : undefined,
+    usedName: used?.key === key ? used.name : undefined,
+  };
+};
diff --git a/extension/src/popup/locales/en/translation.json b/extension/src/popup/locales/en/translation.json
index 2dbd18ed10..e904ccebad 100644
--- a/extension/src/popup/locales/en/translation.json
+++ b/extension/src/popup/locales/en/translation.json
@@ -169,7 +169,9 @@
   "Create New Address": "Create New Address",
   "Create new wallet": "Create new wallet",
   "Cross-chain access to USDT": "Cross-chain access to USDT",
+  "Current account name": "Current account name",
   "Current Network": "Current Network",
+  "Current Soran name": "Current Soran name",
   "Custom": "Custom",
   "dApps": "dApps",
   "data entries": "data entries",
@@ -202,6 +204,7 @@
   "Enabling these may impact the security of your wallets and result in loss of funds": "Enabling these may impact the security of your wallets and result in loss of funds.",
   "Enter a Stellar Asset List compatible URL": "Enter a Stellar Asset List compatible URL",
   "Enter address": "Enter address",
+  "Enter address or Soran name": "Enter address or Soran name",
   "Enter an amount": "Enter an amount",
   "ENTER BIP PATH": "ENTER BIP PATH",
   "Enter details": "Enter details",
@@ -337,6 +340,7 @@
   "invalid destination address": "invalid destination address",
   "Invalid memo format": "Invalid memo format.",
   "Invalid mnemonic phrase": "Invalid mnemonic phrase",
+  "Invalid Soran name": "Invalid Soran name",
   "INVALID STELLAR ADDRESS": "INVALID STELLAR ADDRESS",
   "Invoke Contract": "Invoke Contract",
   "Issuer": "Issuer",
@@ -407,6 +411,7 @@
   "Muxed address not supported": "Muxed address not supported",
   "My Accounts": "My Accounts",
   "Name": "Name",
+  "Name used for this payment": "Name used for this payment",
   "Network": "Network",
   "Network fees": "Network fees",
   "Network icon": "Network icon",
@@ -517,6 +522,7 @@
   "Salt": "Salt",
   "Save": "Save",
   "Save failed!": "Save failed!",
+  "Saved on this device when you sent the payment.": "Saved on this device when you sent the payment.",
   "Search for asset name": "Search for asset name",
   "Search issuer public key, classic assets, SAC assets, and TI assets": "Search issuer public key, classic assets, SAC assets, and TI assets",
   "Search token name or address": "Search token name or address",
@@ -539,6 +545,7 @@
   "Sending": "Sending",
   "Sent": "Sent",
   "Sent Collectible": "Sent Collectible",
+  "Sent using {{name}}": "Sent using {{name}}",
   "Sent!": "Sent!",
   "Sequence #": "Sequence #",
   "Set default": "Set default",
@@ -570,6 +577,9 @@
   "Slippage": "Slippage",
   "Some destination accounts on the Stellar network require a memo to identify your payment.": "Some destination accounts on the Stellar network require a memo to identify your payment.",
   "Some of your assets may not appear, but they are still safe on the network!": "Some of your assets may not appear, but they are still safe on the network!",
+  "Soran lookup requires a Soroban RPC URL": "Soran lookup requires a Soroban RPC URL",
+  "Soran names are only available on Testnet": "Soran names are only available on Testnet",
+  "Soran payment details changed. Select the recipient again.": "Soran payment details changed. Select the recipient again.",
   "Soroban contract tokens aren't supported for swaps yet. Try searching for a Classic token instead.": "Soroban contract tokens aren't supported for swaps yet. Try searching for a Classic token instead.",
   "Soroban is temporarily experiencing issues": "Soroban is temporarily experiencing issues",
   "SOROBAN RPC URL": "SOROBAN RPC URL",
@@ -621,6 +631,7 @@
   "The destination account doesn't exist": "The destination account doesn't exist.",
   "The destination account doesn’t exist": "The destination account doesn’t exist",
   "The destination account must opt to accept this asset before receiving it.": "The destination account must opt to accept this asset before receiving it.",
+  "The memo is set by the Soran name": "The memo is set by the Soran name",
   "The requester expects you to sign this message on": "The requester expects you to sign this message on",
   "The secret phrase you entered is incorrect.": "The secret phrase you entered is incorrect.",
   "The signature returned by your Ledger could not be verified. Disconnect any other devices and try again. If this keeps happening, update the Stellar app on your Ledger.": "The signature returned by your Ledger could not be verified. Disconnect any other devices and try again. If this keeps happening, update the Stellar app on your Ledger.",
@@ -655,6 +666,7 @@
   "This token does not support muxed address (M-) as a target destination.": "This token does not support muxed address (M-) as a target destination.",
   "This token has been flagged as malicious for the following reasons.": "This token has been flagged as malicious for the following reasons.",
   "This token has been flagged as suspicious for the following reasons.": "This token has been flagged as suspicious for the following reasons.",
+  "This token transfer cannot preserve the Soran memo": "This token transfer cannot preserve the Soran memo",
   "This token was flagged as malicious": "This token was flagged as malicious",
   "This token was flagged as malicious (override active)": "This token was flagged as malicious (override active)",
   "This token was flagged as suspicious": "This token was flagged as suspicious",
@@ -666,6 +678,7 @@
   "This transaction was flagged as malicious (override active)": "This transaction was flagged as malicious (override active)",
   "This transaction was flagged as suspicious": "This transaction was flagged as suspicious",
   "This transaction was flagged as suspicious (override active)": "This transaction was flagged as suspicious (override active)",
+  "This transfer cannot preserve the Soran muxed address. Choose another recipient.": "This transfer cannot preserve the Soran muxed address. Choose another recipient.",
   "This will add a trustline to {{code}}": "This will add a trustline to {{code}}",
   "This will be used to unlock your wallet": "This will be used to unlock your wallet",
   "Timeout": "Timeout",
@@ -693,6 +706,7 @@
   "Transaction": "Transaction",
   "Transaction details": "Transaction details",
   "Transaction Details": "Transaction Details",
+  "Transaction does not match the Soran payment details. Select the recipient again.": "Transaction does not match the Soran payment details. Select the recipient again.",
   "Transaction failed": "Transaction failed",
   "Transaction Failed": "Transaction Failed",
   "Transaction Fee": "Transaction Fee",
@@ -714,6 +728,7 @@
   "Unable to load network details": "Unable to load network details",
   "Unable to migrate": "Unable to migrate",
   "Unable to parse assets lists": "Unable to parse assets lists",
+  "Unable to resolve Soran name. Check the name and try again.": "Unable to resolve Soran name. Check the name and try again.",
   "Unable to Scan": "Unable to Scan",
   "Unable to scan site": "Unable to scan site",
   "Unable to scan site for malicious behavior": "Unable to scan site for malicious behavior",
diff --git a/extension/src/popup/locales/pt/translation.json b/extension/src/popup/locales/pt/translation.json
index 464ae1a4c3..2d92b7ae07 100644
--- a/extension/src/popup/locales/pt/translation.json
+++ b/extension/src/popup/locales/pt/translation.json
@@ -169,7 +169,9 @@
   "Create New Address": "Criar Novo Endereço",
   "Create new wallet": "Criar nova carteira",
   "Cross-chain access to USDT": "Acesso cross-chain ao USDT",
+  "Current account name": "Nome atual da conta",
   "Current Network": "Rede Atual",
+  "Current Soran name": "Nome Soran atual",
   "Custom": "Personalizado",
   "dApps": "dApps",
   "data entries": "entradas de dados",
@@ -202,6 +204,7 @@
   "Enabling these may impact the security of your wallets and result in loss of funds": "Habilitar essas configurações pode impactar a segurança de suas carteiras e resultar em perda de fundos.",
   "Enter a Stellar Asset List compatible URL": "Inserir URL compatível com Stellar Asset List",
   "Enter address": "Inserir endereço",
+  "Enter address or Soran name": "Insira um endereço ou nome Soran",
   "Enter an amount": "Digite um valor",
   "ENTER BIP PATH": "INSERIR CAMINHO BIP",
   "Enter details": "Inserir detalhes",
@@ -337,6 +340,7 @@
   "invalid destination address": "endereço de destino inválido",
   "Invalid memo format": "Formato de memo inválido.",
   "Invalid mnemonic phrase": "Frase mnemônica inválida",
+  "Invalid Soran name": "Nome Soran inválido",
   "INVALID STELLAR ADDRESS": "ENDEREÇO STELLAR INVÁLIDO",
   "Invoke Contract": "Invocar Contrato",
   "Issuer": "Emissor",
@@ -407,6 +411,7 @@
   "Muxed address not supported": "Endereço muxed não suportado",
   "My Accounts": "Minhas Contas",
   "Name": "Nome",
+  "Name used for this payment": "Nome usado neste pagamento",
   "Network": "Rede",
   "Network fees": "Taxas de rede",
   "Network icon": "Ícone de rede",
@@ -517,6 +522,7 @@
   "Salt": "Salt",
   "Save": "Salvar",
   "Save failed!": "Falha ao salvar!",
+  "Saved on this device when you sent the payment.": "Salvo neste dispositivo quando você enviou o pagamento.",
   "Search for asset name": "Buscar por nome de ativo",
   "Search issuer public key, classic assets, SAC assets, and TI assets": "Buscar chave pública do issuer, assets clássicos, assets SAC e assets TI",
   "Search token name or address": "Buscar nome do token ou endereço",
@@ -539,6 +545,7 @@
   "Sending": "Enviando",
   "Sent": "Enviado",
   "Sent Collectible": "Colecionável Enviado",
+  "Sent using {{name}}": "Enviado usando {{name}}",
   "Sent!": "Enviado!",
   "Sequence #": "Sequência #",
   "Set default": "Definir padrão",
@@ -570,6 +577,9 @@
   "Slippage": "Deslizamento",
   "Some destination accounts on the Stellar network require a memo to identify your payment.": "Algumas contas de destino na rede Stellar exigem um memo para identificar seu pagamento.",
   "Some of your assets may not appear, but they are still safe on the network!": "Alguns de seus ativos podem não aparecer, mas ainda estão seguros na rede!",
+  "Soran lookup requires a Soroban RPC URL": "A consulta Soran requer uma URL RPC Soroban",
+  "Soran names are only available on Testnet": "Os nomes Soran estão disponíveis apenas na Testnet",
+  "Soran payment details changed. Select the recipient again.": "Os dados de pagamento Soran mudaram. Selecione o destinatário novamente.",
   "Soroban contract tokens aren't supported for swaps yet. Try searching for a Classic token instead.": "Tokens de contrato Soroban ainda não são suportados para trocas. Tente buscar um token Classic.",
   "Soroban is temporarily experiencing issues": "O Soroban está temporariamente com problemas",
   "SOROBAN RPC URL": "URL RPC SOROBAN",
@@ -621,6 +631,7 @@
   "The destination account doesn't exist": "A conta de destino não existe",
   "The destination account doesn’t exist": "A conta de destino não existe",
   "The destination account must opt to accept this asset before receiving it.": "A conta de destino deve optar por aceitar este ativo antes de recebê-lo.",
+  "The memo is set by the Soran name": "O memo é definido pelo nome Soran",
   "The requester expects you to sign this message on": "O solicitante espera que você assine esta mensagem em",
   "The secret phrase you entered is incorrect.": "A frase secreta que você inseriu está incorreta.",
   "The signature returned by your Ledger could not be verified. Disconnect any other devices and try again. If this keeps happening, update the Stellar app on your Ledger.": "Não foi possível verificar a assinatura retornada pelo seu Ledger. Desconecte outros dispositivos e tente novamente. Se o problema persistir, atualize o app Stellar no seu Ledger.",
@@ -655,6 +666,7 @@
   "This token does not support muxed address (M-) as a target destination.": "Este token não suporta endereço muxed (M-) como destino.",
   "This token has been flagged as malicious for the following reasons.": "Este token foi marcado como malicioso pelos seguintes motivos.",
   "This token has been flagged as suspicious for the following reasons.": "Este token foi marcado como suspeito pelos seguintes motivos.",
+  "This token transfer cannot preserve the Soran memo": "Esta transferência de token não pode preservar o memo Soran",
   "This token was flagged as malicious": "Este token foi marcado como malicioso",
   "This token was flagged as malicious (override active)": "Este token foi sinalizado como malicioso (substituição ativa)",
   "This token was flagged as suspicious": "Este token foi marcado como suspeito",
@@ -666,6 +678,7 @@
   "This transaction was flagged as malicious (override active)": "Esta transação foi sinalizada como maliciosa (substituição ativa)",
   "This transaction was flagged as suspicious": "Esta transação foi marcada como suspeita",
   "This transaction was flagged as suspicious (override active)": "Esta transação foi sinalizada como suspeita (substituição ativa)",
+  "This transfer cannot preserve the Soran muxed address. Choose another recipient.": "Esta transferência não pode preservar o endereço muxed Soran. Escolha outro destinatário.",
   "This will add a trustline to {{code}}": "Isto vai adicionar uma linha de confiança para {{code}}",
   "This will be used to unlock your wallet": "Isso será usado para desbloquear sua carteira",
   "Timeout": "Tempo esgotado",
@@ -693,6 +706,7 @@
   "Transaction": "Transação",
   "Transaction details": "Detalhes da transação",
   "Transaction Details": "Detalhes da Transação",
+  "Transaction does not match the Soran payment details. Select the recipient again.": "A transação não corresponde aos dados de pagamento Soran. Selecione o destinatário novamente.",
   "Transaction failed": "Transação falhou",
   "Transaction Failed": "Transação Falhou",
   "Transaction Fee": "Taxa de Transação",
@@ -714,6 +728,7 @@
   "Unable to load network details": "Não foi possível carregar os detalhes da rede",
   "Unable to migrate": "Não foi possível migrar",
   "Unable to parse assets lists": "Não foi possível fazer parse das asset lists",
+  "Unable to resolve Soran name. Check the name and try again.": "Não foi possível resolver o nome Soran. Verifique o nome e tente novamente.",
   "Unable to Scan": "Não foi possível verificar",
   "Unable to scan site": "Não foi possível verificar o site",
   "Unable to scan site for malicious behavior": "Não foi possível escanear o site para comportamento malicioso",
diff --git a/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx b/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx
index a653051826..ddf08c9847 100644
--- a/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx
+++ b/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx
@@ -275,3 +275,22 @@ describe("getRowDataByOpType - Soroban transfer identity", () => {
     expect(row.amount).toContain("XLM");
   });
 });
+
+it("preserves a muxed sender and transaction reference for history naming", async () => {
+  const op = buildPaymentOperation({ to: PUBLIC_KEY, from: COUNTERPARTY });
+  op.from_muxed = new (await import("stellar-sdk")).MuxedAccount(
+    new (await import("stellar-sdk")).Account(COUNTERPARTY, "0"),
+    "42",
+  ).accountId();
+  op.transaction_attr.hash = "a".repeat(64);
+  op.transaction_attr.memo_type = "text";
+  op.transaction_attr.memo = "hello";
+  const row = await callGetRowData(op);
+  expect(row.metadata).toMatchObject({
+    from: op.from_muxed,
+    transactionHash: "a".repeat(64),
+    memoType: "text",
+    memo: "hello",
+    publicKey: PUBLIC_KEY,
+  });
+});
diff --git a/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx b/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx
index 6cc5371609..47a09a3074 100644
--- a/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx
+++ b/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx
@@ -602,6 +602,9 @@ export const getRowDataByOpType = async (
   const baseMetadata = {
     createdAt,
     feeCharged: fee_charged,
+    transactionHash: operation.transaction_hash || transaction_attr.hash,
+    memoType: transaction_attr.memo_type,
+    publicKey,
     memo,
     type,
     isDustPayment: operation.isDustPayment,
@@ -692,7 +695,7 @@ export const getRowDataByOpType = async (
 
   if (isPayment) {
     const destination = to_muxed || to || "";
-    const sender = from || "";
+    const sender = operation.from_muxed || from || "";
 
     // default to Sent if a payment to self.
     // isSameAccount resolves muxed (M...) addresses to their base (G...) account,
diff --git a/extension/src/popup/views/__tests__/Account.test.tsx b/extension/src/popup/views/__tests__/Account.test.tsx
index 9258558bdf..6527a7494b 100644
--- a/extension/src/popup/views/__tests__/Account.test.tsx
+++ b/extension/src/popup/views/__tests__/Account.test.tsx
@@ -768,7 +768,7 @@ describe("Account view", () => {
       expect(screen.getByTestId("TransactionDetailModal")).toBeDefined();
       expect(
         screen.getByTestId("TransactionDetailModal__subtitle-date"),
-      ).toHaveTextContent("Oct 07 2025");
+      ).toHaveTextContent("Oct 7, 2025");
       expect(screen.getByTestId("AssetDiff__amount-0")).toHaveTextContent(
         "100 USDC",
       );

From 2eba87019fd92115571cc88d07df64a2e6f80970 Mon Sep 17 00:00:00 2001
From: flarcos <onadekogbolahan@gmail.com>
Date: Sat, 12 Sep 2026 18:51:21 +0100
Subject: [PATCH 02/10] Fix Soran RPC timeouts and collectible history names

---
 .../src/popup/helpers/__tests__/soran.test.ts | 46 +++++++++++++++
 .../helpers/__tests__/soranHistory.test.ts    | 25 +++++++++
 extension/src/popup/helpers/soran.ts          |  8 +--
 extension/src/popup/helpers/soranHistory.ts   |  5 ++
 .../__tests__/useGetHistoryData.test.tsx      | 56 ++++++++++++++++++-
 .../hooks/useGetHistoryData.tsx               |  2 +
 6 files changed, 136 insertions(+), 6 deletions(-)

diff --git a/extension/src/popup/helpers/__tests__/soran.test.ts b/extension/src/popup/helpers/__tests__/soran.test.ts
index b6740e4765..a67bfe5575 100644
--- a/extension/src/popup/helpers/__tests__/soran.test.ts
+++ b/extension/src/popup/helpers/__tests__/soran.test.ts
@@ -4,6 +4,7 @@ import {
   MAINNET_NETWORK_DETAILS,
 } from "@shared/constants/stellar";
 import {
+  createSoranReader,
   decodeSoranDestination,
   normalizeSoranName,
   resolveSoranName,
@@ -187,3 +188,48 @@ describe("direct Soroban reads", () => {
     ).rejects.toThrow("payment details changed");
   });
 });
+
+describe("Soran RPC transport timeout", () => {
+  beforeEach(() => jest.useFakeTimers());
+  afterEach(() => {
+    jest.restoreAllMocks();
+    jest.useRealTimers();
+  });
+
+  it.each(["resolve_destination", "primary_names"])(
+    "aborts a stalled %s request after 20 seconds, not 20 milliseconds",
+    async (method) => {
+      // Make native timeout signals controllable by Jest's clock.
+      jest.spyOn(AbortSignal, "timeout").mockImplementation((milliseconds) => {
+        const controller = new AbortController();
+        setTimeout(
+          () => controller.abort(new DOMException("Timed out", "TimeoutError")),
+          milliseconds,
+        );
+        return controller.signal;
+      });
+      const fetchMock = jest.spyOn(globalThis, "fetch").mockImplementation(
+        (_url, options) =>
+          new Promise((_resolve, reject) => {
+            options?.signal?.addEventListener("abort", () =>
+              reject(options.signal?.reason),
+            );
+          }),
+      );
+      // Exercise the real SDK HTTP transport; only the network is stubbed.
+      const read = createSoranReader(TESTNET_NETWORK_DETAILS);
+      const rejected = jest.fn();
+      const result = read(method).catch(rejected);
+      await jest.advanceTimersByTimeAsync(19_999);
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      expect(rejected).not.toHaveBeenCalled();
+      await jest.advanceTimersByTimeAsync(1);
+      expect(rejected).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: expect.stringMatching(/timeout of 20000\s?ms exceeded/),
+        }),
+      );
+      await result;
+    },
+  );
+});
diff --git a/extension/src/popup/helpers/__tests__/soranHistory.test.ts b/extension/src/popup/helpers/__tests__/soranHistory.test.ts
index db0819ca18..81a800b256 100644
--- a/extension/src/popup/helpers/__tests__/soranHistory.test.ts
+++ b/extension/src/popup/helpers/__tests__/soranHistory.test.ts
@@ -64,3 +64,28 @@ it.each(["en-GB", "en-US", "pt-BR"])(
 );
 it("handles an unavailable timestamp", () =>
   expect(formatHistoryTimestamp("bad")).toBe("—"));
+
+it.each([
+  { from: "sender", to: "me", isReceiving: true, address: "sender" },
+  { from: "me", to: "recipient", isReceiving: false, address: "recipient" },
+])("selects the collectible counterparty: %j", ({ address, ...metadata }) => {
+  expect(
+    getHistoryCounterparty(
+      operation({ isCollectibleTransfer: true, ...metadata }),
+    ),
+  ).toEqual({ address, isReceiving: metadata.isReceiving });
+});
+it.each([
+  { from: "sender", to: "me" },
+  { to: "me", isReceiving: true },
+  { from: "me", isReceiving: false },
+])(
+  "omits a collectible name when direction or counterparty is missing: %j",
+  (metadata) => {
+    expect(
+      getHistoryCounterparty(
+        operation({ isCollectibleTransfer: true, ...metadata }),
+      ),
+    ).toBeUndefined();
+  },
+);
diff --git a/extension/src/popup/helpers/soran.ts b/extension/src/popup/helpers/soran.ts
index e936c4bd86..024addabba 100644
--- a/extension/src/popup/helpers/soran.ts
+++ b/extension/src/popup/helpers/soran.ts
@@ -22,7 +22,7 @@ export const SORAN_TESTNET_LOOKUP =
 const SORAN_TESTNET_REGISTRY =
   "CCSORANDPQINYOYB5SVO45WJP2LBBYKC72HHUIRVXB4J6RUZKDAUW7G4";
 const READ_SOURCE = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";
-const RPC_TIMEOUT_SECONDS = 20;
+const RPC_TIMEOUT_MS = 20_000;
 const READ_TIMEOUT_SECONDS = 30;
 const DESTINATION_ABI = 2;
 const MAX_MEMO_BYTES = 28;
@@ -156,9 +156,9 @@ export const createSoranReader = (networkDetails: NetworkDetails) => {
   ) {
     throw new Error("Unsupported Soran network");
   }
-  const server = new rpc.Server(networkDetails.sorobanRpcUrl, {
-    timeout: RPC_TIMEOUT_SECONDS,
-  });
+  const server = new rpc.Server(networkDetails.sorobanRpcUrl);
+  // SDK v17 reads transport timeouts from the HTTP client, in milliseconds.
+  server.httpClient.defaults.timeout = RPC_TIMEOUT_MS;
   return async (method: string, args: xdr.ScVal[] = []) => {
     const tx = new TransactionBuilder(new Account(READ_SOURCE, "0"), {
       fee: BASE_FEE,
diff --git a/extension/src/popup/helpers/soranHistory.ts b/extension/src/popup/helpers/soranHistory.ts
index 82e4847a1b..e18cd2a15c 100644
--- a/extension/src/popup/helpers/soranHistory.ts
+++ b/extension/src/popup/helpers/soranHistory.ts
@@ -20,6 +20,11 @@ export const getHistoryCounterparty = (operation: OperationDataRow | null) => {
     metadata.isCollectibleTransfer ||
     metadata.type === "create_account"
   ) {
+    if (
+      metadata.isCollectibleTransfer &&
+      typeof metadata.isReceiving !== "boolean"
+    )
+      return undefined;
     const address = metadata.isReceiving ? metadata.from : metadata.to;
     return address
       ? {
diff --git a/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx b/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx
index ddf08c9847..5b79a2ae6b 100644
--- a/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx
+++ b/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx
@@ -5,7 +5,8 @@ import { SorobanTokenInterface } from "@shared/constants/soroban/token";
 import { HistoryItemOperation } from "popup/components/accountHistory/HistoryItem";
 import * as sorobanHelpers from "popup/helpers/soroban";
 import { AssetType } from "@shared/api/types/account-balance";
-import { getRowDataByOpType } from "../useGetHistoryData";
+import { getHistoryCounterparty } from "popup/helpers/soranHistory";
+import { getRowDataByOpType, CollectibleLookupMap } from "../useGetHistoryData";
 
 // Base account owned by the wallet and its muxed (M...) forms.
 const PUBLIC_KEY = "GAJVUHQV535IYW25XBTWTCUXNHLQN4F2PGIPOOX4DDKL2UPNXUHWU7B3";
@@ -51,6 +52,7 @@ const CONTRACT_ID = "CAAQCAIBAEAQCAIBAEAQCAIBAEAQCAIBAEAQCAIBAEAQCAIBAEAQC526";
 const callGetRowData = (
   operation: HistoryItemOperation,
   balances: AssetType[] = [],
+  collectibles: CollectibleLookupMap = new Map(),
 ) =>
   getRowDataByOpType(
     PUBLIC_KEY,
@@ -60,7 +62,7 @@ const callGetRowData = (
     {},
     fetchTokenDetails,
     {},
-    new Map(),
+    collectibles,
     [],
   );
 
@@ -294,3 +296,53 @@ it("preserves a muxed sender and transaction reference for history naming", asyn
     publicKey: PUBLIC_KEY,
   });
 });
+
+describe("collectible history naming", () => {
+  afterEach(() => jest.restoreAllMocks());
+
+  it.each([
+    { from: COUNTERPARTY, to: PUBLIC_KEY, isReceiving: true },
+    { from: PUBLIC_KEY, to: COUNTERPARTY, isReceiving: false },
+  ])(
+    "preserves the sender and direction: %j",
+    async ({ from, to, isReceiving }) => {
+      jest
+        .spyOn(sorobanHelpers, "getAttrsFromSorobanHorizonOp")
+        .mockReturnValue({
+          fnName: SorobanTokenInterface.transfer,
+          contractId: CONTRACT_ID,
+          from,
+          to,
+          tokenId: 1,
+        });
+      const collectibles: CollectibleLookupMap = new Map([
+        [
+          `${CONTRACT_ID}:1`,
+          {
+            collectionAddress: CONTRACT_ID,
+            collectionName: "Test collection",
+            tokenId: "1",
+            owner: to,
+            tokenUri: "",
+            metadata: null,
+          },
+        ],
+      ]);
+      const row = await callGetRowData(
+        buildInvokeHostFnOperation(),
+        [],
+        collectibles,
+      );
+      expect(row.metadata).toMatchObject({
+        isCollectibleTransfer: true,
+        from,
+        to,
+        isReceiving,
+      });
+      expect(getHistoryCounterparty(row)).toEqual({
+        address: COUNTERPARTY,
+        isReceiving,
+      });
+    },
+  );
+});
diff --git a/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx b/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx
index 47a09a3074..482bcd8598 100644
--- a/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx
+++ b/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx
@@ -936,7 +936,9 @@ export const getRowDataByOpType = async (
             ...baseMetadata,
             isInvokeHostFn,
             isCollectibleTransfer: true,
+            from: attrs.from,
             to: actualDestination,
+            isReceiving,
             amount: `#${collectible.tokenId}`,
             collectionName: collectible.collectionName,
             collectionTokenId: collectible.tokenId,

From 3334526a1b7c538e286e3d33d31e8c24cc07cb07 Mon Sep 17 00:00:00 2001
From: flarcos <onadekogbolahan@gmail.com>
Date: Sat, 12 Sep 2026 19:07:39 +0100
Subject: [PATCH 03/10] Fix recipient selection races and annotation read
 ordering

---
 .../__tests__/soranPaymentNames.test.ts       |  40 ++++
 .../handlers/soranPaymentNames.ts             |   1 +
 .../SendTo/__tests__/SendTo.races.test.tsx    | 199 ++++++++++++++++++
 .../__tests__/useSendToData.soran.test.tsx    |  28 ++-
 .../send/SendTo/hooks/useSendToData.tsx       |  20 +-
 .../popup/components/send/SendTo/index.tsx    |  58 ++++-
 6 files changed, 327 insertions(+), 19 deletions(-)
 create mode 100644 extension/src/popup/components/send/SendTo/__tests__/SendTo.races.test.tsx

diff --git a/extension/src/background/messageListener/handlers/__tests__/soranPaymentNames.test.ts b/extension/src/background/messageListener/handlers/__tests__/soranPaymentNames.test.ts
index 4ee0f9ef1c..1b63cb031b 100644
--- a/extension/src/background/messageListener/handlers/__tests__/soranPaymentNames.test.ts
+++ b/extension/src/background/messageListener/handlers/__tests__/soranPaymentNames.test.ts
@@ -137,3 +137,43 @@ it("contains storage failures without failing a successful payment", async () =>
     await getSoranPaymentName({ request: readRequest, localStore }),
   ).toEqual({ name: null });
 });
+
+it.each([false, true])(
+  "waits for an earlier pending save (storage failure: %s)",
+  async (fails) => {
+    let finish!: () => void;
+    let started!: () => void;
+    const writing = new Promise<void>((resolve) => {
+      started = resolve;
+    });
+    const gate = new Promise<void>((resolve) => {
+      finish = resolve;
+    });
+    jest
+      .mocked(localStore.setItem)
+      .mockImplementationOnce(async (key, value) => {
+        started();
+        await gate;
+        if (fails) throw new Error("disk error");
+        data[key] = value;
+      });
+    const save = saveSoranPaymentName({ request: saveRequest, localStore });
+    await writing;
+    const readFinished = jest.fn();
+    const read = getSoranPaymentName({ request: readRequest, localStore }).then(
+      readFinished,
+    );
+    await Promise.resolve();
+    await Promise.resolve();
+    const earlyReads = readFinished.mock.calls.length;
+    const storageReads = jest.mocked(localStore.getItem).mock.calls.length;
+    finish();
+    await Promise.all([save, read]);
+    expect(earlyReads).toBe(0);
+    // Only the save may read storage before its write completes.
+    expect(storageReads).toBe(1);
+    expect(readFinished).toHaveBeenCalledWith({
+      name: fails ? null : "alice.nova",
+    });
+  },
+);
diff --git a/extension/src/background/messageListener/handlers/soranPaymentNames.ts b/extension/src/background/messageListener/handlers/soranPaymentNames.ts
index 494447e9d2..1689a7cc0e 100644
--- a/extension/src/background/messageListener/handlers/soranPaymentNames.ts
+++ b/extension/src/background/messageListener/handlers/soranPaymentNames.ts
@@ -77,6 +77,7 @@ export const getSoranPaymentName = async ({
     if (!validReference(request.activePublicKey, request.payment))
       return { name: null };
     const key = soranPaymentKey(request.activePublicKey!, request.payment);
+    await writes;
     const stored: StoredName[] =
       (await localStore.getItem(SORAN_PAYMENT_NAMES)) || [];
     const name = stored.find((item) => item.key === key)?.name;
diff --git a/extension/src/popup/components/send/SendTo/__tests__/SendTo.races.test.tsx b/extension/src/popup/components/send/SendTo/__tests__/SendTo.races.test.tsx
new file mode 100644
index 0000000000..9095a79a49
--- /dev/null
+++ b/extension/src/popup/components/send/SendTo/__tests__/SendTo.races.test.tsx
@@ -0,0 +1,199 @@
+import React from "react";
+import { act, fireEvent, render, screen } from "@testing-library/react";
+import { MemoryRouter } from "react-router-dom";
+import { Federation } from "stellar-sdk";
+import { SendTo } from "..";
+import { saveDestination } from "popup/ducks/transactionSubmission";
+
+const mockPayer = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";
+const mockAlice = "GBHKTFVBDUA6RYP5JM4SPZ76OXYAAHV4QHUOFV4S4TK342FMVGPHA2WN";
+const mockBob = "GBES5UHJYI445RV4XBGWHZOMBW4RYXBHOX47ZNZAJZAH2WP42ZEP2DYQ";
+const mockDispatch = jest.fn();
+jest.mock("react-redux", () => ({
+  useDispatch: () => mockDispatch,
+  useSelector: (selector: () => unknown) => selector(),
+}));
+jest.mock("popup/ducks/accountServices", () => ({
+  publicKeySelector: () => mockPayer,
+  allAccountsSelector: () => [{ publicKey: mockBob, name: "Other wallet" }],
+}));
+jest.mock("popup/ducks/transactionSubmission", () => ({
+  transactionDataSelector: () => ({
+    destination: "",
+    federationAddress: "",
+    asset: "native",
+    isCollectible: false,
+  }),
+  saveDestination: jest.fn((value) => ({ type: "destination", value })),
+  saveDestinationAsset: jest.fn(),
+  saveFederationAddress: jest.fn(),
+  saveMemoAndType: jest.fn(),
+  saveRecipientName: jest.fn(),
+}));
+jest.mock("helpers/hooks/useGetBalances", () => ({
+  useGetBalances: () => ({ fetchData: async () => ({ isFunded: true }) }),
+}));
+jest.mock("helpers/hooks/useGetAppData", () => ({
+  AppDataType: { RESOLVED: "resolved", REROUTE: "re-route" },
+  useGetAppData: () => ({
+    fetchData: async () => ({
+      type: "resolved",
+      account: { publicKey: mockPayer, applicationState: "APPLICATION_READY" },
+      settings: {
+        networkDetails: require("@shared/constants/stellar")
+          .TESTNET_NETWORK_DETAILS,
+      },
+    }),
+  }),
+}));
+jest.mock("@shared/api/internal", () => ({
+  loadRecentAddresses: async () => ({
+    recentAddresses: ["alice*example.com", "bob*example.com", "alice.nova"],
+  }),
+}));
+jest.mock("popup/helpers/account", () => ({
+  getBaseAccount: async (address: string) => address,
+}));
+jest.mock("popup/helpers/soroban", () => ({
+  isContractId: (address: string) => address.startsWith("C"),
+}));
+jest.mock("popup/helpers/route", () => ({ reRouteOnboarding: jest.fn() }));
+jest.mock("popup/components/SubviewHeader", () => ({
+  SubviewHeader: ({ customBackAction }: { customBackAction: () => void }) => (
+    <button onClick={customBackAction}>Back</button>
+  ),
+}));
+jest.mock("popup/components/identicons/IdenticonImg", () => ({
+  IdenticonImg: () => null,
+}));
+jest.mock("popup/helpers/localizationConfig", () => ({
+  __esModule: true,
+  default: { t: (key: string) => key },
+}));
+jest.mock("react-i18next", () => ({
+  useTranslation: () => ({ t: (key: string) => key }),
+}));
+
+const deferred = () => {
+  let resolve!: (value: { account_id: string }) => void;
+  let reject!: (error: Error) => void;
+  const promise = new Promise<{ account_id: string }>((done, fail) => {
+    resolve = done;
+    reject = fail;
+  });
+  return { promise, resolve, reject };
+};
+const mount = async () => {
+  const next = jest.fn();
+  const back = jest.fn();
+  const view = render(
+    <MemoryRouter>
+      <SendTo goBack={back} goToNext={next} />
+    </MemoryRouter>,
+  );
+  await act(async () => {
+    await jest.advanceTimersByTimeAsync(400);
+  });
+  expect(screen.getByText("alice*example.com")).toBeInTheDocument();
+  return { next, back, ...view };
+};
+const click = async (text: string) => {
+  await act(async () => {
+    fireEvent.click(screen.getByText(text));
+  });
+};
+beforeEach(() => {
+  jest.clearAllMocks();
+  jest.useFakeTimers();
+});
+afterEach(() => {
+  jest.restoreAllMocks();
+  jest.useRealTimers();
+});
+
+it.each(["older first", "older last", "older fails"])(
+  "only advances to the latest recent recipient: %s",
+  async (order) => {
+    const first = deferred();
+    const second = deferred();
+    jest
+      .spyOn(Federation.Server, "resolve")
+      .mockImplementation((name) =>
+        name === "alice*example.com" ? first.promise : second.promise,
+      );
+    const { next } = await mount();
+    await click("alice*example.com");
+    await click("bob*example.com");
+    if (order === "older first") {
+      await act(async () => {
+        first.resolve({ account_id: mockAlice });
+      });
+      expect(next).not.toHaveBeenCalled();
+    }
+    await act(async () => {
+      second.resolve({ account_id: mockBob });
+    });
+    await act(async () => {
+      if (order === "older fails") first.reject(new Error("late lookup error"));
+      else first.resolve({ account_id: mockAlice });
+    });
+    expect(next).toHaveBeenCalledTimes(1);
+    expect(saveDestination).toHaveBeenCalledTimes(1);
+    expect(saveDestination).toHaveBeenCalledWith(mockBob);
+    expect(screen.getByTestId("send-to-input")).toHaveValue("");
+  },
+);
+
+it.each(["typing", "Soran recent", "my account", "back", "unmount"])(
+  "cancels a pending recent lookup on %s",
+  async (action) => {
+    const first = deferred();
+    jest.spyOn(Federation.Server, "resolve").mockReturnValue(first.promise);
+    const { next, back, unmount } = await mount();
+    await click("alice*example.com");
+    if (action === "typing") {
+      await act(async () => {
+        fireEvent.change(screen.getByTestId("send-to-input"), {
+          target: { value: mockBob },
+        });
+      });
+    } else if (action === "Soran recent") await click("alice.nova");
+    else if (action === "my account") {
+      await act(async () => {
+        fireEvent.click(screen.getByTestId("my-account-button"));
+      });
+    } else if (action === "back") await click("Back");
+    else unmount();
+    await act(async () => {
+      first.resolve({ account_id: mockAlice });
+    });
+    expect(next).toHaveBeenCalledTimes(action === "my account" ? 1 : 0);
+    expect(saveDestination).not.toHaveBeenCalledWith(mockAlice);
+    if (action === "my account")
+      expect(saveDestination).toHaveBeenCalledWith(mockBob);
+    if (action === "back") expect(back).toHaveBeenCalledTimes(1);
+    if (action === "typing")
+      expect(screen.getByTestId("send-to-input")).toHaveValue(mockBob);
+    if (action === "Soran recent")
+      expect(screen.getByTestId("send-to-input")).toHaveValue("alice.nova");
+  },
+);
+
+it("does not start a superseded debounced lookup after selecting a recent", async () => {
+  const resolve = jest
+    .spyOn(Federation.Server, "resolve")
+    .mockResolvedValue({ account_id: mockBob });
+  const { next } = await mount();
+  await act(async () => {
+    fireEvent.change(screen.getByTestId("send-to-input"), {
+      target: { value: "alice*example.com" },
+    });
+  });
+  await click("bob*example.com");
+  await act(async () => {
+    await jest.advanceTimersByTimeAsync(500);
+  });
+  expect(resolve).toHaveBeenCalledTimes(1);
+  expect(resolve).toHaveBeenCalledWith("bob*example.com");
+  expect(next).toHaveBeenCalledTimes(1);
+});
diff --git a/extension/src/popup/components/send/SendTo/hooks/__tests__/useSendToData.soran.test.tsx b/extension/src/popup/components/send/SendTo/hooks/__tests__/useSendToData.soran.test.tsx
index fa35e8cdc9..6419681da5 100644
--- a/extension/src/popup/components/send/SendTo/hooks/__tests__/useSendToData.soran.test.tsx
+++ b/extension/src/popup/components/send/SendTo/hooks/__tests__/useSendToData.soran.test.tsx
@@ -144,7 +144,7 @@ it("ignores an older lookup that completes after the next recipient", async () =
   });
   await act(async () => {
     finishFirst(payment);
-    await first;
+    expect(await first).toBeUndefined();
   });
   expect(result.current.state.data).toMatchObject({
     validatedAddress: G,
@@ -172,3 +172,29 @@ it("rejects collectible muxed destinations before balance loading", async () =>
   );
   expect(mockFetchBalances).not.toHaveBeenCalled();
 });
+
+it.each([false, true])(
+  "returns no result after cancellation (lookup failure: %s)",
+  async (fails) => {
+    let finish!: () => void;
+    resolve.mockImplementationOnce(
+      () =>
+        new Promise((done, reject) => {
+          finish = () =>
+            fails ? reject(new Error("late error")) : done(payment);
+        }),
+    );
+    const { result } = renderHook(() => useSendToData());
+    let pending!: Promise<unknown>;
+    await act(async () => {
+      pending = result.current.fetchData("alice.nova", {});
+    });
+    act(() => result.current.cancelPendingRequest());
+    await act(async () => {
+      finish();
+      expect(await pending).toBeUndefined();
+    });
+    expect(result.current.state.state).not.toBe(RequestState.SUCCESS);
+    expect(result.current.state.state).not.toBe(RequestState.ERROR);
+  },
+);
diff --git a/extension/src/popup/components/send/SendTo/hooks/useSendToData.tsx b/extension/src/popup/components/send/SendTo/hooks/useSendToData.tsx
index 09cde809a1..e4da7123a2 100644
--- a/extension/src/popup/components/send/SendTo/hooks/useSendToData.tsx
+++ b/extension/src/popup/components/send/SendTo/hooks/useSendToData.tsx
@@ -1,5 +1,5 @@
 import { unsupportedSoranMuxed } from "popup/helpers/soranTransaction";
-import { useReducer, useRef } from "react";
+import { useCallback, useEffect, useReducer, useRef } from "react";
 import { Federation, StrKey } from "stellar-sdk";
 import { FormikErrors } from "formik";
 import { captureException } from "@sentry/browser";
@@ -101,6 +101,10 @@ function useSendToData({ isCollectible = false } = {}) {
   });
 
   const requestIdRef = useRef(0);
+  const cancelPendingRequest = useCallback(() => {
+    requestIdRef.current += 1;
+  }, []);
+  useEffect(() => cancelPendingRequest, [cancelPendingRequest]);
   const resolveInput = async (
     requestId: number,
     userInput: string,
@@ -170,12 +174,12 @@ function useSendToData({ isCollectible = false } = {}) {
         payload.destinationBalances = destinationBalances;
       }
 
-      if (requestId === requestIdRef.current)
-        dispatch({ type: "FETCH_DATA_SUCCESS", payload });
+      if (requestId !== requestIdRef.current) return;
+      dispatch({ type: "FETCH_DATA_SUCCESS", payload });
       return payload;
     } catch (error) {
-      if (requestId === requestIdRef.current)
-        dispatch({ type: "FETCH_DATA_ERROR", payload: error });
+      if (requestId !== requestIdRef.current) return;
+      dispatch({ type: "FETCH_DATA_ERROR", payload: error });
       return error;
     }
   };
@@ -244,15 +248,15 @@ function useSendToData({ isCollectible = false } = {}) {
       publicKey,
       networkDetails,
     } as ResolvedSendToData;
-    if (requestId === requestIdRef.current) {
-      dispatch({ type: "FETCH_DATA_SUCCESS", payload });
-    }
+    if (requestId !== requestIdRef.current) return;
+    dispatch({ type: "FETCH_DATA_SUCCESS", payload });
     return payload;
   };
 
   return {
     state,
     fetchData,
+    cancelPendingRequest,
   };
 }
 
diff --git a/extension/src/popup/components/send/SendTo/index.tsx b/extension/src/popup/components/send/SendTo/index.tsx
index ea6d536359..c81ec98f0d 100644
--- a/extension/src/popup/components/send/SendTo/index.tsx
+++ b/extension/src/popup/components/send/SendTo/index.tsx
@@ -1,4 +1,4 @@
-import React, { useEffect, useRef, useState } from "react";
+import React, { useCallback, useEffect, useRef, useState } from "react";
 import { useDispatch, useSelector } from "react-redux";
 import { StrKey } from "stellar-sdk";
 import { useFormik } from "formik";
@@ -135,7 +135,20 @@ export const SendTo = ({
   );
   const allAccounts = useSelector(allAccountsSelector);
   const activePublicKey = useSelector(publicKeySelector);
-  const { state: sendDataState, fetchData } = useSendToData({ isCollectible });
+  const {
+    state: sendDataState,
+    fetchData,
+    cancelPendingRequest,
+  } = useSendToData({ isCollectible });
+  const selectionIdRef = useRef(0);
+  const destinationTimeoutRef = useRef<
+    ReturnType<typeof setTimeout> | undefined
+  >(undefined);
+  const cancelPendingSelection = useCallback(() => {
+    clearTimeout(destinationTimeoutRef.current);
+    cancelPendingRequest();
+    return ++selectionIdRef.current;
+  }, [cancelPendingRequest]);
   const [debouncedDestination, setDebouncedDestination] = useState(
     federationAddress || destination || "",
   );
@@ -156,6 +169,7 @@ export const SendTo = ({
       federationMemoType?: FederationMemoType | "";
     } = {},
   ) => {
+    cancelPendingSelection();
     dispatch(saveDestination(validatedDestination));
     dispatch(saveDestinationAsset(""));
     dispatch(saveFederationAddress(validatedFedAdress || ""));
@@ -218,19 +232,20 @@ export const SendTo = ({
   };
 
   useEffect(() => {
-    const timeoutId = setTimeout(async () => {
+    const selectionId = selectionIdRef.current;
+    destinationTimeoutRef.current = setTimeout(async () => {
       setDebouncedDestination(formik.values.destination);
       const errors = await formik.validateForm(formik.values);
+      if (selectionId !== selectionIdRef.current) return;
       await fetchData(formik.values.destination, errors);
     }, DESTINATION_DEBOUNCE_MS);
 
     return () => {
-      clearTimeout(timeoutId);
+      cancelPendingSelection();
     };
-    // fetchData and formik.validateForm are stable refs — omitting intentionally
-    // to avoid re-triggering the debounce when only those refs change identity.
+    // Request-state updates must not restart the recipient-input debounce.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [formik.values.destination]);
+  }, [formik.values.destination, cancelPendingSelection]);
 
   const hasError = sendDataState.state === RequestState.ERROR;
   const isLoading =
@@ -303,7 +318,13 @@ export const SendTo = ({
 
   return (
     <React.Fragment>
-      <SubviewHeader title={t("Send to")} customBackAction={goBack} />
+      <SubviewHeader
+        title={t("Send to")}
+        customBackAction={() => {
+          cancelPendingSelection();
+          goBack();
+        }}
+      />
       <View.Content hasTopInput>
         <FormRows>
           <Input
@@ -312,7 +333,10 @@ export const SendTo = ({
             id="destination-input"
             name="destination"
             placeholder={t("Enter address or Soran name")}
-            onChange={formik.handleChange}
+            onChange={(event) => {
+              cancelPendingSelection();
+              formik.handleChange(event);
+            }}
             value={formik.values.destination}
             leftElement={<Icon.UserCircle />}
             data-testid="send-to-input"
@@ -394,12 +418,20 @@ export const SendTo = ({
                     type="button"
                     data-testid="recent-address-button"
                     onClick={async () => {
+                      const selectionId = cancelPendingSelection();
                       // Re-enter the normal resolution flow, including errors and network checks.
                       if (isSoranName(address)) {
                         formik.setFieldValue("destination", address);
+                        if (formik.values.destination === address)
+                          await fetchData(address, {});
                         return;
                       }
                       const result = await fetchData(address, {});
+                      if (
+                        selectionId !== selectionIdRef.current ||
+                        result === undefined
+                      )
+                        return;
                       if (
                         !isResolvedSuggestionData(result) ||
                         isSameAccount(result.validatedAddress, activePublicKey)
@@ -446,7 +478,13 @@ export const SendTo = ({
                         type="button"
                         data-testid="my-account-button"
                         onClick={async () => {
-                          await fetchData(account.publicKey, {});
+                          const selectionId = cancelPendingSelection();
+                          const result = await fetchData(account.publicKey, {});
+                          if (
+                            selectionId !== selectionIdRef.current ||
+                            !isResolvedSuggestionData(result)
+                          )
+                            return;
                           handleContinue(account.publicKey, undefined, {
                             recipientName: account.name || "",
                           });

From 71d4b37e58741ab2961d8e8a5f845712f29866d7 Mon Sep 17 00:00:00 2001
From: flarcos <onadekogbolahan@gmail.com>
Date: Sat, 12 Sep 2026 19:30:49 +0100
Subject: [PATCH 04/10] Fix Soran names for fallback token transfer history

---
 .../helpers/__tests__/soranHistory.test.ts    | 47 ++++++++++++++
 extension/src/popup/helpers/soranHistory.ts   |  3 +-
 .../__tests__/useGetHistoryData.test.tsx      | 63 ++++++++++++++++++-
 .../hooks/useGetHistoryData.tsx               |  2 +
 4 files changed, 113 insertions(+), 2 deletions(-)

diff --git a/extension/src/popup/helpers/__tests__/soranHistory.test.ts b/extension/src/popup/helpers/__tests__/soranHistory.test.ts
index 81a800b256..db2e6c54d5 100644
--- a/extension/src/popup/helpers/__tests__/soranHistory.test.ts
+++ b/extension/src/popup/helpers/__tests__/soranHistory.test.ts
@@ -89,3 +89,50 @@ it.each([
     ).toBeUndefined();
   },
 );
+
+describe("token transfer history naming without asset balance changes", () => {
+  it.each([
+    { from: "sender", to: "me", isReceiving: true, address: "sender" },
+    { from: "me", to: "recipient", isReceiving: false, address: "recipient" },
+  ])("selects the counterparty: %j", ({ address, ...metadata }) => {
+    expect(
+      getHistoryCounterparty(
+        operation({
+          isInvokeHostFn: true,
+          isTokenTransfer: true,
+          ...metadata,
+        }),
+      ),
+    ).toEqual({ address, isReceiving: metadata.isReceiving });
+  });
+
+  it.each([
+    { from: "sender", to: "me" },
+    { to: "me", isReceiving: true },
+    { from: "me", isReceiving: false },
+    {
+      from: "me",
+      to: "recipient",
+      isReceiving: false,
+      transactionFailed: true,
+    },
+    { from: "me", to: "recipient", isReceiving: false, isSwap: true },
+    {
+      from: "me",
+      to: "recipient",
+      isReceiving: false,
+      hasAssetDiffs: true,
+      assetDiffs: [{ destination: "first" }, { destination: "second" }],
+    },
+  ])("omits a name for incomplete or ambiguous transfers: %j", (metadata) => {
+    expect(
+      getHistoryCounterparty(
+        operation({
+          isInvokeHostFn: true,
+          isTokenTransfer: true,
+          ...metadata,
+        }),
+      ),
+    ).toBeUndefined();
+  });
+});
diff --git a/extension/src/popup/helpers/soranHistory.ts b/extension/src/popup/helpers/soranHistory.ts
index e18cd2a15c..cd7a710694 100644
--- a/extension/src/popup/helpers/soranHistory.ts
+++ b/extension/src/popup/helpers/soranHistory.ts
@@ -17,11 +17,12 @@ export const getHistoryCounterparty = (operation: OperationDataRow | null) => {
   }
   if (
     metadata.isPayment ||
+    metadata.isTokenTransfer ||
     metadata.isCollectibleTransfer ||
     metadata.type === "create_account"
   ) {
     if (
-      metadata.isCollectibleTransfer &&
+      (metadata.isTokenTransfer || metadata.isCollectibleTransfer) &&
       typeof metadata.isReceiving !== "boolean"
     )
       return undefined;
diff --git a/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx b/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx
index 5b79a2ae6b..ae6c2c81c2 100644
--- a/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx
+++ b/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx
@@ -1,4 +1,4 @@
-import { Asset, Networks } from "stellar-sdk";
+import { Account, Asset, MuxedAccount, Networks } from "stellar-sdk";
 
 import { TESTNET_NETWORK_DETAILS } from "@shared/constants/stellar";
 import { SorobanTokenInterface } from "@shared/constants/soroban/token";
@@ -346,3 +346,64 @@ describe("collectible history naming", () => {
     },
   );
 });
+
+describe("token transfer history naming without asset balance changes", () => {
+  afterEach(() => jest.restoreAllMocks());
+
+  const muxedCounterparty = new MuxedAccount(
+    new Account(COUNTERPARTY, "0"),
+    "42",
+  ).accountId();
+  it.each([
+    {
+      from: COUNTERPARTY,
+      to: PUBLIC_KEY,
+      isReceiving: true,
+      address: COUNTERPARTY,
+    },
+    {
+      from: PUBLIC_KEY,
+      to: COUNTERPARTY,
+      isReceiving: false,
+      address: COUNTERPARTY,
+    },
+    {
+      from: muxedCounterparty,
+      to: MY_MUXED,
+      isReceiving: true,
+      address: muxedCounterparty,
+    },
+    {
+      from: PUBLIC_KEY,
+      to: muxedCounterparty,
+      isReceiving: false,
+      address: muxedCounterparty,
+    },
+  ])(
+    "preserves direction and complete counterparty: %j",
+    async ({ from, to, isReceiving, address }) => {
+      jest
+        .spyOn(sorobanHelpers, "getAttrsFromSorobanHorizonOp")
+        .mockReturnValue({
+          fnName: SorobanTokenInterface.transfer,
+          contractId: CONTRACT_ID,
+          from,
+          to,
+          amount: 10000000,
+        });
+      fetchTokenDetails.mockResolvedValue({ symbol: "TEST", decimals: 7 });
+      const row = await callGetRowData(
+        buildInvokeHostFnOperation({ asset_issuer: CONTRACT_ID }),
+      );
+
+      expect(row.action).toBe(isReceiving ? "Received" : "Sent");
+      expect(row.metadata).toMatchObject({
+        isTokenTransfer: true,
+        from,
+        to,
+        isReceiving,
+      });
+      expect(getHistoryCounterparty(row)).toEqual({ address, isReceiving });
+    },
+  );
+});
diff --git a/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx b/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx
index 482bcd8598..9d03b93591 100644
--- a/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx
+++ b/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx
@@ -900,6 +900,8 @@ export const getRowDataByOpType = async (
               destAssetCode: code,
               isInvokeHostFn,
               isTokenTransfer: true,
+              from: attrs.from,
+              isReceiving,
               nonLabelAmount: `${formattedTokenAmount} ${code}`,
               to: actualDestination,
             },

From 98603e41cb739519c535abeb293ae1dd769ac9c4 Mon Sep 17 00:00:00 2001
From: flarcos <onadekogbolahan@gmail.com>
Date: Sat, 12 Sep 2026 19:43:21 +0100
Subject: [PATCH 05/10] Fix Soran contract token identifiers containing colons

---
 .../__tests__/soranTransaction.test.ts        | 80 +++++++++++++++++++
 .../src/popup/helpers/soranTransaction.ts     |  5 +-
 2 files changed, 83 insertions(+), 2 deletions(-)

diff --git a/extension/src/popup/helpers/__tests__/soranTransaction.test.ts b/extension/src/popup/helpers/__tests__/soranTransaction.test.ts
index f0348a4d8f..960af6d6c3 100644
--- a/extension/src/popup/helpers/__tests__/soranTransaction.test.ts
+++ b/extension/src/popup/helpers/__tests__/soranTransaction.test.ts
@@ -272,3 +272,83 @@ it("rejects malformed envelopes and fee bumps", () => {
     assertSoranTransactionRoute(bump.toXDR(), route(), network, context),
   ).toThrow();
 });
+
+describe.each(["TOKEN", "foo:bar", "foo:bar:baz"])(
+  "contract token symbol %s",
+  (symbol) => {
+    const tokenContext = { ...context, asset: `${symbol}:${contract}` };
+
+    it("accepts a transfer through the exact contract", () => {
+      expect(() =>
+        assertSoranTransactionRoute(
+          build(transfer()).toXDR(),
+          route(),
+          network,
+          tokenContext,
+        ),
+      ).not.toThrow();
+    });
+
+    it("rejects a transfer through a different contract", () => {
+      const wrongContract = new Asset("USD", other).contractId(
+        network.networkPassphrase,
+      );
+      expect(() =>
+        assertSoranTransactionRoute(
+          build(transfer(recipient, payer, wrongContract)).toXDR(),
+          route(),
+          network,
+          tokenContext,
+        ),
+      ).toThrow(/does not match/);
+    });
+
+    it.each([
+      ["payment", () => payment()],
+      [
+        "pathPaymentStrictSend",
+        () =>
+          Operation.pathPaymentStrictSend({
+            sendAsset: Asset.native(),
+            sendAmount: "1",
+            destination: recipient,
+            destAsset: Asset.native(),
+            destMin: "1",
+            path: [],
+          }),
+      ],
+      [
+        "pathPaymentStrictReceive",
+        () =>
+          Operation.pathPaymentStrictReceive({
+            sendAsset: Asset.native(),
+            sendMax: "1",
+            destination: recipient,
+            destAsset: Asset.native(),
+            destAmount: "1",
+            path: [],
+          }),
+      ],
+      [
+        "createAccount",
+        () =>
+          Operation.createAccount({
+            destination: recipient,
+            startingBalance: "1",
+          }),
+      ],
+    ] as const)(
+      "rejects substitution with %s to the same recipient",
+      (_, operation) => {
+        expect(() =>
+          assertSoranTransactionRoute(
+            build(operation()).toXDR(),
+            route(),
+            network,
+            tokenContext,
+          ),
+        ).toThrow(/does not match/);
+      },
+    );
+  },
+);
diff --git a/extension/src/popup/helpers/soranTransaction.ts b/extension/src/popup/helpers/soranTransaction.ts
index 4eb7b8a371..b03980470b 100644
--- a/extension/src/popup/helpers/soranTransaction.ts
+++ b/extension/src/popup/helpers/soranTransaction.ts
@@ -9,6 +9,7 @@ import {
 } from "stellar-sdk";
 import { NetworkDetails } from "@shared/constants/stellar";
 import { isNativeAssetId } from "@shared/helpers/assetIdentity";
+import { splitCanonical } from "@shared/helpers/stellar";
 import { buildMemoFromFederation } from "./federationMemo";
 import { SoranDestination } from "./soran";
 import i18n from "./localizationConfig";
@@ -41,7 +42,7 @@ const expectedContract = (
   if (context.isCollectible) return context.collectionAddress;
   if (isNativeAssetId(context.asset))
     return Asset.native().contractId(passphrase);
-  const [code, issuer] = context.asset.split(":");
+  const { code, issuer } = splitCanonical(context.asset);
   return StrKey.isValidContract(issuer || "")
     ? issuer
     : new Asset(code, issuer).contractId(passphrase);
@@ -115,7 +116,7 @@ export const assertSoranTransactionRoute = (
       // Contract assets and collectibles must never be replaced with a classic payment.
       if (
         context.isCollectible ||
-        StrKey.isValidContract(context.asset.split(":")[1] || "")
+        StrKey.isValidContract(splitCanonical(context.asset).issuer)
       )
         throw mismatch();
       switch (op.type) {

From 3b804deb08a1ef912241f43ce910279533160eed Mon Sep 17 00:00:00 2001
From: flarcos <onadekogbolahan@gmail.com>
Date: Sat, 12 Sep 2026 19:57:22 +0100
Subject: [PATCH 06/10] Bind Soran signer output to the reviewed transaction

---
 .../useSubmitTxData.telemetry.test.tsx        | 207 ++++++++++++++++-
 .../hooks/useSubmitTxData.tsx                 |  18 +-
 .../hardwareConnect/HardwareSign/index.tsx    |  45 ++--
 .../helpers/__tests__/soranHistory.test.ts    |   6 +-
 .../__tests__/soranTransaction.test.ts        | 210 ++++++++++++++++++
 .../src/popup/helpers/soranTransaction.ts     |  17 +-
 6 files changed, 476 insertions(+), 27 deletions(-)

diff --git a/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/__tests__/useSubmitTxData.telemetry.test.tsx b/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/__tests__/useSubmitTxData.telemetry.test.tsx
index 7706272964..df3643a7a0 100644
--- a/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/__tests__/useSubmitTxData.telemetry.test.tsx
+++ b/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/__tests__/useSubmitTxData.telemetry.test.tsx
@@ -60,7 +60,8 @@ jest.mock("helpers/hooks/useGetCollectibles", () => ({
   }),
 }));
 
-const PUBLIC_KEY = Keypair.random().publicKey();
+const SOURCE_KEYPAIR = Keypair.random();
+const PUBLIC_KEY = SOURCE_KEYPAIR.publicKey();
 const DESTINATION = Keypair.random().publicKey();
 const USDC_ISSUER = Keypair.random().publicKey();
 const USDC_CANONICAL = `USDC:${USDC_ISSUER}`;
@@ -898,3 +899,207 @@ describe("Soran successful-payment annotations", () => {
     },
   );
 });
+
+describe("Soran reviewed transaction binding at submission", () => {
+  const buildTransaction = (operation: xdr.Operation) =>
+    new TransactionBuilder(new Account(PUBLIC_KEY, "0"), {
+      fee: "100",
+      networkPassphrase: PASSPHRASE,
+    })
+      .addOperation(operation)
+      .setTimeout(0)
+      .build();
+  const payment = {
+    destination: DESTINATION,
+    asset: new Asset("USDC", USDC_ISSUER),
+    amount: "100",
+  };
+  const pathPayment = {
+    destination: DESTINATION,
+    sendAsset: new Asset("USDC", USDC_ISSUER),
+    sendAmount: "100",
+    destAsset: Asset.native(),
+    destMin: "90",
+    path: [],
+  };
+
+  beforeEach(() => {
+    jest.spyOn(Soran, "verifySoranDestination").mockResolvedValue(undefined);
+    jest.spyOn(ApiInternal, "getTokenPrices").mockResolvedValue({});
+    jest
+      .spyOn(ApiInternal, "saveSoranPaymentName")
+      .mockResolvedValue({ saved: true });
+    mockSubmitOk(buildResultXdr("880000000"));
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    (emitMetric as jest.Mock).mockClear();
+    (emitSigningApproved as jest.Mock).mockClear();
+    (emitSigningFailed as jest.Mock).mockClear();
+  });
+
+  describe.each([false, true])("hardware wallet: %s", (isHardwareWallet) => {
+    it.each([
+      {
+        change: "payment amount",
+        reviewed: Operation.payment(payment),
+        altered: Operation.payment({ ...payment, amount: "101" }),
+      },
+      {
+        change: "payment asset issuer",
+        reviewed: Operation.payment(payment),
+        altered: Operation.payment({
+          ...payment,
+          asset: new Asset("USDC", PUBLIC_KEY),
+        }),
+      },
+      {
+        change: "payment replaced by account creation",
+        reviewed: Operation.payment(payment),
+        altered: Operation.createAccount({
+          destination: DESTINATION,
+          startingBalance: "100",
+        }),
+      },
+      {
+        change: "path-payment destination minimum",
+        reviewed: Operation.pathPaymentStrictSend(pathPayment),
+        altered: Operation.pathPaymentStrictSend({
+          ...pathPayment,
+          destMin: "1",
+        }),
+      },
+      {
+        change: "path-payment source asset",
+        reviewed: Operation.pathPaymentStrictSend(pathPayment),
+        altered: Operation.pathPaymentStrictSend({
+          ...pathPayment,
+          sendAsset: Asset.native(),
+        }),
+      },
+      {
+        change: "path-payment intermediate asset",
+        reviewed: Operation.pathPaymentStrictSend(pathPayment),
+        altered: Operation.pathPaymentStrictSend({
+          ...pathPayment,
+          path: [new Asset("EUR", USDC_ISSUER)],
+        }),
+      },
+      {
+        change: "strict-send replaced by strict-receive",
+        reviewed: Operation.pathPaymentStrictSend(pathPayment),
+        altered: Operation.pathPaymentStrictReceive({
+          destination: DESTINATION,
+          sendAsset: pathPayment.sendAsset,
+          sendMax: pathPayment.sendAmount,
+          destAsset: pathPayment.destAsset,
+          destAmount: pathPayment.destMin,
+          path: [],
+        }),
+      },
+    ])("rejects a signer changing $change", async ({ reviewed, altered }) => {
+      const reviewedTransaction = buildTransaction(reviewed);
+      const signedTransaction = buildTransaction(altered);
+      signedTransaction.sign(SOURCE_KEYPAIR);
+      const signedXdr = signedTransaction.toXDR();
+      const state = makeState({
+        asset: USDC_CANONICAL,
+        preparedTransaction: isHardwareWallet ? signedXdr : null,
+      });
+      state.transactionSubmission.transactionData.federationAddress =
+        "alice.nova";
+      const sign = jest
+        .spyOn(ApiInternal, "signFreighterTransaction")
+        .mockResolvedValue({ signedTransaction: signedXdr });
+      // HardwareSign clears its overlay XDR before this submission step.
+      expect(
+        state.transactionSubmission.hardwareWalletData.transactionXDR,
+      ).toBe("");
+      const { result, store } = renderSubmitHook(
+        state,
+        MAINNET_NETWORK_DETAILS,
+        {
+          isHardwareWallet,
+          transactionXdr: reviewedTransaction.toXDR(),
+        },
+      );
+
+      await act(async () => {
+        await result.current.fetchData({ isSwap: false });
+      });
+
+      if (isHardwareWallet) expect(sign).not.toHaveBeenCalled();
+      else
+        expect(sign).toHaveBeenCalledWith({
+          transactionXDR: reviewedTransaction.toXDR(),
+          network: PASSPHRASE,
+          activePublicKey: PUBLIC_KEY,
+        });
+      expect(global.fetch).not.toHaveBeenCalled();
+      expect(ApiInternal.saveSoranPaymentName).not.toHaveBeenCalled();
+      expect(store.getState().transactionSubmission.submitStatus).toBe(
+        ActionStatus.ERROR,
+      );
+    });
+
+    it.each([
+      { type: "payment", operation: Operation.payment(payment) },
+      {
+        type: "path payment",
+        operation: Operation.pathPaymentStrictSend(pathPayment),
+      },
+    ])(
+      "submits an unchanged $type with a new signature",
+      async ({ operation }) => {
+        const transaction = buildTransaction(operation);
+        const reviewedXdr = transaction.toXDR();
+        transaction.sign(SOURCE_KEYPAIR);
+        const signedXdr = transaction.toXDR();
+        expect(signedXdr).not.toBe(reviewedXdr);
+        const state = makeState({
+          asset: USDC_CANONICAL,
+          preparedTransaction: isHardwareWallet ? signedXdr : null,
+        });
+        state.transactionSubmission.transactionData.federationAddress =
+          "alice.nova";
+        jest
+          .spyOn(ApiInternal, "signFreighterTransaction")
+          .mockResolvedValue({ signedTransaction: signedXdr });
+        const { result, store } = renderSubmitHook(
+          state,
+          MAINNET_NETWORK_DETAILS,
+          {
+            isHardwareWallet,
+            transactionXdr: reviewedXdr,
+          },
+        );
+
+        await act(async () => {
+          await result.current.fetchData({ isSwap: false });
+        });
+
+        expect(global.fetch).toHaveBeenCalledWith(
+          expect.stringContaining("/submit-tx"),
+          expect.objectContaining({
+            body: JSON.stringify({
+              signed_xdr: signedXdr,
+              network_passphrase: PASSPHRASE,
+            }),
+          }),
+        );
+        expect(ApiInternal.saveSoranPaymentName).toHaveBeenCalledWith(
+          PUBLIC_KEY,
+          expect.objectContaining({
+            name: "alice.nova",
+            destination: DESTINATION,
+            transactionHash: Buffer.from(transaction.hash()).toString("hex"),
+          }),
+        );
+        expect(store.getState().transactionSubmission.submitStatus).toBe(
+          ActionStatus.SUCCESS,
+        );
+      },
+    );
+  });
+});
diff --git a/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/useSubmitTxData.tsx b/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/useSubmitTxData.tsx
index 12d6afc096..e38292476b 100644
--- a/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/useSubmitTxData.tsx
+++ b/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/useSubmitTxData.tsx
@@ -167,13 +167,17 @@ function useSubmitTxData({
         collectionAddress: collectibleData.collectionAddress,
         tokenId: collectibleData.tokenId,
       };
-      const validateSoranEnvelope = (envelope: string) => {
+      const validateSoranEnvelope = (
+        envelope: string,
+        reviewedTransactionXdr?: string,
+      ) => {
         try {
           return assertSoranTransactionRoute(
             envelope,
             expectedSoranRoute,
             networkDetails,
             soranContext,
+            reviewedTransactionXdr,
           );
         } catch (error) {
           reduxDispatch(
@@ -193,11 +197,7 @@ function useSubmitTxData({
             },
             networkDetails,
           );
-          validateSoranEnvelope(
-            isHardwareWallet
-              ? transactionSimulation.preparedTransaction || ""
-              : xdr,
-          );
+          validateSoranEnvelope(xdr);
         } catch (error) {
           reduxDispatch(
             setSubmitError({ errorMessage: (error as Error).message }),
@@ -375,10 +375,10 @@ function useSubmitTxData({
           })
         : null;
 
-      // Validate the signer/device output as well as the unsigned input. This
-      // is the exact envelope submitted and the source of the history reference.
+      // The xdr prop is the original reviewed transaction for both software
+      // and hardware wallets. The signer may add signatures, not change its body.
       const soranPaymentReference = isSoranPayment
-        ? validateSoranEnvelope(signedXDR)
+        ? validateSoranEnvelope(signedXDR, xdr)
         : undefined;
       const submitResp = await reduxDispatch(
         submitFreighterTransaction({
diff --git a/extension/src/popup/components/hardwareConnect/HardwareSign/index.tsx b/extension/src/popup/components/hardwareConnect/HardwareSign/index.tsx
index 84944702f3..9caf8a725b 100644
--- a/extension/src/popup/components/hardwareConnect/HardwareSign/index.tsx
+++ b/extension/src/popup/components/hardwareConnect/HardwareSign/index.tsx
@@ -160,29 +160,35 @@ export const HardwareSign = ({
     setIsDetecting(true);
     setConnectError("");
     try {
-      if (
+      const isSoranPayment =
         isInternal &&
         !isSignMessage &&
         !isSignSorobanAuthorization &&
-        isSoranName(transactionData.federationAddress || "")
-      ) {
-        const expected = {
-          address: transactionData.destination,
-          memo: transactionData.memo || "",
-          memoType: transactionData.memoType || "",
-        };
+        isSoranName(transactionData.federationAddress || "");
+      const expected = {
+        address: transactionData.destination,
+        memo: transactionData.memo || "",
+        memoType: transactionData.memoType || "",
+      };
+      const soranContext = {
+        publicKey: activePublicKey,
+        asset: transactionData.asset,
+        isCollectible: transactionData.isCollectible,
+        collectionAddress: transactionData.collectibleData.collectionAddress,
+        tokenId: transactionData.collectibleData.tokenId,
+      };
+      if (isSoranPayment) {
         await verifySoranDestination(
           transactionData.federationAddress,
           expected,
           networkDetails,
         );
-        assertSoranTransactionRoute(transactionXDR, expected, networkDetails, {
-          publicKey: activePublicKey,
-          asset: transactionData.asset,
-          isCollectible: transactionData.isCollectible,
-          collectionAddress: transactionData.collectibleData.collectionAddress,
-          tokenId: transactionData.collectibleData.tokenId,
-        });
+        assertSoranTransactionRoute(
+          transactionXDR,
+          expected,
+          networkDetails,
+          soranContext,
+        );
       }
       const publicKey = await getWalletPublicKey[walletType](bipPath);
 
@@ -222,6 +228,15 @@ export const HardwareSign = ({
       );
       // should support saving signed xdr for SubmitTransaction to submit
       if (signWithHardwareWallet.fulfilled.match(res)) {
+        if (isSoranPayment) {
+          assertSoranTransactionRoute(
+            typeof res.payload === "string" ? res.payload : "",
+            expected,
+            networkDetails,
+            soranContext,
+            transactionXDR,
+          );
+        }
         if (shouldSubmit && !isSignSorobanAuthorization && !isSignMessage) {
           // The internal branch: the device produced a signature and the flow
           // carries it to submission. This is where an internal hardware
diff --git a/extension/src/popup/helpers/__tests__/soranHistory.test.ts b/extension/src/popup/helpers/__tests__/soranHistory.test.ts
index db2e6c54d5..a9bf3bc285 100644
--- a/extension/src/popup/helpers/__tests__/soranHistory.test.ts
+++ b/extension/src/popup/helpers/__tests__/soranHistory.test.ts
@@ -56,7 +56,11 @@ it("uses one unambiguous contract transfer and omits multi-party calls, swaps an
 it.each(["en-GB", "en-US", "pt-BR"])(
   "formats valid dates in %s without assuming AM/PM",
   (locale) => {
-    const result = formatHistoryTimestamp("2026-09-12T09:58:00Z", locale);
+    const date = new Date(2026, 8, 12, 9, 58);
+    const result = formatHistoryTimestamp(date.toISOString(), locale);
+    expect(result.split(" • ")[1]).toBe(
+      locale === "en-US" ? "09:58 AM" : "09:58",
+    );
     expect(result).toContain("2026");
     expect(result).toContain(" • ");
     expect(result).not.toMatch(/undefined|Invalid|NaN/);
diff --git a/extension/src/popup/helpers/__tests__/soranTransaction.test.ts b/extension/src/popup/helpers/__tests__/soranTransaction.test.ts
index 960af6d6c3..44b0031663 100644
--- a/extension/src/popup/helpers/__tests__/soranTransaction.test.ts
+++ b/extension/src/popup/helpers/__tests__/soranTransaction.test.ts
@@ -352,3 +352,213 @@ describe.each(["TOKEN", "foo:bar", "foo:bar:baz"])(
     );
   },
 );
+
+describe("binding the signed transaction to the reviewed transaction", () => {
+  const usd = new Asset("USD", other);
+  const pathParams = {
+    sendAsset: Asset.native(),
+    sendAmount: "1",
+    destination: recipient,
+    destAsset: usd,
+    destMin: "0.9",
+    path: [new Asset("EUR", other)],
+  };
+  const pathPayment = () => Operation.pathPaymentStrictSend(pathParams);
+
+  it.each([
+    ["payment", () => payment()],
+    ["path payment", pathPayment],
+    [
+      "account creation",
+      () =>
+        Operation.createAccount({
+          destination: recipient,
+          startingBalance: "1",
+        }),
+    ],
+    ["contract transfer", () => transfer()],
+  ] as const)(
+    "allows only signature additions to a reviewed %s",
+    (_, operation) => {
+      const tx = build(operation());
+      tx.sign(Keypair.random());
+      const reviewedXdr = tx.toXDR();
+      tx.sign(Keypair.random());
+
+      expect(
+        assertSoranTransactionRoute(
+          tx.toXDR(),
+          route(),
+          network,
+          context,
+          reviewedXdr,
+        ).transactionHash,
+      ).toBe(Buffer.from(tx.hash()).toString("hex"));
+    },
+  );
+
+  it.each([
+    [
+      "amount",
+      () =>
+        Operation.payment({
+          destination: recipient,
+          asset: Asset.native(),
+          amount: "2",
+        }),
+    ],
+    [
+      "asset",
+      () =>
+        Operation.payment({
+          destination: recipient,
+          asset: usd,
+          amount: "1",
+        }),
+    ],
+    [
+      "operation type to account creation",
+      () =>
+        Operation.createAccount({
+          destination: recipient,
+          startingBalance: "1",
+        }),
+    ],
+    ["operation type to a path payment", pathPayment],
+    ["operation type to a contract transfer", () => transfer()],
+  ] as const)("rejects changing the reviewed payment's %s", (_, operation) => {
+    expect(() =>
+      assertSoranTransactionRoute(
+        build(operation()).toXDR(),
+        route(),
+        network,
+        context,
+        build().toXDR(),
+      ),
+    ).toThrow(/does not match/);
+  });
+
+  it.each([
+    ["send amount", { sendAmount: "2" }],
+    ["send asset", { sendAsset: usd }],
+    ["destination asset", { destAsset: Asset.native() }],
+    ["minimum received amount", { destMin: "0.1" }],
+    ["path", { path: [] as Asset[] }],
+  ] as const)(
+    "rejects changing the reviewed path payment's %s",
+    (_, changes) => {
+      expect(() =>
+        assertSoranTransactionRoute(
+          build(
+            Operation.pathPaymentStrictSend({ ...pathParams, ...changes }),
+          ).toXDR(),
+          route(),
+          network,
+          context,
+          build(pathPayment()).toXDR(),
+        ),
+      ).toThrow(/does not match/);
+    },
+  );
+
+  it.each([
+    ["fee", "200", "0"],
+    ["sequence", "100", "1"],
+  ] as const)(
+    "rejects changing the reviewed transaction's %s",
+    (_, fee, sequence) => {
+      const changed = new TransactionBuilder(new Account(payer, sequence), {
+        fee,
+        networkPassphrase: network.networkPassphrase,
+      })
+        .addOperation(payment())
+        .setTimeout(0)
+        .build();
+      expect(() =>
+        assertSoranTransactionRoute(
+          changed.toXDR(),
+          route(),
+          network,
+          context,
+          build().toXDR(),
+        ),
+      ).toThrow(/does not match/);
+    },
+  );
+
+  it("rejects a changed memo even when it matches the current route", () => {
+    expect(() =>
+      assertSoranTransactionRoute(
+        build(payment(), Memo.text("changed")).toXDR(),
+        route(recipient, "changed", "text"),
+        network,
+        context,
+        build().toXDR(),
+      ),
+    ).toThrow(/does not match/);
+  });
+
+  it("rejects changing a contract transfer to another positive amount", () => {
+    expect(() =>
+      assertSoranTransactionRoute(
+        build(
+          transfer(
+            recipient,
+            payer,
+            contract,
+            "transfer",
+            nativeToScVal(BigInt(20), { type: "i128" }),
+          ),
+        ).toXDR(),
+        route(),
+        network,
+        context,
+        build(transfer()).toXDR(),
+      ),
+    ).toThrow(/does not match/);
+  });
+
+  it.each([
+    ["empty", (): string => ""],
+    ["malformed", (): string => "invalid"],
+    [
+      "fee bump",
+      () =>
+        TransactionBuilder.buildFeeBumpTransaction(
+          payer,
+          "100",
+          build(),
+          network.networkPassphrase,
+        ).toXDR(),
+    ],
+  ] as const)("rejects a supplied %s reviewed transaction", (_, reference) => {
+    expect(() =>
+      assertSoranTransactionRoute(
+        build().toXDR(),
+        route(),
+        network,
+        context,
+        reference(),
+      ),
+    ).toThrow(/does not match/);
+  });
+
+  it("rejects strict-receive payments even without a reviewed reference", () => {
+    const strictReceive = Operation.pathPaymentStrictReceive({
+      sendAsset: Asset.native(),
+      sendMax: "1",
+      destination: recipient,
+      destAsset: usd,
+      destAmount: "0.9",
+      path: [],
+    });
+    expect(() =>
+      assertSoranTransactionRoute(
+        build(strictReceive).toXDR(),
+        route(),
+        network,
+        context,
+      ),
+    ).toThrow(/does not match/);
+  });
+});
diff --git a/extension/src/popup/helpers/soranTransaction.ts b/extension/src/popup/helpers/soranTransaction.ts
index b03980470b..e09b60af35 100644
--- a/extension/src/popup/helpers/soranTransaction.ts
+++ b/extension/src/popup/helpers/soranTransaction.ts
@@ -57,6 +57,7 @@ export const assertSoranTransactionRoute = (
   expected: Omit<SoranDestination, "memoType"> & { memoType: string },
   network: NetworkDetails,
   context: SoranTransactionContext,
+  reviewedTransactionXdr?: string,
 ) => {
   try {
     const tx = TransactionBuilder.fromXDR(
@@ -70,6 +71,21 @@ export const assertSoranTransactionRoute = (
       tx.source !== context.publicKey
     )
       throw mismatch();
+    if (reviewedTransactionXdr !== undefined) {
+      const reviewed = TransactionBuilder.fromXDR(
+        reviewedTransactionXdr,
+        network.networkPassphrase,
+      );
+      // Signing may add envelope signatures, but must preserve the entire
+      // reviewed transaction body, including amounts, assets, paths and fees.
+      if (
+        !(reviewed instanceof Transaction) ||
+        !Buffer.from(tx.signatureBase()).equals(
+          Buffer.from(reviewed.signatureBase()),
+        )
+      )
+        throw mismatch();
+    }
     if (!["", "text", "id", "hash"].includes(expected.memoType))
       throw mismatch();
     const memo = expected.memoType
@@ -122,7 +138,6 @@ export const assertSoranTransactionRoute = (
       switch (op.type) {
         case "payment":
         case "pathPaymentStrictSend":
-        case "pathPaymentStrictReceive":
           destination = op.destination;
           break;
         case "createAccount":

From 600ad1944ad0efd6f43ca23d593c2a78c525de34 Mon Sep 17 00:00:00 2001
From: flarcos <onadekogbolahan@gmail.com>
Date: Sat, 12 Sep 2026 20:11:55 +0100
Subject: [PATCH 07/10] Preserve regional locales in history timestamps

---
 .../__tests__/SoranHistoryDisplay.test.tsx    | 67 ++++++++++++++++---
 .../TransactionDetail/index.tsx               |  2 +-
 2 files changed, 58 insertions(+), 11 deletions(-)

diff --git a/extension/src/popup/components/__tests__/SoranHistoryDisplay.test.tsx b/extension/src/popup/components/__tests__/SoranHistoryDisplay.test.tsx
index 6a13dfc1b5..cb7e6ac0ce 100644
--- a/extension/src/popup/components/__tests__/SoranHistoryDisplay.test.tsx
+++ b/extension/src/popup/components/__tests__/SoranHistoryDisplay.test.tsx
@@ -1,23 +1,29 @@
 import React from "react";
-import { render, screen } from "@testing-library/react";
+import { render as renderComponent, screen } from "@testing-library/react";
+import { createInstance, type i18n } from "i18next";
+import { I18nextProvider } from "react-i18next";
 import { TESTNET_NETWORK_DETAILS } from "@shared/constants/stellar";
 import { HistoryItem } from "popup/components/accountHistory/HistoryItem";
 import { TransactionDetail } from "popup/components/accountHistory/TransactionDetail";
 import { useSoranHistoryName } from "popup/hooks/useSoranHistoryName";
+import englishTranslations from "popup/locales/en/translation.json";
+import portugueseTranslations from "popup/locales/pt/translation.json";
 import type { OperationDataRow } from "popup/views/AccountHistory/hooks/useGetHistoryData";
 
-jest.mock("react-i18next", () => ({
-  useTranslation: () => ({
-    t: (key: string, options?: { name?: string }) =>
-      key.replace("{{name}}", options?.name || ""),
-    i18n: { resolvedLanguage: "en-GB" },
-  }),
-}));
+jest.unmock("i18next");
+jest.unmock("i18next-browser-languagedetector");
+jest.unmock("i18next-resources-to-backend");
+jest.unmock("react-i18next");
 
 jest.mock("popup/hooks/useSoranHistoryName", () => ({
   useSoranHistoryName: jest.fn(),
 }));
 const names = jest.mocked(useSoranHistoryName);
+let localeInstance: i18n;
+const render = (component: React.ReactElement) =>
+  renderComponent(
+    <I18nextProvider i18n={localeInstance}>{component}</I18nextProvider>,
+  );
 const destination = "GBES5UHJYI445RV4XBGWHZOMBW4RYXBHOX47ZNZAJZAH2WP42ZEP2DYQ";
 const operation: OperationDataRow = {
   id: "123",
@@ -39,11 +45,52 @@ const operation: OperationDataRow = {
     memo: "hello",
   },
 };
-beforeEach(() =>
+beforeEach(async () => {
+  localeInstance = createInstance();
+  await localeInstance.init({
+    lng: "en-GB",
+    fallbackLng: "en",
+    resources: {
+      en: { translation: englishTranslations },
+      pt: { translation: portugueseTranslations },
+    },
+  });
   names.mockReturnValue({
     currentName: "current.nova",
     usedName: "original.nova",
-  }),
+  });
+});
+
+it.each([
+  { locale: "en-GB", translationLanguage: "en", expectedTime: "09:58" },
+  { locale: "en-US", translationLanguage: "en", expectedTime: "09:58 AM" },
+  { locale: "pt-BR", translationLanguage: "pt", expectedTime: "09:58" },
+])(
+  "preserves the $locale clock when translations fall back to $translationLanguage",
+  async ({ locale, translationLanguage, expectedTime }) => {
+    await localeInstance.changeLanguage(locale);
+    expect(localeInstance.language).toBe(locale);
+    expect(localeInstance.resolvedLanguage).toBe(translationLanguage);
+
+    render(
+      <TransactionDetail
+        activeOperation={{
+          ...operation,
+          metadata: {
+            ...operation.metadata,
+            createdAt: new Date(2026, 8, 12, 9, 58).toISOString(),
+          },
+        }}
+        networkDetails={TESTNET_NETWORK_DETAILS}
+      />,
+    );
+
+    const timestamp = screen.getByTestId(
+      "TransactionDetailModal__subtitle-date",
+    ).textContent;
+    expect(timestamp?.split(" • ")[1]).toBe(expectedTime);
+    expect(timestamp).not.toContain("undefined");
+  },
 );
 it("labels a historical name separately while retaining the address and memo", () => {
   render(
diff --git a/extension/src/popup/components/accountHistory/TransactionDetail/index.tsx b/extension/src/popup/components/accountHistory/TransactionDetail/index.tsx
index 7c553ae200..0d3d4290b8 100644
--- a/extension/src/popup/components/accountHistory/TransactionDetail/index.tsx
+++ b/extension/src/popup/components/accountHistory/TransactionDetail/index.tsx
@@ -339,7 +339,7 @@ export const TransactionDetail = ({
                 >
                   {formatHistoryTimestamp(
                     activeOperation.metadata.createdAt,
-                    i18n?.resolvedLanguage,
+                    i18n?.language,
                   )}
                 </div>
               </>

From a10bbb9d27130cdbb403fd9f9b200351e81287f9 Mon Sep 17 00:00:00 2001
From: flarcos <onadekogbolahan@gmail.com>
Date: Sat, 12 Sep 2026 20:26:02 +0100
Subject: [PATCH 08/10] Validate exact Soran token amounts before review

---
 .../useSimulateTxData.soran.test.tsx          | 258 ++++++++++++++++++
 .../SendAmount/hooks/useSimulateTxData.tsx    |  24 +-
 .../__tests__/soranTransaction.test.ts        | 176 +++++++++++-
 .../src/popup/helpers/soranTransaction.ts     |  46 +++-
 4 files changed, 499 insertions(+), 5 deletions(-)
 create mode 100644 extension/src/popup/components/send/SendAmount/hooks/__tests__/useSimulateTxData.soran.test.tsx

diff --git a/extension/src/popup/components/send/SendAmount/hooks/__tests__/useSimulateTxData.soran.test.tsx b/extension/src/popup/components/send/SendAmount/hooks/__tests__/useSimulateTxData.soran.test.tsx
new file mode 100644
index 0000000000..4252db32c0
--- /dev/null
+++ b/extension/src/popup/components/send/SendAmount/hooks/__tests__/useSimulateTxData.soran.test.tsx
@@ -0,0 +1,258 @@
+import React from "react";
+import { Provider } from "react-redux";
+import { act, renderHook } from "@testing-library/react";
+import BigNumber from "bignumber.js";
+import {
+  Account,
+  Address,
+  Contract,
+  Keypair,
+  TransactionBuilder,
+  nativeToScVal,
+  rpc,
+} from "stellar-sdk";
+
+import * as ApiInternal from "@shared/api/internal";
+import { TESTNET_NETWORK_DETAILS } from "@shared/constants/stellar";
+import { RequestState } from "constants/request";
+import { AccountBalances } from "helpers/hooks/useGetBalances";
+import * as MuxedAddress from "helpers/muxedAddress";
+import { makeDummyStore } from "popup/__testHelpers__";
+import { initialState as submissionInitialState } from "popup/ducks/transactionSubmission";
+import * as AccountHelpers from "popup/helpers/account";
+import * as Soran from "popup/helpers/soran";
+import { SimulateResult, useSimulateTxData } from "../useSimulateTxData";
+
+const mockFetchBalances = jest.fn();
+const mockScanTx = jest.fn();
+
+jest.mock("helpers/hooks/useGetBalances", () => ({
+  useGetBalances: () => ({ fetchData: mockFetchBalances }),
+}));
+jest.mock("popup/helpers/blockaid", () => ({
+  useScanTx: () => ({ scanTx: mockScanTx }),
+}));
+jest.mock("helpers/metrics", () => ({
+  ...jest.requireActual("helpers/metrics"),
+  emitMetric: jest.fn(),
+}));
+
+const PAYER = Keypair.random().publicKey();
+const RECIPIENT = Keypair.random().publicKey();
+const CONTRACT = "CCVKI6UYJDO34LO4D653IXCTPBGJOHJSJGSIOB4A46IH4ULNHS2MPQL7";
+const NETWORK = TESTNET_NETWORK_DETAILS;
+
+const buildTransfer = (amount: bigint) =>
+  new TransactionBuilder(new Account(PAYER, "0"), {
+    fee: "100",
+    networkPassphrase: NETWORK.networkPassphrase,
+  })
+    .addOperation(
+      new Contract(CONTRACT).call(
+        "transfer",
+        new Address(PAYER).toScVal(),
+        new Address(RECIPIENT).toScVal(),
+        nativeToScVal(amount, { type: "i128" }),
+      ),
+    )
+    .setTimeout(0)
+    .build()
+    .toXDR();
+
+const renderSimulation = (amount: string, decimals: number) => {
+  const balances: AccountBalances = {
+    isFunded: true,
+    subentryCount: 0,
+    balances: [
+      {
+        contractId: CONTRACT,
+        token: { code: "TOKEN", issuer: { key: CONTRACT } },
+        symbol: "TOKEN",
+        name: "Test token",
+        decimals,
+        total: new BigNumber("1000000000000000000"),
+      },
+    ],
+  };
+  mockFetchBalances.mockResolvedValue(balances);
+  const store = makeDummyStore({
+    auth: { publicKey: PAYER },
+    transactionSubmission: {
+      ...submissionInitialState,
+      transactionData: {
+        ...submissionInitialState.transactionData,
+        asset: `TOKEN:${CONTRACT}`,
+        amount,
+        destination: RECIPIENT,
+        federationAddress: "alice.nova",
+      },
+    },
+  });
+  const wrapper = ({ children }: { children: React.ReactNode }) => (
+    <Provider store={store}>{children}</Provider>
+  );
+  const rendered = renderHook(
+    () =>
+      useSimulateTxData({
+        publicKey: PAYER,
+        destination: RECIPIENT,
+        networkDetails: NETWORK,
+        simParams: { type: "soroban", xdr: "" },
+        isMainnet: false,
+      }),
+    { wrapper },
+  );
+  return { ...rendered, store };
+};
+
+const mockSimulation = (amount: bigint) => {
+  const preparedTransaction = buildTransfer(amount);
+  const simulate = jest
+    .spyOn(ApiInternal, "simulateTokenTransfer")
+    .mockResolvedValue({
+      ok: true,
+      response: {
+        preparedTransaction,
+        simulationResponse: {
+          minResourceFee: "100",
+        } as rpc.Api.SimulateTransactionSuccessResponse,
+      },
+    });
+  return { simulate, preparedTransaction };
+};
+
+describe("Soran token amount validation before review", () => {
+  beforeEach(() => {
+    jest.spyOn(Soran, "verifySoranDestination").mockResolvedValue(undefined);
+    jest.spyOn(AccountHelpers, "getBaseAccount").mockResolvedValue(RECIPIENT);
+    jest.spyOn(MuxedAddress, "checkIsMuxedSupported").mockResolvedValue(false);
+    mockScanTx.mockResolvedValue(null);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    mockFetchBalances.mockReset();
+    mockScanTx.mockReset();
+  });
+
+  it.each([
+    { amount: "123", decimals: 0, units: BigInt("123") },
+    { amount: "1.2345678", decimals: 7, units: BigInt("12345678") },
+    { amount: "1,234.5678901", decimals: 7, units: BigInt("12345678901") },
+    {
+      amount: "9007199254740993",
+      decimals: 0,
+      units: BigInt("9007199254740993"),
+    },
+    {
+      amount: "900719925.4740993",
+      decimals: 7,
+      units: BigInt("9007199254740993"),
+    },
+  ])(
+    "accepts the exact $amount at $decimals decimals",
+    async ({ amount, decimals, units }) => {
+      const { simulate, preparedTransaction } = mockSimulation(units);
+      const { result, store } = renderSimulation(amount, decimals);
+      let response: SimulateResult | undefined;
+
+      await act(async () => {
+        response = await result.current.fetchData();
+      });
+
+      expect(simulate).toHaveBeenCalledTimes(1);
+      expect(response).toMatchObject({
+        ok: true,
+        data: { transactionXdr: preparedTransaction },
+      });
+      expect(result.current.state.state).toBe(RequestState.SUCCESS);
+      expect(mockScanTx).toHaveBeenCalledWith(
+        preparedTransaction,
+        "internal",
+        NETWORK,
+      );
+      expect(
+        store.getState().transactionSubmission.transactionSimulation
+          .preparedTransaction,
+      ).toBe(preparedTransaction);
+    },
+  );
+
+  it.each([
+    {
+      change: "smaller",
+      amount: "1.2345678",
+      decimals: 7,
+      units: BigInt("12345677"),
+    },
+    {
+      change: "larger",
+      amount: "1.2345678",
+      decimals: 7,
+      units: BigInt("12345679"),
+    },
+    {
+      change: "rounded above 2^53",
+      amount: "9007199254740993",
+      decimals: 0,
+      units: BigInt("9007199254740992"),
+    },
+    {
+      change: "rounded above 2^53",
+      amount: "900719925.4740993",
+      decimals: 7,
+      units: BigInt("9007199254740992"),
+    },
+  ])(
+    "rejects a $change response for $amount at $decimals decimals",
+    async ({ amount, decimals, units }) => {
+      const { simulate } = mockSimulation(units);
+      const { result, store } = renderSimulation(amount, decimals);
+      let response: SimulateResult | undefined;
+
+      await act(async () => {
+        response = await result.current.fetchData();
+      });
+
+      expect(simulate).toHaveBeenCalledTimes(1);
+      expect(response).toMatchObject({ ok: false });
+      expect(result.current.state).toMatchObject({
+        state: RequestState.ERROR,
+        data: null,
+      });
+      expect(mockScanTx).not.toHaveBeenCalled();
+      expect(
+        store.getState().transactionSubmission.transactionSimulation
+          .preparedTransaction,
+      ).toBeNull();
+    },
+  );
+
+  it.each([
+    { amount: "1.1", decimals: 0 },
+    { amount: "1.00000001", decimals: 7 },
+  ])(
+    "rejects $amount beyond $decimals decimals before simulation",
+    async ({ amount, decimals }) => {
+      const { simulate } = mockSimulation(BigInt(1));
+      const { result, store } = renderSimulation(amount, decimals);
+      let response: SimulateResult | undefined;
+
+      await act(async () => {
+        response = await result.current.fetchData();
+      });
+
+      expect(simulate).not.toHaveBeenCalled();
+      expect(response).toMatchObject({ ok: false });
+      expect(result.current.state).toMatchObject({
+        state: RequestState.ERROR,
+        data: null,
+      });
+      expect(mockScanTx).not.toHaveBeenCalled();
+      expect(
+        store.getState().transactionSubmission.transactionSimulation
+          .preparedTransaction,
+      ).toBeNull();
+    },
+  );
+});
diff --git a/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx b/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx
index 62df522e22..409ae9a7f3 100644
--- a/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx
+++ b/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx
@@ -1,5 +1,6 @@
 import {
   assertSoranTransactionRoute,
+  getSoranTokenAmount,
   unsupportedSoranMuxed,
 } from "popup/helpers/soranTransaction";
 import { useReducer } from "react";
@@ -546,9 +547,16 @@ function useSimulateTxData({
       const tokenAddress = isNativeAssetId(currentAssetAddress)
         ? getNativeContractId(networkDetails.networkPassphrase)
         : currentAssetAddress;
+      const tokenDecimals = Number(
+        "decimals" in assetBalance ? assetBalance.decimals : 7,
+      );
+      const expectedTokenAmount =
+        isSoranPayment && simParams.type === "soroban"
+          ? getSoranTokenAmount(cleanAmount(currentAmount), tokenDecimals)
+          : undefined;
       const parsedAmount = parseTokenAmount(
         cleanAmount(currentAmount),
-        Number("decimals" in assetBalance ? assetBalance.decimals : 7),
+        tokenDecimals,
       );
 
       // For Soroban transfers, check if contract supports muxed and determine final destination
@@ -596,6 +604,18 @@ function useSimulateTxData({
           },
         },
       });
+      if (isSoranPayment && simParams.type === "soroban") {
+        assertSoranTransactionRoute(
+          simResponse.payload?.preparedTransaction || "",
+          {
+            address: destination,
+            memo: currentMemo || "",
+            memoType: currentMemoType || "",
+          },
+          networkDetails,
+          { publicKey, asset: currentAsset, expectedTokenAmount },
+        );
+      }
       const simulationResponse =
         simResponse.payload && "simulationTransaction" in simResponse.payload
           ? simResponse.payload?.simulationTransaction
@@ -674,7 +694,7 @@ function useSimulateTxData({
         });
       }
 
-      if (isSoranPayment) {
+      if (isSoranPayment && simParams.type === "classic") {
         assertSoranTransactionRoute(
           payload.transactionXdr,
           {
diff --git a/extension/src/popup/helpers/__tests__/soranTransaction.test.ts b/extension/src/popup/helpers/__tests__/soranTransaction.test.ts
index 44b0031663..8bd7be1e88 100644
--- a/extension/src/popup/helpers/__tests__/soranTransaction.test.ts
+++ b/extension/src/popup/helpers/__tests__/soranTransaction.test.ts
@@ -12,7 +12,10 @@ import {
   xdr,
 } from "stellar-sdk";
 import { TESTNET_NETWORK_DETAILS as network } from "@shared/constants/stellar";
-import { assertSoranTransactionRoute } from "../soranTransaction";
+import {
+  assertSoranTransactionRoute,
+  getSoranTokenAmount,
+} from "../soranTransaction";
 
 const payer = Keypair.random().publicKey();
 const recipient = Keypair.random().publicKey();
@@ -562,3 +565,174 @@ describe("binding the signed transaction to the reviewed transaction", () => {
     ).toThrow(/does not match/);
   });
 });
+
+describe("binding a simulated token transfer to the selected amount", () => {
+  const validateAmount = (value: xdr.ScVal, expectedTokenAmount: bigint) =>
+    assertSoranTransactionRoute(
+      build(transfer(recipient, payer, contract, "transfer", value)).toXDR(),
+      route(),
+      network,
+      { ...context, expectedTokenAmount },
+    );
+
+  it.each(["10", "9007199254740993"])(
+    "accepts the exact selected base-unit amount %s",
+    (amount) => {
+      expect(() =>
+        validateAmount(
+          nativeToScVal(BigInt(amount), { type: "i128" }),
+          BigInt(amount),
+        ),
+      ).not.toThrow();
+    },
+  );
+
+  it.each([
+    ["increased", "11"],
+    ["decreased", "9"],
+  ])("rejects an %s simulated amount", (_, amount) => {
+    expect(() =>
+      validateAmount(
+        nativeToScVal(BigInt(amount), { type: "i128" }),
+        BigInt(10),
+      ),
+    ).toThrow(/does not match/);
+  });
+
+  it("rejects a rounded response above Number.MAX_SAFE_INTEGER", () => {
+    expect(() =>
+      validateAmount(
+        nativeToScVal(BigInt("9007199254740992"), { type: "i128" }),
+        BigInt("9007199254740993"),
+      ),
+    ).toThrow(/does not match/);
+  });
+
+  it.each(["0", "-1"])("rejects a simulated amount of %s", (amount) => {
+    expect(() =>
+      validateAmount(
+        nativeToScVal(BigInt(amount), { type: "i128" }),
+        BigInt(amount),
+      ),
+    ).toThrow(/does not match/);
+  });
+
+  it.each(["0", "-1"])("rejects a selected amount of %s", (amount) => {
+    expect(() =>
+      validateAmount(
+        nativeToScVal(BigInt(10), { type: "i128" }),
+        BigInt(amount),
+      ),
+    ).toThrow(/does not match/);
+  });
+
+  it("rejects the correct amount encoded with the wrong integer type", () => {
+    expect(() =>
+      validateAmount(nativeToScVal(BigInt(10), { type: "u128" }), BigInt(10)),
+    ).toThrow(/does not match/);
+  });
+
+  it("rejects substituting a classic payment for an expected token transfer", () => {
+    expect(() =>
+      assertSoranTransactionRoute(build().toXDR(), route(), network, {
+        ...context,
+        expectedTokenAmount: BigInt(10000000),
+      }),
+    ).toThrow(/does not match/);
+  });
+
+  it("continues validating collectible token IDs independently of fungible amounts", () => {
+    const collectibleContext = {
+      ...context,
+      isCollectible: true,
+      collectionAddress: contract,
+      tokenId: 42,
+    };
+    const collectibleXdr = (tokenId: number) =>
+      build(
+        transfer(
+          recipient,
+          payer,
+          contract,
+          "transfer",
+          nativeToScVal(tokenId, { type: "u32" }),
+        ),
+      ).toXDR();
+
+    expect(() =>
+      assertSoranTransactionRoute(
+        collectibleXdr(42),
+        route(),
+        network,
+        collectibleContext,
+      ),
+    ).not.toThrow();
+    expect(() =>
+      assertSoranTransactionRoute(
+        collectibleXdr(43),
+        route(),
+        network,
+        collectibleContext,
+      ),
+    ).toThrow(/does not match/);
+    expect(() =>
+      assertSoranTransactionRoute(collectibleXdr(42), route(), network, {
+        ...collectibleContext,
+        expectedTokenAmount: BigInt(10),
+      }),
+    ).toThrow(/does not match/);
+  });
+});
+
+describe("calculating exact Soran token amounts", () => {
+  it.each([
+    ["1", 0, "1"],
+    ["1.0000000", 0, "1"],
+    ["1.25", 7, "12500000"],
+    ["0.0000001", 7, "1"],
+    ["900719925.4740993", 7, "9007199254740993"],
+    [
+      "170141183460469231731687303715884105727",
+      0,
+      "170141183460469231731687303715884105727",
+    ],
+  ] as const)(
+    "scales %s by %s decimals without rounding",
+    (amount, decimals, expected) => {
+      expect(getSoranTokenAmount(amount, decimals)).toBe(BigInt(expected));
+    },
+  );
+
+  it.each([
+    ["0.00000001", 7],
+    ["1.12345678", 7],
+    ["1.5", 0],
+    ["0", 7],
+    ["-1", 7],
+    ["NaN", 7],
+    ["Infinity", 7],
+    ["", 7],
+    ["invalid", 7],
+    ["170141183460469231731687303715884105728", 0],
+    ["170141183460469231731687303715884105727", 1],
+    ["1e1000000", 7],
+  ] as const)(
+    "rejects an invalid or unrepresentable amount %s at %s decimals",
+    (amount, decimals) => {
+      expect(() => getSoranTokenAmount(amount, decimals)).toThrow(
+        /does not match/,
+      );
+    },
+  );
+
+  it.each([
+    -1,
+    1.5,
+    NaN,
+    Infinity,
+    Number.MAX_SAFE_INTEGER + 1,
+    Number.MAX_SAFE_INTEGER,
+  ])("rejects invalid decimals %s", (decimals) => {
+    expect(() => getSoranTokenAmount("1", decimals)).toThrow(/does not match/);
+  });
+});
diff --git a/extension/src/popup/helpers/soranTransaction.ts b/extension/src/popup/helpers/soranTransaction.ts
index e09b60af35..2794728776 100644
--- a/extension/src/popup/helpers/soranTransaction.ts
+++ b/extension/src/popup/helpers/soranTransaction.ts
@@ -1,3 +1,4 @@
+import BigNumber from "bignumber.js";
 import {
   Address,
   Asset,
@@ -20,14 +21,42 @@ export interface SoranTransactionContext {
   isCollectible?: boolean;
   collectionAddress?: string;
   tokenId?: number | null;
+  // Exact base units calculated locally before accepting a simulation. Later
+  // signing checks can bind the already validated reviewed transaction instead.
+  expectedTokenAmount?: bigint;
 }
 
+const MAX_SORAN_TOKEN_AMOUNT = new BigNumber(
+  "170141183460469231731687303715884105727",
+);
+
 const mismatch = () =>
   new Error(
     i18n.t(
       "Transaction does not match the Soran payment details. Select the recipient again.",
     ),
   );
+
+export const getSoranTokenAmount = (
+  amount: string,
+  decimals: number,
+): bigint => {
+  try {
+    if (!Number.isSafeInteger(decimals) || decimals < 0) throw mismatch();
+    const baseUnits = new BigNumber(amount).shiftedBy(decimals);
+    if (
+      !baseUnits.isFinite() ||
+      !baseUnits.isInteger() ||
+      !baseUnits.gt(0) ||
+      baseUnits.gt(MAX_SORAN_TOKEN_AMOUNT)
+    )
+      throw mismatch();
+    return BigInt(baseUnits.toFixed(0));
+  } catch {
+    throw mismatch();
+  }
+};
+
 export const unsupportedSoranMuxed = () =>
   new Error(
     i18n.t(
@@ -99,6 +128,11 @@ export const assertSoranTransactionRoute = (
       throw mismatch();
     const op = tx.operations[0];
     if (op.source && op.source !== context.publicKey) throw mismatch();
+    if (
+      context.expectedTokenAmount !== undefined &&
+      (op.type !== "invokeHostFunction" || context.isCollectible)
+    )
+      throw mismatch();
     let destination: string;
     if (op.type === "invokeHostFunction") {
       if (
@@ -126,8 +160,16 @@ export const assertSoranTransactionRoute = (
           scValToNative(value) !== context.tokenId
         )
           throw mismatch();
-      } else if (value.type !== "scvI128" || scValToNative(value) <= BigInt(0))
-        throw mismatch();
+      } else {
+        if (value.type !== "scvI128") throw mismatch();
+        const amount = scValToNative(value);
+        if (
+          amount <= BigInt(0) ||
+          (context.expectedTokenAmount !== undefined &&
+            amount !== context.expectedTokenAmount)
+        )
+          throw mismatch();
+      }
     } else {
       // Contract assets and collectibles must never be replaced with a classic payment.
       if (

From 0062587017d254bc3584457b8147d0c5cf5f60e9 Mon Sep 17 00:00:00 2001
From: flarcos <onadekogbolahan@gmail.com>
Date: Sat, 12 Sep 2026 20:51:27 +0100
Subject: [PATCH 09/10] Fix Soran simulation freshness and history edge cases

---
 .../useSubmitTxData.telemetry.test.tsx        |  63 +++
 .../hooks/useSubmitTxData.tsx                 |   2 +-
 .../__tests__/SendAmount.soranReview.test.tsx | 235 ++++++++++
 .../useSimulateTxData.soran.test.tsx          | 407 +++++++++++++++++-
 .../SendAmount/hooks/useSimulateTxData.tsx    |  87 ++--
 .../components/send/SendAmount/index.tsx      |  46 +-
 .../SendTo/__tests__/SendTo.races.test.tsx    |  40 +-
 .../popup/components/send/SendTo/index.tsx    |  10 +-
 .../hooks/useSimulateTxData.ts                |  89 ++--
 .../helpers/__tests__/soranAdversary.test.tsx |  17 +-
 .../__tests__/soranTransaction.test.ts        |  70 +++
 .../src/popup/helpers/soranTransaction.ts     |  34 +-
 .../popup/helpers/useSoranSimulationGuard.ts  |  97 +++++
 .../__tests__/useGetHistoryData.test.tsx      | 209 +++++++--
 .../hooks/useGetHistoryData.tsx               |  15 +-
 15 files changed, 1296 insertions(+), 125 deletions(-)
 create mode 100644 extension/src/popup/components/send/SendAmount/__tests__/SendAmount.soranReview.test.tsx
 create mode 100644 extension/src/popup/helpers/useSoranSimulationGuard.ts

diff --git a/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/__tests__/useSubmitTxData.telemetry.test.tsx b/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/__tests__/useSubmitTxData.telemetry.test.tsx
index df3643a7a0..03cede17a8 100644
--- a/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/__tests__/useSubmitTxData.telemetry.test.tsx
+++ b/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/__tests__/useSubmitTxData.telemetry.test.tsx
@@ -940,6 +940,69 @@ describe("Soran reviewed transaction binding at submission", () => {
   });
 
   describe.each([false, true])("hardware wallet: %s", (isHardwareWallet) => {
+    it.each([false, true])(
+      "validates a Soran path payment when the caller sets isSwap (altered: %s)",
+      async (altered) => {
+        const reviewed = buildTransaction(
+          Operation.pathPaymentStrictSend(pathPayment),
+        );
+        const signed = buildTransaction(
+          Operation.pathPaymentStrictSend({
+            ...pathPayment,
+            sendAmount: altered ? "101" : pathPayment.sendAmount,
+          }),
+        );
+        signed.sign(SOURCE_KEYPAIR);
+        const signedXdr = signed.toXDR();
+        const state = makeState({
+          asset: USDC_CANONICAL,
+          destinationAsset: "native",
+          destinationAmount: "90",
+          preparedTransaction: isHardwareWallet ? signedXdr : null,
+        });
+        state.transactionSubmission.transactionData.federationAddress =
+          "alice.nova";
+        jest
+          .spyOn(ApiInternal, "signFreighterTransaction")
+          .mockResolvedValue({ signedTransaction: signedXdr });
+        const { result, store } = renderSubmitHook(
+          state,
+          MAINNET_NETWORK_DETAILS,
+          { isHardwareWallet, transactionXdr: reviewed.toXDR() },
+        );
+
+        await act(async () => {
+          await result.current.fetchData({ isSwap: true });
+        });
+
+        expect(Soran.verifySoranDestination).toHaveBeenCalledWith(
+          "alice.nova",
+          { address: DESTINATION, memo: "", memoType: "" },
+          MAINNET_NETWORK_DETAILS,
+        );
+        if (altered) {
+          expect(global.fetch).not.toHaveBeenCalled();
+          expect(ApiInternal.saveSoranPaymentName).not.toHaveBeenCalled();
+          expect(store.getState().transactionSubmission.submitStatus).toBe(
+            ActionStatus.ERROR,
+          );
+        } else {
+          expect(global.fetch).toHaveBeenCalled();
+          expect(ApiInternal.saveSoranPaymentName).toHaveBeenCalledWith(
+            PUBLIC_KEY,
+            expect.objectContaining({
+              name: "alice.nova",
+              destination: DESTINATION,
+              transactionHash: Buffer.from(signed.hash()).toString("hex"),
+            }),
+          );
+          expect(store.getState().transactionSubmission.submitStatus).toBe(
+            ActionStatus.SUCCESS,
+          );
+        }
+      },
+    );
+
     it.each([
       {
         change: "payment amount",
diff --git a/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/useSubmitTxData.tsx b/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/useSubmitTxData.tsx
index e38292476b..b40101fcde 100644
--- a/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/useSubmitTxData.tsx
+++ b/extension/src/popup/components/InternalTransaction/SubmitTransaction/hooks/useSubmitTxData.tsx
@@ -154,7 +154,7 @@ function useSubmitTxData({
         status: "success",
       } as SubmitTxData;
 
-      const isSoranPayment = !isSwap && isSoranName(federationAddress || "");
+      const isSoranPayment = isSoranName(federationAddress || "");
       const expectedSoranRoute = {
         address: destination,
         memo: memo || "",
diff --git a/extension/src/popup/components/send/SendAmount/__tests__/SendAmount.soranReview.test.tsx b/extension/src/popup/components/send/SendAmount/__tests__/SendAmount.soranReview.test.tsx
new file mode 100644
index 0000000000..4036c48e2b
--- /dev/null
+++ b/extension/src/popup/components/send/SendAmount/__tests__/SendAmount.soranReview.test.tsx
@@ -0,0 +1,235 @@
+import React from "react";
+import {
+  act,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from "@testing-library/react";
+import { Provider } from "react-redux";
+import { MemoryRouter } from "react-router-dom";
+import BigNumber from "bignumber.js";
+import { AssetType } from "stellar-sdk";
+
+import { TESTNET_NETWORK_DETAILS } from "@shared/constants/stellar";
+import { APPLICATION_STATE } from "@shared/constants/applicationState";
+import { defaultBlockaidScanAssetResult } from "@shared/helpers/stellar";
+import { RequestState, State } from "constants/request";
+import { AppDataType } from "helpers/hooks/useGetAppData";
+import { makeDummyStore } from "popup/__testHelpers__";
+import {
+  initialState,
+  saveFederationAddress,
+} from "popup/ducks/transactionSubmission";
+import { NetworkCongestion } from "popup/helpers/useNetworkFees";
+import { SimulateTxData } from "types/transactions";
+import { SendAmount } from "..";
+import * as sendAmountData from "../hooks/useSendAmountData";
+
+jest.mock("popup/components/InternalTransaction/ReviewTransaction", () => ({
+  ReviewTx: () => <div data-testid="review-tx">Review</div>,
+}));
+
+const destination = "GBES5UHJYI445RV4XBGWHZOMBW4RYXBHOX47ZNZAJZAH2WP42ZEP2DYQ";
+const successState: State<SimulateTxData, string> = {
+  state: RequestState.SUCCESS,
+  data: { transactionXdr: "reviewed-xdr" },
+  error: null,
+};
+const errorState: State<SimulateTxData, string> = {
+  state: RequestState.ERROR,
+  data: null,
+  error: "Unable to validate Soran destination",
+};
+
+const renderSend = (
+  federationAddress: string,
+  simulationState: State<SimulateTxData, string>,
+  ok: boolean,
+) => {
+  const store = makeDummyStore({
+    transactionSubmission: {
+      ...initialState,
+      transactionData: {
+        ...initialState.transactionData,
+        asset: "native",
+        amount: "5",
+        destination,
+        federationAddress,
+        transactionFee: "0.00001",
+      },
+    },
+  });
+  const fetchSimulationData = jest
+    .fn()
+    .mockResolvedValue(
+      ok
+        ? { ok: true, data: successState.data }
+        : { ok: false, error: errorState.error },
+    );
+  const component = (state: State<SimulateTxData, string>) => (
+    <SendAmount
+      goBack={jest.fn()}
+      goToNext={jest.fn()}
+      goToChooseDest={jest.fn()}
+      goToChooseAsset={jest.fn()}
+      simulationState={state}
+      fetchSimulationData={fetchSimulationData}
+      networkCongestion={NetworkCongestion.LOW}
+      recommendedFee="0.00001"
+    />
+  );
+  const rendered = render(component(simulationState), {
+    wrapper: ({ children }) => (
+      <Provider store={store}>
+        <MemoryRouter>{children}</MemoryRouter>
+      </Provider>
+    ),
+  });
+  return {
+    store,
+    fetchSimulationData,
+    rerenderSimulation: (state: State<SimulateTxData, string>) =>
+      rendered.rerender(component(state)),
+  };
+};
+
+const review = async () => {
+  await act(async () => {
+    fireEvent.click(screen.getByTestId("send-amount-btn-continue"));
+  });
+};
+
+beforeEach(() => {
+  jest.spyOn(sendAmountData, "useGetSendAmountData").mockReturnValue({
+    state: {
+      state: RequestState.SUCCESS,
+      error: null,
+      data: {
+        type: AppDataType.RESOLVED,
+        applicationState: APPLICATION_STATE.MNEMONIC_PHRASE_CONFIRMED,
+        publicKey: destination,
+        networkDetails: TESTNET_NETWORK_DETAILS,
+        icons: {},
+        userBalances: {
+          isFunded: true,
+          subentryCount: 0,
+          balances: [
+            {
+              token: { type: AssetType.native, code: "XLM" },
+              total: new BigNumber("100"),
+              available: new BigNumber("100"),
+              buyingLiabilities: "0",
+              sellingLiabilities: "0",
+              minimumBalance: "1",
+              blockaidData: defaultBlockaidScanAssetResult,
+            },
+          ],
+        },
+        destinationBalances: { balances: [], isFunded: true, subentryCount: 0 },
+        domains: [],
+        tokenPrices: {},
+      },
+    },
+    fetchData: jest.fn().mockResolvedValue(undefined),
+  });
+});
+afterEach(() => jest.restoreAllMocks());
+
+it.each([errorState, successState])(
+  "does not open Soran review for failed or stale simulation results: $state",
+  async (simulationState) => {
+    const { fetchSimulationData } = renderSend(
+      "alice.nova",
+      simulationState,
+      false,
+    );
+    await review();
+    expect(fetchSimulationData).toHaveBeenCalledTimes(1);
+    expect(screen.queryByTestId("review-tx")).not.toBeInTheDocument();
+  },
+);
+
+it("shows Soran simulation errors on the amount screen and allows retry", async () => {
+  const { fetchSimulationData, rerenderSimulation } = renderSend(
+    "alice.nova",
+    errorState,
+    false,
+  );
+  expect(
+    screen.getByText("Failed to fetch your transaction details"),
+  ).toBeInTheDocument();
+  expect(screen.getByText(errorState.error)).toBeInTheDocument();
+  expect(screen.getByTestId("send-amount-btn-continue")).not.toBeDisabled();
+  await review();
+  await review();
+  expect(fetchSimulationData).toHaveBeenCalledTimes(2);
+  expect(screen.queryByTestId("review-tx")).not.toBeInTheDocument();
+
+  fetchSimulationData.mockResolvedValue({ ok: true, data: successState.data });
+  rerenderSimulation(successState);
+  await review();
+  expect(fetchSimulationData).toHaveBeenCalledTimes(3);
+  expect(screen.getByTestId("review-tx")).toBeInTheDocument();
+});
+
+it("keeps the existing review error path for unnamed classic payments", async () => {
+  renderSend("", errorState, false);
+  await review();
+  expect(screen.getByTestId("review-tx")).toBeInTheDocument();
+});
+
+it("ignores an unnamed classic completion after selecting a Soran name", async () => {
+  const { fetchSimulationData, store } = renderSend("", errorState, false);
+  let finish!: (result: { ok: false; error: string }) => void;
+  fetchSimulationData.mockReturnValueOnce(
+    new Promise((resolve) => {
+      finish = resolve;
+    }),
+  );
+  await review();
+  expect(fetchSimulationData).toHaveBeenCalledTimes(1);
+  await act(async () => {
+    store.dispatch(saveFederationAddress("alice.nova"));
+    finish({ ok: false, error: "Simulation inputs changed" });
+  });
+  expect(screen.queryByTestId("review-tx")).not.toBeInTheDocument();
+});
+
+it("opens review for a successful Soran simulation", async () => {
+  renderSend("alice.nova", successState, true);
+  await review();
+  expect(screen.getByTestId("review-tx")).toBeInTheDocument();
+});
+
+it.each<State<SimulateTxData, string>>([
+  { state: RequestState.IDLE, data: null, error: null },
+  { state: RequestState.LOADING, data: null, error: null },
+  errorState,
+])("closes Soran review when simulation becomes $state", async (nextState) => {
+  const { rerenderSimulation } = renderSend("alice.nova", successState, true);
+  await review();
+  expect(screen.getByTestId("review-tx")).toBeInTheDocument();
+  rerenderSimulation(nextState);
+  await waitFor(() =>
+    expect(screen.queryByTestId("review-tx")).not.toBeInTheDocument(),
+  );
+});
+
+it("does not close an unnamed classic review when simulation reports an error", async () => {
+  const { rerenderSimulation } = renderSend("", successState, true);
+  await review();
+  rerenderSimulation(errorState);
+  expect(screen.getByTestId("review-tx")).toBeInTheDocument();
+});
+
+it("closes an unnamed review when selecting Soran invalidates its simulation", async () => {
+  const { store, rerenderSimulation } = renderSend("", successState, true);
+  await review();
+  expect(screen.getByTestId("review-tx")).toBeInTheDocument();
+  await act(async () => {
+    store.dispatch(saveFederationAddress("alice.nova"));
+    rerenderSimulation({ state: RequestState.IDLE, data: null, error: null });
+  });
+  expect(screen.queryByTestId("review-tx")).not.toBeInTheDocument();
+});
diff --git a/extension/src/popup/components/send/SendAmount/hooks/__tests__/useSimulateTxData.soran.test.tsx b/extension/src/popup/components/send/SendAmount/hooks/__tests__/useSimulateTxData.soran.test.tsx
index 4252db32c0..0b582acb01 100644
--- a/extension/src/popup/components/send/SendAmount/hooks/__tests__/useSimulateTxData.soran.test.tsx
+++ b/extension/src/popup/components/send/SendAmount/hooks/__tests__/useSimulateTxData.soran.test.tsx
@@ -7,6 +7,7 @@ import {
   Address,
   Contract,
   Keypair,
+  MuxedAccount,
   TransactionBuilder,
   nativeToScVal,
   rpc,
@@ -18,9 +19,19 @@ import { RequestState } from "constants/request";
 import { AccountBalances } from "helpers/hooks/useGetBalances";
 import * as MuxedAddress from "helpers/muxedAddress";
 import { makeDummyStore } from "popup/__testHelpers__";
-import { initialState as submissionInitialState } from "popup/ducks/transactionSubmission";
+import {
+  initialState as submissionInitialState,
+  saveAmount,
+  saveCollectibleData,
+  saveFederationAddress,
+  saveMemoAndType,
+} from "popup/ducks/transactionSubmission";
+import { useSimulateTxData as useCollectibleSimulation } from "popup/components/sendCollectible/SelectedCollectible/hooks/useSimulateTxData";
 import * as AccountHelpers from "popup/helpers/account";
 import * as Soran from "popup/helpers/soran";
+import i18n from "popup/helpers/localizationConfig";
+import portugueseTranslations from "popup/locales/pt/translation.json";
+import { FederationMemoType } from "popup/helpers/federationMemo";
 import { SimulateResult, useSimulateTxData } from "../useSimulateTxData";
 
 const mockFetchBalances = jest.fn();
@@ -42,9 +53,9 @@ const RECIPIENT = Keypair.random().publicKey();
 const CONTRACT = "CCVKI6UYJDO34LO4D653IXCTPBGJOHJSJGSIOB4A46IH4ULNHS2MPQL7";
 const NETWORK = TESTNET_NETWORK_DETAILS;
 
-const buildTransfer = (amount: bigint) =>
+const buildTransfer = (amount: bigint, fee = "200") =>
   new TransactionBuilder(new Account(PAYER, "0"), {
-    fee: "100",
+    fee,
     networkPassphrase: NETWORK.networkPassphrase,
   })
     .addOperation(
@@ -59,7 +70,29 @@ const buildTransfer = (amount: bigint) =>
     .build()
     .toXDR();
 
-const renderSimulation = (amount: string, decimals: number) => {
+const buildCollectibleTransfer = (tokenId: number, fee = "200") =>
+  new TransactionBuilder(new Account(PAYER, "0"), {
+    fee,
+    networkPassphrase: NETWORK.networkPassphrase,
+  })
+    .addOperation(
+      new Contract(CONTRACT).call(
+        "transfer",
+        new Address(PAYER).toScVal(),
+        new Address(RECIPIENT).toScVal(),
+        nativeToScVal(tokenId, { type: "u32" }),
+      ),
+    )
+    .setTimeout(0)
+    .build()
+    .toXDR();
+
+const renderSimulation = (
+  amount: string,
+  decimals: number,
+  destination = RECIPIENT,
+  isCollectible = false,
+) => {
   const balances: AccountBalances = {
     isFunded: true,
     subentryCount: 0,
@@ -83,24 +116,34 @@ const renderSimulation = (amount: string, decimals: number) => {
         ...submissionInitialState.transactionData,
         asset: `TOKEN:${CONTRACT}`,
         amount,
-        destination: RECIPIENT,
+        destination,
         federationAddress: "alice.nova",
+        isCollectible,
+        collectibleData: {
+          ...submissionInitialState.transactionData.collectibleData,
+          collectionAddress: CONTRACT,
+          tokenId: 1,
+        },
       },
     },
   });
   const wrapper = ({ children }: { children: React.ReactNode }) => (
     <Provider store={store}>{children}</Provider>
   );
+  const useSimulation = isCollectible
+    ? useCollectibleSimulation
+    : useSimulateTxData;
   const rendered = renderHook(
-    () =>
-      useSimulateTxData({
-        publicKey: PAYER,
-        destination: RECIPIENT,
-        networkDetails: NETWORK,
+    (props) =>
+      useSimulation({
+        ...props,
         simParams: { type: "soroban", xdr: "" },
         isMainnet: false,
       }),
-    { wrapper },
+    {
+      wrapper,
+      initialProps: { publicKey: PAYER, destination, networkDetails: NETWORK },
+    },
   );
   return { ...rendered, store };
 };
@@ -256,3 +299,345 @@ describe("Soran token amount validation before review", () => {
     },
   );
 });
+
+const deferred = <Value,>() => {
+  let resolve!: (value: Value) => void;
+  let reject!: (error: Error) => void;
+  const promise = new Promise<Value>((done, fail) => {
+    resolve = done;
+    reject = fail;
+  });
+  return { promise, resolve, reject };
+};
+
+describe("Soran simulation request freshness", () => {
+  beforeEach(() => {
+    jest.spyOn(Soran, "verifySoranDestination").mockResolvedValue(undefined);
+    jest.spyOn(AccountHelpers, "getBaseAccount").mockResolvedValue(RECIPIENT);
+    jest.spyOn(MuxedAddress, "checkIsMuxedSupported").mockResolvedValue(false);
+    mockScanTx.mockResolvedValue(null);
+  });
+  afterEach(() => {
+    jest.restoreAllMocks();
+    mockFetchBalances.mockReset();
+    mockScanTx.mockReset();
+  });
+
+  const response = (units: bigint) => ({
+    ok: true,
+    response: {
+      preparedTransaction: buildTransfer(units),
+      simulationResponse: {
+        minResourceFee: "100",
+      } as rpc.Api.SimulateTransactionSuccessResponse,
+    },
+  });
+
+  it.each(["amount", "payer", "destination", "network", "unmount"])(
+    "discards a prepared transaction after changing %s",
+    async (change) => {
+      const pending = deferred<ReturnType<typeof response>>();
+      jest
+        .spyOn(ApiInternal, "simulateTokenTransfer")
+        .mockReturnValue(pending.promise);
+      const { result, store, rerender, unmount } = renderSimulation("1", 7);
+      let request!: Promise<SimulateResult>;
+      await act(async () => {
+        request = result.current.fetchData();
+      });
+      expect(ApiInternal.simulateTokenTransfer).toHaveBeenCalledTimes(1);
+      act(() => {
+        if (change === "amount") store.dispatch(saveAmount("2"));
+        else if (change === "unmount") unmount();
+        else
+          rerender({
+            publicKey: change === "payer" ? RECIPIENT : PAYER,
+            destination: change === "destination" ? PAYER : RECIPIENT,
+            networkDetails:
+              change === "network"
+                ? { ...NETWORK, sorobanRpcUrl: "https://other.example/rpc" }
+                : NETWORK,
+          });
+      });
+      await act(async () => {
+        pending.resolve(response(BigInt(10000000)));
+        expect(await request).toMatchObject({ ok: false });
+      });
+      expect(mockScanTx).not.toHaveBeenCalled();
+      expect(
+        store.getState().transactionSubmission.transactionSimulation
+          .preparedTransaction,
+      ).toBeNull();
+      if (change !== "unmount") expect(result.current.state.data).toBeNull();
+    },
+  );
+
+  it("does not save or expose a response changed while scanning", async () => {
+    mockSimulation(BigInt(10000000));
+    const scan = deferred<null>();
+    mockScanTx.mockReturnValue(scan.promise);
+    const { result, store } = renderSimulation("1", 7);
+    let request!: Promise<SimulateResult>;
+    await act(async () => {
+      request = result.current.fetchData();
+    });
+    expect(mockScanTx).toHaveBeenCalledTimes(1);
+    expect(
+      store.getState().transactionSubmission.transactionSimulation
+        .preparedTransaction,
+    ).toBeNull();
+    act(() => {
+      store.dispatch(saveAmount("2"));
+    });
+    await act(async () => {
+      scan.resolve(null);
+      expect(await request).toMatchObject({ ok: false });
+    });
+    expect(result.current.state.data).toBeNull();
+    expect(
+      store.getState().transactionSubmission.transactionSimulation
+        .preparedTransaction,
+    ).toBeNull();
+  });
+
+  it.each([false, true])(
+    "preserves a newer simulation when an older request finishes (error: %s)",
+    async (fails) => {
+      const older = deferred<ReturnType<typeof response>>();
+      jest
+        .spyOn(ApiInternal, "simulateTokenTransfer")
+        .mockReturnValueOnce(older.promise)
+        .mockResolvedValueOnce(response(BigInt(20000000)));
+      const { result, store } = renderSimulation("1", 7);
+      let first!: Promise<SimulateResult>;
+      await act(async () => {
+        first = result.current.fetchData();
+      });
+      act(() => {
+        store.dispatch(saveAmount("2"));
+      });
+      await act(async () => {
+        expect(await result.current.fetchData()).toMatchObject({ ok: true });
+      });
+      const latest = result.current.state.data;
+      const saved =
+        store.getState().transactionSubmission.transactionSimulation;
+      await act(async () => {
+        if (fails) older.reject(new Error("untrusted stale error"));
+        else older.resolve(response(BigInt(10000000)));
+        expect(await first).toMatchObject({ ok: false });
+      });
+      expect(result.current.state.data).toEqual(latest);
+      expect(
+        store.getState().transactionSubmission.transactionSimulation,
+      ).toEqual(saved);
+    },
+  );
+
+  it("hides an accepted review when its amount changes", async () => {
+    mockSimulation(BigInt(10000000));
+    const { result, store } = renderSimulation("1", 7);
+    await act(async () => {
+      await result.current.fetchData();
+    });
+    expect(result.current.state.state).toBe(RequestState.SUCCESS);
+    act(() => {
+      store.dispatch(saveAmount("2"));
+    });
+    expect(result.current.state.data).toBeNull();
+  });
+
+  it("prevents an older direct-address simulation from overwriting a Soran review", async () => {
+    const older = deferred<ReturnType<typeof response>>();
+    jest
+      .spyOn(ApiInternal, "simulateTokenTransfer")
+      .mockReturnValueOnce(older.promise)
+      .mockResolvedValueOnce(response(BigInt(20000000)));
+    const { result, store } = renderSimulation("1", 7);
+    act(() => {
+      store.dispatch(saveFederationAddress(""));
+    });
+    let first!: Promise<SimulateResult>;
+    await act(async () => {
+      first = result.current.fetchData();
+    });
+    act(() => {
+      store.dispatch(saveAmount("2"));
+      store.dispatch(saveFederationAddress("alice.nova"));
+    });
+    await act(async () => {
+      expect(await result.current.fetchData()).toMatchObject({ ok: true });
+    });
+    const latest = result.current.state.data;
+    const saved = store.getState().transactionSubmission.transactionSimulation;
+    await act(async () => {
+      older.resolve(response(BigInt(10000000)));
+      expect(await first).toMatchObject({ ok: false });
+    });
+    expect(result.current.state.data).toEqual(latest);
+    expect(
+      store.getState().transactionSubmission.transactionSimulation,
+    ).toEqual(saved);
+  });
+
+  it("discards a collectible simulation after selecting another token ID", async () => {
+    const transaction = buildCollectibleTransfer(1);
+    const pending = deferred<ReturnType<typeof response>>();
+    jest
+      .spyOn(ApiInternal, "simulateSendCollectible")
+      .mockReturnValue(pending.promise);
+    const { result, store } = renderSimulation("1", 7, RECIPIENT, true);
+    let request!: Promise<SimulateResult>;
+    await act(async () => {
+      request = result.current.fetchData();
+    });
+    act(() => {
+      store.dispatch(
+        saveCollectibleData({
+          ...store.getState().transactionSubmission.transactionData
+            .collectibleData,
+          tokenId: 2,
+        }),
+      );
+    });
+    await act(async () => {
+      pending.resolve({
+        ...response(BigInt(1)),
+        response: {
+          ...response(BigInt(1)).response,
+          preparedTransaction: transaction,
+        },
+      });
+      expect(await request).toMatchObject({ ok: false });
+    });
+    expect(mockScanTx).not.toHaveBeenCalled();
+    expect(result.current.state.data).toBeNull();
+    expect(
+      store.getState().transactionSubmission.transactionSimulation
+        .preparedTransaction,
+    ).toBeNull();
+  });
+
+  describe.each([false, true])("collectible: %s", (isCollectible) => {
+    it.each(["100", "200", "300"])(
+      "checks the prepared fee %s against the reviewed fee",
+      async (fee) => {
+        const preparedTransaction = isCollectible
+          ? buildCollectibleTransfer(1, fee)
+          : buildTransfer(BigInt(10000000), fee);
+        jest
+          .spyOn(
+            ApiInternal,
+            isCollectible ? "simulateSendCollectible" : "simulateTokenTransfer",
+          )
+          .mockResolvedValue({
+            ...response(BigInt(10000000)),
+            response: {
+              ...response(BigInt(10000000)).response,
+              preparedTransaction,
+            },
+          });
+        const { result, store } = renderSimulation(
+          "1",
+          7,
+          RECIPIENT,
+          isCollectible,
+        );
+        await act(async () => {
+          expect(await result.current.fetchData()).toMatchObject({
+            ok: fee === "200",
+          });
+        });
+        if (fee === "200") {
+          expect(mockScanTx).toHaveBeenCalledTimes(1);
+          expect(
+            store.getState().transactionSubmission.transactionSimulation
+              .preparedTransaction,
+          ).toBe(preparedTransaction);
+        } else {
+          expect(mockScanTx).not.toHaveBeenCalled();
+          expect(result.current.state.data).toBeNull();
+          expect(
+            store.getState().transactionSubmission.transactionSimulation
+              .preparedTransaction,
+          ).toBeNull();
+        }
+      },
+    );
+  });
+});
+
+it("shows the Portuguese Soran error for an unsupported muxed token recipient", async () => {
+  const locale = jest
+    .requireActual<typeof import("i18next")>("i18next")
+    .createInstance();
+  await locale.init({
+    lng: "pt-BR",
+    resources: { pt: { translation: portugueseTranslations } },
+  });
+  jest.spyOn(i18n, "t").mockImplementation(locale.t);
+  jest.spyOn(Soran, "verifySoranDestination").mockResolvedValue(undefined);
+  jest.spyOn(AccountHelpers, "getBaseAccount").mockResolvedValue(RECIPIENT);
+  jest.spyOn(MuxedAddress, "checkIsMuxedSupported").mockResolvedValue(false);
+  const { simulate } = mockSimulation(BigInt(10000000));
+  const muxed = new MuxedAccount(new Account(RECIPIENT, "0"), "42").accountId();
+  const { result, store } = renderSimulation("1", 7, muxed);
+  try {
+    let response: SimulateResult | undefined;
+    await act(async () => {
+      response = await result.current.fetchData();
+    });
+    const message =
+      "Esta transferência não pode preservar o endereço muxed Soran. Escolha outro destinatário.";
+    expect(response).toEqual({ ok: false, error: message });
+    expect(result.current.state).toMatchObject({
+      state: RequestState.ERROR,
+      error: message,
+    });
+    expect(simulate).not.toHaveBeenCalled();
+    expect(
+      store.getState().transactionSubmission.transactionSimulation
+        .preparedTransaction,
+    ).toBeNull();
+  } finally {
+    jest.restoreAllMocks();
+    mockFetchBalances.mockReset();
+    mockScanTx.mockReset();
+  }
+});
+
+it("shows the Portuguese Soran error when a token cannot preserve the required memo", async () => {
+  const locale = jest
+    .requireActual<typeof import("i18next")>("i18next")
+    .createInstance();
+  await locale.init({
+    lng: "pt-BR",
+    resources: { pt: { translation: portugueseTranslations } },
+  });
+  jest.spyOn(i18n, "t").mockImplementation(locale.t);
+  jest.spyOn(Soran, "verifySoranDestination").mockResolvedValue(undefined);
+  const { simulate } = mockSimulation(BigInt(10000000));
+  const { result, store } = renderSimulation("1", 7);
+  act(() => {
+    store.dispatch(
+      saveMemoAndType({ memo: "hello", memoType: FederationMemoType.Text }),
+    );
+  });
+  try {
+    await act(async () => {
+      expect(await result.current.fetchData()).toEqual({
+        ok: false,
+        error:
+          portugueseTranslations[
+            "This token transfer cannot preserve the Soran memo"
+          ],
+      });
+    });
+    expect(simulate).not.toHaveBeenCalled();
+    expect(result.current.state.data).toBeNull();
+  } finally {
+    jest.restoreAllMocks();
+    mockFetchBalances.mockReset();
+    mockScanTx.mockReset();
+  }
+});
diff --git a/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx b/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx
index 409ae9a7f3..b9aad08426 100644
--- a/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx
+++ b/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx
@@ -2,6 +2,9 @@ import {
   assertSoranTransactionRoute,
   getSoranTokenAmount,
   unsupportedSoranMuxed,
+  unsupportedSoranMemo,
+  UnsupportedSoranMuxedError,
+  UnsupportedSoranMemoError,
 } from "popup/helpers/soranTransaction";
 import { useReducer } from "react";
 import { splitCanonical } from "@shared/helpers/stellar";
@@ -65,6 +68,7 @@ import {
 } from "helpers/muxedAddress";
 import { SimulateTxData, SimulateResult } from "types/transactions";
 import { getCurrentTransactionFee } from "popup/helpers/fees";
+import { useSoranSimulationGuard } from "popup/helpers/useSoranSimulationGuard";
 
 export type { SimulateTxData, SimulateResult };
 
@@ -435,6 +439,11 @@ function useSimulateTxData({
   const store = useStore();
   const { asset, amount, transactionFee, memo, memoType, isCollectible } =
     useSelector(transactionDataSelector);
+  const simulationGuard = useSoranSimulationGuard({
+    publicKey,
+    destination,
+    networkDetails,
+  });
 
   const { scanTx } = useScanTx();
   const [state, dispatch] = useReducer(
@@ -452,6 +461,7 @@ function useSimulateTxData({
   });
 
   const fetchData = async () => {
+    const request = simulationGuard.beginRequest();
     dispatch({ type: "FETCH_DATA_START" });
     try {
       // Read memo and transactionFee from Redux state inside fetchData to get the latest values
@@ -472,11 +482,10 @@ function useSimulateTxData({
           },
           networkDetails,
         );
+        request.assertCurrent();
         // The token transfer backend cannot preserve typed transaction memos.
         if (simParams.type === "soroban" && currentMemo) {
-          throw new Error(
-            t("This token transfer cannot preserve the Soran memo"),
-          );
+          throw unsupportedSoranMemo();
         }
       }
       const currentAmount = currentTransactionData.amount || amount;
@@ -580,12 +589,13 @@ function useSimulateTxData({
             sorobanMemo = "";
           }
         } catch (error) {
-          if (isSoranPayment) throw error;
+          if (isSoranPayment) throw unsupportedSoranMuxed();
           // If we can't determine muxed destination, use original destination
           console.error("Error determining muxed destination:", error);
         }
       }
 
+      request.assertCurrent();
       const simResponse = await simulateTx({
         type: simParams.type,
         recommendedFee: currentTransactionFee,
@@ -604,6 +614,7 @@ function useSimulateTxData({
           },
         },
       });
+      request.assertCurrent();
       if (isSoranPayment && simParams.type === "soroban") {
         assertSoranTransactionRoute(
           simResponse.payload?.preparedTransaction || "",
@@ -613,20 +624,31 @@ function useSimulateTxData({
             memoType: currentMemoType || "",
           },
           networkDetails,
-          { publicKey, asset: currentAsset, expectedTokenAmount },
+          {
+            publicKey,
+            asset: currentAsset,
+            expectedTokenAmount,
+            expectedFee: getSoranTokenAmount(
+              simResponse.recommendedFee,
+              CLASSIC_ASSET_DECIMALS,
+            ),
+          },
         );
       }
       const simulationResponse =
         simResponse.payload && "simulationTransaction" in simResponse.payload
           ? simResponse.payload?.simulationTransaction
           : "";
-      reduxDispatch(saveTransactionFee(simResponse.recommendedFee));
-      reduxDispatch(
-        saveSimulation({
-          preparedTransaction: simResponse.payload?.preparedTransaction,
-          response: simulationResponse,
-        }),
-      );
+      const saveSimulationResult = () => {
+        reduxDispatch(saveTransactionFee(simResponse.recommendedFee));
+        reduxDispatch(
+          saveSimulation({
+            preparedTransaction: simResponse.payload?.preparedTransaction,
+            response: simulationResponse,
+          }),
+        );
+      };
+      if (!isSoranPayment) saveSimulationResult();
 
       if (simResponse.inclusionFee !== undefined) {
         payload.inclusionFee = simResponse.inclusionFee;
@@ -676,6 +698,19 @@ function useSimulateTxData({
         );
         const xdr = transaction.build().toXdr();
         payload.transactionXdr = xdr;
+        request.assertCurrent();
+        if (isSoranPayment) {
+          assertSoranTransactionRoute(
+            xdr,
+            {
+              address: destination,
+              memo: currentMemo || "",
+              memoType: currentMemoType || "",
+            },
+            networkDetails,
+            { publicKey, asset: currentAsset },
+          );
+        }
         payload.scanResult = applyExpectedToFailReason({
           scanResult: await scanTx(xdr, scanUrlstub, networkDetails),
           expectedToFailReason,
@@ -694,21 +729,18 @@ function useSimulateTxData({
         });
       }
 
-      if (isSoranPayment && simParams.type === "classic") {
-        assertSoranTransactionRoute(
-          payload.transactionXdr,
-          {
-            address: destination,
-            memo: currentMemo || "",
-            memoType: currentMemoType || "",
-          },
-          networkDetails,
-          { publicKey, asset: currentAsset },
-        );
-      }
+      request.assertCurrent();
+      if (isSoranPayment) saveSimulationResult();
       dispatch({ type: "FETCH_DATA_SUCCESS", payload });
       return { ok: true, data: payload } as SimulateResult;
     } catch (error) {
+      if (!request.isCurrent()) {
+        return {
+          ok: false,
+          error:
+            "We had an issue retrieving your transaction details. Please try again.",
+        } as SimulateResult;
+      }
       // Report the real cause here (the generic user-facing string below is not
       // a useful reason_code). Matches mobile's payment.simulation_failed.
       // `network` is NOT hand-added — it rides on buildCommonContext. (Mobile
@@ -723,14 +755,17 @@ function useSimulateTxData({
             : "unknown",
       });
       const errorMessage =
-        "We had an issue retrieving your transaction details. Please try again.";
+        error instanceof UnsupportedSoranMuxedError ||
+        error instanceof UnsupportedSoranMemoError
+          ? error.message
+          : "We had an issue retrieving your transaction details. Please try again.";
       dispatch({ type: "FETCH_DATA_ERROR", payload: errorMessage });
       return { ok: false, error: errorMessage } as SimulateResult;
     }
   };
 
   return {
-    state,
+    state: simulationGuard.isCurrent() ? state : initialState,
     fetchData,
   };
 }
diff --git a/extension/src/popup/components/send/SendAmount/index.tsx b/extension/src/popup/components/send/SendAmount/index.tsx
index 4a91a35b0d..0b7529a50a 100644
--- a/extension/src/popup/components/send/SendAmount/index.tsx
+++ b/extension/src/popup/components/send/SendAmount/index.tsx
@@ -1,5 +1,5 @@
 import React, { useState, useEffect, useRef } from "react";
-import { useDispatch, useSelector } from "react-redux";
+import { useDispatch, useSelector, useStore } from "react-redux";
 import { Navigate, useLocation } from "react-router-dom";
 import BigNumber from "bignumber.js";
 import { useFormik } from "formik";
@@ -10,7 +10,7 @@ import { LoadingBackground } from "popup/basics/LoadingBackground";
 import { View } from "popup/basics/layout/View";
 import { METRIC_NAMES } from "popup/constants/metricsNames";
 import { isSoranName } from "popup/helpers/soran";
-import { AppDispatch } from "popup/App";
+import { AppDispatch, AppState } from "popup/App";
 import { isNativeAssetId } from "@shared/helpers/assetIdentity";
 import {
   getAssetFromCanonical,
@@ -43,6 +43,7 @@ import {
 } from "popup/helpers/formatters";
 import {
   transactionSubmissionSelector,
+  transactionDataSelector,
   saveAmount,
   saveAsset,
   saveIsToken,
@@ -119,6 +120,7 @@ export const SendAmount = ({
   const { t } = useTranslation();
   const location = useLocation();
   const dispatch = useDispatch<AppDispatch>();
+  const store = useStore<AppState>();
   const { transactionData } = useSelector(transactionSubmissionSelector);
   const networkDetails = useSelector(settingsNetworkDetailsSelector);
   const {
@@ -136,6 +138,7 @@ export const SendAmount = ({
     manualTransactionFee,
   } = transactionData;
   const fee = transactionFee || recommendedFee;
+  const isSoranPayment = isSoranName(federationAddress || "");
 
   // Persist the last-known inclusion fee across re-simulations so the
   // EditSettings input never jumps back to the total fee while LOADING
@@ -199,6 +202,18 @@ export const SendAmount = ({
   // so neither is reported as a rejection.
   const wasReviewingRef = useRef(false);
   const skipRejectionRef = useRef(false);
+  const isReviewingSoranRef = useRef(false);
+
+  useEffect(() => {
+    if (
+      isReviewingTx &&
+      (isReviewingSoranRef.current || isSoranPayment) &&
+      simulationState.state !== RequestState.SUCCESS
+    ) {
+      skipRejectionRef.current = true;
+      setIsReviewingTx(false);
+    }
+  }, [isReviewingTx, isSoranPayment, simulationState.state]);
 
   /**
    * Reports the review stages: the `confirm` stage when the review opens, and
@@ -375,16 +390,21 @@ export const SendAmount = ({
       dispatch(saveTransactionFee(fee));
     }
     const simResult = await fetchSimulationData();
-    // For Soroban, only open the review modal on success — on failure the fee
-    // display shows the error state and the user can retry.
-    // For classic sends, always proceed to review: ReviewTx already handles the
-    // error UI for RequestState.ERROR, so blocking navigation would leave the
-    // user with no feedback path.
+    const currentIsSoranPayment = isSoranName(
+      transactionDataSelector(store.getState()).federationAddress || "",
+    );
+    // Soroban and named Soran sends require a successful simulation. Their
+    // errors appear on the amount screen so the user can retry. Unnamed classic
+    // sends retain the review's existing error display.
     // Note: for Soroban, fetchSimulationData internally dispatches
     // saveTransactionFee again with the simulated total fee. The dispatch
     // above resets to the inclusion fee so the simulation starts from a clean
     // base; the one inside fetchSimulationData overwrites it with the result.
-    if (simResult.ok || (!isToken && !isCollectible)) {
+    if (
+      simResult.ok ||
+      (!isToken && !isCollectible && !isSoranPayment && !currentIsSoranPayment)
+    ) {
+      isReviewingSoranRef.current = isSoranPayment || currentIsSoranPayment;
       setIsReviewingTx(true);
     }
   };
@@ -713,7 +733,7 @@ export const SendAmount = ({
             </div>
             {isCollectible ? (
               <>
-                {(isToken || isCollectible) &&
+                {(isToken || isCollectible || isSoranPayment) &&
                 simulationState.state === RequestState.ERROR ? (
                   <Notification
                     variant="error"
@@ -728,7 +748,8 @@ export const SendAmount = ({
                   disabled={
                     !destination ||
                     isMuxedAddressWithoutMemoSupport ||
-                    simulationState.state === RequestState.ERROR
+                    (!isSoranPayment &&
+                      simulationState.state === RequestState.ERROR)
                   }
                   isLoading={simulationState.state === RequestState.LOADING}
                   data-testid="send-collectible-btn-continue"
@@ -742,7 +763,7 @@ export const SendAmount = ({
               </>
             ) : (
               <>
-                {(isToken || isCollectible) &&
+                {(isToken || isCollectible || isSoranPayment) &&
                 simulationState.state === RequestState.ERROR ? (
                   <Notification
                     variant="error"
@@ -759,7 +780,8 @@ export const SendAmount = ({
                     !isAmountInputValid ||
                     isAmountTooHigh ||
                     isMuxedAddressWithoutMemoSupport ||
-                    ((isToken || isCollectible) &&
+                    (!isSoranPayment &&
+                      (isToken || isCollectible) &&
                       simulationState.state === RequestState.ERROR)
                   }
                   isLoading={simulationState.state === RequestState.LOADING}
diff --git a/extension/src/popup/components/send/SendTo/__tests__/SendTo.races.test.tsx b/extension/src/popup/components/send/SendTo/__tests__/SendTo.races.test.tsx
index 9095a79a49..c5bb2a3e12 100644
--- a/extension/src/popup/components/send/SendTo/__tests__/SendTo.races.test.tsx
+++ b/extension/src/popup/components/send/SendTo/__tests__/SendTo.races.test.tsx
@@ -3,7 +3,13 @@ import { act, fireEvent, render, screen } from "@testing-library/react";
 import { MemoryRouter } from "react-router-dom";
 import { Federation } from "stellar-sdk";
 import { SendTo } from "..";
-import { saveDestination } from "popup/ducks/transactionSubmission";
+import {
+  saveDestination,
+  saveFederationAddress,
+  saveMemoAndType,
+} from "popup/ducks/transactionSubmission";
+import * as Soran from "popup/helpers/soran";
+import { FederationMemoType } from "popup/helpers/federationMemo";
 
 const mockPayer = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";
 const mockAlice = "GBHKTFVBDUA6RYP5JM4SPZ76OXYAAHV4QHUOFV4S4TK342FMVGPHA2WN";
@@ -197,3 +203,35 @@ it("does not start a superseded debounced lookup after selecting a recent", asyn
   expect(resolve).toHaveBeenCalledWith("bob*example.com");
   expect(next).toHaveBeenCalledTimes(1);
 });
+
+it("settles a recent Soran name clicked before its matching input debounce", async () => {
+  const resolve = jest.spyOn(Soran, "resolveSoranName").mockResolvedValue({
+    name: "alice.nova",
+    address: mockAlice,
+    memo: "hello",
+    memoType: FederationMemoType.Text,
+  });
+  const { next } = await mount();
+  await act(async () => {
+    fireEvent.change(screen.getByTestId("send-to-input"), {
+      target: { value: "alice.nova" },
+    });
+  });
+  await click("alice.nova");
+  await act(async () => {
+    await jest.advanceTimersByTimeAsync(400);
+  });
+
+  expect(resolve).toHaveBeenCalledTimes(1);
+  expect(screen.getByTestId("send-to-suggestion-button")).toBeInTheDocument();
+  await act(async () => {
+    fireEvent.click(screen.getByTestId("send-to-btn-continue"));
+  });
+  expect(next).toHaveBeenCalledTimes(1);
+  expect(saveDestination).toHaveBeenCalledWith(mockAlice);
+  expect(saveFederationAddress).toHaveBeenCalledWith("alice.nova");
+  expect(saveMemoAndType).toHaveBeenCalledWith({
+    memo: "hello",
+    memoType: FederationMemoType.Text,
+  });
+});
diff --git a/extension/src/popup/components/send/SendTo/index.tsx b/extension/src/popup/components/send/SendTo/index.tsx
index c81ec98f0d..3be47f19a9 100644
--- a/extension/src/popup/components/send/SendTo/index.tsx
+++ b/extension/src/popup/components/send/SendTo/index.tsx
@@ -422,8 +422,14 @@ export const SendTo = ({
                       // Re-enter the normal resolution flow, including errors and network checks.
                       if (isSoranName(address)) {
                         formik.setFieldValue("destination", address);
-                        if (formik.values.destination === address)
-                          await fetchData(address, {});
+                        if (formik.values.destination === address) {
+                          setDebouncedDestination(address);
+                          const errors = await formik.validateForm({
+                            destination: address,
+                          });
+                          if (selectionId !== selectionIdRef.current) return;
+                          await fetchData(address, errors);
+                        }
                         return;
                       }
                       const result = await fetchData(address, {});
diff --git a/extension/src/popup/components/sendCollectible/SelectedCollectible/hooks/useSimulateTxData.ts b/extension/src/popup/components/sendCollectible/SelectedCollectible/hooks/useSimulateTxData.ts
index f3ac4e335b..c2d77f0de5 100644
--- a/extension/src/popup/components/sendCollectible/SelectedCollectible/hooks/useSimulateTxData.ts
+++ b/extension/src/popup/components/sendCollectible/SelectedCollectible/hooks/useSimulateTxData.ts
@@ -1,6 +1,9 @@
 import {
   assertSoranTransactionRoute,
+  getSoranTokenAmount,
   unsupportedSoranMuxed,
+  UnsupportedSoranMuxedError,
+  UnsupportedSoranMemoError,
 } from "popup/helpers/soranTransaction";
 import { isSoranName, verifySoranDestination } from "popup/helpers/soran";
 import { StrKey } from "stellar-sdk";
@@ -28,6 +31,7 @@ import {
 import { AppDispatch, AppState } from "popup/App";
 import { useScanTx } from "popup/helpers/blockaid";
 import { SimulateTxData, SimulateResult } from "types/transactions";
+import { useSoranSimulationGuard } from "popup/helpers/useSoranSimulationGuard";
 
 export type { SimulateTxData };
 
@@ -98,6 +102,11 @@ function useSimulateTxData({
   const { transactionFee, collectibleData } = useSelector(
     transactionDataSelector,
   );
+  const simulationGuard = useSoranSimulationGuard({
+    publicKey,
+    destination,
+    networkDetails,
+  });
 
   const { scanTx } = useScanTx();
   const [state, dispatch] = useReducer(
@@ -106,6 +115,7 @@ function useSimulateTxData({
   );
 
   const fetchData = async () => {
+    const request = simulationGuard.beginRequest();
     dispatch({ type: "FETCH_DATA_START" });
     try {
       // Read transactionFee from Redux state inside fetchData to get the latest values
@@ -115,6 +125,9 @@ function useSimulateTxData({
       );
       const soranName = currentTransactionData.federationAddress || "";
       const isSoranPayment = isSoranName(soranName);
+      const currentCollectibleData = isSoranPayment
+        ? currentTransactionData.collectibleData
+        : collectibleData;
       if (isSoranPayment) {
         if (StrKey.isValidMed25519PublicKey(destination))
           throw unsupportedSoranMuxed();
@@ -123,6 +136,7 @@ function useSimulateTxData({
           { address: destination, memo: "", memoType: "" },
           networkDetails,
         );
+        request.assertCurrent();
       }
       const currentTransactionFee = getCurrentTransactionFee({
         currentTransactionFee: currentTransactionData.transactionFee,
@@ -132,7 +146,7 @@ function useSimulateTxData({
       const payload = { transactionXdr: "" } as SimulateTxData;
       let destinationAccount = await getBaseAccount(destination);
 
-      if (collectibleData.tokenId === null) {
+      if (currentCollectibleData.tokenId === null) {
         throw new Error("Token ID is required");
       }
 
@@ -140,15 +154,16 @@ function useSimulateTxData({
         throw new Error("Destination account not found");
       }
 
+      request.assertCurrent();
       const simResponse = await simulateTx({
         recommendedFee: currentTransactionFee,
         options: {
           sendCollectible: {
-            collectionAddress: collectibleData.collectionAddress,
+            collectionAddress: currentCollectibleData.collectionAddress,
             publicKey,
             params: {
-              collectionAddress: collectibleData.collectionAddress,
-              tokenId: collectibleData.tokenId,
+              collectionAddress: currentCollectibleData.collectionAddress,
+              tokenId: currentCollectibleData.tokenId,
               publicKey,
               destination: destinationAccount,
             },
@@ -157,17 +172,39 @@ function useSimulateTxData({
           },
         },
       });
+      request.assertCurrent();
+      if (isSoranPayment) {
+        assertSoranTransactionRoute(
+          simResponse.payload?.preparedTransaction || "",
+          { address: destination, memo: "", memoType: "" },
+          networkDetails,
+          {
+            publicKey,
+            asset: currentTransactionData.asset,
+            isCollectible: true,
+            collectionAddress: currentCollectibleData.collectionAddress,
+            tokenId: currentCollectibleData.tokenId,
+            expectedFee: getSoranTokenAmount(
+              simResponse.recommendedFee,
+              CLASSIC_ASSET_DECIMALS,
+            ),
+          },
+        );
+      }
       const simulationResponse =
         simResponse.payload && "simulationTransaction" in simResponse.payload
           ? simResponse.payload?.simulationTransaction
           : "";
-      reduxDispatch(saveTransactionFee(simResponse.recommendedFee));
-      reduxDispatch(
-        saveSimulation({
-          preparedTransaction: simResponse.payload?.preparedTransaction,
-          response: simulationResponse,
-        }),
-      );
+      const saveSimulationResult = () => {
+        reduxDispatch(saveTransactionFee(simResponse.recommendedFee));
+        reduxDispatch(
+          saveSimulation({
+            preparedTransaction: simResponse.payload?.preparedTransaction,
+            response: simulationResponse,
+          }),
+        );
+      };
+      if (!isSoranPayment) saveSimulationResult();
 
       if (simResponse.inclusionFee !== undefined) {
         payload.inclusionFee = simResponse.inclusionFee;
@@ -185,25 +222,23 @@ function useSimulateTxData({
         networkDetails,
       );
 
-      if (isSoranPayment) {
-        assertSoranTransactionRoute(
-          payload.transactionXdr,
-          { address: destination, memo: "", memoType: "" },
-          networkDetails,
-          {
-            publicKey,
-            asset: currentTransactionData.asset,
-            isCollectible: true,
-            collectionAddress: collectibleData.collectionAddress,
-            tokenId: collectibleData.tokenId,
-          },
-        );
-      }
+      request.assertCurrent();
+      if (isSoranPayment) saveSimulationResult();
       dispatch({ type: "FETCH_DATA_SUCCESS", payload });
       return { ok: true, data: payload } as SimulateResult;
     } catch (error) {
+      if (!request.isCurrent()) {
+        return {
+          ok: false,
+          error:
+            "We had an issue retrieving your transaction details. Please try again.",
+        } as SimulateResult;
+      }
       const errorMessage =
-        "We had an issue retrieving your transaction details. Please try again.";
+        error instanceof UnsupportedSoranMuxedError ||
+        error instanceof UnsupportedSoranMemoError
+          ? error.message
+          : "We had an issue retrieving your transaction details. Please try again.";
       dispatch({ type: "FETCH_DATA_ERROR", payload: errorMessage });
       captureException(
         `error simulating collectible transaction: ${JSON.stringify(error)}`,
@@ -213,7 +248,7 @@ function useSimulateTxData({
   };
 
   return {
-    state,
+    state: simulationGuard.isCurrent() ? state : initialState,
     fetchData,
   };
 }
diff --git a/extension/src/popup/helpers/__tests__/soranAdversary.test.tsx b/extension/src/popup/helpers/__tests__/soranAdversary.test.tsx
index 1cef5023a3..a6721cf6c8 100644
--- a/extension/src/popup/helpers/__tests__/soranAdversary.test.tsx
+++ b/extension/src/popup/helpers/__tests__/soranAdversary.test.tsx
@@ -27,6 +27,8 @@ import { initialState as submissionInitialState } from "popup/ducks/transactionS
 import { makeDummyStore } from "popup/__testHelpers__";
 import * as api from "@shared/api/internal";
 import * as soran from "popup/helpers/soran";
+import i18n from "popup/helpers/localizationConfig";
+import portugueseTranslations from "popup/locales/pt/translation.json";
 
 jest.mock("webextension-polyfill", () => ({
   __esModule: true,
@@ -236,7 +238,15 @@ it("rejects account creation that would drop a Soran muxed ID", async () => {
   ).toThrow(/cannot preserve/);
 });
 
-it("rejects a collectible muxed route before requesting simulation", async () => {
+it("shows the Portuguese muxed error before requesting collectible simulation", async () => {
+  const locale = jest
+    .requireActual<typeof import("i18next")>("i18next")
+    .createInstance();
+  await locale.init({
+    lng: "pt-BR",
+    resources: { pt: { translation: portugueseTranslations } },
+  });
+  jest.spyOn(i18n, "t").mockImplementation(locale.t);
   mockLookup(muxed);
   expect(await soran.resolveSoranName("mux.nova", network)).toMatchObject({
     address: muxed,
@@ -274,7 +284,10 @@ it("rejects a collectible muxed route before requesting simulation", async () =>
   await act(async () => {
     response = await result.current.fetchData();
   });
-  expect(response).toMatchObject({ ok: false });
+  const message =
+    "Esta transferência não pode preservar o endereço muxed Soran. Escolha outro destinatário.";
+  expect(response).toEqual({ ok: false, error: message });
+  expect(result.current.state.error).toBe(message);
   expect(simulate).not.toHaveBeenCalled();
 });
 
diff --git a/extension/src/popup/helpers/__tests__/soranTransaction.test.ts b/extension/src/popup/helpers/__tests__/soranTransaction.test.ts
index 8bd7be1e88..bd24be8d63 100644
--- a/extension/src/popup/helpers/__tests__/soranTransaction.test.ts
+++ b/extension/src/popup/helpers/__tests__/soranTransaction.test.ts
@@ -15,6 +15,10 @@ import { TESTNET_NETWORK_DETAILS as network } from "@shared/constants/stellar";
 import {
   assertSoranTransactionRoute,
   getSoranTokenAmount,
+  unsupportedSoranMemo,
+  UnsupportedSoranMemoError,
+  unsupportedSoranMuxed,
+  UnsupportedSoranMuxedError,
 } from "../soranTransaction";
 
 const payer = Keypair.random().publicKey();
@@ -68,6 +72,28 @@ const transfer = (
     value,
   );
 
+it("identifies the trusted muxed-transfer error without inspecting untrusted messages", () => {
+  const error = unsupportedSoranMuxed();
+  expect(error).toBeInstanceOf(UnsupportedSoranMuxedError);
+  expect(error.message).toBe(
+    "This transfer cannot preserve the Soran muxed address. Choose another recipient.",
+  );
+  expect(new Error(error.message)).not.toBeInstanceOf(
+    UnsupportedSoranMuxedError,
+  );
+});
+
+it("identifies the trusted memo-transfer error without inspecting untrusted messages", () => {
+  const error = unsupportedSoranMemo();
+  expect(error).toBeInstanceOf(UnsupportedSoranMemoError);
+  expect(error.message).toBe(
+    "This token transfer cannot preserve the Soran memo",
+  );
+  expect(new Error(error.message)).not.toBeInstanceOf(
+    UnsupportedSoranMemoError,
+  );
+});
+
 it.each([recipient, muxed])(
   "accepts a complete classic destination and derives the history hash: %s",
   (destination) => {
@@ -736,3 +762,47 @@ describe("calculating exact Soran token amounts", () => {
     expect(() => getSoranTokenAmount("1", decimals)).toThrow(/does not match/);
   });
 });
+
+describe("binding the prepared fee to the fee shown for review", () => {
+  const prepared = (fee: string) =>
+    new TransactionBuilder(new Account(payer, "0"), {
+      fee,
+      networkPassphrase: network.networkPassphrase,
+    })
+      .addOperation(transfer())
+      .setTimeout(0)
+      .build()
+      .toXDR();
+
+  it("accepts the exact total fee in stroops", () => {
+    expect(() =>
+      assertSoranTransactionRoute(prepared("200"), route(), network, {
+        ...context,
+        expectedTokenAmount: BigInt(10),
+        expectedFee: BigInt(200),
+      }),
+    ).not.toThrow();
+  });
+
+  it.each(["100", "300"])(
+    "rejects a header fee of %s when review shows 200 stroops",
+    (fee) => {
+      expect(() =>
+        assertSoranTransactionRoute(prepared(fee), route(), network, {
+          ...context,
+          expectedTokenAmount: BigInt(10),
+          expectedFee: BigInt(200),
+        }),
+      ).toThrow(/does not match/);
+    },
+  );
+
+  it("preserves validation without a simulation fee expectation", () => {
+    expect(() =>
+      assertSoranTransactionRoute(prepared("300"), route(), network, {
+        ...context,
+        expectedTokenAmount: BigInt(10),
+      }),
+    ).not.toThrow();
+  });
+});
diff --git a/extension/src/popup/helpers/soranTransaction.ts b/extension/src/popup/helpers/soranTransaction.ts
index 2794728776..fb0e0b1a5e 100644
--- a/extension/src/popup/helpers/soranTransaction.ts
+++ b/extension/src/popup/helpers/soranTransaction.ts
@@ -24,6 +24,8 @@ export interface SoranTransactionContext {
   // Exact base units calculated locally before accepting a simulation. Later
   // signing checks can bind the already validated reviewed transaction instead.
   expectedTokenAmount?: bigint;
+  // Total fee displayed for the simulation, in stroops.
+  expectedFee?: bigint;
 }
 
 const MAX_SORAN_TOKEN_AMOUNT = new BigNumber(
@@ -57,12 +59,27 @@ export const getSoranTokenAmount = (
   }
 };
 
-export const unsupportedSoranMuxed = () =>
-  new Error(
-    i18n.t(
-      "This transfer cannot preserve the Soran muxed address. Choose another recipient.",
-    ),
-  );
+export class UnsupportedSoranMuxedError extends Error {
+  constructor() {
+    super(
+      i18n.t(
+        "This transfer cannot preserve the Soran muxed address. Choose another recipient.",
+      ),
+    );
+    this.name = "UnsupportedSoranMuxedError";
+  }
+}
+
+export const unsupportedSoranMuxed = () => new UnsupportedSoranMuxedError();
+
+export class UnsupportedSoranMemoError extends Error {
+  constructor() {
+    super(i18n.t("This token transfer cannot preserve the Soran memo"));
+    this.name = "UnsupportedSoranMemoError";
+  }
+}
+
+export const unsupportedSoranMemo = () => new UnsupportedSoranMemoError();
 
 const expectedContract = (
   context: SoranTransactionContext,
@@ -100,6 +117,11 @@ export const assertSoranTransactionRoute = (
       tx.source !== context.publicKey
     )
       throw mismatch();
+    if (
+      context.expectedFee !== undefined &&
+      BigInt(tx.fee) !== context.expectedFee
+    )
+      throw mismatch();
     if (reviewedTransactionXdr !== undefined) {
       const reviewed = TransactionBuilder.fromXDR(
         reviewedTransactionXdr,
diff --git a/extension/src/popup/helpers/useSoranSimulationGuard.ts b/extension/src/popup/helpers/useSoranSimulationGuard.ts
new file mode 100644
index 0000000000..e3fffcb511
--- /dev/null
+++ b/extension/src/popup/helpers/useSoranSimulationGuard.ts
@@ -0,0 +1,97 @@
+import { useEffect, useRef } from "react";
+import { useSelector, useStore } from "react-redux";
+import { NetworkDetails } from "@shared/constants/stellar";
+import { AppState } from "popup/App";
+import { publicKeySelector } from "popup/ducks/accountServices";
+import { settingsSelector } from "popup/ducks/settings";
+import { transactionDataSelector } from "popup/ducks/transactionSubmission";
+import { isSoranName } from "./soran";
+
+const snapshot = (state: AppState) => {
+  const data = transactionDataSelector(state);
+  // Simulation updates transactionFee itself. Only the explicitly edited fee
+  // belongs to the user's inputs; including the estimated fee cancels our result.
+  return JSON.stringify([
+    publicKeySelector(state),
+    settingsSelector(state).networkDetails,
+    data.amount,
+    data.asset,
+    data.decimals,
+    data.destination,
+    data.federationAddress,
+    data.memo,
+    data.memoType,
+    data.destinationAsset,
+    data.destinationAmount,
+    data.destinationDecimals,
+    data.path,
+    data.allowedSlippage,
+    data.transactionTimeout,
+    data.manualTransactionFee,
+    data.isToken,
+    data.isSoroswap,
+    data.isCollectible,
+    data.collectibleData.collectionAddress,
+    data.collectibleData.tokenId,
+  ]);
+};
+
+export const useSoranSimulationGuard = ({
+  publicKey,
+  destination,
+  networkDetails,
+}: {
+  publicKey: string;
+  destination: string;
+  networkDetails: NetworkDetails;
+}) => {
+  const store = useStore<AppState>();
+  // Re-render to hide a completed review as soon as its inputs change.
+  useSelector(snapshot);
+  const scope = JSON.stringify([publicKey, destination, networkDetails]);
+  const scopeRef = useRef(scope);
+  scopeRef.current = scope;
+  const requestIdRef = useRef(0);
+  const currentRequestRef = useRef<(() => boolean) | undefined>(undefined);
+  useEffect(
+    () => () => {
+      requestIdRef.current += 1;
+    },
+    [scope],
+  );
+
+  const beginRequest = () => {
+    const requestId = ++requestIdRef.current;
+    const currentState = store.getState();
+    const isSoranPayment = isSoranName(
+      transactionDataSelector(currentState).federationAddress || "",
+    );
+    const inputs = snapshot(currentState);
+    const isCurrent = () => {
+      const latestState = store.getState();
+      const protectsSoran =
+        isSoranPayment ||
+        isSoranName(
+          transactionDataSelector(latestState).federationAddress || "",
+        );
+      return (
+        !protectsSoran ||
+        (requestId === requestIdRef.current &&
+          scope === scopeRef.current &&
+          inputs === snapshot(latestState))
+      );
+    };
+    currentRequestRef.current = isCurrent;
+    return {
+      isCurrent,
+      assertCurrent: () => {
+        if (!isCurrent()) throw new Error("Soran simulation inputs changed");
+      },
+    };
+  };
+
+  return {
+    beginRequest,
+    isCurrent: () => currentRequestRef.current?.() ?? true,
+  };
+};
diff --git a/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx b/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx
index ae6c2c81c2..208f753fdf 100644
--- a/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx
+++ b/extension/src/popup/views/AccountHistory/hooks/__tests__/useGetHistoryData.test.tsx
@@ -1,12 +1,37 @@
-import { Account, Asset, MuxedAccount, Networks } from "stellar-sdk";
+import {
+  Account,
+  Address,
+  Asset,
+  Contract,
+  MuxedAccount,
+  Networks,
+  Operation,
+  TransactionBuilder,
+  nativeToScVal,
+} from "stellar-sdk";
 
 import { TESTNET_NETWORK_DETAILS } from "@shared/constants/stellar";
 import { SorobanTokenInterface } from "@shared/constants/soroban/token";
 import { HistoryItemOperation } from "popup/components/accountHistory/HistoryItem";
 import * as sorobanHelpers from "popup/helpers/soroban";
 import { AssetType } from "@shared/api/types/account-balance";
+import { fetchCollectibles } from "@shared/api/helpers/fetchCollectibles";
 import { getHistoryCounterparty } from "popup/helpers/soranHistory";
-import { getRowDataByOpType, CollectibleLookupMap } from "../useGetHistoryData";
+import {
+  getOperationDependencies,
+  getRowDataByOpType,
+  CollectibleLookupMap,
+} from "../useGetHistoryData";
+
+jest.mock("@shared/api/helpers/fetchCollectibles", () => ({
+  fetchCollectibles: jest.fn(),
+}));
+jest.mock("popup/App", () => ({
+  store: {
+    getState: () => ({ cache: { collections: {} } }),
+    dispatch: jest.fn(),
+  },
+}));
 
 // Base account owned by the wallet and its muxed (M...) forms.
 const PUBLIC_KEY = "GAJVUHQV535IYW25XBTWTCUXNHLQN4F2PGIPOOX4DDKL2UPNXUHWU7B3";
@@ -142,6 +167,57 @@ describe("getRowDataByOpType - classic payment muxed classification", () => {
   });
 });
 
+describe("account creation history naming", () => {
+  it.each([
+    { funder: COUNTERPARTY, account: PUBLIC_KEY, withOtherPayment: false },
+    { funder: PUBLIC_KEY, account: COUNTERPARTY, withOtherPayment: false },
+    { funder: COUNTERPARTY, account: PUBLIC_KEY, withOtherPayment: true },
+    { funder: PUBLIC_KEY, account: COUNTERPARTY, withOtherPayment: true },
+  ])(
+    "uses the funder and account belonging to this operation: %j",
+    async ({ funder, account, withOtherPayment }) => {
+      const tx = new TransactionBuilder(new Account(funder, "0"), {
+        networkPassphrase: TESTNET_NETWORK_DETAILS.networkPassphrase,
+        fee: "100",
+      });
+      if (withOtherPayment) {
+        tx.addOperation(
+          Operation.payment({
+            destination:
+              "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF",
+            asset: Asset.native(),
+            amount: "1",
+          }),
+        );
+      }
+      tx.addOperation(
+        Operation.createAccount({ destination: account, startingBalance: "5" }),
+      );
+      const row = await callGetRowData({
+        ...buildInvokeHostFnOperation(),
+        type: "create_account",
+        type_i: 0,
+        account,
+        funder,
+        starting_balance: "5",
+        isCreateExternalAccount: account !== PUBLIC_KEY,
+        transaction_attr: {
+          ...buildInvokeHostFnOperation().transaction_attr,
+          operation_count: withOtherPayment ? 2 : 1,
+          envelope_xdr: tx.setTimeout(0).build().toXDR(),
+        },
+      } as HistoryItemOperation);
+
+      expect(row.metadata.to).toBe(account);
+      expect(row.metadata.from).toBe(funder);
+      expect(getHistoryCounterparty(row)).toEqual({
+        address: COUNTERPARTY,
+        isReceiving: account === PUBLIC_KEY,
+      });
+    },
+  );
+});
+
 describe("getRowDataByOpType - Soroban token transfer muxed classification", () => {
   afterEach(() => {
     jest.restoreAllMocks();
@@ -300,41 +376,59 @@ it("preserves a muxed sender and transaction reference for history naming", asyn
 describe("collectible history naming", () => {
   afterEach(() => jest.restoreAllMocks());
 
+  const collectibleOperation = (from: string, to: string, tokenId: number) => {
+    const envelopeXdr = new TransactionBuilder(new Account(from, "0"), {
+      networkPassphrase: TESTNET_NETWORK_DETAILS.networkPassphrase,
+      fee: "100",
+    })
+      .addOperation(
+        new Contract(CONTRACT_ID).call(
+          SorobanTokenInterface.transfer,
+          new Address(from).toScVal(),
+          new Address(to).toScVal(),
+          nativeToScVal(tokenId, { type: "u32" }),
+        ),
+      )
+      .setTimeout(0)
+      .build()
+      .toXDR();
+    return buildInvokeHostFnOperation({
+      transaction_attr: {
+        operation_count: 1,
+        fee_charged: "100",
+        memo: "",
+        envelope_xdr: envelopeXdr,
+      },
+    });
+  };
+  const collectible = (owner: string, tokenId: number) => ({
+    collectionAddress: CONTRACT_ID,
+    collectionName: "Test collection",
+    tokenId: tokenId.toString(),
+    owner,
+    tokenUri: "",
+    metadata: null,
+  });
+
   it.each([
-    { from: COUNTERPARTY, to: PUBLIC_KEY, isReceiving: true },
-    { from: PUBLIC_KEY, to: COUNTERPARTY, isReceiving: false },
+    { from: COUNTERPARTY, to: PUBLIC_KEY, isReceiving: true, tokenId: 0 },
+    { from: PUBLIC_KEY, to: COUNTERPARTY, isReceiving: false, tokenId: 0 },
+    { from: COUNTERPARTY, to: PUBLIC_KEY, isReceiving: true, tokenId: 1 },
+    { from: PUBLIC_KEY, to: COUNTERPARTY, isReceiving: false, tokenId: 1 },
   ])(
     "preserves the sender and direction: %j",
-    async ({ from, to, isReceiving }) => {
-      jest
-        .spyOn(sorobanHelpers, "getAttrsFromSorobanHorizonOp")
-        .mockReturnValue({
-          fnName: SorobanTokenInterface.transfer,
-          contractId: CONTRACT_ID,
-          from,
-          to,
-          tokenId: 1,
-        });
+    async ({ from, to, isReceiving, tokenId }) => {
       const collectibles: CollectibleLookupMap = new Map([
-        [
-          `${CONTRACT_ID}:1`,
-          {
-            collectionAddress: CONTRACT_ID,
-            collectionName: "Test collection",
-            tokenId: "1",
-            owner: to,
-            tokenUri: "",
-            metadata: null,
-          },
-        ],
+        [`${CONTRACT_ID}:${tokenId}`, collectible(to, tokenId)],
       ]);
       const row = await callGetRowData(
-        buildInvokeHostFnOperation(),
+        collectibleOperation(from, to, tokenId),
         [],
         collectibles,
       );
       expect(row.metadata).toMatchObject({
         isCollectibleTransfer: true,
+        collectionTokenId: tokenId.toString(),
         from,
         to,
         isReceiving,
@@ -345,6 +439,69 @@ describe("collectible history naming", () => {
       });
     },
   );
+
+  it.each([
+    { from: COUNTERPARTY, to: PUBLIC_KEY, isReceiving: true },
+    { from: PUBLIC_KEY, to: COUNTERPARTY, isReceiving: false },
+  ])(
+    "fetches token zero through the batch dependency pipeline: %j",
+    async ({ from, to, isReceiving }) => {
+      const fetch = jest.mocked(fetchCollectibles);
+      fetch.mockClear();
+      fetch.mockResolvedValue([
+        {
+          collection: {
+            address: CONTRACT_ID,
+            name: "Test collection",
+            symbol: "TEST",
+            collectibles: [collectible(to, 0)],
+          },
+        },
+      ]);
+      const op = collectibleOperation(from, to, 0);
+      const { collectibleLookup } = await getOperationDependencies(
+        [op],
+        TESTNET_NETWORK_DETAILS,
+        PUBLIC_KEY,
+        {},
+      );
+      expect(fetch).toHaveBeenCalledWith({
+        publicKey: PUBLIC_KEY,
+        networkDetails: TESTNET_NETWORK_DETAILS,
+        contracts: [{ id: CONTRACT_ID, token_ids: ["0"] }],
+      });
+      expect(collectibleLookup.get(`${CONTRACT_ID}:0`)).toEqual(
+        collectible(to, 0),
+      );
+      const row = await callGetRowData(op, [], collectibleLookup);
+      expect(row.amount).toBe("#0");
+      expect(getHistoryCounterparty(row)).toEqual({
+        address: COUNTERPARTY,
+        isReceiving,
+      });
+    },
+  );
+
+  it("does not fetch or name a collectible without a token ID", async () => {
+    jest.spyOn(sorobanHelpers, "getAttrsFromSorobanHorizonOp").mockReturnValue({
+      fnName: SorobanTokenInterface.transfer,
+      contractId: CONTRACT_ID,
+      from: COUNTERPARTY,
+      to: PUBLIC_KEY,
+    });
+    jest.mocked(fetchCollectibles).mockClear();
+    const op = buildInvokeHostFnOperation();
+    const { collectibleLookup } = await getOperationDependencies(
+      [op],
+      TESTNET_NETWORK_DETAILS,
+      PUBLIC_KEY,
+      {},
+    );
+    expect(fetchCollectibles).not.toHaveBeenCalled();
+    const row = await callGetRowData(op, [], collectibleLookup);
+    expect(row.metadata.isCollectibleTransfer).toBeUndefined();
+    expect(getHistoryCounterparty(row)).toBeUndefined();
+  });
 });
 
 describe("token transfer history naming without asset balance changes", () => {
diff --git a/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx b/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx
index 9d03b93591..225701c508 100644
--- a/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx
+++ b/extension/src/popup/views/AccountHistory/hooks/useGetHistoryData.tsx
@@ -916,7 +916,7 @@ export const getRowDataByOpType = async (
       // otherwise, we treat this as a collectible transfer
       try {
         // if the tokenId is not present, we can't fetch the collectible; return generic invocation
-        if (!attrs.tokenId) {
+        if (attrs.tokenId === undefined) {
           return genericInvocation;
         }
 
@@ -967,13 +967,6 @@ export const getRowDataByOpType = async (
       // receiving some XLM to create(fund) your own account
       const isReceiving = !isCreateExternalAccount;
 
-      // Extract destination from XDR for createAccount (may be muxed if sent to muxed address)
-      const actualDestination = await extractDestinationFromXDR(
-        txEnvelopeXdr,
-        networkDetails,
-        account || "",
-      );
-
       const paymentDifference = isReceiving ? "+" : "-";
       const nonLabelAmount = formatAmount(
         new BigNumber(startingBalance!).toString(),
@@ -990,8 +983,8 @@ export const getRowDataByOpType = async (
           ...baseMetadata,
           isReceiving,
           nonLabelAmount,
-          to: actualDestination,
-          from,
+          to: account,
+          from: operation.funder,
         },
         rowIcon: (
           <div className="HistoryItem__icon__bordered">
@@ -1120,7 +1113,7 @@ export const getOperationDependencies = async (
       if (
         attrs &&
         attrs.fnName === SorobanCollectibleInterface.transfer &&
-        attrs.tokenId &&
+        attrs.tokenId !== undefined &&
         !attrs.amount
       ) {
         const contractId = attrs.contractId;

From e1d83a062fb0be55cbbe452556b27693c1c3fa64 Mon Sep 17 00:00:00 2001
From: flarcos <onadekogbolahan@gmail.com>
Date: Sat, 12 Sep 2026 21:12:15 +0100
Subject: [PATCH 10/10] Preserve exact Soran token amounts through simulation

---
 @shared/api/__tests__/internal.test.ts        | 174 +++++++++++++++++-
 @shared/api/internal.ts                       |  15 +-
 .../useSimulateTxData.soran.test.tsx          | 114 +++++++++++-
 .../SendAmount/hooks/useSimulateTxData.tsx    |   5 +-
 4 files changed, 298 insertions(+), 10 deletions(-)

diff --git a/@shared/api/__tests__/internal.test.ts b/@shared/api/__tests__/internal.test.ts
index 3240dfb7ad..8c45570cc9 100644
--- a/@shared/api/__tests__/internal.test.ts
+++ b/@shared/api/__tests__/internal.test.ts
@@ -1,4 +1,15 @@
-import { Networks } from "stellar-sdk";
+import {
+  Account,
+  Address,
+  MuxedAccount,
+  Networks,
+  SorobanDataBuilder,
+  Transaction,
+  TransactionBuilder,
+  nativeToScVal,
+  rpc,
+  scValToNative,
+} from "stellar-sdk";
 import {
   FUTURENET_NETWORK_DETAILS,
   MAINNET_NETWORK_DETAILS,
@@ -8,6 +19,7 @@ import * as GetLedgerKeyAccounts from "../helpers/getLedgerKeyAccounts";
 import * as internalApi from "../internal";
 import { sendMessageToBackground } from "@shared/api/helpers/extensionMessaging";
 import { SERVICE_TYPES } from "@shared/constants/services";
+import { CUSTOM_NETWORK } from "@shared/helpers/stellar";
 
 jest.mock("@shared/api/helpers/extensionMessaging");
 const mockedSend = sendMessageToBackground as jest.Mock;
@@ -194,6 +206,166 @@ describe("internalApi", () => {
         }),
       );
     });
+
+    const payer = "GBHKTFVBDUA6RYP5JM4SPZ76OXYAAHV4QHUOFV4S4TK342FMVGPHA2WN";
+    const recipient =
+      "GBES5UHJYI445RV4XBGWHZOMBW4RYXBHOX47ZNZAJZAH2WP42ZEP2DYQ";
+    const contract = "CCVKI6UYJDO34LO4D653IXCTPBGJOHJSJGSIOB4A46IH4ULNHS2MPQL7";
+    const muxed = new MuxedAccount(
+      new Account(recipient, "0"),
+      "18446744073709551615",
+    ).accountId();
+
+    const expectTransfer = (
+      transaction: Transaction,
+      destination: string,
+      amount: string,
+    ) => {
+      expect(transaction.source).toBe(payer);
+      expect(transaction.sequence).toBe("124");
+      expect(transaction.signatures).toHaveLength(0);
+      expect(transaction.operations).toHaveLength(1);
+      const operation = transaction.operations[0];
+      if (
+        operation.type !== "invokeHostFunction" ||
+        operation.func.type !== "hostFunctionTypeInvokeContract"
+      ) {
+        throw new Error("Expected a token transfer");
+      }
+      const invocation = operation.func.invokeContract;
+      expect(Address.fromScAddress(invocation.contractAddress).toString()).toBe(
+        contract,
+      );
+      expect(invocation.functionName.toString()).toBe("transfer");
+      expect(invocation.args).toHaveLength(3);
+      expect(Address.fromScVal(invocation.args[0]).toString()).toBe(payer);
+      expect(Address.fromScVal(invocation.args[1]).toString()).toBe(
+        destination,
+      );
+      expect(scValToNative(invocation.args[2])).toBe(BigInt(amount));
+    };
+
+    describe.each([
+      { route: "classic", destination: recipient },
+      { route: "muxed", destination: muxed },
+      { route: "contract", destination: contract },
+    ])("exact $route transfer", ({ destination }) => {
+      it.each(["9007199254740993", "170141183460469231731687303715884105727"])(
+        "encodes %s into the submitted simulation XDR without numeric rounding",
+        async (amount) => {
+          const account = jest
+            .spyOn(rpc.Server.prototype, "getAccount")
+            .mockResolvedValue(new Account(payer, "123"));
+          const submit = jest.spyOn(rpc.Server.prototype, "sendTransaction");
+          const simulationResponse = {
+            preparedTransaction: "prepared-xdr",
+            simulationResponse: { minResourceFee: "100" },
+          };
+          const fetchSpy = jest.spyOn(global, "fetch").mockResolvedValue({
+            ok: true,
+            json: async () => simulationResponse,
+          } as Response);
+
+          const result = await internalApi.simulateTokenTransfer({
+            address: contract,
+            publicKey: payer,
+            memo: "",
+            params: { publicKey: payer, destination, amount },
+            networkDetails: TESTNET_NETWORK_DETAILS,
+            transactionFee: "0.00001",
+          });
+
+          expect(account).toHaveBeenCalledWith(payer);
+          expect(fetchSpy).toHaveBeenCalledTimes(1);
+          const [url, options] = fetchSpy.mock.calls[0];
+          expect(url).toEqual(expect.stringContaining("/simulate-tx"));
+          const body = JSON.parse(options!.body as string);
+          expect(body.network_passphrase).toBe(
+            TESTNET_NETWORK_DETAILS.networkPassphrase,
+          );
+          expect(body).not.toHaveProperty("params");
+          const transaction = TransactionBuilder.fromXDR(
+            body.xdr,
+            body.network_passphrase,
+          );
+          expect(transaction).toBeInstanceOf(Transaction);
+          expectTransfer(transaction as Transaction, destination, amount);
+          expect(transaction.fee).toBe("100");
+          expect(result).toEqual({ ok: true, response: simulationResponse });
+          expect(submit).not.toHaveBeenCalled();
+        },
+      );
+    });
+
+    it.each(["9007199254740993", 10])(
+      "keeps custom-network RPC simulation exact for %s",
+      async (amount) => {
+        jest
+          .spyOn(rpc.Server.prototype, "getAccount")
+          .mockResolvedValue(new Account(payer, "123"));
+        const simulate = jest
+          .spyOn(rpc.Server.prototype, "simulateTransaction")
+          .mockResolvedValue({
+            _parsed: true,
+            id: "simulation",
+            latestLedger: 1,
+            minResourceFee: "100",
+            events: [],
+            transactionData: new SorobanDataBuilder().setResourceFee("100"),
+            result: { auth: [], retval: nativeToScVal(null) },
+          });
+        const fetchSpy = jest.spyOn(global, "fetch");
+        const networkDetails = {
+          ...TESTNET_NETWORK_DETAILS,
+          network: CUSTOM_NETWORK,
+        };
+        const result = await internalApi.simulateTokenTransfer({
+          address: contract,
+          publicKey: payer,
+          params: { publicKey: payer, destination: muxed, amount },
+          networkDetails,
+          transactionFee: "0.00001",
+        });
+        expect(result.ok).toBe(true);
+        expect(simulate).toHaveBeenCalledTimes(1);
+        expectTransfer(
+          simulate.mock.calls[0][0] as Transaction,
+          muxed,
+          String(amount),
+        );
+        const prepared = TransactionBuilder.fromXDR(
+          result.response.preparedTransaction,
+          networkDetails.networkPassphrase,
+        );
+        expectTransfer(prepared as Transaction, muxed, String(amount));
+        expect(prepared.fee).toBe("200");
+        expect(fetchSpy).not.toHaveBeenCalled();
+      },
+    );
+
+    it("rejects an exact transfer without RPC configuration before network access", async () => {
+      const fetchSpy = jest.spyOn(global, "fetch").mockResolvedValue({
+        ok: true,
+        json: async () => ({}),
+      } as Response);
+      await expect(
+        internalApi.simulateTokenTransfer({
+          address: contract,
+          publicKey: payer,
+          params: {
+            publicKey: payer,
+            destination: recipient,
+            amount: "9007199254740993",
+          },
+          networkDetails: {
+            ...TESTNET_NETWORK_DETAILS,
+            sorobanRpcUrl: undefined,
+          },
+          transactionFee: "0.00001",
+        }),
+      ).rejects.toThrow();
+      expect(fetchSpy).not.toHaveBeenCalled();
+    });
   });
 
   describe("getTokenPrices request payload filtering", () => {
diff --git a/@shared/api/internal.ts b/@shared/api/internal.ts
index 60ad7b6a9b..fc653ed2ef 100644
--- a/@shared/api/internal.ts
+++ b/@shared/api/internal.ts
@@ -2458,7 +2458,7 @@ export const simulateTokenTransfer = async (args: {
   params: {
     publicKey: string;
     destination: string;
-    amount: number;
+    amount: number | string;
   };
   networkDetails: NetworkDetails;
   transactionFee: string;
@@ -2472,7 +2472,8 @@ export const simulateTokenTransfer = async (args: {
   const { address, publicKey, memo, params, networkDetails, transactionFee } =
     args;
 
-  if (isCustomNetwork(networkDetails)) {
+  const isCustom = isCustomNetwork(networkDetails);
+  if (isCustom || typeof params.amount === "string") {
     if (!networkDetails.sorobanRpcUrl) {
       throw new SorobanRpcNotSupportedError();
     }
@@ -2493,6 +2494,14 @@ export const simulateTokenTransfer = async (args: {
       new XdrLargeInt("i128", params.amount).toI128(), // amount
     ];
     const transaction = transfer(address, transferParams, memo, builder);
+    if (!isCustom) {
+      // Carry exact integer amounts in XDR instead of the numeric token endpoint.
+      // This reuses the same simulation API as collectible transfers.
+      return simulateTransaction({
+        xdr: transaction.toXdr(),
+        networkDetails,
+      });
+    }
     // TODO: type narrow instead of cast
     const simulationResponse = (await server.simulateTransaction(
       transaction,
@@ -2531,7 +2540,7 @@ export const simulateTokenTransfer = async (args: {
     pub_key: publicKey,
     memo: memo || "", // Backend requires memo as string, use empty string if undefined
     fee: xlmToStroop(transactionFee).toFixed(),
-    params,
+    params: { ...params, amount: params.amount },
     network_passphrase: networkDetails.networkPassphrase,
   };
 
diff --git a/extension/src/popup/components/send/SendAmount/hooks/__tests__/useSimulateTxData.soran.test.tsx b/extension/src/popup/components/send/SendAmount/hooks/__tests__/useSimulateTxData.soran.test.tsx
index 0b582acb01..dc34a1de94 100644
--- a/extension/src/popup/components/send/SendAmount/hooks/__tests__/useSimulateTxData.soran.test.tsx
+++ b/extension/src/popup/components/send/SendAmount/hooks/__tests__/useSimulateTxData.soran.test.tsx
@@ -11,6 +11,7 @@ import {
   TransactionBuilder,
   nativeToScVal,
   rpc,
+  scValToNative,
 } from "stellar-sdk";
 
 import * as ApiInternal from "@shared/api/internal";
@@ -53,7 +54,7 @@ const RECIPIENT = Keypair.random().publicKey();
 const CONTRACT = "CCVKI6UYJDO34LO4D653IXCTPBGJOHJSJGSIOB4A46IH4ULNHS2MPQL7";
 const NETWORK = TESTNET_NETWORK_DETAILS;
 
-const buildTransfer = (amount: bigint, fee = "200") =>
+const buildTransfer = (amount: bigint, fee = "200", destination = RECIPIENT) =>
   new TransactionBuilder(new Account(PAYER, "0"), {
     fee,
     networkPassphrase: NETWORK.networkPassphrase,
@@ -62,7 +63,7 @@ const buildTransfer = (amount: bigint, fee = "200") =>
       new Contract(CONTRACT).call(
         "transfer",
         new Address(PAYER).toScVal(),
-        new Address(RECIPIENT).toScVal(),
+        new Address(destination).toScVal(),
         nativeToScVal(amount, { type: "i128" }),
       ),
     )
@@ -148,8 +149,8 @@ const renderSimulation = (
   return { ...rendered, store };
 };
 
-const mockSimulation = (amount: bigint) => {
-  const preparedTransaction = buildTransfer(amount);
+const mockSimulation = (amount: bigint, destination = RECIPIENT) => {
+  const preparedTransaction = buildTransfer(amount, "200", destination);
   const simulate = jest
     .spyOn(ApiInternal, "simulateTokenTransfer")
     .mockResolvedValue({
@@ -204,6 +205,11 @@ describe("Soran token amount validation before review", () => {
       });
 
       expect(simulate).toHaveBeenCalledTimes(1);
+      expect(simulate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          params: expect.objectContaining({ amount: units.toString() }),
+        }),
+      );
       expect(response).toMatchObject({
         ok: true,
         data: { transactionXdr: preparedTransaction },
@@ -300,6 +306,106 @@ describe("Soran token amount validation before review", () => {
   );
 });
 
+describe("Soran simulation through the API boundary", () => {
+  beforeEach(() => {
+    jest.spyOn(Soran, "verifySoranDestination").mockResolvedValue(undefined);
+    jest.spyOn(AccountHelpers, "getBaseAccount").mockResolvedValue(RECIPIENT);
+    jest
+      .spyOn(rpc.Server.prototype, "getAccount")
+      .mockImplementation(async () => new Account(PAYER, "0"));
+    mockScanTx.mockResolvedValue(null);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    mockFetchBalances.mockReset();
+    mockScanTx.mockReset();
+  });
+
+  it.each([
+    { amount: "9007199254740993", decimals: 0, altered: false },
+    { amount: "900719925.4740993", decimals: 7, altered: false },
+    { amount: "9007199254740993", decimals: 0, altered: true },
+    { amount: "900719925.4740993", decimals: 7, altered: true },
+  ])(
+    "preserves $amount through XDR and rejects altered responses ($altered)",
+    async ({ amount, decimals, altered }) => {
+      jest
+        .spyOn(MuxedAddress, "checkIsMuxedSupported")
+        .mockResolvedValue(false);
+      let postedUnits: bigint | undefined;
+      const fetch = jest
+        .spyOn(global, "fetch")
+        .mockImplementation(async (_url, options) => {
+          const body = JSON.parse(options?.body as string);
+          const transaction = TransactionBuilder.fromXDR(
+            body.xdr,
+            body.network_passphrase,
+          );
+          const operation = transaction.operations[0];
+          if (
+            operation.type !== "invokeHostFunction" ||
+            operation.func.type !== "hostFunctionTypeInvokeContract"
+          )
+            throw new Error("Expected a contract transfer");
+          postedUnits = scValToNative(operation.func.invokeContract.args[2]);
+          return {
+            ok: true,
+            json: async () => ({
+              preparedTransaction: buildTransfer(
+                postedUnits! + (altered ? BigInt(1) : BigInt(0)),
+              ),
+              simulationResponse: { minResourceFee: "100" },
+            }),
+          } as Response;
+        });
+      const { result, store } = renderSimulation(amount, decimals);
+      let response: SimulateResult | undefined;
+      await act(async () => {
+        response = await result.current.fetchData();
+      });
+      expect(fetch).toHaveBeenCalledWith(
+        expect.stringContaining("/simulate-tx"),
+        expect.any(Object),
+      );
+      expect(postedUnits).toBe(BigInt("9007199254740993"));
+      expect(response).toMatchObject({ ok: !altered });
+      if (altered) {
+        expect(mockScanTx).not.toHaveBeenCalled();
+        expect(result.current.state.data).toBeNull();
+        expect(
+          store.getState().transactionSubmission.transactionSimulation
+            .preparedTransaction,
+        ).toBeNull();
+      } else {
+        expect(result.current.state.state).toBe(RequestState.SUCCESS);
+        expect(mockScanTx).toHaveBeenCalledTimes(1);
+      }
+    },
+  );
+
+  it.each([RECIPIENT, CONTRACT])(
+    "preserves an ordinary recipient %s when the mux-capability lookup fails",
+    async (destination) => {
+      const spec = jest
+        .spyOn(ApiInternal, "getContractSpec")
+        .mockRejectedValue(new Error("Temporary capability lookup failure"));
+      const { simulate } = mockSimulation(BigInt(10000000), destination);
+      const { result } = renderSimulation("1", 7, destination);
+      await act(async () => {
+        expect(await result.current.fetchData()).toMatchObject({ ok: true });
+      });
+      expect(spec).toHaveBeenCalledTimes(1);
+      expect(simulate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          params: expect.objectContaining({ destination }),
+        }),
+      );
+      expect(result.current.state.state).toBe(RequestState.SUCCESS);
+    },
+  );
+});
+
 const deferred = <Value,>() => {
   let resolve!: (value: Value) => void;
   let reject!: (error: Error) => void;
diff --git a/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx b/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx
index b9aad08426..d86ed8e1da 100644
--- a/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx
+++ b/extension/src/popup/components/send/SendAmount/hooks/useSimulateTxData.tsx
@@ -346,7 +346,7 @@ const simulateTx = async ({
       params: {
         publicKey: string;
         destination: string;
-        amount: number;
+        amount: number | string;
       };
       networkDetails: NetworkDetails;
       transactionFee: string;
@@ -605,7 +605,8 @@ function useSimulateTxData({
             publicKey,
             memo: sorobanMemo,
             params: {
-              amount: parsedAmount.toNumber(),
+              amount:
+                expectedTokenAmount?.toString() ?? parsedAmount.toNumber(),
               publicKey,
               destination: finalDestination,
             },