[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/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.GetBlockHeaderByHash(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

nil/internal/execution/execution_state_test.go

@@ -92,15 +92,13 @@ func (s *SuiteExecutionState) TestExecState() {
 	})
 
 	s.Run("CheckTransactions", func() {
-		data, err := es.shardAccessor.GetBlock().ByHash(blockRes.BlockHash)
+		block, err := es.shardAccessor.GetBlockHeaderByHash(blockRes.BlockHash)
 		s.Require().NoError(err)
-		s.Require().NotNil(data)
-		s.Require().NotNil(data.Block())
 
 		transactionsRoot := NewDbTransactionTrieReader(tx, es.ShardId)
-		s.Require().NoError(transactionsRoot.SetRootHash(data.Block().InTransactionsRoot))
+		s.Require().NoError(transactionsRoot.SetRootHash(block.InTransactionsRoot))
 		receiptsRoot := NewDbReceiptTrieReader(tx, es.ShardId)
-		s.Require().NoError(receiptsRoot.SetRootHash(data.Block().ReceiptsRoot))
+		s.Require().NoError(receiptsRoot.SetRootHash(block.ReceiptsRoot))
 
 		var transactionIndex types.TransactionIndex
 		for {

nil/internal/execution/state.go

@@ -125,7 +125,7 @@ type ExecutionState struct {
 	// Tracing hooks set for every EVM created during execution
 	EvmTracingHooks *tracing.Hooks
 
-	shardAccessor *shardAccessor
+	shardAccessor ShardAccessor
 
 	// Pointer to currently executed VM
 	evm *vm.EVM
@@ -256,17 +256,15 @@ type revision struct {
 
 // NewEVMBlockContext creates a new context for use in the EVM.
 func NewEVMBlockContext(es *ExecutionState) (*vm.BlockContext, error) {
-	data, err := es.shardAccessor.GetBlock().ByHash(es.PrevBlock)
+	header, err := es.shardAccessor.GetBlockHeaderByHash(es.PrevBlock)
 	if err != nil && !errors.Is(err, db.ErrKeyNotFound) {
 		return nil, err
 	}
 
 	currentBlockId := uint64(0)
-	var header *types.Block
 	time := uint64(0)
 	rollbackCounter := uint32(0)
 	if err == nil {
-		header = data.Block()
 		currentBlockId = header.Id.Uint64() + 1
 		// TODO: we need to use header.Timestamp instead of but it's always zero for now.
 		// Let's return some kind of logical timestamp (monotonic increasing block number).
@@ -393,7 +391,7 @@ func (ca *DbContractAccessor) UpdateContracts(contracts map[types.Address]*Accou
 }
 
 func (es *ExecutionState) initTries(params *StateParams) error {
-	data, err := es.shardAccessor.GetBlock().ByHash(es.PrevBlock)
+	block, err := es.shardAccessor.GetBlockHeaderByHash(es.PrevBlock)
 	if err != nil && !errors.Is(err, db.ErrKeyNotFound) {
 		return err
 	}
@@ -403,7 +401,6 @@ func (es *ExecutionState) initTries(params *StateParams) error {
 	outTransactionsRoot := mpt.EmptyRootHash
 	inTransactionsRoot := mpt.EmptyRootHash
 	if err == nil {
-		block := data.Block()
 		smartContractsRoot = block.SmartContractsRoot
 		outTransactionsRoot = block.OutTransactionsRoot
 		inTransactionsRoot = block.InTransactionsRoot
@@ -481,7 +478,7 @@ func (es *ExecutionState) setAccountObject(acc *AccountState) {
 	es.Accounts[acc.address] = acc
 }
 
-func (es *ExecutionState) AddAddressToAccessList(addr types.Address) {
+func (es *ExecutionState) AddAddressToAccessList(types.Address) {
 }
 
 // AddBalance adds amount to the account associated with addr.
@@ -530,10 +527,10 @@ func (es *ExecutionState) GetRefund() uint64 {
 	return es.refund
 }
 
-func (es *ExecutionState) AddSlotToAccessList(addr types.Address, slot common.Hash) {
+func (es *ExecutionState) AddSlotToAccessList(types.Address, common.Hash) {
 }
 
-func (es *ExecutionState) AddressInAccessList(addr types.Address) bool {
+func (es *ExecutionState) AddressInAccessList(types.Address) bool {
 	return true // FIXME
 }
 
@@ -688,7 +685,7 @@ func (es *ExecutionState) SetInitState(addr types.Address, transaction *types.Tr
 	return nil
 }
 
-func (es *ExecutionState) SlotInAccessList(addr types.Address, slot common.Hash) (addressOk bool, slotOk bool) {
+func (es *ExecutionState) SlotInAccessList(types.Address, common.Hash) (addressOk bool, slotOk bool) {
 	return true, true // FIXME
 }
 
@@ -1658,6 +1655,7 @@ func (es *ExecutionState) BuildBlock(blockId types.BlockNumber) (*BlockGeneratio
 		InTxnHashes:  es.InTransactionHashes,
 		OutTxns:      outTxnValues,
 		OutTxnHashes: outTxnHashes,
+		Receipts:     es.Receipts,
 		ConfigParams: configParams,
 	}, nil
 }
@@ -1979,16 +1977,11 @@ func (es *ExecutionState) resetVm() {
 }
 
 func (es *ExecutionState) MarshalJSON() ([]byte, error) {
-	prevBlockRes, err := es.shardAccessor.GetBlock().ByHash(es.PrevBlock)
+	prevBlock, err := es.shardAccessor.GetBlockHeaderByHash(es.PrevBlock)
 	if err != nil && !errors.Is(err, db.ErrKeyNotFound) {
 		return nil, err
 	}
 
-	var prevBlock *types.Block
-	if err == nil {
-		prevBlock = prevBlockRes.Block()
-	}
-
 	data := struct {
 		ContractTreeRoot    common.Hash                                  `json:"contractTreeRoot"`
 		ReceiptTreeRoot     common.Hash                                  `json:"receiptTreeRoot"`