block: drop staterootinheader, make it a block version 1

Signed-off-by: Roman Khimov <[email protected]>

Author: roman-khimov

cli/server/cli_server_test.go

@@ -61,13 +61,6 @@ func TestServerStart(t *testing.T) {
 		})
 		e.RunWithError(t, baseCmd...)
 	})
-	t.Run("stateroot service is on && StateRootInHeader=true", func(t *testing.T) {
-		saveCfg(t, func(cfg *config.Config) {
-			cfg.ApplicationConfiguration.StateRoot.Enabled = true
-			cfg.ProtocolConfiguration.StateRootInHeader = true
-		})
-		e.RunWithError(t, baseCmd...)
-	})
 	t.Run("invalid Oracle config", func(t *testing.T) {
 		saveCfg(t, func(cfg *config.Config) {
 			cfg.ApplicationConfiguration.Oracle.Enabled = true

cli/server/server.go

@@ -276,7 +276,7 @@ func restoreDB(ctx *cli.Context) error {
 	}
 
 	var buf []byte
-	if versionOrLen == block.VersionInitial {
+	if versionOrLen == block.VersionInitial || versionOrLen == block.VersionFaun {
 		// Block length > 0 => we read block version, so we have ordinary chain dump.
 		buf = binary.LittleEndian.AppendUint32(buf, allBlocks)
 		allBlocks = start

cli/vm/cli_test.go

@@ -129,7 +129,9 @@ func newTestVMClIWithState(t *testing.T) *executor {
 	store, err := storage.NewLevelDBStore(opts)
 	require.NoError(t, err)
 	customConfig := func(c *config.Blockchain) {
-		c.StateRootInHeader = true // Need for P2PStateExchangeExtensions check.
+		c.Hardforks = map[string]uint32{
+			config.HFFaun.String(): 0, // Need for P2PStateExchangeExtensions check.
+		}
 	}
 	bc, validators, committee, err := chain.NewMultiWithCustomConfigAndStoreNoCheck(t, customConfig, store)
 	require.NoError(t, err)
@@ -148,7 +150,6 @@ func newTestVMClIWithState(t *testing.T) *executor {
 	require.NoError(t, err)
 	cfg.ApplicationConfiguration.DBConfiguration.Type = dbconfig.LevelDB
 	cfg.ApplicationConfiguration.DBConfiguration.LevelDBOptions = opts
-	cfg.ProtocolConfiguration.StateRootInHeader = protoCfg.StateRootInHeader
 	cfg.ProtocolConfiguration.P2PStateExchangeExtensions = protoCfg.P2PStateExchangeExtensions
 	cfg.ProtocolConfiguration.Hardforks = protoCfg.Hardforks
 	return newTestVMCLIWithLogoAndCustomConfig(t, false, &cfg)

config/protocol.privnet.docker.single.yml

@@ -13,6 +13,12 @@ ProtocolConfiguration:
     - node_single:20333
   VerifyTransactions: true
   P2PSigExtensions: false
+  Hardforks:
+    Aspidochelone: 5
+    Basilisk: 10
+    Cockatrice: 15
+    Domovoi: 20
+    Echidna: 50
 
 ApplicationConfiguration:
   SkipBlockVerification: false

config/protocol.testnet.neofs.yml

@@ -16,7 +16,6 @@ ProtocolConfiguration:
   - 0272350def90715494b857315c9b9c70181739eeec52d777424fef2891c3396cad
   - 03a8cee2d3877bcce5b4595578714d77ca2d47673150b8b9cd4e391b7c73b6bda3
   - 0215e735a657f6e23478728d1d0718d516bf50c06c2abd92ec7c00eba2bd7a2552
-  StateRootInHeader: false
   ValidatorsCount: 7
   SeedList:
   - morph1.t5.fs.neo.org:50333

config/protocol.unit_testnet.yml

@@ -25,6 +25,7 @@ ProtocolConfiguration:
     Cockatrice: 3
     Domovoi: 4
     Echidna: 5
+    Faun: 6
 
 ApplicationConfiguration:
   SkipBlockVerification: false

internal/fakechain/fakechain.go

@@ -56,6 +56,11 @@ type FakeStateSync struct {
 	AddMPTNodesFunc   func(nodes [][]byte) error
 }
 
+// IsHardforkEnabled implements Blockchainer interface.
+func (s *FakeStateSync) IsHardforkEnabled(hf *config.Hardfork, blockHeight uint32) bool {
+	return false
+}
+
 // HeaderHeight returns the height of the latest stored header.
 func (s *FakeStateSync) HeaderHeight() uint32 {
 	return 0

pkg/compiler/interop_test.go

@@ -373,7 +373,7 @@ func TestAppCall(t *testing.T) {
 	}
 
 	fc := fakechain.NewFakeChain()
-	ic := interop.NewContext(trigger.Application, fc, dao.NewSimple(storage.NewMemoryStore(), false),
+	ic := interop.NewContext(trigger.Application, fc, dao.NewSimple(storage.NewMemoryStore()),
 		interop.DefaultBaseExecFee, native.DefaultStoragePrice, contractGetter, nil, nil, nil, nil, zaptest.NewLogger(t))
 
 	t.Run("valid script", func(t *testing.T) {

pkg/config/protocol_config.go

@@ -56,8 +56,6 @@ type (
 
 		SeedList         []string `yaml:"SeedList"`
 		StandbyCommittee []string `yaml:"StandbyCommittee"`
-		// StateRootInHeader enables storing state root in block header.
-		StateRootInHeader bool `yaml:"StateRootInHeader"`
 		// StateSyncInterval is the number of blocks between state heights available for MPT state data synchronization.
 		// It is valid only if P2PStateExchangeExtensions are enabled.
 		StateSyncInterval int `yaml:"StateSyncInterval"`
@@ -243,7 +241,6 @@ func (p *ProtocolConfiguration) Equals(o *ProtocolConfiguration) bool {
 		p.P2PSigExtensions != o.P2PSigExtensions ||
 		p.P2PStateExchangeExtensions != o.P2PStateExchangeExtensions ||
 		p.ReservedAttributes != o.ReservedAttributes ||
-		p.StateRootInHeader != o.StateRootInHeader ||
 		p.StateSyncInterval != o.StateSyncInterval ||
 		p.TimePerBlock != o.TimePerBlock ||
 		p.Genesis.MaxValidUntilBlockIncrement != o.Genesis.MaxValidUntilBlockIncrement ||

pkg/consensus/consensus.go

@@ -44,6 +44,7 @@ type Ledger interface {
 	GetStateRoot(height uint32) (*state.MPTRoot, error)
 	GetTransaction(util.Uint256) (*transaction.Transaction, uint32, error)
 	ComputeNextBlockValidators() []*keys.PublicKey
+	IsHardforkEnabled(hf *config.Hardfork, blockHeight uint32) bool
 	GetMillisecondsPerBlock() uint32
 	PoolTx(t *transaction.Transaction, pools ...*mempool.Pool) error
 	SubscribeForBlocks(ch chan *coreb.Block)
@@ -216,27 +217,24 @@ var (
 )
 
 // NewPayload creates a new consensus payload for the provided network.
-func NewPayload(m netmode.Magic, stateRootEnabled bool) *Payload {
+func NewPayload(m netmode.Magic) *Payload {
 	return &Payload{
 		Extensible: npayload.Extensible{
 			Category: npayload.ConsensusCategory,
 		},
-		message: message{
-			stateRootEnabled: stateRootEnabled,
-		},
 		network: m,
 	}
 }
 
 func (s *service) newPayload(c *dbft.Context[util.Uint256], t dbft.MessageType, msg any) dbft.ConsensusPayload[util.Uint256] {
-	cp := NewPayload(s.ProtocolConfiguration.Magic, s.ProtocolConfiguration.StateRootInHeader)
+	cp := NewPayload(s.ProtocolConfiguration.Magic)
 	cp.BlockIndex = c.BlockIndex
 	cp.message.ValidatorIndex = byte(c.MyIndex)
 	cp.message.ViewNumber = c.ViewNumber
 	cp.message.Type = messageType(t)
 	if pr, ok := msg.(*prepareRequest); ok {
 		pr.prevHash = s.dbft.PrevHash
-		pr.version = coreb.VersionInitial
+		pr.version = coreb.VersionInitial // TODO: ?
 	}
 	cp.payload = msg.(io.Serializable)
 
@@ -249,12 +247,14 @@ func (s *service) newPayload(c *dbft.Context[util.Uint256], t dbft.MessageType,
 
 func (s *service) newPrepareRequest(ts uint64, nonce uint64, transactionsHashes []util.Uint256) dbft.PrepareRequest[util.Uint256] {
 	r := &prepareRequest{
+		version:           coreb.VersionInitial,
 		timestamp:         ts / nsInMs,
 		nonce:             nonce,
 		transactionHashes: transactionsHashes,
 	}
-	if s.ProtocolConfiguration.StateRootInHeader {
-		r.stateRootEnabled = true
+	var f = config.HFFaun
+	if s.Chain.IsHardforkEnabled(&f, s.dbft.BlockIndex) {
+		r.version = coreb.VersionFaun
 		if sr, err := s.Chain.GetStateRoot(s.dbft.BlockIndex - 1); err == nil {
 			r.stateRoot = sr.Root
 		} else {
@@ -291,9 +291,7 @@ func (s *service) newRecoveryRequest(ts uint64) dbft.RecoveryRequest {
 }
 
 func (s *service) newRecoveryMessage() dbft.RecoveryMessage[util.Uint256] {
-	return &recoveryMessage{
-		stateRootEnabled: s.ProtocolConfiguration.StateRootInHeader,
-	}
+	return new(recoveryMessage)
 }
 
 // Name returns service name.
@@ -464,9 +462,6 @@ func (s *service) getKeyPair(pubs []dbft.PublicKey) (int, dbft.PrivateKey, dbft.
 func (s *service) payloadFromExtensible(ep *npayload.Extensible) *Payload {
 	return &Payload{
 		Extensible: *ep,
-		message: message{
-			stateRootEnabled: s.ProtocolConfiguration.StateRootInHeader,
-		},
 	}
 }
 
@@ -597,16 +592,28 @@ func (s *service) verifyRequest(p dbft.ConsensusPayload[util.Uint256]) error {
 	if req.prevHash != s.dbft.PrevHash {
 		return errInvalidPrevHash
 	}
-	if req.version != coreb.VersionInitial {
-		return errInvalidVersion
+	var (
+		f               = config.HFFaun
+		expectedVersion = coreb.VersionInitial
+	)
+	if s.Chain.IsHardforkEnabled(&f, s.dbft.BlockIndex) {
+		expectedVersion = coreb.VersionFaun
+	}
+	if req.version != expectedVersion {
+		return fmt.Errorf("%w: expected %d, got %d", errInvalidVersion, expectedVersion, req.version)
 	}
-	if s.ProtocolConfiguration.StateRootInHeader {
+	if req.version == coreb.VersionFaun {
 		sr, err := s.Chain.GetStateRoot(s.dbft.BlockIndex - 1)
 		if err != nil {
 			return err
 		} else if sr.Root != req.stateRoot {
 			return fmt.Errorf("%w: %s != %s", errInvalidStateRoot, sr.Root, req.stateRoot)
 		}
+	} else {
+		// TODO: port this check to C# node:
+		if !req.stateRoot.Equals(util.Uint256{}) {
+			return fmt.Errorf("stateroot is not empty, but Faun is not enabled yet: %s", req.stateRoot)
+		}
 	}
 	if len(req.TransactionHashes()) > int(s.ProtocolConfiguration.MaxTransactionsPerBlock) {
 		return fmt.Errorf("%w: max = %d, got %d", errInvalidTransactionsCount, s.ProtocolConfiguration.MaxTransactionsPerBlock, len(req.TransactionHashes()))
@@ -756,17 +763,23 @@ func convertKeys(validators []dbft.PublicKey) (pubs []*keys.PublicKey) {
 }
 
 func (s *service) newBlockFromContext(ctx *dbft.Context[util.Uint256]) dbft.Block[util.Uint256] {
-	block := &neoBlock{network: s.ProtocolConfiguration.Magic}
+	var (
+		blockVersion = coreb.VersionInitial
+		block        = &neoBlock{network: s.ProtocolConfiguration.Magic}
+	)
 
+	hff, ok := s.ProtocolConfiguration.Hardforks[config.HFFaun.String()]
+	if ok && hff <= ctx.BlockIndex {
+		blockVersion = coreb.VersionFaun
+	}
 	block.Block.Timestamp = ctx.Timestamp / nsInMs
 	block.Nonce = ctx.Nonce
 	block.Block.Index = ctx.BlockIndex
-	if s.ProtocolConfiguration.StateRootInHeader {
+	if blockVersion > coreb.VersionInitial {
 		sr, err := s.Chain.GetStateRoot(ctx.BlockIndex - 1)
 		if err != nil {
 			s.log.Fatal(fmt.Sprintf("failed to get state root: %s", err.Error()))
 		}
-		block.StateRootEnabled = true
 		block.PrevStateRoot = sr.Root
 	}
 
@@ -787,7 +800,7 @@ func (s *service) newBlockFromContext(ctx *dbft.Context[util.Uint256]) dbft.Bloc
 	}
 	block.NextConsensus = hash.Hash160(script)
 	block.Block.PrevHash = ctx.PrevHash
-	block.Version = coreb.VersionInitial
+	block.Version = blockVersion
 
 	primaryIndex := byte(ctx.PrimaryIndex)
 	block.PrimaryIndex = primaryIndex