Merge pull request #1042 from CortexFoundation/neo

Neo version 4 cortex full node

Author: ucwong

consensus/cuckoo/consensus.go

@@ -353,12 +353,14 @@ func (cuckoo *Cuckoo) CalcDifficulty(chain consensus.ChainHeaderReader, time uin
 func CalcDifficulty(config *params.ChainConfig, time uint64, parent *types.Header) *big.Int {
 	next := new(big.Int).Add(parent.Number, big1)
 	switch {
+	case config.IsNeo(next):
+		return calcDifficultyNeo(time, parent, true)
 	case config.IsIstanbul(next):
-		return calcDifficultyIstanbul(time, parent)
+		return calcDifficultyIstanbul(time, parent, false)
 	case config.IsConstantinople(next):
-		return calcDifficultyConstantinople(time, parent)
+		return calcDifficultyConstantinople(time, parent, false)
 	case config.IsByzantium(next):
-		return calcDifficultyByzantium(time, parent)
+		return calcDifficultyByzantium(time, parent, false)
 	case config.IsHomestead(next):
 		return calcDifficultyHomestead(time, parent)
 	default:
@@ -406,18 +408,22 @@ var (
 	bigMinus99    = big.NewInt(-99)
 )
 
-func calcDifficultyIstanbul(time uint64, parent *types.Header) *big.Int {
-	return calcDifficultyConstantinople(time, parent)
+func calcDifficultyIstanbul(time uint64, parent *types.Header, neo bool) *big.Int {
+	return calcDifficultyConstantinople(time, parent, neo)
 }
 
-func calcDifficultyConstantinople(time uint64, parent *types.Header) *big.Int {
-	return calcDifficultyByzantium(time, parent)
+func calcDifficultyConstantinople(time uint64, parent *types.Header, neo bool) *big.Int {
+	return calcDifficultyByzantium(time, parent, neo)
+}
+
+func calcDifficultyNeo(time uint64, parent *types.Header, neo bool) *big.Int {
+	return calcDifficultyIstanbul(time, parent, neo)
 }
 
 // calcDifficultyByzantium is the difficulty adjustment algorithm. It returns
 // the difficulty that a new block should have when created at time given the
 // parent block's time and difficulty. The calculation uses the Byzantium rules.
-func calcDifficultyByzantium(time uint64, parent *types.Header) *big.Int {
+func calcDifficultyByzantium(time uint64, parent *types.Header, neo bool) *big.Int {
 	// https://github.com/cortex/EIPs/issues/100.
 	// algorithm:
 	// diff = (parent_diff +
@@ -448,13 +454,16 @@ func calcDifficultyByzantium(time uint64, parent *types.Header) *big.Int {
 		x.Set(big0)
 	}
 
-	// TODO
 	if parent.Difficulty.Cmp(params.MeanDifficultyBoundDivisor) >= 0 && parent.Difficulty.Cmp(params.HighDifficultyBoundDivisor) < 0 {
 		y.Div(parent.Difficulty, params.MeanDifficultyBoundDivisor)
 	} else if parent.Difficulty.Cmp(params.HighDifficultyBoundDivisor) >= 0 {
 		y.Div(parent.Difficulty, params.HighDifficultyBoundDivisor)
 	} else {
-		y.Div(parent.Difficulty, params.DifficultyBoundDivisor)
+		if neo {
+			y = params.MinimumDifficulty // delta 2
+		} else {
+			y.Div(parent.Difficulty, params.DifficultyBoundDivisor_2)
+		}
 
 		if x.Cmp(big0) > 0 {
 			x.Set(big1)
@@ -533,7 +542,7 @@ func makeDifficultyCalculator(bombDelay *big.Int) func(time uint64, parent *type
 			x.Set(bigMinus99)
 		}
 		// parent_diff + (parent_diff / 2048 * max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99))
-		y.Div(parent.Difficulty, params.DifficultyBoundDivisor)
+		y.Div(parent.Difficulty, params.DifficultyBoundDivisor_2)
 		x.Mul(y, x)
 		x.Add(parent.Difficulty, x)
 
@@ -594,7 +603,7 @@ func calcDifficultyHomestead(time uint64, parent *types.Header) *big.Int {
 	} else if parent.Difficulty.Cmp(params.HighDifficultyBoundDivisor) >= 0 {
 		y.Div(parent.Difficulty, params.HighDifficultyBoundDivisor)
 	} else {
-		y.Div(parent.Difficulty, params.DifficultyBoundDivisor)
+		y.Div(parent.Difficulty, params.DifficultyBoundDivisor_2)
 	}
 	x.Mul(y, x)
 	x.Add(parent.Difficulty, x)
@@ -622,7 +631,7 @@ func calcDifficultyHomestead(time uint64, parent *types.Header) *big.Int {
 // block's time and difficulty. The calculation uses the Frontier rules.
 func calcDifficultyFrontier(time uint64, parent *types.Header) *big.Int {
 	diff := new(big.Int)
-	adjust := new(big.Int).Div(parent.Difficulty, params.DifficultyBoundDivisor)
+	adjust := new(big.Int).Div(parent.Difficulty, params.DifficultyBoundDivisor_2)
 	bigTime := new(big.Int)
 	bigParentTime := new(big.Int)
 

consensus/cuckoo/consensus_test.go

@@ -1,7 +1,10 @@
 package cuckoo
 
 import (
+	"encoding/binary"
+	"github.com/CortexFoundation/CortexTheseus/core/types"
 	"math/big"
+	"math/rand"
 	"testing"
 )
 
@@ -17,3 +20,36 @@ func TestReward(t *testing.T) {
 	reward = calculateRewardByNumber(big.NewInt(8409600*4), uint64(21))
 	t.Log(reward)
 }
+
+func TestDifficultyCalculators(t *testing.T) {
+	rand.Seed(2)
+	diff := big.NewInt(10)
+	for i := 0; i < 30; i++ {
+
+		// 1 to 300 seconds diff
+		var timeDelta = uint64(18)
+		//rand.Read(difficulty)
+		header := &types.Header{
+			Difficulty: diff,
+			Number:     new(big.Int).SetUint64(rand.Uint64() % 50_000_000),
+			Time:       rand.Uint64(),
+		}
+		//if rand.Uint32()&1 == 0 {
+		header.UncleHash = types.EmptyUncleHash
+		//}
+
+		diff = calcDifficultyNeo(header.Time+timeDelta, header, true)
+		//t.Log(header.Difficulty)
+		t.Log(diff)
+	}
+}
+
+func randSlice(min, max uint32) []byte {
+	var b = make([]byte, 4)
+	rand.Read(b)
+	a := binary.LittleEndian.Uint32(b)
+	size := min + a%(max-min)
+	out := make([]byte, size)
+	rand.Read(out)
+	return out
+}

core/vm/contracts.go

@@ -76,6 +76,8 @@ var PrecompiledContractsIstanbul = map[common.Address]PrecompiledContract{
 	common.BytesToAddress([]byte{9}): &blake2F{},
 }
 
+var PrecompiledContractsNeo = PrecompiledContractsIstanbul
+
 // PrecompiledContractsBerlin contains the default set of pre-compiled Cortex
 // contracts used in the Berlin release.
 var PrecompiledContractsBerlin = map[common.Address]PrecompiledContract{

core/vm/cvm.go

@@ -68,6 +68,8 @@ func (cvm *CVM) IsInput(code []byte) bool {
 func (cvm *CVM) precompile(addr common.Address) (PrecompiledContract, bool) {
 	var precompiles map[common.Address]PrecompiledContract
 	switch {
+	case cvm.chainRules.IsNeo:
+		precompiles = PrecompiledContractsNeo
 	case cvm.chainRules.IsIstanbul:
 		precompiles = PrecompiledContractsIstanbul
 	case cvm.chainRules.IsByzantium:

core/vm/instructions.go

@@ -871,6 +871,9 @@ func opCall(pc *uint64, interpreter *CVMInterpreter, callContext *callCtx) ([]by
 	}
 	stack.push(&temp)
 	if err == nil || err == ErrExecutionReverted {
+		if interpreter.cvm.chainRules.IsNeo {
+			ret = common.CopyBytes(ret)
+		}
 		callContext.memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
 	}
 	callContext.contract.Gas += returnGas
@@ -906,6 +909,9 @@ func opCallCode(pc *uint64, interpreter *CVMInterpreter, callContext *callCtx) (
 	}
 	stack.push(&temp)
 	if err == nil || err == ErrExecutionReverted {
+		if interpreter.cvm.chainRules.IsNeo {
+			ret = common.CopyBytes(ret)
+		}
 		callContext.memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
 	}
 	callContext.contract.Gas += returnGas
@@ -935,6 +941,9 @@ func opDelegateCall(pc *uint64, interpreter *CVMInterpreter, callContext *callCt
 	}
 	stack.push(&temp)
 	if err == nil || err == ErrExecutionReverted {
+		if interpreter.cvm.chainRules.IsNeo {
+			ret = common.CopyBytes(ret)
+		}
 		callContext.memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
 	}
 	callContext.contract.Gas += returnGas
@@ -964,6 +973,9 @@ func opStaticCall(pc *uint64, interpreter *CVMInterpreter, callContext *callCtx)
 	}
 	stack.push(&temp)
 	if err == nil || err == ErrExecutionReverted {
+		if interpreter.cvm.chainRules.IsNeo {
+			ret = common.CopyBytes(ret)
+		}
 		callContext.memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
 	}
 	callContext.contract.Gas += returnGas

core/vm/interpreter.go

@@ -109,6 +109,8 @@ func NewCVMInterpreter(cvm *CVM, cfg Config) *CVMInterpreter {
 	if cfg.JumpTable[STOP] == nil {
 		var jt JumpTable
 		switch {
+		case cvm.chainRules.IsNeo:
+			jt = neoInstructionSet
 		case cvm.chainRules.IsIstanbul:
 			jt = istanbulInstructionSet
 		case cvm.chainRules.IsConstantinople:
@@ -339,6 +341,7 @@ func (in *CVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 		pcCopy  uint64 // needed for the deferred Tracer
 		gasCopy uint64 // for Tracer to log gas remaining before execution
 		logged  bool   // deferred Tracer should ignore already logged steps
+		res     []byte
 	)
 	// Don't move this deferrred function, it's placed before the capturestate-deferred method,
 	// so that it get's executed _after_: the capturestate needs the stacks before
@@ -369,7 +372,6 @@ func (in *CVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 		contract.Code = contract.Code[2:]
 	}
 	cgas := uint64(0)
-	res := make([]byte, 10)
 	for atomic.LoadInt32(&in.cvm.abort) == 0 {
 		if in.cfg.Debug {
 			// Capture pre-execution values for tracing.
@@ -462,7 +464,11 @@ func (in *CVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 		// if the operation clears the return data (e.g. it has returning data)
 		// set the last return to the result of the operation.
 		if operation.returns {
-			in.returnData = common.CopyBytes(res)
+			if in.cvm.chainRules.IsNeo {
+				in.returnData = res
+			} else {
+				in.returnData = common.CopyBytes(res)
+			}
 		}
 		switch {
 		case err != nil:

core/vm/jump_table.go

@@ -54,11 +54,18 @@ var (
 	byzantiumInstructionSet        = newByzantiumInstructionSet()
 	constantinopleInstructionSet   = newConstantinopleInstructionSet()
 	istanbulInstructionSet         = newIstanbulInstructionSet()
+	neoInstructionSet              = newNeoInstructionSet()
 )
 
 // JumpTable contains the CVM opcodes supported at a given fork.
 type JumpTable [256]*operation
 
+func newNeoInstructionSet() JumpTable {
+	instructionSet := newIstanbulInstructionSet()
+
+	return instructionSet
+}
+
 // newIstanbulInstructionSet returns the frontier, homestead
 // byzantium, contantinople and petersburg instructions.
 func newIstanbulInstructionSet() JumpTable {

miner/worker.go

@@ -1008,7 +1008,7 @@ func (w *worker) commit(uncles []*types.Header, interval func(), update bool, st
 			log.Info("Commit new mining work", "number", block.Number(), "sealhash", w.engine.SealHash(block.Header()),
 				"uncles", len(uncles), "txs", w.current.tcount,
 				"gas", block.GasUsed(), "fees", totalFees(block, receipts),
-				"elapsed", common.PrettyDuration(time.Since(start)))
+				"elapsed", common.PrettyDuration(time.Since(start)), "diff", block.Difficulty())
 
 		case <-w.exitCh:
 			log.Info("Worker has exited")

params/config.go

@@ -130,6 +130,7 @@ var (
 		ConstantinopleBlock: big.NewInt(0),
 		PetersburgBlock:     big.NewInt(0),
 		IstanbulBlock:       big.NewInt(3_230_000),
+		NeoBlock:            big.NewInt(4_650_000),
 		Cuckoo:              new(CuckooConfig),
 	}
 
@@ -147,6 +148,7 @@ var (
 		ConstantinopleBlock: big.NewInt(0),
 		PetersburgBlock:     big.NewInt(0),
 		IstanbulBlock:       big.NewInt(0),
+		NeoBlock:            nil,
 		Clique: &CliqueConfig{
 			Period: 3,
 			Epoch:  30000,
@@ -167,6 +169,7 @@ var (
 		ConstantinopleBlock: big.NewInt(0),
 		PetersburgBlock:     big.NewInt(0),
 		IstanbulBlock:       big.NewInt(0),
+		NeoBlock:            nil,
 		Cuckoo:              new(CuckooConfig),
 	}
 
@@ -184,6 +187,7 @@ var (
 		ConstantinopleBlock: big.NewInt(0),
 		PetersburgBlock:     big.NewInt(0),
 		IstanbulBlock:       big.NewInt(0),
+		NeoBlock:            nil,
 		Clique: &CliqueConfig{
 			Period: 15,
 			Epoch:  30000,
@@ -208,6 +212,7 @@ var (
 		ConstantinopleBlock: big.NewInt(0),
 		PetersburgBlock:     big.NewInt(0),
 		IstanbulBlock:       nil,
+		NeoBlock:            nil,
 		Cuckoo:              new(CuckooConfig),
 		Clique:              nil}
 
@@ -216,9 +221,9 @@ var (
 	//
 	// This configuration is intentionally not using keyed fields to force anyone
 	// adding flags to the config to also have to set these fields.
-	AllCliqueProtocolChanges = &ChainConfig{big.NewInt(1337), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, nil, nil, &CliqueConfig{Period: 0, Epoch: 30000}}
+	AllCliqueProtocolChanges = &ChainConfig{big.NewInt(1337), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, nil, nil, nil, &CliqueConfig{Period: 0, Epoch: 30000}}
 
-	TestChainConfig = &ChainConfig{big.NewInt(1), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, nil, new(CuckooConfig), nil}
+	TestChainConfig = &ChainConfig{big.NewInt(1), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, nil, nil, new(CuckooConfig), nil}
 	TestRules       = TestChainConfig.Rules(new(big.Int))
 )
 
@@ -246,6 +251,7 @@ type ChainConfig struct {
 	ConstantinopleBlock *big.Int `json:"constantinopleBlock,omitempty"` // Constantinople switch block (nil = no fork, 0 = already activated)
 	PetersburgBlock     *big.Int `json:"petersburgBlock,omitempty"`     // Petersburg switch block (nil = same as Constantinople)
 	IstanbulBlock       *big.Int `json:"istanbulBlock,omitempty"`       // Istanbul switch block (nil = no fork, 0 = already on istanbul)
+	NeoBlock            *big.Int `json:"neoBlock,omitempty"`
 	// Various consensus engines
 	Cuckoo *CuckooConfig `json:"cuckoo,omitempty"`
 	Clique *CliqueConfig `json:"clique,omitempty"`
@@ -280,7 +286,7 @@ func (c *ChainConfig) String() string {
 	default:
 		engine = "unknown"
 	}
-	return fmt.Sprintf("{ChainID: %v Homestead: %v DAO: %v DAOSupport: %v TangerineWhistle(EIP150): %v SpuriousDragon(EIP155): %v SpuriousDragon(EIP158): %v Byzantium: %v Constantinople: %v Petersburg: %v Istanbul: %v Engine: %v}",
+	return fmt.Sprintf("{ChainID: %v Homestead: %v DAO: %v DAOSupport: %v TangerineWhistle(EIP150): %v SpuriousDragon(EIP155): %v SpuriousDragon(EIP158): %v Byzantium: %v Constantinople: %v Petersburg: %v Istanbul: %v Neo:%v Engine: %v}",
 		c.ChainID,
 		c.HomesteadBlock,
 		c.DAOForkBlock,
@@ -292,6 +298,7 @@ func (c *ChainConfig) String() string {
 		c.ConstantinopleBlock,
 		c.PetersburgBlock,
 		c.IstanbulBlock,
+		c.NeoBlock,
 		engine,
 	)
 }
@@ -342,6 +349,10 @@ func (c *ChainConfig) IsIstanbul(num *big.Int) bool {
 	return isForked(c.IstanbulBlock, num)
 }
 
+func (c *ChainConfig) IsNeo(num *big.Int) bool {
+	return isForked(c.NeoBlock, num)
+}
+
 // GasTable returns the gas table corresponding to the current phase (homestead or homestead reprice).
 //
 // The returned GasTable's fields shouldn't, under any circumstances, be changed.
@@ -397,6 +408,7 @@ func (c *ChainConfig) CheckConfigForkOrder() error {
 		{name: "constantinopleBlock", block: c.ConstantinopleBlock},
 		{name: "petersburgBlock", block: c.PetersburgBlock},
 		{name: "istanbulBlock", block: c.IstanbulBlock},
+		{name: "neoBlock", block: c.NeoBlock},
 	} {
 		if lastFork.name != "" {
 			// Next one must be higher number
@@ -456,6 +468,10 @@ func (c *ChainConfig) checkCompatible(newcfg *ChainConfig, head *big.Int) *Confi
 	if isForkIncompatible(c.IstanbulBlock, newcfg.IstanbulBlock, head) {
 		return newCompatError("Istanbul fork block", c.IstanbulBlock, newcfg.IstanbulBlock)
 	}
+
+	if isForkIncompatible(c.NeoBlock, newcfg.NeoBlock, head) {
+		return newCompatError("Neo fork block", c.NeoBlock, newcfg.NeoBlock)
+	}
 	return nil
 }
 
@@ -521,9 +537,9 @@ func (err *ConfigCompatError) Error() string {
 // Rules is a one time interface meaning that it shouldn't be used in between transition
 // phases.
 type Rules struct {
-	ChainID                                                 *big.Int
-	IsHomestead, IsEIP150, IsEIP155, IsEIP158               bool
-	IsByzantium, IsConstantinople, IsPetersburg, IsIstanbul bool
+	ChainID                                                        *big.Int
+	IsHomestead, IsEIP150, IsEIP155, IsEIP158                      bool
+	IsByzantium, IsConstantinople, IsPetersburg, IsIstanbul, IsNeo bool
 }
 
 // Rules ensures c's ChainID is not nil.
@@ -532,7 +548,7 @@ func (c *ChainConfig) Rules(num *big.Int) Rules {
 	if chainID == nil {
 		chainID = new(big.Int)
 	}
-	return Rules{ChainID: new(big.Int).Set(chainID), IsHomestead: c.IsHomestead(num), IsEIP150: c.IsEIP150(num), IsEIP155: c.IsEIP155(num), IsEIP158: c.IsEIP158(num), IsByzantium: c.IsByzantium(num), IsPetersburg: c.IsPetersburg(num), IsIstanbul: c.IsIstanbul(num)}
+	return Rules{ChainID: new(big.Int).Set(chainID), IsHomestead: c.IsHomestead(num), IsEIP150: c.IsEIP150(num), IsEIP155: c.IsEIP155(num), IsEIP158: c.IsEIP158(num), IsByzantium: c.IsByzantium(num), IsPetersburg: c.IsPetersburg(num), IsIstanbul: c.IsIstanbul(num), IsNeo: c.IsNeo(num)}
 }
 
 // Get Mature Block