14 files changed, 681 insertions, 584 deletions
diff --git a/eth/api.go b/eth/api.go
index b64090e..ada2a97 100644
--- a/eth/api.go
+++ b/eth/api.go
@@ -34,10 +34,10 @@ import (
 "github.com/ava-labs/coreth/core/types"
 "github.com/ava-labs/coreth/internal/ethapi"
 "github.com/ava-labs/coreth/rpc"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/hexutil"
- "github.com/ava-labs/go-ethereum/rlp"
- "github.com/ava-labs/go-ethereum/trie"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/rlp"
+ "github.com/ethereum/go-ethereum/trie"
 )
 
 // PublicEthereumAPI provides an API to access Ethereum full node-related
@@ -166,8 +166,21 @@ func NewPrivateAdminAPI(eth *Ethereum) *PrivateAdminAPI {
 return &PrivateAdminAPI{eth: eth}
 }
 
-// ExportChain exports the current blockchain into a local file.
-func (api *PrivateAdminAPI) ExportChain(file string) (bool, error) {
+// ExportChain exports the current blockchain into a local file,
+// or a range of blocks if first and last are non-nil
+func (api *PrivateAdminAPI) ExportChain(file string, first *uint64, last *uint64) (bool, error) {
+ if first == nil && last != nil {
+ return false, errors.New("last cannot be specified without first")
+ }
+ if first != nil && last == nil {
+ head := api.eth.BlockChain().CurrentHeader().Number.Uint64()
+ last = &head
+ }
+ if _, err := os.Stat(file); err == nil {
+ // File already exists. Allowing overwrite could be a DoS vecotor,
+ // since the 'file' may point to arbitrary paths on the drive
+ return false, errors.New("location would overwrite an existing file")
+ }
 // Make sure we can create the file to export into
 out, err := os.OpenFile(file, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
 if err != nil {
@@ -182,7 +195,11 @@ func (api *PrivateAdminAPI) ExportChain(file string) (bool, error) {
 }
 
 // Export the blockchain
- if err := api.eth.BlockChain().Export(writer); err != nil {
+ if first != nil {
+ if err := api.eth.BlockChain().ExportN(writer, *first, *last); err != nil {
+ return false, err
+ }
+ } else if err := api.eth.BlockChain().Export(writer); err != nil {
 return false, err
 }
 return true, nil
@@ -336,70 +353,52 @@ func (api *PrivateDebugAPI) GetBadBlocks(ctx context.Context) ([]*BadBlockArgs,
 return results, nil
 }
 
-// AccountRangeResult returns a mapping from the hash of an account addresses
-// to its preimage. It will return the JSON null if no preimage is found.
-// Since a query can return a limited amount of results, a "next" field is
-// also present for paging.
-type AccountRangeResult struct {
- Accounts map[common.Hash]*common.Address `json:"accounts"`
- Next common.Hash `json:"next"`
-}
-
-func accountRange(st state.Trie, start *common.Hash, maxResults int) (AccountRangeResult, error) {
- if start == nil {
- start = &common.Hash{0}
- }
- it := trie.NewIterator(st.NodeIterator(start.Bytes()))
- result := AccountRangeResult{Accounts: make(map[common.Hash]*common.Address), Next: common.Hash{}}
-
- if maxResults > AccountRangeMaxResults {
- maxResults = AccountRangeMaxResults
- }
-
- for i := 0; i < maxResults && it.Next(); i++ {
- if preimage := st.GetKey(it.Key); preimage != nil {
- addr := &common.Address{}
- addr.SetBytes(preimage)
- result.Accounts[common.BytesToHash(it.Key)] = addr
- } else {
- result.Accounts[common.BytesToHash(it.Key)] = nil
- }
- }
-
- if it.Next() {
- result.Next = common.BytesToHash(it.Key)
- }
-
- return result, nil
-}
-
 // AccountRangeMaxResults is the maximum number of results to be returned per call
 const AccountRangeMaxResults = 256
 
-// AccountRange enumerates all accounts in the latest state
-func (api *PrivateDebugAPI) AccountRange(ctx context.Context, start *common.Hash, maxResults int) (AccountRangeResult, error) {
- var statedb *state.StateDB
+// AccountRange enumerates all accounts in the given block and start point in paging request
+func (api *PublicDebugAPI) AccountRange(blockNrOrHash rpc.BlockNumberOrHash, start []byte, maxResults int, nocode, nostorage, incompletes bool) (state.IteratorDump, error) {
+ var stateDb *state.StateDB
 var err error
- block := api.eth.blockchain.CurrentBlock()
 
- if len(block.Transactions()) == 0 {
- statedb, err = api.computeStateDB(block, defaultTraceReexec)
- if err != nil {
- return AccountRangeResult{}, err
+ if number, ok := blockNrOrHash.Number(); ok {
+ if number == rpc.PendingBlockNumber {
+ // If we're dumping the pending state, we need to request
+ // both the pending block as well as the pending state from
+ // the miner and operate on those
+ _, stateDb = api.eth.miner.Pending()
+ } else {
+ var block *types.Block
+ if number == rpc.LatestBlockNumber {
+ block = api.eth.blockchain.CurrentBlock()
+ } else if number == rpc.AcceptedBlockNumber {
+ block = api.eth.AcceptedBlock()
+ } else {
+ block = api.eth.blockchain.GetBlockByNumber(uint64(number))
+ }
+ if block == nil {
+ return state.IteratorDump{}, fmt.Errorf("block #%d not found", number)
+ }
+ stateDb, err = api.eth.BlockChain().StateAt(block.Root())
+ if err != nil {
+ return state.IteratorDump{}, err
+ }
 }
- } else {
- _, _, statedb, err = api.computeTxEnv(block.Hash(), len(block.Transactions())-1, 0)
+ } else if hash, ok := blockNrOrHash.Hash(); ok {
+ block := api.eth.blockchain.GetBlockByHash(hash)
+ if block == nil {
+ return state.IteratorDump{}, fmt.Errorf("block %s not found", hash.Hex())
+ }
+ stateDb, err = api.eth.BlockChain().StateAt(block.Root())
 if err != nil {
- return AccountRangeResult{}, err
+ return state.IteratorDump{}, err
 }
 }
 
- trie, err := statedb.Database().OpenTrie(block.Header().Root)
- if err != nil {
- return AccountRangeResult{}, err
+ if maxResults > AccountRangeMaxResults || maxResults <= 0 {
+ maxResults = AccountRangeMaxResults
 }
-
- return accountRange(trie, start, maxResults)
+ return stateDb.IteratorDump(nocode, nostorage, incompletes, start, maxResults), nil
 }
 
 // StorageRangeResult is the result of a debug_storageRangeAt API call.
@@ -416,8 +415,13 @@ type storageEntry struct {
 }
 
 // StorageRangeAt returns the storage at the given block height and transaction index.
-func (api *PrivateDebugAPI) StorageRangeAt(ctx context.Context, blockHash common.Hash, txIndex int, contractAddress common.Address, keyStart hexutil.Bytes, maxResult int) (StorageRangeResult, error) {
- _, _, statedb, err := api.computeTxEnv(blockHash, txIndex, 0)
+func (api *PrivateDebugAPI) StorageRangeAt(blockHash common.Hash, txIndex int, contractAddress common.Address, keyStart hexutil.Bytes, maxResult int) (StorageRangeResult, error) {
+ // Retrieve the block
+ block := api.eth.blockchain.GetBlockByHash(blockHash)
+ if block == nil {
+ return StorageRangeResult{}, fmt.Errorf("block %#x not found", blockHash)
+ }
+ _, _, statedb, err := api.computeTxEnv(block, txIndex, 0)
 if err != nil {
 return StorageRangeResult{}, err
 }
diff --git a/eth/api_backend.go b/eth/api_backend.go
index d4061f8..bbc8691 100644
--- a/eth/api_backend.go
+++ b/eth/api_backend.go
@@ -22,20 +22,21 @@ import (
 "math/big"
 
 "github.com/ava-labs/coreth/accounts"
+ "github.com/ava-labs/coreth/consensus"
 "github.com/ava-labs/coreth/core"
+ "github.com/ava-labs/coreth/core/bloombits"
 "github.com/ava-labs/coreth/core/rawdb"
 "github.com/ava-labs/coreth/core/state"
 "github.com/ava-labs/coreth/core/types"
 "github.com/ava-labs/coreth/core/vm"
 "github.com/ava-labs/coreth/eth/gasprice"
+ "github.com/ava-labs/coreth/miner"
 "github.com/ava-labs/coreth/params"
 "github.com/ava-labs/coreth/rpc"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/math"
- "github.com/ava-labs/go-ethereum/core/bloombits"
- "github.com/ava-labs/go-ethereum/eth/downloader"
- "github.com/ava-labs/go-ethereum/ethdb"
- "github.com/ava-labs/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/eth/downloader"
+ "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/event"
 )
 
 // EthAPIBackend implements ethapi.Backend for full nodes
@@ -79,6 +80,23 @@ func (b *EthAPIBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumb
 return b.eth.blockchain.GetHeaderByNumber(uint64(number)), nil
 }
 
+func (b *EthAPIBackend) HeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Header, error) {
+ if blockNr, ok := blockNrOrHash.Number(); ok {
+ return b.HeaderByNumber(ctx, blockNr)
+ }
+ if hash, ok := blockNrOrHash.Hash(); ok {
+ header := b.eth.blockchain.GetHeaderByHash(hash)
+ if header == nil {
+ return nil, errors.New("header for hash not found")
+ }
+ if blockNrOrHash.RequireCanonical && b.eth.blockchain.GetCanonicalHash(header.Number.Uint64()) != hash {
+ return nil, errors.New("hash is not currently canonical")
+ }
+ return header, nil
+ }
+ return nil, errors.New("invalid arguments; neither block nor hash specified")
+}
+
 func (b *EthAPIBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
 return b.eth.blockchain.GetHeaderByHash(hash), nil
 }
@@ -103,6 +121,27 @@ func (b *EthAPIBackend) BlockByHash(ctx context.Context, hash common.Hash) (*typ
 return b.eth.blockchain.GetBlockByHash(hash), nil
 }
 
+func (b *EthAPIBackend) BlockByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Block, error) {
+ if blockNr, ok := blockNrOrHash.Number(); ok {
+ return b.BlockByNumber(ctx, blockNr)
+ }
+ if hash, ok := blockNrOrHash.Hash(); ok {
+ header := b.eth.blockchain.GetHeaderByHash(hash)
+ if header == nil {
+ return nil, errors.New("header for hash not found")
+ }
+ if blockNrOrHash.RequireCanonical && b.eth.blockchain.GetCanonicalHash(header.Number.Uint64()) != hash {
+ return nil, errors.New("hash is not currently canonical")
+ }
+ block := b.eth.blockchain.GetBlock(hash, header.Number.Uint64())
+ if block == nil {
+ return nil, errors.New("header found, but block body is missing")
+ }
+ return block, nil
+ }
+ return nil, errors.New("invalid arguments; neither block nor hash specified")
+}
+
 func (b *EthAPIBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) {
 // Pending state is only known by the miner
 if number == rpc.PendingBlockNumber {
@@ -121,6 +160,27 @@ func (b *EthAPIBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.B
 return stateDb, header, err
 }
 
+func (b *EthAPIBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error) {
+ if blockNr, ok := blockNrOrHash.Number(); ok {
+ return b.StateAndHeaderByNumber(ctx, blockNr)
+ }
+ if hash, ok := blockNrOrHash.Hash(); ok {
+ header, err := b.HeaderByHash(ctx, hash)
+ if err != nil {
+ return nil, nil, err
+ }
+ if header == nil {
+ return nil, nil, errors.New("header for hash not found")
+ }
+ if blockNrOrHash.RequireCanonical && b.eth.blockchain.GetCanonicalHash(header.Number.Uint64()) != hash {
+ return nil, nil, errors.New("hash is not currently canonical")
+ }
+ stateDb, err := b.eth.BlockChain().StateAt(header.Root)
+ return stateDb, header, err
+ }
+ return nil, nil, errors.New("invalid arguments; neither block nor hash specified")
+}
+
 func (b *EthAPIBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {
 return b.eth.blockchain.GetReceiptsByHash(hash), nil
 }
@@ -137,12 +197,11 @@ func (b *EthAPIBackend) GetLogs(ctx context.Context, hash common.Hash) ([][]*typ
 return logs, nil
 }
 
-func (b *EthAPIBackend) GetTd(blockHash common.Hash) *big.Int {
- return b.eth.blockchain.GetTdByHash(blockHash)
+func (b *EthAPIBackend) GetTd(ctx context.Context, hash common.Hash) *big.Int {
+ return b.eth.blockchain.GetTdByHash(hash)
 }
 
 func (b *EthAPIBackend) GetEVM(ctx context.Context, msg core.Message, state *state.StateDB, header *types.Header) (*vm.EVM, func() error, error) {
- state.SetBalance(msg.From(), math.MaxBig256)
 vmError := func() error { return nil }
 
 context := core.NewEVMContext(msg, header, b.eth.BlockChain(), nil)
@@ -153,6 +212,10 @@ func (b *EthAPIBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEven
 return b.eth.BlockChain().SubscribeRemovedLogsEvent(ch)
 }
 
+func (b *EthAPIBackend) SubscribePendingLogsEvent(ch chan<- []*types.Log) event.Subscription {
+ return b.eth.miner.SubscribePendingLogs(ch)
+}
+
 func (b *EthAPIBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription {
 return b.eth.BlockChain().SubscribeChainEvent(ch)
 }
@@ -211,6 +274,10 @@ func (b *EthAPIBackend) TxPoolContent() (map[common.Address]types.Transactions,
 return b.eth.TxPool().Content()
 }
 
+func (b *EthAPIBackend) TxPool() *core.TxPool {
+ return b.eth.TxPool()
+}
+
 func (b *EthAPIBackend) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription {
 return b.eth.TxPool().SubscribeNewTxsEvent(ch)
 }
@@ -243,10 +310,14 @@ func (b *EthAPIBackend) ExtRPCEnabled() bool {
 return b.extRPCEnabled
 }
 
-func (b *EthAPIBackend) RPCGasCap() *big.Int {
+func (b *EthAPIBackend) RPCGasCap() uint64 {
 return b.eth.config.RPCGasCap
 }
 
+func (b *EthAPIBackend) RPCTxFeeCap() float64 {
+ return b.eth.config.RPCTxFeeCap
+}
+
 func (b *EthAPIBackend) BloomStatus() (uint64, uint64) {
 sections, _, _ := b.eth.bloomIndexer.Sections()
 return params.BloomBitsBlocks, sections
@@ -257,3 +328,19 @@ func (b *EthAPIBackend) ServiceFilter(ctx context.Context, session *bloombits.Ma
 go session.Multiplex(bloomRetrievalBatch, bloomRetrievalWait, b.eth.bloomRequests)
 }
 }
+
+func (b *EthAPIBackend) Engine() consensus.Engine {
+ return b.eth.engine
+}
+
+func (b *EthAPIBackend) CurrentHeader() *types.Header {
+ return b.eth.blockchain.CurrentHeader()
+}
+
+func (b *EthAPIBackend) Miner() *miner.Miner {
+ return b.eth.Miner()
+}
+
+func (b *EthAPIBackend) StartMining(threads int) error {
+ return b.eth.StartMining(threads)
+}
diff --git a/eth/api_tracer.go b/eth/api_tracer.go
index c8a5307..c044dcc 100644
--- a/eth/api_tracer.go
+++ b/eth/api_tracer.go
@@ -36,11 +36,11 @@ import (
 "github.com/ava-labs/coreth/eth/tracers"
 "github.com/ava-labs/coreth/internal/ethapi"
 "github.com/ava-labs/coreth/rpc"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/hexutil"
- "github.com/ava-labs/go-ethereum/log"
- "github.com/ava-labs/go-ethereum/rlp"
- "github.com/ava-labs/go-ethereum/trie"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/log"
+ "github.com/ethereum/go-ethereum/rlp"
+ "github.com/ethereum/go-ethereum/trie"
 )
 
 const (
@@ -151,7 +151,7 @@ func (api *PrivateDebugAPI) traceChain(ctx context.Context, start, end *types.Bl
 
 // Ensure we have a valid starting state before doing any work
 origin := start.NumberU64()
- database := state.NewDatabaseWithCache(api.eth.ChainDb(), 16) // Chain tracing will probably start at genesis
+ database := state.NewDatabaseWithCache(api.eth.ChainDb(), 16, "") // Chain tracing will probably start at genesis
 
 if number := start.NumberU64(); number > 0 {
 start = api.eth.blockchain.GetBlock(start.ParentHash(), start.NumberU64()-1)
@@ -159,7 +159,7 @@ func (api *PrivateDebugAPI) traceChain(ctx context.Context, start, end *types.Bl
 return nil, fmt.Errorf("parent block #%d not found", number-1)
 }
 }
- statedb, err := state.New(start.Root(), database)
+ statedb, err := state.New(start.Root(), database, nil)
 if err != nil {
 // If the starting state is missing, allow some number of blocks to be reexecuted
 reexec := defaultTraceReexec
@@ -172,7 +172,7 @@ func (api *PrivateDebugAPI) traceChain(ctx context.Context, start, end *types.Bl
 if start == nil {
 break
 }
- if statedb, err = state.New(start.Root(), database); err == nil {
+ if statedb, err = state.New(start.Root(), database, nil); err == nil {
 break
 }
 }
@@ -407,7 +407,7 @@ func (api *PrivateDebugAPI) TraceBlockFromFile(ctx context.Context, file string,
 return api.TraceBlock(ctx, blob, config)
 }
 
-// TraceBadBlockByHash returns the structured logs created during the execution of
+// TraceBadBlock returns the structured logs created during the execution of
 // EVM against a block pulled from the pool of bad ones and returns them as a JSON
 // object.
 func (api *PrivateDebugAPI) TraceBadBlock(ctx context.Context, hash common.Hash, config *TraceConfig) ([]*txTraceResult, error) {
@@ -508,7 +508,7 @@ func (api *PrivateDebugAPI) traceBlock(ctx context.Context, block *types.Block,
 vmctx := core.NewEVMContext(msg, block.Header(), api.eth.blockchain, nil)
 
 vmenv := vm.NewEVM(vmctx, statedb, api.eth.blockchain.Config(), vm.Config{})
- if _, _, _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.Gas())); err != nil {
+ if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.Gas())); err != nil {
 failed = err
 break
 }
@@ -602,7 +602,7 @@ func (api *PrivateDebugAPI) standardTraceBlockToFile(ctx context.Context, block
 }
 // Execute the transaction and flush any traces to disk
 vmenv := vm.NewEVM(vmctx, statedb, api.eth.blockchain.Config(), vmConf)
- _, _, _, err = core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.Gas()))
+ _, err = core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.Gas()))
 if writer != nil {
 writer.Flush()
 }
@@ -647,14 +647,14 @@ func (api *PrivateDebugAPI) computeStateDB(block *types.Block, reexec uint64) (*
 }
 // Otherwise try to reexec blocks until we find a state or reach our limit
 origin := block.NumberU64()
- database := state.NewDatabaseWithCache(api.eth.ChainDb(), 16)
+ database := state.NewDatabaseWithCache(api.eth.ChainDb(), 16, "")
 
 for i := uint64(0); i < reexec; i++ {
 block = api.eth.blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1)
 if block == nil {
 break
 }
- if statedb, err = state.New(block.Root(), database); err == nil {
+ if statedb, err = state.New(block.Root(), database, nil); err == nil {
 break
 }
 }
@@ -717,7 +717,12 @@ func (api *PrivateDebugAPI) TraceTransaction(ctx context.Context, hash common.Ha
 if config != nil && config.Reexec != nil {
 reexec = *config.Reexec
 }
- msg, vmctx, statedb, err := api.computeTxEnv(blockHash, int(index), reexec)
+ // Retrieve the block
+ block := api.eth.blockchain.GetBlockByHash(blockHash)
+ if block == nil {
+ return nil, fmt.Errorf("block %#x not found", blockHash)
+ }
+ msg, vmctx, statedb, err := api.computeTxEnv(block, int(index), reexec)
 if err != nil {
 return nil, err
 }
@@ -725,6 +730,40 @@ func (api *PrivateDebugAPI) TraceTransaction(ctx context.Context, hash common.Ha
 return api.traceTx(ctx, msg, vmctx, statedb, config)
 }
 
+// TraceCall lets you trace a given eth_call. It collects the structured logs created during the execution of EVM
+// if the given transaction was added on top of the provided block and returns them as a JSON object.
+// You can provide -2 as a block number to trace on top of the pending block.
+func (api *PrivateDebugAPI) TraceCall(ctx context.Context, args ethapi.CallArgs, blockNrOrHash rpc.BlockNumberOrHash, config *TraceConfig) (interface{}, error) {
+ // First try to retrieve the state
+ statedb, header, err := api.eth.APIBackend.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
+ if err != nil {
+ // Try to retrieve the specified block
+ var block *types.Block
+ if hash, ok := blockNrOrHash.Hash(); ok {
+ block = api.eth.blockchain.GetBlockByHash(hash)
+ } else if number, ok := blockNrOrHash.Number(); ok {
+ block = api.eth.blockchain.GetBlockByNumber(uint64(number))
+ }
+ if block == nil {
+ return nil, fmt.Errorf("block %v not found: %v", blockNrOrHash, err)
+ }
+ // try to recompute the state
+ reexec := defaultTraceReexec
+ if config != nil && config.Reexec != nil {
+ reexec = *config.Reexec
+ }
+ _, _, statedb, err = api.computeTxEnv(block, 0, reexec)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ // Execute the trace
+ msg := args.ToMessage(api.eth.APIBackend.RPCGasCap())
+ vmctx := core.NewEVMContext(msg, header, api.eth.blockchain, nil)
+ return api.traceTx(ctx, msg, vmctx, statedb, config)
+}
+
 // traceTx configures a new tracer according to the provided configuration, and
 // executes the given message in the provided environment. The return value will
 // be tracer dependent.
@@ -764,17 +803,22 @@ func (api *PrivateDebugAPI) traceTx(ctx context.Context, message core.Message, v
 // Run the transaction with tracing enabled.
 vmenv := vm.NewEVM(vmctx, statedb, api.eth.blockchain.Config(), vm.Config{Debug: true, Tracer: tracer})
 
- ret, gas, failed, err := core.ApplyMessage(vmenv, message, new(core.GasPool).AddGas(message.Gas()))
+ result, err := core.ApplyMessage(vmenv, message, new(core.GasPool).AddGas(message.Gas()))
 if err != nil {
 return nil, fmt.Errorf("tracing failed: %v", err)
 }
 // Depending on the tracer type, format and return the output
 switch tracer := tracer.(type) {
 case *vm.StructLogger:
+ // If the result contains a revert reason, return it.
+ returnVal := fmt.Sprintf("%x", result.Return())
+ if len(result.Revert()) > 0 {
+ returnVal = fmt.Sprintf("%x", result.Revert())
+ }
 return &ethapi.ExecutionResult{
- Gas: gas,
- Failed: failed,
- ReturnValue: fmt.Sprintf("%x", ret),
+ Gas: result.UsedGas,
+ Failed: result.Failed(),
+ ReturnValue: returnVal,
 StructLogs: ethapi.FormatLogs(tracer.StructLogs()),
 }, nil
 
@@ -787,12 +831,8 @@ func (api *PrivateDebugAPI) traceTx(ctx context.Context, message core.Message, v
 }
 
 // computeTxEnv returns the execution environment of a certain transaction.
-func (api *PrivateDebugAPI) computeTxEnv(blockHash common.Hash, txIndex int, reexec uint64) (core.Message, vm.Context, *state.StateDB, error) {
+func (api *PrivateDebugAPI) computeTxEnv(block *types.Block, txIndex int, reexec uint64) (core.Message, vm.Context, *state.StateDB, error) {
 // Create the parent state database
- block := api.eth.blockchain.GetBlockByHash(blockHash)
- if block == nil {
- return nil, vm.Context{}, nil, fmt.Errorf("block %#x not found", blockHash)
- }
 parent := api.eth.blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1)
 if parent == nil {
 return nil, vm.Context{}, nil, fmt.Errorf("parent %#x not found", block.ParentHash())
@@ -818,12 +858,12 @@ func (api *PrivateDebugAPI) computeTxEnv(blockHash common.Hash, txIndex int, ree
 }
 // Not yet the searched for transaction, execute on top of the current state
 vmenv := vm.NewEVM(context, statedb, api.eth.blockchain.Config(), vm.Config{})
- if _, _, _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas())); err != nil {
+ if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas())); err != nil {
 return nil, vm.Context{}, nil, fmt.Errorf("transaction %#x failed: %v", tx.Hash(), err)
 }
 // Ensure any modifications are committed to the state
 // Only delete empty objects if EIP158/161 (a.k.a Spurious Dragon) is in effect
 statedb.Finalise(vmenv.ChainConfig().IsEIP158(block.Number()))
 }
- return nil, vm.Context{}, nil, fmt.Errorf("transaction index %d out of range for block %#x", txIndex, blockHash)
+ return nil, vm.Context{}, nil, fmt.Errorf("transaction index %d out of range for block %#x", txIndex, block.Hash())
 }
diff --git a/eth/backend.go b/eth/backend.go
index 773f48e..728ec4d 100644
--- a/eth/backend.go
+++ b/eth/backend.go
@@ -26,12 +26,12 @@ import (
 //"sync/atomic"
 
 "github.com/ava-labs/coreth/accounts"
- "github.com/ava-labs/coreth/accounts/abi/bind"
 "github.com/ava-labs/coreth/consensus"
 "github.com/ava-labs/coreth/consensus/clique"
 "github.com/ava-labs/coreth/consensus/dummy"
 "github.com/ava-labs/coreth/consensus/ethash"
 "github.com/ava-labs/coreth/core"
+ "github.com/ava-labs/coreth/core/bloombits"
 "github.com/ava-labs/coreth/core/rawdb"
 "github.com/ava-labs/coreth/core/types"
 "github.com/ava-labs/coreth/core/vm"
@@ -42,26 +42,17 @@ import (
 "github.com/ava-labs/coreth/node"
 "github.com/ava-labs/coreth/params"
 "github.com/ava-labs/coreth/rpc"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/hexutil"
- "github.com/ava-labs/go-ethereum/core/bloombits"
- "github.com/ava-labs/go-ethereum/eth/downloader"
- "github.com/ava-labs/go-ethereum/ethdb"
- "github.com/ava-labs/go-ethereum/event"
- "github.com/ava-labs/go-ethereum/log"
- "github.com/ava-labs/go-ethereum/p2p"
- "github.com/ava-labs/go-ethereum/rlp"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/eth/downloader"
+ "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/log"
+ "github.com/ethereum/go-ethereum/p2p"
+ "github.com/ethereum/go-ethereum/p2p/enode"
+ "github.com/ethereum/go-ethereum/rlp"
 )
 
-type LesServer interface {
- Start(srvr *p2p.Server)
- Stop()
- APIs() []rpc.API
- Protocols() []p2p.Protocol
- SetBloomBitsIndexer(bbIndexer *core.ChainIndexer)
- SetContractBackend(bind.ContractBackend)
-}
-
 type BackendCallbacks struct {
 OnQueryAcceptedBlock func() *types.Block
 }
@@ -70,16 +61,11 @@ type BackendCallbacks struct {
 type Ethereum struct {
 config *Config
 
- // Channel for shutting down the service
- shutdownChan chan bool
-
- server *p2p.Server
-
 // Handlers
 txPool *core.TxPool
 blockchain *core.BlockChain
 //protocolManager *ProtocolManager
- lesServer LesServer
+ dialCandidates enode.Iterator
 
 // DB interfaces
 chainDb ethdb.Database // Block chain database
@@ -88,8 +74,9 @@ type Ethereum struct {
 engine consensus.Engine
 accountManager *accounts.Manager
 
- bloomRequests chan chan *bloombits.Retrieval // Channel receiving bloom data retrieval requests
- bloomIndexer *core.ChainIndexer // Bloom indexer operating during block imports
+ bloomRequests chan chan *bloombits.Retrieval // Channel receiving bloom data retrieval requests
+ bloomIndexer *core.ChainIndexer // Bloom indexer operating during block imports
+ closeBloomHandler chan struct{}
 
 APIBackend *EthAPIBackend
 
@@ -100,28 +87,17 @@ type Ethereum struct {
 networkID uint64
 netRPCService *ethapi.PublicNetAPI
 
+ p2pServer *p2p.Server
+
 lock sync.RWMutex // Protects the variadic fields (e.g. gas price and etherbase)
 
 txSubmitChan chan struct{}
 bcb *BackendCallbacks
 }
 
-func (s *Ethereum) AddLesServer(ls LesServer) {
- s.lesServer = ls
- ls.SetBloomBitsIndexer(s.bloomIndexer)
-}
-
-// SetClient sets a rpc client which connecting to our local node.
-func (s *Ethereum) SetContractBackend(backend bind.ContractBackend) {
- // Pass the rpc client to les server if it is enabled.
- if s.lesServer != nil {
- s.lesServer.SetContractBackend(backend)
- }
-}
-
 // New creates a new Ethereum object (including the
 // initialisation of the common Ethereum object)
-func New(ctx *node.ServiceContext, config *Config,
+func New(stack *node.Node, config *Config,
 cb *dummy.ConsensusCallbacks,
 mcb *miner.MinerCallbacks,
 bcb *BackendCallbacks,
@@ -138,7 +114,12 @@ func New(ctx *node.ServiceContext, config *Config,
 config.Miner.GasPrice = new(big.Int).Set(DefaultConfig.Miner.GasPrice)
 }
 if config.NoPruning && config.TrieDirtyCache > 0 {
- config.TrieCleanCache += config.TrieDirtyCache
+ if config.SnapshotCache > 0 {
+ config.TrieCleanCache += config.TrieDirtyCache * 3 / 5
+ config.SnapshotCache += config.TrieDirtyCache * 2 / 5
+ } else {
+ config.TrieCleanCache += config.TrieDirtyCache
+ }
 config.TrieDirtyCache = 0
 }
 log.Info("Allocated trie memory caches", "clean", common.StorageSize(config.TrieCleanCache)*1024*1024, "dirty", common.StorageSize(config.TrieDirtyCache)*1024*1024)
@@ -146,31 +127,32 @@ func New(ctx *node.ServiceContext, config *Config,
 var err error
 if chainDb == nil {
 // Assemble the Ethereum object
- chainDb, err = ctx.OpenDatabaseWithFreezer("chaindata", config.DatabaseCache, config.DatabaseHandles, config.DatabaseFreezer, "eth/db/chaindata/")
+ chainDb, err = stack.OpenDatabaseWithFreezer("chaindata", config.DatabaseCache, config.DatabaseHandles, config.DatabaseFreezer, "eth/db/chaindata/")
 if err != nil {
 return nil, err
 }
 }
- chainConfig, genesisHash, genesisErr := core.SetupGenesisBlockWithOverride(chainDb, config.Genesis, config.OverrideIstanbul)
+ chainConfig, genesisHash, genesisErr := core.SetupGenesisBlock(chainDb, config.Genesis)
 if _, ok := genesisErr.(*params.ConfigCompatError); genesisErr != nil && !ok {
 return nil, genesisErr
 }
 log.Info("Initialised chain configuration", "config", chainConfig)
 
 eth := &Ethereum{
- config: config,
- chainDb: chainDb,
- eventMux: ctx.EventMux,
- accountManager: ctx.AccountManager,
- engine: CreateConsensusEngine(ctx, chainConfig, &config.Ethash, config.Miner.Notify, config.Miner.Noverify, chainDb, cb),
- shutdownChan: make(chan bool),
- networkID: config.NetworkId,
- gasPrice: config.Miner.GasPrice,
- etherbase: config.Miner.Etherbase,
- bloomRequests: make(chan chan *bloombits.Retrieval),
- bloomIndexer: NewBloomIndexer(chainDb, params.BloomBitsBlocks, params.BloomConfirms),
- txSubmitChan: make(chan struct{}, 1),
- bcb: bcb,
+ config: config,
+ chainDb: chainDb,
+ eventMux: stack.EventMux(),
+ accountManager: stack.AccountManager(),
+ engine: CreateConsensusEngine(stack, chainConfig, &config.Ethash, config.Miner.Notify, config.Miner.Noverify, chainDb, cb),
+ closeBloomHandler: make(chan struct{}),
+ networkID: config.NetworkId,
+ gasPrice: config.Miner.GasPrice,
+ etherbase: config.Miner.Etherbase,
+ bloomRequests: make(chan chan *bloombits.Retrieval),
+ bloomIndexer: NewBloomIndexer(chainDb, params.BloomBitsBlocks, params.BloomConfirms),
+ p2pServer: stack.Server(),
+ txSubmitChan: make(chan struct{}, 1),
+ bcb: bcb,
 }
 
 bcVersion := rawdb.ReadDatabaseVersion(chainDb)
@@ -196,13 +178,16 @@ func New(ctx *node.ServiceContext, config *Config,
 }
 cacheConfig = &core.CacheConfig{
 TrieCleanLimit: config.TrieCleanCache,
+ TrieCleanJournal: stack.ResolvePath(config.TrieCleanCacheJournal),
+ TrieCleanRejournal: config.TrieCleanCacheRejournal,
 TrieCleanNoPrefetch: config.NoPrefetch,
 TrieDirtyLimit: config.TrieDirtyCache,
 TrieDirtyDisabled: config.NoPruning,
 TrieTimeLimit: config.TrieTimeout,
+ SnapshotLimit: config.SnapshotCache,
 }
 )
- eth.blockchain, err = core.NewBlockChain(chainDb, cacheConfig, chainConfig, eth.engine, vmConfig, eth.shouldPreserve, config.ManualCanonical)
+ eth.blockchain, err = core.NewBlockChain(chainDb, cacheConfig, chainConfig, eth.engine, vmConfig, eth.shouldPreserve, &config.TxLookupLimit, config.ManualCanonical)
 if err != nil {
 return nil, err
 }
@@ -215,12 +200,12 @@ func New(ctx *node.ServiceContext, config *Config,
 eth.bloomIndexer.Start(eth.blockchain)
 
 if config.TxPool.Journal != "" {
- config.TxPool.Journal = ctx.ResolvePath(config.TxPool.Journal)
+ config.TxPool.Journal = stack.ResolvePath(config.TxPool.Journal)
 }
 eth.txPool = core.NewTxPool(config.TxPool, chainConfig, eth.blockchain)
 
 //// Permit the downloader to use the trie cache allowance during fast sync
- //cacheLimit := cacheConfig.TrieCleanLimit + cacheConfig.TrieDirtyLimit
+ //cacheLimit := cacheConfig.TrieCleanLimit + cacheConfig.TrieDirtyLimit + cacheConfig.SnapshotLimit
 //checkpoint := config.Checkpoint
 //if checkpoint == nil {
 // checkpoint = params.TrustedCheckpoints[genesisHash]
@@ -231,13 +216,25 @@ func New(ctx *node.ServiceContext, config *Config,
 eth.miner = miner.New(eth, &config.Miner, chainConfig, eth.EventMux(), eth.engine, eth.isLocalBlock, mcb)
 eth.miner.SetExtra(makeExtraData(config.Miner.ExtraData))
 
- eth.APIBackend = &EthAPIBackend{ctx.ExtRPCEnabled(), eth, nil}
+ eth.APIBackend = &EthAPIBackend{stack.Config().ExtRPCEnabled(), eth, nil}
 gpoParams := config.GPO
 if gpoParams.Default == nil {
 gpoParams.Default = config.Miner.GasPrice
 }
 eth.APIBackend.gpo = gasprice.NewOracle(eth.APIBackend, gpoParams)
 
+ //eth.dialCandidates, err = eth.setupDiscovery(&stack.Config().P2P)
+ if err != nil {
+ return nil, err
+ }
+
+ // Start the RPC service
+ eth.netRPCService = ethapi.NewPublicNetAPI(eth.p2pServer, eth.NetVersion())
+
+ // Register the backend on the node
+ stack.RegisterAPIs(eth.APIs())
+ //stack.RegisterProtocols(eth.Protocols())
+ //stack.RegisterLifecycle(eth)
 return eth, nil
 }
 
@@ -259,7 +256,7 @@ func makeExtraData(extra []byte) []byte {
 }
 
 // CreateConsensusEngine creates the required type of consensus engine instance for an Ethereum service
-func CreateConsensusEngine(ctx *node.ServiceContext, chainConfig *params.ChainConfig, config *ethash.Config, notify []string, noverify bool, db ethdb.Database, cb *dummy.ConsensusCallbacks) consensus.Engine {
+func CreateConsensusEngine(stack *node.Node, chainConfig *params.ChainConfig, config *ethash.Config, notify []string, noverify bool, db ethdb.Database, cb *dummy.ConsensusCallbacks) consensus.Engine {
 return dummy.NewDummyEngine(cb)
 }
 
@@ -268,18 +265,9 @@ func CreateConsensusEngine(ctx *node.ServiceContext, chainConfig *params.ChainCo
 func (s *Ethereum) APIs() []rpc.API {
 apis := ethapi.GetAPIs(s.APIBackend)
 
- // Append any APIs exposed explicitly by the les server
- if s.lesServer != nil {
- apis = append(apis, s.lesServer.APIs()...)
- }
 // Append any APIs exposed explicitly by the consensus engine
 apis = append(apis, s.engine.APIs(s.BlockChain())...)
 
- // Append any APIs exposed explicitly by the les server
- if s.lesServer != nil {
- apis = append(apis, s.lesServer.APIs()...)
- }
-
 // Append all the local APIs and return
 return append(apis, []rpc.API{
 {
@@ -487,77 +475,68 @@ func (s *Ethereum) NetVersion() uint64 { return s.networkID }
 func (s *Ethereum) Downloader() *downloader.Downloader { return nil } // s.protocolManager.downloader }
 func (s *Ethereum) Synced() bool { return true } // atomic.LoadUint32(&s.protocolManager.acceptTxs) == 1 }
 func (s *Ethereum) ArchiveMode() bool { return s.config.NoPruning }
+func (s *Ethereum) BloomIndexer() *core.ChainIndexer { return s.bloomIndexer }
 
-// Protocols implements node.Service, returning all the currently configured
+// Protocols returns all the currently configured
 // network protocols to start.
 func (s *Ethereum) Protocols() []p2p.Protocol {
 protos := make([]p2p.Protocol, len(ProtocolVersions))
 //for i, vsn := range ProtocolVersions {
 // protos[i] = s.protocolManager.makeProtocol(vsn)
 // protos[i].Attributes = []enr.Entry{s.currentEthEntry()}
- //}
- //if s.lesServer != nil {
- // protos = append(protos, s.lesServer.Protocols()...)
+ // protos[i].DialCandidates = s.dialCandidates
 //}
 return protos
 }
 
-// Start implements node.Service, starting all internal goroutines needed by the
+// Start implements node.Lifecycle, starting all internal goroutines needed by the
 // Ethereum protocol implementation.
-func (s *Ethereum) Start(srvr *p2p.Server) error {
- //s.startEthEntryUpdate(srvr.LocalNode())
+func (s *Ethereum) Start() error {
+ //s.startEthEntryUpdate(s.p2pServer.LocalNode())
 
 // Start the bloom bits servicing goroutines
 s.startBloomHandlers(params.BloomBitsBlocks)
 
- // Start the RPC service
- s.netRPCService = ethapi.NewPublicNetAPI(srvr, s.NetVersion())
-
 // Figure out a max peers count based on the server limits
- maxPeers := srvr.MaxPeers
+ maxPeers := s.p2pServer.MaxPeers
 if s.config.LightServ > 0 {
- if s.config.LightPeers >= srvr.MaxPeers {
- return fmt.Errorf("invalid peer config: light peer count (%d) >= total peer count (%d)", s.config.LightPeers, srvr.MaxPeers)
+ if s.config.LightPeers >= s.p2pServer.MaxPeers {
+ return fmt.Errorf("invalid peer config: light peer count (%d) >= total peer count (%d)", s.config.LightPeers, s.p2pServer.MaxPeers)
 }
 maxPeers -= s.config.LightPeers
 }
 // Start the networking layer and the light server if requested
 //s.protocolManager.Start(maxPeers)
- //if s.lesServer != nil {
- // s.lesServer.Start(srvr)
- //}
 return nil
 }
 
-// Stop implements node.Service, terminating all internal goroutines used by the
+// Stop implements node.Lifecycle, terminating all internal goroutines used by the
 // Ethereum protocol.
 func (s *Ethereum) Stop() error {
- s.bloomIndexer.Close()
- s.blockchain.Stop()
- s.engine.Close()
+ // Stop all the peer-related stuff first.
 //s.protocolManager.Stop()
- //if s.lesServer != nil {
- // s.lesServer.Stop()
- //}
+
+ // Then stop everything else.
+ s.bloomIndexer.Close()
+ close(s.closeBloomHandler)
 s.txPool.Stop()
 s.miner.Stop()
- s.eventMux.Stop()
-
+ s.blockchain.Stop()
+ s.engine.Close()
 s.chainDb.Close()
- close(s.shutdownChan)
+ s.eventMux.Stop()
 return nil
 }
 
 func (s *Ethereum) StopPart() error {
 s.bloomIndexer.Close()
- s.blockchain.Stop()
- s.engine.Close()
+ close(s.closeBloomHandler)
 s.txPool.Stop()
 s.miner.Stop()
- s.eventMux.Stop()
-
+ s.blockchain.Stop()
+ s.engine.Close()
 s.chainDb.Close()
- close(s.shutdownChan)
+ s.eventMux.Stop()
 return nil
 }
 
diff --git a/eth/bloombits.go b/eth/bloombits.go
index 7136c29..a6b51a2 100644
--- a/eth/bloombits.go
+++ b/eth/bloombits.go
@@ -24,9 +24,9 @@ import (
 "github.com/ava-labs/coreth/core/bloombits"
 "github.com/ava-labs/coreth/core/rawdb"
 "github.com/ava-labs/coreth/core/types"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/bitutil"
- "github.com/ava-labs/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/bitutil"
+ "github.com/ethereum/go-ethereum/ethdb"
 )
 
 const (
@@ -54,7 +54,7 @@ func (eth *Ethereum) startBloomHandlers(sectionSize uint64) {
 go func() {
 for {
 select {
- case <-eth.shutdownChan:
+ case <-eth.closeBloomHandler:
 return
 
 case request := <-eth.bloomRequests:
@@ -136,3 +136,8 @@ func (b *BloomIndexer) Commit() error {
 }
 return batch.Write()
 }
+
+// Prune returns an empty error since we don't support pruning here.
+func (b *BloomIndexer) Prune(threshold uint64) error {
+ return nil
+}
diff --git a/eth/config.go b/eth/config.go
index 18dbd8e..5354ca1 100644
--- a/eth/config.go
+++ b/eth/config.go
@@ -30,39 +30,58 @@ import (
 "github.com/ava-labs/coreth/eth/gasprice"
 "github.com/ava-labs/coreth/miner"
 "github.com/ava-labs/coreth/params"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/hexutil"
- "github.com/ava-labs/go-ethereum/eth/downloader"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/eth/downloader"
 )
 
+// DefaultFullGPOConfig contains default gasprice oracle settings for full node.
+var DefaultFullGPOConfig = gasprice.Config{
+ Blocks: 20,
+ Percentile: 60,
+ MaxPrice: gasprice.DefaultMaxPrice,
+}
+
+// DefaultLightGPOConfig contains default gasprice oracle settings for light client.
+var DefaultLightGPOConfig = gasprice.Config{
+ Blocks: 2,
+ Percentile: 60,
+ MaxPrice: gasprice.DefaultMaxPrice,
+}
+
 // DefaultConfig contains default settings for use on the Ethereum main net.
 var DefaultConfig = Config{
 SyncMode: downloader.FastSync,
 Ethash: ethash.Config{
- CacheDir: "ethash",
- CachesInMem: 2,
- CachesOnDisk: 3,
- DatasetsInMem: 1,
- DatasetsOnDisk: 2,
+ CacheDir: "ethash",
+ CachesInMem: 2,
+ CachesOnDisk: 3,
+ CachesLockMmap: false,
+ DatasetsInMem: 1,
+ DatasetsOnDisk: 2,
+ DatasetsLockMmap: false,
 },
- NetworkId: 1,
- LightPeers: 100,
- UltraLightFraction: 75,
- DatabaseCache: 512,
- TrieCleanCache: 256,
- TrieDirtyCache: 256,
- TrieTimeout: 60 * time.Minute,
+ NetworkId: 1,
+ LightPeers: 100,
+ UltraLightFraction: 75,
+ DatabaseCache: 512,
+ TrieCleanCache: 154,
+ TrieCleanCacheJournal: "triecache",
+ TrieCleanCacheRejournal: 60 * time.Minute,
+ TrieDirtyCache: 256,
+ TrieTimeout: 60 * time.Minute,
+ SnapshotCache: 102,
 Miner: miner.Config{
 GasFloor: 8000000,
 GasCeil: 8000000,
 GasPrice: big.NewInt(params.GWei),
 Recommit: 3 * time.Second,
 },
- TxPool: core.DefaultTxPoolConfig,
- GPO: gasprice.Config{
- Blocks: 20,
- Percentile: 60,
- },
+ TxPool: core.DefaultTxPoolConfig,
+ RPCGasCap: 25000000,
+ GPO: DefaultFullGPOConfig,
+ RPCTxFeeCap: 1, // 1 ether
+
 ManualCanonical: false,
 }
 
@@ -98,17 +117,24 @@ type Config struct {
 NetworkId uint64 // Network ID to use for selecting peers to connect to
 SyncMode downloader.SyncMode
 
+ // This can be set to list of enrtree:// URLs which will be queried for
+ // for nodes to connect to.
+ DiscoveryURLs []string
+
 NoPruning bool // Whether to disable pruning and flush everything to disk
 NoPrefetch bool // Whether to disable prefetching and only load state on demand
 
+ TxLookupLimit uint64 `toml:",omitempty"` // The maximum number of blocks from head whose tx indices are reserved.
+
 // Whitelist of required block number -> hash values to accept
 Whitelist map[uint64]common.Hash `toml:"-"`
 
 // Light client options
- LightServ int `toml:",omitempty"` // Maximum percentage of time allowed for serving LES requests
- LightIngress int `toml:",omitempty"` // Incoming bandwidth limit for light servers
- LightEgress int `toml:",omitempty"` // Outgoing bandwidth limit for light servers
- LightPeers int `toml:",omitempty"` // Maximum number of LES client peers
+ LightServ int `toml:",omitempty"` // Maximum percentage of time allowed for serving LES requests
+ LightIngress int `toml:",omitempty"` // Incoming bandwidth limit for light servers
+ LightEgress int `toml:",omitempty"` // Outgoing bandwidth limit for light servers
+ LightPeers int `toml:",omitempty"` // Maximum number of LES client peers
+ LightNoPrune bool `toml:",omitempty"` // Whether to disable light chain pruning
 
 // Ultra Light client options
 UltraLightServers []string `toml:",omitempty"` // List of trusted ultra light servers
@@ -121,9 +147,12 @@ type Config struct {
 DatabaseCache int
 DatabaseFreezer string
 
- TrieCleanCache int
- TrieDirtyCache int
- TrieTimeout time.Duration
+ TrieCleanCache int
+ TrieCleanCacheJournal string `toml:",omitempty"` // Disk journal directory for trie cache to survive node restarts
+ TrieCleanCacheRejournal time.Duration `toml:",omitempty"` // Time interval to regenerate the journal for clean cache
+ TrieDirtyCache int
+ TrieTimeout time.Duration
+ SnapshotCache int
 
 // Mining options
 Miner miner.Config
@@ -150,7 +179,11 @@ type Config struct {
 EVMInterpreter string
 
 // RPCGasCap is the global gas cap for eth-call variants.
- RPCGasCap *big.Int `toml:",omitempty"`
+ RPCGasCap uint64 `toml:",omitempty"`
+
+ // RPCTxFeeCap is the global transaction fee(price * gaslimit) cap for
+ // send-transction variants. The unit is ether.
+ RPCTxFeeCap float64 `toml:",omitempty"`
 
 // Checkpoint is a hardcoded checkpoint which can be nil.
 Checkpoint *params.TrustedCheckpoint `toml:",omitempty"`
@@ -158,9 +191,6 @@ type Config struct {
 // CheckpointOracle is the configuration for checkpoint oracle.
 CheckpointOracle *params.CheckpointOracleConfig `toml:",omitempty"`
 
- // Istanbul block override (TODO: remove after the fork)
- OverrideIstanbul *big.Int
-
 // Manually select and grow the canonical chain
 ManualCanonical bool
 }
@@ -191,7 +221,7 @@ func MyDefaultConfig() Config {
 ByzantiumBlock: big.NewInt(0),
 ConstantinopleBlock: big.NewInt(0),
 PetersburgBlock: big.NewInt(0),
- IstanbulBlock: nil,
+ IstanbulBlock: big.NewInt(0),
 Ethash: nil,
 }
 genBalance := big.NewInt(1000000000000000000)
diff --git a/eth/filters/api.go b/eth/filters/api.go
index a1d0b21..71e6454 100644
--- a/eth/filters/api.go
+++ b/eth/filters/api.go
@@ -27,11 +27,11 @@ import (
 
 "github.com/ava-labs/coreth/core/types"
 "github.com/ava-labs/coreth/rpc"
- ethereum "github.com/ava-labs/go-ethereum"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/hexutil"
- "github.com/ava-labs/go-ethereum/ethdb"
- "github.com/ava-labs/go-ethereum/event"
+ ethereum "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/event"
 )
 
 var (
@@ -65,9 +65,8 @@ type PublicFilterAPI struct {
 func NewPublicFilterAPI(backend Backend, lightMode bool) *PublicFilterAPI {
 api := &PublicFilterAPI{
 backend: backend,
- mux: backend.EventMux(),
 chainDb: backend.ChainDb(),
- events: NewEventSystem(backend.EventMux(), backend, lightMode),
+ events: NewEventSystem(backend, lightMode),
 filters: make(map[rpc.ID]*filter),
 }
 go api.timeoutLoop()
@@ -79,6 +78,7 @@ func NewPublicFilterAPI(backend Backend, lightMode bool) *PublicFilterAPI {
 // Tt is started when the api is created.
 func (api *PublicFilterAPI) timeoutLoop() {
 ticker := time.NewTicker(5 * time.Minute)
+ defer ticker.Stop()
 for {
 <-ticker.C
 api.filtersMu.Lock()
@@ -428,7 +428,7 @@ func (api *PublicFilterAPI) GetFilterChanges(id rpc.ID) (interface{}, error) {
 hashes := f.hashes
 f.hashes = nil
 return returnHashes(hashes), nil
- case LogsSubscription:
+ case LogsSubscription, MinedAndPendingLogsSubscription:
 logs := f.logs
 f.logs = nil
 return returnLogs(logs), nil
diff --git a/eth/filters/filter.go b/eth/filters/filter.go
index 6d4a74d..48a76c7 100644
--- a/eth/filters/filter.go
+++ b/eth/filters/filter.go
@@ -22,17 +22,16 @@ import (
 "math/big"
 
 "github.com/ava-labs/coreth/core"
+ "github.com/ava-labs/coreth/core/bloombits"
 "github.com/ava-labs/coreth/core/types"
 "github.com/ava-labs/coreth/rpc"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/core/bloombits"
- "github.com/ava-labs/go-ethereum/ethdb"
- "github.com/ava-labs/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/event"
 )
 
 type Backend interface {
 ChainDb() ethdb.Database
- EventMux() *event.TypeMux
 HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Header, error)
 HeaderByHash(ctx context.Context, blockHash common.Hash) (*types.Header, error)
 GetReceipts(ctx context.Context, blockHash common.Hash) (types.Receipts, error)
@@ -42,6 +41,7 @@ type Backend interface {
 SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription
 SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription
 SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription
+ SubscribePendingLogsEvent(ch chan<- []*types.Log) event.Subscription
 
 BloomStatus() (uint64, uint64)
 ServiceFilter(ctx context.Context, session *bloombits.MatcherSession)
@@ -210,7 +210,7 @@ func (f *Filter) indexedLogs(ctx context.Context, end uint64) ([]*types.Log, err
 }
 }
 
-// indexedLogs returns the logs matching the filter criteria based on raw block
+// unindexedLogs returns the logs matching the filter criteria based on raw block
 // iteration and bloom matching.
 func (f *Filter) unindexedLogs(ctx context.Context, end uint64) ([]*types.Log, error) {
 var logs []*types.Log
diff --git a/eth/filters/filter_system.go b/eth/filters/filter_system.go
index 41427c7..1c0f1bf 100644
--- a/eth/filters/filter_system.go
+++ b/eth/filters/filter_system.go
@@ -20,7 +20,6 @@ package filters
 
 import (
 "context"
- "errors"
 "fmt"
 "sync"
 "time"
@@ -29,10 +28,10 @@ import (
 "github.com/ava-labs/coreth/core/rawdb"
 "github.com/ava-labs/coreth/core/types"
 "github.com/ava-labs/coreth/rpc"
- ethereum "github.com/ava-labs/go-ethereum"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/event"
- "github.com/ava-labs/go-ethereum/log"
+ ethereum "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/log"
 )
 
 // Type determines the kind of filter and is used to put the filter in to
@@ -58,7 +57,6 @@ const (
 )
 
 const (
-
 // txChanSize is the size of channel listening to NewTxsEvent.
 // The number is referenced from the size of tx pool.
 txChanSize = 4096
@@ -70,10 +68,6 @@ const (
 chainEvChanSize = 10
 )
 
-var (
- ErrInvalidSubscriptionID = errors.New("invalid id")
-)
-
 type subscription struct {
 id rpc.ID
 typ Type
@@ -89,25 +83,25 @@ type subscription struct {
 // EventSystem creates subscriptions, processes events and broadcasts them to the
 // subscription which match the subscription criteria.
 type EventSystem struct {
- mux *event.TypeMux
 backend Backend
 lightMode bool
 lastHead *types.Header
 
 // Subscriptions
- txsSub event.Subscription // Subscription for new transaction event
- logsSub event.Subscription // Subscription for new log event
- rmLogsSub event.Subscription // Subscription for removed log event
- chainSub event.Subscription // Subscription for new chain event
- pendingLogSub *event.TypeMuxSubscription // Subscription for pending log event
+ txsSub event.Subscription // Subscription for new transaction event
+ logsSub event.Subscription // Subscription for new log event
+ rmLogsSub event.Subscription // Subscription for removed log event
+ pendingLogsSub event.Subscription // Subscription for pending log event
+ chainSub event.Subscription // Subscription for new chain event
 
 // Channels
- install chan *subscription // install filter for event notification
- uninstall chan *subscription // remove filter for event notification
- txsCh chan core.NewTxsEvent // Channel to receive new transactions event
- logsCh chan []*types.Log // Channel to receive new log event
- rmLogsCh chan core.RemovedLogsEvent // Channel to receive removed log event
- chainCh chan core.ChainEvent // Channel to receive new chain event
+ install chan *subscription // install filter for event notification
+ uninstall chan *subscription // remove filter for event notification
+ txsCh chan core.NewTxsEvent // Channel to receive new transactions event
+ logsCh chan []*types.Log // Channel to receive new log event
+ pendingLogsCh chan []*types.Log // Channel to receive new log event
+ rmLogsCh chan core.RemovedLogsEvent // Channel to receive removed log event
+ chainCh chan core.ChainEvent // Channel to receive new chain event
 }
 
 // NewEventSystem creates a new manager that listens for event on the given mux,
@@ -116,17 +110,17 @@ type EventSystem struct {
 //
 // The returned manager has a loop that needs to be stopped with the Stop function
 // or by stopping the given mux.
-func NewEventSystem(mux *event.TypeMux, backend Backend, lightMode bool) *EventSystem {
+func NewEventSystem(backend Backend, lightMode bool) *EventSystem {
 m := &EventSystem{
- mux: mux,
- backend: backend,
- lightMode: lightMode,
- install: make(chan *subscription),
- uninstall: make(chan *subscription),
- txsCh: make(chan core.NewTxsEvent, txChanSize),
- logsCh: make(chan []*types.Log, logsChanSize),
- rmLogsCh: make(chan core.RemovedLogsEvent, rmLogsChanSize),
- chainCh: make(chan core.ChainEvent, chainEvChanSize),
+ backend: backend,
+ lightMode: lightMode,
+ install: make(chan *subscription),
+ uninstall: make(chan *subscription),
+ txsCh: make(chan core.NewTxsEvent, txChanSize),
+ logsCh: make(chan []*types.Log, logsChanSize),
+ rmLogsCh: make(chan core.RemovedLogsEvent, rmLogsChanSize),
+ pendingLogsCh: make(chan []*types.Log, logsChanSize),
+ chainCh: make(chan core.ChainEvent, chainEvChanSize),
 }
 
 // Subscribe events
@@ -134,12 +128,10 @@ func NewEventSystem(mux *event.TypeMux, backend Backend, lightMode bool) *EventS
 m.logsSub = m.backend.SubscribeLogsEvent(m.logsCh)
 m.rmLogsSub = m.backend.SubscribeRemovedLogsEvent(m.rmLogsCh)
 m.chainSub = m.backend.SubscribeChainEvent(m.chainCh)
- // TODO(rjl493456442): use feed to subscribe pending log event
- m.pendingLogSub = m.mux.Subscribe(core.PendingLogsEvent{})
+ m.pendingLogsSub = m.backend.SubscribePendingLogsEvent(m.pendingLogsCh)
 
 // Make sure none of the subscriptions are empty
- if m.txsSub == nil || m.logsSub == nil || m.rmLogsSub == nil || m.chainSub == nil ||
- m.pendingLogSub.Closed() {
+ if m.txsSub == nil || m.logsSub == nil || m.rmLogsSub == nil || m.chainSub == nil || m.pendingLogsSub == nil {
 log.Crit("Subscribe for event system failed")
 }
 
@@ -316,58 +308,61 @@ func (es *EventSystem) SubscribePendingTxs(hashes chan []common.Hash) *Subscript
 
 type filterIndex map[Type]map[rpc.ID]*subscription
 
-// broadcast event to filters that match criteria.
-func (es *EventSystem) broadcast(filters filterIndex, ev interface{}) {
- if ev == nil {
+func (es *EventSystem) handleLogs(filters filterIndex, ev []*types.Log) {
+ if len(ev) == 0 {
 return
 }
+ for _, f := range filters[LogsSubscription] {
+ matchedLogs := filterLogs(ev, f.logsCrit.FromBlock, f.logsCrit.ToBlock, f.logsCrit.Addresses, f.logsCrit.Topics)
+ if len(matchedLogs) > 0 {
+ f.logs <- matchedLogs
+ }
+ }
+}
 
- switch e := ev.(type) {
- case []*types.Log:
- if len(e) > 0 {
- for _, f := range filters[LogsSubscription] {
- if matchedLogs := filterLogs(e, f.logsCrit.FromBlock, f.logsCrit.ToBlock, f.logsCrit.Addresses, f.logsCrit.Topics); len(matchedLogs) > 0 {
- f.logs <- matchedLogs
- }
- }
+func (es *EventSystem) handlePendingLogs(filters filterIndex, ev []*types.Log) {
+ if len(ev) == 0 {
+ return
+ }
+ for _, f := range filters[PendingLogsSubscription] {
+ matchedLogs := filterLogs(ev, nil, f.logsCrit.ToBlock, f.logsCrit.Addresses, f.logsCrit.Topics)
+ if len(matchedLogs) > 0 {
+ f.logs <- matchedLogs
 }
- case core.RemovedLogsEvent:
- for _, f := range filters[LogsSubscription] {
- if matchedLogs := filterLogs(e.Logs, f.logsCrit.FromBlock, f.logsCrit.ToBlock, f.logsCrit.Addresses, f.logsCrit.Topics); len(matchedLogs) > 0 {
- f.logs <- matchedLogs
- }
+ }
+}
+
+func (es *EventSystem) handleRemovedLogs(filters filterIndex, ev core.RemovedLogsEvent) {
+ for _, f := range filters[LogsSubscription] {
+ matchedLogs := filterLogs(ev.Logs, f.logsCrit.FromBlock, f.logsCrit.ToBlock, f.logsCrit.Addresses, f.logsCrit.Topics)
+ if len(matchedLogs) > 0 {
+ f.logs <- matchedLogs
 }
- case *event.TypeMuxEvent:
- if muxe, ok := e.Data.(core.PendingLogsEvent); ok {
- for _, f := range filters[PendingLogsSubscription] {
- if e.Time.After(f.created) {
- if matchedLogs := filterLogs(muxe.Logs, nil, f.logsCrit.ToBlock, f.logsCrit.Addresses, f.logsCrit.Topics); len(matchedLogs) > 0 {
- f.logs <- matchedLogs
- }
+ }
+}
+
+func (es *EventSystem) handleTxsEvent(filters filterIndex, ev core.NewTxsEvent) {
+ hashes := make([]common.Hash, 0, len(ev.Txs))
+ for _, tx := range ev.Txs {
+ hashes = append(hashes, tx.Hash())
+ }
+ for _, f := range filters[PendingTransactionsSubscription] {
+ f.hashes <- hashes
+ }
+}
+
+func (es *EventSystem) handleChainEvent(filters filterIndex, ev core.ChainEvent) {
+ for _, f := range filters[BlocksSubscription] {
+ f.headers <- ev.Block.Header()
+ }
+ if es.lightMode && len(filters[LogsSubscription]) > 0 {
+ es.lightFilterNewHead(ev.Block.Header(), func(header *types.Header, remove bool) {
+ for _, f := range filters[LogsSubscription] {
+ if matchedLogs := es.lightFilterLogs(header, f.logsCrit.Addresses, f.logsCrit.Topics, remove); len(matchedLogs) > 0 {
+ f.logs <- matchedLogs
 }
 }
- }
- case core.NewTxsEvent:
- hashes := make([]common.Hash, 0, len(e.Txs))
- for _, tx := range e.Txs {
- hashes = append(hashes, tx.Hash())
- }
- for _, f := range filters[PendingTransactionsSubscription] {
- f.hashes <- hashes
- }
- case core.ChainEvent:
- for _, f := range filters[BlocksSubscription] {
- f.headers <- e.Block.Header()
- }
- if es.lightMode && len(filters[LogsSubscription]) > 0 {
- es.lightFilterNewHead(e.Block.Header(), func(header *types.Header, remove bool) {
- for _, f := range filters[LogsSubscription] {
- if matchedLogs := es.lightFilterLogs(header, f.logsCrit.Addresses, f.logsCrit.Topics, remove); len(matchedLogs) > 0 {
- f.logs <- matchedLogs
- }
- }
- })
- }
+ })
 }
 }
 
@@ -448,10 +443,10 @@ func (es *EventSystem) lightFilterLogs(header *types.Header, addresses []common.
 func (es *EventSystem) eventLoop() {
 // Ensure all subscriptions get cleaned up
 defer func() {
- es.pendingLogSub.Unsubscribe()
 es.txsSub.Unsubscribe()
 es.logsSub.Unsubscribe()
 es.rmLogsSub.Unsubscribe()
+ es.pendingLogsSub.Unsubscribe()
 es.chainSub.Unsubscribe()
 }()
 
@@ -462,20 +457,16 @@ func (es *EventSystem) eventLoop() {
 
 for {
 select {
- // Handle subscribed events
 case ev := <-es.txsCh:
- es.broadcast(index, ev)
+ es.handleTxsEvent(index, ev)
 case ev := <-es.logsCh:
- es.broadcast(index, ev)
+ es.handleLogs(index, ev)
 case ev := <-es.rmLogsCh:
- es.broadcast(index, ev)
+ es.handleRemovedLogs(index, ev)
+ case ev := <-es.pendingLogsCh:
+ es.handlePendingLogs(index, ev)
 case ev := <-es.chainCh:
- es.broadcast(index, ev)
- case ev, active := <-es.pendingLogSub.Chan():
- if !active { // system stopped
- return
- }
- es.broadcast(index, ev)
+ es.handleChainEvent(index, ev)
 
 case f := <-es.install:
 if f.typ == MinedAndPendingLogsSubscription {
diff --git a/eth/gasprice/gasprice.go b/eth/gasprice/gasprice.go
index 23e49a6..14f50b1 100644
--- a/eth/gasprice/gasprice.go
+++ b/eth/gasprice/gasprice.go
@@ -23,123 +23,144 @@ import (
 "sync"
 
 "github.com/ava-labs/coreth/core/types"
- "github.com/ava-labs/coreth/internal/ethapi"
 "github.com/ava-labs/coreth/params"
 "github.com/ava-labs/coreth/rpc"
- "github.com/ava-labs/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/log"
 )
 
-var maxPrice = big.NewInt(500 * params.GWei)
+const sampleNumber = 3 // Number of transactions sampled in a block
+
+var DefaultMaxPrice = big.NewInt(500 * params.GWei)
 
 type Config struct {
 Blocks int
 Percentile int
 Default *big.Int `toml:",omitempty"`
+ MaxPrice *big.Int `toml:",omitempty"`
+}
+
+// OracleBackend includes all necessary background APIs for oracle.
+type OracleBackend interface {
+ HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error)
+ BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error)
+ ChainConfig() *params.ChainConfig
 }
 
 // Oracle recommends gas prices based on the content of recent
 // blocks. Suitable for both light and full clients.
 type Oracle struct {
- backend ethapi.Backend
+ backend OracleBackend
 lastHead common.Hash
 lastPrice *big.Int
+ maxPrice *big.Int
 cacheLock sync.RWMutex
 fetchLock sync.Mutex
 
- checkBlocks, maxEmpty, maxBlocks int
- percentile int
+ checkBlocks int
+ percentile int
 }
 
-// NewOracle returns a new oracle.
-func NewOracle(backend ethapi.Backend, params Config) *Oracle {
+// NewOracle returns a new gasprice oracle which can recommend suitable
+// gasprice for newly created transaction.
+func NewOracle(backend OracleBackend, params Config) *Oracle {
 blocks := params.Blocks
 if blocks < 1 {
 blocks = 1
+ log.Warn("Sanitizing invalid gasprice oracle sample blocks", "provided", params.Blocks, "updated", blocks)
 }
 percent := params.Percentile
 if percent < 0 {
 percent = 0
+ log.Warn("Sanitizing invalid gasprice oracle sample percentile", "provided", params.Percentile, "updated", percent)
 }
 if percent > 100 {
 percent = 100
+ log.Warn("Sanitizing invalid gasprice oracle sample percentile", "provided", params.Percentile, "updated", percent)
+ }
+ maxPrice := params.MaxPrice
+ if maxPrice == nil || maxPrice.Int64() <= 0 {
+ maxPrice = DefaultMaxPrice
+ log.Warn("Sanitizing invalid gasprice oracle price cap", "provided", params.MaxPrice, "updated", maxPrice)
 }
 return &Oracle{
 backend: backend,
 lastPrice: params.Default,
+ maxPrice: maxPrice,
 checkBlocks: blocks,
- maxEmpty: blocks / 2,
- maxBlocks: blocks * 5,
 percentile: percent,
 }
 }
 
-// SuggestPrice returns the recommended gas price.
+// SuggestPrice returns a gasprice so that newly created transaction can
+// have a very high chance to be included in the following blocks.
 func (gpo *Oracle) SuggestPrice(ctx context.Context) (*big.Int, error) {
- gpo.cacheLock.RLock()
- lastHead := gpo.lastHead
- lastPrice := gpo.lastPrice
- gpo.cacheLock.RUnlock()
-
 head, _ := gpo.backend.HeaderByNumber(ctx, rpc.LatestBlockNumber)
 headHash := head.Hash()
+
+ // If the latest gasprice is still available, return it.
+ gpo.cacheLock.RLock()
+ lastHead, lastPrice := gpo.lastHead, gpo.lastPrice
+ gpo.cacheLock.RUnlock()
 if headHash == lastHead {
 return lastPrice, nil
 }
-
 gpo.fetchLock.Lock()
 defer gpo.fetchLock.Unlock()
 
- // try checking the cache again, maybe the last fetch fetched what we need
+ // Try checking the cache again, maybe the last fetch fetched what we need
 gpo.cacheLock.RLock()
- lastHead = gpo.lastHead
- lastPrice = gpo.lastPrice
+ lastHead, lastPrice = gpo.lastHead, gpo.lastPrice
 gpo.cacheLock.RUnlock()
 if headHash == lastHead {
 return lastPrice, nil
 }
-
- blockNum := head.Number.Uint64()
- ch := make(chan getBlockPricesResult, gpo.checkBlocks)
- sent := 0
- exp := 0
- var blockPrices []*big.Int
- for sent < gpo.checkBlocks && blockNum > 0 {
- go gpo.getBlockPrices(ctx, types.MakeSigner(gpo.backend.ChainConfig(), big.NewInt(int64(blockNum))), blockNum, ch)
+ var (
+ sent, exp int
+ number = head.Number.Uint64()
+ result = make(chan getBlockPricesResult, gpo.checkBlocks)
+ quit = make(chan struct{})
+ txPrices []*big.Int
+ )
+ for sent < gpo.checkBlocks && number > 0 {
+ go gpo.getBlockPrices(ctx, types.MakeSigner(gpo.backend.ChainConfig(), big.NewInt(int64(number))), number, sampleNumber, result, quit)
 sent++
 exp++
- blockNum--
+ number--
 }
- maxEmpty := gpo.maxEmpty
 for exp > 0 {
- res := <-ch
+ res := <-result
 if res.err != nil {
+ close(quit)
 return lastPrice, res.err
 }
 exp--
- if res.price != nil {
- blockPrices = append(blockPrices, res.price)
- continue
- }
- if maxEmpty > 0 {
- maxEmpty--
- continue
+ // Nothing returned. There are two special cases here:
+ // - The block is empty
+ // - All the transactions included are sent by the miner itself.
+ // In these cases, use the latest calculated price for samping.
+ if len(res.prices) == 0 {
+ res.prices = []*big.Int{lastPrice}
 }
- if blockNum > 0 && sent < gpo.maxBlocks {
- go gpo.getBlockPrices(ctx, types.MakeSigner(gpo.backend.ChainConfig(), big.NewInt(int64(blockNum))), blockNum, ch)
+ // Besides, in order to collect enough data for sampling, if nothing
+ // meaningful returned, try to query more blocks. But the maximum
+ // is 2*checkBlocks.
+ if len(res.prices) == 1 && len(txPrices)+1+exp < gpo.checkBlocks*2 && number > 0 {
+ go gpo.getBlockPrices(ctx, types.MakeSigner(gpo.backend.ChainConfig(), big.NewInt(int64(number))), number, sampleNumber, result, quit)
 sent++
 exp++
- blockNum--
+ number--
 }
+ txPrices = append(txPrices, res.prices...)
 }
 price := lastPrice
- if len(blockPrices) > 0 {
- sort.Sort(bigIntArray(blockPrices))
- price = blockPrices[(len(blockPrices)-1)*gpo.percentile/100]
+ if len(txPrices) > 0 {
+ sort.Sort(bigIntArray(txPrices))
+ price = txPrices[(len(txPrices)-1)*gpo.percentile/100]
 }
- if price.Cmp(maxPrice) > 0 {
- price = new(big.Int).Set(maxPrice)
+ if price.Cmp(gpo.maxPrice) > 0 {
+ price = new(big.Int).Set(gpo.maxPrice)
 }
-
 gpo.cacheLock.Lock()
 gpo.lastHead = headHash
 gpo.lastPrice = price
@@ -148,38 +169,48 @@ func (gpo *Oracle) SuggestPrice(ctx context.Context) (*big.Int, error) {
 }
 
 type getBlockPricesResult struct {
- price *big.Int
- err error
+ prices []*big.Int
+ err error
 }
 
 type transactionsByGasPrice []*types.Transaction
 
 func (t transactionsByGasPrice) Len() int { return len(t) }
 func (t transactionsByGasPrice) Swap(i, j int) { t[i], t[j] = t[j], t[i] }
-func (t transactionsByGasPrice) Less(i, j int) bool { return t[i].GasPrice().Cmp(t[j].GasPrice()) < 0 }
+func (t transactionsByGasPrice) Less(i, j int) bool { return t[i].GasPriceCmp(t[j]) < 0 }
 
 // getBlockPrices calculates the lowest transaction gas price in a given block
-// and sends it to the result channel. If the block is empty, price is nil.
-func (gpo *Oracle) getBlockPrices(ctx context.Context, signer types.Signer, blockNum uint64, ch chan getBlockPricesResult) {
+// and sends it to the result channel. If the block is empty or all transactions
+// are sent by the miner itself(it doesn't make any sense to include this kind of
+// transaction prices for sampling), nil gasprice is returned.
+func (gpo *Oracle) getBlockPrices(ctx context.Context, signer types.Signer, blockNum uint64, limit int, result chan getBlockPricesResult, quit chan struct{}) {
 block, err := gpo.backend.BlockByNumber(ctx, rpc.BlockNumber(blockNum))
 if block == nil {
- ch <- getBlockPricesResult{nil, err}
+ select {
+ case result <- getBlockPricesResult{nil, err}:
+ case <-quit:
+ }
 return
 }
-
 blockTxs := block.Transactions()
 txs := make([]*types.Transaction, len(blockTxs))
 copy(txs, blockTxs)
 sort.Sort(transactionsByGasPrice(txs))
 
+ var prices []*big.Int
 for _, tx := range txs {
 sender, err := types.Sender(signer, tx)
 if err == nil && sender != block.Coinbase() {
- ch <- getBlockPricesResult{tx.GasPrice(), nil}
- return
+ prices = append(prices, tx.GasPrice())
+ if len(prices) >= limit {
+ break
+ }
 }
 }
- ch <- getBlockPricesResult{nil, nil}
+ select {
+ case result <- getBlockPricesResult{prices, nil}:
+ case <-quit:
+ }
 }
 
 type bigIntArray []*big.Int
diff --git a/eth/gen_config.go b/eth/gen_config.go
index d34f0b3..423d6bb 100644
--- a/eth/gen_config.go
+++ b/eth/gen_config.go
@@ -3,7 +3,6 @@
 package eth
 
 import (
- "math/big"
 "time"
 
 "github.com/ava-labs/coreth/consensus/ethash"
@@ -11,8 +10,8 @@ import (
 "github.com/ava-labs/coreth/eth/gasprice"
 "github.com/ava-labs/coreth/miner"
 "github.com/ava-labs/coreth/params"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/eth/downloader"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/eth/downloader"
 )
 
 // MarshalTOML marshals as TOML.
@@ -21,13 +20,16 @@ func (c Config) MarshalTOML() (interface{}, error) {
 Genesis *core.Genesis `toml:",omitempty"`
 NetworkId uint64
 SyncMode downloader.SyncMode
+ DiscoveryURLs []string
 NoPruning bool
 NoPrefetch bool
+ TxLookupLimit uint64 `toml:",omitempty"`
 Whitelist map[uint64]common.Hash `toml:"-"`
 LightServ int `toml:",omitempty"`
 LightIngress int `toml:",omitempty"`
 LightEgress int `toml:",omitempty"`
 LightPeers int `toml:",omitempty"`
+ LightNoPrune bool `toml:",omitempty"`
 UltraLightServers []string `toml:",omitempty"`
 UltraLightFraction int `toml:",omitempty"`
 UltraLightOnlyAnnounce bool `toml:",omitempty"`
@@ -36,8 +38,11 @@ func (c Config) MarshalTOML() (interface{}, error) {
 DatabaseCache int
 DatabaseFreezer string
 TrieCleanCache int
+ TrieCleanCacheJournal string `toml:",omitempty"`
+ TrieCleanCacheRejournal time.Duration `toml:",omitempty"`
 TrieDirtyCache int
 TrieTimeout time.Duration
+ SnapshotCache int
 Miner miner.Config
 Ethash ethash.Config
 TxPool core.TxPoolConfig
@@ -46,23 +51,26 @@ func (c Config) MarshalTOML() (interface{}, error) {
 DocRoot string `toml:"-"`
 EWASMInterpreter string
 EVMInterpreter string
- RPCGasCap *big.Int `toml:",omitempty"`
+ RPCGasCap uint64 `toml:",omitempty"`
+ RPCTxFeeCap float64 `toml:",omitempty"`
 Checkpoint *params.TrustedCheckpoint `toml:",omitempty"`
 CheckpointOracle *params.CheckpointOracleConfig `toml:",omitempty"`
- OverrideIstanbul *big.Int
 ManualCanonical bool
 }
 var enc Config
 enc.Genesis = c.Genesis
 enc.NetworkId = c.NetworkId
 enc.SyncMode = c.SyncMode
+ enc.DiscoveryURLs = c.DiscoveryURLs
 enc.NoPruning = c.NoPruning
 enc.NoPrefetch = c.NoPrefetch
+ enc.TxLookupLimit = c.TxLookupLimit
 enc.Whitelist = c.Whitelist
 enc.LightServ = c.LightServ
 enc.LightIngress = c.LightIngress
 enc.LightEgress = c.LightEgress
 enc.LightPeers = c.LightPeers
+ enc.LightNoPrune = c.LightNoPrune
 enc.UltraLightServers = c.UltraLightServers
 enc.UltraLightFraction = c.UltraLightFraction
 enc.UltraLightOnlyAnnounce = c.UltraLightOnlyAnnounce
@@ -71,8 +79,11 @@ func (c Config) MarshalTOML() (interface{}, error) {
 enc.DatabaseCache = c.DatabaseCache
 enc.DatabaseFreezer = c.DatabaseFreezer
 enc.TrieCleanCache = c.TrieCleanCache
+ enc.TrieCleanCacheJournal = c.TrieCleanCacheJournal
+ enc.TrieCleanCacheRejournal = c.TrieCleanCacheRejournal
 enc.TrieDirtyCache = c.TrieDirtyCache
 enc.TrieTimeout = c.TrieTimeout
+ enc.SnapshotCache = c.SnapshotCache
 enc.Miner = c.Miner
 enc.Ethash = c.Ethash
 enc.TxPool = c.TxPool
@@ -82,9 +93,9 @@ func (c Config) MarshalTOML() (interface{}, error) {
 enc.EWASMInterpreter = c.EWASMInterpreter
 enc.EVMInterpreter = c.EVMInterpreter
 enc.RPCGasCap = c.RPCGasCap
+ enc.RPCTxFeeCap = c.RPCTxFeeCap
 enc.Checkpoint = c.Checkpoint
 enc.CheckpointOracle = c.CheckpointOracle
- enc.OverrideIstanbul = c.OverrideIstanbul
 enc.ManualCanonical = c.ManualCanonical
 return &enc, nil
 }
@@ -95,13 +106,16 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 Genesis *core.Genesis `toml:",omitempty"`
 NetworkId *uint64
 SyncMode *downloader.SyncMode
+ DiscoveryURLs []string
 NoPruning *bool
 NoPrefetch *bool
+ TxLookupLimit *uint64 `toml:",omitempty"`
 Whitelist map[uint64]common.Hash `toml:"-"`
 LightServ *int `toml:",omitempty"`
 LightIngress *int `toml:",omitempty"`
 LightEgress *int `toml:",omitempty"`
 LightPeers *int `toml:",omitempty"`
+ LightNoPrune *bool `toml:",omitempty"`
 UltraLightServers []string `toml:",omitempty"`
 UltraLightFraction *int `toml:",omitempty"`
 UltraLightOnlyAnnounce *bool `toml:",omitempty"`
@@ -110,8 +124,11 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 DatabaseCache *int
 DatabaseFreezer *string
 TrieCleanCache *int
+ TrieCleanCacheJournal *string `toml:",omitempty"`
+ TrieCleanCacheRejournal *time.Duration `toml:",omitempty"`
 TrieDirtyCache *int
 TrieTimeout *time.Duration
+ SnapshotCache *int
 Miner *miner.Config
 Ethash *ethash.Config
 TxPool *core.TxPoolConfig
@@ -120,10 +137,10 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 DocRoot *string `toml:"-"`
 EWASMInterpreter *string
 EVMInterpreter *string
- RPCGasCap *big.Int `toml:",omitempty"`
+ RPCGasCap *uint64 `toml:",omitempty"`
+ RPCTxFeeCap *float64 `toml:",omitempty"`
 Checkpoint *params.TrustedCheckpoint `toml:",omitempty"`
 CheckpointOracle *params.CheckpointOracleConfig `toml:",omitempty"`
- OverrideIstanbul *big.Int
 ManualCanonical *bool
 }
 var dec Config
@@ -139,12 +156,18 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 if dec.SyncMode != nil {
 c.SyncMode = *dec.SyncMode
 }
+ if dec.DiscoveryURLs != nil {
+ c.DiscoveryURLs = dec.DiscoveryURLs
+ }
 if dec.NoPruning != nil {
 c.NoPruning = *dec.NoPruning
 }
 if dec.NoPrefetch != nil {
 c.NoPrefetch = *dec.NoPrefetch
 }
+ if dec.TxLookupLimit != nil {
+ c.TxLookupLimit = *dec.TxLookupLimit
+ }
 if dec.Whitelist != nil {
 c.Whitelist = dec.Whitelist
 }
@@ -160,6 +183,9 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 if dec.LightPeers != nil {
 c.LightPeers = *dec.LightPeers
 }
+ if dec.LightNoPrune != nil {
+ c.LightNoPrune = *dec.LightNoPrune
+ }
 if dec.UltraLightServers != nil {
 c.UltraLightServers = dec.UltraLightServers
 }
@@ -184,12 +210,21 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 if dec.TrieCleanCache != nil {
 c.TrieCleanCache = *dec.TrieCleanCache
 }
+ if dec.TrieCleanCacheJournal != nil {
+ c.TrieCleanCacheJournal = *dec.TrieCleanCacheJournal
+ }
+ if dec.TrieCleanCacheRejournal != nil {
+ c.TrieCleanCacheRejournal = *dec.TrieCleanCacheRejournal
+ }
 if dec.TrieDirtyCache != nil {
 c.TrieDirtyCache = *dec.TrieDirtyCache
 }
 if dec.TrieTimeout != nil {
 c.TrieTimeout = *dec.TrieTimeout
 }
+ if dec.SnapshotCache != nil {
+ c.SnapshotCache = *dec.SnapshotCache
+ }
 if dec.Miner != nil {
 c.Miner = *dec.Miner
 }
@@ -215,7 +250,10 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 c.EVMInterpreter = *dec.EVMInterpreter
 }
 if dec.RPCGasCap != nil {
- c.RPCGasCap = dec.RPCGasCap
+ c.RPCGasCap = *dec.RPCGasCap
+ }
+ if dec.RPCTxFeeCap != nil {
+ c.RPCTxFeeCap = *dec.RPCTxFeeCap
 }
 if dec.Checkpoint != nil {
 c.Checkpoint = dec.Checkpoint
@@ -223,9 +261,6 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 if dec.CheckpointOracle != nil {
 c.CheckpointOracle = dec.CheckpointOracle
 }
- if dec.OverrideIstanbul != nil {
- c.OverrideIstanbul = dec.OverrideIstanbul
- }
 if dec.ManualCanonical != nil {
 c.ManualCanonical = *dec.ManualCanonical
 }
diff --git a/eth/metrics.go b/eth/metrics.go
deleted file mode 100644
index 0729c44..0000000
--- a/eth/metrics.go
+++ /dev/null
@@ -1,139 +0,0 @@
-// Copyright 2015 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 <http://www.gnu.org/licenses/>.
-
-package eth
-
-import (
- "github.com/ava-labs/go-ethereum/metrics"
- "github.com/ava-labs/go-ethereum/p2p"
-)
-
-var (
- propTxnInPacketsMeter = metrics.NewRegisteredMeter("eth/prop/txns/in/packets", nil)
- propTxnInTrafficMeter = metrics.NewRegisteredMeter("eth/prop/txns/in/traffic", nil)
- propTxnOutPacketsMeter = metrics.NewRegisteredMeter("eth/prop/txns/out/packets", nil)
- propTxnOutTrafficMeter = metrics.NewRegisteredMeter("eth/prop/txns/out/traffic", nil)
- propHashInPacketsMeter = metrics.NewRegisteredMeter("eth/prop/hashes/in/packets", nil)
- propHashInTrafficMeter = metrics.NewRegisteredMeter("eth/prop/hashes/in/traffic", nil)
- propHashOutPacketsMeter = metrics.NewRegisteredMeter("eth/prop/hashes/out/packets", nil)
- propHashOutTrafficMeter = metrics.NewRegisteredMeter("eth/prop/hashes/out/traffic", nil)
- propBlockInPacketsMeter = metrics.NewRegisteredMeter("eth/prop/blocks/in/packets", nil)
- propBlockInTrafficMeter = metrics.NewRegisteredMeter("eth/prop/blocks/in/traffic", nil)
- propBlockOutPacketsMeter = metrics.NewRegisteredMeter("eth/prop/blocks/out/packets", nil)
- propBlockOutTrafficMeter = metrics.NewRegisteredMeter("eth/prop/blocks/out/traffic", nil)
- reqHeaderInPacketsMeter = metrics.NewRegisteredMeter("eth/req/headers/in/packets", nil)
- reqHeaderInTrafficMeter = metrics.NewRegisteredMeter("eth/req/headers/in/traffic", nil)
- reqHeaderOutPacketsMeter = metrics.NewRegisteredMeter("eth/req/headers/out/packets", nil)
- reqHeaderOutTrafficMeter = metrics.NewRegisteredMeter("eth/req/headers/out/traffic", nil)
- reqBodyInPacketsMeter = metrics.NewRegisteredMeter("eth/req/bodies/in/packets", nil)
- reqBodyInTrafficMeter = metrics.NewRegisteredMeter("eth/req/bodies/in/traffic", nil)
- reqBodyOutPacketsMeter = metrics.NewRegisteredMeter("eth/req/bodies/out/packets", nil)
- reqBodyOutTrafficMeter = metrics.NewRegisteredMeter("eth/req/bodies/out/traffic", nil)
- reqStateInPacketsMeter = metrics.NewRegisteredMeter("eth/req/states/in/packets", nil)
- reqStateInTrafficMeter = metrics.NewRegisteredMeter("eth/req/states/in/traffic", nil)
- reqStateOutPacketsMeter = metrics.NewRegisteredMeter("eth/req/states/out/packets", nil)
- reqStateOutTrafficMeter = metrics.NewRegisteredMeter("eth/req/states/out/traffic", nil)
- reqReceiptInPacketsMeter = metrics.NewRegisteredMeter("eth/req/receipts/in/packets", nil)
- reqReceiptInTrafficMeter = metrics.NewRegisteredMeter("eth/req/receipts/in/traffic", nil)
- reqReceiptOutPacketsMeter = metrics.NewRegisteredMeter("eth/req/receipts/out/packets", nil)
- reqReceiptOutTrafficMeter = metrics.NewRegisteredMeter("eth/req/receipts/out/traffic", nil)
- miscInPacketsMeter = metrics.NewRegisteredMeter("eth/misc/in/packets", nil)
- miscInTrafficMeter = metrics.NewRegisteredMeter("eth/misc/in/traffic", nil)
- miscOutPacketsMeter = metrics.NewRegisteredMeter("eth/misc/out/packets", nil)
- miscOutTrafficMeter = metrics.NewRegisteredMeter("eth/misc/out/traffic", nil)
-)
-
-// meteredMsgReadWriter is a wrapper around a p2p.MsgReadWriter, capable of
-// accumulating the above defined metrics based on the data stream contents.
-type meteredMsgReadWriter struct {
- p2p.MsgReadWriter // Wrapped message stream to meter
- version int // Protocol version to select correct meters
-}
-
-// newMeteredMsgWriter wraps a p2p MsgReadWriter with metering support. If the
-// metrics system is disabled, this function returns the original object.
-func newMeteredMsgWriter(rw p2p.MsgReadWriter) p2p.MsgReadWriter {
- if !metrics.Enabled {
- return rw
- }
- return &meteredMsgReadWriter{MsgReadWriter: rw}
-}
-
-// Init sets the protocol version used by the stream to know which meters to
-// increment in case of overlapping message ids between protocol versions.
-func (rw *meteredMsgReadWriter) Init(version int) {
- rw.version = version
-}
-
-func (rw *meteredMsgReadWriter) ReadMsg() (p2p.Msg, error) {
- // Read the message and short circuit in case of an error
- msg, err := rw.MsgReadWriter.ReadMsg()
- if err != nil {
- return msg, err
- }
- // Account for the data traffic
- packets, traffic := miscInPacketsMeter, miscInTrafficMeter
- switch {
- case msg.Code == BlockHeadersMsg:
- packets, traffic = reqHeaderInPacketsMeter, reqHeaderInTrafficMeter
- case msg.Code == BlockBodiesMsg:
- packets, traffic = reqBodyInPacketsMeter, reqBodyInTrafficMeter
-
- case rw.version >= eth63 && msg.Code == NodeDataMsg:
- packets, traffic = reqStateInPacketsMeter, reqStateInTrafficMeter
- case rw.version >= eth63 && msg.Code == ReceiptsMsg:
- packets, traffic = reqReceiptInPacketsMeter, reqReceiptInTrafficMeter
-
- case msg.Code == NewBlockHashesMsg:
- packets, traffic = propHashInPacketsMeter, propHashInTrafficMeter
- case msg.Code == NewBlockMsg:
- packets, traffic = propBlockInPacketsMeter, propBlockInTrafficMeter
- case msg.Code == TxMsg:
- packets, traffic = propTxnInPacketsMeter, propTxnInTrafficMeter
- }
- packets.Mark(1)
- traffic.Mark(int64(msg.Size))
-
- return msg, err
-}
-
-func (rw *meteredMsgReadWriter) WriteMsg(msg p2p.Msg) error {
- // Account for the data traffic
- packets, traffic := miscOutPacketsMeter, miscOutTrafficMeter
- switch {
- case msg.Code == BlockHeadersMsg:
- packets, traffic = reqHeaderOutPacketsMeter, reqHeaderOutTrafficMeter
- case msg.Code == BlockBodiesMsg:
- packets, traffic = reqBodyOutPacketsMeter, reqBodyOutTrafficMeter
-
- case rw.version >= eth63 && msg.Code == NodeDataMsg:
- packets, traffic = reqStateOutPacketsMeter, reqStateOutTrafficMeter
- case rw.version >= eth63 && msg.Code == ReceiptsMsg:
- packets, traffic = reqReceiptOutPacketsMeter, reqReceiptOutTrafficMeter
-
- case msg.Code == NewBlockHashesMsg:
- packets, traffic = propHashOutPacketsMeter, propHashOutTrafficMeter
- case msg.Code == NewBlockMsg:
- packets, traffic = propBlockOutPacketsMeter, propBlockOutTrafficMeter
- case msg.Code == TxMsg:
- packets, traffic = propTxnOutPacketsMeter, propTxnOutTrafficMeter
- }
- packets.Mark(1)
- traffic.Mark(int64(msg.Size))
-
- // Send the packet to the p2p layer
- return rw.MsgReadWriter.WriteMsg(msg)
-}
diff --git a/eth/protocol.go b/eth/protocol.go
index e205aad..ef5dcde 100644
--- a/eth/protocol.go
+++ b/eth/protocol.go
@@ -22,46 +22,53 @@ import (
 "math/big"
 
 "github.com/ava-labs/coreth/core"
+ "github.com/ava-labs/coreth/core/forkid"
 "github.com/ava-labs/coreth/core/types"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/event"
- "github.com/ava-labs/go-ethereum/rlp"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/rlp"
 )
 
 // Constants to match up protocol versions and messages
 const (
- eth62 = 62
 eth63 = 63
+ eth64 = 64
+ eth65 = 65
 )
 
 // protocolName is the official short name of the protocol used during capability negotiation.
 const protocolName = "eth"
 
 // ProtocolVersions are the supported versions of the eth protocol (first is primary).
-var ProtocolVersions = []uint{eth63}
+var ProtocolVersions = []uint{eth65, eth64, eth63}
 
 // protocolLengths are the number of implemented message corresponding to different protocol versions.
-var protocolLengths = map[uint]uint64{eth63: 17, eth62: 8}
+var protocolLengths = map[uint]uint64{eth65: 17, eth64: 17, eth63: 17}
 
 const protocolMaxMsgSize = 10 * 1024 * 1024 // Maximum cap on the size of a protocol message
 
 // eth protocol message codes
 const (
- // Protocol messages belonging to eth/62
 StatusMsg = 0x00
 NewBlockHashesMsg = 0x01
- TxMsg = 0x02
+ TransactionMsg = 0x02
 GetBlockHeadersMsg = 0x03
 BlockHeadersMsg = 0x04
 GetBlockBodiesMsg = 0x05
 BlockBodiesMsg = 0x06
 NewBlockMsg = 0x07
-
- // Protocol messages belonging to eth/63
- GetNodeDataMsg = 0x0d
- NodeDataMsg = 0x0e
- GetReceiptsMsg = 0x0f
- ReceiptsMsg = 0x10
+ GetNodeDataMsg = 0x0d
+ NodeDataMsg = 0x0e
+ GetReceiptsMsg = 0x0f
+ ReceiptsMsg = 0x10
+
+ // New protocol message codes introduced in eth65
+ //
+ // Previously these message ids were used by some legacy and unsupported
+ // eth protocols, reown them here.
+ NewPooledTransactionHashesMsg = 0x08
+ GetPooledTransactionsMsg = 0x09
+ PooledTransactionsMsg = 0x0a
 )
 
 type errCode int
@@ -71,11 +78,11 @@ const (
 ErrDecode
 ErrInvalidMsgCode
 ErrProtocolVersionMismatch
- ErrNetworkIdMismatch
- ErrGenesisBlockMismatch
+ ErrNetworkIDMismatch
+ ErrGenesisMismatch
+ ErrForkIDRejected
 ErrNoStatusMsg
 ErrExtraStatusMsg
- ErrSuspendedPeer
 )
 
 func (e errCode) String() string {
@@ -88,14 +95,22 @@ var errorToString = map[int]string{
 ErrDecode: "Invalid message",
 ErrInvalidMsgCode: "Invalid message code",
 ErrProtocolVersionMismatch: "Protocol version mismatch",
- ErrNetworkIdMismatch: "NetworkId mismatch",
- ErrGenesisBlockMismatch: "Genesis block mismatch",
+ ErrNetworkIDMismatch: "Network ID mismatch",
+ ErrGenesisMismatch: "Genesis mismatch",
+ ErrForkIDRejected: "Fork ID rejected",
 ErrNoStatusMsg: "No status message",
 ErrExtraStatusMsg: "Extra status message",
- ErrSuspendedPeer: "Suspended peer",
 }
 
 type txPool interface {
+ // Has returns an indicator whether txpool has a transaction
+ // cached with the given hash.
+ Has(hash common.Hash) bool
+
+ // Get retrieves the transaction from local txpool with given
+ // tx hash.
+ Get(hash common.Hash) *types.Transaction
+
 // AddRemotes should add the given transactions to the pool.
 AddRemotes([]*types.Transaction) []error
 
@@ -108,8 +123,8 @@ type txPool interface {
 SubscribeNewTxsEvent(chan<- core.NewTxsEvent) event.Subscription
 }
 
-// statusData is the network packet for the status message.
-type statusData struct {
+// statusData63 is the network packet for the status message for eth/63.
+type statusData63 struct {
 ProtocolVersion uint32
 NetworkId uint64
 TD *big.Int
@@ -117,6 +132,16 @@ type statusData struct {
 GenesisBlock common.Hash
 }
 
+// statusData is the network packet for the status message for eth/64 and later.
+type statusData struct {
+ ProtocolVersion uint32
+ NetworkID uint64
+ TD *big.Int
+ Head common.Hash
+ Genesis common.Hash
+ ForkID forkid.ID
+}
+
 // newBlockHashesData is the network packet for the block announcements.
 type newBlockHashesData []struct {
 Hash common.Hash // Hash of one particular block being announced
diff --git a/eth/tracers/tracer.go b/eth/tracers/tracer.go
index f2ef25d..524500d 100644
--- a/eth/tracers/tracer.go
+++ b/eth/tracers/tracer.go
@@ -26,10 +26,10 @@ import (
 "unsafe"
 
 "github.com/ava-labs/coreth/core/vm"
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/common/hexutil"
- "github.com/ava-labs/go-ethereum/crypto"
- "github.com/ava-labs/go-ethereum/log"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/log"
 duktape "gopkg.in/olebedev/go-duktape.v3"
 )
 
@@ -93,18 +93,27 @@ type memoryWrapper struct {
 
 // slice returns the requested range of memory as a byte slice.
 func (mw *memoryWrapper) slice(begin, end int64) []byte {
+ if end == begin {
+ return []byte{}
+ }
+ if end < begin || begin < 0 {
+ // TODO(karalabe): We can't js-throw from Go inside duktape inside Go. The Go
+ // runtime goes belly up https://github.com/golang/go/issues/15639.
+ log.Warn("Tracer accessed out of bound memory", "offset", begin, "end", end)
+ return nil
+ }
 if mw.memory.Len() < int(end) {
 // TODO(karalabe): We can't js-throw from Go inside duktape inside Go. The Go
 // runtime goes belly up https://github.com/golang/go/issues/15639.
 log.Warn("Tracer accessed out of bound memory", "available", mw.memory.Len(), "offset", begin, "size", end-begin)
 return nil
 }
- return mw.memory.Get(begin, end-begin)
+ return mw.memory.GetCopy(begin, end-begin)
 }
 
 // getUint returns the 32 bytes at the specified address interpreted as a uint.
 func (mw *memoryWrapper) getUint(addr int64) *big.Int {
- if mw.memory.Len() < int(addr)+32 {
+ if mw.memory.Len() < int(addr)+32 || addr < 0 {
 // TODO(karalabe): We can't js-throw from Go inside duktape inside Go. The Go
 // runtime goes belly up https://github.com/golang/go/issues/15639.
 log.Warn("Tracer accessed out of bound memory", "available", mw.memory.Len(), "offset", addr, "size", 32)
@@ -147,13 +156,13 @@ type stackWrapper struct {
 
 // peek returns the nth-from-the-top element of the stack.
 func (sw *stackWrapper) peek(idx int) *big.Int {
- if len(sw.stack.Data()) <= idx {
+ if len(sw.stack.Data()) <= idx || idx < 0 {
 // TODO(karalabe): We can't js-throw from Go inside duktape inside Go. The Go
 // runtime goes belly up https://github.com/golang/go/issues/15639.
 log.Warn("Tracer accessed out of bound stack", "size", len(sw.stack.Data()), "index", idx)
 return new(big.Int)
 }
- return sw.stack.Data()[len(sw.stack.Data())-idx-1]
+ return sw.stack.Back(idx).ToBig()
 }
 
 // pushObject assembles a JSVM object wrapping a swappable stack and pushes it
@@ -419,17 +428,17 @@ func New(code string) (*Tracer, error) {
 tracer.tracerObject = 0 // yeah, nice, eval can't return the index itself
 
 if !tracer.vm.GetPropString(tracer.tracerObject, "step") {
- return nil, fmt.Errorf("Trace object must expose a function step()")
+ return nil, fmt.Errorf("trace object must expose a function step()")
 }
 tracer.vm.Pop()
 
 if !tracer.vm.GetPropString(tracer.tracerObject, "fault") {
- return nil, fmt.Errorf("Trace object must expose a function fault()")
+ return nil, fmt.Errorf("trace object must expose a function fault()")
 }
 tracer.vm.Pop()
 
 if !tracer.vm.GetPropString(tracer.tracerObject, "result") {
- return nil, fmt.Errorf("Trace object must expose a function result()")
+ return nil, fmt.Errorf("trace object must expose a function result()")
 }
 tracer.vm.Pop()
 
@@ -532,7 +541,7 @@ func (jst *Tracer) CaptureStart(from common.Address, to common.Address, create b
 }
 
 // CaptureState implements the Tracer interface to trace a single step of VM execution.
-func (jst *Tracer) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, contract *vm.Contract, depth int, err error) error {
+func (jst *Tracer) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, rStack *vm.ReturnStack, rdata []byte, contract *vm.Contract, depth int, err error) error {
 if jst.err == nil {
 // Initialize the context if it wasn't done yet
 if !jst.inited {
@@ -571,7 +580,7 @@ func (jst *Tracer) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost
 
 // CaptureFault implements the Tracer interface to trace an execution fault
 // while running an opcode.
-func (jst *Tracer) CaptureFault(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, contract *vm.Contract, depth int, err error) error {
+func (jst *Tracer) CaptureFault(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, rStack *vm.ReturnStack, contract *vm.Contract, depth int, err error) error {
 if jst.err == nil {
 // Apart from the error, everything matches the previous invocation
 jst.errorValue = new(string)