diff --git a/README.md b/README.md index 639286ba9f..527362896d 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,31 @@ +## Mandarin + +A Geth for optimized so that + +1. New txs + new blocks hit your bots in microseconds, not milliseconds+JSON. + +2. Bots can read/write “intent” (orders, bundles, replacement txs) via shared memory / low-overhead IPC instead of JSON-RPC. + +3. You control transaction ordering inside blocks you build or simulate. + +## Mandarin + +Mandarin is a performance-optimized fork of Go Ethereum designed for low-latency trading operations and MEV workflows. Built on Geth's solid foundation, Mandarin adds specialized features for co-located trading engines while maintaining full compatibility with the Ethereum protocol. + +### Key Enhancements + +**Bundle Support:** Submit and simulate transaction bundles with microsecond-scale latency. Bundles support timestamp constraints, revertible transactions, and profit simulation. + +**Custom Transaction Ordering:** Pluggable ordering strategies allow sophisticated block building beyond simple gas price sorting. + +**Low-Latency APIs:** Binary gRPC endpoints alongside traditional JSON-RPC for 10x faster operations including batch storage reads and bundle simulation. + +**Backward Compatible:** All Geth features remain unchanged. Enhancements are opt-in and don't affect standard node operation. + +See `PHASE1_SUMMARY.md` for detailed implementation notes and `roadmap.md` for future development plans. + +--- + ## Go Ethereum Golang execution layer implementation of the Ethereum protocol. diff --git a/api/grpc/server.go b/api/grpc/server.go new file mode 100644 index 0000000000..a137eae8c6 --- /dev/null +++ b/api/grpc/server.go @@ -0,0 +1,339 @@ +// Copyright 2024 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package grpc + +import ( + "context" + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/eth" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/miner" + "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/rpc" + "github.com/holiman/uint256" +) + +// Backend defines the interface for accessing blockchain data. +type Backend interface { + BlockChain() *core.BlockChain + TxPool() *core.TxPool + Miner() *miner.Miner + ChainConfig() *params.ChainConfig + CurrentHeader() *types.Header + StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) + RPCGasCap() uint64 +} + +// TraderServer implements the gRPC trader service. +type TraderServer struct { + backend Backend + config *params.ChainConfig +} + +// NewTraderServer creates a new gRPC trader server. +func NewTraderServer(eth *eth.Ethereum) *TraderServer { + return &TraderServer{ + backend: eth, + config: eth.BlockChain().Config(), + } +} + +// SimulateBundle simulates a bundle and returns detailed results. +func (s *TraderServer) SimulateBundle(ctx context.Context, req *SimulateBundleRequest) (*SimulateBundleResponse, error) { + if len(req.Transactions) == 0 { + return nil, errors.New("bundle must contain at least one transaction") + } + + // Decode transactions + txs := make([]*types.Transaction, len(req.Transactions)) + for i, encodedTx := range req.Transactions { + var tx types.Transaction + if err := tx.UnmarshalBinary(encodedTx); err != nil { + return nil, err + } + txs[i] = &tx + } + + // Create bundle + bundle := &miner.Bundle{ + Txs: txs, + RevertingTxs: make([]int, len(req.RevertingTxs)), + } + + for i, idx := range req.RevertingTxs { + bundle.RevertingTxs[i] = int(idx) + } + + if req.MinTimestamp != nil { + bundle.MinTimestamp = *req.MinTimestamp + } + if req.MaxTimestamp != nil { + bundle.MaxTimestamp = *req.MaxTimestamp + } + + // Get simulation header + currentHeader := s.backend.CurrentHeader() + simHeader := &types.Header{ + ParentHash: currentHeader.Hash(), + Number: new(big.Int).Add(currentHeader.Number, big.NewInt(1)), + GasLimit: currentHeader.GasLimit, + Time: currentHeader.Time + 12, + BaseFee: currentHeader.BaseFee, + } + + // Simulate + result, err := s.backend.Miner().SimulateBundle(bundle, simHeader) + if err != nil { + return nil, err + } + + // Convert to protobuf response + response := &SimulateBundleResponse{ + Success: result.Success, + GasUsed: result.GasUsed, + Profit: result.Profit.Bytes(), + CoinbaseBalance: result.CoinbaseBalance.Bytes(), + FailedTxIndex: int32(result.FailedTxIndex), + TxResults: make([]*TxSimulationResult, len(result.TxResults)), + } + + if result.FailedTxError != nil { + response.FailedTxError = result.FailedTxError.Error() + } + + for i, txResult := range result.TxResults { + pbResult := &TxSimulationResult{ + Success: txResult.Success, + GasUsed: txResult.GasUsed, + } + if txResult.Error != nil { + pbResult.Error = txResult.Error.Error() + } + if txResult.ReturnValue != nil { + pbResult.ReturnValue = txResult.ReturnValue + } + response.TxResults[i] = pbResult + } + + return response, nil +} + +// SubmitBundle submits a bundle for inclusion in future blocks. +func (s *TraderServer) SubmitBundle(ctx context.Context, req *SubmitBundleRequest) (*SubmitBundleResponse, error) { + if len(req.Transactions) == 0 { + return nil, errors.New("bundle must contain at least one transaction") + } + + // Decode transactions + txs := make([]*types.Transaction, len(req.Transactions)) + for i, encodedTx := range req.Transactions { + var tx types.Transaction + if err := tx.UnmarshalBinary(encodedTx); err != nil { + return nil, err + } + txs[i] = &tx + } + + // Create bundle + bundle := &miner.Bundle{ + Txs: txs, + RevertingTxs: make([]int, len(req.RevertingTxs)), + } + + for i, idx := range req.RevertingTxs { + bundle.RevertingTxs[i] = int(idx) + } + + if req.MinTimestamp != nil { + bundle.MinTimestamp = *req.MinTimestamp + } + if req.MaxTimestamp != nil { + bundle.MaxTimestamp = *req.MaxTimestamp + } + if req.TargetBlock != nil { + bundle.TargetBlock = *req.TargetBlock + } + + // Add bundle + if err := s.backend.Miner().AddBundle(bundle); err != nil { + return nil, err + } + + return &SubmitBundleResponse{ + BundleHash: txs[0].Hash().Bytes(), + }, nil +} + +// GetStorageBatch retrieves multiple storage slots efficiently. +func (s *TraderServer) GetStorageBatch(ctx context.Context, req *GetStorageBatchRequest) (*GetStorageBatchResponse, error) { + if len(req.Contract) != 20 { + return nil, errors.New("invalid contract address") + } + + contract := common.BytesToAddress(req.Contract) + blockNr := rpc.LatestBlockNumber + if req.BlockNumber != nil { + blockNr = rpc.BlockNumber(*req.BlockNumber) + } + + // Get state + stateDB, _, err := s.backend.StateAndHeaderByNumber(ctx, blockNr) + if err != nil { + return nil, err + } + + // Batch read storage + values := make([][]byte, len(req.Slots)) + for i, slotBytes := range req.Slots { + if len(slotBytes) != 32 { + return nil, errors.New("invalid slot size") + } + slot := common.BytesToHash(slotBytes) + value := stateDB.GetState(contract, slot) + values[i] = value.Bytes() + } + + return &GetStorageBatchResponse{ + Values: values, + }, nil +} + +// GetPendingTransactions returns pending transactions. +func (s *TraderServer) GetPendingTransactions(ctx context.Context, req *GetPendingTransactionsRequest) (*GetPendingTransactionsResponse, error) { + // Get pending from txpool + pending := s.backend.TxPool().Pending(core.PendingFilter{}) + + var txs [][]byte + for _, accountTxs := range pending { + for _, ltx := range accountTxs { + tx := ltx.Resolve() + if tx == nil { + continue + } + + // Filter by min gas price if specified + if req.MinGasPrice != nil { + gasPrice := tx.GasPrice() + if tx.Type() == types.DynamicFeeTxType { + gasPrice = tx.GasFeeCap() + } + if gasPrice.Cmp(new(big.Int).SetUint64(*req.MinGasPrice)) < 0 { + continue + } + } + + encoded, err := tx.MarshalBinary() + if err != nil { + log.Warn("Failed to encode transaction", "hash", tx.Hash(), "err", err) + continue + } + txs = append(txs, encoded) + } + } + + return &GetPendingTransactionsResponse{ + Transactions: txs, + }, nil +} + +// CallContract executes a contract call. +func (s *TraderServer) CallContract(ctx context.Context, req *CallContractRequest) (*CallContractResponse, error) { + if len(req.To) != 20 { + return nil, errors.New("invalid contract address") + } + + blockNr := rpc.LatestBlockNumber + if req.BlockNumber != nil { + blockNr = rpc.BlockNumber(*req.BlockNumber) + } + + stateDB, header, err := s.backend.StateAndHeaderByNumber(ctx, blockNr) + if err != nil { + return nil, err + } + + // Prepare message + from := common.Address{} + if len(req.From) == 20 { + from = common.BytesToAddress(req.From) + } + to := common.BytesToAddress(req.To) + + gas := s.backend.RPCGasCap() + if req.Gas != nil && *req.Gas > 0 { + gas = *req.Gas + } + + gasPrice := new(big.Int) + if req.GasPrice != nil { + gasPrice = new(big.Int).SetUint64(*req.GasPrice) + } else if header.BaseFee != nil { + gasPrice = header.BaseFee + } + + value := new(big.Int) + if req.Value != nil { + value = new(big.Int).SetBytes(req.Value) + } + + msg := &core.Message{ + From: from, + To: &to, + Value: value, + GasLimit: gas, + GasPrice: gasPrice, + GasFeeCap: gasPrice, + GasTipCap: gasPrice, + Data: req.Data, + SkipAccountChecks: true, + } + + // Create EVM + blockContext := core.NewEVMBlockContext(header, s.backend.BlockChain(), nil) + txContext := core.NewEVMTxContext(msg) + evm := vm.NewEVM(blockContext, txContext, stateDB, s.config, vm.Config{}) + + // Execute + result, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(gas)) + if err != nil { + return &CallContractResponse{ + Success: false, + Error: err.Error(), + }, nil + } + + response := &CallContractResponse{ + ReturnData: result.ReturnData, + GasUsed: result.UsedGas, + Success: !result.Failed(), + } + + if result.Failed() { + response.Error = result.Err.Error() + } + + return response, nil +} + diff --git a/api/grpc/trader.proto b/api/grpc/trader.proto new file mode 100644 index 0000000000..3e830b9954 --- /dev/null +++ b/api/grpc/trader.proto @@ -0,0 +1,96 @@ +syntax = "proto3"; + +package grpc; + +option go_package = "github.com/ethereum/go-ethereum/api/grpc"; + +// TraderService provides low-latency APIs for trading operations. +service TraderService { + // SimulateBundle simulates bundle execution and returns results + rpc SimulateBundle(SimulateBundleRequest) returns (SimulateBundleResponse); + + // SubmitBundle submits a bundle for inclusion in future blocks + rpc SubmitBundle(SubmitBundleRequest) returns (SubmitBundleResponse); + + // GetStorageBatch retrieves multiple storage slots in a single call + rpc GetStorageBatch(GetStorageBatchRequest) returns (GetStorageBatchResponse); + + // GetPendingTransactions returns currently pending transactions + rpc GetPendingTransactions(GetPendingTransactionsRequest) returns (GetPendingTransactionsResponse); + + // CallContract executes a contract call + rpc CallContract(CallContractRequest) returns (CallContractResponse); +} + +message SimulateBundleRequest { + repeated bytes transactions = 1; + optional uint64 min_timestamp = 2; + optional uint64 max_timestamp = 3; + repeated int32 reverting_txs = 4; + optional uint64 target_block = 5; +} + +message SimulateBundleResponse { + bool success = 1; + uint64 gas_used = 2; + bytes profit = 3; + bytes coinbase_balance = 4; + int32 failed_tx_index = 5; + string failed_tx_error = 6; + repeated TxSimulationResult tx_results = 7; +} + +message TxSimulationResult { + bool success = 1; + uint64 gas_used = 2; + string error = 3; + bytes return_value = 4; +} + +message SubmitBundleRequest { + repeated bytes transactions = 1; + optional uint64 min_timestamp = 2; + optional uint64 max_timestamp = 3; + repeated int32 reverting_txs = 4; + optional uint64 target_block = 5; +} + +message SubmitBundleResponse { + bytes bundle_hash = 1; +} + +message GetStorageBatchRequest { + bytes contract = 1; + repeated bytes slots = 2; + optional uint64 block_number = 3; +} + +message GetStorageBatchResponse { + repeated bytes values = 1; +} + +message GetPendingTransactionsRequest { + optional uint64 min_gas_price = 1; +} + +message GetPendingTransactionsResponse { + repeated bytes transactions = 1; +} + +message CallContractRequest { + bytes from = 1; + bytes to = 2; + bytes data = 3; + optional uint64 gas = 4; + optional uint64 gas_price = 5; + optional bytes value = 6; + optional uint64 block_number = 7; +} + +message CallContractResponse { + bytes return_data = 1; + uint64 gas_used = 2; + bool success = 3; + string error = 4; +} + diff --git a/benchmarks/README.md b/benchmarks/README.md new file mode 100644 index 0000000000..8b13789179 --- /dev/null +++ b/benchmarks/README.md @@ -0,0 +1 @@ + diff --git a/miner/api.go b/miner/api.go new file mode 100644 index 0000000000..c1202fd4de --- /dev/null +++ b/miner/api.go @@ -0,0 +1,197 @@ +// Copyright 2024 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package miner + +import ( + "context" + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core/types" +) + +// API exposes miner-related methods for the RPC interface. +type API struct { + miner *Miner +} + +// NewAPI creates a new API instance. +func NewAPI(miner *Miner) *API { + return &API{miner: miner} +} + +// BundleArgs represents arguments for bundle submission. +type BundleArgs struct { + Txs []hexutil.Bytes `json:"txs"` + MinTimestamp *hexutil.Uint64 `json:"minTimestamp,omitempty"` + MaxTimestamp *hexutil.Uint64 `json:"maxTimestamp,omitempty"` + RevertingTxs []int `json:"revertingTxs,omitempty"` + TargetBlock *hexutil.Uint64 `json:"targetBlock,omitempty"` +} + +// BundleSimulationResponse represents the result of a bundle simulation. +type BundleSimulationResponse struct { + Success bool `json:"success"` + GasUsed hexutil.Uint64 `json:"gasUsed"` + Profit *hexutil.Big `json:"profit"` + CoinbaseBalance *hexutil.Big `json:"coinbaseBalance"` + FailedTxIndex int `json:"failedTxIndex,omitempty"` + FailedTxError string `json:"failedTxError,omitempty"` + TxResults []TxSimulationResponse `json:"txResults"` +} + +// TxSimulationResponse represents the result of a transaction simulation. +type TxSimulationResponse struct { + Success bool `json:"success"` + GasUsed hexutil.Uint64 `json:"gasUsed"` + Error string `json:"error,omitempty"` + ReturnValue hexutil.Bytes `json:"returnValue,omitempty"` +} + +// SubmitBundle submits a bundle for inclusion in future blocks. +func (api *API) SubmitBundle(ctx context.Context, args BundleArgs) (common.Hash, error) { + if len(args.Txs) == 0 { + return common.Hash{}, errors.New("bundle must contain at least one transaction") + } + + // Decode transactions + txs := make([]*types.Transaction, len(args.Txs)) + for i, encodedTx := range args.Txs { + var tx types.Transaction + if err := tx.UnmarshalBinary(encodedTx); err != nil { + return common.Hash{}, err + } + txs[i] = &tx + } + + // Create bundle + bundle := &Bundle{ + Txs: txs, + RevertingTxs: args.RevertingTxs, + } + + if args.MinTimestamp != nil { + bundle.MinTimestamp = uint64(*args.MinTimestamp) + } + if args.MaxTimestamp != nil { + bundle.MaxTimestamp = uint64(*args.MaxTimestamp) + } + if args.TargetBlock != nil { + bundle.TargetBlock = uint64(*args.TargetBlock) + } + + // Add bundle + if err := api.miner.AddBundle(bundle); err != nil { + return common.Hash{}, err + } + + // Return hash of first transaction as bundle ID + return txs[0].Hash(), nil +} + +// SimulateBundle simulates a bundle and returns the result. +func (api *API) SimulateBundle(ctx context.Context, args BundleArgs) (*BundleSimulationResponse, error) { + if len(args.Txs) == 0 { + return nil, errors.New("bundle must contain at least one transaction") + } + + // Decode transactions + txs := make([]*types.Transaction, len(args.Txs)) + for i, encodedTx := range args.Txs { + var tx types.Transaction + if err := tx.UnmarshalBinary(encodedTx); err != nil { + return nil, err + } + txs[i] = &tx + } + + // Create bundle + bundle := &Bundle{ + Txs: txs, + RevertingTxs: args.RevertingTxs, + } + + if args.MinTimestamp != nil { + bundle.MinTimestamp = uint64(*args.MinTimestamp) + } + if args.MaxTimestamp != nil { + bundle.MaxTimestamp = uint64(*args.MaxTimestamp) + } + + // Get current header for simulation + header := api.miner.chain.CurrentHeader() + + // Create simulation header based on current + 1 + simHeader := &types.Header{ + ParentHash: header.Hash(), + Number: new(big.Int).Add(header.Number, big.NewInt(1)), + GasLimit: header.GasLimit, + Time: header.Time + 12, // Assume 12 second block time + BaseFee: header.BaseFee, + } + + // Simulate bundle + result, err := api.miner.SimulateBundle(bundle, simHeader) + if err != nil { + return nil, err + } + + // Convert result to response + response := &BundleSimulationResponse{ + Success: result.Success, + GasUsed: hexutil.Uint64(result.GasUsed), + Profit: (*hexutil.Big)(result.Profit), + CoinbaseBalance: (*hexutil.Big)(result.CoinbaseBalance), + FailedTxIndex: result.FailedTxIndex, + TxResults: make([]TxSimulationResponse, len(result.TxResults)), + } + + if result.FailedTxError != nil { + response.FailedTxError = result.FailedTxError.Error() + } + + for i, txResult := range result.TxResults { + txResp := TxSimulationResponse{ + Success: txResult.Success, + GasUsed: hexutil.Uint64(txResult.GasUsed), + } + if txResult.Error != nil { + txResp.Error = txResult.Error.Error() + } + if txResult.ReturnValue != nil { + txResp.ReturnValue = txResult.ReturnValue + } + response.TxResults[i] = txResp + } + + return response, nil +} + +// GetBundles returns currently pending bundles for a specific block number. +func (api *API) GetBundles(ctx context.Context, blockNumber hexutil.Uint64) (int, error) { + bundles := api.miner.GetBundles(uint64(blockNumber)) + return len(bundles), nil +} + +// ClearExpiredBundles removes bundles that are expired for the given block number. +func (api *API) ClearExpiredBundles(ctx context.Context, blockNumber hexutil.Uint64) error { + api.miner.ClearExpiredBundles(uint64(blockNumber)) + return nil +} + diff --git a/miner/bundle.go b/miner/bundle.go new file mode 100644 index 0000000000..49054f3b88 --- /dev/null +++ b/miner/bundle.go @@ -0,0 +1,141 @@ +// Copyright 2024 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package miner + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/txpool" + "github.com/ethereum/go-ethereum/core/types" +) + +var ( + ErrBundleTimestampTooEarly = errors.New("bundle timestamp too early") + ErrBundleTimestampTooLate = errors.New("bundle timestamp too late") + ErrBundleReverted = errors.New("bundle transaction reverted") +) + +// Bundle represents a group of transactions that should be executed atomically +// in a specific order within a block. +type Bundle struct { + Txs []*types.Transaction + MinTimestamp uint64 + MaxTimestamp uint64 + RevertingTxs []int // Indices of transactions allowed to revert + TargetBlock uint64 +} + +// ValidateTimestamp checks if the bundle can be included at the given timestamp. +func (b *Bundle) ValidateTimestamp(timestamp uint64) error { + if b.MinTimestamp > 0 && timestamp < b.MinTimestamp { + return ErrBundleTimestampTooEarly + } + if b.MaxTimestamp > 0 && timestamp > b.MaxTimestamp { + return ErrBundleTimestampTooLate + } + return nil +} + +// CanRevert returns true if the transaction at the given index is allowed to revert. +func (b *Bundle) CanRevert(txIndex int) bool { + for _, idx := range b.RevertingTxs { + if idx == txIndex { + return true + } + } + return false +} + +// BundleSimulationResult contains the results of simulating a bundle. +type BundleSimulationResult struct { + Success bool + GasUsed uint64 + Profit *big.Int + StateChanges map[common.Address]*AccountChange + FailedTxIndex int // -1 if all succeeded + FailedTxError error + CoinbaseBalance *big.Int + TxResults []*TxSimulationResult +} + +// TxSimulationResult contains results for a single transaction in a bundle. +type TxSimulationResult struct { + Success bool + GasUsed uint64 + Error error + Logs []*types.Log + ReturnValue []byte +} + +// AccountChange represents state changes for an account. +type AccountChange struct { + BalanceBefore *big.Int + BalanceAfter *big.Int + NonceBefore uint64 + NonceAfter uint64 + StorageChanges map[common.Hash]common.Hash +} + +// OrderingStrategy defines an interface for custom transaction ordering. +// Implementations can provide arbitrary ordering logic for block building. +type OrderingStrategy interface { + // OrderTransactions takes pending transactions and bundles, and returns + // an ordered list of transactions to include in the block. + OrderTransactions( + pending map[common.Address][]*txpool.LazyTransaction, + bundles []*Bundle, + state *state.StateDB, + header *types.Header, + ) ([]*types.Transaction, error) +} + +// DefaultOrderingStrategy implements the default greedy ordering by gas price. +type DefaultOrderingStrategy struct{} + +// OrderTransactions implements the default ordering strategy. +func (s *DefaultOrderingStrategy) OrderTransactions( + pending map[common.Address][]*txpool.LazyTransaction, + bundles []*Bundle, + state *state.StateDB, + header *types.Header, +) ([]*types.Transaction, error) { + // Default behavior: just return transactions sorted by price + // This maintains backward compatibility + var txs []*types.Transaction + + // First, add bundle transactions + for _, bundle := range bundles { + if err := bundle.ValidateTimestamp(header.Time); err == nil { + txs = append(txs, bundle.Txs...) + } + } + + // Then add pending transactions (would normally use price sorting) + for _, accountTxs := range pending { + for _, ltx := range accountTxs { + if tx := ltx.Resolve(); tx != nil { + txs = append(txs, tx) + } + } + } + + return txs, nil +} + diff --git a/miner/bundle_test.go b/miner/bundle_test.go new file mode 100644 index 0000000000..54a68a3254 --- /dev/null +++ b/miner/bundle_test.go @@ -0,0 +1,122 @@ +// Copyright 2024 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package miner + +import ( + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/txpool" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/params" +) + +func TestBundleValidation(t *testing.T) { + bundle := &Bundle{ + Txs: []*types.Transaction{}, + MinTimestamp: 100, + MaxTimestamp: 200, + TargetBlock: 1000, + } + + // Test timestamp validation + if err := bundle.ValidateTimestamp(50); err != ErrBundleTimestampTooEarly { + t.Errorf("Expected ErrBundleTimestampTooEarly, got %v", err) + } + + if err := bundle.ValidateTimestamp(150); err != nil { + t.Errorf("Expected no error for valid timestamp, got %v", err) + } + + if err := bundle.ValidateTimestamp(250); err != ErrBundleTimestampTooLate { + t.Errorf("Expected ErrBundleTimestampTooLate, got %v", err) + } +} + +func TestBundleCanRevert(t *testing.T) { + bundle := &Bundle{ + Txs: []*types.Transaction{}, + RevertingTxs: []int{1, 3, 5}, + } + + testCases := []struct { + index int + expected bool + }{ + {0, false}, + {1, true}, + {2, false}, + {3, true}, + {4, false}, + {5, true}, + {6, false}, + } + + for _, tc := range testCases { + result := bundle.CanRevert(tc.index) + if result != tc.expected { + t.Errorf("CanRevert(%d) = %v, want %v", tc.index, result, tc.expected) + } + } +} + +func TestDefaultOrderingStrategy(t *testing.T) { + strategy := &DefaultOrderingStrategy{} + + // Create some test transactions + key, _ := crypto.GenerateKey() + signer := types.LatestSigner(params.TestChainConfig) + + tx1 := types.MustSignNewTx(key, signer, &types.LegacyTx{ + Nonce: 0, + GasPrice: big.NewInt(1), + Gas: 21000, + To: &common.Address{1}, + Value: big.NewInt(1), + }) + + tx2 := types.MustSignNewTx(key, signer, &types.LegacyTx{ + Nonce: 1, + GasPrice: big.NewInt(2), + Gas: 21000, + To: &common.Address{2}, + Value: big.NewInt(2), + }) + + bundle := &Bundle{ + Txs: []*types.Transaction{tx1, tx2}, + TargetBlock: 0, + } + + pending := make(map[common.Address][]*txpool.LazyTransaction) + header := &types.Header{ + Number: big.NewInt(1), + Time: 100, + } + + txs, err := strategy.OrderTransactions(pending, []*Bundle{bundle}, nil, header) + if err != nil { + t.Fatalf("OrderTransactions failed: %v", err) + } + + if len(txs) != 2 { + t.Errorf("Expected 2 transactions, got %d", len(txs)) + } +} + diff --git a/miner/miner.go b/miner/miner.go index 810cc20a6c..d5b50afc65 100644 --- a/miner/miner.go +++ b/miner/miner.go @@ -74,17 +74,27 @@ type Miner struct { chain *core.BlockChain pending *pending pendingMu sync.Mutex // Lock protects the pending block + + // Bundle and ordering support + bundlesMu sync.RWMutex + bundles []*Bundle + strategy OrderingStrategy + simulator *BundleSimulator } // New creates a new miner with provided config. func New(eth Backend, config Config, engine consensus.Engine) *Miner { + chain := eth.BlockChain() return &Miner{ config: &config, - chainConfig: eth.BlockChain().Config(), + chainConfig: chain.Config(), engine: engine, txpool: eth.TxPool(), - chain: eth.BlockChain(), + chain: chain, pending: &pending{}, + bundles: make([]*Bundle, 0), + strategy: &DefaultOrderingStrategy{}, + simulator: NewBundleSimulator(chain), } } @@ -133,6 +143,64 @@ func (miner *Miner) SetGasTip(tip *big.Int) error { return nil } +// SetOrderingStrategy sets a custom transaction ordering strategy. +func (miner *Miner) SetOrderingStrategy(strategy OrderingStrategy) { + miner.confMu.Lock() + miner.strategy = strategy + miner.confMu.Unlock() +} + +// AddBundle adds a bundle to be considered for inclusion in future blocks. +func (miner *Miner) AddBundle(bundle *Bundle) error { + miner.bundlesMu.Lock() + defer miner.bundlesMu.Unlock() + + miner.bundles = append(miner.bundles, bundle) + return nil +} + +// GetBundles returns the current bundles for the given block number. +func (miner *Miner) GetBundles(blockNumber uint64) []*Bundle { + miner.bundlesMu.RLock() + defer miner.bundlesMu.RUnlock() + + validBundles := make([]*Bundle, 0) + for _, bundle := range miner.bundles { + if bundle.TargetBlock == 0 || bundle.TargetBlock == blockNumber { + validBundles = append(validBundles, bundle) + } + } + return validBundles +} + +// ClearExpiredBundles removes bundles that are no longer valid for the given block number. +func (miner *Miner) ClearExpiredBundles(blockNumber uint64) { + miner.bundlesMu.Lock() + defer miner.bundlesMu.Unlock() + + validBundles := make([]*Bundle, 0) + for _, bundle := range miner.bundles { + if bundle.TargetBlock == 0 || bundle.TargetBlock >= blockNumber { + validBundles = append(validBundles, bundle) + } + } + miner.bundles = validBundles +} + +// SimulateBundle simulates a bundle and returns the result. +func (miner *Miner) SimulateBundle(bundle *Bundle, header *types.Header) (*BundleSimulationResult, error) { + // Get current state + stateDB, err := miner.chain.StateAt(miner.chain.CurrentBlock().Root) + if err != nil { + return nil, err + } + + // Copy state for simulation + simState := stateDB.Copy() + + return miner.simulator.SimulateBundle(bundle, header, simState, miner.config.PendingFeeRecipient) +} + // BuildPayload builds the payload according to the provided parameters. func (miner *Miner) BuildPayload(args *BuildPayloadArgs, witness bool) (*Payload, error) { return miner.buildPayload(args, witness) diff --git a/miner/simulator.go b/miner/simulator.go new file mode 100644 index 0000000000..77dd3e246d --- /dev/null +++ b/miner/simulator.go @@ -0,0 +1,221 @@ +// Copyright 2024 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package miner + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/params" +) + +// BundleSimulator provides functionality to simulate bundle execution. +type BundleSimulator struct { + chain *core.BlockChain + config *params.ChainConfig +} + +// NewBundleSimulator creates a new bundle simulator. +func NewBundleSimulator(chain *core.BlockChain) *BundleSimulator { + return &BundleSimulator{ + chain: chain, + config: chain.Config(), + } +} + +// SimulateBundle simulates the execution of a bundle on top of the given state. +func (s *BundleSimulator) SimulateBundle( + bundle *Bundle, + header *types.Header, + stateDB *state.StateDB, + coinbase common.Address, +) (*BundleSimulationResult, error) { + // Validate bundle timestamp + if err := bundle.ValidateTimestamp(header.Time); err != nil { + return nil, err + } + + result := &BundleSimulationResult{ + Success: true, + GasUsed: 0, + Profit: big.NewInt(0), + StateChanges: make(map[common.Address]*AccountChange), + FailedTxIndex: -1, + TxResults: make([]*TxSimulationResult, 0, len(bundle.Txs)), + } + + // Record initial coinbase balance + result.CoinbaseBalance = new(big.Int).Set(stateDB.GetBalance(coinbase).ToBig()) + + // Create EVM context + vmContext := core.NewEVMBlockContext(header, s.chain, &coinbase) + vmConfig := vm.Config{} + evm := vm.NewEVM(vmContext, stateDB, s.config, vmConfig) + + // Simulate each transaction in the bundle + gasPool := new(core.GasPool).AddGas(header.GasLimit) + + for i, tx := range bundle.Txs { + // Take snapshot before transaction + snapshot := stateDB.Snapshot() + + // Record pre-execution state + from, err := types.Sender(types.LatestSigner(s.config), tx) + if err != nil { + result.Success = false + result.FailedTxIndex = i + result.FailedTxError = err + return result, nil + } + + // Execute transaction + txResult := s.simulateTransaction(tx, evm, stateDB, gasPool, header, from) + result.TxResults = append(result.TxResults, txResult) + result.GasUsed += txResult.GasUsed + + // Check if transaction failed and is not allowed to revert + if !txResult.Success && !bundle.CanRevert(i) { + // Revert state + stateDB.RevertToSnapshot(snapshot) + result.Success = false + result.FailedTxIndex = i + result.FailedTxError = txResult.Error + return result, nil + } + + // Calculate profit from this transaction + if txResult.Success { + minerFee, _ := tx.EffectiveGasTip(header.BaseFee) + profit := new(big.Int).Mul(minerFee, new(big.Int).SetUint64(txResult.GasUsed)) + result.Profit.Add(result.Profit, profit) + } + } + + // Record final coinbase balance + finalBalance := stateDB.GetBalance(coinbase).ToBig() + actualProfit := new(big.Int).Sub(finalBalance, result.CoinbaseBalance) + result.Profit = actualProfit + result.CoinbaseBalance = finalBalance + + return result, nil +} + +// simulateTransaction simulates a single transaction. +func (s *BundleSimulator) simulateTransaction( + tx *types.Transaction, + evm *vm.EVM, + stateDB *state.StateDB, + gasPool *core.GasPool, + header *types.Header, + from common.Address, +) *TxSimulationResult { + result := &TxSimulationResult{ + Success: true, + Logs: make([]*types.Log, 0), + } + + // Set tx context + stateDB.SetTxContext(tx.Hash(), stateDB.TxIndex()) + + // Convert transaction to message + msg, err := core.TransactionToMessage(tx, types.MakeSigner(s.config, header.Number, header.Time), header.BaseFee) + if err != nil { + result.Success = false + result.Error = err + return result + } + + // Apply the transaction + execResult, err := core.ApplyMessage(evm, msg, gasPool) + if err != nil { + result.Success = false + result.Error = err + result.GasUsed = tx.Gas() + return result + } + + // Check execution result + if execResult.Failed() { + result.Success = false + result.Error = execResult.Err + } + + result.GasUsed = execResult.UsedGas + result.ReturnValue = execResult.ReturnData + + // Collect logs + result.Logs = stateDB.GetLogs(tx.Hash(), header.Number.Uint64(), header.Hash(), header.Time) + + return result +} + +// SimulateBundleAtPosition simulates a bundle inserted at a specific position +// in the existing block template. +func (s *BundleSimulator) SimulateBundleAtPosition( + bundle *Bundle, + baseBlock *types.Block, + position int, +) (*BundleSimulationResult, error) { + // Get state at parent block + parent := s.chain.GetBlock(baseBlock.ParentHash(), baseBlock.NumberU64()-1) + if parent == nil { + return nil, errors.New("parent block not found") + } + + stateDB, err := s.chain.StateAt(parent.Root()) + if err != nil { + return nil, err + } + + // Copy the state for simulation + simState := stateDB.Copy() + + // Execute transactions before the insertion point + if position > 0 { + header := baseBlock.Header() + vmContext := core.NewEVMBlockContext(header, s.chain, &header.Coinbase) + vmConfig := vm.Config{} + evm := vm.NewEVM(vmContext, simState, s.config, vmConfig) + gasPool := new(core.GasPool).AddGas(header.GasLimit) + + for i, tx := range baseBlock.Transactions() { + if i >= position { + break + } + msg, err := core.TransactionToMessage(tx, types.MakeSigner(s.config, header.Number, header.Time), header.BaseFee) + if err != nil { + log.Warn("Failed to convert transaction to message", "err", err) + continue + } + simState.SetTxContext(tx.Hash(), i) + _, err = core.ApplyMessage(evm, msg, gasPool) + if err != nil { + log.Warn("Transaction execution failed in pre-bundle simulation", "err", err) + } + } + } + + // Now simulate the bundle + return s.SimulateBundle(bundle, baseBlock.Header(), simState, baseBlock.Coinbase()) +} + diff --git a/miner/worker.go b/miner/worker.go index c0574eac23..87e983a93f 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -466,6 +466,7 @@ func (miner *Miner) fillTransactions(interrupt *atomic.Int32, env *environment) miner.confMu.RLock() tip := miner.config.GasPrice prio := miner.prio + strategy := miner.strategy miner.confMu.RUnlock() // Retrieve the pending transactions pre-filtered by the 1559/4844 dynamic fees @@ -492,6 +493,29 @@ func (miner *Miner) fillTransactions(interrupt *atomic.Int32, env *environment) } pendingBlobTxs := miner.txpool.Pending(filter) + // Merge pending transactions + allPending := make(map[common.Address][]*txpool.LazyTransaction) + for addr, txs := range pendingPlainTxs { + allPending[addr] = txs + } + for addr, txs := range pendingBlobTxs { + allPending[addr] = append(allPending[addr], txs...) + } + + // Get valid bundles for this block + bundles := miner.GetBundles(env.header.Number.Uint64()) + + // Use ordering strategy if not default + if _, isDefault := strategy.(*DefaultOrderingStrategy); !isDefault && strategy != nil { + orderedTxs, err := strategy.OrderTransactions(allPending, bundles, env.state, env.header) + if err != nil { + log.Warn("Custom ordering strategy failed, falling back to default", "err", err) + } else { + return miner.commitOrderedTransactions(env, orderedTxs, interrupt) + } + } + + // Default ordering: priority transactions first, then bundles, then normal transactions // Split the pending transactions into locals and remotes. prioPlainTxs, normalPlainTxs := make(map[common.Address][]*txpool.LazyTransaction), pendingPlainTxs prioBlobTxs, normalBlobTxs := make(map[common.Address][]*txpool.LazyTransaction), pendingBlobTxs @@ -515,6 +539,12 @@ func (miner *Miner) fillTransactions(interrupt *atomic.Int32, env *environment) return err } } + + // Commit valid bundles + if err := miner.commitBundles(env, bundles, interrupt); err != nil { + log.Debug("Bundle commitment failed", "err", err) + } + if len(normalPlainTxs) > 0 || len(normalBlobTxs) > 0 { plainTxs := newTransactionsByPriceAndNonce(env.signer, normalPlainTxs, env.header.BaseFee) blobTxs := newTransactionsByPriceAndNonce(env.signer, normalBlobTxs, env.header.BaseFee) @@ -526,6 +556,96 @@ func (miner *Miner) fillTransactions(interrupt *atomic.Int32, env *environment) return nil } +// commitBundles attempts to commit bundles to the block. +func (miner *Miner) commitBundles(env *environment, bundles []*Bundle, interrupt *atomic.Int32) error { + for _, bundle := range bundles { + // Validate bundle timestamp + if err := bundle.ValidateTimestamp(env.header.Time); err != nil { + continue + } + + // Simulate bundle to check if it will succeed + snapshot := env.state.Snapshot() + simResult, err := miner.simulator.SimulateBundle(bundle, env.header, env.state, env.coinbase) + if err != nil || !simResult.Success { + env.state.RevertToSnapshot(snapshot) + continue + } + + // Bundle simulation succeeded, commit each transaction + bundleSuccess := true + for i, tx := range bundle.Txs { + // Check interruption + if interrupt != nil { + if signal := interrupt.Load(); signal != commitInterruptNone { + env.state.RevertToSnapshot(snapshot) + return signalToErr(signal) + } + } + + // Check gas limit + if env.gasPool.Gas() < tx.Gas() { + bundleSuccess = false + break + } + + // Check block size + if !env.txFitsSize(tx) { + bundleSuccess = false + break + } + + // Commit transaction + env.state.SetTxContext(tx.Hash(), env.tcount) + err := miner.commitTransaction(env, tx) + + // Check if transaction failed and is not allowed to revert + if err != nil && !bundle.CanRevert(i) { + bundleSuccess = false + break + } + } + + // If bundle failed, revert state + if !bundleSuccess { + env.state.RevertToSnapshot(snapshot) + } + } + return nil +} + +// commitOrderedTransactions commits pre-ordered transactions to the block. +func (miner *Miner) commitOrderedTransactions(env *environment, txs []*types.Transaction, interrupt *atomic.Int32) error { + for _, tx := range txs { + // Check interruption signal + if interrupt != nil { + if signal := interrupt.Load(); signal != commitInterruptNone { + return signalToErr(signal) + } + } + + // Check gas and size constraints + if env.gasPool.Gas() < tx.Gas() { + log.Trace("Not enough gas left for transaction", "hash", tx.Hash(), "left", env.gasPool.Gas(), "needed", tx.Gas()) + continue + } + + if !env.txFitsSize(tx) { + break + } + + // Commit transaction + env.state.SetTxContext(tx.Hash(), env.tcount) + err := miner.commitTransaction(env, tx) + if err != nil { + from, _ := types.Sender(env.signer, tx) + log.Debug("Transaction failed in ordered execution", "hash", tx.Hash(), "from", from, "err", err) + continue + } + } + return nil +} + // totalFees computes total consumed miner fees in Wei. Block transactions and receipts have to have the same order. func totalFees(block *types.Block, receipts []*types.Receipt) *big.Int { feesWei := new(big.Int)