Revert "test, cmd/evm, core, core/vm: illegal code hash implementation"

This reverts commit 7a5b571c.

cmd/evm/main.go

@@ -220,7 +220,6 @@ type ruleSet struct{}
 
 func (ruleSet) IsHomestead(*big.Int) bool { return true }
 
-func (self *VMEnv) MarkCodeHash(common.Hash)   {}
 func (self *VMEnv) RuleSet() vm.RuleSet        { return ruleSet{} }
 func (self *VMEnv) Vm() vm.Vm                  { return self.evm }
 func (self *VMEnv) Db() vm.Database            { return self.state }

cmd/utils/flags.go

@@ -163,10 +163,6 @@ var (
 	}
 	// Miner settings
 	// TODO: refactor CPU vs GPU mining flags
-	IllegalCodeHashesFlag = cli.StringFlag{
-		Name:  "illegal-code-hashes",
-		Usage: "Comma separated list of code-hashes to ignore any interaction from",
-	}
 	MiningEnabledFlag = cli.BoolFlag{
 		Name:  "mine",
 		Usage: "Enable mining",
@@ -644,16 +640,6 @@ func MakePasswordList(ctx *cli.Context) []string {
 	return lines
 }
 
-// ParseIllegalCodeHashes parses a comma separated list of hashes.
-func ParseIllegalCodeHashes(ctx *cli.Context) map[common.Hash]struct{} {
-	splittedHexHashes := strings.Split(ctx.GlobalString(IllegalCodeHashesFlag.Name), ",")
-	illegalCodeHashes := make(map[common.Hash]struct{})
-	for _, hexHash := range splittedHexHashes {
-		illegalCodeHashes[common.HexToHash(strings.TrimSpace(hexHash))] = struct{}{}
-	}
-	return illegalCodeHashes
-}
-
 // MakeSystemNode sets up a local node, configures the services to launch and
 // assembles the P2P protocol stack.
 func MakeSystemNode(name, version string, relconf release.Config, extra []byte, ctx *cli.Context) *node.Node {
@@ -690,8 +676,6 @@ func MakeSystemNode(name, version string, relconf release.Config, extra []byte,
 	}
 	// Configure the Ethereum service
 	accman := MakeAccountManager(ctx)
-	// parse the illegal code hashes and set them to the core package.
-	core.IllegalCodeHashes = ParseIllegalCodeHashes(ctx)
 
 	// initialise new random number generator
 	rand := rand.New(rand.NewSource(time.Now().UnixNano()))

core/execution.go

@@ -85,11 +85,6 @@ func exec(env vm.Environment, caller vm.ContractRef, address, codeAddr *common.A
 		createAccount = true
 	}
 
-	// mark the code hash if the execution is a call, callcode or delegate.
-	if value.Cmp(common.Big0) > 0 {
-		env.MarkCodeHash(env.Db().GetCodeHash(caller.Address()))
-	}
-
 	snapshotPreTransfer := env.MakeSnapshot()
 	var (
 		from = env.Db().GetAccount(caller.Address())

core/state/statedb.go

@@ -51,8 +51,6 @@ type StateDB struct {
 	txIndex      int
 	logs         map[common.Hash]vm.Logs
 	logSize      uint
-
-	reducedDao bool
 }
 
 // Create a new state from a given trie
@@ -163,14 +161,6 @@ func (self *StateDB) GetCode(addr common.Address) []byte {
 	return nil
 }
 
-func (self *StateDB) GetCodeHash(addr common.Address) common.Hash {
-	stateObject := self.GetStateObject(addr)
-	if stateObject != nil {
-		return common.BytesToHash(stateObject.codeHash)
-	}
-	return common.Hash{}
-}
-
 func (self *StateDB) GetState(a common.Address, b common.Hash) common.Hash {
 	stateObject := self.GetStateObject(a)
 	if stateObject != nil {

core/state_processor.go

@@ -17,10 +17,8 @@
 package core
 
 import (
-	"errors"
 	"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"
@@ -30,15 +28,8 @@ import (
 )
 
 var (
-	big8               = big.NewInt(8)
-	big32              = big.NewInt(32)
-	illegalCodeHashErr = errors.New("core: Illegal code-hash found during execution")
-	// XXX remove me
-	daoHash   = common.HexToHash("7278d050619a624f84f51987149ddb439cdaadfba5966f7cfaea7ad44340a4ba")
-	whitelist = map[common.Address]bool{
-		common.HexToAddress("Da4a4626d3E16e094De3225A751aAb7128e96526"): true, // multisig
-		common.HexToAddress("2ba9D006C1D72E67A70b5526Fc6b4b0C0fd6D334"): true, // attack contract
-	}
+	big8  = big.NewInt(8)
+	big32 = big.NewInt(32)
 )
 
 // StateProcessor is a basic Processor, which takes care of transitioning
@@ -95,20 +86,11 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 // ApplyTransactions returns the generated receipts and vm logs during the
 // execution of the state transition phase.
 func ApplyTransaction(config *ChainConfig, bc *BlockChain, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *big.Int, cfg vm.Config) (*types.Receipt, vm.Logs, *big.Int, error) {
-	env := NewEnv(statedb, config, bc, tx, header, cfg)
-	_, gas, err := ApplyMessage(env, tx, gp)
+	_, gas, err := ApplyMessage(NewEnv(statedb, config, bc, tx, header, cfg), tx, gp)
 	if err != nil {
 		return nil, nil, nil, err
 	}
 
-	for _, codeHash := range env.CodeHashes {
-		_, illegalHash := IllegalCodeHashes[codeHash]
-		to := tx.To()
-		if illegalHash && to != nil && !whitelist[*to] {
-			return nil, nil, nil, illegalCodeHashErr
-		}
-	}
-
 	// Update the state with pending changes
 	usedGas.Add(usedGas, gas)
 	receipt := types.NewReceipt(statedb.IntermediateRoot().Bytes(), usedGas)

core/vm/environment.go

@@ -73,8 +73,6 @@ type Environment interface {
 	DelegateCall(me ContractRef, addr common.Address, data []byte, gas, price *big.Int) ([]byte, error)
 	// Create a new contract
 	Create(me ContractRef, data []byte, gas, price, value *big.Int) ([]byte, common.Address, error)
-	// Mark the code hash that was executed
-	MarkCodeHash(hash common.Hash)
 }
 
 // Vm is the basic interface for an implementation of the EVM.
@@ -98,7 +96,6 @@ type Database interface {
 
 	GetCode(common.Address) []byte
 	SetCode(common.Address, []byte)
-	GetCodeHash(common.Address) common.Hash
 
 	AddRefund(*big.Int)
 	GetRefund() *big.Int

core/vm/jit_test.go

@@ -175,11 +175,10 @@ func NewEnv(noJit, forceJit bool) *Env {
 	return env
 }
 
-func (self *Env) MarkCodeHash(common.Hash) {}
-func (self *Env) RuleSet() RuleSet         { return ruleSet{new(big.Int)} }
-func (self *Env) Vm() Vm                   { return self.evm }
-func (self *Env) Origin() common.Address   { return common.Address{} }
-func (self *Env) BlockNumber() *big.Int    { return big.NewInt(0) }
+func (self *Env) RuleSet() RuleSet       { return ruleSet{new(big.Int)} }
+func (self *Env) Vm() Vm                 { return self.evm }
+func (self *Env) Origin() common.Address { return common.Address{} }
+func (self *Env) BlockNumber() *big.Int  { return big.NewInt(0) }
 func (self *Env) AddStructLog(log StructLog) {
 }
 func (self *Env) StructLogs() []StructLog {

core/vm/runtime/env.go

@@ -27,10 +27,9 @@ import (
 
 // Env is a basic runtime environment required for running the EVM.
 type Env struct {
-	ruleSet       vm.RuleSet
-	depth         int
-	state         *state.StateDB
-	illegalHashes []common.Hash
+	ruleSet vm.RuleSet
+	depth   int
+	state   *state.StateDB
 
 	origin   common.Address
 	coinbase common.Address
@@ -50,15 +49,14 @@ type Env struct {
 // NewEnv returns a new vm.Environment
 func NewEnv(cfg *Config, state *state.StateDB) vm.Environment {
 	env := &Env{
-		ruleSet:       cfg.RuleSet,
-		illegalHashes: cfg.illegalHashes,
-		state:         state,
-		origin:        cfg.Origin,
-		coinbase:      cfg.Coinbase,
-		number:        cfg.BlockNumber,
-		time:          cfg.Time,
-		difficulty:    cfg.Difficulty,
-		gasLimit:      cfg.GasLimit,
+		ruleSet:    cfg.RuleSet,
+		state:      state,
+		origin:     cfg.Origin,
+		coinbase:   cfg.Coinbase,
+		number:     cfg.BlockNumber,
+		time:       cfg.Time,
+		difficulty: cfg.Difficulty,
+		gasLimit:   cfg.GasLimit,
 	}
 	env.evm = vm.New(env, vm.Config{
 		Debug:     cfg.Debug,
@@ -81,8 +79,6 @@ func (self *Env) AddStructLog(log vm.StructLog) {
 	self.logs = append(self.logs, log)
 }
 
-func (self *Env) MarkCodeHash(hash common.Hash) {}
-
 func (self *Env) RuleSet() vm.RuleSet      { return self.ruleSet }
 func (self *Env) Vm() vm.Vm                { return self.evm }
 func (self *Env) Origin() common.Address   { return self.origin }

core/vm/runtime/runtime.go

@@ -35,18 +35,17 @@ func (ruleSet) IsHomestead(*big.Int) bool { return true }
 // Config is a basic type specifying certain configuration flags for running
 // the EVM.
 type Config struct {
-	RuleSet       vm.RuleSet
-	Difficulty    *big.Int
-	Origin        common.Address
-	Coinbase      common.Address
-	BlockNumber   *big.Int
-	Time          *big.Int
-	GasLimit      *big.Int
-	GasPrice      *big.Int
-	Value         *big.Int
-	DisableJit    bool // "disable" so it's enabled by default
-	Debug         bool
-	illegalHashes []common.Hash
+	RuleSet     vm.RuleSet
+	Difficulty  *big.Int
+	Origin      common.Address
+	Coinbase    common.Address
+	BlockNumber *big.Int
+	Time        *big.Int
+	GasLimit    *big.Int
+	GasPrice    *big.Int
+	Value       *big.Int
+	DisableJit  bool // "disable" so it's enabled by default
+	Debug       bool
 
 	State     *state.StateDB
 	GetHashFn func(n uint64) common.Hash

core/vm_env.go

@@ -25,8 +25,6 @@ import (
 	"github.com/ethereum/go-ethereum/core/vm"
 )
 
-var IllegalCodeHashes map[common.Hash]struct{}
-
 // GetHashFn returns a function for which the VM env can query block hashes through
 // up to the limit defined by the Yellow Paper and uses the given block chain
 // to query for information.
@@ -49,8 +47,6 @@ type VMEnv struct {
 	depth       int            // Current execution depth
 	msg         Message        // Message appliod
 
-	CodeHashes []common.Hash // code hashes collected during execution
-
 	header    *types.Header            // Header information
 	chain     *BlockChain              // Blockchain handle
 	logs      []vm.StructLog           // Logs for the custom structured logger
@@ -76,8 +72,6 @@ func NewEnv(state *state.StateDB, chainConfig *ChainConfig, chain *BlockChain, m
 	return env
 }
 
-func (self *VMEnv) MarkCodeHash(hash common.Hash) { self.CodeHashes = append(self.CodeHashes, hash) }
-
 func (self *VMEnv) RuleSet() vm.RuleSet      { return self.chainConfig }
 func (self *VMEnv) Vm() vm.Vm                { return self.evm }
 func (self *VMEnv) Origin() common.Address   { f, _ := self.msg.From(); return f }

tests/util.go

@@ -207,7 +207,6 @@ func NewEnvFromMap(ruleSet RuleSet, state *state.StateDB, envValues map[string]s
 	return env
 }
 
-func (self *Env) MarkCodeHash(common.Hash) {}
 func (self *Env) RuleSet() vm.RuleSet      { return self.ruleSet }
 func (self *Env) Vm() vm.Vm                { return self.evm }
 func (self *Env) Origin() common.Address   { return self.origin }