chore: the native token's label follows the network (closes #372)

networks.js gives each network a nativeCurrency (ETH, SepoliaETH) and nothing
read it: every screen wrote ETH. The wallet's balances and the Send and
confirmation screens now use the active network's. A transaction's figures use
the network its chain id names, through nativeCurrencyByChainId(): the
approval value and fee, the wait, success and error screens, history entries,
the detail screen and the fee-limit refusal, so a site switching networks
cannot make one read as another network's coin. The "ETH" that selectedToken
and txInfo.token hold is the native token's id and is unchanged. A token
reporting any network's nativeCurrency is a spoof, and the detail screen calls
an entry a token transfer when it has a token contract.

Model: opus-5-5

README.md

@@ -846,6 +846,20 @@ wherever shown. If a formatting rule applies in one place, it applies in every
 place. Users should never see the same value rendered differently on two
 screens.
 
+The native token's label is a network's `nativeCurrency` in
+`src/shared/networks.js`: `ETH` on mainnet, `SepoliaETH` on Sepolia. The
+wallet's balances and the Send and confirmation screens, which send on the
+active network, use the active network's. A transaction's figures use the one of
+the network its chain id names, whichever network is active: the value and fee
+on the approval screen, the amount on the wait, success and error screens, the
+transaction history and the transaction detail screen, and the refusal of a fee
+above 1 ETH. A chain id that names no network reads `ETH`. Wherever this
+document shows ETH as the label of a native balance, value or fee, in a "Native
+ETH transfer" type line, in the contract-recipient warning or in that refusal,
+Sepolia shows `SepoliaETH`. The swap lines keep `ETH`, the router's own name for
+the native currency, and the ETH/USD price line, shown on mainnet only, keeps
+its fixed wording.
+
 **Specific Exception — Truncation:** On some non-critical display locations, we
 may truncate _a small number_ of characters from the middle of an address solely
 due to display size constraints. Wherever possible, and, notably, **in all
@@ -1106,7 +1120,8 @@ balance is nonzero and it is in the bundled known-token list, is tracked by the
 user, or has 1,000 or more holders; a token claiming a symbol from the bundled
 list from any other contract address is always dropped, and so is any token
 claiming a symbol that belongs to the native asset and therefore has no
-legitimate contract at all (`"ETH"`). That filter is unconditional — the "Hide
+legitimate contract at all (`"ETH"`, and every network's `nativeCurrency`, such
+as `"SepoliaETH"`, on every network). That filter is unconditional — the "Hide
 tokens with fewer than 1,000 holders" setting governs the transaction history
 and the send-screen token selector, not this list. `fetchTokenBalances()` stores
 every nonzero holding of a token it admits, however small, but a holding below
@@ -1589,7 +1604,9 @@ view would leave a wallet one click from deletion.
     - "Transaction" heading, "Back" button
     - Transaction hash: full hash (tap to copy) + etherscan link
     - Type: transaction classification — one of: Native ETH Transfer, ERC-20
-      Token Transfer, Swap, Token Approval, Contract Call, Contract Creation
+      Token Transfer, Swap, Token Approval, Contract Call, Contract Creation. A
+      transfer with a token contract is an ERC-20 Token Transfer whatever symbol
+      the token reports.
     - Status: "Success" or "Failed"
     - From: blockie + color dot + full address (tap to copy) + etherscan link;
       ENS name if available
@@ -2362,7 +2379,8 @@ indexes it as a real token transfer.
   act on and what the user believes they own rather than what the history
   displays. All three surfaces read the rule from `src/shared/symbolSpoof.js`,
   so they cannot answer the question differently. A symbol the list maps to no
-  contract at all — `"ETH"`, the native asset, is the only one — may be borne by
+  contract at all — the native asset's labels: `"ETH"` and every network's
+  `nativeCurrency`, such as `"SepoliaETH"`, on every network — may be borne by
   no contract, so every ERC-20 claiming it is a spoof on all three. The user's
   real ETH balance is not an ERC-20 and is read over RPC, so the rule never sees
   it.

TODO.md

@@ -45,6 +45,18 @@ but the review is broader than any of them.
 
 # Completed Steps
 
