go/consensus/cometbft/abci: Include all events in the events root

The events root in block metadata system transaction now includes all events,
not just provable ones.

Author: peternose

.changelog/6289.breaking.0.md

@@ -0,0 +1,4 @@
+go/consensus/cometbft/abci: Include all events in the events root
+
+The events root in block metadata system transaction now includes all events,
+not just provable ones.

go/consensus/api/meta.go

@@ -23,7 +23,7 @@ const BlockMetadataMaxSize = 16_384
 type BlockMetadata struct {
 	// StateRoot is the state root after executing all logic in the block.
 	StateRoot hash.Hash `json:"state_root"`
-	// EventsRoot is the provable events root.
+	// EventsRoot is the root hash of all events emitted in the block.
 	EventsRoot []byte `json:"events_root"`
 }
 

go/consensus/cometbft/abci/mux.go

@@ -531,28 +531,25 @@ func (mux *abciMux) executeProposal(
 	mux.state.resetProposal()
 	mux.state.proposal.hash = hash
 
-	resultsBeginBlock := mux.BeginBlock(types.RequestBeginBlock{
+	// The proposal is updated inside every call, as the end block phase
+	// requires these results immediately to validate system transactions.
+	mux.BeginBlock(types.RequestBeginBlock{
 		Hash:                hash,
 		Header:              header,
 		LastCommitInfo:      lastCommit,
 		ByzantineValidators: misbehavior,
 	})
 
-	resultsDeliverTx := make([]*types.ResponseDeliverTx, 0, len(txs))
 	for _, tx := range txs {
-		resp := mux.DeliverTx(types.RequestDeliverTx{
+		mux.DeliverTx(types.RequestDeliverTx{
 			Tx: tx,
 		})
-		resultsDeliverTx = append(resultsDeliverTx, &resp)
 	}
 
-	resultsEndBlock := mux.EndBlock(types.RequestEndBlock{
+	mux.EndBlock(types.RequestEndBlock{
 		Height: header.Height,
 	})
 
-	// Update the proposal with results, marking the proposal as executed.
-	mux.state.proposal.setResults(&resultsBeginBlock, resultsDeliverTx, &resultsEndBlock)
-
 	return nil
 }
 
@@ -638,19 +635,22 @@ func (mux *abciMux) BeginBlock(req types.RequestBeginBlock) types.ResponseBeginB
 		}
 	}
 
-	response := mux.BaseApplication.BeginBlock(req)
+	result := mux.BaseApplication.BeginBlock(req)
 
 	// During the first block, also collect and prepend application events generated during
 	// InitChain to BeginBlock events.
 	if mux.state.BlockHeight() == 0 {
-		response.Events = append(response.Events, mux.state.initEvents...)
+		result.Events = append(result.Events, mux.state.initEvents...)
 	}
 
 	// Collect and return events from the application's BeginBlock calls.
-	response.Events = append(response.Events, ctx.GetEvents()...)
+	result.Events = append(result.Events, ctx.GetEvents()...)
 	mux.processProvableEvents(ctx)
 
-	return response
+	// Update the proposal.
+	mux.state.proposal.resultsBeginBlock = &result
+
+	return result
 }
 
 func (mux *abciMux) notifyInvalidatedCheckTx(txHash hash.Hash, err error) {
@@ -715,7 +715,17 @@ func (mux *abciMux) DeliverTx(req types.RequestDeliverTx) types.ResponseDeliverT
 	ctx := mux.state.NewContext(api.ContextDeliverTx)
 	defer ctx.Close()
 
-	if err := mux.executeTx(ctx, req.Tx); err != nil {
+	var results types.ResponseDeliverTx
+	switch err := mux.executeTx(ctx, req.Tx); err {
+	case nil:
+		results = types.ResponseDeliverTx{
+			Code:      types.CodeTypeOK,
+			Data:      cbor.Marshal(ctx.Data()),
+			Events:    ctx.GetEvents(),
+			GasWanted: int64(ctx.Gas().GasWanted()),
+			GasUsed:   int64(ctx.Gas().GasUsed()),
+		}
+	default:
 		if api.IsUnavailableStateError(err) {
 			// Make sure to not commit any transactions which include results based on unavailable
 			// and/or corrupted state -- doing so can further corrupt state.
@@ -726,9 +736,7 @@ func (mux *abciMux) DeliverTx(req types.RequestDeliverTx) types.ResponseDeliverT
 		}
 		module, code := errors.Code(err)
 
-		mux.processProvableEvents(ctx)
-
-		return types.ResponseDeliverTx{
+		results = types.ResponseDeliverTx{
 			Codespace: module,
 			Code:      code,
 			Log:       err.Error(),
@@ -740,13 +748,10 @@ func (mux *abciMux) DeliverTx(req types.RequestDeliverTx) types.ResponseDeliverT
 
 	mux.processProvableEvents(ctx)
 
-	return types.ResponseDeliverTx{
-		Code:      types.CodeTypeOK,
-		Data:      cbor.Marshal(ctx.Data()),
-		Events:    ctx.GetEvents(),
-		GasWanted: int64(ctx.Gas().GasWanted()),
-		GasUsed:   int64(ctx.Gas().GasUsed()),
-	}
+	// Update the proposal.
+	mux.state.proposal.resultsDeliverTx = append(mux.state.proposal.resultsDeliverTx, &results)
+
+	return results
 }
 
 func (mux *abciMux) EndBlock(req types.RequestEndBlock) types.ResponseEndBlock {
@@ -768,9 +773,9 @@ func (mux *abciMux) EndBlock(req types.RequestEndBlock) types.ResponseEndBlock {
 	defer ctx.Close()
 
 	// Dispatch EndBlock to all applications.
-	resp := mux.BaseApplication.EndBlock(req)
+	results := mux.BaseApplication.EndBlock(req)
 	for _, app := range mux.appsByLexOrder {
-		newResp, err := app.EndBlock(ctx)
+		newResults, err := app.EndBlock(ctx)
 		if err != nil {
 			mux.logger.Error("EndBlock: fatal error in application",
 				"err", err,
@@ -779,7 +784,7 @@ func (mux *abciMux) EndBlock(req types.RequestEndBlock) types.ResponseEndBlock {
 			panic(fmt.Errorf("mux: EndBlock: fatal error in application: '%s': %w", app.Name(), err))
 		}
 		if app.Blessed() {
-			resp = newResp
+			results = newResults
 		}
 	}
 
@@ -798,22 +803,25 @@ func (mux *abciMux) EndBlock(req types.RequestEndBlock) types.ResponseEndBlock {
 	}
 
 	// Collect and return events.
-	resp.Events = ctx.GetEvents()
+	results.Events = ctx.GetEvents()
 	mux.processProvableEvents(ctx)
 
 	// Update version to what we are actually running.
-	resp.ConsensusParamUpdates = &cmtproto.ConsensusParams{
+	results.ConsensusParamUpdates = &cmtproto.ConsensusParams{
 		Version: &cmtproto.VersionParams{
 			App: version.CometBFTAppVersion,
 		},
 	}
 
+	// Update the proposal.
+	mux.state.proposal.resultsEndBlock = &results
+
 	// Validate system transactions included by the proposer.
 	if err := mux.validateSystemTxs(); err != nil {
 		panic(fmt.Errorf("proposed block has invalid system transactions: %w", err))
 	}
 
-	return resp
+	return results
 }
 
 func (mux *abciMux) Commit() types.ResponseCommit {

go/consensus/cometbft/abci/state.go

@@ -112,17 +112,6 @@ func (ps *proposalState) needsExecution() bool {
 	return ps.resultsBeginBlock == nil || ps.resultsDeliverTx == nil || ps.resultsEndBlock == nil
 }
 
-// setResults sets the proposal execution results.
-func (ps *proposalState) setResults(
-	resultsBeginBlock *types.ResponseBeginBlock,
-	resultsDeliverTx []*types.ResponseDeliverTx,
-	resultsEndBlock *types.ResponseEndBlock,
-) {
-	ps.resultsBeginBlock = resultsBeginBlock
-	ps.resultsDeliverTx = resultsDeliverTx
-	ps.resultsEndBlock = resultsEndBlock
-}
-
 type applicationState struct { // nolint: maligned
 	logger *logging.Logger
 

go/consensus/cometbft/abci/system.go

@@ -13,6 +13,7 @@ import (
 	"github.com/oasisprotocol/oasis-core/go/consensus/cometbft/api"
 	cmtcrypto "github.com/oasisprotocol/oasis-core/go/consensus/cometbft/crypto"
 	"github.com/oasisprotocol/oasis-core/go/consensus/cometbft/crypto/merkle"
+	"github.com/oasisprotocol/oasis-core/go/upgrade/migrations"
 )
 
 // prepareSystemTxs prepares a list of system transactions to be included in a proposed block in
@@ -28,9 +29,9 @@ func (mux *abciMux) prepareSystemTxs() ([][]byte, []*types.ResponseDeliverTx, er
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to compute working state root: %w", err)
 	}
-	eventsRoot, err := mux.computeProvableEventsRoot()
+	eventsRoot, err := mux.computeEventsRoot()
 	if err != nil {
-		return nil, nil, fmt.Errorf("failed to compute provable events root: %w", err)
+		return nil, nil, fmt.Errorf("failed to compute events root: %w", err)
 	}
 
 	blockMeta := consensus.NewBlockMetadataTx(&consensus.BlockMetadata{
@@ -124,10 +125,10 @@ func (mux *abciMux) validateSystemTxs() error {
 				return fmt.Errorf("invalid state root in block metadata (expected: %s got: %s)", stateRoot, meta.StateRoot)
 			}
 
-			// Verify provable events root.
-			eventsRoot, err := mux.computeProvableEventsRoot()
+			// Verify events root.
+			eventsRoot, err := mux.computeEventsRoot()
 			if err != nil {
-				return fmt.Errorf("failed to compute provable events root: %w", err)
+				return fmt.Errorf("failed to compute events root: %w", err)
 			}
 			if !bytes.Equal(eventsRoot, meta.EventsRoot) {
 				return fmt.Errorf("invalid events root in block metadata (expected: %x got: %x)", eventsRoot, meta.EventsRoot)
@@ -148,11 +149,30 @@ func (mux *abciMux) validateSystemTxs() error {
 	return nil
 }
 
-func (mux *abciMux) computeProvableEventsRoot() ([]byte, error) {
-	provable := mux.state.blockCtx.ProvableEvents
-	provableEvents := make([][]byte, len(provable))
-	for i, pe := range provable {
-		provableEvents[i] = cbor.Marshal(pe.ProvableRepresentation())
+func (mux *abciMux) computeEventsRoot() ([]byte, error) {
+	if !mux.state.ConsensusParameters().IsFeatureVersion(migrations.Version256) {
+		// Events root used to be computed only from provable events.
+		provable := mux.state.blockCtx.ProvableEvents
+		provableEvents := make([][]byte, len(provable))
+		for i, pe := range provable {
+			provableEvents[i] = cbor.Marshal(pe.ProvableRepresentation())
+		}
+		return merkle.RootHash(provableEvents), nil
+	}
+
+	// Events root is now computed from all emitted events.
+	var events [][]byte
+	for _, ev := range mux.state.proposal.resultsBeginBlock.Events {
+		events = append(events, cbor.Marshal(ev))
 	}
-	return merkle.RootHash(provableEvents), nil
+	for _, res := range mux.state.proposal.resultsDeliverTx {
+		for _, ev := range res.Events {
+			events = append(events, cbor.Marshal(ev))
+		}
+	}
+	for _, ev := range mux.state.proposal.resultsEndBlock.Events {
+		events = append(events, cbor.Marshal(ev))
+	}
+
+	return merkle.RootHash(events), nil
 }

go/upgrade/migrations/consensus_256.go

@@ -14,6 +14,8 @@ import (
 // This upgrade includes:
 //   - The `MayQuery“ field in the CHURP SGX policy, which defines which enclave identities
 //     are allowed to query runtime key shares.
+//   - An updated events root in the block metadata system transaction to capture all events
+//     emitted in the block.
 const Consensus256 = "consensus256"
 
 // Version256 is the Oasis Core 25.6 version.

runtime/src/consensus/mod.rs

@@ -47,6 +47,6 @@ pub enum Event {
 pub struct BlockMetadata {
     /// State root after executing all logic in the block.
     pub state_root: Hash,
-    // EventsRoot is the provable events root.
+    // Root hash of all events emitted in the block.
     pub events_root: Vec<u8>,
 }