refactor(rpc): trace block reads

blockchain/blockchain.go

@@ -56,6 +56,11 @@
 		blockNumber, index uint64,
 	) (transaction core.Transaction, err error)
 	TransactionsByBlockNumber(blockNumber uint64) (transactions []core.Transaction, err error)
+	TransactionsAndReceiptsByBlockNumber(blockNumber uint64) (
+		transactions []core.Transaction,
+		receipts []*core.TransactionReceipt,
+		err error,
+	)
 	TransactionHashesByBlockNumber(blockNumber uint64) (hashes []felt.Felt, err error)
 
 	Receipt(
@@ -299,6 +304,14 @@
 	return core.GetTransactionsByBlockNumber(b.database, number)
 }
 
+// TransactionsAndReceiptsByBlockNumber gets all transactions and receipts for a given block number
+func (b *Blockchain) TransactionsAndReceiptsByBlockNumber(
+	number uint64,
+) ([]core.Transaction, []*core.TransactionReceipt, error) {
+	b.listener.OnRead("TransactionsAndReceiptsByBlockNumber")
+	return core.GetTransactionsAndReceiptsByBlockNumber(b.database, number)
+}
+
 // BlockNumberAndIndexByTxHash gets transaction block number and index by Tx hash
 func (b *Blockchain) BlockNumberAndIndexByTxHash(
 	hash *felt.TransactionHash,

core/accessors.go

@@ -513,6 +513,28 @@
 	return BlockTransactionsAllTransactionHashesPartialBucket.Get(r, blockNumber, struct{}{})
 }
 
+// GetTransactionsAndReceiptsByBlockNumber returns all transactions and receipts in a given block.
+// Both live under the same key, so this reads the block only once.
+func GetTransactionsAndReceiptsByBlockNumber(
+	r db.KeyValueReader,
+	blockNumber uint64,
+) ([]Transaction, []*TransactionReceipt, error) {
+	result, err := BlockTransactionsAllTransactionsAndReceiptsPartialBucket.Get(
+		r,
+		blockNumber,
+		struct{}{},
+	)
+	if err != nil {
+		return nil, nil, fmt.Errorf(
+			"getting transactions and receipts of block %d: %w",
+			blockNumber,
+			err,
+		)
+	}
+
+	return result.Transactions, result.Receipts, nil
+}
+
 // GetReceiptByBlockAndIndex returns a receipt by block number and transaction index
 func GetReceiptByBlockAndIndex(
 	r db.KeyValueReader,
@@ -555,12 +577,7 @@
 		return nil, err
 	}
 
-	txs, err := GetTransactionsByBlockNumber(r, blockNumber)
-	if err != nil {
-		return nil, err
-	}
-
-	receipts, err := GetReceiptsByBlockNumber(r, blockNumber)
+	txs, receipts, err := GetTransactionsAndReceiptsByBlockNumber(r, blockNumber)
 	if err != nil {
 		return nil, err
 	}

core/block_transaction.go

@@ -41,6 +41,12 @@ type TransactionAndReceipt struct {
 	Receipt     *TransactionReceipt
 }
 
+// TransactionsAndReceipts holds every transaction and receipt of a single block.
+type TransactionsAndReceipts struct {
+	Transactions []Transaction
+	Receipts     []*TransactionReceipt
+}
+
 func NewBlockTransactionsFromIterators[T, R any](
 	transactions iter.Seq2[T, error],
 	receipts iter.Seq2[R, error],

core/block_transaction_serializer.go

@@ -112,6 +112,27 @@
 	return b.Receipts().All()
 }
 
+type extractAllTransactionsAndReceipts struct{}
+
+// extract decodes both halves of the entry in one pass, so reading them together needs neither a
+// second lookup nor a copy of the whole block blob.
+func (extractAllTransactionsAndReceipts) extract(
+	b *BlockTransactions,
+	_ struct{},
+) (TransactionsAndReceipts, error) {
+	transactions, err := b.Transactions().All()
+	if err != nil {
+		return TransactionsAndReceipts{}, fmt.Errorf("extracting transactions: %w", err)
+	}
+
+	receipts, err := b.Receipts().All()
+	if err != nil {
+		return TransactionsAndReceipts{}, fmt.Errorf("extracting receipts: %w", err)
+	}
+
+	return TransactionsAndReceipts{Transactions: transactions, Receipts: receipts}, nil
+}
+
 type extractAllTransactionEvents struct{}
 
 func (extractAllTransactionEvents) extract(
@@ -190,6 +211,11 @@
 		struct{},
 		[]*TransactionReceipt,
 	]{}
