rpc sharding by tx sender for autobahn

docker/localnode/scripts/step1_configure_init.sh

@@ -33,12 +33,14 @@ cp docker/localnode/config/config.toml "$TENDERMINT_CONFIG_FILE"
 SEI_NODE_ID=$(seid tendermint show-node-id)
 NODE_IP=$(hostname -i | awk '{print $1}')
 P2P_PORT=26656  # Must match [p2p] laddr in config.toml
+EVMRPC_PORT=8545  # Must match the EVM RPC HTTP port (evmrpc DefaultConfig HTTPPort).
 echo "$SEI_NODE_ID@$NODE_IP:$P2P_PORT" >> build/generated/persistent_peers.txt
 
 # Store autobahn-compatible pubkeys and address for config generation
 cp ~/.sei/config/validator_pubkey.txt "$NODE_DIR/" || { echo "ERROR: failed to copy validator_pubkey.txt"; exit 1; }
 cp ~/.sei/config/node_pubkey.txt "$NODE_DIR/" || { echo "ERROR: failed to copy node_pubkey.txt"; exit 1; }
 echo "$NODE_IP:$P2P_PORT" > "$NODE_DIR/autobahn_address.txt"
+echo "http://$NODE_IP:$EVMRPC_PORT" > "$NODE_DIR/evmrpc_url.txt"
 
 # Create a new account
 ACCOUNT_NAME="node_admin"

evmrpc/block_txcount_parity_test.go

