[execution] Improve caching in accessors + simplify code

Author: dmtrskv

nil/internal/collate/block_listener.go

@@ -212,15 +212,9 @@ func SetBlockRequestHandler(
 		}
 		defer tx.Rollback()
 
-		acc := accessor.RawAccess(tx, shardId).
-			GetBlock().
-			WithOutTransactions().
-			WithInTransactions().
-			WithChildBlocks().
-			WithConfig()
-
+		acc := accessor.RawAccess(tx, shardId)
 		for id := blockReq.GetId(); ; id++ {
-			resp, err := acc.ByNumber(types.BlockNumber(id))
+			resp, err := acc.GetFullBlockByNumber(types.BlockNumber(id))
 			if err != nil {
 				if !errors.Is(err, db.ErrKeyNotFound) {
 					logError(logger, err, "DB error")
@@ -229,11 +223,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_test.go

@@ -1,6 +1,7 @@
 package collate
 
 import (
+	"slices"
 	"testing"
 
 	"github.com/NilFoundation/nil/nil/common"
@@ -97,24 +98,24 @@ func (s *ProposerTestSuite) TestCollator() {
 	p := newTestProposer(params, pool)
 	shardId := p.params.ShardId
 
-	generateBlock := func() *execution.Proposal {
+	generateBlock := func() (*execution.Proposal, *execution.BlockGenerationResult) {
 		proposal := s.generateProposal(p)
 
 		tx, err := s.db.CreateRoTx(s.T().Context())
 		s.Require().NoError(err)
 		defer tx.Rollback()
 
-		block, err := db.ReadBlock(tx, shardId, proposal.PrevBlockHash)
+		prevBlock, err := db.ReadBlock(tx, shardId, proposal.PrevBlockHash)
 		s.Require().NoError(err)
 
-		blockGenerator, err := execution.NewBlockGenerator(s.T().Context(), params.BlockGeneratorParams, s.db, block)
+		gen, err := execution.NewBlockGenerator(s.T().Context(), params.BlockGeneratorParams, s.db, prevBlock)
 		s.Require().NoError(err)
-		defer blockGenerator.Rollback()
+		defer gen.Rollback()
 
-		_, err = blockGenerator.GenerateBlock(proposal, &types.ConsensusParams{})
+		block, err := gen.GenerateBlock(proposal, &types.ConsensusParams{})
 		s.Require().NoError(err)
 
-		return proposal
+		return proposal, block
 	}
 
 	s.Run("GenerateZeroState", func() {
@@ -133,9 +134,9 @@ func (s *ProposerTestSuite) TestCollator() {
 		pool.Reset()
 		pool.Add(m1, m2)
 
-		proposal := generateBlock()
-		r1 = s.checkReceipt(shardId, m1)
-		r2 = s.checkReceipt(shardId, m2)
+		proposal, res := generateBlock()
+		r1 = s.checkReceipt(res, m1)
+		r2 = s.checkReceipt(res, m2)
 		s.Equal(pool.Txns, proposal.ExternalTxns)
 
 		// Each transaction subtracts its value + actual gas used from the balance.
@@ -160,15 +161,13 @@ func (s *ProposerTestSuite) TestCollator() {
 
 		balance = balance.Add(r1.Forwarded).Add(r2.Forwarded)
 		s.Equal(balance, s.getMainBalance())
-
-		s.checkSeqno(shardId)
 	})
 
 	s.Run("DoNotProcessDuplicates", func() {
 		pool.Reset()
 		pool.Add(m1, m2)
 
-		proposal := generateBlock()
+		proposal, _ := generateBlock()
 		s.Empty(proposal.ExternalTxns)
 		s.Empty(proposal.InternalTxns)
 		s.Empty(proposal.ForwardTxns)
@@ -183,36 +182,17 @@ func (s *ProposerTestSuite) TestCollator() {
 		pool.Reset()
 		pool.Add(m)
 
-		generateBlock()
-		s.checkReceipt(shardId, m)
+		_, res := generateBlock()
+		s.checkReceipt(res, m)
 	})
 
 	s.Run("Execute", func() {
 		m := execution.NewExecutionTransaction(to, to, 1, contracts.NewCounterAddCallData(s.T(), 3))
 		pool.Reset()
 		pool.Add(m)
 
-		generateBlock()
-		s.checkReceipt(shardId, m)
-	})
-
-	s.Run("CheckRefundsSeqno", func() {
-		m01 := execution.NewSendMoneyTransaction(s.T(), to, 2)
-		m02 := execution.NewSendMoneyTransaction(s.T(), to, 3)
-		pool.Reset()
-		pool.Add(m01, m02)
-
-		// send tokens
-		generateBlock()
-
-		// process internal transactions
-		generateBlock()
-
-		// process refunds
-		generateBlock()
-
-		// check refunds seqnos
-		s.checkSeqno(shardId)
+		_, res := generateBlock()
+		s.checkReceipt(res, m)
 	})
 }
 
@@ -245,52 +225,16 @@ func (s *ProposerTestSuite) getBalance(shardId types.ShardId, addr types.Address
 	return acc.Balance
 }
 
-func (s *ProposerTestSuite) checkSeqno(shardId types.ShardId) {
-	s.T().Helper()
-
-	tx, err := s.db.CreateRoTx(s.T().Context())
-	s.Require().NoError(err)
-	defer tx.Rollback()
-
-	sa := execution.NewStateAccessor()
-	blockHash, err := db.ReadLastBlockHash(tx, shardId)
-	s.Require().NoError(err)
-
-	block, err := sa.Access(tx, shardId).GetBlock().WithInTransactions().WithOutTransactions().ByHash(blockHash)
-	s.Require().NoError(err)
-
-	check := func(txns []*types.Transaction) {
-		if len(txns) == 0 {
-			return
-		}
-		seqno := txns[0].Seqno
-		for _, m := range txns {
-			s.Require().Equal(seqno, m.Seqno)
-			seqno++
-		}
-	}
-
-	check(block.InTransactions())
-	check(block.OutTransactions())
-}
-
-func (s *ProposerTestSuite) checkReceipt(shardId types.ShardId, m *types.Transaction) *types.Receipt {
+func (s *ProposerTestSuite) checkReceipt(genRes *execution.BlockGenerationResult, m *types.Transaction) *types.Receipt {
 	s.T().Helper()
 
-	tx, err := s.db.CreateRoTx(s.T().Context())
-	s.Require().NoError(err)
-	defer tx.Rollback()
-
-	sa := execution.NewStateAccessor()
-	txnData, err := sa.Access(tx, m.From.ShardId()).GetInTransaction().ByHash(m.Hash())
-	s.Require().NoError(err)
+	hash := m.Hash()
+	idx := slices.IndexFunc(genRes.Receipts, func(r *types.Receipt) bool {
+		return r.TxnHash == hash
+	})
+	s.Require().GreaterOrEqual(idx, 0, "receipt not found for transaction %s", hash)
 
-	receiptsTrie := execution.NewDbReceiptTrieReader(tx, shardId)
-	s.Require().NoError(receiptsTrie.SetRootHash(txnData.Block().ReceiptsRoot))
-	receipt, err := receiptsTrie.Fetch(txnData.Index())
-	s.Require().NoError(err)
-	s.Equal(m.Hash(), receipt.TxnHash)
-	return receipt
+	return genRes.Receipts[idx]
 }
 
 func TestProposer(t *testing.T) {

nil/internal/db/accessors.go

@@ -3,22 +3,43 @@ package db
 import (
 	"encoding/binary"
 	"errors"
+	"fmt"
 	"reflect"
 
 	"github.com/NilFoundation/nil/nil/common"
 	"github.com/NilFoundation/nil/nil/internal/serialization"
 	"github.com/NilFoundation/nil/nil/internal/types"
 )
 
-// todo: return errors
+type prettyKey interface {
+	fmt.Stringer
+	Bytes() []byte
+}
+
+func Get(tx RoTx, table TableName, key prettyKey) ([]byte, error) {
+	data, err := tx.Get(table, key.Bytes())
+	if err != nil {
+		return nil, fmt.Errorf("%w: key=%s", err, key)
+	}
+	return data, nil
+}
+
+func GetFromShard(tx RoTx, shardId types.ShardId, table ShardedTableName, key prettyKey) ([]byte, error) {
+	data, err := tx.GetFromShard(shardId, table, key.Bytes())
+	if err != nil {
+		return nil, fmt.Errorf("%w: key=%s", err, key)
+	}
+	return data, nil
+}
+
 func readDecodable[
 	T interface {
 		~*S
 		serialization.NilUnmarshaler
 	},
 	S any,
 ](tx RoTx, table ShardedTableName, shardId types.ShardId, hash common.Hash) (*S, error) {
-	data, err := tx.GetFromShard(shardId, table, hash.Bytes())
+	data, err := GetFromShard(tx, shardId, table, hash)
 	if err != nil {
 		return nil, err
 	}
@@ -30,25 +51,15 @@ func readDecodable[
 	return decoded, nil
 }
 
-func writeRawKeyEncodable[
-	T interface {
-		serialization.NilMarshaler
-	},
-](tx RwTx, tableName ShardedTableName, shardId types.ShardId, key []byte, value T) error {
-	data, err := value.MarshalNil()
+func writeEncodable[T serialization.NilMarshaler](
+	tx RwTx, tableName ShardedTableName, shardId types.ShardId, hash common.Hash, obj T,
+) error {
+	data, err := obj.MarshalNil()
 	if err != nil {
 		return err
 	}
 
-	return tx.PutToShard(shardId, tableName, key, data)
-}
-
-func writeEncodable[
-	T interface {
-		serialization.NilMarshaler
-	},
-](tx RwTx, tableName ShardedTableName, shardId types.ShardId, hash common.Hash, obj T) error {
-	return writeRawKeyEncodable(tx, tableName, shardId, hash.Bytes(), obj)
+	return tx.PutToShard(shardId, tableName, hash.Bytes(), data)
 }
 
 func ReadVersionInfo(tx RoTx) (*types.VersionInfo, error) {
@@ -88,7 +99,7 @@ func ReadBlock(tx RoTx, shardId types.ShardId, hash common.Hash) (*types.Block,
 }
 
 func ReadBlockBytes(tx RoTx, shardId types.ShardId, hash common.Hash) ([]byte, error) {
-	return tx.GetFromShard(shardId, blockTable, hash.Bytes())
+	return GetFromShard(tx, shardId, blockTable, hash)
 }
 
 func ReadLastBlock(tx RoTx, shardId types.ShardId) (*types.Block, common.Hash, error) {
@@ -105,7 +116,7 @@ func ReadLastBlock(tx RoTx, shardId types.ShardId) (*types.Block, common.Hash, e
 
 func ReadCollatorState(tx RoTx, shardId types.ShardId) (types.CollatorState, error) {
 	res := types.CollatorState{}
-	buf, err := tx.Get(collatorStateTable, shardId.Bytes())
+	buf, err := Get(tx, collatorStateTable, shardId)
 	if err != nil {
 		return res, err
 	}
@@ -125,7 +136,7 @@ func WriteCollatorState(tx RwTx, shardId types.ShardId, state types.CollatorStat
 }
 
 func ReadLastBlockHash(tx RoTx, shardId types.ShardId) (common.Hash, error) {
-	h, err := tx.Get(LastBlockTable, shardId.Bytes())
+	h, err := Get(tx, LastBlockTable, shardId)
 	return common.BytesToHash(h), err
 }
 
@@ -140,7 +151,7 @@ func WriteBlockTimestamp(tx RwTx, shardId types.ShardId, blockHash common.Hash,
 }
 
 func ReadBlockTimestamp(tx RoTx, shardId types.ShardId, blockHash common.Hash) (uint64, error) {
-	value, err := tx.GetFromShard(shardId, blockTimestampTable, blockHash.Bytes())
+	value, err := GetFromShard(tx, shardId, blockTimestampTable, blockHash)
 	if err != nil {
 		return 0, err
 	}
@@ -156,7 +167,7 @@ func WriteError(tx RwTx, txnHash common.Hash, errMsg string) error {
 }
 
 func ReadError(tx RoTx, txnHash common.Hash) (string, error) {
-	res, err := tx.Get(errorByTransactionHashTable, txnHash.Bytes())
+	res, err := Get(tx, errorByTransactionHashTable, txnHash)
 	if err != nil {
 		return "", err
 	}
@@ -168,14 +179,14 @@ func WriteCode(tx RwTx, shardId types.ShardId, hash common.Hash, code types.Code
 }
 
 func ReadCode(tx RoTx, shardId types.ShardId, hash common.Hash) (types.Code, error) {
-	if hash == types.EmptyCodeHash {
+	if hash.Empty() {
 		return types.Code{}, nil
 	}
-	return tx.GetFromShard(shardId, codeTable, hash.Bytes())
+	return GetFromShard(tx, shardId, codeTable, hash)
 }
 
 func ReadBlockHashByNumber(tx RoTx, shardId types.ShardId, blockNumber types.BlockNumber) (common.Hash, error) {
-	blockHash, err := tx.GetFromShard(shardId, BlockHashByNumberIndex, blockNumber.Bytes())
+	blockHash, err := GetFromShard(tx, shardId, BlockHashByNumberIndex, blockNumber)
 	return common.BytesToHash(blockHash), err
 }
 

nil/internal/db/badger.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"errors"
+	"fmt"
 	"io"
 	"runtime"
 	"sync"
@@ -226,7 +227,7 @@ func (tx *BadgerRwTx) Put(tableName TableName, key, value []byte) error {
 func (tx *BadgerRoTx) Get(tableName TableName, key []byte) ([]byte, error) {
 	item, err := tx.tx.Get(MakeKey(tableName, key))
 	if errors.Is(err, badger.ErrKeyNotFound) {
-		return nil, ErrKeyNotFound
+		return nil, fmt.Errorf("%w: table %s", ErrKeyNotFound, tableName)
 	}
 	if err != nil {
 		return nil, err

nil/internal/execution/block_cache.go

@@ -35,17 +35,17 @@ func getHashFn(es *ExecutionState, ref *types.Block) func(n uint64) (common.Hash
 		lastKnownHash := cache[len(cache)-1]
 
 		for {
-			data, err := es.shardAccessor.GetBlock().ByHash(lastKnownHash)
+			b, err := es.shardAccessor.GetBlockByHash(lastKnownHash)
 			if errors.Is(err, db.ErrKeyNotFound) {
 				break
 			}
 			if err != nil {
 				return common.EmptyHash, err
 			}
 
-			cache = append(cache, data.Block().PrevBlock)
-			lastKnownHash = data.Block().PrevBlock
-			lastKnownNumber := data.Block().Id.Uint64() - 1
+			cache = append(cache, b.PrevBlock)
+			lastKnownHash = b.PrevBlock
+			lastKnownNumber := b.Id.Uint64() - 1
 			if n == lastKnownNumber {
 				return lastKnownHash, nil
 			}

nil/internal/execution/block_generator.go

@@ -60,6 +60,7 @@ type BlockGenerationResult struct {
 	InTxnHashes  []common.Hash
 	OutTxns      []*types.Transaction
 	OutTxnHashes []common.Hash
+	Receipts     []*types.Receipt
 	ConfigParams map[string][]byte
 
 	Counters *BlockGeneratorCounters