fix: add call path to revert errors and improve sender recovery

- Include target address in revert error messages for both eth_simulateV1
  and debug_traceCall to help identify which call failed
- Handle contract creation case consistently (show "contract creation"
  when to address is empty)
- Add recoverSender function that handles different tx types correctly:
  pre-EIP-155 (HomesteadSigner), EIP-155, EIP-2930, EIP-1559, EIP-4844
- Add tests with real mainnet transactions (pre-EIP-155 and EIP-1559)
  to verify parsing and sender recovery end-to-end

Author: kant777

tools/preconf-rpc/sim/inline_simulator.go

@@ -94,7 +94,7 @@ func NewInlineSimulator(rpcURLs []string, logger *slog.Logger) (*InlineSimulator
 	}
 
 	if len(endpoints) == 0 {
-		return nil, fmt.Errorf("failed to connect to any RPC endpoint")
+		return nil, errors.New("failed to connect to any RPC endpoint")
 	}
 
 	if logger == nil {
@@ -140,11 +140,10 @@ func (s *InlineSimulator) Simulate(ctx context.Context, txRaw string, state SimS
 		return nil, false, fmt.Errorf("invalid transaction: %w", err)
 	}
 
-	signer := types.LatestSignerForChainID(tx.ChainId())
-	sender, err := types.Sender(signer, tx)
+	sender, err := recoverSender(tx)
 	if err != nil {
 		s.metrics.fail.Inc()
-		return nil, false, fmt.Errorf("failed to get sender: %w", err)
+		return nil, false, fmt.Errorf("failed to recover sender: %w", err)
 	}
 
 	// Build call object. We use "input" here; debug_traceCall expects "data" so we convert later.
@@ -158,7 +157,6 @@ func (s *InlineSimulator) Simulate(ctx context.Context, txRaw string, state SimS
 		callObj["to"] = tx.To().Hex()
 	}
 
-	// Set gas price fields based on tx type (EIP-1559 vs legacy)
 	switch tx.Type() {
 	case types.DynamicFeeTxType, types.BlobTxType:
 		callObj["maxFeePerGas"] = hexutil.EncodeBig(tx.GasFeeCap())
@@ -245,6 +243,12 @@ func (s *InlineSimulator) executeSimulateV1(ctx context.Context, client *rpc.Cli
 
 	call := block.Calls[0]
 
+	// Extract call target for error messages
+	toAddr := "contract creation"
+	if to, ok := callObj["to"].(string); ok && to != "" {
+		toAddr = to
+	}
+
 	// status 0 means reverted
 	if call.Status == 0 {
 		reason := "execution reverted"
@@ -253,7 +257,7 @@ func (s *InlineSimulator) executeSimulateV1(ctx context.Context, client *rpc.Cli
 		} else if len(call.ReturnData) > 0 {
 			reason = decodeRevert(hexutil.Encode(call.ReturnData), reason)
 		}
-		return nil, false, &NonRetryableError{Err: fmt.Errorf("reverted: %s", reason)}
+		return nil, false, &NonRetryableError{Err: fmt.Errorf("reverted: %s (to=%s)", reason, toAddr)}
 	}
 
 	if call.GasUsed == 0 {
@@ -296,7 +300,11 @@ func (s *InlineSimulator) executeDebugTraceCall(ctx context.Context, client *rpc
 
 	if result.Error != "" {
 		reason := decodeRevertFromTrace(result.Output, result.Error)
-		return nil, false, &NonRetryableError{Err: fmt.Errorf("reverted: %s", reason)}
+		toAddr := result.To
+		if toAddr == "" {
+			toAddr = "contract creation"
+		}
+		return nil, false, &NonRetryableError{Err: fmt.Errorf("reverted: %s (to=%s)", reason, toAddr)}
 	}
 
 	// Check nested calls for reverts (e.g., inner contract call failed)
@@ -422,3 +430,30 @@ func (s *InlineSimulator) Close() error {
 	}
 	return nil
 }
+
+// recoverSender extracts the sender address from a signed transaction.
+// Uses the appropriate signer based on transaction type to handle edge cases
+// like pre-EIP-155 transactions that lack chain ID replay protection.
+func recoverSender(tx *types.Transaction) (common.Address, error) {
+	var signer types.Signer
+
+	switch tx.Type() {
+	case types.LegacyTxType:
+		chainID := tx.ChainId()
+		if chainID.Sign() == 0 {
+			signer = types.HomesteadSigner{}
+		} else {
+			signer = types.NewEIP155Signer(chainID)
+		}
+	case types.AccessListTxType:
+		signer = types.NewEIP2930Signer(tx.ChainId())
+	case types.DynamicFeeTxType:
+		signer = types.NewLondonSigner(tx.ChainId())
+	case types.BlobTxType:
+		signer = types.NewCancunSigner(tx.ChainId())
+	default:
+		signer = types.LatestSignerForChainID(tx.ChainId())
+	}
+
+	return types.Sender(signer, tx)
+}

tools/preconf-rpc/sim/inline_simulator_test.go

@@ -2,13 +2,15 @@ package sim_test
 
 import (
 	"context"
+	"encoding/hex"
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"strings"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/primev/mev-commit/tools/preconf-rpc/sim"
 )
 
@@ -255,6 +257,102 @@ var traceCallResponseBalancer = `{
 	]
 }`
 
+// Real mainnet transaction test vectors for e2e validation of parsing and sender recovery.
+var realTxVectors = []struct {
+	name           string
+	rawHex         string
+	expectedType   uint8
+	expectedSender string
+	hasChainID     bool
+}{
+	{
+		// Pre-EIP-155 legacy transaction (no chain ID replay protection)
+		// Block 46147 - early mainnet transaction
+		name:           "PreEIP155_Legacy",
+		rawHex:         "f86780862d79883d2000825208945df9b87991262f6ba471f09758cde1c0fc1de734827a69801ca088ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0a045e0aff800961cfce805daef7016f9ae479c0a24afba38dd33c2ecdbb01dcacf",
+		expectedType:   types.LegacyTxType,
+		expectedSender: "0xD3678D173368032b34E00AE057C31b083FBAb830",
+		hasChainID:     false,
+	},
+	{
+		// EIP-1559 dynamic fee transaction (type 2)
+		name:           "EIP1559_DynamicFee",
+		rawHex:         "02f8730101843b9aca00850c92a69c0082520894d8da6bf26964af9d7eed9e03e53415d37aa9604588016345785d8a000080c001a0a9f0aabbfa2b831dd37d0f8d48d941f35f4fd40a1f2e2fa74a7df3e60aa534c8a0488e799fae157d086b8e0b624ab63627f14509482fe037e88f516a3725070896",
+		expectedType:   types.DynamicFeeTxType,
+		expectedSender: "0xcEC000D467698070C6D8D73D8ff1F60FD7DCb531",
+		hasChainID:     true,
+	},
+}
+
+func TestTransactionParsingAndSenderRecovery(t *testing.T) {
+	for _, tc := range realTxVectors {
+		t.Run(tc.name, func(t *testing.T) {
+			rawBytes, err := hex.DecodeString(tc.rawHex)
+			if err != nil {
+				t.Fatalf("failed to decode hex: %v", err)
+			}
+
+			tx := new(types.Transaction)
+			if err := tx.UnmarshalBinary(rawBytes); err != nil {
+				t.Fatalf("failed to parse tx: %v", err)
+			}
+
+			if tx.Type() != tc.expectedType {
+				t.Errorf("expected tx type %d, got %d", tc.expectedType, tx.Type())
+			}
+
+			if tc.hasChainID {
+				if tx.ChainId().Sign() == 0 {
+					t.Error("expected non-zero chainId")
+				}
+			} else {
+				if tx.ChainId().Sign() != 0 {
+					t.Errorf("expected chainId 0, got %s", tx.ChainId().String())
+				}
+			}
+
+			sender, err := recoverSenderForTest(tx)
+			if err != nil {
+				t.Fatalf("failed to recover sender: %v", err)
+			}
+
+			if sender == (common.Address{}) {
+				t.Error("recovered zero address")
+			}
+
+			if tc.expectedSender != "" {
+				expected := common.HexToAddress(tc.expectedSender)
+				if sender != expected {
+					t.Errorf("sender mismatch: got %s, want %s", sender.Hex(), expected.Hex())
+				}
+			}
+
+			t.Logf("tx=%s sender=%s chainId=%s", tc.name, sender.Hex(), tx.ChainId().String())
+		})
+	}
+}
+
+func recoverSenderForTest(tx *types.Transaction) (common.Address, error) {
+	var signer types.Signer
+	switch tx.Type() {
+	case types.LegacyTxType:
+		if tx.ChainId().Sign() == 0 {
+			signer = types.HomesteadSigner{}
+		} else {
+			signer = types.NewEIP155Signer(tx.ChainId())
+		}
+	case types.AccessListTxType:
+		signer = types.NewEIP2930Signer(tx.ChainId())
+	case types.DynamicFeeTxType:
+		signer = types.NewLondonSigner(tx.ChainId())
+	case types.BlobTxType:
+		signer = types.NewCancunSigner(tx.ChainId())
+	default:
+		signer = types.LatestSignerForChainID(tx.ChainId())
+	}
+	return types.Sender(signer, tx)
+}
+
 func TestInlineSimulator(t *testing.T) {
 	// eth_simulateV1 responses
 	simV1Responses := map[string]string{