From 1869d6d46084dc75996b03fe57e677828cee1f67 Mon Sep 17 00:00:00 2001 From: Evgenii Stratonikov Date: Tue, 17 Nov 2020 15:57:50 +0300 Subject: [PATCH] core: allow to use state root in header --- cli/server/server.go | 2 +- pkg/compiler/interop_test.go | 2 +- pkg/config/protocol_config.go | 4 +- pkg/consensus/consensus.go | 59 +++++++++++++++++++++----- pkg/consensus/consensus_test.go | 34 ++++++++++++++- pkg/consensus/payload.go | 14 +++++- pkg/consensus/payload_test.go | 5 ++- pkg/consensus/prepare_request.go | 8 ++++ pkg/consensus/recovery_message.go | 17 +++++--- pkg/consensus/recovery_message_test.go | 26 ++++++++---- pkg/core/block/block.go | 10 +++-- pkg/core/block/block_base.go | 21 +++++++++ pkg/core/block/block_test.go | 10 ++--- pkg/core/block/header_test.go | 19 ++++++++- pkg/core/block/helper_test.go | 2 +- pkg/core/blockchain.go | 14 +++++- pkg/core/blockchain_test.go | 29 ++++++++++++- pkg/core/dao/cacheddao_test.go | 4 +- pkg/core/dao/dao.go | 10 +++-- pkg/core/dao/dao_test.go | 28 ++++++------ pkg/core/helper_test.go | 23 +++++++++- pkg/core/interop_neo_test.go | 13 +++--- pkg/core/interops_test.go | 3 +- pkg/core/native_contract_test.go | 4 +- pkg/core/native_designate_test.go | 2 +- pkg/core/native_oracle_test.go | 2 +- pkg/network/message.go | 11 +++-- pkg/network/payload/headers.go | 3 ++ pkg/network/server.go | 25 ++++++----- pkg/network/tcp_peer.go | 2 +- pkg/rpc/client/client.go | 18 ++++---- pkg/rpc/client/rpc.go | 7 ++- pkg/rpc/client/rpc_test.go | 2 +- pkg/rpc/client/wsclient.go | 2 +- pkg/rpc/response/result/version.go | 2 + pkg/rpc/server/server.go | 34 ++++++++------- pkg/rpc/server/server_helper_test.go | 2 +- 37 files changed, 349 insertions(+), 124 deletions(-) diff --git a/cli/server/server.go b/cli/server/server.go index b4a874963..ff538269c 100644 --- a/cli/server/server.go +++ b/cli/server/server.go @@ -281,7 +281,7 @@ func restoreDB(ctx *cli.Context) error { default: } bytes, err := readBlock(reader) - block := block.New(cfg.ProtocolConfiguration.Magic) + block := block.New(cfg.ProtocolConfiguration.Magic, cfg.ProtocolConfiguration.StateRootInHeader) newReader := io.NewBinReaderFromBuf(bytes) block.DecodeBinary(newReader) if err != nil { diff --git a/pkg/compiler/interop_test.go b/pkg/compiler/interop_test.go index 901217b96..c484f5db4 100644 --- a/pkg/compiler/interop_test.go +++ b/pkg/compiler/interop_test.go @@ -105,7 +105,7 @@ func TestAppCall(t *testing.T) { require.NoError(t, err) ih := hash.Hash160(inner) - ic := interop.NewContext(trigger.Application, nil, dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet), nil, nil, nil, zaptest.NewLogger(t)) + ic := interop.NewContext(trigger.Application, nil, dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false), nil, nil, nil, zaptest.NewLogger(t)) require.NoError(t, ic.DAO.PutContractState(&state.Contract{ Script: inner, Manifest: *m, diff --git a/pkg/config/protocol_config.go b/pkg/config/protocol_config.go index f9beb5100..c934a5a7a 100644 --- a/pkg/config/protocol_config.go +++ b/pkg/config/protocol_config.go @@ -24,7 +24,9 @@ type ( SecondsPerBlock int `yaml:"SecondsPerBlock"` SeedList []string `yaml:"SeedList"` StandbyCommittee []string `yaml:"StandbyCommittee"` - ValidatorsCount int `yaml:"ValidatorsCount"` + // StateRooInHeader enables storing state root in block header. + StateRootInHeader bool `yaml:"StateRootInHeader"` + ValidatorsCount int `yaml:"ValidatorsCount"` // Whether to verify received blocks. VerifyBlocks bool `yaml:"VerifyBlocks"` // Whether to verify transactions in received blocks. diff --git a/pkg/consensus/consensus.go b/pkg/consensus/consensus.go index 3cd091d0f..696b99e02 100644 --- a/pkg/consensus/consensus.go +++ b/pkg/consensus/consensus.go @@ -2,6 +2,7 @@ package consensus import ( "errors" + "fmt" "sort" "time" @@ -73,6 +74,8 @@ type service struct { lastProposal []util.Uint256 wallet *wallet.Wallet network netmode.Magic + // stateRootEnabled specifies if state root should be exchanged and checked during consensus. + stateRootEnabled bool // started is a flag set with Start method that runs an event handling // goroutine. started *atomic.Bool @@ -116,12 +119,13 @@ func NewService(cfg Config) (Service, error) { txx: newFIFOCache(cacheMaxCapacity), messages: make(chan Payload, 100), - transactions: make(chan *transaction.Transaction, 100), - blockEvents: make(chan *coreb.Block, 1), - network: cfg.Chain.GetConfig().Magic, - started: atomic.NewBool(false), - quit: make(chan struct{}), - finished: make(chan struct{}), + transactions: make(chan *transaction.Transaction, 100), + blockEvents: make(chan *coreb.Block, 1), + network: cfg.Chain.GetConfig().Magic, + stateRootEnabled: cfg.Chain.GetConfig().StateRootInHeader, + started: atomic.NewBool(false), + quit: make(chan struct{}), + finished: make(chan struct{}), } if cfg.Wallet == nil { @@ -168,12 +172,14 @@ func NewService(cfg Config) (Service, error) { dbft.WithGetConsensusAddress(srv.getConsensusAddress), dbft.WithNewConsensusPayload(srv.newPayload), - dbft.WithNewPrepareRequest(func() payload.PrepareRequest { return new(prepareRequest) }), + dbft.WithNewPrepareRequest(srv.newPrepareRequest), dbft.WithNewPrepareResponse(func() payload.PrepareResponse { return new(prepareResponse) }), dbft.WithNewChangeView(func() payload.ChangeView { return new(changeView) }), dbft.WithNewCommit(func() payload.Commit { return new(commit) }), dbft.WithNewRecoveryRequest(func() payload.RecoveryRequest { return new(recoveryRequest) }), - dbft.WithNewRecoveryMessage(func() payload.RecoveryMessage { return new(recoveryMessage) }), + dbft.WithNewRecoveryMessage(func() payload.RecoveryMessage { + return &recoveryMessage{stateRootEnabled: srv.stateRootEnabled} + }), dbft.WithVerifyPrepareRequest(srv.verifyRequest), dbft.WithVerifyPrepareResponse(func(_ payload.ConsensusPayload) error { return nil }), ) @@ -191,15 +197,30 @@ var ( ) // NewPayload creates new consensus payload for the provided network. -func NewPayload(m netmode.Magic) *Payload { +func NewPayload(m netmode.Magic, stateRootEnabled bool) *Payload { return &Payload{ network: m, - message: new(message), + message: &message{ + stateRootEnabled: stateRootEnabled, + }, } } func (s *service) newPayload() payload.ConsensusPayload { - return NewPayload(s.network) + return NewPayload(s.network, s.stateRootEnabled) +} + +func (s *service) newPrepareRequest() payload.PrepareRequest { + r := new(prepareRequest) + if s.stateRootEnabled { + r.stateRootEnabled = true + if sr, err := s.Chain.GetStateRoot(s.dbft.BlockIndex - 1); err == nil { + r.stateRoot = sr.Root + } else { + panic(err) + } + } + return r } func (s *service) Start() { @@ -446,6 +467,14 @@ func (s *service) verifyBlock(b block.Block) bool { func (s *service) verifyRequest(p payload.ConsensusPayload) error { req := p.GetPrepareRequest().(*prepareRequest) + if s.stateRootEnabled { + sr, err := s.Chain.GetStateRoot(s.dbft.BlockIndex - 1) + if err != nil { + return err + } else if sr.Root != req.stateRoot { + return fmt.Errorf("state root mismatch: %s != %s", sr.Root, req.stateRoot) + } + } // Save lastProposal for getVerified(). s.lastProposal = req.transactionHashes @@ -584,6 +613,14 @@ func (s *service) newBlockFromContext(ctx *dbft.Context) block.Block { block.Block.Network = s.network block.Block.Timestamp = ctx.Timestamp / nsInMs block.Block.Index = ctx.BlockIndex + if s.stateRootEnabled { + sr, err := s.Chain.GetStateRoot(ctx.BlockIndex - 1) + if err != nil { + return nil + } + block.StateRootEnabled = true + block.PrevStateRoot = sr.Root + } var validators keys.PublicKeys var err error diff --git a/pkg/consensus/consensus_test.go b/pkg/consensus/consensus_test.go index ccb28e928..d269ad35a 100644 --- a/pkg/consensus/consensus_test.go +++ b/pkg/consensus/consensus_test.go @@ -285,6 +285,31 @@ func TestService_getTx(t *testing.T) { srv.Chain.Close() } +func TestService_PrepareRequest(t *testing.T) { + srv := newTestServiceWithState(t, true) + srv.dbft.Start() + defer srv.dbft.Timer.Stop() + + priv, _ := getTestValidator(1) + p := new(Payload) + p.message = &message{} + p.SetValidatorIndex(1) + + p.SetPayload(&prepareRequest{}) + require.NoError(t, p.Sign(priv)) + require.Error(t, srv.verifyRequest(p), "invalid stateroot setting") + + p.SetPayload(&prepareRequest{stateRootEnabled: true}) + require.NoError(t, p.Sign(priv)) + require.Error(t, srv.verifyRequest(p), "invalid state root") + + sr, err := srv.Chain.GetStateRoot(srv.dbft.BlockIndex - 1) + require.NoError(t, err) + p.SetPayload(&prepareRequest{stateRootEnabled: true, stateRoot: sr.Root}) + require.NoError(t, p.Sign(priv)) + require.NoError(t, srv.verifyRequest(p)) +} + func TestService_OnPayload(t *testing.T) { srv := newTestService(t) // This test directly reads things from srv.messages that normally @@ -407,8 +432,12 @@ func shouldNotReceive(t *testing.T, ch chan Payload) { } } +func newTestServiceWithState(t *testing.T, stateRootInHeader bool) *service { + return newTestServiceWithChain(t, newTestChain(t, stateRootInHeader)) +} + func newTestService(t *testing.T) *service { - return newTestServiceWithChain(t, newTestChain(t)) + return newTestServiceWithState(t, false) } func newTestServiceWithChain(t *testing.T, bc *core.Blockchain) *service { @@ -445,9 +474,10 @@ func newSingleTestChain(t *testing.T) *core.Blockchain { return chain } -func newTestChain(t *testing.T) *core.Blockchain { +func newTestChain(t *testing.T, stateRootInHeader bool) *core.Blockchain { unitTestNetCfg, err := config.Load("../../config", netmode.UnitTestNet) require.NoError(t, err) + unitTestNetCfg.ProtocolConfiguration.StateRootInHeader = stateRootInHeader chain, err := core.NewBlockchain(storage.NewMemoryStore(), unitTestNetCfg.ProtocolConfiguration, zaptest.NewLogger(t)) require.NoError(t, err) diff --git a/pkg/consensus/payload.go b/pkg/consensus/payload.go index 33c29161b..ce563e4eb 100644 --- a/pkg/consensus/payload.go +++ b/pkg/consensus/payload.go @@ -21,6 +21,8 @@ type ( ViewNumber byte payload io.Serializable + // stateRootEnabled specifies if state root is exchanged during consensus. + stateRootEnabled bool } // Payload is a type for consensus-related messages. @@ -302,7 +304,11 @@ func (m *message) DecodeBinary(r *io.BinReader) { cv.newViewNumber = m.ViewNumber + 1 m.payload = cv case prepareRequestType: - m.payload = new(prepareRequest) + r := new(prepareRequest) + if m.stateRootEnabled { + r.stateRootEnabled = true + } + m.payload = r case prepareResponseType: m.payload = new(prepareResponse) case commitType: @@ -310,7 +316,11 @@ func (m *message) DecodeBinary(r *io.BinReader) { case recoveryRequestType: m.payload = new(recoveryRequest) case recoveryMessageType: - m.payload = new(recoveryMessage) + r := new(recoveryMessage) + if m.stateRootEnabled { + r.stateRootEnabled = true + } + m.payload = r default: r.Err = fmt.Errorf("invalid type: 0x%02x", byte(m.Type)) return diff --git a/pkg/consensus/payload_test.go b/pkg/consensus/payload_test.go index e74803c57..9ebbc5201 100644 --- a/pkg/consensus/payload_test.go +++ b/pkg/consensus/payload_test.go @@ -104,12 +104,13 @@ func TestConsensusPayload_Serializable(t *testing.T) { require.Nil(t, actual.message) actual.message = new(message) // message should now be decoded from actual.data byte array + actual.message = new(message) assert.NoError(t, actual.decodeData()) assert.NotNil(t, actual.MarshalUnsigned()) require.Equal(t, p, actual) data = p.MarshalUnsigned() - pu := NewPayload(netmode.Magic(rand.Uint32())) + pu := NewPayload(netmode.Magic(rand.Uint32()), false) require.NoError(t, pu.UnmarshalUnsigned(data)) assert.NoError(t, pu.decodeData()) _ = pu.MarshalUnsigned() @@ -316,7 +317,7 @@ func TestPayload_Sign(t *testing.T) { p := randomPayload(t, prepareRequestType) h := priv.PublicKey().GetScriptHash() - bc := newTestChain(t) + bc := newTestChain(t, false) defer bc.Close() require.Error(t, bc.VerifyWitness(h, p, &p.Witness, payloadGasLimit)) require.NoError(t, p.Sign(priv)) diff --git a/pkg/consensus/prepare_request.go b/pkg/consensus/prepare_request.go index ad745f9c6..9099740fe 100644 --- a/pkg/consensus/prepare_request.go +++ b/pkg/consensus/prepare_request.go @@ -12,6 +12,8 @@ type prepareRequest struct { timestamp uint64 nonce uint64 transactionHashes []util.Uint256 + stateRootEnabled bool + stateRoot util.Uint256 } var _ payload.PrepareRequest = (*prepareRequest)(nil) @@ -21,6 +23,9 @@ func (p *prepareRequest) EncodeBinary(w *io.BinWriter) { w.WriteU64LE(p.timestamp) w.WriteU64LE(p.nonce) w.WriteArray(p.transactionHashes) + if p.stateRootEnabled { + w.WriteBytes(p.stateRoot[:]) + } } // DecodeBinary implements io.Serializable interface. @@ -28,6 +33,9 @@ func (p *prepareRequest) DecodeBinary(r *io.BinReader) { p.timestamp = r.ReadU64LE() p.nonce = r.ReadU64LE() r.ReadArray(&p.transactionHashes, block.MaxTransactionsPerBlock) + if p.stateRootEnabled { + r.ReadBytes(p.stateRoot[:]) + } } // Timestamp implements payload.PrepareRequest interface. diff --git a/pkg/consensus/recovery_message.go b/pkg/consensus/recovery_message.go index 44151aff4..c094c7f3c 100644 --- a/pkg/consensus/recovery_message.go +++ b/pkg/consensus/recovery_message.go @@ -16,6 +16,7 @@ type ( preparationPayloads []*preparationCompact commitPayloads []*commitCompact changeViewPayloads []*changeViewCompact + stateRootEnabled bool prepareRequest *message } @@ -47,7 +48,7 @@ func (m *recoveryMessage) DecodeBinary(r *io.BinReader) { var hasReq = r.ReadBool() if hasReq { - m.prepareRequest = new(message) + m.prepareRequest = &message{stateRootEnabled: m.stateRootEnabled} m.prepareRequest.DecodeBinary(r) if r.Err == nil && m.prepareRequest.Type != prepareRequestType { r.Err = errors.New("recovery message PrepareRequest has wrong type") @@ -143,9 +144,10 @@ func (m *recoveryMessage) AddPayload(p payload.ConsensusPayload) { switch p.Type() { case payload.PrepareRequestType: m.prepareRequest = &message{ - Type: prepareRequestType, - ViewNumber: p.ViewNumber(), - payload: p.GetPrepareRequest().(*prepareRequest), + Type: prepareRequestType, + ViewNumber: p.ViewNumber(), + payload: p.GetPrepareRequest().(*prepareRequest), + stateRootEnabled: m.stateRootEnabled, } h := p.Hash() m.preparationHash = &h @@ -291,9 +293,10 @@ func fromPayload(t messageType, recovery *Payload, p io.Serializable) *Payload { return &Payload{ network: recovery.network, message: &message{ - Type: t, - ViewNumber: recovery.message.ViewNumber, - payload: p, + Type: t, + ViewNumber: recovery.message.ViewNumber, + payload: p, + stateRootEnabled: recovery.stateRootEnabled, }, version: recovery.Version(), prevHash: recovery.PrevHash(), diff --git a/pkg/consensus/recovery_message_test.go b/pkg/consensus/recovery_message_test.go index 47471a0e6..b0fb4237b 100644 --- a/pkg/consensus/recovery_message_test.go +++ b/pkg/consensus/recovery_message_test.go @@ -12,8 +12,17 @@ import ( "github.com/stretchr/testify/require" ) -func TestRecoveryMessage_Setters(t *testing.T) { - srv := newTestService(t) +func TestRecoveryMessageSetters(t *testing.T) { + t.Run("NoStateRoot", func(t *testing.T) { + testRecoveryMessageSetters(t, false) + }) + t.Run("WithStateRoot", func(t *testing.T) { + testRecoveryMessageSetters(t, true) + }) +} + +func testRecoveryMessageSetters(t *testing.T, enableStateRoot bool) { + srv := newTestServiceWithState(t, enableStateRoot) defer srv.Chain.Close() privs := make([]*privateKey, testchain.Size()) pubs := make([]crypto.PublicKey, testchain.Size()) @@ -21,8 +30,8 @@ func TestRecoveryMessage_Setters(t *testing.T) { privs[i], pubs[i] = getTestValidator(i) } - r := &recoveryMessage{} - p := NewPayload(netmode.UnitTestNet) + r := &recoveryMessage{stateRootEnabled: enableStateRoot} + p := NewPayload(netmode.UnitTestNet, enableStateRoot) p.SetType(payload.RecoveryMessageType) p.SetPayload(r) // sign payload to have verification script @@ -32,15 +41,16 @@ func TestRecoveryMessage_Setters(t *testing.T) { timestamp: 87, nonce: 321, transactionHashes: []util.Uint256{{1}}, + stateRootEnabled: enableStateRoot, } - p1 := NewPayload(netmode.UnitTestNet) + p1 := NewPayload(netmode.UnitTestNet, enableStateRoot) p1.SetType(payload.PrepareRequestType) p1.SetPayload(req) p1.SetValidatorIndex(0) require.NoError(t, p1.Sign(privs[0])) t.Run("prepare response is added", func(t *testing.T) { - p2 := NewPayload(netmode.UnitTestNet) + p2 := NewPayload(netmode.UnitTestNet, enableStateRoot) p2.SetType(payload.PrepareResponseType) p2.SetPayload(&prepareResponse{ preparationHash: p1.Hash(), @@ -76,7 +86,7 @@ func TestRecoveryMessage_Setters(t *testing.T) { }) t.Run("change view is added", func(t *testing.T) { - p3 := NewPayload(netmode.UnitTestNet) + p3 := NewPayload(netmode.UnitTestNet, enableStateRoot) p3.SetType(payload.ChangeViewType) p3.SetPayload(&changeView{ newViewNumber: 1, @@ -98,7 +108,7 @@ func TestRecoveryMessage_Setters(t *testing.T) { }) t.Run("commit is added", func(t *testing.T) { - p4 := NewPayload(netmode.UnitTestNet) + p4 := NewPayload(netmode.UnitTestNet, enableStateRoot) p4.SetType(payload.CommitType) p4.SetPayload(randomMessage(t, commitType)) p4.SetValidatorIndex(3) diff --git a/pkg/core/block/block.go b/pkg/core/block/block.go index 650df993e..e7fa4974a 100644 --- a/pkg/core/block/block.go +++ b/pkg/core/block/block.go @@ -77,10 +77,11 @@ func (b *Block) RebuildMerkleRoot() { // This is commonly used to create a block from stored data. // Blocks created from trimmed data will have their Trimmed field // set to true. -func NewBlockFromTrimmedBytes(network netmode.Magic, b []byte) (*Block, error) { +func NewBlockFromTrimmedBytes(network netmode.Magic, stateRootEnabled bool, b []byte) (*Block, error) { block := &Block{ Base: Base{ - Network: network, + Network: network, + StateRootEnabled: stateRootEnabled, }, Trimmed: true, } @@ -113,10 +114,11 @@ func NewBlockFromTrimmedBytes(network netmode.Magic, b []byte) (*Block, error) { } // New creates a new blank block tied to the specific network. -func New(network netmode.Magic) *Block { +func New(network netmode.Magic, stateRootEnabled bool) *Block { return &Block{ Base: Base{ - Network: network, + Network: network, + StateRootEnabled: stateRootEnabled, }, } } diff --git a/pkg/core/block/block_base.go b/pkg/core/block/block_base.go index 2fb7b2e01..483a62c01 100644 --- a/pkg/core/block/block_base.go +++ b/pkg/core/block/block_base.go @@ -43,6 +43,11 @@ type Base struct { // necessary for correct signing/verification. Network netmode.Magic + // StateRootEnabled specifies if header contains state root. + StateRootEnabled bool + // PrevStateRoot is state root of the previous block. + PrevStateRoot util.Uint256 + // Hash of this block, created when binary encoded (double SHA256). hash util.Uint256 @@ -61,6 +66,7 @@ type baseAux struct { Timestamp uint64 `json:"time"` Index uint32 `json:"index"` NextConsensus string `json:"nextconsensus"` + PrevStateRoot *util.Uint256 `json:"previousstateroot,omitempty"` Witnesses []transaction.Witness `json:"witnesses"` } @@ -130,6 +136,9 @@ func (b *Base) encodeHashableFields(bw *io.BinWriter) { bw.WriteU64LE(b.Timestamp) bw.WriteU32LE(b.Index) bw.WriteBytes(b.NextConsensus[:]) + if b.StateRootEnabled { + bw.WriteBytes(b.PrevStateRoot[:]) + } } // decodeHashableFields decodes the fields used for hashing. @@ -141,6 +150,9 @@ func (b *Base) decodeHashableFields(br *io.BinReader) { b.Timestamp = br.ReadU64LE() b.Index = br.ReadU32LE() br.ReadBytes(b.NextConsensus[:]) + if b.StateRootEnabled { + br.ReadBytes(b.PrevStateRoot[:]) + } // Make the hash of the block here so we dont need to do this // again. @@ -161,6 +173,9 @@ func (b Base) MarshalJSON() ([]byte, error) { NextConsensus: address.Uint160ToString(b.NextConsensus), Witnesses: []transaction.Witness{b.Script}, } + if b.StateRootEnabled { + aux.PrevStateRoot = &b.PrevStateRoot + } return json.Marshal(aux) } @@ -188,6 +203,12 @@ func (b *Base) UnmarshalJSON(data []byte) error { b.Index = aux.Index b.NextConsensus = nextC b.Script = aux.Witnesses[0] + if b.StateRootEnabled { + if aux.PrevStateRoot == nil { + return errors.New("'previousstateroot' is empty") + } + b.PrevStateRoot = *aux.PrevStateRoot + } if !aux.Hash.Equals(b.Hash()) { return errors.New("json 'hash' doesn't match block hash") } diff --git a/pkg/core/block/block_test.go b/pkg/core/block/block_test.go index ab1052944..a681056da 100644 --- a/pkg/core/block/block_test.go +++ b/pkg/core/block/block_test.go @@ -31,7 +31,7 @@ func TestDecodeBlock1(t *testing.T) { b, err := hex.DecodeString(data["raw"].(string)) require.NoError(t, err) - block := New(netmode.TestNet) + block := New(netmode.TestNet, false) assert.NoError(t, testserdes.DecodeBinary(b, block)) assert.Equal(t, uint32(data["index"].(float64)), block.Index) @@ -58,7 +58,7 @@ func TestTrimmedBlock(t *testing.T) { b, err := block.Trim() require.NoError(t, err) - trimmedBlock, err := NewBlockFromTrimmedBytes(netmode.TestNet, b) + trimmedBlock, err := NewBlockFromTrimmedBytes(netmode.TestNet, false, b) require.NoError(t, err) assert.True(t, trimmedBlock.Trimmed) @@ -114,7 +114,7 @@ func TestBinBlockDecodeEncode(t *testing.T) { rawtx := "0000000005440c786a66aaebf472aacb1d1db19d5b494c6a9226ea91bf5cf0e63a6605138cde5064efb81bc6539620b9e6d6d7c74f97d415b922c4fb4bb1833ce6a97a9d61f962fb7301000065f000005d12ac6c589d59f92e82d8bf60659cb716ffc1f101fd4a010c4011ff5d2138cf546d112ef712ee8a15277f7b6f1d5d2564b97497ac155782e6089cd3005dc9de81a8b22bb2f1c3a2edbac55e01581cb27980fdedf3a8bc57fa470c40657253c374a48da773fc653591f282a63a60695f29ab6c86300020ed505a019e5563e1be493efa71bdde37b16b4ec3f5f6dc2d2a2550151b020176b4dbe7afe40c403efdc559cb6bff135fd79138267db897c6fded01e3a0f15c0fb1c337359935d65e7ac49239f020951a74a96e11e73d225c9789953ffec40d5f7c9a84707b1d9a0c402804f24ab8034fa41223977ba48883eb94951184e31e5739872daf4f65461de3196ebf333f6d7dc4aff0b7b2143793179415f50a715484aba4e33b97dc636e150c40ed6b2ffeaef97eef746815ad16f5b8aed743892e93f7216bb744eb5c2f4cad91ae291919b61cd9a8d50fe85630d5e010c49a01ed687727c3ae5a7e17d4da213afdfd00150c2103009b7540e10f2562e5fd8fac9eaec25166a58b26e412348ff5a86927bfac22a20c21030205e9cefaea5a1dfc580af20c8d5aa2468bb0148f1a5e4605fc622c80e604ba0c210214baf0ceea3a66f17e7e1e839ea25fd8bed6cd82e6bb6e68250189065f44ff010c2103408dcd416396f64783ac587ea1e1593c57d9fea880c8a6a1920e92a2594778060c2102a7834be9b32e2981d157cb5bbd3acb42cfd11ea5c3b10224d7a44e98c5910f1b0c2102ba2c70f5996f357a43198705859fae2cfea13e1172962800772b3d588a9d4abd0c2102f889ecd43c5126ff1932d75fa87dea34fc95325fb724db93c8f79fe32cc3f180170b41138defaf0202c1353ed4e94d0cbc00be80024f7673890000000000261c130000000000e404210001f813c2cc8e18bbe4b3b87f8ef9105b50bb93918e01005d0300743ba40b0000000c14aa07cc3f2193a973904a09a6e60b87f1f96273970c14f813c2cc8e18bbe4b3b87f8ef9105b50bb93918e13c00c087472616e736665720c14bcaf41d684c7d4ad6ee0d99da9707b9d1f0c8e6641627d5b523801420c402360bbf64b9644c25f066dbd406454b07ab9f56e8e25d92d90c96c598f6c29d97eabdcf226f3575481662cfcdd064ee410978e5fae3f09a2f83129ba9cd82641290c2103caf763f91d3691cba5b5df3eb13e668fdace0295b37e2e259fd0fb152d354f900b4195440d78" rawtxBytes, _ := hex.DecodeString(rawtx) - b := New(netmode.TestNet) + b := New(netmode.TestNet, false) assert.NoError(t, testserdes.DecodeBinary(rawtxBytes, b)) expected := map[string]bool{ // 1 trans @@ -150,7 +150,7 @@ func TestBinBlockDecodeEncode(t *testing.T) { // update hidden hash value. _ = b.ConsensusData.Hash() - testserdes.MarshalUnmarshalJSON(t, b, New(netmode.TestNet)) + testserdes.MarshalUnmarshalJSON(t, b, New(netmode.TestNet, false)) } func TestBlockSizeCalculation(t *testing.T) { @@ -163,7 +163,7 @@ func TestBlockSizeCalculation(t *testing.T) { rawBlock := "0000000005440c786a66aaebf472aacb1d1db19d5b494c6a9226ea91bf5cf0e63a6605138cde5064efb81bc6539620b9e6d6d7c74f97d415b922c4fb4bb1833ce6a97a9d61f962fb7301000065f000005d12ac6c589d59f92e82d8bf60659cb716ffc1f101fd4a010c4011ff5d2138cf546d112ef712ee8a15277f7b6f1d5d2564b97497ac155782e6089cd3005dc9de81a8b22bb2f1c3a2edbac55e01581cb27980fdedf3a8bc57fa470c40657253c374a48da773fc653591f282a63a60695f29ab6c86300020ed505a019e5563e1be493efa71bdde37b16b4ec3f5f6dc2d2a2550151b020176b4dbe7afe40c403efdc559cb6bff135fd79138267db897c6fded01e3a0f15c0fb1c337359935d65e7ac49239f020951a74a96e11e73d225c9789953ffec40d5f7c9a84707b1d9a0c402804f24ab8034fa41223977ba48883eb94951184e31e5739872daf4f65461de3196ebf333f6d7dc4aff0b7b2143793179415f50a715484aba4e33b97dc636e150c40ed6b2ffeaef97eef746815ad16f5b8aed743892e93f7216bb744eb5c2f4cad91ae291919b61cd9a8d50fe85630d5e010c49a01ed687727c3ae5a7e17d4da213afdfd00150c2103009b7540e10f2562e5fd8fac9eaec25166a58b26e412348ff5a86927bfac22a20c21030205e9cefaea5a1dfc580af20c8d5aa2468bb0148f1a5e4605fc622c80e604ba0c210214baf0ceea3a66f17e7e1e839ea25fd8bed6cd82e6bb6e68250189065f44ff010c2103408dcd416396f64783ac587ea1e1593c57d9fea880c8a6a1920e92a2594778060c2102a7834be9b32e2981d157cb5bbd3acb42cfd11ea5c3b10224d7a44e98c5910f1b0c2102ba2c70f5996f357a43198705859fae2cfea13e1172962800772b3d588a9d4abd0c2102f889ecd43c5126ff1932d75fa87dea34fc95325fb724db93c8f79fe32cc3f180170b41138defaf0202c1353ed4e94d0cbc00be80024f7673890000000000261c130000000000e404210001f813c2cc8e18bbe4b3b87f8ef9105b50bb93918e01005d0300743ba40b0000000c14aa07cc3f2193a973904a09a6e60b87f1f96273970c14f813c2cc8e18bbe4b3b87f8ef9105b50bb93918e13c00c087472616e736665720c14bcaf41d684c7d4ad6ee0d99da9707b9d1f0c8e6641627d5b523801420c402360bbf64b9644c25f066dbd406454b07ab9f56e8e25d92d90c96c598f6c29d97eabdcf226f3575481662cfcdd064ee410978e5fae3f09a2f83129ba9cd82641290c2103caf763f91d3691cba5b5df3eb13e668fdace0295b37e2e259fd0fb152d354f900b4195440d78" rawBlockBytes, _ := hex.DecodeString(rawBlock) - b := New(netmode.TestNet) + b := New(netmode.TestNet, false) assert.NoError(t, testserdes.DecodeBinary(rawBlockBytes, b)) expected := []struct { diff --git a/pkg/core/block/header_test.go b/pkg/core/block/header_test.go index 989920fbf..4fc865757 100644 --- a/pkg/core/block/header_test.go +++ b/pkg/core/block/header_test.go @@ -6,12 +6,13 @@ import ( "github.com/nspcc-dev/neo-go/pkg/core/transaction" "github.com/nspcc-dev/neo-go/pkg/crypto/hash" + "github.com/nspcc-dev/neo-go/pkg/internal/random" "github.com/nspcc-dev/neo-go/pkg/internal/testserdes" "github.com/nspcc-dev/neo-go/pkg/util" "github.com/stretchr/testify/assert" ) -func TestHeaderEncodeDecode(t *testing.T) { +func testHeaderEncodeDecode(t *testing.T, stateRootEnabled bool) { header := Header{Base: Base{ Version: 0, PrevHash: hash.Sha256([]byte("prevhash")), @@ -24,9 +25,13 @@ func TestHeaderEncodeDecode(t *testing.T) { VerificationScript: []byte{0x11}, }, }} + if stateRootEnabled { + header.StateRootEnabled = stateRootEnabled + header.PrevStateRoot = random.Uint256() + } _ = header.Hash() - headerDecode := &Header{} + headerDecode := &Header{Base: Base{StateRootEnabled: stateRootEnabled}} testserdes.EncodeDecodeBinary(t, &header, headerDecode) assert.Equal(t, header.Version, headerDecode.Version, "expected both versions to be equal") @@ -36,4 +41,14 @@ func TestHeaderEncodeDecode(t *testing.T) { assert.Equal(t, header.NextConsensus, headerDecode.NextConsensus, "expected both next consensus fields to be equal") assert.Equal(t, header.Script.InvocationScript, headerDecode.Script.InvocationScript, "expected equal invocation scripts") assert.Equal(t, header.Script.VerificationScript, headerDecode.Script.VerificationScript, "expected equal verification scripts") + assert.Equal(t, header.PrevStateRoot, headerDecode.PrevStateRoot, "expected equal state roots") +} + +func TestHeaderEncodeDecode(t *testing.T) { + t.Run("NoStateRoot", func(t *testing.T) { + testHeaderEncodeDecode(t, false) + }) + t.Run("WithStateRoot", func(t *testing.T) { + testHeaderEncodeDecode(t, true) + }) } diff --git a/pkg/core/block/helper_test.go b/pkg/core/block/helper_test.go index 98f1abf23..cefea3959 100644 --- a/pkg/core/block/helper_test.go +++ b/pkg/core/block/helper_test.go @@ -19,7 +19,7 @@ func getDecodedBlock(t *testing.T, i int) *Block { b, err := hex.DecodeString(data["raw"].(string)) require.NoError(t, err) - block := New(netmode.TestNet) + block := New(netmode.TestNet, false) require.NoError(t, testserdes.DecodeBinary(b, block)) return block diff --git a/pkg/core/blockchain.go b/pkg/core/blockchain.go index d26377d45..d7247f973 100644 --- a/pkg/core/blockchain.go +++ b/pkg/core/blockchain.go @@ -160,7 +160,7 @@ func NewBlockchain(s storage.Store, cfg config.ProtocolConfiguration, log *zap.L } bc := &Blockchain{ config: cfg, - dao: dao.NewSimple(s, cfg.Magic), + dao: dao.NewSimple(s, cfg.Magic, cfg.StateRootInHeader), stopCh: make(chan struct{}), runToExitCh: make(chan struct{}), memPool: mempool.New(cfg.MemPoolSize), @@ -429,6 +429,16 @@ func (bc *Blockchain) AddBlock(block *block.Block) error { if expectedHeight != block.Index { return fmt.Errorf("expected %d, got %d: %w", expectedHeight, block.Index, ErrInvalidBlockIndex) } + if bc.config.StateRootInHeader != block.StateRootEnabled { + return fmt.Errorf("%w: %v != %v", + ErrHdrStateRootSetting, bc.config.StateRootInHeader, block.StateRootEnabled) + } + if bc.config.StateRootInHeader { + if sr := bc.dao.MPT.StateRoot(); block.PrevStateRoot != sr { + return fmt.Errorf("%w: %s != %s", + ErrHdrInvalidStateRoot, block.PrevStateRoot.StringLE(), sr.StringLE()) + } + } if block.Index == bc.HeaderHeight()+1 { err := bc.addHeaders(bc.config.VerifyBlocks, block.Header()) @@ -1218,6 +1228,8 @@ var ( ErrHdrHashMismatch = errors.New("previous header hash doesn't match") ErrHdrIndexMismatch = errors.New("previous header index doesn't match") ErrHdrInvalidTimestamp = errors.New("block is not newer than the previous one") + ErrHdrStateRootSetting = errors.New("state root setting mismatch") + ErrHdrInvalidStateRoot = errors.New("state root for previous block is invalid") ) func (bc *Blockchain) verifyHeader(currHeader, prevHeader *block.Header) error { diff --git a/pkg/core/blockchain_test.go b/pkg/core/blockchain_test.go index 93d18c442..15276ddcf 100644 --- a/pkg/core/blockchain_test.go +++ b/pkg/core/blockchain_test.go @@ -122,6 +122,33 @@ func TestAddBlock(t *testing.T) { assert.Equal(t, lastBlock.Hash(), bc.CurrentHeaderHash()) } +func TestAddBlockStateRoot(t *testing.T) { + bc := newTestChainWithStateRoot(t, true) + defer bc.Close() + + sr, err := bc.GetStateRoot(bc.BlockHeight()) + require.NoError(t, err) + + tx := newNEP5Transfer(bc.contracts.NEO.Hash, neoOwner, util.Uint160{}, 1) + tx.ValidUntilBlock = bc.BlockHeight() + 1 + addSigners(tx) + require.NoError(t, signTx(bc, tx)) + + lastBlock := bc.topBlock.Load().(*block.Block) + b := newBlock(bc.config, lastBlock.Index+1, lastBlock.Hash(), tx) + err = bc.AddBlock(b) + require.True(t, errors.Is(err, ErrHdrStateRootSetting), "got: %v", err) + + u := sr.Root + u[0] ^= 0xFF + b = newBlockWithState(bc.config, lastBlock.Index+1, lastBlock.Hash(), &u, tx) + err = bc.AddBlock(b) + require.True(t, errors.Is(err, ErrHdrInvalidStateRoot), "got: %v", err) + + b = bc.newBlock(tx) + require.NoError(t, bc.AddBlock(b)) +} + func TestAddBadBlock(t *testing.T) { bc := newTestChain(t) defer bc.Close() @@ -500,7 +527,7 @@ func TestVerifyTx(t *testing.T) { InvocationScript: testchain.SignCommittee(txSetOracle.GetSignedPart()), VerificationScript: testchain.CommitteeVerificationScript(), }} - bl := block.New(netmode.UnitTestNet) + bl := block.New(netmode.UnitTestNet, bc.config.StateRootInHeader) bl.Index = bc.BlockHeight() + 1 ic := bc.newInteropContext(trigger.All, bc.dao, bl, txSetOracle) ic.SpawnVM() diff --git a/pkg/core/dao/cacheddao_test.go b/pkg/core/dao/cacheddao_test.go index 7170a46ed..6a58debaa 100644 --- a/pkg/core/dao/cacheddao_test.go +++ b/pkg/core/dao/cacheddao_test.go @@ -15,7 +15,7 @@ import ( func TestCachedDaoContracts(t *testing.T) { store := storage.NewMemoryStore() - pdao := NewSimple(store, netmode.UnitTestNet) + pdao := NewSimple(store, netmode.UnitTestNet, false) dao := NewCached(pdao) script := []byte{0xde, 0xad, 0xbe, 0xef} @@ -54,7 +54,7 @@ func TestCachedDaoContracts(t *testing.T) { func TestCachedCachedDao(t *testing.T) { store := storage.NewMemoryStore() // Persistent DAO to check for backing storage. - pdao := NewSimple(store, netmode.UnitTestNet) + pdao := NewSimple(store, netmode.UnitTestNet, false) assert.NotEqual(t, store, pdao.Store) // Cached DAO. cdao := NewCached(pdao) diff --git a/pkg/core/dao/dao.go b/pkg/core/dao/dao.go index d2a4f9ebe..ed687d6ac 100644 --- a/pkg/core/dao/dao.go +++ b/pkg/core/dao/dao.go @@ -76,12 +76,14 @@ type Simple struct { MPT *mpt.Trie Store *storage.MemCachedStore network netmode.Magic + // stateRootInHeader specifies if block header contains state root. + stateRootInHeader bool } // NewSimple creates new simple dao using provided backend store. -func NewSimple(backend storage.Store, network netmode.Magic) *Simple { +func NewSimple(backend storage.Store, network netmode.Magic, stateRootInHeader bool) *Simple { st := storage.NewMemCachedStore(backend) - return &Simple{Store: st, network: network} + return &Simple{Store: st, network: network, stateRootInHeader: stateRootInHeader} } // GetBatch returns currently accumulated DB changeset. @@ -92,7 +94,7 @@ func (dao *Simple) GetBatch() *storage.MemBatch { // GetWrapped returns new DAO instance with another layer of wrapped // MemCachedStore around the current DAO Store. func (dao *Simple) GetWrapped() DAO { - d := NewSimple(dao.Store, dao.network) + d := NewSimple(dao.Store, dao.network, dao.stateRootInHeader) d.MPT = dao.MPT return d } @@ -514,7 +516,7 @@ func (dao *Simple) GetBlock(hash util.Uint256) (*block.Block, error) { return nil, err } - block, err := block.NewBlockFromTrimmedBytes(dao.network, b) + block, err := block.NewBlockFromTrimmedBytes(dao.network, dao.stateRootInHeader, b) if err != nil { return nil, err } diff --git a/pkg/core/dao/dao_test.go b/pkg/core/dao/dao_test.go index bf6ba00b1..74f76a1a7 100644 --- a/pkg/core/dao/dao_test.go +++ b/pkg/core/dao/dao_test.go @@ -18,7 +18,7 @@ import ( ) func TestPutGetAndDecode(t *testing.T) { - dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet) + dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false) serializable := &TestSerializable{field: random.String(4)} hash := []byte{1} err := dao.Put(serializable, hash) @@ -43,7 +43,7 @@ func (t *TestSerializable) DecodeBinary(reader *io.BinReader) { } func TestPutAndGetContractState(t *testing.T) { - dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet) + dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false) contractState := &state.Contract{Script: []byte{}} hash := contractState.ScriptHash() err := dao.PutContractState(contractState) @@ -54,7 +54,7 @@ func TestPutAndGetContractState(t *testing.T) { } func TestDeleteContractState(t *testing.T) { - dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet) + dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false) contractState := &state.Contract{Script: []byte{}} hash := contractState.ScriptHash() err := dao.PutContractState(contractState) @@ -67,7 +67,7 @@ func TestDeleteContractState(t *testing.T) { } func TestSimple_GetAndUpdateNextContractID(t *testing.T) { - dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet) + dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false) id, err := dao.GetAndUpdateNextContractID() require.NoError(t, err) require.EqualValues(t, 0, id) @@ -80,7 +80,7 @@ func TestSimple_GetAndUpdateNextContractID(t *testing.T) { } func TestPutGetAppExecResult(t *testing.T) { - dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet) + dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false) hash := random.Uint256() appExecResult := &state.AppExecResult{ Container: hash, @@ -98,7 +98,7 @@ func TestPutGetAppExecResult(t *testing.T) { } func TestPutGetStorageItem(t *testing.T) { - dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet) + dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false) id := int32(random.Int(0, 1024)) key := []byte{0} storageItem := &state.StorageItem{Value: []uint8{}} @@ -109,7 +109,7 @@ func TestPutGetStorageItem(t *testing.T) { } func TestDeleteStorageItem(t *testing.T) { - dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet) + dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false) id := int32(random.Int(0, 1024)) key := []byte{0} storageItem := &state.StorageItem{Value: []uint8{}} @@ -122,7 +122,7 @@ func TestDeleteStorageItem(t *testing.T) { } func TestGetBlock_NotExists(t *testing.T) { - dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet) + dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false) hash := random.Uint256() block, err := dao.GetBlock(hash) require.Error(t, err) @@ -130,7 +130,7 @@ func TestGetBlock_NotExists(t *testing.T) { } func TestPutGetBlock(t *testing.T) { - dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet) + dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false) b := &block.Block{ Base: block.Base{ Script: transaction.Witness{ @@ -148,14 +148,14 @@ func TestPutGetBlock(t *testing.T) { } func TestGetVersion_NoVersion(t *testing.T) { - dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet) + dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false) version, err := dao.GetVersion() require.Error(t, err) require.Equal(t, "", version) } func TestGetVersion(t *testing.T) { - dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet) + dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false) err := dao.PutVersion("testVersion") require.NoError(t, err) version, err := dao.GetVersion() @@ -164,14 +164,14 @@ func TestGetVersion(t *testing.T) { } func TestGetCurrentHeaderHeight_NoHeader(t *testing.T) { - dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet) + dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false) height, err := dao.GetCurrentBlockHeight() require.Error(t, err) require.Equal(t, uint32(0), height) } func TestGetCurrentHeaderHeight_Store(t *testing.T) { - dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet) + dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false) b := &block.Block{ Base: block.Base{ Script: transaction.Witness{ @@ -188,7 +188,7 @@ func TestGetCurrentHeaderHeight_Store(t *testing.T) { } func TestStoreAsTransaction(t *testing.T) { - dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet) + dao := NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false) tx := transaction.New(netmode.UnitTestNet, []byte{byte(opcode.PUSH1)}, 1) hash := tx.Hash() err := dao.StoreAsTransaction(tx, 0, nil) diff --git a/pkg/core/helper_test.go b/pkg/core/helper_test.go index ad8205e81..63119ab2e 100644 --- a/pkg/core/helper_test.go +++ b/pkg/core/helper_test.go @@ -38,8 +38,13 @@ var neoOwner = testchain.MultisigScriptHash() // newTestChain should be called before newBlock invocation to properly setup // global state. func newTestChain(t *testing.T) *Blockchain { + return newTestChainWithStateRoot(t, false) +} + +func newTestChainWithStateRoot(t *testing.T, stateRootInHeader bool) *Blockchain { unitTestNetCfg, err := config.Load("../../config", testchain.Network()) require.NoError(t, err) + unitTestNetCfg.ProtocolConfiguration.StateRootInHeader = stateRootInHeader chain, err := NewBlockchain(storage.NewMemoryStore(), unitTestNetCfg.ProtocolConfiguration, zaptest.NewLogger(t)) require.NoError(t, err) go chain.Run() @@ -48,10 +53,22 @@ func newTestChain(t *testing.T) *Blockchain { func (bc *Blockchain) newBlock(txs ...*transaction.Transaction) *block.Block { lastBlock := bc.topBlock.Load().(*block.Block) + if bc.config.StateRootInHeader { + sr, err := bc.GetStateRoot(bc.BlockHeight()) + if err != nil { + panic(err) + } + return newBlockWithState(bc.config, lastBlock.Index+1, lastBlock.Hash(), &sr.Root, txs...) + } return newBlock(bc.config, lastBlock.Index+1, lastBlock.Hash(), txs...) } func newBlock(cfg config.ProtocolConfiguration, index uint32, prev util.Uint256, txs ...*transaction.Transaction) *block.Block { + return newBlockWithState(cfg, index, prev, nil, txs...) +} + +func newBlockWithState(cfg config.ProtocolConfiguration, index uint32, prev util.Uint256, + prevState *util.Uint256, txs ...*transaction.Transaction) *block.Block { validators, _ := validatorsFromConfig(cfg) valScript, _ := smartcontract.CreateDefaultMultiSigRedeemScript(validators) witness := transaction.Witness{ @@ -73,6 +90,10 @@ func newBlock(cfg config.ProtocolConfiguration, index uint32, prev util.Uint256, }, Transactions: txs, } + if prevState != nil { + b.StateRootEnabled = true + b.PrevStateRoot = *prevState + } b.RebuildMerkleRoot() b.Script.InvocationScript = testchain.Sign(b.GetSignedPart()) return b @@ -99,7 +120,7 @@ func getDecodedBlock(t *testing.T, i int) *block.Block { b, err := hex.DecodeString(data["raw"].(string)) require.NoError(t, err) - block := block.New(testchain.Network()) + block := block.New(testchain.Network(), false) require.NoError(t, testserdes.DecodeBinary(b, block)) return block diff --git a/pkg/core/interop_neo_test.go b/pkg/core/interop_neo_test.go index a04fd3f12..47b6c34b8 100644 --- a/pkg/core/interop_neo_test.go +++ b/pkg/core/interop_neo_test.go @@ -144,7 +144,7 @@ func TestECDSAVerify(t *testing.T) { chain := newTestChain(t) defer chain.Close() - ic := chain.newInteropContext(trigger.Application, dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet), nil, nil) + ic := chain.newInteropContext(trigger.Application, dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false), nil, nil) runCase := func(t *testing.T, isErr bool, result interface{}, args ...interface{}) { ic.SpawnVM() for i := range args { @@ -266,7 +266,7 @@ func TestRuntimeEncodeDecode(t *testing.T) { func createVM(t *testing.T) (*vm.VM, *interop.Context, *Blockchain) { chain := newTestChain(t) context := chain.newInteropContext(trigger.Application, - dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet), nil, nil) + dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, chain.config.StateRootInHeader), nil, nil) v := context.SpawnVM() return v, context, chain } @@ -280,7 +280,8 @@ func createVMAndPushBlock(t *testing.T) (*vm.VM, *block.Block, *interop.Context, func createVMAndBlock(t *testing.T) (*vm.VM, *block.Block, *interop.Context, *Blockchain) { block := newDumbBlock() chain := newTestChain(t) - context := chain.newInteropContext(trigger.Application, dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet), block, nil) + d := dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, chain.GetConfig().StateRootInHeader) + context := chain.newInteropContext(trigger.Application, d, block, nil) v := context.SpawnVM() return v, block, context, chain } @@ -301,7 +302,8 @@ func createVMAndContractState(t *testing.T) (*vm.VM, *state.Contract, *interop.C } chain := newTestChain(t) - context := chain.newInteropContext(trigger.Application, dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet), nil, nil) + d := dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, chain.config.StateRootInHeader) + context := chain.newInteropContext(trigger.Application, d, nil, nil) v := context.SpawnVM() return v, contractState, context, chain } @@ -312,7 +314,8 @@ func createVMAndTX(t *testing.T) (*vm.VM, *transaction.Transaction, *interop.Con tx.Signers = []transaction.Signer{{Account: util.Uint160{1, 2, 3, 4}}} chain := newTestChain(t) - context := chain.newInteropContext(trigger.Application, dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet), nil, tx) + d := dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, chain.config.StateRootInHeader) + context := chain.newInteropContext(trigger.Application, d, nil, tx) v := context.SpawnVM() return v, tx, context, chain } diff --git a/pkg/core/interops_test.go b/pkg/core/interops_test.go index 748744e0b..a8391ef9d 100644 --- a/pkg/core/interops_test.go +++ b/pkg/core/interops_test.go @@ -19,7 +19,8 @@ func testNonInterop(t *testing.T, value interface{}, f func(*interop.Context) er v.Estack().PushVal(value) chain := newTestChain(t) defer chain.Close() - context := chain.newInteropContext(trigger.Application, dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet), nil, nil) + d := dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, chain.config.StateRootInHeader) + context := chain.newInteropContext(trigger.Application, d, nil, nil) context.VM = v require.Error(t, f(context)) } diff --git a/pkg/core/native_contract_test.go b/pkg/core/native_contract_test.go index 49061db49..3a438c365 100644 --- a/pkg/core/native_contract_test.go +++ b/pkg/core/native_contract_test.go @@ -225,8 +225,8 @@ func TestNativeContract_InvokeInternal(t *testing.T) { }) require.NoError(t, err) - ic := chain.newInteropContext(trigger.Application, - dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet), nil, nil) + d := dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, chain.config.StateRootInHeader) + ic := chain.newInteropContext(trigger.Application, d, nil, nil) v := ic.SpawnVM() t.Run("fail, bad current script hash", func(t *testing.T) { diff --git a/pkg/core/native_designate_test.go b/pkg/core/native_designate_test.go index f12fff91a..dcc75c17e 100644 --- a/pkg/core/native_designate_test.go +++ b/pkg/core/native_designate_test.go @@ -118,7 +118,7 @@ func TestDesignate_DesignateAsRole(t *testing.T) { des := bc.contracts.Designate tx := transaction.New(netmode.UnitTestNet, []byte{}, 0) - bl := block.New(netmode.UnitTestNet) + bl := block.New(netmode.UnitTestNet, bc.config.StateRootInHeader) bl.Index = bc.BlockHeight() + 1 ic := bc.newInteropContext(trigger.OnPersist, bc.dao, bl, tx) ic.SpawnVM() diff --git a/pkg/core/native_oracle_test.go b/pkg/core/native_oracle_test.go index 2d603e2b2..3df0c9b55 100644 --- a/pkg/core/native_oracle_test.go +++ b/pkg/core/native_oracle_test.go @@ -142,7 +142,7 @@ func TestOracle_Request(t *testing.T) { pub := priv.PublicKey() tx := transaction.New(netmode.UnitTestNet, []byte{}, 0) - bl := block.New(netmode.UnitTestNet) + bl := block.New(netmode.UnitTestNet, bc.config.StateRootInHeader) bl.Index = bc.BlockHeight() + 1 setSigner(tx, testchain.CommitteeScriptHash()) ic := bc.newInteropContext(trigger.Application, bc.dao, bl, tx) diff --git a/pkg/network/message.go b/pkg/network/message.go index 368d69cc9..efa58ad29 100644 --- a/pkg/network/message.go +++ b/pkg/network/message.go @@ -34,6 +34,9 @@ type Message struct { // Network this message comes from, it has to be set upon Message // creation for correct decoding. Network netmode.Magic + // StateRootInHeader specifies if state root is included in block header. + // This is needed for correct decoding. + StateRootInHeader bool } // MessageFlag represents compression level of message payload @@ -106,7 +109,7 @@ func (m *Message) Decode(br *io.BinReader) error { case CMDFilterClear, CMDGetAddr, CMDMempool, CMDVerack: m.Payload = payload.NewNullPayload() default: - return errors.New("unexpected empty payload") + return fmt.Errorf("unexpected empty payload: %s", m.Command) } return nil } @@ -142,9 +145,9 @@ func (m *Message) decodePayload() error { case CMDAddr: p = &payload.AddressList{} case CMDBlock: - p = block.New(m.Network) + p = block.New(m.Network, m.StateRootInHeader) case CMDConsensus: - p = consensus.NewPayload(m.Network) + p = consensus.NewPayload(m.Network, m.StateRootInHeader) case CMDGetBlocks: p = &payload.GetBlocks{} case CMDGetHeaders: @@ -152,7 +155,7 @@ func (m *Message) decodePayload() error { case CMDGetBlockByIndex: p = &payload.GetBlockByIndex{} case CMDHeaders: - p = &payload.Headers{Network: m.Network} + p = &payload.Headers{Network: m.Network, StateRootInHeader: m.StateRootInHeader} case CMDTX: p = &transaction.Transaction{Network: m.Network} case CMDMerkleBlock: diff --git a/pkg/network/payload/headers.go b/pkg/network/payload/headers.go index ba68bbc78..61b27053e 100644 --- a/pkg/network/payload/headers.go +++ b/pkg/network/payload/headers.go @@ -12,6 +12,8 @@ import ( type Headers struct { Hdrs []*block.Header Network netmode.Magic + // StateRootInHeader specifies whether header contains state root. + StateRootInHeader bool } // Users can at most request 2k header. @@ -38,6 +40,7 @@ func (p *Headers) DecodeBinary(br *io.BinReader) { for i := 0; i < int(lenHeaders); i++ { header := &block.Header{} header.Network = p.Network + header.StateRootEnabled = p.StateRootInHeader header.DecodeBinary(br) p.Hdrs[i] = header } diff --git a/pkg/network/server.go b/pkg/network/server.go index 6dd91b0ba..fef50fe27 100644 --- a/pkg/network/server.go +++ b/pkg/network/server.go @@ -55,6 +55,8 @@ type ( // Network's magic number for correct message decoding. network netmode.Magic + // stateRootInHeader specifies if block header contain state root. + stateRootInHeader bool transport Transporter discovery Discoverer @@ -95,17 +97,18 @@ func NewServer(config ServerConfig, chain blockchainer.Blockchainer, log *zap.Lo } s := &Server{ - ServerConfig: config, - chain: chain, - id: randomID(), - network: chain.GetConfig().Magic, - quit: make(chan struct{}), - register: make(chan Peer), - unregister: make(chan peerDrop), - peers: make(map[Peer]bool), - consensusStarted: atomic.NewBool(false), - log: log, - transactions: make(chan *transaction.Transaction, 64), + ServerConfig: config, + chain: chain, + id: randomID(), + network: chain.GetConfig().Magic, + stateRootInHeader: chain.GetConfig().StateRootInHeader, + quit: make(chan struct{}), + register: make(chan Peer), + unregister: make(chan peerDrop), + peers: make(map[Peer]bool), + consensusStarted: atomic.NewBool(false), + log: log, + transactions: make(chan *transaction.Transaction, 64), } s.bQueue = newBlockQueue(maxBlockBatch, chain, log, func(b *block.Block) { if !s.consensusStarted.Load() { diff --git a/pkg/network/tcp_peer.go b/pkg/network/tcp_peer.go index 64d884feb..ea383f5d9 100644 --- a/pkg/network/tcp_peer.go +++ b/pkg/network/tcp_peer.go @@ -150,7 +150,7 @@ func (p *TCPPeer) handleConn() { if err == nil { r := io.NewBinReaderFromIO(p.conn) for { - msg := &Message{Network: p.server.network} + msg := &Message{Network: p.server.network, StateRootInHeader: p.server.stateRootInHeader} err = msg.Decode(r) if err == payload.ErrTooManyHeaders { diff --git a/pkg/rpc/client/client.go b/pkg/rpc/client/client.go index e72becf7f..c9042a468 100644 --- a/pkg/rpc/client/client.go +++ b/pkg/rpc/client/client.go @@ -28,14 +28,15 @@ const ( // Client represents the middleman for executing JSON RPC calls // to remote NEO RPC nodes. type Client struct { - cli *http.Client - endpoint *url.URL - network netmode.Magic - initDone bool - ctx context.Context - opts Options - requestF func(*request.Raw) (*response.Raw, error) - cache cache + cli *http.Client + endpoint *url.URL + network netmode.Magic + stateRootInHeader bool + initDone bool + ctx context.Context + opts Options + requestF func(*request.Raw) (*response.Raw, error) + cache cache } // Options defines options for the RPC client. @@ -115,6 +116,7 @@ func (c *Client) Init() error { return fmt.Errorf("failed to get network magic: %w", err) } c.network = version.Magic + c.stateRootInHeader = version.StateRootInHeader neoContractHash, err := c.GetContractStateByAddressOrName("neo") if err != nil { return fmt.Errorf("failed to get NEO contract scripthash: %w", err) diff --git a/pkg/rpc/client/rpc.go b/pkg/rpc/client/rpc.go index 075de911f..446ca9b3d 100644 --- a/pkg/rpc/client/rpc.go +++ b/pkg/rpc/client/rpc.go @@ -83,7 +83,7 @@ func (c *Client) getBlock(params request.RawParams) (*block.Block, error) { return nil, err } r := io.NewBinReaderFromBuf(resp) - b = block.New(c.GetNetwork()) + b = block.New(c.GetNetwork(), c.StateRootInHeader()) b.DecodeBinary(r) if r.Err != nil { return nil, r.Err @@ -606,6 +606,11 @@ func (c *Client) GetNetwork() netmode.Magic { return c.network } +// StateRootInHeader returns true if state root is contained in block header. +func (c *Client) StateRootInHeader() bool { + return c.stateRootInHeader +} + // GetNativeContractHash returns native contract hash by its name. It is not case-sensitive. func (c *Client) GetNativeContractHash(name string) (util.Uint160, error) { lowercasedName := strings.ToLower(name) diff --git a/pkg/rpc/client/rpc_test.go b/pkg/rpc/client/rpc_test.go index 0ca265f13..b82f3f74c 100644 --- a/pkg/rpc/client/rpc_test.go +++ b/pkg/rpc/client/rpc_test.go @@ -61,7 +61,7 @@ func getResultBlock1() *result.Block { if err != nil { panic(err) } - b := block.New(netmode.UnitTestNet) + b := block.New(netmode.UnitTestNet, false) err = testserdes.DecodeBinary(binB, b) if err != nil { panic(err) diff --git a/pkg/rpc/client/wsclient.go b/pkg/rpc/client/wsclient.go index 266257ef1..7f79b6711 100644 --- a/pkg/rpc/client/wsclient.go +++ b/pkg/rpc/client/wsclient.go @@ -139,7 +139,7 @@ readloop: var val interface{} switch event { case response.BlockEventID: - val = block.New(c.GetNetwork()) + val = block.New(c.GetNetwork(), c.StateRootInHeader()) case response.TransactionEventID: val = &transaction.Transaction{Network: c.GetNetwork()} case response.NotificationEventID: diff --git a/pkg/rpc/response/result/version.go b/pkg/rpc/response/result/version.go index 4d0fd76d0..5a1f9c5ce 100644 --- a/pkg/rpc/response/result/version.go +++ b/pkg/rpc/response/result/version.go @@ -11,5 +11,7 @@ type ( WSPort uint16 `json:"wsport,omitempty"` Nonce uint32 `json:"nonce"` UserAgent string `json:"useragent"` + // StateRootInHeader is true if state root is contained in block header. + StateRootInHeader bool `json:"staterootinheader,omitempty"` } ) diff --git a/pkg/rpc/server/server.go b/pkg/rpc/server/server.go index 8afba33b3..5e3083d74 100644 --- a/pkg/rpc/server/server.go +++ b/pkg/rpc/server/server.go @@ -39,13 +39,14 @@ type ( // Server represents the JSON-RPC 2.0 server. Server struct { *http.Server - chain blockchainer.Blockchainer - config rpc.Config - network netmode.Magic - coreServer *network.Server - log *zap.Logger - https *http.Server - shutdown chan struct{} + chain blockchainer.Blockchainer + config rpc.Config + network netmode.Magic + stateRootEnabled bool + coreServer *network.Server + log *zap.Logger + https *http.Server + shutdown chan struct{} subsLock sync.RWMutex subscribers map[*subscriber]bool @@ -138,14 +139,15 @@ func New(chain blockchainer.Blockchainer, conf rpc.Config, coreServer *network.S } return Server{ - Server: httpServer, - chain: chain, - config: conf, - network: chain.GetConfig().Magic, - coreServer: coreServer, - log: log, - https: tlsServer, - shutdown: make(chan struct{}), + Server: httpServer, + chain: chain, + config: conf, + network: chain.GetConfig().Magic, + stateRootEnabled: chain.GetConfig().StateRootInHeader, + coreServer: coreServer, + log: log, + https: tlsServer, + shutdown: make(chan struct{}), subscribers: make(map[*subscriber]bool), // These are NOT buffered to preserve original order of events. @@ -1039,7 +1041,7 @@ func (s *Server) submitBlock(reqParams request.Params) (interface{}, *response.E if err != nil { return nil, response.ErrInvalidParams } - b := block.New(s.network) + b := block.New(s.network, s.stateRootEnabled) r := io.NewBinReaderFromBuf(blockBytes) b.DecodeBinary(r) if r.Err != nil { diff --git a/pkg/rpc/server/server_helper_test.go b/pkg/rpc/server/server_helper_test.go index ee41e0be4..a62c70820 100644 --- a/pkg/rpc/server/server_helper_test.go +++ b/pkg/rpc/server/server_helper_test.go @@ -52,7 +52,7 @@ func getTestBlocks(t *testing.T) []*block.Block { blocks := make([]*block.Block, 0, int(nBlocks)) for i := 0; i < int(nBlocks); i++ { _ = br.ReadU32LE() - b := block.New(netmode.UnitTestNet) + b := block.New(netmode.UnitTestNet, false) b.DecodeBinary(br) require.Nil(t, br.Err) blocks = append(blocks, b)