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/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) => {