renamed Store Interface Load methods to Get (#1349)

closes: #1284

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

- **Refactor**
- Updated method names for data retrieval across the application for
improved clarity and consistency.

- **Tests**
- Adjusted test cases to align with the updated method names in the data
retrieval process.

- **Documentation**
- Revised documentation to reflect the changes in method naming
conventions.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: deepakgudla

block/manager.go

@@ -96,7 +96,7 @@ type Manager struct {
 
 // getInitialState tries to load lastState from Store, and if it's not available it reads GenesisDoc.
 func getInitialState(store store.Store, genesis *cmtypes.GenesisDoc) (types.State, error) {
-	s, err := store.LoadState()
+	s, err := store.GetState()
 	if err != nil {
 		s, err = types.NewFromGenesisDoc(genesis)
 	}
@@ -597,11 +597,11 @@ func (m *Manager) publishBlock(ctx context.Context) error {
 	if newHeight == uint64(m.genesis.InitialHeight) {
 		lastCommit = &types.Commit{}
 	} else {
-		lastCommit, err = m.store.LoadCommit(height)
+		lastCommit, err = m.store.GetCommit(height)
 		if err != nil {
 			return fmt.Errorf("error while loading last commit: %w", err)
 		}
-		lastBlock, err := m.store.LoadBlock(height)
+		lastBlock, err := m.store.GetBlock(height)
 		if err != nil {
 			return fmt.Errorf("error while loading last block: %w", err)
 		}
@@ -613,7 +613,7 @@ func (m *Manager) publishBlock(ctx context.Context) error {
 
 	// Check if there's an already stored block at a newer height
 	// If there is use that instead of creating a new block
-	pendingBlock, err := m.store.LoadBlock(newHeight)
+	pendingBlock, err := m.store.GetBlock(newHeight)
 	if err == nil {
 		m.logger.Info("Using pending block", "height", newHeight)
 		block = pendingBlock

node/full_client.go

@@ -315,7 +315,7 @@ func (c *FullClient) BlockchainInfo(ctx context.Context, minHeight, maxHeight in
 
 	blocks := make([]*cmtypes.BlockMeta, 0, maxHeight-minHeight+1)
 	for height := maxHeight; height >= minHeight; height-- {
-		block, err := c.node.Store.LoadBlock(uint64(height))
+		block, err := c.node.Store.GetBlock(uint64(height))
 		if err != nil {
 			return nil, err
 		}
@@ -405,7 +405,7 @@ func (c *FullClient) Health(ctx context.Context) (*ctypes.ResultHealth, error) {
 // If height is nil, it returns information about last known block.
 func (c *FullClient) Block(ctx context.Context, height *int64) (*ctypes.ResultBlock, error) {
 	heightValue := c.normalizeHeight(height)
-	block, err := c.node.Store.LoadBlock(heightValue)
+	block, err := c.node.Store.GetBlock(heightValue)
 	if err != nil {
 		return nil, err
 	}
@@ -428,7 +428,7 @@ func (c *FullClient) Block(ctx context.Context, height *int64) (*ctypes.ResultBl
 
 // BlockByHash returns BlockID and block itself for given hash.
 func (c *FullClient) BlockByHash(ctx context.Context, hash []byte) (*ctypes.ResultBlock, error) {
-	block, err := c.node.Store.LoadBlockByHash(hash)
+	block, err := c.node.Store.GetBlockByHash(hash)
 	if err != nil {
 		return nil, err
 	}
@@ -461,7 +461,7 @@ func (c *FullClient) BlockResults(ctx context.Context, height *int64) (*ctypes.R
 	if err != nil {
 		return nil, err
 	}
-	resp, err := c.node.Store.LoadBlockResponses(h)
+	resp, err := c.node.Store.GetBlockResponses(h)
 	if err != nil {
 		return nil, err
 	}
@@ -479,11 +479,11 @@ func (c *FullClient) BlockResults(ctx context.Context, height *int64) (*ctypes.R
 // Commit returns signed header (aka commit) at given height.
 func (c *FullClient) Commit(ctx context.Context, height *int64) (*ctypes.ResultCommit, error) {
 	heightValue := c.normalizeHeight(height)
-	com, err := c.node.Store.LoadCommit(heightValue)
+	com, err := c.node.Store.GetCommit(heightValue)
 	if err != nil {
 		return nil, err
 	}
-	b, err := c.node.Store.LoadBlock(heightValue)
+	b, err := c.node.Store.GetBlock(heightValue)
 	if err != nil {
 		return nil, err
 	}
@@ -499,7 +499,7 @@ func (c *FullClient) Commit(ctx context.Context, height *int64) (*ctypes.ResultC
 // Validators returns paginated list of validators at given height.
 func (c *FullClient) Validators(ctx context.Context, heightPtr *int64, pagePtr, perPagePtr *int) (*ctypes.ResultValidators, error) {
 	height := c.normalizeHeight(heightPtr)
-	validators, err := c.node.Store.LoadValidators(height)
+	validators, err := c.node.Store.GetValidators(height)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load validators for height %d: %w", height, err)
 	}
@@ -537,7 +537,7 @@ func (c *FullClient) Tx(ctx context.Context, hash []byte, prove bool) (*ctypes.R
 
 	var proof cmtypes.TxProof
 	if prove {
-		block, _ := c.node.Store.LoadBlock(uint64(height))
+		block, _ := c.node.Store.GetBlock(uint64(height))
 		blockProof := block.Data.Txs.Proof(int(index)) // XXX: overflow on 32-bit machines
 		proof = cmtypes.TxProof{
 			RootHash: blockProof.RootHash,
@@ -606,7 +606,7 @@ func (c *FullClient) TxSearch(ctx context.Context, query string, prove bool, pag
 
 		var proof cmtypes.TxProof
 		/*if prove {
-			block := nil                               //env.BlockStore.LoadBlock(r.Height)
+			block := nil                               //env.BlockStore.GetBlock(r.Height)
 			proof = block.Data.Txs.Proof(int(r.Index)) // XXX: overflow on 32-bit machines
 		}*/
 
@@ -666,7 +666,7 @@ func (c *FullClient) BlockSearch(ctx context.Context, query string, page, perPag
 	// Fetch the blocks
 	blocks := make([]*ctypes.ResultBlock, 0, pageSize)
 	for i := skipCount; i < skipCount+pageSize; i++ {
-		b, err := c.node.Store.LoadBlock(uint64(results[i]))
+		b, err := c.node.Store.GetBlock(uint64(results[i]))
 		if err != nil {
 			return nil, err
 		}
@@ -687,23 +687,23 @@ func (c *FullClient) BlockSearch(ctx context.Context, query string, page, perPag
 
 // Status returns detailed information about current status of the node.
 func (c *FullClient) Status(ctx context.Context) (*ctypes.ResultStatus, error) {
-	latest, err := c.node.Store.LoadBlock(c.node.Store.Height())
+	latest, err := c.node.Store.GetBlock(c.node.Store.Height())
 	if err != nil {
 		return nil, fmt.Errorf("failed to find latest block: %w", err)
 	}
 
-	initial, err := c.node.Store.LoadBlock(uint64(c.node.GetGenesis().InitialHeight))
+	initial, err := c.node.Store.GetBlock(uint64(c.node.GetGenesis().InitialHeight))
 	if err != nil {
 		return nil, fmt.Errorf("failed to find earliest block: %w", err)
 	}
 
-	validators, err := c.node.Store.LoadValidators(latest.Height())
+	validators, err := c.node.Store.GetValidators(latest.Height())
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch the validator info at latest block: %w", err)
 	}
 	_, validator := validators.GetByAddress(latest.SignedHeader.ProposerAddress)
 
-	state, err := c.node.Store.LoadState()
+	state, err := c.node.Store.GetState()
 	if err != nil {
 		return nil, fmt.Errorf("failed to load the last saved state: %w", err)
 	}
@@ -807,7 +807,7 @@ func (c *FullClient) HeaderByHash(ctx context.Context, hash cmbytes.HexBytes) (*
 	// decoding logic in the HTTP service will correctly translate from JSON.
 	// See https://github.com/cometbft/cometbft/issues/6802 for context.
 
-	block, err := c.node.Store.LoadBlockByHash(types.Hash(hash))
+	block, err := c.node.Store.GetBlockByHash(types.Hash(hash))
 	if err != nil {
 		return nil, err
 	}
@@ -891,7 +891,7 @@ func (c *FullClient) normalizeHeight(height *int64) uint64 {
 }
 
 func (rpc *FullClient) getBlockMeta(n int64) *cmtypes.BlockMeta {
-	b, err := rpc.node.Store.LoadBlock(uint64(n))
+	b, err := rpc.node.Store.GetBlock(uint64(n))
 	if err != nil {
 		return nil
 	}

node/full_client_test.go

@@ -48,7 +48,7 @@ func getRandomBlockWithProposer(height uint64, nTxs int, proposerAddr []byte) *t
 }
 
 func getBlockMeta(rpc *FullClient, n int64) *cmtypes.BlockMeta {
-	b, err := rpc.node.Store.LoadBlock(uint64(n))
+	b, err := rpc.node.Store.GetBlock(uint64(n))
 	if err != nil {
 		return nil
 	}
@@ -1109,7 +1109,7 @@ func TestStatus(t *testing.T) {
 
 	// specific validation
 	assert.Equal(tconfig.DefaultBaseConfig().Moniker, resp.NodeInfo.Moniker)
-	state, err := rpc.node.Store.LoadState()
+	state, err := rpc.node.Store.GetState()
 	assert.NoError(err)
 	defaultProtocolVersion := p2p.NewProtocolVersion(
 		version.P2PProtocol,

node/full_node_integration_test.go

@@ -133,9 +133,9 @@ func TestTxGossipingAndAggregation(t *testing.T) {
 
 		// assert that all blocks known to node are same as produced by aggregator
 		for h := uint64(1); h <= nodes[i].Store.Height(); h++ {
-			aggBlock, err := nodes[0].Store.LoadBlock(h)
+			aggBlock, err := nodes[0].Store.GetBlock(h)
 			require.NoError(err)
-			nodeBlock, err := nodes[i].Store.LoadBlock(h)
+			nodeBlock, err := nodes[i].Store.GetBlock(h)
 			require.NoError(err)
 			assert.Equal(aggBlock, nodeBlock, fmt.Sprintf("height: %d", h))
 		}
@@ -289,7 +289,7 @@ func TestFastDASync(t *testing.T) {
 	// Verify that the block we synced to is DA included. This is to
 	// ensure that the test is passing due to the DA syncing, since the P2P
 	// block sync will sync quickly but the block won't be DA included.
-	block, err := node2.Store.LoadBlock(numberOfBlocksToSyncTill)
+	block, err := node2.Store.GetBlock(numberOfBlocksToSyncTill)
 	require.NoError(err)
 	require.True(node2.blockManager.IsDAIncluded(block.Hash()))
 }

store/store.go

@@ -94,20 +94,20 @@ func (s *DefaultStore) SaveBlock(block *types.Block, commit *types.Commit) error
 	return nil
 }
 
-// LoadBlock returns block at given height, or error if it's not found in Store.
+// GetBlock returns block at given height, or error if it's not found in Store.
 // TODO(tzdybal): what is more common access pattern? by height or by hash?
 // currently, we're indexing height->hash, and store blocks by hash, but we might as well store by height
 // and index hash->height
-func (s *DefaultStore) LoadBlock(height uint64) (*types.Block, error) {
+func (s *DefaultStore) GetBlock(height uint64) (*types.Block, error) {
 	h, err := s.loadHashFromIndex(height)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load hash from index: %w", err)
 	}
-	return s.LoadBlockByHash(h)
+	return s.GetBlockByHash(h)
 }
 
-// LoadBlockByHash returns block with given block header hash, or error if it's not found in Store.
-func (s *DefaultStore) LoadBlockByHash(hash types.Hash) (*types.Block, error) {
+// GetBlockByHash returns block with given block header hash, or error if it's not found in Store.
+func (s *DefaultStore) GetBlockByHash(hash types.Hash) (*types.Block, error) {
 	blockData, err := s.db.Get(s.ctx, ds.NewKey(getBlockKey(hash)))
 	if err != nil {
 		return nil, fmt.Errorf("failed to load block data: %w", err)
@@ -130,8 +130,8 @@ func (s *DefaultStore) SaveBlockResponses(height uint64, responses *abci.Respons
 	return s.db.Put(s.ctx, ds.NewKey(getResponsesKey(height)), data)
 }
 
-// LoadBlockResponses returns block results at given height, or error if it's not found in Store.
-func (s *DefaultStore) LoadBlockResponses(height uint64) (*abci.ResponseFinalizeBlock, error) {
+// GetBlockResponses returns block results at given height, or error if it's not found in Store.
+func (s *DefaultStore) GetBlockResponses(height uint64) (*abci.ResponseFinalizeBlock, error) {
 	data, err := s.db.Get(s.ctx, ds.NewKey(getResponsesKey(height)))
 	if err != nil {
 		return nil, fmt.Errorf("failed to retrieve block results from height %v: %w", height, err)
@@ -144,17 +144,17 @@ func (s *DefaultStore) LoadBlockResponses(height uint64) (*abci.ResponseFinalize
 	return &responses, nil
 }
 
-// LoadCommit returns commit for a block at given height, or error if it's not found in Store.
-func (s *DefaultStore) LoadCommit(height uint64) (*types.Commit, error) {
+// GetCommit returns commit for a block at given height, or error if it's not found in Store.
+func (s *DefaultStore) GetCommit(height uint64) (*types.Commit, error) {
 	hash, err := s.loadHashFromIndex(height)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load hash from index: %w", err)
 	}
-	return s.LoadCommitByHash(hash)
+	return s.GetCommitByHash(hash)
 }
 
-// LoadCommitByHash returns commit for a block with given block header hash, or error if it's not found in Store.
-func (s *DefaultStore) LoadCommitByHash(hash types.Hash) (*types.Commit, error) {
+// GetCommitByHash returns commit for a block with given block header hash, or error if it's not found in Store.
+func (s *DefaultStore) GetCommitByHash(hash types.Hash) (*types.Commit, error) {
 	commitData, err := s.db.Get(s.ctx, ds.NewKey(getCommitKey(hash)))
 	if err != nil {
 		return nil, fmt.Errorf("failed to retrieve commit from hash %v: %w", hash, err)
@@ -181,8 +181,8 @@ func (s *DefaultStore) UpdateState(state types.State) error {
 	return s.db.Put(s.ctx, ds.NewKey(getStateKey()), data)
 }
 
-// LoadState returns last state saved with UpdateState.
-func (s *DefaultStore) LoadState() (types.State, error) {
+// GetState returns last state saved with UpdateState.
+func (s *DefaultStore) GetState() (types.State, error) {
 	blob, err := s.db.Get(s.ctx, ds.NewKey(getStateKey()))
 	if err != nil {
 		return types.State{}, fmt.Errorf("failed to retrieve state: %w", err)
@@ -213,8 +213,8 @@ func (s *DefaultStore) SaveValidators(height uint64, validatorSet *cmtypes.Valid
 	return s.db.Put(s.ctx, ds.NewKey(getValidatorsKey(height)), blob)
 }
 
-// LoadValidators loads validator set at given block height from store.
-func (s *DefaultStore) LoadValidators(height uint64) (*cmtypes.ValidatorSet, error) {
+// GetValidators loads validator set at given block height from store.
+func (s *DefaultStore) GetValidators(height uint64) (*cmtypes.ValidatorSet, error) {
 	blob, err := s.db.Get(s.ctx, ds.NewKey(getValidatorsKey(height)))
 	if err != nil {
 		return nil, fmt.Errorf("failed to load Validators for height %v: %w", height, err)

store/store.md

@@ -11,16 +11,16 @@ The Store interface defines the following methods:
 - `Height`: Returns the height of the highest block in the store.
 - `SetHeight`: Sets given height in the store if it's higher than the existing height in the store.
 - `SaveBlock`: Saves a block along with its seen commit.
-- `LoadBlock`: Returns a block at a given height.
-- `LoadBlockByHash`: Returns a block with a given block header hash.
+- `GetBlock`: Returns a block at a given height.
+- `GetBlockByHash`: Returns a block with a given block header hash.
 - `SaveBlockResponses`: Saves block responses in the Store.
-- `LoadBlockResponses`: Returns block results at a given height.
-- `LoadCommit`: Returns a commit for a block at a given height.
-- `LoadCommitByHash`: Returns a commit for a block with a given block header hash.
+- `GetBlockResponses`: Returns block results at a given height.
+- `GetCommit`: Returns a commit for a block at a given height.
+- `GetCommitByHash`: Returns a commit for a block with a given block header hash.
 - `UpdateState`: Updates the state saved in the Store. Only one State is stored.
-- `LoadState`: Returns the last state saved with UpdateState.
+- `GetState`: Returns the last state saved with UpdateState.
 - `SaveValidators`: Saves the validator set at a given height.
-- `LoadValidators`: Returns the validator set at a given height.
+- `GetValidators`: Returns the validator set at a given height.
 
 The `TxnDatastore` interface inside [go-datastore] is used for constructing different key-value stores for the underlying storage of a full node. The are two different implementations of `TxnDatastore` in [kv.go]:
 
@@ -39,7 +39,7 @@ For the main node data, `DefaultStore` struct, an implementation of the Store in
 - `responsesPrefix` with value "r": Used to store responses related to the blocks.
 - `validatorsPrefix` with value "v": Used to store validator sets at a given height.
 
-For example, in a call to `LoadBlockByHash` for some block hash `<block_hash>`, the key used in the full node's base key-value store will be `/0/b/<block_hash>` where `0` is the main store prefix and `b` is the block prefix. Similarly, in a call to `LoadValidators` for some height `<height>`, the key used in the full node's base key-value store will be `/0/v/<height>` where `0` is the main store prefix and `v` is the validator set prefix.
+For example, in a call to `GetBlockByHash` for some block hash `<block_hash>`, the key used in the full node's base key-value store will be `/0/b/<block_hash>` where `0` is the main store prefix and `b` is the block prefix. Similarly, in a call to `GetValidators` for some height `<height>`, the key used in the full node's base key-value store will be `/0/v/<height>` where `0` is the main store prefix and `v` is the validator set prefix.
 
 Inside the key-value store, the value of these various types of data like `Block`, `Commit`, etc is stored as a byte array which is encoded and decoded using the corresponding Protobuf [marshal and unmarshal methods][serialization].
 

store/store_test.go

@@ -111,12 +111,12 @@ func TestStoreLoad(t *testing.T) {
 				}
 
 				for _, expected := range c.blocks {
-					block, err := bstore.LoadBlock(uint64(expected.Height()))
+					block, err := bstore.GetBlock(uint64(expected.Height()))
 					assert.NoError(err)
 					assert.NotNil(block)
 					assert.Equal(expected, block)
 
-					commit, err := bstore.LoadCommit(uint64(expected.Height()))
+					commit, err := bstore.GetCommit(uint64(expected.Height()))
 					assert.NoError(err)
 					assert.NotNil(commit)
 				}
@@ -146,7 +146,7 @@ func TestRestart(t *testing.T) {
 	assert.NoError(err)
 
 	s2 := New(ctx, kv)
-	_, err = s2.LoadState()
+	_, err = s2.GetState()
 	assert.NoError(err)
 
 	assert.Equal(expectedHeight, s2.Height())
@@ -183,11 +183,11 @@ func TestBlockResponses(t *testing.T) {
 	err := s.SaveBlockResponses(1, expected)
 	assert.NoError(err)
 
-	resp, err := s.LoadBlockResponses(123)
+	resp, err := s.GetBlockResponses(123)
 	assert.Error(err)
 	assert.Nil(resp)
 
-	resp, err = s.LoadBlockResponses(1)
+	resp, err = s.GetBlockResponses(1)
 	assert.NoError(err)
 	assert.NotNil(resp)
 	assert.Equal(expected, resp)

store/types.go

@@ -18,29 +18,29 @@ type Store interface {
 	// SaveBlock saves block along with its seen commit (which will be included in the next block).
 	SaveBlock(block *types.Block, commit *types.Commit) error
 
-	// LoadBlock returns block at given height, or error if it's not found in Store.
-	LoadBlock(height uint64) (*types.Block, error)
-	// LoadBlockByHash returns block with given block header hash, or error if it's not found in Store.
-	LoadBlockByHash(hash types.Hash) (*types.Block, error)
+	// GetBlock returns block at given height, or error if it's not found in Store.
+	GetBlock(height uint64) (*types.Block, error)
+	// GetBlockByHash returns block with given block header hash, or error if it's not found in Store.
+	GetBlockByHash(hash types.Hash) (*types.Block, error)
 
 	// SaveBlockResponses saves block responses (events, tx responses, validator set updates, etc) in Store.
 	SaveBlockResponses(height uint64, responses *abci.ResponseFinalizeBlock) error
 
 	// LoadBlockResponses returns block results at given height, or error if it's not found in Store.
-	LoadBlockResponses(height uint64) (*abci.ResponseFinalizeBlock, error)
+	GetBlockResponses(height uint64) (*abci.ResponseFinalizeBlock, error)
 
-	// LoadCommit returns commit for a block at given height, or error if it's not found in Store.
-	LoadCommit(height uint64) (*types.Commit, error)
-	// LoadCommitByHash returns commit for a block with given block header hash, or error if it's not found in Store.
-	LoadCommitByHash(hash types.Hash) (*types.Commit, error)
+	// GetCommit returns commit for a block at given height, or error if it's not found in Store.
+	GetCommit(height uint64) (*types.Commit, error)
+	// GetCommitByHash returns commit for a block with given block header hash, or error if it's not found in Store.
+	GetCommitByHash(hash types.Hash) (*types.Commit, error)
 
 	// UpdateState updates state saved in Store. Only one State is stored.
 	// If there is no State in Store, state will be saved.
 	UpdateState(state types.State) error
-	// LoadState returns last state saved with UpdateState.
-	LoadState() (types.State, error)
+	// GetState returns last state saved with UpdateState.
+	GetState() (types.State, error)
 
 	SaveValidators(height uint64, validatorSet *cmtypes.ValidatorSet) error
 
-	LoadValidators(height uint64) (*cmtypes.ValidatorSet, error)
+	GetValidators(height uint64) (*cmtypes.ValidatorSet, error)
 }