test(taskengine): prove erc20_overrides flip the Uniswap swap revert end-to-end

Strengthen the RPC-level E2E test so it is a real before/after rather than a
revert-string check: assert the control run (no overrides) reverts on the
funding/approval precondition, then assert the same swap succeeds once
erc20_overrides seed USDC balance (slot 9) and the SwapRouter02 allowance
(slot 10) through the request → proto → RunNodeImmediately → SimulationStateMap
→ Tenderly path. Slots confirmed empirically against the deployed Sepolia USDC.

Author: will-dz

core/taskengine/run_node_immediately_rpc_test.go

@@ -3,6 +3,7 @@ package taskengine
 import (
 	"fmt"
 	"math/big"
+	"strings"
 	"testing"
 
 	"github.com/AvaProtocol/EigenLayer-AVS/core/chainio/aa"
@@ -465,31 +466,38 @@ func TestRunNodeImmediatelyRPC(t *testing.T) {
 		require.NotNil(t, control)
 		t.Logf("control (no overrides): success=%v error=%q", control.Success, control.Error)
 
+		// The swap pulls USDC from the runner via transferFrom, so without an
+		// approval (and balance) it reverts on the funding/approval precondition.
+		// The control run above establishes that baseline; assert it so the
+		// override run below is a meaningful before/after, not a no-op.
+		require.Falsef(t, control.Success,
+			"control run (no overrides) unexpectedly succeeded — the test wallet already has a standing USDC approval for SwapRouter02, so this test no longer proves erc20_overrides did anything. Reset the wallet's approval or use a fresh runner. control.Error=%q", control.Error)
+		require.True(t,
+			isFundingOrApprovalRevert(control.Error),
+			"control run should revert on the allowance/balance precondition the override targets, got: "+control.Error)
+
 		// Seed the runner's USDC balance and its approval for SwapRouter02 via the
-		// request. USDC on Sepolia is a FiatToken (balance slot 9, allowance slot
-		// 10); we also cover the standard ERC20 layout (balance 0, allowance 3) so
-		// the override lands regardless of the deployed token's storage layout. Each
-		// entry drives a distinct slot through the real request → proto →
-		// simulation-state path.
+		// request. USDC on Sepolia is Circle's FiatToken: balanceOf lives at
+		// storage slot 9 and allowance at slot 10 (confirmed empirically against
+		// the deployed token). Each entry drives a distinct slot through the real
+		// request → proto → RunNodeImmediately → SimulationStateMap → Tenderly
+		// state_objects path — the surface this PR adds.
 		maxAllowance := "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
-		bigBalance := "0x38d7ea4c68000" // 1,000,000 USDC
-		overrides := []*avsproto.ERC20StateOverride{}
-		for _, slot := range []uint64{0, 9} {
-			overrides = append(overrides, &avsproto.ERC20StateOverride{
+		bigBalance := "0x38d7ea4c68000" // 1,000,000 USDC (6 decimals)
+		overrides := []*avsproto.ERC20StateOverride{
+			{
 				TokenAddress: overridesUSDC,
 				OwnerAddress: runner,
 				Balance:      strPtr(bigBalance),
-				BalanceSlot:  u64Ptr(slot),
-			})
-		}
-		for _, slot := range []uint64{3, 10} {
-			overrides = append(overrides, &avsproto.ERC20StateOverride{
+				BalanceSlot:  u64Ptr(9),
+			},
+			{
 				TokenAddress:   overridesUSDC,
 				OwnerAddress:   runner,
 				SpenderAddress: strPtr(overridesSwapRouter02),
 				Allowance:      strPtr(maxAllowance),
-				AllowanceSlot:  u64Ptr(slot),
-			})
+				AllowanceSlot:  u64Ptr(10),
+			},
 		}
 
 		result, err := engine.RunNodeImmediatelyRPC(user, newReq(overrides))
@@ -499,13 +507,19 @@ func TestRunNodeImmediatelyRPC(t *testing.T) {
 
 		// The feature's contract: with balance + allowance seeded through the
 		// request, the simulation must not revert on the funding/approval
-		// precondition. Any remaining revert (e.g. pool liquidity) is unrelated.
+		// precondition that the control run hit.
 		assert.NotContains(t, result.Error, "transfer amount exceeds allowance",
 			"erc20_overrides should have seeded the allowance through the RPC path")
 		assert.NotContains(t, result.Error, "transfer amount exceeds balance",
 			"erc20_overrides should have seeded the balance through the RPC path")
 		assert.NotContains(t, result.Error, "STF",
 			"Uniswap TransferHelper 'STF' means transferFrom failed — overrides should prevent it")
+
+		// Decisive proof: the override run flips the control's precondition revert
+		// into a clean simulated swap. Only the seeded balance/allowance — flowing
+		// from the request all the way into the Tenderly simulation — can do that.
+		assert.Truef(t, result.Success,
+			"swap simulation should succeed once erc20_overrides seed balance+allowance, got error=%q", result.Error)
 	})
 }
 
@@ -521,6 +535,15 @@ const (
 func strPtr(s string) *string { return &s }
 func u64Ptr(v uint64) *uint64 { return &v }
 
+// isFundingOrApprovalRevert reports whether a simulation error is the
+// ERC20 funding/approval precondition that erc20_overrides exist to seed —
+// either the OpenZeppelin-style messages or Uniswap's TransferHelper "STF".
+func isFundingOrApprovalRevert(errMsg string) bool {
+	return strings.Contains(errMsg, "transfer amount exceeds allowance") ||
+		strings.Contains(errMsg, "transfer amount exceeds balance") ||
+		strings.Contains(errMsg, "STF")
+}
+
 // exactInputSingleSwapNode builds a SwapRouter02.exactInputSingle contractWrite
 // node that pulls `amountIn` USDC from the runner via transferFrom — the exact
 // path that reverts with "transfer amount exceeds allowance/balance" (Uniswap