go/consensus/cometbft: Rename block height to last height

Author: peternose

.changelog/6303.trivial.md

@@ -75,7 +75,7 @@ type ApplicationConfig struct {
 	ReadOnlyStorage bool
 
 	// InitialHeight is the height of the initial block.
-	InitialHeight uint64
+	InitialHeight int64
 
 	// ChainContext is the chain context for the network.
 	ChainContext string
@@ -273,7 +273,7 @@ func (mux *abciMux) registerHaltHook(hook api.HaltHook) {
 func (mux *abciMux) Info(types.RequestInfo) types.ResponseInfo {
 	return types.ResponseInfo{
 		AppVersion:       version.CometBFTAppVersion,
-		LastBlockHeight:  mux.state.BlockHeight(),
+		LastBlockHeight:  mux.state.LastHeight(),
 		LastBlockAppHash: mux.state.StateRootHash(),
 	}
 }
@@ -298,7 +298,7 @@ func (mux *abciMux) InitChain(req types.RequestInitChain) types.ResponseInitChai
 	})
 	mux.state.blockLock.Unlock()
 
-	if st.Height != req.InitialHeight || uint64(st.Height) != mux.state.initialHeight {
+	if st.Height != req.InitialHeight || st.Height != mux.state.initialHeight {
 		panic(fmt.Errorf("mux: inconsistent initial height (genesis: %d abci: %d state: %d)", st.Height, req.InitialHeight, mux.state.initialHeight))
 	}
 
@@ -570,12 +570,12 @@ func (mux *abciMux) BeginBlock(req types.RequestBeginBlock) types.ResponseBeginB
 		return *mux.state.proposal.resultsBeginBlock
 	}
 
-	blockHeight := mux.state.BlockHeight()
+	lastHeight := mux.state.LastHeight()
 
 	mux.logger.Debug("BeginBlock",
 		"req", req,
 		"hash", hex.EncodeToString(req.Hash),
-		"block_height", blockHeight,
+		"height", lastHeight,
 	)
 
 	params := mux.state.ConsensusParameters()
@@ -607,20 +607,20 @@ func (mux *abciMux) BeginBlock(req types.RequestBeginBlock) types.ResponseBeginB
 	// checks must run on each block to make sure that any pending upgrade descriptors are cleared
 	// after consensus upgrade is performed.
 	if upgrader := mux.state.Upgrader(); upgrader != nil {
-		switch err := upgrader.ConsensusUpgrade(ctx, currentEpoch, blockHeight); err {
+		switch err := upgrader.ConsensusUpgrade(ctx, currentEpoch, lastHeight); err {
 		case nil:
 			// Everything ok.
 		case upgrade.ErrStopForUpgrade:
 			// Signal graceful stop for upgrade.
-			mux.haltForUpgrade(blockHeight, currentEpoch, true)
+			mux.haltForUpgrade(lastHeight, currentEpoch, true)
 		default:
 			panic(fmt.Errorf("mux: error while trying to perform consensus upgrade: %w", err))
 		}
 	}
 
 	// Check if we need to halt based on local configuration.
-	if mux.state.shouldLocalHalt(blockHeight+1, currentEpoch) {
-		mux.haltForUpgrade(blockHeight, currentEpoch, true)
+	if mux.state.shouldLocalHalt(lastHeight+1, currentEpoch) {
+		mux.haltForUpgrade(lastHeight, currentEpoch, true)
 	}
 
 	// Dispatch BeginBlock to all applications.
@@ -632,7 +632,7 @@ func (mux *abciMux) BeginBlock(req types.RequestBeginBlock) types.ResponseBeginB
 			)
 
 			if errors.Is(err, upgrade.ErrStopForUpgrade) {
-				mux.haltForUpgrade(blockHeight, currentEpoch, true)
+				mux.haltForUpgrade(lastHeight, currentEpoch, true)
 			}
 			panic(fmt.Errorf("mux: BeginBlock: fatal error in application: '%s': %w", app.Name(), err))
 		}
@@ -642,7 +642,7 @@ func (mux *abciMux) BeginBlock(req types.RequestBeginBlock) types.ResponseBeginB
 
 	// During the first block, also collect and prepend application events generated during
 	// InitChain to BeginBlock events.