@@ -3,6 +3,7 @@ package evmrpc_test
 import (
 	"context"
 	"fmt"
+	"net/url"
 	"sync"
 	"testing"
 	"time"
@@ -37,6 +38,10 @@ func (*parityTxCountTMClient) EvmNextPendingNonce(common.Address) uint64 {
 	return 0
 }
 
+func (*parityTxCountTMClient) EvmProxy(common.Address) (*url.URL, bool) {
+	return nil, false
+}
+
 func (c *parityTxCountTMClient) Block(_ context.Context, h *int64) (*coretypes.ResultBlock, error) {
 	if h != nil && *h == parityTestHeight {
 		return c.block, nil

evmrpc/height_availability_test.go

@@ -3,6 +3,7 @@ package evmrpc
 import (
 	"context"
 	"encoding/hex"
+	"net/url"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -33,6 +34,10 @@ func (*heightTestClient) EvmNextPendingNonce(common.Address) uint64 {
 	return 0
 }
 
+func (*heightTestClient) EvmProxy(common.Address) (*url.URL, bool) {
+	return nil, false
+}
+
 func newHeightTestClient(highHeight, earliest, latest int64) *heightTestClient {
 	return &heightTestClient{
 		Client:   mock.Client{},

evmrpc/metrics.go

@@ -40,8 +40,9 @@ var (
 	rpcTelemetryMeter = otel.Meter("evmrpc")
 
 	metrics = struct {
-		requestLatencySeconds metric.Float64Histogram
-		wsConnectionCount     metric.Int64Counter
+		requestLatencySeconds  metric.Float64Histogram
+		wsConnectionCount      metric.Int64Counter
+		redirectedRequestCount metric.Int64Counter
 	}{
 		requestLatencySeconds: must(rpcTelemetryMeter.Float64Histogram(
 			"evmrpc_request_latency_seconds",
@@ -57,6 +58,11 @@ var (
 			metric.WithDescription("Number of new websocket connections"),
 			metric.WithUnit("{count}"),
 		)),
+		redirectedRequestCount: must(rpcTelemetryMeter.Int64Counter(
+			"evmrpc_redirected_requests_total",
+			metric.WithDescription("Number of EVM RPC requests redirected to another validator"),
+			metric.WithUnit("{count}"),
+		)),
 	}
 )
 
@@ -125,3 +131,12 @@ func recordRPCLatency(ctx context.Context, endpoint, connection string, success
 func recordWebsocketConnect(ctx context.Context) {
 	metrics.wsConnectionCount.Add(ctx, 1)
 }
+
+func recordRedirectedRequest(ctx context.Context, endpoint, connection string) {
+	metrics.redirectedRequestCount.Add(ctx, 1,
+		metric.WithAttributes(
+			attribute.String(endpointKey, endpoint),
+			attribute.String(connectionKey, connection),
+		),
+	)
+}

evmrpc/metrics_test.go

@@ -14,6 +14,7 @@ func TestRecordRPCMetricsNoPanic(t *testing.T) {
 	endpoint := "eth_smoke_" + t.Name()
 	recordRPCLatency(ctx, endpoint, "http", true, nil, false, time.Now().Add(-2*time.Millisecond))
 	recordWebsocketConnect(ctx)
+	recordRedirectedRequest(ctx, endpoint, "http")
 }
 
 func TestClassifyRPCMetricError(t *testing.T) {

evmrpc/send.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"math/big"
 	"sync"
 	"time"
 
@@ -77,25 +78,46 @@ func (s *SendAPI) SendRawTransaction(ctx context.Context, input hexutil.Bytes) (
 		return
 	}
 	hash = tx.Hash()
-	var txData ethtx.TxData
-	txData, err = ethtx.NewTxDataFromTx(tx)
-	if err != nil {
-		return
+	// getSender fails for AccessListTx, in which case we are not able to proxy or simulate,
+	// but we still need to handle it.
+	sender, senderErr := getSender(tx, s.keeper.ChainID(s.ctxProvider(LatestCtxHeight)))
+	if senderErr == nil {
+		if url, ok := s.tmClient.EvmProxy(sender); ok {
+			recordRedirectedRequest(ctx, "eth_sendRawTransaction", string(s.connectionType))
+			// HTTP transport pooling already happens globally underneath net/http, so
+			// creating a fresh RPC client per proxied request is fine here. If we
+			// start proxying over WebSocket, we'll need explicit custom pooling since
+			// the underlying TCP connection lifecycle is strictly bound to Dial -> Close calls.
+			client, err := rpc.DialContext(ctx, url.String())
+			if err != nil {
+				return hash, fmt.Errorf("rpc.DialContext(%q): %w", url.String(), err)
+			}
+			defer client.Close()
+
+			if err := client.CallContext(ctx, &hash, "eth_sendRawTransaction", input); err != nil {
+				return hash, fmt.Errorf("eth_sendRawTransaction(%q): %w", url.String(), err)
+			}
+			return hash, nil
+		}
 	}
-	var msg *types.MsgEVMTransaction
-	msg, err = types.NewMsgEVMTransaction(txData)
+
+	txData, err := ethtx.NewTxDataFromTx(tx)
 	if err != nil {
-		return
+		return hash, err
 	}
-	var gasUsedEstimate uint64
-	gasUsedEstimate, err = s.simulateTx(ctx, tx)
+	msg, err := types.NewMsgEVMTransaction(txData)
 	if err != nil {
-		tx, _ = msg.AsTransaction()
-		gasUsedEstimate = tx.Gas() // if issue simulating, fallback to gas limit
+		return hash, err
+	}
+	gasUsedEstimate := tx.Gas() // if issue simulating, fallback to gas limit
+	if senderErr == nil {       // simulation requires sender.
+		if gas, err := s.simulateTx(ctx, sender, tx); err == nil {
+			gasUsedEstimate = gas
+		}
 	}
 	txBuilder := s.txConfigProvider(LatestCtxHeight).NewTxBuilder()
-	if err = txBuilder.SetMsgs(msg); err != nil {
-		return
+	if err := txBuilder.SetMsgs(msg); err != nil {
+		return hash, err
 	}
 	txBuilder.SetGasEstimate(gasUsedEstimate)
 	txbz, encodeErr := s.txConfigProvider(LatestCtxHeight).TxEncoder()(txBuilder.GetTx())
@@ -125,30 +147,30 @@ func (s *SendAPI) SendRawTransaction(ctx context.Context, input hexutil.Bytes) (
 	return
 }
 
-func (s *SendAPI) simulateTx(ctx context.Context, tx *ethtypes.Transaction) (estimate uint64, err error) {
-	var from common.Address
-	if tx.Type() == ethtypes.DynamicFeeTxType {
-		signer := ethtypes.NewLondonSigner(s.keeper.ChainID(s.ctxProvider(LatestCtxHeight)))
-		from, err = signer.Sender(tx)
+func getSender(tx *ethtypes.Transaction, chainID *big.Int) (common.Address, error) {
+	switch {
+	case tx.Type() == ethtypes.DynamicFeeTxType:
+		from, err := ethtypes.NewLondonSigner(chainID).Sender(tx)
 		if err != nil {
-			err = fmt.Errorf("failed to get sender for dynamic fee tx: %w", err)
-			return
+			return common.Address{}, fmt.Errorf("failed to get sender for dynamic fee tx: %w", err)
 		}
-	} else if tx.Protected() {
-		signer := ethtypes.NewEIP155Signer(s.keeper.ChainID(s.ctxProvider(LatestCtxHeight)))
-		from, err = signer.Sender(tx)
+		return from, nil
+	case tx.Protected():
+		from, err := ethtypes.NewEIP155Signer(chainID).Sender(tx)
 		if err != nil {
-			err = fmt.Errorf("failed to get sender for protected tx: %w", err)
-			return
+			return common.Address{}, fmt.Errorf("failed to get sender for protected tx: %w", err)
 		}
-	} else {
-		signer := ethtypes.HomesteadSigner{}
-		from, err = signer.Sender(tx)
+		return from, nil
+	default:
+		from, err := ethtypes.HomesteadSigner{}.Sender(tx)
 		if err != nil {
-			err = fmt.Errorf("failed to get sender for homestead tx: %w", err)
-			return
+			return common.Address{}, fmt.Errorf("failed to get sender for homestead tx: %w", err)
 		}
+		return from, nil
 	}
+}
+
+func (s *SendAPI) simulateTx(ctx context.Context, sender common.Address, tx *ethtypes.Transaction) (estimate uint64, err error) {
 	input_ := (hexutil.Bytes)(tx.Data())
 	gas_ := hexutil.Uint64(tx.Gas())
 	nonce_ := hexutil.Uint64(tx.Nonce())
@@ -165,7 +187,7 @@ func (s *SendAPI) simulateTx(ctx context.Context, tx *ethtypes.Transaction) (est
 		gp = nil
 	}
 	txArgs := export.TransactionArgs{
-		From:                 &from,
+		From:                 &sender,
 		To:                   tx.To(),
 		Gas:                  &gas_,
 		GasPrice:             (*hexutil.Big)(gp),

evmrpc/send_test.go

@@ -1,19 +1,40 @@
 package evmrpc_test
 
 import (
+	"context"
 	"encoding/hex"
+	"encoding/json"
 	"math/big"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
+	legacyabci "github.com/sei-protocol/sei-chain/app/legacyabci"
+	"github.com/sei-protocol/sei-chain/evmrpc"
+	"github.com/sei-protocol/sei-chain/sei-cosmos/client"
 	"github.com/sei-protocol/sei-chain/sei-cosmos/crypto/hd"
 	sdk "github.com/sei-protocol/sei-chain/sei-cosmos/types"
 	"github.com/sei-protocol/sei-chain/x/evm/types"
 	"github.com/stretchr/testify/require"
 )
 
+type sendProxyClient struct {
+	*MockClient
+	proxyURL *url.URL
+}
+
+func (c *sendProxyClient) EvmProxy(common.Address) (*url.URL, bool) {
+	if c.proxyURL == nil {
+		return nil, false
+	}
+	return c.proxyURL, true
+}
+
 func TestMnemonicToPrivateKey(t *testing.T) {
 	mnemonic := "mushroom lamp kingdom obscure sun advice puzzle ancient crystal service beef have zone true chimney act situate laundry guess vacuum razor virus wink enforce"
 	hdp := hd.CreateHDPath(sdk.GetConfig().GetCoinType(), 0, 0).String()
@@ -63,3 +84,67 @@ func TestSendRawTransaction(t *testing.T) {
 	errMap = resObj["error"].(map[string]interface{})
 	require.Equal(t, ": invalid sequence", errMap["message"].(string))
 }
+
+func TestSendRawTransactionUsesProxy(t *testing.T) {
+	to := common.HexToAddress("010203")
+	_, tx := buildTx(ethtypes.DynamicFeeTx{
+		Nonce:     1,
+		GasFeeCap: big.NewInt(10),
+		Gas:       1000,
+		To:        &to,
+		Value:     big.NewInt(1000),
+		Data:      []byte("abc"),
+		ChainID:   EVMKeeper.ChainID(Ctx),
+	})
+	ethTxBytes, err := tx.MarshalBinary()
+	require.NoError(t, err)
+
+	var gotMethod string
+	var gotPayload string
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		defer r.Body.Close()
+
+		var req struct {
+			Method string            `json:"method"`
+			Params []json.RawMessage `json:"params"`
+		}
+		require.NoError(t, json.NewDecoder(r.Body).Decode(&req))
+		require.Len(t, req.Params, 1)
+		gotMethod = req.Method
+		require.NoError(t, json.Unmarshal(req.Params[0], &gotPayload))
+
+		w.Header().Set("Content-Type", "application/json")
+		require.NoError(t, json.NewEncoder(w).Encode(map[string]any{
+			"jsonrpc": "2.0",
+			"id":      1,
+			"result":  tx.Hash().Hex(),
+		}))
+	}))
+	defer server.Close()
+
+	proxyURL, err := url.Parse(server.URL)
+	require.NoError(t, err)
+
+	sendAPI := evmrpc.NewSendAPI(
+		&sendProxyClient{MockClient: &MockClient{}, proxyURL: proxyURL},
+		func(int64) client.TxConfig { return TxConfig },
+		&evmrpc.SendConfig{},
+		EVMKeeper,
+		legacyabci.BeginBlockKeepers{},
+		func(int64) sdk.Context { return Ctx },
+		"",
+		nil,
+		nil,
+		nil,
+		evmrpc.ConnectionTypeHTTP,
+		evmrpc.NewBlockCache(1),
+		nil,
+		nil,
+	)
+
+	hash, err := sendAPI.SendRawTransaction(context.Background(), hexutil.Bytes(ethTxBytes))
+	require.NoError(t, err)
+	require.Equal(t, tx.Hash(), hash)
+	require.Equal(t, "eth_sendRawTransaction", gotMethod)
+	require.Equal(t, hexutil.Encode(ethTxBytes), gotPayload)
+}

evmrpc/setup_test.go

@@ -12,6 +12,7 @@ import (
 	"math/big"
 	"net"
 	"net/http"
+	"net/url"
 	"strconv"
 	"strings"
 	"testing"
@@ -123,6 +124,10 @@ func (*MockClient) EvmNextPendingNonce(common.Address) uint64 {
 	return 0
 }
 
+func (*MockClient) EvmProxy(common.Address) (*url.URL, bool) {
+	return nil, false
+}
+
 func NewMockClientWithLatest(latest int64) *MockClient {
 	return &MockClient{latestOverride: latest}
 }

evmrpc/simulate_test.go

@@ -5,6 +5,7 @@ import (
 	"encoding/hex"
 	"fmt"
 	"math/big"
+	"net/url"
 	"os"
 	"strings"
 	"sync"
@@ -871,6 +872,10 @@ func (c *fixedBlockClient) EvmNextPendingNonce(common.Address) uint64 {
 	return 0
 }
 
+func (c *fixedBlockClient) EvmProxy(common.Address) (*url.URL, bool) {
+	return nil, false
+}
+
 func (c *fixedBlockClient) Block(_ context.Context, _ *int64) (*coretypes.ResultBlock, error) {
 	return c.block, nil
 }

evmrpc/tests/mock_client.go

@@ -7,6 +7,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"net/url"
 	"strconv"
 	"strings"
 	"time"
@@ -40,6 +41,10 @@ func (c *MockClient) EvmNextPendingNonce(_ common.Address) uint64 {
 	return 0
 }
 
+func (c *MockClient) EvmProxy(common.Address) (*url.URL, bool) {
+	return nil, false
+}
+
 func (c *MockClient) Block(_ context.Context, h *int64) (*coretypes.ResultBlock, error) {
 	if c.mockedBlockResults != nil {
 		blockNum := int64(-1)