+- 2026-10-04: The native token's label follows the network
+  ([#372](https://git.eeqj.de/sneak/AutistMask/issues/372)). `networks.js` gives
+  each network a `nativeCurrency` and nothing read it: every screen wrote `ETH`,
+  so on Sepolia the balance, the value and the fee all read `ETH`. Every native
+  figure now reads `nativeCurrency`, which is `ETH` on mainnet and `SepoliaETH`
+  on Sepolia: the balance lists, Send and confirmation screens and the
+  contract-recipient warning the active network's; the approval, wait, success,
+  error and transaction detail screens, the transaction history and the refusal
+  of a fee above the limit that of the network the transaction's chain id names.
+  A token claiming any network's `nativeCurrency` is dropped as a fake, as one
+  claiming `ETH` already was, and the transaction detail screen calls an entry a
+  token transfer when it has a token contract, not by its symbol.
 - 2026-10-04: A popup that is already open when the stored profile becomes
   unreadable moves to the recovery screen
   ([#373](https://git.eeqj.de/sneak/AutistMask/issues/373)). It used to stay on

src/popup/index.html

@@ -640,19 +640,13 @@
                         Double-check the address before sending.
                     </div>
                 </div>
+                <!-- Its sentence names the network's native token, so show()
+                in confirmTx.js sets it. -->
                 <div
                     id="confirm-contract-warning"
-                    class="mb-2"
+                    class="mb-2 border border-red-500 border-dashed p-2 text-xs font-bold text-red-500"
                     style="visibility: hidden"
-                >
+                ></div>
-                    <div
-                        class="border border-red-500 border-dashed p-2 text-xs font-bold text-red-500"
-                    >
-                        WARNING: The recipient is a smart contract. Sending ETH
-                        or tokens directly to a contract may result in permanent
-                        loss of funds.
-                    </div>
-                </div>
                 <div
                     id="confirm-burn-warning"
                     class="mb-2"
@@ -690,14 +684,13 @@
                     Your balance does not cover this amount plus the network
                     fee. Please go back and send a smaller amount.
                 </div>
+                <!-- Its sentence names the network's native token, so show()
+                in confirmTx.js sets it. -->
                 <div
                     id="confirm-gas-error"
                     class="mb-2 border border-border border-dashed p-2 text-xs"
                     style="visibility: hidden"
-                >
+                ></div>
-                    You do not have enough ETH to pay the network fee for this
-                    transfer. Please add ETH to this address and try again.
-                </div>
                 <!-- Its sentence names why the fee could not be estimated,
                 so show() in confirmTx.js sets it. -->
                 <div

src/popup/views/addressDetail.js

@@ -12,7 +12,7 @@ const {
     goBack,
     pushCurrentView,
 } = require("./helpers");
-const { state, saveState } = require("../../shared/state");
+const { state, saveState, currentNetwork } = require("../../shared/state");
 const { formatAddressTotal, getAddressValue } = require("../../shared/prices");
 const {
     fetchRecentTransactions,
@@ -153,6 +153,7 @@ async function loadTransactions(address) {
         const rawTxs = await fetchRecentTransactions(
             address,
             state.blockscoutUrl,
+            currentNetwork().chainId,
         );
         const result = filterTransactions(rawTxs, {
             hideSpoofedSymbols: state.hideSpoofedSymbols,

src/popup/views/addressToken.js

@@ -10,6 +10,7 @@ const {
     addressTitle,
     escapeHtml,
     displaySymbol,
+    nativeCurrency,
     balanceLine,
     unknownableAmount,
     renderAddressHtml,
@@ -17,7 +18,7 @@ const {
     goBack,
     pushCurrentView,
 } = require("./helpers");
-const { state, saveState } = require("../../shared/state");
+const { state, saveState, currentNetwork } = require("../../shared/state");
 const { TOKEN_BY_ADDRESS, resolveSymbol } = require("../../shared/tokenList");
 const { formatUsd, getPrice } = require("../../shared/prices");
 const {
@@ -106,7 +107,7 @@ function show() {
     let symbol, amount, price;
     const knownToken = TOKEN_BY_ADDRESS.get(tokenId.toLowerCase());
     if (tokenId === "ETH") {
-        symbol = "ETH";
+        symbol = nativeCurrency();
         amount = parseFloat(addr.balance || "0");
         price = getPrice("ETH");
     } else {
@@ -226,6 +227,7 @@ async function loadTransactions(address, tokenId) {
         const rawTxs = await fetchRecentTransactions(
             address,
             state.blockscoutUrl,
+            currentNetwork().chainId,
         );
         const result = filterTransactions(rawTxs, {
             hideSpoofedSymbols: state.hideSpoofedSymbols,

src/popup/views/approval.js

@@ -12,7 +12,10 @@ const {
     formatFee,
 } = require("./helpers");
 const { state, saveState } = require("../../shared/state");
-const { networkByChainId } = require("../../shared/networks");
+const {
+    networkByChainId,
+    nativeCurrencyByChainId,
+} = require("../../shared/networks");
 const {
     formatEther,
     formatUnits,
@@ -219,8 +222,12 @@ function showTxFee(approvedTx) {
     const gasLimit = BigInt(approvedTx.gasLimit);
     const feePerGas = BigInt(approvedTx.maxFeePerGas || approvedTx.gasPrice);
     // Through formatFee(), as the confirmation screen's fee is, so the same
-    // fee reads the same on both.
+    // fee reads the same on both. In the native currency of the network shown
-    $("approve-tx-fee").textContent = formatFee(gasLimit * feePerGas);
+    // above, as the value is.
+    $("approve-tx-fee").textContent = formatFee(
+        gasLimit * feePerGas,
+        nativeCurrencyByChainId(approvedTx.chainId),
+    );
 
     let detail =
         gasLimit.toString() +
@@ -264,6 +271,7 @@ function showTxApproval(details) {
         amount: formatTxValue(ethValue),
         token: "ETH",
         tokenSymbol: null,
+        chainId: approvedTx.chainId,
     };
 
     // If this is an ERC-20 call, try to extract the real recipient and amount
@@ -329,8 +337,15 @@ function showTxApproval(details) {
     const ethPrice = getPrice("ETH");
     const ethUsd = ethPrice ? parseFloat(ethValueFormatted) * ethPrice : null;
     const usdStr = formatUsd(ethUsd);
+    // In the native currency of the network the transaction is for, which the
+    // Network line names, not the active network's: a site can switch the
+    // active network after this transaction is prepared and back before it is
+    // signed.
     $("approve-tx-value").textContent =
-        ethValueFormatted + " ETH" + (usdStr ? " (" + usdStr + ")" : "");
+        ethValueFormatted +
+        " " +
+        nativeCurrencyByChainId(approvedTx.chainId) +
+        (usdStr ? " (" + usdStr + ")" : "");
 
     showTxFee(approvedTx);
 

src/popup/views/confirmTx.js

@@ -11,13 +11,14 @@ const {
     addressTitle,
     escapeHtml,
     displaySymbol,
+    nativeCurrency,
     renderAddressHtml,
     attachCopyHandlers,
     goBack,
     onViewLeave,
     formatFee,
 } = require("./helpers");
-const { state } = require("../../shared/state");
+const { state, currentNetwork } = require("../../shared/state");
 const { getSignerForAddress } = require("../../shared/wallet");
 const { decryptWithPassword } = require("../../shared/vault");
 const { formatUsd, getPrice } = require("../../shared/prices");
@@ -90,7 +91,7 @@ function show(txInfo) {
     // The raw symbol is the price-table key; the capped one is what the
     // screen says. Truncating before the lookup would silently drop the
     // price of any token whose symbol is long enough to be capped.
-    const rawSymbol = isErc20 ? txInfo.tokenSymbol || "?" : "ETH";
+    const rawSymbol = isErc20 ? txInfo.tokenSymbol || "?" : nativeCurrency();
     const symbol = displaySymbol(rawSymbol);
 
     // Transaction type
@@ -98,7 +99,7 @@ function show(txInfo) {
         $("confirm-type").textContent =
             "ERC-20 token transfer (" + symbol + ")";
     } else {
-        $("confirm-type").textContent = "Native ETH transfer";
+        $("confirm-type").textContent = "Native " + symbol + " transfer";
     }
 
     // Token contract section (ERC-20 only)
@@ -162,7 +163,7 @@ function show(txInfo) {
         const bal = txInfo.balance || "0";
         const balUsd = ethPrice ? parseFloat(bal) * ethPrice : null;
         $("confirm-balance").textContent = valueWithUsd(
-            truncateAmountNeverZero(bal) + " ETH",
+            truncateAmountNeverZero(bal) + " " + symbol,
             balUsd,
         );
     }
@@ -197,6 +198,19 @@ function show(txInfo) {
     // estimate landing later never moves anything.
     $("confirm-amount-fee-error").classList.toggle("hidden", isErc20);
     $("confirm-gas-error").classList.toggle("hidden", !isErc20);
+    $("confirm-gas-error").textContent =
+        "You do not have enough " +
+        nativeCurrency() +
+        " to pay the network fee for this transfer. Please add " +
+        nativeCurrency() +
+        " to this address and try again.";
+
+    // Shown later, once checkRecipientHistory() finds a contract.
+    $("confirm-contract-warning").textContent =
+        "WARNING: The recipient is a smart contract. Sending " +
+        nativeCurrency() +
+        " or tokens directly to a contract may result in permanent loss of" +
+        " funds.";
 
     // The fee-unknown message names its cause, which is also known here.
     // Without the token's scale estimateGas() cannot encode the transfer, so
@@ -245,7 +259,9 @@ function show(txInfo) {
 // touches already occupies its space, so re-running it never moves anything.
 function renderValidation(txInfo) {
     const isErc20 = txInfo.token !== "ETH";
-    const symbol = isErc20 ? displaySymbol(txInfo.tokenSymbol || "?") : "ETH";
+    const symbol = isErc20
+        ? displaySymbol(txInfo.tokenSymbol || "?")
+        : nativeCurrency();
 
     const { canSend, codes } = validateTransfer({
         isErc20,
@@ -258,7 +274,7 @@ function renderValidation(txInfo) {
 
     // Messages carrying the user's own numbers are built here; the fixed
     // sentences live in the reserved elements in index.html, except the
-    // fee-unknown one, which show() sets.
+    // gas and fee-unknown ones, which show() sets.
     const messages = [];
     if (codes.includes(CODES.AMOUNT_INVALID)) {
         messages.push("Please enter a valid amount to send.");
@@ -287,9 +303,13 @@ function renderValidation(txInfo) {
         messages.push(
             "Insufficient balance. You have " +
                 truncateAmountNeverZero(txInfo.balance || "0") +
-                " ETH but are trying to send " +
+                " " +
+                symbol +
+                " but are trying to send " +
                 txInfo.amount +
-                " ETH.",
+                " " +
+                symbol +
+                ".",
         );
     }
 
@@ -378,17 +398,23 @@ async function estimateGas(txInfo) {
         // The fee line goes through formatFee(), as the approval screen's
         // does, so the same fee reads the same on both.
         if (estimateWei !== null && estimateWei < gasCostWei) {
-            $("confirm-fee-amount").textContent = "~" + formatFee(estimateWei);
+            $("confirm-fee-amount").textContent =
+                "~" + formatFee(estimateWei, nativeCurrency());
             $("confirm-fee-reserve").textContent =
                 "up to " +
                 truncateAmountNeverZero(formatEther(gasCostWei)) +
-                " ETH reserved";
+                " " +
+                nativeCurrency() +
+                " reserved";
             setVisible("confirm-fee-reserve", true);
         } else {
             // No spread to report: either there is no estimate, or the node
             // quotes a gas price at or above maxFeePerGas, so the expected
             // cost is not below the reserve. Show the reserve alone.
-            $("confirm-fee-amount").textContent = formatFee(gasCostWei);
+            $("confirm-fee-amount").textContent = formatFee(
+                gasCostWei,
+                nativeCurrency(),
+            );
             setVisible("confirm-fee-reserve", false);
         }
         feeStatus = FEE_KNOWN;
@@ -508,6 +534,10 @@ function init(_ctx) {
         $("btn-confirm-send").disabled = true;
         $("btn-confirm-send").classList.add("text-muted");
 
+        // The network it is sent on. The wait, success and error screens
+        // label its amount by this, not by the network active when they draw.
+        pendingTx.chainId = currentNetwork().chainId;
+
         let tx;
         try {
             const signer = getSignerForAddress(

src/popup/views/helpers.js

@@ -267,16 +267,31 @@ function unknownableAmount(balance) {
     return Number.isFinite(n) ? n : null;
 }
 
+// The active network's native token symbol, `ETH` on mainnet and `SepoliaETH`
+// on Sepolia, as src/shared/networks.js names it. The wallet's balances and
+// the Send and confirmation screens, which send on the active network, label a
+// native amount with this; a transaction already made or requested is labelled
+// by its own chain id, through nativeCurrencyByChainId() in networks.js. The
+// "ETH" that state.selectedToken and txInfo.token hold is the native token's
+// id, not its label, and stays "ETH" on every network.
+function nativeCurrency() {
+    return currentNetwork().nativeCurrency;
+}
+
 // A network fee in wei as the confirmation and approval screens both show it:
-// the ETH figure through truncateAmountNeverZero(), then its USD value when the
+// the ETH figure through truncateAmountNeverZero() and labelled `symbol`, the
-// ETH price is known. The USD value is of the exact fee, not of the truncated
+// native currency of the network the fee is paid on, then its USD value when
-// figure.
+// the ETH price is known. The USD value is of the exact fee, not of the
-function formatFee(wei) {
+// truncated figure.
+function formatFee(wei, symbol) {
     const eth = formatEther(wei);
     const ethPrice = getPrice("ETH");
     const usd = ethPrice ? formatUsd(parseFloat(eth) * ethPrice) : "";
     return (
-        truncateAmountNeverZero(eth) + " ETH" + (usd ? " (" + usd + ")" : "")
+        truncateAmountNeverZero(eth) +
+        " " +
+        symbol +
+        (usd ? " (" + usd + ")" : "")
     );
 }
 
@@ -318,7 +333,7 @@ function balanceLine(symbol, amount, price, tokenId) {
 
 function balanceLinesForAddress(addr, trackedTokens, showZero) {
     let html = balanceLine(
-        "ETH",
+        nativeCurrency(),
         parseFloat(addr.balance || "0"),
         getPrice("ETH"),
         "ETH",
@@ -675,6 +690,7 @@ module.exports = {
     balanceLinesForAddress,
     addressHoldsFunds,
     unknownableAmount,
+    nativeCurrency,
     formatFee,
     addressColor,
     addressDotHtml,

src/popup/views/home.js

@@ -10,11 +10,17 @@ const {
     addressTitle,
     escapeHtml,
     displaySymbol,
+    nativeCurrency,
     renderAddressHtml,
     attachCopyHandlers,
     pushCurrentView,
 } = require("./helpers");
-const { state, saveState, currentAddress } = require("../../shared/state");
+const {
+    state,
+    saveState,
+    currentAddress,
+    currentNetwork,
+} = require("../../shared/state");
 const { notify } = require("../../shared/browserApi");
 const {
     updateSendBalance,
@@ -68,7 +74,7 @@ function renderTotalValue() {
         return;
     }
     const ethBal = parseFloat(addr.balance || "0");
-    const ethStr = ethBal.toFixed(4) + " ETH";
+    const ethStr = ethBal.toFixed(4) + " " + nativeCurrency();
     const ethUsd = ethPrice ? " (" + formatUsd(ethBal * ethPrice) + ")" : "";
     el.textContent = ethStr + ethUsd;
 
@@ -182,7 +188,11 @@ async function loadHomeTxs(ctx) {
 
     try {
         const fetches = allAddresses.map((addr) =>
-            fetchRecentTransactions(addr, state.blockscoutUrl),
+            fetchRecentTransactions(
+                addr,
+                state.blockscoutUrl,
+                currentNetwork().chainId,
+            ),
         );
         const results = await Promise.all(fetches);
 

src/popup/views/send.js

@@ -5,6 +5,8 @@ const {
     showFlash,
     addressTitle,
     displaySymbol,
+    escapeHtml,
+    nativeCurrency,
     renderAddressHtml,
     attachCopyHandlers,
     goBack,
@@ -124,7 +126,7 @@ function updateToValidation() {
 
 function renderSendTokenSelect(addr) {
     const sel = $("send-token");
-    sel.innerHTML = '<option value="ETH">ETH</option>';
+    sel.innerHTML = `<option value="ETH">${escapeHtml(nativeCurrency())}</option>`;
     const fraudSet = new Set(
         (state.fraudContracts || []).map((a) => a.toLowerCase()),
     );
@@ -204,7 +206,8 @@ function updateSendBalance() {
         $("send-balance").textContent =
             "Current balance: " +
             truncateAmountNeverZero(addr.balance || "0") +
-            " ETH";
+            " " +
+            nativeCurrency();
     } else {
         const symbol = resolveSymbol(
             token,

src/popup/views/transactionDetail.js

@@ -21,6 +21,7 @@ const {
     goBack,
 } = require("./helpers");
 const { state } = require("../../shared/state");
+const { nativeCurrencyByChainId } = require("../../shared/networks");
 const { formatEther, formatUnits } = require("ethers");
 const makeBlockie = require("ethereum-blockies-base64");
 const { log, debugFetch } = require("../../shared/log");
@@ -41,8 +42,10 @@ function getTransactionType(tx) {
             return "Token Approval";
         return "Contract Call";
     }
-    if (tx.symbol && tx.symbol !== "ETH") return "ERC-20 Token Transfer";
+    // By the token contract, not the symbol: a token chooses its own symbol
-    return "Native ETH Transfer";
+    // and can report the native token's, but only a token transfer has one.
+    if (tx.contractAddress) return "ERC-20 Token Transfer";
+    return "Native " + nativeCurrencyByChainId(tx.chainId) + " Transfer";
 }
 
 function blockieHtml(address) {
@@ -84,6 +87,11 @@ function show(tx) {
             isContractCall: tx.isContractCall || false,
             method: tx.method || null,
             contractAddress: tx.contractAddress || null,
+            // The network the history entry was read from. The type line and
+            // the fee are in its native currency, not the active network's:
+            // a site can switch the active network before a later popup
+            // shows this screen again.
+            chainId: tx.chainId,
         },
     };
     render();
@@ -179,7 +187,7 @@ function render() {
         if (el) el.classList.add("hidden");
     }
 
-    loadFullTxDetails(tx.hash, tx.to);
+    loadFullTxDetails(tx.hash, tx.to, tx.chainId);
 
     const isoStr = isoDate(tx.timestamp);
     $("tx-detail-time").innerHTML =
@@ -197,7 +205,7 @@ function showDetailField(sectionId, contentId, value) {
     section.classList.remove("hidden");
 }
 
-function populateOnChainDetails(txData) {
+function populateOnChainDetails(txData, chainId) {
     // Block number
     if (txData.block_number != null) {
         const blockLink = explorerUrl("block", String(txData.block_number));
@@ -227,7 +235,7 @@ function populateOnChainDetails(txData) {
         showDetailField(
             "tx-detail-fee-section",
             "tx-detail-fee",
-            feeEth + " ETH",
+            feeEth + " " + nativeCurrencyByChainId(chainId),
         );
     }
 
@@ -287,7 +295,7 @@ function populateOnChainDetails(txData) {
     }
 }
 
-async function loadFullTxDetails(txHash, toAddress) {
+async function loadFullTxDetails(txHash, toAddress, chainId) {
     const section = $("tx-detail-calldata-section");
     const actionEl = $("tx-detail-calldata-action");
     const detailsEl = $("tx-detail-calldata-details");
@@ -304,7 +312,7 @@ async function loadFullTxDetails(txHash, toAddress) {
         const txData = await resp.json();
 
         // Populate on-chain detail fields (block, nonce, gas, fee)
-        populateOnChainDetails(txData);
+        populateOnChainDetails(txData, chainId);
 
         const inputData = txData.raw_input || txData.input || null;
         if (!inputData || inputData === "0x") return;

src/popup/views/txStatus.js

@@ -16,6 +16,7 @@ const {
 } = require("./helpers");
 const { resolveTokenSymbol } = require("../../shared/approvalAmount");
 const { state } = require("../../shared/state");
+const { nativeCurrencyByChainId } = require("../../shared/networks");
 const { getProvider } = require("../../shared/balances");
 const { log } = require("../../shared/log");
 
@@ -86,9 +87,13 @@ function startWait(txInfo, txHash, broadcastTime, pollNow) {
     endWait();
     const id = waitId;
 
+    // A native amount, here and on the success and error screens, is in the
+    // native currency of txInfo.chainId, the network the transaction was sent
+    // on, not the active network's: a site can switch the active network
+    // while this screen is open or before a later popup resumes it.
     const symbol =
         txInfo.token === "ETH"
-            ? "ETH"
+            ? nativeCurrencyByChainId(txInfo.chainId)
             : displaySymbol(txInfo.tokenSymbol || "?");
     $("wait-tx-summary").textContent = txInfo.amount + " " + symbol;
     $("wait-tx-to").innerHTML = toAddressHtml(txInfo.to);
@@ -193,9 +198,10 @@ function showWait(txInfo, txHash) {
 // an object merely missing one of them throws a TypeError out of
 // restoreView() — which init() does not guard, skipping the rest of popup
 // init and leaving wait-tx on screen with no back control. A non-numeric
-// broadcastTime leaves an unexitable wait counting "NaNs". txInfo.token and
+// broadcastTime leaves an unexitable wait counting "NaNs". txInfo.token,
-// txInfo.tokenSymbol are deliberately unchecked: they are compared and
+// txInfo.tokenSymbol and txInfo.chainId are deliberately unchecked: they are
-// coalesced rather than dereferenced, and tokenSymbol is null for ETH.
+// compared and coalesced rather than dereferenced, and tokenSymbol is null for
+// ETH.
 function restoreWait() {
     const d = state.viewData;
     if (!d || !d.pendingWait) return false;
@@ -223,7 +229,7 @@ function showSuccess(txInfo, txHash, blockNumber) {
 
     const symbol =
         txInfo.token === "ETH"
-            ? "ETH"
+            ? nativeCurrencyByChainId(txInfo.chainId)
             : displaySymbol(txInfo.tokenSymbol || "?");
     state.viewData = {
         amount: txInfo.amount,
@@ -320,7 +326,7 @@ function showError(txInfo, txHash, message) {
 
     const symbol =
         txInfo.token === "ETH"
-            ? "ETH"
+            ? nativeCurrencyByChainId(txInfo.chainId)
             : displaySymbol(txInfo.tokenSymbol || "?");
     state.viewData = {
         amount: txInfo.amount,

src/shared/approvalVerify.js

@@ -54,9 +54,11 @@ const {
     formatEther,
     getAddress,
     getBytes,
+    toQuantity,
     verifyMessage,
     verifyTypedData,
 } = require("ethers");
+const { nativeCurrencyByChainId } = require("./networks");
 
 // The only transaction types this wallet signs: legacy, EIP-2930 and
 // EIP-1559. populateTransaction() produces nothing else, so nothing else can
@@ -407,12 +409,21 @@ function assertWithinCeilings(tx) {
             price = normalizeQuantity(tx.gasPrice, "gas price");
         }
         if (price !== null && gasLimit * price > MAX_TOTAL_FEE) {
+            // The fee is paid in the native currency of the network the
+            // transaction is for. Every caller's transaction names it.
+            const nativeCurrency = nativeCurrencyByChainId(
+                present(tx.chainId) ? toQuantity(tx.chainId) : null,
+            );
             throw refuse(
                 "This transaction would allow a network fee of up to " +
                     formatEther(gasLimit * price) +
-                    " ETH, which is more than the " +
+                    " " +
+                    nativeCurrency +
+                    ", which is more than the " +
                     formatEther(MAX_TOTAL_FEE) +
-                    " ETH this wallet will sign for.",
+                    " " +
+                    nativeCurrency +
+                    " this wallet will sign for.",
             );
         }
     }

src/shared/networks.js

@@ -76,6 +76,15 @@ function networkByChainId(chainId) {
     return null;
 }
 
+// The native currency of the network with this chain id. A transaction's
+// value and fee are labelled with the one of the chain the transaction is on,
+// which need not be the active network. `ETH` when the chain id is missing or
+// no network here has it.
+function nativeCurrencyByChainId(chainId) {
+    const network = networkByChainId(chainId);
+    return network ? network.nativeCurrency : "ETH";
+}
+
 // Build a block explorer link for the given path type and value.
 // type: "address" | "tx" | "token" | "block"
 function explorerLink(network, type, value) {
@@ -89,5 +98,6 @@ module.exports = {
     isKnownNetworkId,
     networkById,
     networkByChainId,
+    nativeCurrencyByChainId,
     explorerLink,
 };

src/shared/symbolSpoof.js

@@ -11,8 +11,8 @@
 // KNOWN_SYMBOLS maps a symbol to the set of lowercased contract addresses
 // that may bear it, or to null.  Null means the symbol belongs to the native
 // asset, which has no contract at all, so no contract may bear it and every
-// one that does is a spoof.  "ETH" is the only such entry today; the rule is
+// one that does is a spoof.  "ETH" is one such entry, and every network's
-// written so that a second one needs no change here or at any call site.
+// `nativeCurrency` in networks.js (`SepoliaETH`) is another, on every network.
 //
 // The value is a set because a ticker is not unique: seven symbols in the
 // bundled list belong to two real contracts each, and answering with one of

src/shared/tokenList.js

@@ -6,6 +6,7 @@
 // 511 tokens.
 
 const { debugFetch } = require("./log");
+const { NETWORKS } = require("./networks");
 
 const COINDESK_API = "https://data-api.coindesk.com/index/cc/v1/latest/tick";
 
@@ -3610,7 +3611,9 @@ for (const t of TOKENS) {
 // Build a map of symbol (uppercased) -> the set of contract addresses
 // (lowercased) that legitimately bear it.  Used for spoofed-symbol detection.
 // "ETH" maps to null: the native asset has no contract, so no contract may
-// bear its symbol.
+// bear its symbol. So does every network's `nativeCurrency` in networks.js
+// (`SepoliaETH`), on every network, since that is the label the wallet shows
+// its native asset under on that network.
 //
 // The value is a set and not a single address because tickers are not unique
 // and the list above proves it: seven of these 512 tokens share a symbol with
@@ -3624,6 +3627,9 @@ for (const t of TOKENS) {
 // loosen the rule, because a contract outside the set is still a spoof.
 const KNOWN_SYMBOLS = new Map();
 KNOWN_SYMBOLS.set("ETH", null);
+for (const network of Object.values(NETWORKS)) {
+    KNOWN_SYMBOLS.set(network.nativeCurrency.toUpperCase(), null);
+}
 for (const t of TOKENS) {
     const upper = t.symbol.toUpperCase();
     if (!KNOWN_SYMBOLS.has(upper)) {

src/shared/transactions.js

@@ -11,6 +11,7 @@ const { log, debugFetch } = require("./log");
 const { TOKEN_BY_ADDRESS } = require("./tokenList");
 const { parseHoldersCount, isLowHolderCount } = require("./holders");
 const { isSpoofedSymbol } = require("./symbolSpoof");
+const { nativeCurrencyByChainId } = require("./networks");
 // The uint8 test every scale in this wallet goes through. Shared, not copied:
 // a scale is either reported or it is unknown, and "unknown" must mean the
 // same thing here as it does on the screens that refuse to format one.
@@ -28,7 +29,7 @@ function normalizeAddress(addr) {
     return (addr || "").toLowerCase();
 }
 
-function parseTx(tx, addrLower) {
+function parseTx(tx, addrLower, chainId) {
     const from = tx.from?.hash || "";
     const to = tx.to?.hash || "";
     const rawWei = tx.value || "0";
@@ -36,7 +37,7 @@ function parseTx(tx, addrLower) {
     const method = tx.method || null;
 
     // For contract calls, produce a meaningful label instead of "0.0000 ETH"
-    let symbol = "ETH";
+    let symbol = nativeCurrencyByChainId(chainId);
     let value = formatTxValue(formatEther(rawWei));
     let exactValue = formatEther(rawWei);
     let rawAmount = rawWei;
@@ -90,10 +91,11 @@ function parseTx(tx, addrLower) {
         holders: null,
         isContractCall: toIsContract,
         method: method,
+        chainId: chainId,
     };
 }
 
-function parseTokenTransfer(tt, addrLower) {
+function parseTokenTransfer(tt, addrLower, chainId) {
     const from = tt.from?.hash || "";
     const to = tt.to?.hash || "";
     // The explorer's own answer, or null. Never a default: a transfer of
@@ -139,6 +141,7 @@ function parseTokenTransfer(tt, addrLower) {
         // low-holder filter declines to judge a null, so a legitimate token
         // is not hidden because a field went missing upstream.
         holders: parseHoldersCount(tt.token?.holders_count),
+        chainId: chainId,
     };
 }
 
@@ -221,7 +224,15 @@ function mergeTransactions(txs, tokenTransfers) {
     return merged;
 }
 
-async function fetchRecentTransactions(address, blockscoutUrl, count = 25) {
+// `chainId` is the chain id of the network `blockscoutUrl` serves. Every entry
+// carries it, and a native entry is labelled with that network's
+// `nativeCurrency` from networks.js (`ETH`, `SepoliaETH`).
+async function fetchRecentTransactions(
+    address,
+    blockscoutUrl,
+    chainId,
+    count = 25,
+) {
     log.debugf("fetchRecentTransactions", address);
     const addrLower = normalizeAddress(address);
 
@@ -254,8 +265,10 @@ async function fetchRecentTransactions(address, blockscoutUrl, count = 25) {
     const ttJson = ttResp.ok ? await ttResp.json() : {};
 
     const txs = mergeTransactions(
-        (txJson.items || []).map((tx) => parseTx(tx, addrLower)),
+        (txJson.items || []).map((tx) => parseTx(tx, addrLower, chainId)),
-        (ttJson.items || []).map((tt) => parseTokenTransfer(tt, addrLower)),
+        (ttJson.items || []).map((tt) =>
+            parseTokenTransfer(tt, addrLower, chainId),
+        ),
     );
 
     const result = txs.slice(0, count);

tests/approvalVerify.test.js

@@ -599,6 +599,24 @@ describe("verifySignedTx field comparison", () => {
                 expect(e.message).toContain("1.0 ETH");
             }
         });
+
+        // The fee is in the native currency of the network the transaction is
+        // for, whether its chain id is the hex string the background prepares
+        // or the number ethers parses from a signed transaction.
+        test.each([
+            ["0x1", "ETH"],
+            [1n, "ETH"],
+            ["0xaa36a7", "SepoliaETH"],
+            [11155111n, "SepoliaETH"],
+        ])("the refusal on chain %p names %s", (chainId, nativeCurrency) => {
+            expect(() => assertWithinCeilings({ ...OVER, chainId })).toThrow(
+                "up to 3000.0 " +
+                    nativeCurrency +
+                    ", which is more than the 1.0 " +
+                    nativeCurrency +
+                    " this wallet",
+            );
+        });
     });
 
     test("every field mismatch is a refusal, not a warning", async () => {

tests/nativeCurrency.test.js

@@ -0,0 +1,461 @@
+// The native token's label on the screens that show a native amount.
+//
+// src/shared/networks.js gives each network a nativeCurrency, `ETH` on mainnet
+// and `SepoliaETH` on Sepolia, and nothing read it: every screen wrote a
+// hardcoded "ETH", so on Sepolia the balance, the value and the fee all read
+// ETH (https://git.eeqj.de/sneak/AutistMask/issues/372). Each line is asserted
+// on both networks, through the real Send, confirmation and approval screens,
+// with only the node and the DOM stubbed. So is that a token cannot pass for
+// the native token by reporting its label, and that a transaction's figures
+// carry its own network's label when another network is active.
+
+"use strict";
+
+jest.mock("ethers", () => {
+    const actual = jest.requireActual("ethers");
+    class StubProvider {
+        async lookupAddress() {
+            return null;
+        }
+        // 10 gwei expected, 20 gwei reserved per gas.
+        async getFeeData() {
+            return { maxFeePerGas: 20000000000n, gasPrice: 10000000000n };
+        }
+        async estimateGas() {
+            return 21000n;
+        }
+        async getCode() {
+            return "0x";
+        }
+        async getTransactionCount() {
+            return 1;
+        }
+        async getTransactionReceipt() {
+            return { blockNumber: 21000000 };
+        }
+    }
+    return {
+        ...actual,
+        JsonRpcProvider: StubProvider,
+        Network: { from: () => ({}) },
+    };
+});
+
+jest.mock("../src/shared/log", () => ({
+    log: {
+        debugf: () => {},
+        infof: () => {},
+        warnf: () => {},
+        errorf: () => {},
+    },
+    debugFetch: jest.fn(async () => ({
+        ok: true,
+        status: 200,
+        json: async () => ({ items: [] }),
+    })),
+    urlOrigin: () => "",
+    setRuntimeDebug: () => {},
+    isDebug: () => false,
+}));
+
+// Signing a send succeeds without a key, and sending answers with a hash.
+jest.mock("../src/shared/vault", () => ({
+    ...jest.requireActual("../src/shared/vault"),
+    decryptWithPassword: async () => "secret",
+}));
+jest.mock("../src/shared/wallet", () => ({
+    ...jest.requireActual("../src/shared/wallet"),
+    getSignerForAddress: () => ({
+        connect: () => ({
+            populateTransaction: async (request) => request,
+            sendTransaction: async () => ({ hash: "0x" + "3".repeat(64) }),
+        }),
+    }),
+}));
+
+global.fetch = jest.fn(() => {
+    throw new Error("tests must not perform network requests");
+});
+
+// The approval the background hands the approval screen. Set per test.
+let approvalDetails = null;
+
+const { makeStorageStub } = require("./support/storageStub");
+global.chrome = {
+    storage: makeStorageStub(),
+    runtime: {
+        connect: () => ({
+            postMessage() {},
+            disconnect() {},
+            onDisconnect: { addListener() {} },
+        }),
+        sendMessage(message, callback) {
+            callback(
+                message.type === "AUTISTMASK_GET_APPROVAL"
+                    ? approvalDetails
+                    : undefined,
+            );
+        },
+    },
+};
+
+// A stub DOM: every id resolves to a recording element.
+const elements = new Map();
+
+function makeEl(id) {
+    const handlers = new Map();
+    return {
+        id,
+        textContent: "",
+        innerHTML: "",
+        value: "",
+        disabled: false,
+        style: {},
+        dataset: {},
+        classList: {
+            add() {},
+            remove() {},
+            toggle() {},
+            contains: () => false,
+        },
+        handlers,
+        children: [],
+        addEventListener(name, fn) {
+            handlers.set(name, fn);
+        },
+        appendChild(child) {
+            this.children.push(child);
+            return child;
+        },
+        querySelectorAll: () => [],
+        querySelector: () => null,
+        remove() {},
+        focus() {},
+        // Views reach for .parentElement to hide whole sections.
+        get parentElement() {
+            return global.document.getElementById(id + "-parent");
+        },
+    };
+}
+
+global.document = {
+    getElementById(id) {
+        if (!elements.has(id)) elements.set(id, makeEl(id));
+        return elements.get(id);
+    },
+    createElement: (tag) => makeEl(tag),
+    body: { prepend() {}, appendChild() {} },
+    addEventListener() {},
+};
+global.navigator = { clipboard: { writeText() {} } };
+
+const { state } = require("../src/shared/state");
+const { NETWORKS } = require("../src/shared/networks");
+const { clearPrices } = require("../src/shared/prices");
+const send = require("../src/popup/views/send");
+const confirmTx = require("../src/popup/views/confirmTx");
+const approval = require("../src/popup/views/approval");
+const transactionDetail = require("../src/popup/views/transactionDetail");
+const txStatus = require("../src/popup/views/txStatus");
+const { balanceLinesForAddress } = require("../src/popup/views/helpers");
+const { filterTransactions } = require("../src/shared/transactions");
+const { debugFetch } = require("../src/shared/log");
+
+const HOLDER = "0x" + "a".repeat(40);
+const RECIPIENT = "0xC0FfEE0000000000000000000000000000c0fFEe";
+// A token contract that is not in the bundled token list.
+const TOKEN_CONTRACT = "0xd05339f9ea5ab9d9f03b9d57f671d2abd1f55c82";
+
+function text(id) {
+    return global.document.getElementById(id).textContent;
+}
+
+// Press Review on the Send screen for a native send of `amount`, and show the
+// confirmation screen it leads to with its fee estimate settled.
+async function confirmSend(amount) {
+    let txInfo = null;
+    send.init({ showConfirmTx: (info) => (txInfo = info) });
+    state.selectedToken = "ETH";
+    global.document.getElementById("send-to").value = RECIPIENT;
+    global.document.getElementById("send-amount").value = amount;
+    await global.document
+        .getElementById("btn-send-review")
+        .handlers.get("click")();
+    confirmTx.show(txInfo);
+    for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
+}
+
+// The approval screen for a dApp transaction sending 0.01 of the native token
+// with 21000 gas at up to 20 gwei, on the network with `chainId`.
+async function approveTx(chainId) {
+    approvalDetails = {
+        type: "tx",
+        origin: "https://dapp.example",
+        approvedFrom: HOLDER,
+        approvedTx: {
+            to: RECIPIENT,
+            value: "10000000000000000",
+            data: "0x",
+            chainId,
+            gasLimit: "21000",
+            maxFeePerGas: "20000000000",
+            nonce: 0,
+        },
+    };
+    await approval.show("1");
+}
+
+describe.each([
+    ["mainnet", "ETH"],
+    ["sepolia", "SepoliaETH"],
+])("on %s the native token reads %s", (networkId, symbol) => {
+    beforeEach(() => {
+        elements.clear();
+        clearPrices();
+        state.networkId = networkId;
+        state.wallets = [
+            {
+                name: "Wallet 1",
+                addresses: [{ address: HOLDER, balance: "1.5" }],
+            },
+        ];
+        state.selectedWallet = 0;
+        state.selectedAddress = 0;
+        state.trackedTokens = [];
+        state.fraudContracts = [];
+        state.currentView = null;
+    });
+
+    test("the balance", async () => {
+        const addr = state.wallets[0].addresses[0];
+        expect(balanceLinesForAddress(addr, [], false)).toContain(
+            `<span>${symbol}</span><span>1.5000</span>`,
+        );
+        state.selectedToken = "ETH";
+        send.updateSendBalance();
+        expect(text("send-balance")).toBe("Current balance: 1.5000 " + symbol);
+        await confirmSend("0.1");
+        expect(text("confirm-balance")).toBe("1.5000 " + symbol);
+    });
+
+    test("the value", async () => {
+        await confirmSend("0.1");
+        expect(text("confirm-type")).toBe("Native " + symbol + " transfer");
+        expect(text("confirm-amount")).toBe("0.1 " + symbol);
+        await approveTx(NETWORKS[networkId].chainId);
+        expect(text("approve-tx-value")).toBe("0.0100 " + symbol);
+    });
+
+    test("the fee", async () => {
+        await confirmSend("0.1");
+        // 21000 gas at 10 gwei expected, at 20 gwei reserved.
+        expect(text("confirm-fee-amount")).toBe("~0.0002 " + symbol);
+        expect(text("confirm-fee-reserve")).toBe(
+            "up to 0.0004 " + symbol + " reserved",
+        );
+        expect(text("confirm-gas-error")).toContain(
+            "You do not have enough " + symbol + " to pay the network fee",
+        );
+        await approveTx(NETWORKS[networkId].chainId);
+        expect(text("approve-tx-fee")).toBe("0.0004 " + symbol);
+    });
+
+    test("the contract-recipient warning", async () => {
+        await confirmSend("0.1");
+        expect(text("confirm-contract-warning")).toContain(
+            "Sending " + symbol + " or tokens directly to a contract",
+        );
+    });
+
+    // A token reports whatever symbol it likes. One reporting the label the
+    // wallet shows its native token under, on this network or any other, is
+    // a fake, exactly as one reporting `ETH` always was.
+    test.each(["ETH", symbol])(
+        "a token claiming %s is dropped from the history and the Send selector",
+        (claim) => {
+            const result = filterTransactions(
+                [
+                    {
+                        hash: "0x" + "1".repeat(64),
+                        symbol: claim,
+                        contractAddress: TOKEN_CONTRACT,
+                        holders: 900000,
+                        valueGwei: null,
+                        isContractCall: false,
+                    },
+                ],
+                { hideSpoofedSymbols: true },
+            );
+            expect(result.transactions).toEqual([]);
+            expect(result.newFraudContracts).toEqual([TOKEN_CONTRACT]);
+
+            send.renderSendTokenSelect({
+                address: HOLDER,
+                tokenBalances: [
+                    {
+                        address: TOKEN_CONTRACT,
+                        symbol: claim,
+                        decimals: 18,
+                        balance: "5",
+                        holders: 900000,
+                    },
+                ],
+            });
+            expect(
+                global.document.getElementById("send-token").children,
+            ).toEqual([]);
+        },
+    );
+
+    // The detail screen tells the two apart by the token contract, which only
+    // a token transfer has, so a token reporting the native label still reads
+    // as a token transfer.
+    test("the transaction detail screen's type line", () => {
+        const entry = {
+            hash: "0x" + "2".repeat(64),
+            from: RECIPIENT,
+            to: HOLDER,
+            value: "1.0000",
+            exactValue: "1.0",
+            symbol,
+            timestamp: 1790000000,
+            isError: false,
+            direction: "received",
+            directionLabel: "Received",
+            chainId: NETWORKS[networkId].chainId,
+        };
+        transactionDetail.show({ ...entry, contractAddress: null });
+        expect(text("tx-detail-type")).toBe("Native " + symbol + " Transfer");
+        transactionDetail.show({ ...entry, contractAddress: TOKEN_CONTRACT });
+        expect(text("tx-detail-type")).toBe("ERC-20 Token Transfer");
+    });
+
+    test("the insufficient-balance error", async () => {
+        await confirmSend("2");
+        expect(
+            global.document.getElementById("confirm-errors").innerHTML,
+        ).toContain(
+            "You have 1.5000 " +
+                symbol +
+                " but are trying to send 2 " +
+                symbol +
+                ".",
+        );
+    });
+});
+
+// A transaction's value and fee are in the native currency of the network the
+// transaction is on, which need not be the active one. A site can switch the
+// active network after its transaction is prepared and back before it is
+// signed, and a popup opened after a switch shows a sent or listed transaction
+// again. The wallet's balances follow the active network; these do not.
+describe.each([
+    ["mainnet", "sepolia", "ETH"],
+    ["sepolia", "mainnet", "SepoliaETH"],
+])(
+    "a %s transaction shown with %s active reads %s",
+    (txNetworkId, activeNetworkId, symbol) => {
+        const chainId = NETWORKS[txNetworkId].chainId;
+        const hash = "0x" + "3".repeat(64);
+
+        beforeEach(() => {
+            elements.clear();
+            clearPrices();
+            state.networkId = activeNetworkId;
+            state.wallets = [
+                {
+                    name: "Wallet 1",
+                    addresses: [{ address: HOLDER, balance: "1.5" }],
+                },
+            ];
+            state.selectedWallet = 0;
+            state.selectedAddress = 0;
+            state.trackedTokens = [];
+            state.fraudContracts = [];
+            state.currentView = null;
+            txStatus.init({ doRefreshAndRender() {} });
+        });
+
+        afterEach(() => {
+            txStatus.endWait();
+        });
+
+        test("the approval screen's value and fee", async () => {
+            await approveTx(chainId);
+            expect(text("approve-tx-network")).toBe(NETWORKS[txNetworkId].name);
+            expect(text("approve-tx-value")).toBe("0.0100 " + symbol);
+            expect(text("approve-tx-fee")).toBe("0.0004 " + symbol);
+        });
+
+        test("the wait, success and error screens", async () => {
+            const txInfo = {
+                from: HOLDER,
+                to: RECIPIENT,
+                amount: "0.0100",
+                token: "ETH",
+                tokenSymbol: null,
+                chainId,
+            };
+            txStatus.showWait(txInfo, hash);
+            expect(text("wait-tx-summary")).toBe("0.0100 " + symbol);
+            txStatus.showError(txInfo, hash, "Failed.");
+            expect(text("error-tx-summary")).toBe("0.0100 " + symbol);
+            // A later popup resumes the wait, and the receipt is there.
+            state.viewData = {
+                pendingWait: { txInfo, hash, broadcastTime: Date.now() },
+            };
+            txStatus.restoreWait();
+            for (let i = 0; i < 10; i++) {
+                await new Promise((r) => setTimeout(r, 0));
+            }
+            expect(text("success-tx-summary")).toBe("0.0100 " + symbol);
+        });
+
+        // Sent from the Send screen on the transaction's network, then
+        // resumed by a popup that opens after the active network changed.
+        test("the wait screen after a send", async () => {
+            state.networkId = txNetworkId;
+            await confirmSend("0.1");
+            confirmTx.init({});
+            global.document.getElementById("confirm-tx-password").value = "pw";
+            await global.document
+                .getElementById("btn-confirm-send")
+                .handlers.get("click")();
+            expect(text("wait-tx-summary")).toBe("0.1 " + symbol);
+            state.networkId = activeNetworkId;
+            txStatus.restoreWait();
+            expect(text("wait-tx-summary")).toBe("0.1 " + symbol);
+        });
+
+        test("the transaction detail screen's type line and fee", async () => {
+            debugFetch.mockImplementationOnce(async () => ({
+                ok: true,
+                status: 200,
+                json: async () => ({ fee: { value: "21000000000000" } }),
+            }));
+            transactionDetail.show({
+                hash,
+                from: RECIPIENT,
+                to: HOLDER,
+                value: "1.0000",
+                exactValue: "1.0",
+                symbol,
+                timestamp: 1790000000,
+                isError: false,
+                direction: "received",
+                directionLabel: "Received",
+                contractAddress: null,
+                chainId,
+            });
+            expect(text("tx-detail-type")).toBe(
+                "Native " + symbol + " Transfer",
+            );
+            for (let i = 0; i < 10; i++) {
+                await new Promise((r) => setTimeout(r, 0));
+            }
+            expect(
+                global.document.getElementById("tx-detail-fee").innerHTML,
+            ).toContain("0.000021 " + symbol);
+        });
+    },
+);

tests/transactions.test.js

@@ -1219,7 +1219,7 @@ describe("fetchRecentTransactions merge and dedup", () => {
 
     test("queries only the two Blockscout endpoints for the address", async () => {
         respondWith([], []);
-        await fetchRecentTransactions(VICTIM, BLOCKSCOUT);
+        await fetchRecentTransactions(VICTIM, BLOCKSCOUT, "0x1");
         expect(debugFetch).toHaveBeenCalledTimes(2);
         const urls = debugFetch.mock.calls.map((c) => c[0]);
         expect(urls).toContain(
@@ -1283,7 +1283,7 @@ describe("fetchRecentTransactions merge and dedup", () => {
             ],
         );
 
-        const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT);
+        const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT, "0x1");
         expect(txs).toHaveLength(1);
         const merged = txs[0];
         // The received leg (the swap output) supplies the display amount.
@@ -1320,7 +1320,7 @@ describe("fetchRecentTransactions merge and dedup", () => {
             ],
         );
 
-        const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT);
+        const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT, "0x1");
         expect(txs).toHaveLength(1);
         expect(txs[0].symbol).toBe("USDC");
         expect(txs[0].value).toBe("1500.5000");
@@ -1346,7 +1346,7 @@ describe("fetchRecentTransactions merge and dedup", () => {
         });
         respondWith([], [leg("1000000"), leg("2000000")]);
 
-        const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT);
+        const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT, "0x1");
         expect(txs).toHaveLength(1);
         // Keyed by hash plus contract, so the later leg wins.
         expect(txs[0].exactValue).toBe("2.0");
@@ -1386,7 +1386,7 @@ describe("fetchRecentTransactions merge and dedup", () => {
             ],
         );
 
-        const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT);
+        const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT, "0x1");
         expect(txs.map((t) => t.symbol).sort()).toEqual(["USDC", "WETH"]);
     });
 
@@ -1427,12 +1427,13 @@ describe("fetchRecentTransactions merge and dedup", () => {
             ],
         );
 
-        const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT);
+        const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT, "0x1");
         expect(txs).toHaveLength(1);
         expect(txs[0].symbol).toBe("USDC");
         expect(txs[0].exactValue).toBe("1.0");
         expect(txs[0].direction).toBe("sent");
         expect(txs[0].contractAddress).toBe(USDC_CONTRACT);
+        expect(txs[0].chainId).toBe("0x1");
         // The surviving row is the token row, and the filters keep it.
         const kept = filterTransactions(txs, filters()).transactions;
         expect(kept).toHaveLength(1);
@@ -1452,10 +1453,46 @@ describe("fetchRecentTransactions merge and dedup", () => {
         });
         respondWith([item(6), item(8), item(7)], []);
 
-        const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT, 2);
+        const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT, "0x1", 2);
         expect(txs.map((t) => t.blockNumber)).toEqual([21000008, 21000007]);
     });
 
+    // https://git.eeqj.de/sneak/AutistMask/issues/372: the caller hands in
+    // the chain id of the network the explorer serves. Every entry carries
+    // it, and a native entry is labelled with that network's nativeCurrency.
+    test("a native entry is labelled by the chain id handed in", async () => {
+        respondWith(
+            [
+                {
+                    hash: "0x" + "a".repeat(64),
+                    block_number: 21000090,
+                    timestamp: TS,
+                    from: { hash: ORDINARY_PEER },
+                    to: { hash: VICTIM, is_contract: false },
+                    value: "10000000000000000",
+                    method: null,
+                    status: "ok",
+                },
+            ],
+            [],
+        );
+        const sepolia = await fetchRecentTransactions(
+            VICTIM,
+            BLOCKSCOUT,
+            "0xaa36a7",
+        );
+        expect(sepolia[0].symbol).toBe("SepoliaETH");
+        expect(sepolia[0].value).toBe("0.0100");
+        expect(sepolia[0].chainId).toBe("0xaa36a7");
+        const mainnet = await fetchRecentTransactions(
+            VICTIM,
+            BLOCKSCOUT,
+            "0x1",
+        );
+        expect(mainnet[0].symbol).toBe("ETH");
+        expect(mainnet[0].chainId).toBe("0x1");
+    });
+
     test("the fake token transfer survives fetching and is then filtered", async () => {
         respondWith(
             [],
@@ -1476,7 +1513,7 @@ describe("fetchRecentTransactions merge and dedup", () => {
             ],
         );
 
-        const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT);
+        const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT, "0x1");
         expect(txs).toHaveLength(1);
         expect(txs[0].contractAddress).toBe(FAKE_ETH_CONTRACT);
         expect(txs[0].holders).toBe(0);
@@ -1515,19 +1552,31 @@ describe("fetchRecentTransactions merge and dedup", () => {
 
         test("an omitted holders_count parses to null", async () => {
             respondWith([], spamTransferWithToken(OMITTED));
-            const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT);
+            const txs = await fetchRecentTransactions(
+                VICTIM,
+                BLOCKSCOUT,
+                "0x1",
+            );
             expect(txs[0].holders).toBeNull();
         });
 
         test("a null holders_count parses to null", async () => {
             respondWith([], spamTransferWithToken(NULLED));
-            const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT);
+            const txs = await fetchRecentTransactions(
+                VICTIM,
+                BLOCKSCOUT,
+                "0x1",
+            );
             expect(txs[0].holders).toBeNull();
         });
 
         test("the transfer survives the low-holder filter", async () => {
             respondWith([], spamTransferWithToken(OMITTED));
-            const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT);
+            const txs = await fetchRecentTransactions(
+                VICTIM,
+                BLOCKSCOUT,
+                "0x1",
+            );
             expect(filterTransactions(txs, filters()).transactions).toEqual(
                 txs,
             );
@@ -1539,7 +1588,11 @@ describe("fetchRecentTransactions merge and dedup", () => {
         // holder count is the only rule that can catch it.
         test('a reported holders_count of "0" still parses to 0 and is filtered', async () => {
             respondWith([], spamTransferWithToken(ZERO));
-            const txs = await fetchRecentTransactions(VICTIM, BLOCKSCOUT);
+            const txs = await fetchRecentTransactions(
+                VICTIM,
+                BLOCKSCOUT,
+                "0x1",
+            );
             expect(txs[0].holders).toBe(0);
             expect(filterTransactions(txs, filters()).transactions).toEqual([]);
         });
@@ -1555,7 +1608,7 @@ describe("fetchRecentTransactions merge and dedup", () => {
             },
         }));
         await expect(
-            fetchRecentTransactions(VICTIM, BLOCKSCOUT),
+            fetchRecentTransactions(VICTIM, BLOCKSCOUT, "0x1"),
         ).resolves.toEqual([]);
     });