-	if mux.state.BlockHeight() == 0 {
+	if mux.state.LastHeight() == 0 {
 		response.Events = append(response.Events, mux.state.initEvents...)
 	}
 
@@ -761,7 +761,7 @@ func (mux *abciMux) EndBlock(req types.RequestEndBlock) types.ResponseEndBlock {
 
 	mux.logger.Debug("EndBlock",
 		"req", req,
-		"block_height", mux.state.BlockHeight(),
+		"height", mux.state.LastHeight(),
 	)
 
 	ctx := mux.state.NewContext(api.ContextEndBlock)
@@ -829,7 +829,7 @@ func (mux *abciMux) Commit() types.ResponseCommit {
 	}
 
 	mux.logger.Debug("Commit",
-		"block_height", mux.state.BlockHeight(),
+		"height", mux.state.LastHeight(),
 		"state_root_hash", hex.EncodeToString(mux.state.StateRootHash()),
 		"last_retained_version", lastRetainedVersion,
 	)
@@ -936,7 +936,7 @@ func (mux *abciMux) checkDependencies() error {
 }
 
 func (mux *abciMux) finishInitialization() error {
-	if mux.state.BlockHeight() >= mux.state.InitialHeight() {
+	if mux.state.LastHeight() >= mux.state.InitialHeight() {
 		mux.state.resetProposal()
 		defer mux.state.closeProposal()
 
@@ -996,7 +996,7 @@ func newABCIMux(ctx context.Context, upgrader upgrade.Backend, cfg *ApplicationC
 	mux.md.Subscribe(api.MessageExecuteSubcall, mux)
 
 	mux.logger.Debug("ABCI multiplexer initialized",
-		"block_height", state.BlockHeight(),
+		"height", state.LastHeight(),
 		"state_root_hash", hex.EncodeToString(state.StateRootHash()),
 	)
 

go/consensus/cometbft/abci/mux.go

@@ -129,7 +129,7 @@ type applicationState struct {
 	ctx       context.Context
 	cancelCtx context.CancelFunc
 
-	initialHeight uint64
+	initialHeight int64
 
 	stateRoot storage.Root
 	storage   storage.LocalBackend
@@ -193,7 +193,7 @@ func (s *applicationState) NewContext(mode api.ContextMode) *api.Context {
 		s.initState = mkvs.NewOverlay(mkvs.New(nil, nil, storage.RootTypeState, mkvs.WithoutWriteLog()))
 		state = s.initState
 		// Configure block height so that current height will be correctly computed.
-		lastHeight = int64(s.initialHeight) - 1
+		lastHeight = s.initialHeight - 1
 	case api.ContextCheckTx:
 		state = mkvs.NewOverlayWrapper(s.checkState)
 	case api.ContextDeliverTx, api.ContextBeginBlock, api.ContextEndBlock:
@@ -217,7 +217,7 @@ func (s *applicationState) NewContext(mode api.ContextMode) *api.Context {
 		state,
 		blockCtx,
 		lastHeight,
-		int64(s.initialHeight),
+		s.initialHeight,
 	)
 }
 
@@ -234,25 +234,26 @@ func (s *applicationState) Checkpointer() checkpoint.Checkpointer {
 }
 
 func (s *applicationState) InitialHeight() int64 {
-	return int64(s.initialHeight)
+	return s.initialHeight
 }
 
-func (s *applicationState) BlockHeight() int64 {
+func (s *applicationState) LastHeight() int64 {
 	s.blockLock.RLock()
 	defer s.blockLock.RUnlock()
 
-	height := s.stateRoot.Version
+	height := int64(s.stateRoot.Version)
 	if height < s.initialHeight {
 		height = 0
 	}
-	return int64(height)
+	return height
 }
 
 func (s *applicationState) StateRootHash() []byte {
 	s.blockLock.RLock()
 	defer s.blockLock.RUnlock()
 
-	if s.stateRoot.Version < s.initialHeight {
+	height := int64(s.stateRoot.Version)
+	if height < s.initialHeight {
 		// CometBFT expects a nil hash when there is no state otherwise it will panic.
 		return nil
 	}
@@ -279,12 +280,12 @@ func (s *applicationState) GetEpoch(ctx context.Context, blockHeight int64) (bea
 }
 
 func (s *applicationState) GetCurrentEpoch(ctx context.Context) (beacon.EpochTime, error) {
-	blockHeight := s.BlockHeight()
-	if blockHeight == 0 {
+	lastHeight := s.LastHeight()
+	if lastHeight == 0 {
 		return beacon.EpochInvalid, nil
 	}
 
-	latestHeight := blockHeight
+	latestHeight := lastHeight
 	if abciCtx := api.FromCtx(ctx); abciCtx != nil {
 		// If request was made from an ABCI application context, then use blockHeight + 1, to fetch
 		// the epoch at current (future) height. See cometbft/api.NewImmutableState for details.
@@ -297,23 +298,23 @@ func (s *applicationState) GetCurrentEpoch(ctx context.Context) (beacon.EpochTim
 	if err != nil {
 		return beacon.EpochInvalid, fmt.Errorf("failed to get future epoch for height %d: %w", latestHeight, err)
 	}
-	if future != nil && future.Height == blockHeight+1 {
+	if future != nil && future.Height == lastHeight+1 {
 		return future.Epoch, nil
 	}
 
 	currentEpoch, err := s.timeSource.GetEpoch(ctx, latestHeight)
 	if err != nil {
-		return beacon.EpochInvalid, fmt.Errorf("failed to get epoch for height %d: %w", blockHeight+1, err)
+		return beacon.EpochInvalid, fmt.Errorf("failed to get epoch for height %d: %w", lastHeight+1, err)
 	}
 	return currentEpoch, nil
 }
 
 func (s *applicationState) EpochChanged(ctx *api.Context) (bool, beacon.EpochTime) {
-	blockHeight := s.BlockHeight()
-	if blockHeight == 0 {
+	lastHeight := s.LastHeight()
+	if lastHeight == 0 {
 		return false, beacon.EpochInvalid
 	}
-	latestHeight := blockHeight
+	latestHeight := lastHeight
 	if abciCtx := api.FromCtx(ctx); abciCtx != nil {
 		// If request was made from an ABCI application context, then use blockHeight + 1, to fetch
 		// the epoch at current (future) height. See cometbft/api.NewImmutableState for details.
@@ -328,7 +329,7 @@ func (s *applicationState) EpochChanged(ctx *api.Context) (bool, beacon.EpochTim
 		return false, beacon.EpochInvalid
 	}
 
-	if uint64(blockHeight) == s.initialHeight {
+	if lastHeight == s.initialHeight {
 		// There is no block before the first block. For historic reasons, this is defined as not
 		// having had a transition.
 		return false, currentEpoch
@@ -380,13 +381,14 @@ func (s *applicationState) doInitChain() error {
 
 	// We use the height before the initial height for the state before the first block. Note that
 	// this tree is not persisted, we only need it to compute the root hash.
-	_, stateRootHash, err := s.canonicalState.Commit(s.ctx, s.stateRoot.Namespace, s.initialHeight-1, mkvs.NoPersist())
+	version := uint64(s.initialHeight - 1)
+	_, stateRootHash, err := s.canonicalState.Commit(s.ctx, s.stateRoot.Namespace, version, mkvs.NoPersist())
 	if err != nil {
 		return fmt.Errorf("failed to commit: %w", err)
 	}
 
 	s.stateRoot.Hash = stateRootHash
-	s.stateRoot.Version = s.initialHeight - 1
+	s.stateRoot.Version = version
 
 	return s.doCommitOrInitChainLocked()
 }
@@ -622,7 +624,7 @@ func (s *applicationState) pruneWorker() {
 			if err := s.statePruner.Prune(version); err != nil {
 				s.logger.Warn("failed to prune state",
 					"err", err,
-					"block_height", version,
+					"height", version,
 				)
 			}
 		}
@@ -756,7 +758,8 @@ func newApplicationState(ctx context.Context, upgrader upgrade.Backend, cfg *App
 	}
 
 	// Refresh consensus parameters when loading state if we are past genesis.
-	if latestVersion >= s.initialHeight {
+	initialVersion := uint64(s.initialHeight)
+	if latestVersion >= initialVersion {
 		if err = s.doCommitOrInitChainLocked(); err != nil {
 			return nil, fmt.Errorf("state: failed to run initial state commit hook: %w", err)
 		}
@@ -774,7 +777,7 @@ func newApplicationState(ctx context.Context, upgrader upgrade.Backend, cfg *App
 					Interval:       params.StateCheckpointInterval,
 					NumKept:        params.StateCheckpointNumKept,
 					ChunkSize:      params.StateCheckpointChunkSize,
-					InitialVersion: cfg.InitialHeight,
+					InitialVersion: initialVersion,
 					ChunkerThreads: cfg.ChunkerThreads,
 				}, nil
 			},

go/consensus/cometbft/abci/state.go

@@ -156,7 +156,7 @@ func (mux *abciMux) EstimateGas(caller signature.PublicKey, tx *transaction.Tran
 
 	// Certain modules, in particular the beacon require InitChain or BeginBlock
 	// to have completed before initialization is complete.
-	if mux.state.BlockHeight() == 0 {
+	if mux.state.LastHeight() == 0 {
 		return 0, consensus.ErrNoCommittedBlocks
 	}
 

go/consensus/cometbft/abci/transaction.go

@@ -24,7 +24,7 @@ func (mux *abciMux) maybeHaltForUpgrade() {
 		)
 		return
 	}
-	height := mux.state.BlockHeight()
+	height := mux.state.LastHeight()
 
 	// Check if we need to halt for an upgrade -- but do not actually run the upgrade.
 	switch err := upgrader.ConsensusUpgrade(nil, epoch, height); err {

go/consensus/cometbft/abci/upgrade.go

@@ -83,8 +83,8 @@ type ApplicationQueryState interface {
 	// This may be nil in case checkpoints are disabled.
 	Checkpointer() checkpoint.Checkpointer
 
-	// BlockHeight returns the last committed block height.
-	BlockHeight() int64
+	// LastHeight returns the last committed block height.
+	LastHeight() int64
 
 	// GetEpoch returns epoch at block height.
 	GetEpoch(ctx context.Context, blockHeight int64) (beacon.EpochTime, error)
@@ -104,7 +104,7 @@ type MockApplicationState interface {
 
 // MockApplicationStateConfig is the configuration for the mock application state.
 type MockApplicationStateConfig struct {
-	BlockHeight   int64
+	LastHeight    int64
 	StateRootHash []byte
 
 	BaseEpoch    beacon.EpochTime
@@ -155,8 +155,8 @@ func (ms *mockApplicationState) InitialHeight() int64 {
 	return ms.cfg.Genesis.Height
 }
 
-func (ms *mockApplicationState) BlockHeight() int64 {
-	return ms.cfg.BlockHeight
+func (ms *mockApplicationState) LastHeight() int64 {
+	return ms.cfg.LastHeight
 }
 
 func (ms *mockApplicationState) StateRootHash() []byte {
@@ -214,7 +214,7 @@ func (ms *mockApplicationState) NewContext(mode ContextMode) *Context {
 		gasAccountant: NewNopGasAccountant(),
 		state:         ms.tree,
 		appState:      ms,
-		lastHeight:    ms.cfg.BlockHeight,
+		lastHeight:    ms.cfg.LastHeight,
 		blockCtx:      ms.blockCtx,
 		initialHeight: ms.InitialHeight(),
 		logger:        logging.GetLogger("consensus/cometbft/abci").With("mode", mode),
@@ -273,14 +273,14 @@ func NewImmutableStateAt(ctx context.Context, state ApplicationQueryState, versi
 	}
 
 	// Handle a regular (external) query where we need to create a new tree.
-	if state.BlockHeight() == 0 {
+	if state.LastHeight() == 0 {
 		return nil, consensus.ErrNoCommittedBlocks
 	}
-	if version > state.BlockHeight() {
+	if version > state.LastHeight() {
 		return nil, consensus.ErrVersionNotFound
 	}
 	if version <= 0 {
-		version = state.BlockHeight()
+		version = state.LastHeight()
 	}
 
 	ndb := state.Storage().NodeDB()

go/consensus/cometbft/api/state.go

@@ -279,7 +279,7 @@ func TestGenesis(t *testing.T) {
 	currentEpoch := beacon.EpochTime(80)
 
 	appState := abciAPI.NewMockApplicationState(&abciAPI.MockApplicationStateConfig{
-		BlockHeight:  1000,
+		LastHeight:   1000,
 		BaseEpoch:    1,
 		CurrentEpoch: currentEpoch,
 	})

go/consensus/cometbft/apps/governance/genesis_test.go

@@ -178,7 +178,7 @@ func NewArchive(ctx context.Context, cfg ArchiveConfig) (consensusAPI.Service, e
 		},
 		Identity:            cfg.Identity,
 		DisableCheckpointer: true,
-		InitialHeight:       uint64(srv.genesisHeight),
+		InitialHeight:       srv.genesisHeight,
 		// ReadOnly should actually be preferable for archive but there is a badger issue with read-only:
 		// https://discuss.dgraph.io/t/read-only-log-truncate-required-to-run-db/16444/2
 		ReadOnlyStorage: false,

go/consensus/cometbft/full/archive.go

@@ -511,7 +511,7 @@ func (n *commonNode) heightToCometBFTHeight(height int64) (int64, error) {
 		// Do not let CometBFT determine the latest height (e.g., by passing nil) as that
 		// completely ignores ABCI processing so it can return a block for which local state does
 		// not yet exist. Use our mux notion of latest height instead.
-		tmHeight := n.mux.State().BlockHeight()
+		tmHeight := n.mux.State().LastHeight()
 		if tmHeight == 0 {
 			// No committed blocks yet.
 			return 0, consensusAPI.ErrNoCommittedBlocks

go/consensus/cometbft/full/common.go

@@ -571,7 +571,7 @@ func (t *fullService) lazyInit() error { // nolint: gocyclo
 		DisableCheckpointer:       config.GlobalConfig.Consensus.Checkpointer.Disabled,
 		CheckpointerCheckInterval: config.GlobalConfig.Consensus.Checkpointer.CheckInterval,
 		ChunkerThreads:            threads,
-		InitialHeight:             uint64(t.genesisHeight),
+		InitialHeight:             t.genesisHeight,
 		ChainContext:              t.chainContext,
 	}
 	t.mux, err = abci.NewApplicationServer(t.ctx, t.upgrader, appConfig)