+	BlockTransactionsAllTransactionsAndReceiptsPartialSerializer = blockTransactionsPartialSerializer[
+		extractAllTransactionsAndReceipts,
+		struct{},
+		TransactionsAndReceipts,
+	]{}
 	BlockTransactionsAllTransactionEventsPartialSerializer = blockTransactionsPartialSerializer[
 		extractAllTransactionEvents,
 		struct{},

core/block_transaction_test.go

@@ -149,6 +149,16 @@ func TestBlockTransactionsSerializer(t *testing.T) {
 		)
 	})
 
+	t.Run("BlockTransactionsAllTransactionsAndReceiptsPartialSerializer", func(t *testing.T) {
+		assertPartialSerializer(
+			t,
+			core.BlockTransactionsAllTransactionsAndReceiptsPartialSerializer,
+			struct{}{},
+			core.TransactionsAndReceipts{Transactions: transactions, Receipts: receipts},
+			serialised,
+		)
+	})
+
 	t.Run("BlockTransactionsAllTransactionEventsPartialSerializer", func(t *testing.T) {
 		expected := make([]core.TransactionEvents, len(receipts))
 		for i, receipt := range receipts {

core/pending/pending.go

@@ -116,20 +116,22 @@ func (p *PreConfirmed) GetTransactionStateDiffs() []*core.StateDiff {
 
 // TransactionByHash locates a transaction by hash in the block and returns
 // it together with its index. Returns ErrTransactionNotFound when missing.
-func (p *PreConfirmed) TransactionByHash(hash *felt.Felt) (core.Transaction, uint, error) {
+func (p *PreConfirmed) TransactionByHash(
+	hash *felt.TransactionHash,
+) (core.Transaction, uint, error) {
 	for i, tx := range p.Block.Transactions {
-		if tx.Hash().Equal(hash) {
+		if tx.Hash().Equal((*felt.Felt)(hash)) {
 			return tx, uint(i), nil
 		}
 	}
 	return nil, 0, ErrTransactionNotFound
 }
 
 func (p *PreConfirmed) ReceiptByHash(
-	hash *felt.Felt,
+	hash *felt.TransactionHash,
 ) (*core.TransactionReceipt, error) {
 	for _, receipt := range p.Block.Receipts {
-		if receipt.TransactionHash.Equal(hash) {
+		if receipt.TransactionHash.Equal((*felt.Felt)(hash)) {
 			return receipt, nil
 		}
 	}

core/pending/pending_test.go

@@ -10,11 +10,11 @@ import (
 )
 
 func TestPreConfirmedTransactionByHash(t *testing.T) {
-	preConfirmedTxHash := felt.FromUint64[felt.Felt](2)
-	nonExistingTxHash := felt.FromUint64[felt.Felt](4)
+	preConfirmedTxHash := felt.FromUint64[felt.TransactionHash](2)
+	nonExistingTxHash := felt.FromUint64[felt.TransactionHash](4)
 
 	preConfirmedTx := &core.InvokeTransaction{
-		TransactionHash: &preConfirmedTxHash,
+		TransactionHash: (*felt.Felt)(&preConfirmedTxHash),
 	}
 
 	preConfirmed := &pending.PreConfirmed{
@@ -41,11 +41,11 @@ func TestPreConfirmedTransactionByHash(t *testing.T) {
 }
 
 func TestPreConfirmedReceiptByHash(t *testing.T) {
-	preConfirmedReceiptHash := felt.FromUint64[felt.Felt](2)
-	nonExistingReceiptHash := felt.FromUint64[felt.Felt](3)
+	preConfirmedReceiptHash := felt.FromUint64[felt.TransactionHash](2)
+	nonExistingReceiptHash := felt.FromUint64[felt.TransactionHash](3)
 
 	preConfirmedReceipt := core.TransactionReceipt{
-		TransactionHash: &preConfirmedReceiptHash,
+		TransactionHash: (*felt.Felt)(&preConfirmedReceiptHash),
 	}
 
 	preConfirmedBlockNumber := uint64(2)

core/typed_buckets.go

@@ -197,6 +197,11 @@ var BlockTransactionsAllReceiptsPartialBucket = partial.NewPartialBucket(
 	BlockTransactionsAllReceiptsPartialSerializer,
 )
 
+var BlockTransactionsAllTransactionsAndReceiptsPartialBucket = partial.NewPartialBucket(
+	BlockTransactionsBucket.Bucket,
+	BlockTransactionsAllTransactionsAndReceiptsPartialSerializer,
+)
+
 var BlockTransactionsAllTransactionEventsPartialBucket = partial.NewPartialBucket(
 	BlockTransactionsBucket.Bucket,
 	BlockTransactionsAllTransactionEventsPartialSerializer,

rpc/rpccore/rpccore.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"github.com/NethermindEth/juno/core/felt"
 	"github.com/NethermindEth/juno/jsonrpc"
 	"github.com/NethermindEth/juno/l1/eth"
 )
@@ -35,10 +34,6 @@ type L1Client interface {
 	TransactionReceipt(ctx context.Context, txHash eth.Hash) (eth.Receipt, error)
 }
 
-type TraceCacheKey struct {
-	BlockHash felt.Felt
-}
-
 var (
 	ErrContractNotFound   = &jsonrpc.Error{Code: 20, Message: "Contract not found"}
 	ErrEntrypointNotFound = &jsonrpc.Error{

rpc/v10/adapt_trace.go

@@ -303,14 +303,14 @@ func adaptVMInitialReads(vmInitialReads *vm.InitialReads) InitialReads {
 *****************************************************/
 
 func AdaptFeederBlockTrace(
-	block *core.Block,
+	transactions []core.Transaction,
 	blockTrace *starknet.BlockTrace,
 ) ([]TracedBlockTransaction, error) {
 	if blockTrace == nil {
 		return nil, nil
 	}
 
-	if len(block.Transactions) != len(blockTrace.Traces) {
+	if len(transactions) != len(blockTrace.Traces) {
 		return nil, errors.New("mismatched number of txs and traces")
 	}
 
@@ -320,7 +320,7 @@ func AdaptFeederBlockTrace(
 		feederTrace := &blockTrace.Traces[index]
 
 		trace := TransactionTrace{
-			Type: transactionTypeFrom(block.Transactions[index]),
+			Type: transactionTypeFrom(transactions[index]),
 		}
 
 		if feederTrace.FeeTransferInvocation != nil && trace.Type != TxnL1Handler {

rpc/v10/handlers.go

@@ -11,6 +11,7 @@ import (
 	"github.com/NethermindEth/juno/blockchain"
 	"github.com/NethermindEth/juno/clients/feeder"
 	"github.com/NethermindEth/juno/core"
+	"github.com/NethermindEth/juno/core/felt"
 	"github.com/NethermindEth/juno/core/pending"
 	"github.com/NethermindEth/juno/feed"
 	"github.com/NethermindEth/juno/jsonrpc"
@@ -42,9 +43,7 @@ type Handler struct {
 	idgen         func() string
 	subscriptions stdsync.Map // map[string]*subscription
 
-	// todo(rdr): why do we have the `TraceCacheKey` type and why it feels uncomfortable
-	// to use. It makes no sense, why not use `Felt` or `Hash` directly?
-	blockTraceCache *lru.Cache[rpccore.TraceCacheKey, TraceBlockTransactionsResponse]
+	blockTraceCache *lru.Cache[felt.Felt, TraceBlockTransactionsResponse]
 	// todo(rdr): Can this cache be genericified and can it be applied to the `blockTraceCache`
 	submittedTransactionsCache *rpccore.TransactionCache
 
@@ -86,7 +85,7 @@ func New(
 		l1Heads:          feed.New[*core.L1Head](),
 
 		blockTraceCache: lru.New[
-			rpccore.TraceCacheKey,
+			felt.Felt,
 			TraceBlockTransactionsResponse,
 		](rpccore.TraceCacheSize),
 		filterLimit: math.MaxUint,

rpc/v10/handlers_test.go

@@ -77,7 +77,9 @@ func TestThrottledVMError(t *testing.T) {
 			Transactions: []core.Transaction{l1Tx, declareTx},
 		}
 
-		mockReader.EXPECT().BlockByHash(blockHash).Return(block, nil)
+		mockReader.EXPECT().BlockHeaderByHash(blockHash).Return(header, nil)
+		mockReader.EXPECT().TransactionsByBlockNumber(header.Number).
+			Return(block.Transactions, nil)
 		state := mocks.NewMockStateReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(state, nopCloser, nil)
 		headState := mocks.NewMockStateReader(mockCtrl)