fix: say an unknown-scale balance the same way on Send and on confirm (closes #377)

When two addresses' explorer reports disagree on a token's decimals, the
Send screen showed the stored figure while the confirmation screen said
the balance was unknown. One function in send.js now gives both the
balance and scale, so both read `unknown (SYMBOL)`.

The confirmation screen's fee-unknown message names its cause: for an
unknown scale it says the wallet does not know the token's decimal
places and the transaction cannot be sent, instead of asking for a
retry that cannot help. Other causes keep the old sentence.

Model: opus-5-5

src/popup/views/confirmTx.js

@@ -198,6 +198,19 @@ function show(txInfo) {
     $("confirm-amount-fee-error").classList.toggle("hidden", isErc20);
     $("confirm-gas-error").classList.toggle("hidden", !isErc20);
 
+    // The fee-unknown message names its cause, which is also known here.
+    // Without the token's scale estimateGas() cannot encode the transfer, so
+    // the estimate fails every time and going back cannot help; any other
+    // failure may clear on a retry.
+    $("confirm-fee-unknown-error").textContent =
+        isErc20 && txInfo.tokenDecimals == null
+            ? "The network fee could not be estimated, because this wallet" +
+              " does not know how many decimal places this token uses, so" +
+              " this transaction cannot be sent."
+            : "The network fee could not be estimated, so this transaction" +
+              " cannot be checked against your balance. Please go back and" +
+              " try again.";
+
     renderValidation(txInfo);
 
     // Reset password field and error
@@ -244,7 +257,8 @@ function renderValidation(txInfo) {
     });
 
     // Messages carrying the user's own numbers are built here; the fixed
-    // sentences live in the reserved elements in index.html.
+    // sentences live in the reserved elements in index.html, except the
+    // fee-unknown one, which show() sets.
     const messages = [];
     if (codes.includes(CODES.AMOUNT_INVALID)) {
         messages.push("Please enter a valid amount to send.");

src/popup/views/send.js

@@ -146,6 +146,50 @@ function renderSendTokenSelect(addr) {
     }
 }
 
+// The token balance and scale the Send screen states and hands the
+// confirmation screen, so the two screens describe the holding the same way.
+//
+// The scale is resolved the same way balances.js resolved the scale it
+// DISPLAYED this token's balance at: bundled list, then the user's tracked
+// tokens, then the explorer. The stored tokenBalances[].decimals is the
+// explorer's own answer alone, so reading it raw carries a null forward for a
+// token the wallet does know the scale of — and displayedDecimals() then throws
+// inside estimateGas(), which the confirmation screen reports as an unestimable
+// fee. Unsendable, over a scale that was never in doubt
+// (https://git.eeqj.de/sneak/AutistMask/issues/349). Still null when nothing
+// knows: no fallback.
+//
+// Resolved WITH `wallets`, which balances.js does not pass: that adds
+// explorerDecimals()'s cross-address check, so a contract two addresses report
+// different scales for answers null rather than picking one. That check has to
+// apply here, because this scale encodes the transfer — it is carried forward
+// so the transfer is encoded with the number the user read rather than with
+// whatever the contract answers at signing time (see
+// src/shared/transferAmount.js). balances.js is formatting one explorer row at
+// fetch time and cannot consult a state it is in the middle of replacing.
+//
+// The two resolutions can therefore differ, and where they do, the stored
+// `balance` is a quantity computed at a scale this screen has just declined to
+// stand behind. Stating it would leave validateTransfer() checking the amount
+// against a number the wallet does not vouch for, so it is withdrawn: unknown
+// scale means unknown balance. It is null rather than "0": both screens state
+// an unknown balance as unknown, and validateTransfer() treats it as no balance
+// to spend from, which is the fail-closed side of an amount nobody can check.
+// Only a stored quantity is withdrawn: the "0" for a token that has no row at
+// all is an absence of holdings, which is true at every scale.
+function tokenBalanceAndDecimals(addr, token) {
+    const tb = (addr.tokenBalances || []).find(
+        (t) => t.address.toLowerCase() === token.toLowerCase(),
+    );
+    const tokenDecimals = resolveTokenDecimals(token, {
+        trackedTokens: state.trackedTokens,
+        wallets: state.wallets,
+    });
+    if (!tb) return { tokenBalance: "0", tokenDecimals };
+    if (tokenDecimals === null) return { tokenBalance: null, tokenDecimals };
+    return { tokenBalance: tb.balance ?? null, tokenDecimals };
+}
+
 function updateSendBalance() {
     const addr = currentAddress();
     if (!addr) return;
@@ -162,18 +206,16 @@ function updateSendBalance() {
             truncateAmountNeverZero(addr.balance || "0") +
             " ETH";
     } else {
-        const tb = (addr.tokenBalances || []).find(
-            (t) => t.address.toLowerCase() === token.toLowerCase(),
-        );
         const symbol = resolveSymbol(
             token,
             addr.tokenBalances,
             state.trackedTokens,
         );
-        // A null balance is a holding whose scale nothing knows. Saying "0"
-        // for it would be a claim about the amount; the send itself is
+        // A null balance is a holding whose scale is unknown. Saying a figure
+        // for it would be a claim about the amount, so it reads as the
+        // confirmation screen's balance line reads it; the send itself is
         // refused later by transferAmountUnits() for the same missing scale.
-        const bal = tb ? tb.balance : "0";
+        const bal = tokenBalanceAndDecimals(addr, token).tokenBalance;
         $("send-balance").textContent =
             bal == null
                 ? "Current balance: unknown (" + symbol + ")"
@@ -240,59 +282,17 @@ function init(_ctx) {
 
         let tokenSymbol = null;
         let tokenBalance = null;
-        // The scale the amount and the balance below are rendered at, carried
-        // forward so the transfer is encoded with the number the user read
-        // rather than with whatever the contract answers at signing time. See
-        // src/shared/transferAmount.js.
         let tokenDecimals = null;
         if (token !== "ETH") {
-            const tb = (addr.tokenBalances || []).find(
-                (t) => t.address.toLowerCase() === token.toLowerCase(),
-            );
             tokenSymbol = resolveSymbol(
                 token,
                 addr.tokenBalances,
                 state.trackedTokens,
             );
-            // null carried through rather than flattened to "0": the confirm
-            // screen states an unknown balance as unknown, and
-            // validateTransfer() treats it as no balance to spend from, which
-            // is the fail-closed side of an amount nobody can check.
-            tokenBalance = tb ? (tb.balance ?? null) : "0";
-            // Resolved the same way balances.js resolved the scale it
-            // DISPLAYED this token's balance at: bundled list, then the user's
-            // tracked tokens, then the explorer. The stored
-            // tokenBalances[].decimals is the explorer's own answer alone, so
-            // reading it raw carries a null forward for a token the wallet
-            // does know the scale of — and displayedDecimals() then throws
-            // inside estimateGas(), which the confirmation screen reports as
-            // an unestimable fee. Unsendable, over a scale that was never in
-            // doubt (https://git.eeqj.de/sneak/AutistMask/issues/349).
-            // Still null when nothing knows: no fallback.
-            //
-            // Resolved WITH `wallets`, which balances.js does not pass: that
-            // adds explorerDecimals()'s cross-address check, so a contract two
-            // addresses report different scales for answers null rather than
-            // picking one. That check has to apply here, because this value
-            // encodes a transfer; balances.js is formatting one explorer row
-            // at fetch time and cannot consult a state it is in the middle of
-            // replacing.
-            tokenDecimals = resolveTokenDecimals(token, {
-                trackedTokens: state.trackedTokens,
-                wallets: state.wallets,
-            });
-            // The two resolutions can therefore differ, and where they do, the
-            // stored `balance` is a quantity computed at a scale this screen
-            // has just declined to stand behind. Stating it would leave
-            // validateTransfer() checking the amount against a number the
-            // wallet does not vouch for, and — since the unknown-balance path
-            // is gated on the balance, not on the scale — would leave the
-            // fee-estimate failure as the only thing on the confirmation
-            // screen, which says nothing about decimals. Unknown scale means
-            // unknown balance. Only a stored quantity is withdrawn: the "0"
-            // for a token that has no row at all is an absence of holdings,
-            // which is true at every scale.
-            if (tb && tokenDecimals === null) tokenBalance = null;
+            ({ tokenBalance, tokenDecimals } = tokenBalanceAndDecimals(
+                addr,
+                token,
+            ));
         }
 
         ctx.showConfirmTx({