fix: show balances and fees below 0.000001 as nonzero on the send screens (closes #343)

The stored ETH and token balances and the send-confirm screen's fee were each
cut to six decimal places, and a token holding cut to zero was dropped, so a
value below 0.000001 read as zero. Balances are now stored exactly, whatever
decimals a token declares, and every nonzero token holding is kept; the balance
check reads a token balance to its first 18 places. The balance lists, the
send-screen token selector, the address total and the remove-address warning
leave out a holding below 0.000001 themselves, through isBelowOneMillionth().
The send and send-confirm screens' balances, reserve and insufficient-balance
messages go through truncateAmountNeverZero(). The send-confirm and approval
screens both render the fee through formatFee(), which prices the exact fee in
USD.

Model: opus-5-5

src/shared/amountDisplay.js

@@ -6,10 +6,10 @@
 // (`src/shared/uniswap.js`) — and a fix applied to one of them left the other
 // two showing a different number for the same value.
 //
-// The two functions below are the two policies, not two implementations of
-// one: summary lists truncate, and the screens that state what is being
-// authorized truncate with a floor. Keeping them adjacent is the point, so a
-// change to the rule cannot reach one screen and miss another.
+// The two truncation functions below are the two policies, not two
+// implementations of one: summary lists truncate, and the screens that state
+// what is being authorized truncate with a floor. Keeping them adjacent is the
+// point, so a change to the rule cannot reach one screen and miss another.
 
 // Truncate to exactly four decimal places. Truncation, never rounding: an
 // amount must never be displayed as larger than it is, so 0.99999 stays
@@ -43,4 +43,18 @@ function truncateAmountNeverZero(val) {
     return parts[0] + "." + parts[1].slice(0, sig + 1);
 }
 
-module.exports = { truncateAmount, truncateAmountNeverZero };
+// Whether a stored token balance is a holding below 0.000001. The balance
+// lists, the send-screen token selector, the address total and the
+// remove-address warning leave such a holding out; the Send and confirmation
+// screens show it when its token is the one being sent. Exact, because
+// src/shared/balances.js stores plain decimal digits: below 0.000001 the
+// balance reads "0.000000" and then more digits.
+function isBelowOneMillionth(balance) {
+    return typeof balance === "string" && balance.startsWith("0.000000");
+}
+
+module.exports = {
+    truncateAmount,
+    truncateAmountNeverZero,
+    isBelowOneMillionth,
+};

src/shared/balances.js

@@ -52,19 +52,16 @@ function requireNetworkId(networkId) {
     return net;
 }
 
-function formatBalance(wei) {
-    const eth = formatEther(wei);
-    const parts = eth.split(".");
-    if (parts.length === 1) return eth + ".0";
-    const dec = parts[1].slice(0, 6).replace(/0+$/, "") || "0";
-    return parts[0] + "." + dec;
-}
-
+// A token balance as an exact decimal string, never cut: a cut stores a small
+// nonzero holding as zero. fetchTokenBalances() stores every nonzero holding of
+// a token it admits, however small; the screens that leave out one below
+// 0.000001 decide that themselves, through isBelowOneMillionth() in
+// src/shared/amountDisplay.js.
 function formatTokenBalance(raw, decimals) {
     const val = formatUnits(raw, decimals);
     const parts = val.split(".");
     if (parts.length === 1) return val + ".0";
-    const dec = parts[1].slice(0, 6).replace(/0+$/, "") || "0";
+    const dec = parts[1].replace(/0+$/, "") || "0";
     return parts[0] + "." + dec;
 }
 
@@ -149,11 +146,7 @@ async function fetchTokenBalances(address, blockscoutUrl, trackedTokens) {
             const scale = known !== null ? known : decimals;
             // null is a holding of an amount that cannot be stated, which is
             // not the same as a holding of zero, and must never render as one.
-            // With a scale, the display filter proper applies: a balance that
-            // rounds to zero at six places is dust and is not listed. Without
-            // one there is no such judgement to make, and the row is kept.
             const bal = scale === null ? null : formatTokenBalance(raw, scale);
-            if (bal === "0.0") continue;
             // null means the explorer reported no count, which is not the
             // same as a count of zero.  This gate is not the low-holder
             // display filter: it has no user-facing off switch and governs
@@ -221,7 +214,9 @@ async function refreshBalances(
                 provider
                     .getBalance(addr.address)
                     .then((bal) => {
-                        addr.balance = formatBalance(bal);
+                        // Exact, never cut: a cut here stores a small nonzero
+                        // balance as zero.
+                        addr.balance = formatEther(bal);
                         log.debugf("ETH balance", addr.address, addr.balance);
                     })
                     .catch((e) => {

src/shared/prices.js

@@ -1,6 +1,7 @@
 // Price fetching with 5-minute cache, USD formatting, value aggregation.
 
 const { getTopTokenPrices } = require("./tokenList");
+const { isBelowOneMillionth } = require("./amountDisplay");
 
 const PRICE_CACHE_TTL = 300000; // 5 minutes
 
@@ -78,6 +79,9 @@ function getAddressValue(addr) {
     let usd = parseFloat(addr.balance || "0") * prices.ETH;
     let partial = false;
     for (const token of addr.tokenBalances || []) {
+        // A holding below 0.000001 is left out, as the balance lists leave it
+        // out, so the total never counts a holding the list does not show.
+        if (isBelowOneMillionth(token.balance)) continue;
         // A null balance is a holding whose scale nothing knows, so it has no
         // quantity to price — but it is still a holding, and a total that
         // silently omits it would read as complete. That is exactly what

src/shared/txValidation.js

@@ -139,7 +139,15 @@ function validateTransfer({
     const feeFp = known ? feeWei : null;
 
     if (isErc20) {
-        const tokenFp = toFixedPoint(tokenBalance) ?? 0n;
+        // A token can declare more than 18 decimals, and its balance is
+        // stored with all of them. Only the first 18 places (SCALE_DECIMALS)
+        // are read: an amount with more was refused above, so the places
+        // after them cannot decide whether the amount fits.
+        const tokenText =
+            typeof tokenBalance === "string"
+                ? tokenBalance.replace(/(\.\d{18})\d+$/, "$1")
+                : tokenBalance;
+        const tokenFp = toFixedPoint(tokenText) ?? 0n;
         if (amountFp > tokenFp) codes.push(CODES.INSUFFICIENT_TOKEN);
         if (feeFp !== null && feeFp > ethFp) {
             codes.push(CODES.INSUFFICIENT_ETH_FOR_FEE);