Refactoring: statedb interface

cmd/opera/launcher/export.go

@@ -138,7 +138,11 @@ func exportEvmKeys(ctx *cli.Context) error {
 	keysDB := batched.Wrap(keysDB_)
 	defer keysDB.Close()
 
-	it := gdb.EvmStore().EvmDb.NewIterator(nil, nil)
+	evmDb := gdb.EvmStore().EvmDb
+	if evmDb == nil {
+		panic("unknown EvmDb format")
+	}
+	it := evmDb.NewIterator(nil, nil)
 	// iterate only over MPT data
 	it = mptAndPreimageIterator{it}
 	defer it.Release()

cmd/opera/launcher/genesiscmd.go

@@ -376,7 +376,12 @@ func exportGenesis(ctx *cli.Context) error {
 		if err != nil {
 			return err
 		}
-		it := gdb.EvmStore().EvmDb.NewIterator(nil, nil)
+
+		evmDb := gdb.EvmStore().EvmDb
+		if evmDb == nil {
+			panic("unknown EvmDb format")
+		}
+		it := evmDb.NewIterator(nil, nil)
 		if mode == "mpt" {
 			// iterate only over MPT data
 			it = mptIterator{it}

cmd/opera/launcher/snapshotcmd.go

@@ -195,7 +195,13 @@ func pruneState(ctx *cli.Context) error {
 			return err
 		}
 	}
-	pruner, err := evmpruner.NewPruner(gdb.EvmStore().EvmDb, genesisRoot, root, tmpDir, bloom)
+
+	evmDb := gdb.EvmStore().EvmDb
+	if evmDb == nil {
+		panic("unknown EvmDb format")
+	}
+
+	pruner, err := evmpruner.NewPruner(evmDb, genesisRoot, root, tmpDir, bloom)
 	if err != nil {
 		log.Error("Failed to open snapshot tree", "err", err)
 		return err
@@ -269,6 +275,9 @@ func traverseState(ctx *cli.Context) error {
 		return errors.New("failed to open snapshot tree: genesis is not written")
 	}
 	chaindb := gdb.EvmStore().EvmDb
+	if chaindb == nil {
+		panic("unknown EvmDb format")
+	}
 
 	if ctx.NArg() > 1 {
 		log.Error("Too many arguments given")
@@ -359,6 +368,9 @@ func traverseRawState(ctx *cli.Context) error {
 		return errors.New("failed to open snapshot tree: genesis is not written")
 	}
 	chaindb := gdb.EvmStore().EvmDb
+	if chaindb == nil {
+		panic("unknown EvmDb format")
+	}
 
 	if ctx.NArg() > 1 {
 		log.Error("Too many arguments given")

ethapi/api.go

@@ -34,7 +34,6 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/consensus/ethash"
-	"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/crypto"
@@ -710,8 +709,14 @@ type StorageResult struct {
 
 // GetProof returns the Merkle-proof for a given account and optionally some storage keys.
 func (s *PublicBlockChainAPI) GetProof(ctx context.Context, address common.Address, storageKeys []string, blockNrOrHash rpc.BlockNumberOrHash) (*AccountResult, error) {
-	state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
-	if state == nil || err != nil {
+	statedb, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
+	if statedb == nil || err != nil {
+		return nil, err
+	}
+
+	state, ok := evmcore.IsMptStateDB(statedb)
+	if !ok {
+		err = errors.New("Proofs are not provided by current state db impl")
 		return nil, err
 	}
 
@@ -912,7 +917,7 @@ type OverrideAccount struct {
 type StateOverride map[common.Address]OverrideAccount
 
 // Apply overrides the fields of specified accounts into the given state.
-func (diff *StateOverride) Apply(state *state.StateDB) error {
+func (diff *StateOverride) Apply(state evmcore.StateDB) error {
 	if diff == nil {
 		return nil
 	}

ethapi/backend.go

@@ -26,7 +26,6 @@ import (
 	"github.com/Fantom-foundation/lachesis-base/inter/idx"
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
-	"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/ethdb"
@@ -69,12 +68,12 @@ type Backend interface {
 	HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*evmcore.EvmHeader, error)
 	HeaderByHash(ctx context.Context, hash common.Hash) (*evmcore.EvmHeader, error)
 	BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*evmcore.EvmBlock, error)
-	StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *evmcore.EvmHeader, error)
+	StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (evmcore.StateDB, *evmcore.EvmHeader, error)
 	ResolveRpcBlockNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (idx.Block, error)
 	BlockByHash(ctx context.Context, hash common.Hash) (*evmcore.EvmBlock, error)
 	GetReceiptsByNumber(ctx context.Context, number rpc.BlockNumber) (types.Receipts, error)
 	GetTd(hash common.Hash) *big.Int
-	GetEVM(ctx context.Context, msg evmcore.Message, state *state.StateDB, header *evmcore.EvmHeader, vmConfig *vm.Config) (*vm.EVM, func() error, error)
+	GetEVM(ctx context.Context, msg evmcore.Message, state evmcore.StateDB, header *evmcore.EvmHeader, vmConfig *vm.Config) (*vm.EVM, func() error, error)
 	MinGasPrice() *big.Int
 	MaxGasLimit() uint64
 

evmcore/apply_fake_genesis.go

@@ -24,7 +24,6 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
@@ -35,7 +34,7 @@ import (
 var FakeGenesisTime = inter.Timestamp(1608600000 * time.Second)
 
 // ApplyFakeGenesis writes or updates the genesis block in db.
-func ApplyFakeGenesis(statedb *state.StateDB, time inter.Timestamp, balances map[common.Address]*big.Int) (*EvmBlock, error) {
+func ApplyFakeGenesis(statedb StateDB, time inter.Timestamp, balances map[common.Address]*big.Int) (*EvmBlock, error) {
 	for acc, balance := range balances {
 		statedb.SetBalance(acc, balance)
 	}
@@ -50,7 +49,7 @@ func ApplyFakeGenesis(statedb *state.StateDB, time inter.Timestamp, balances map
 	return block, nil
 }
 
-func flush(statedb *state.StateDB, clean bool) (root common.Hash, err error) {
+func flush(statedb StateDB, clean bool) (root common.Hash, err error) {
 	root, err = statedb.Commit(clean)
 	if err != nil {
 		return
@@ -83,7 +82,7 @@ func genesisBlock(time inter.Timestamp, root common.Hash) *EvmBlock {
 }
 
 // MustApplyFakeGenesis writes the genesis block and state to db, panicking on error.
-func MustApplyFakeGenesis(statedb *state.StateDB, time inter.Timestamp, balances map[common.Address]*big.Int) *EvmBlock {
+func MustApplyFakeGenesis(statedb StateDB, time inter.Timestamp, balances map[common.Address]*big.Int) *EvmBlock {
 	block, err := ApplyFakeGenesis(statedb, time, balances)
 	if err != nil {
 		log.Crit("ApplyFakeGenesis", "err", err)

evmcore/bench_test.go

@@ -23,10 +23,11 @@ import (
 	"os"
 	"testing"
 
+	"github.com/ethereum/go-ethereum/core/state"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/core/rawdb"
-	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethdb"
@@ -145,13 +146,19 @@ func benchInsertChain(b *testing.B, disk bool, gen func(int, *BlockGen)) {
 		defer db.Close()
 	}
 
+	stateAt := func(root common.Hash) StateDB {
+		st, err := state.New(root, state.NewDatabase(db), nil)
+		if err != nil {
+			panic(err)
+		}
+
+		return ToStateDB(st)
+	}
+
 	// Generate a chain of b.N blocks using the supplied block
 	// generator function.
 	// state
-	statedb, err := state.New(common.Hash{}, state.NewDatabase(db), nil)
-	if err != nil {
-		b.Fatalf("cannot create statedb: %v", err)
-	}
+	statedb := newMemoryStateDB()
 	genesisBlock := MustApplyFakeGenesis(statedb, FakeGenesisTime, map[common.Address]*big.Int{
 		benchRootAddr: benchRootFunds,
 	})
@@ -162,5 +169,5 @@ func benchInsertChain(b *testing.B, disk bool, gen func(int, *BlockGen)) {
 	b.ReportAllocs()
 	b.ResetTimer()
 
-	_, _, _ = GenerateChain(nil, genesisBlock, db, b.N, gen)
+	_, _, _ = GenerateChain(nil, genesisBlock, b.N, stateAt, gen)
 }

evmcore/chain_makers.go

@@ -22,10 +22,8 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
-	"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/ethdb"
 	"github.com/ethereum/go-ethereum/params"
 
 	"github.com/Fantom-foundation/go-opera/inter"
@@ -39,7 +37,7 @@ type BlockGen struct {
 	parent  *EvmBlock
 	chain   []*EvmBlock
 	header  *EvmHeader
-	statedb *state.StateDB
+	statedb StateDB
 
 	gasPool  *GasPool
 	txs      []*types.Transaction
@@ -100,7 +98,7 @@ func (b *BlockGen) AddTxWithChain(bc DummyChain, tx *types.Transaction) {
 	b.statedb.Prepare(tx.Hash(), len(b.txs))
 	blockContext := NewEVMBlockContext(b.header, bc, nil)
 	vmenv := vm.NewEVM(blockContext, vm.TxContext{}, b.statedb, b.config, opera.DefaultVMConfig)
-	receipt, _, _, err := applyTransaction(msg, b.config, b.gasPool, b.statedb, b.header.Number, b.header.Hash, tx, &b.header.GasUsed, vmenv, func(log *types.Log, db *state.StateDB) {})
+	receipt, _, _, err := applyTransaction(msg, b.config, b.gasPool, b.statedb, b.header.Number, b.header.Hash, tx, &b.header.GasUsed, vmenv, func(log *types.Log, db StateDB) {})
 	if err != nil {
 		panic(err)
 	}
@@ -185,7 +183,11 @@ func (b *BlockGen) OffsetTime(seconds int64) {
 // Blocks created by GenerateChain do not contain valid proof of work
 // values. Inserting them into BlockChain requires use of FakePow or
 // a similar non-validating proof of work implementation.
-func GenerateChain(config *params.ChainConfig, parent *EvmBlock, db ethdb.Database, n int, gen func(int, *BlockGen)) ([]*EvmBlock, []types.Receipts, DummyChain) {
+func GenerateChain(
+	config *params.ChainConfig, parent *EvmBlock, n int, stateAt func(common.Hash) StateDB, gen func(int, *BlockGen),
+) (
+	[]*EvmBlock, []types.Receipts, DummyChain,
+) {
 	if config == nil {
 		config = params.AllEthashProtocolChanges
 	}
@@ -195,7 +197,7 @@ func GenerateChain(config *params.ChainConfig, parent *EvmBlock, db ethdb.Databa
 	}
 
 	blocks, receipts := make([]*EvmBlock, n), make([]types.Receipts, n)
-	genblock := func(i int, parent *EvmBlock, statedb *state.StateDB) (*EvmBlock, types.Receipts) {
+	genblock := func(i int, parent *EvmBlock, statedb StateDB) (*EvmBlock, types.Receipts) {
 		b := &BlockGen{i: i, chain: blocks, parent: parent, statedb: statedb, config: config}
 		b.header = makeHeader(parent, statedb)
 
@@ -219,11 +221,10 @@ func GenerateChain(config *params.ChainConfig, parent *EvmBlock, db ethdb.Databa
 
 		return block, b.receipts
 	}
+
 	for i := 0; i < n; i++ {
-		statedb, err := state.New(parent.Root, state.NewDatabase(db), nil)
-		if err != nil {
-			panic(err)
-		}
+		statedb := stateAt(parent.Root)
+
 		block, receipt := genblock(i, parent, statedb)
 		blocks[i] = block
 		receipts[i] = receipt
@@ -234,7 +235,7 @@ func GenerateChain(config *params.ChainConfig, parent *EvmBlock, db ethdb.Databa
 	return blocks, receipts, chain
 }
 
-func makeHeader(parent *EvmBlock, state *state.StateDB) *EvmHeader {
+func makeHeader(parent *EvmBlock, state StateDB) *EvmHeader {
 	var t inter.Timestamp
 	if parent.Time == 0 {
 		t = 10
@@ -252,27 +253,6 @@ func makeHeader(parent *EvmBlock, state *state.StateDB) *EvmHeader {
 	return header
 }
 
-// makeHeaderChain creates a deterministic chain of headers rooted at parent.
-func makeHeaderChain(parent *EvmHeader, n int, db ethdb.Database, seed int) []*EvmHeader {
-	block := &EvmBlock{}
-	block.EvmHeader = *parent
-
-	blocks := makeBlockChain(block, n, db, seed)
-	headers := make([]*EvmHeader, len(blocks))
-	for i, block := range blocks {
-		headers[i] = block.Header()
-	}
-	return headers
-}
-
-// makeBlockChain creates a deterministic chain of blocks rooted at parent.
-func makeBlockChain(parent *EvmBlock, n int, db ethdb.Database, seed int) []*EvmBlock {
-	blocks, _, _ := GenerateChain(params.TestChainConfig, parent, db, n, func(i int, b *BlockGen) {
-		b.SetCoinbase(common.Address{0: byte(seed), 19: byte(i)})
-	})
-	return blocks
-}
-
 type fakeChainReader struct {
 	config  *params.ChainConfig
 	genesis *EvmBlock

evmcore/state_prefetcher.go

@@ -19,7 +19,6 @@ package evmcore
 import (
 	"sync/atomic"
 
-	"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/params"
@@ -46,7 +45,7 @@ func newStatePrefetcher(config *params.ChainConfig, bc DummyChain) *statePrefetc
 // Prefetch processes the state changes according to the Ethereum rules by running
 // the transaction messages using the statedb, but any changes are discarded. The
 // only goal is to pre-cache transaction signatures and state trie nodes.
-func (p *statePrefetcher) Prefetch(block *EvmBlock, statedb *state.StateDB, cfg vm.Config, interrupt *uint32) {
+func (p *statePrefetcher) Prefetch(block *EvmBlock, statedb StateDB, cfg vm.Config, interrupt *uint32) {
 	var (
 		header       = block.Header()
 		gaspool      = new(GasPool).AddGas(block.GasLimit)
@@ -84,7 +83,7 @@ func (p *statePrefetcher) Prefetch(block *EvmBlock, statedb *state.StateDB, cfg
 // precacheTransaction attempts to apply a transaction to the given state database
 // and uses the input parameters for its environment. The goal is not to execute
 // the transaction successfully, rather to warm up touched data slots.
-func precacheTransaction(msg types.Message, config *params.ChainConfig, gaspool *GasPool, statedb *state.StateDB, header *EvmHeader, evm *vm.EVM) error {
+func precacheTransaction(msg types.Message, config *params.ChainConfig, gaspool *GasPool, statedb StateDB, header *EvmHeader, evm *vm.EVM) error {
 	// Update the evm with the new transaction context.
 	evm.Reset(NewEVMTxContext(msg), statedb)
 	// Add addresses to access list if applicable

evmcore/state_processor.go

@@ -21,7 +21,6 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
-	"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/crypto"
@@ -56,7 +55,7 @@ func NewStateProcessor(config *params.ChainConfig, bc DummyChain) *StateProcesso
 // returns the amount of gas that was used in the process. If any of the
 // transactions failed to execute due to insufficient gas it will return an error.
 func (p *StateProcessor) Process(
-	block *EvmBlock, statedb *state.StateDB, cfg vm.Config, usedGas *uint64, onNewLog func(*types.Log, *state.StateDB),
+	block *EvmBlock, statedb StateDB, cfg vm.Config, usedGas *uint64, onNewLog func(*types.Log, StateDB),
 ) (
 	receipts types.Receipts, allLogs []*types.Log, skipped []uint32, err error,
 ) {
@@ -99,13 +98,13 @@ func applyTransaction(
 	msg types.Message,
 	config *params.ChainConfig,
 	gp *GasPool,
-	statedb *state.StateDB,
+	statedb StateDB,
 	blockNumber *big.Int,
 	blockHash common.Hash,
 	tx *types.Transaction,
 	usedGas *uint64,
 	evm *vm.EVM,
-	onNewLog func(*types.Log, *state.StateDB),
+	onNewLog func(*types.Log, StateDB),
 ) (
 	*types.Receipt,
 	uint64,

evmcore/state_transition.go

@@ -42,8 +42,10 @@ The state transitioning model does all the necessary work to work out a valid ne
 3) Create a new state object if the recipient is \0*32
 4) Value transfer
 == If contract creation ==
-  4a) Attempt to run transaction data
-  4b) If valid, use result as code for the new state object
+
+	4a) Attempt to run transaction data
+	4b) If valid, use result as code for the new state object
+
 == end ==
 5) Run Script section
 6) Derive new state root
@@ -232,13 +234,13 @@ func (st *StateTransition) internal() bool {
 // TransitionDb will transition the state by applying the current message and
 // returning the evm execution result with following fields.
 //
-// - used gas:
-//      total gas used (including gas being refunded)
-// - returndata:
-//      the returned data from evm
-// - concrete execution error:
-//      various **EVM** error which aborts the execution,
-//      e.g. ErrOutOfGas, ErrExecutionReverted
+//   - used gas:
+//     total gas used (including gas being refunded)
+//   - returndata:
+//     the returned data from evm
+//   - concrete execution error:
+//     various **EVM** error which aborts the execution,
+//     e.g. ErrOutOfGas, ErrExecutionReverted
 //
 // However if any consensus issue encountered, return the error directly with
 // nil evm execution result.