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

The screen that decides what gets signed had no automated coverage of its
own behaviour: no unit tests, and the e2e suite never reached it. The
arithmetic underneath is well covered in src/shared/txValidation.js; the
gap was the wiring — which number reaches the gate, when the gate re-runs,
what the fee block renders, and whether Send is enabled.

The confirmation screen quotes the fee ESTIMATE (gasLimit * gasPrice) and
gates on the fee RESERVE (gasLimit * maxFeePerGas). Reading the quoted
number instead was issue #154, and until now that was correct by reading
only — a mutant swapping the two passed the whole suite. It no longer
does: two of the new tests fail on it, one per transaction type.

The harness gains a funded-balance fixture to make any of this reachable.
tests/e2e/network.js now serves a configurable ETH balance, an ERC-20
holding, a latest block with a baseFeePerGas (without which ethers has no
maxFeePerGas and the reserve and the estimate collapse into one number),
and decimals() for the stub token. It can also refuse a gas estimate, and
hold one open so the pending state can be observed rather than raced.

Nine tests, over both the native ETH and the ERC-20 path: Send disabled
while the estimate is pending, enabled once it lands, the fee block
quoting both numbers, the distinct message for an estimate that failed,
refusal for a send past the balance, refusal for a send the reserve does
not cover, and the view height constant across every one of those
transitions.

Driving a failure path means provoking the console.error the code is
supposed to emit, which the harness fails a run on. ErrorCollector gains
expect(): it consumes exactly one matching record, and a declaration
nothing matched fails its test just as an undeclared error does, so it
cannot be used to silence anything. Both halves of that were verified by
running the suite against a deliberately wrong pattern.

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,
 };