test: drive ConfirmTx in the e2e suite, gate assertion included (closes #238)

ConfirmTx -- the screen that decides what gets signed -- had no automated
coverage of its own behaviour. The arithmetic underneath was well tested; the
wiring was not, so a mutant making the spend gate read the displayed fee
estimate instead of the reserve would have reintroduced the #154 overspend with
the suite still green.

Nine end-to-end tests now drive it for both the native and ERC-20 paths,
covering the pending, funded, over-balance and estimate-failed states, and
asserting that the gate reads the reserve rather than the estimate. Swapping the
two makes the suite fail. The view height is asserted constant across every
state transition rather than merely printed.

Reaching the screen needs a funded balance and a gas estimate, so the route
interception gains fixtures for both. Testing the estimate-failed state means
provoking the console error the code is supposed to emit, which the harness
otherwise fails a run on; an expectation mechanism consumes exactly one matching
record, is scoped to the declaring test, and fails that test if nothing matched,
so it cannot mask an unrelated error.

tests/e2e/network.js

@@ -53,18 +53,96 @@ const STUB_TX_TIMESTAMP = "2026-01-02T03:04:05.000000Z";
 // log.errorf(), i.e. console.error, which fails the run on its own.
 const ZERO_WORD = "0x" + "0".repeat(64);
 
+function hex(value) {
+    return "0x" + BigInt(value).toString(16);
+}
+
+// A bigint as a 32-byte ABI word.
+function word(value) {
+    return "0x" + BigInt(value).toString(16).padStart(64, "0");
+}
+
+// ------------------------------------------------------------ fee fixture
+//
+// The confirmation screen carries two different numbers for the same
+// transaction and may gate on only one of them:
+//
+//   reserve  = gasLimit * maxFeePerGas — what a node requires to be
+//              available for a type-2 transaction, and what the spend gate
+//              must use.
+//   estimate = gasLimit * gasPrice — what the transfer is expected to
+//              actually cost. Display only.
+//
+// Issue #154 was the gate reading the smaller of the two. ethers derives
+// maxFeePerGas as baseFeePerGas * 2 + maxPriorityFeePerGas, so the numbers
+// below put the reserve at very nearly twice the estimate. That gap is the
+// entire point of these values: it leaves room for a send that an
+// estimate-based gate accepts and a reserve-based gate refuses, which is
+// what lets the ConfirmTx tests tell the two apart at all. Collapse the gap
+// — by dropping baseFeePerGas from the block below, say — and those tests
+// go on passing while asserting nothing.
+const GAS_LIMIT = 21000n;
+const BASE_FEE_WEI = 100000000000n; // 100 gwei
+const PRIORITY_FEE_WEI = 1000000000n; // 1 gwei
+const GAS_PRICE_WEI = BASE_FEE_WEI + PRIORITY_FEE_WEI; // 101 gwei
+const MAX_FEE_WEI = BASE_FEE_WEI * 2n + PRIORITY_FEE_WEI; // 201 gwei
+
+const FEE_ESTIMATE_WEI = GAS_LIMIT * GAS_PRICE_WEI; // 0.002121 ETH
+const FEE_RESERVE_WEI = GAS_LIMIT * MAX_FEE_WEI; // 0.004221 ETH
+
 const RPC_RESULTS = {
     eth_chainId: "0x1",
     net_version: "1",
     eth_blockNumber: "0x1406f40",
     eth_getBalance: "0x0",
     eth_call: ZERO_WORD,
-    eth_gasPrice: "0x3b9aca00",
-    eth_estimateGas: "0x5208",
+    eth_getCode: "0x",
+    eth_gasPrice: hex(GAS_PRICE_WEI),
+    eth_estimateGas: hex(GAS_LIMIT),
     eth_getTransactionCount: "0x0",
-    eth_maxPriorityFeePerGas: "0x3b9aca00",
+    eth_maxPriorityFeePerGas: hex(PRIORITY_FEE_WEI),
 };
 
+// The "latest" block, which ethers' getFeeData() reads baseFeePerGas from
+// to derive maxFeePerGas. Without it every fee is a legacy gasPrice, the
+// reserve and the estimate collapse to the same number, and the gate tests
+// stop being able to distinguish them.
+function latestBlock() {
+    return {
+        hash: "0x" + "11".repeat(32),
+        parentHash: "0x" + "22".repeat(32),
+        number: hex(STUB_BLOCK_NUMBER),
+        timestamp: hex(1767326645),
+        nonce: "0x0000000000000000",
+        difficulty: "0x0",
+        gasLimit: "0x1c9c380",
+        gasUsed: "0xf4240",
+        miner: STUB_COUNTERPARTY,
+        extraData: "0x",
+        baseFeePerGas: hex(BASE_FEE_WEI),
+        transactions: [],
+    };
+}
+
+// keccak("decimals()")[0:4].
+const SELECTOR_DECIMALS = "0x313ce567";
+
+// Every eth_call still answers with a zero word except decimals() on the
+// stub token. ethers reads that before it can encode an ERC-20 transfer,
+// and a zero there makes parseUnits() reject any fractional amount — so the
+// ERC-20 confirmation path would fail its gas estimate for a reason that
+// has nothing to do with what is being tested.
+function ethCallResult(req) {
+    const call = Array.isArray(req.params) ? req.params[0] : null;
+    if (!call || typeof call !== "object") return ZERO_WORD;
+    const data = String(call.data || call.input || "").toLowerCase();
+    const to = String(call.to || "").toLowerCase();
+    if (data.startsWith(SELECTOR_DECIMALS) && to === STUB_TOKEN.address) {
+        return word(STUB_TOKEN.decimals);
+    }
+    return ZERO_WORD;
+}
+
 function tokenObject() {
     return {
         address_hash: STUB_TOKEN.address,
@@ -92,6 +170,18 @@ function tokenTransferItems(address) {
     ];
 }
 
+// A holding of 1.5 E2E, in the shape src/shared/balances.js parses. Serving
+// this is what puts an ERC-20 in the send screen's token dropdown, which is
+// the only way the confirmation screen's ERC-20 path can be reached.
+function tokenBalanceItems() {
+    return [
+        {
+            value: "1500000",
+            token: tokenObject(),
+        },
+    ];
+}
+
 // Full details for STUB_TX_HASH. raw_input is "0x" so the calldata
 // decoder short-circuits; the on-chain detail fields still populate.
 function transactionDetails() {
@@ -121,7 +211,82 @@ function blockscoutAddress(pathname) {
     return m ? m[1] : null;
 }
 
-function handleRpc(route, postData, report) {
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// How long a deliberately held reply is allowed to stay held, and how often
+// the release flag is re-read while it is.
+const HOLD_POLL_MS = 25;
+const HOLD_MAX_MS = 30000;
+
+// Hold a gas estimate open for as long as the test asks.
+//
+// opts.holdGasEstimate is read here rather than captured, so a test flips it
+// on the same options object the route was registered with — the same
+// pattern as seedTokenTransfer. This is the only way to observe the
+// confirmation screen while its estimate is genuinely in flight; sampling
+// the screen and hoping to win a race against the network would assert
+// nothing on a slow machine.
+//
+// It never gives up quietly. A hold that outlives the bound is reported like
+// any other harness fault, because a "pending" state that stopped being
+// pending on its own is a green assertion about the wrong screen.
+async function awaitRelease(opts, report) {
+    const started = Date.now();
+    while (opts.holdGasEstimate) {
+        if (Date.now() - started > HOLD_MAX_MS) {
+            report(
+                "held gas estimate was never released after " +
+                    HOLD_MAX_MS +
+                    "ms",
+            );
+            return;
+        }
+        await sleep(HOLD_POLL_MS);
+    }
+}
+
+// One JSON-RPC reply. Methods whose answer depends on a fixture a test has
+// set, or on the call itself, are resolved here; every other method is a
+// constant in RPC_RESULTS.
+function rpcReply(req, opts, report) {
+    const envelope = { jsonrpc: "2.0", id: req.id };
+
+    if (req.method === "eth_getBalance") {
+        return Object.assign(envelope, {
+            result: opts.ethBalanceWei || RPC_RESULTS.eth_getBalance,
+        });
+    }
+    if (req.method === "eth_call") {
+        return Object.assign(envelope, { result: ethCallResult(req) });
+    }
+    if (req.method === "eth_getBlockByNumber") {
+        return Object.assign(envelope, { result: latestBlock() });
+    }
+    if (req.method === "eth_estimateGas" && opts.failGasEstimate) {
+        // A refusal the node itself would produce, not a transport error:
+        // this is the shape the confirmation screen has to turn into
+        // "Unable to estimate" rather than into a fee of zero.
+        return Object.assign(envelope, {
+            error: {
+                code: -32000,
+                message: "e2e fixture: gas required exceeds allowance",
+            },
+        });
+    }
+
+    const result = RPC_RESULTS[req.method];
+    if (result === undefined) {
+        report("unstubbed RPC method: " + req.method);
+        return Object.assign(envelope, {
+            error: { code: -32601, message: "unstubbed in e2e harness" },
+        });
+    }
+    return Object.assign(envelope, { result });
+}
+
+async function handleRpc(route, postData, opts, report) {
     let payload;
     try {
         payload = JSON.parse(postData || "null");
@@ -148,18 +313,11 @@ function handleRpc(route, postData, report) {
         report("unstubbed request: POST " + route.request().url());
         return route.abort();
     }
-    const replies = batch.map((req) => {
-        const result = RPC_RESULTS[req.method];
-        if (result === undefined) {
-            report("unstubbed RPC method: " + req.method);
-            return {
-                jsonrpc: "2.0",
-                id: req.id,
-                error: { code: -32601, message: "unstubbed in e2e harness" },
-            };
-        }
-        return { jsonrpc: "2.0", id: req.id, result };
-    });
+    if (batch.some((req) => req.method === "eth_estimateGas")) {
+        await awaitRelease(opts, report);
+    }
+
+    const replies = batch.map((req) => rpcReply(req, opts, report));
     return jsonResponse(route, Array.isArray(payload) ? replies : replies[0]);
 }
 
@@ -199,6 +357,15 @@ function traceEnabled(raw) {
  * @param {boolean} [opts.seedTokenTransfer]  serve the stubbed ERC-20
  *   transfer. Read at request time, so a test can flip it on the same
  *   options object without re-registering the route.
+ * @param {boolean} [opts.seedTokenBalance]  serve the stubbed ERC-20
+ *   holding, which is what makes the token reachable from the send screen.
+ * @param {string} [opts.ethBalanceWei]  hex wei answered to eth_getBalance;
+ *   defaults to zero, which is what every test that predates the funded
+ *   fixture expects.
+ * @param {boolean} [opts.failGasEstimate]  answer eth_estimateGas with a
+ *   node-side refusal.
+ * @param {boolean} [opts.holdGasEstimate]  hold every batch containing an
+ *   eth_estimateGas until this is cleared again.
  * @returns {Promise<{waitForServiceWorkerTraffic: (ms: number) =>
  *   Promise<string|null>}>}
  */
@@ -241,7 +408,7 @@ async function installNetworkStubs(ctx, opts) {
 
         // JSON-RPC endpoint (any host): a POST with a JSON-RPC body.
         if (req.method() === "POST") {
-            return handleRpc(route, req.postData(), report);
+            return handleRpc(route, req.postData(), opts, report);
         }
 
         // Blockscout v2
@@ -259,7 +426,10 @@ async function installNetworkStubs(ctx, opts) {
                 });
             }
             if (/\/addresses\/0x[0-9a-fA-F]{40}\/token-balances$/.test(p)) {
-                return jsonResponse(route, []);
+                return jsonResponse(
+                    route,
+                    opts.seedTokenBalance ? tokenBalanceItems() : [],
+                );
             }
             if (p.endsWith("/transactions/" + STUB_TX_HASH)) {
                 return jsonResponse(route, transactionDetails());
@@ -329,6 +499,9 @@ async function installNetworkStubs(ctx, opts) {
 
 module.exports = {
     installNetworkStubs,
+    FEE_ESTIMATE_WEI,
+    FEE_RESERVE_WEI,
+    STUB_COUNTERPARTY,
     STUB_TOKEN,
     STUB_TX_HASH,
 };