[cache] BlockAccessor with caching separate from StateAccessor

nil/internal/collate/block_listener.go

@@ -175,6 +175,22 @@ func unmarshalBlock(pbBlock *pb.RawFullBlock) (*types.BlockWithExtractedData, er
 	return raw.DecodeBytes()
 }
 
+type blockByNumberCache struct {
+	blockByHash       *execution.BlockByHashAccessor
+	blockHashByNumber *execution.BlockHashByNumberAccessor
+}
+
+func (b blockByNumberCache) Get(
+	tx db.RoTx, shardId types.ShardId, num types.BlockNumber,
+) (*types.RawBlockWithExtractedData, error) {
+	hash, err := b.blockHashByNumber.Get(tx, shardId, num)
+	if err != nil {
+		return nil, err
+	}
+
+	return b.blockByHash.Get(tx, shardId, hash)
+}
+
 func SetBlockRequestHandler(
 	ctx context.Context, networkManager network.Manager, shardId types.ShardId, database db.DB, logger logging.Logger,
 ) {
@@ -183,8 +199,10 @@ func SetBlockRequestHandler(
 		return
 	}
 
-	// Sharing accessor between all handlers enables caching.
-	accessor := execution.NewStateAccessor(128, 0)
+	accessor := &blockByNumberCache{
+		blockByHash:       execution.NewBlockByHashAccessor(128),
+		blockHashByNumber: execution.NewBlockHashByNumberAccessor(),
+	}
 	handler := func(s network.Stream) {
 		if err := s.SetDeadline(time.Now().Add(requestTimeout)); err != nil {
 			return
@@ -212,15 +230,8 @@ func SetBlockRequestHandler(
 		}
 		defer tx.Rollback()
 
-		acc := accessor.RawAccess(tx, shardId).
-			GetBlock().
-			WithOutTransactions().
-			WithInTransactions().
-			WithChildBlocks().
-			WithConfig()
-
 		for id := blockReq.GetId(); ; id++ {
-			resp, err := acc.ByNumber(types.BlockNumber(id))
+			resp, err := accessor.Get(tx, shardId, types.BlockNumber(id))
 			if err != nil {
 				if !errors.Is(err, db.ErrKeyNotFound) {
 					logError(logger, err, "DB error")
@@ -229,11 +240,11 @@ func SetBlockRequestHandler(
 			}
 
 			b := &pb.RawFullBlock{
-				BlockBytes:           resp.Block(),
-				OutTransactionsBytes: resp.OutTransactions(),
-				InTransactionsBytes:  resp.InTransactions(),
-				ChildBlocks:          pb.PackHashes(resp.ChildBlocks()),
-				Config:               resp.Config(),
+				BlockBytes:           resp.Block,
+				OutTransactionsBytes: resp.OutTransactions,
+				InTransactionsBytes:  resp.InTransactions,
+				ChildBlocks:          pb.PackHashes(resp.ChildBlocks),
+				Config:               resp.Config,
 			}
 
 			if err := writeBlockToStream(s, b); err != nil {

nil/internal/collate/proposer.go

@@ -73,11 +73,10 @@ func (p *proposer) GenerateProposal(ctx context.Context, txFabric db.DB) (*execu
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch previous block: %w", err)
 	}
-	data, err := p.params.StateAccessor.Access(tx, p.params.ShardId).GetBlock().ByHash(prevBlockHash)
+	prevBlock, err := p.params.BlockAccessor.GetByHash(tx, p.params.ShardId, prevBlockHash)
 	if err != nil {
 		return nil, err
 	}
-	prevBlock := data.Block()
 
 	if prevBlock.PatchLevel > validatorPatchLevel {
 		return nil, fmt.Errorf(
@@ -94,7 +93,7 @@ func (p *proposer) GenerateProposal(ctx context.Context, txFabric db.DB) (*execu
 	p.executionState, err = execution.NewExecutionState(tx, p.params.ShardId, execution.StateParams{
 		Block:          prevBlock,
 		ConfigAccessor: configAccessor,
-		StateAccessor:  p.params.StateAccessor,
+		BlockAccessor:  p.params.BlockAccessor,
 		FeeCalculator:  p.params.FeeCalculator,
 		Mode:           execution.ModeProposal,
 	})
@@ -381,17 +380,14 @@ func (p *proposer) handleTransactionsFromNeighbors(tx db.RoTx) error {
 		neighbor := &state.Neighbors[position]
 		nextTx := p.executionState.InTxCounts[neighborId]
 
-		shardAccessor := p.params.StateAccessor.Access(tx, neighborId)
-
 		for checkLimits() {
-			data, err := shardAccessor.GetBlock().ByNumber(neighbor.BlockNumber)
+			block, err := p.params.BlockAccessor.GetByNumber(tx, neighborId, neighbor.BlockNumber)
 			if errors.Is(err, db.ErrKeyNotFound) {
 				break
 			}
 			if err != nil {
 				return err
 			}
-			block := data.Block()
 
 			outTxnTrie := execution.NewDbTransactionTrieReader(tx, neighborId)
 			if err := outTxnTrie.SetRootHash(block.OutTransactionsRoot); err != nil {

nil/internal/collate/validator.go

@@ -112,11 +112,11 @@ func (s *Validator) getLastBlockUnlocked(ctx context.Context) (*types.Block, com
 		return nil, common.EmptyHash, err
 	}
 
-	block, err := s.params.StateAccessor.Access(tx, s.params.ShardId).GetBlock().ByHash(hash)
+	block, err := s.params.BlockAccessor.GetByHash(tx, s.params.ShardId, hash)
 	if err != nil {
 		return nil, common.EmptyHash, err
 	}
-	return block.Block(), hash, nil
+	return block, hash, nil
 }
 
 func (s *Validator) GetLastBlock(ctx context.Context) (*types.Block, common.Hash, error) {
@@ -140,11 +140,11 @@ func (s *Validator) getBlock(ctx context.Context, hash common.Hash) (*types.Bloc
 	}
 	defer tx.Rollback()
 
-	block, err := s.params.StateAccessor.Access(tx, s.params.ShardId).GetBlock().ByHash(hash)
+	block, err := s.params.BlockAccessor.GetByHash(tx, s.params.ShardId, hash)
 	if err != nil {
 		return nil, err
 	}
-	return block.Block(), nil
+	return block, nil
 }
 
 func (s *Validator) TxPool() TxnPool {