feat: a "Max" button on the Send screen (closes #198)

Max fills in a token's balance, cut down to the 18 decimal places the
confirmation screen accepts, or for ETH the exact balance minus the fee
reserve the confirmation screen's balance check gates on. An ETH fee estimate
that finishes after the Send screen was left, or its address, holding,
recipient or amount changed, fills nothing in. The confirmation screen works a
max ETH amount out again from its own fee estimate and signs it with that
estimate's fee fields, so a fee that rose before signing cannot push amount
plus fee above the balance. validateTransfer() still gates every send, the
check that ETH covers a token send's fee included. Where there is nothing to
fill in, a flash message says why.

Model: opus-5-5

src/popup/views/send.js

@@ -22,10 +22,25 @@ const {
     truncateAmountNeverZero,
     isBelowOneMillionth,
 } = require("../../shared/amountDisplay");
-const { getAddress } = require("ethers");
+const {
+    feeReserveWei,
+    maxEthAmount,
+    maxTokenAmount,
+} = require("../../shared/txValidation");
+const { log } = require("../../shared/log");
+const { getAddress, parseEther } = require("ethers");
 
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 
+// Whether the amount field holds what Max filled in. The confirmation screen
+// re-derives a max ETH amount from its own fee estimate; typing in the field
+// makes it an ordinary amount again.
+let amountIsMax = false;
+
+// Counts the times the Send screen has opened, so a Max fee estimate started
+// before it was last opened fills nothing in.
+let sendScreenOpenings = 0;
+
 /**
  * Validate a destination address string.
  * Returns { valid: true } or { valid: false, error: "..." }.
@@ -229,9 +244,102 @@ function updateSendBalance() {
     }
 }
 
+// Fill the amount field with the most the selected holding can send: a
+// token's whole balance (cut to 18 decimal places), or for ETH the exact
+// balance minus the fee reserve the confirmation screen checks against, never
+// the rounded balance the screen shows. Where there is nothing to fill in, a
+// flash message says why.
+async function fillMaxAmount() {
+    const addr = currentAddress();
+    if (!addr) return;
+    const token = state.selectedToken || $("send-token").value;
+
+    if (token !== "ETH") {
+        const bal = tokenBalanceAndDecimals(addr, token).tokenBalance;
+        if (bal == null) {
+            showFlash("This token's balance is unknown.");
+            return;
+        }
+        const amount = maxTokenAmount(bal);
+        if (!(parseFloat(amount) > 0)) {
+            showFlash("This token's balance is zero.");
+            return;
+        }
+        $("send-amount").value = amount;
+        amountIsMax = true;
+        return;
+    }
+
+    // The fee is estimated for this recipient, as the confirmation screen
+    // estimates it: sending to a contract can cost more gas.
+    const to = $("send-to").value.trim();
+    if (!validateToAddress(to).valid) {
+        showFlash("Please enter a recipient address first.");
+        return;
+    }
+    const typed = $("send-amount").value;
+    const opening = sendScreenOpenings;
+    let feeWei = null;
+    try {
+        const provider = getProvider(state.rpcUrl, state.networkId);
+        const [feeData, gasLimit] = await Promise.all([
+            provider.getFeeData(),
+            provider.estimateGas({
+                from: addr.address,
+                to,
+                value: parseEther(addr.balance || "0"),
+            }),
+        ]);
+        feeWei = feeReserveWei(gasLimit, feeData);
+    } catch (e) {
+        log.errorf(
+            "max amount fee estimate failed:",
+            e.shortMessage || e.message,
+        );
+    }
+    // While the estimate was in flight the user left the screen (and perhaps
+    // opened it again), typed an amount, or changed the address, the holding
+    // or the recipient: what they did wins.
+    if (
+        state.currentView !== "send" ||
+        sendScreenOpenings !== opening ||
+        currentAddress()?.address !== addr.address ||
+        (state.selectedToken || $("send-token").value) !== token ||
+        $("send-to").value.trim() !== to ||
+        $("send-amount").value !== typed
+    ) {
+        return;
+    }
+
+    if (feeWei === null) {
+        showFlash("The network fee could not be estimated.");
+        return;
+    }
+    const amount = maxEthAmount(addr.balance, feeWei);
+    if (amount === null) {
+        showFlash("Your balance does not cover the network fee.");
+        return;
+    }
+    $("send-amount").value = amount;
+    amountIsMax = true;
+}
+
 function init(_ctx) {
     ctx = _ctx;
-    $("send-token").addEventListener("change", updateSendBalance);
+    $("send-token").addEventListener("change", () => {
+        // A filled-in maximum is the maximum of the holding it was filled in
+        // for.
+        if (amountIsMax) {
+            $("send-amount").value = "";
+            amountIsMax = false;
+        }
+        updateSendBalance();
+    });
+
+    $("btn-send-max").addEventListener("click", fillMaxAmount);
+    $("send-amount").addEventListener("input", () => {
+        amountIsMax = false;
+    });
 
     // Initial state: disable review button until address is entered
     $("btn-send-review").disabled = true;
@@ -308,6 +416,7 @@ function init(_ctx) {
             tokenSymbol: tokenSymbol,
             tokenBalance: tokenBalance,
             tokenDecimals: tokenDecimals,
+            max: amountIsMax,
         });
     });
 
@@ -318,7 +427,10 @@ function init(_ctx) {
     });
 }
 
+// Called each time the Send screen opens, with its fields cleared.
 function resetSendValidation() {
+    sendScreenOpenings++;
+    amountIsMax = false;
     const errorEl = $("send-to-error");
     const btn = $("btn-send-review");
     if (errorEl) errorEl.textContent = "";