feat: Combined layout for transactions

Author: infrmtcs

blockchain/blockchain.go

@@ -184,13 +184,7 @@ func (b *Blockchain) L1HandlerTxnHash(msgHash *common.Hash) (felt.Felt, error) {
 // TransactionByBlockNumberAndIndex gets the transaction for a given block number and index.
 func (b *Blockchain) TransactionByBlockNumberAndIndex(blockNumber, index uint64) (core.Transaction, error) {
 	b.listener.OnRead("TransactionByBlockNumberAndIndex")
-	return core.TransactionsByBlockNumberAndIndexBucket.Get(
-		b.database,
-		db.BlockNumIndexKey{
-			Number: blockNumber,
-			Index:  index,
-		},
-	)
+	return core.GetTxByBlockNumberAndIndex(b.database, blockNumber, index)
 }
 
 // TransactionByHash gets the transaction for a given hash.
@@ -208,7 +202,7 @@ func (b *Blockchain) Receipt(hash *felt.Felt) (*core.TransactionReceipt, *felt.F
 		return nil, nil, 0, err
 	}
 
-	receipt, err := core.GetReceiptByHash(b.database, txHash)
+	receipt, err := core.GetReceiptByBlockNumberAndIndex(b.database, bnIndex.Number, bnIndex.Index)
 	if err != nil {
 		return nil, nil, 0, err
 	}
@@ -255,11 +249,13 @@ func (b *Blockchain) Store(
 			return err
 		}
 
-		for i, tx := range block.Transactions {
-			if err := core.WriteTxAndReceipt(txn, block.Number, uint64(i), tx,
-				block.Receipts[i]); err != nil {
-				return err
-			}
+		if err := core.WriteTransactionsAndReceipts(
+			txn,
+			block.Number,
+			block.Transactions,
+			block.Receipts,
+		); err != nil {
+			return err
 		}
 
 		if err := core.WriteStateUpdateByBlockNum(txn, block.Number, stateUpdate); err != nil {
@@ -724,11 +720,13 @@ func (b *Blockchain) storeBlockData(
 		return err
 	}
 
-	// Store transactions and receipts
-	for i, tx := range block.Transactions {
-		if err := core.WriteTxAndReceipt(txn, block.Number, uint64(i), tx, block.Receipts[i]); err != nil {
-			return err
-		}
+	if err := core.WriteTransactionsAndReceipts(
+		txn,
+		block.Number,
+		block.Transactions,
+		block.Receipts,
+	); err != nil {
+		return err
 	}
 
 	// Store state update

core/accessors.go

@@ -246,47 +246,40 @@ func DeleteBlockHeaderByNumber(w db.KeyValueWriter, number uint64) error {
 	return w.Delete(db.BlockHeaderByNumberKey(number))
 }
 
-func GetReceiptByHash(
+func GetReceiptByBlockNumberAndIndex(
 	r db.KeyValueReader,
-	hash *felt.TransactionHash,
+	blockNumber uint64,
+	index uint64,
 ) (*TransactionReceipt, error) {
-	val, err := TransactionBlockNumbersAndIndicesByHashBucket.RawValue().Get(r, hash)
+	blockTransactions, err := BlockTransactionsBucket.Get(r, blockNumber)
 	if err != nil {
 		return nil, err
 	}
 
-	receipt, err := ReceiptsByBlockNumberAndIndexBucket.RawKey().Get(r, val)
-	if err != nil {
-		return nil, err
+	if index >= uint64(len(blockTransactions.Receipts)) {
+		return nil, db.ErrKeyNotFound
 	}
-	return &receipt, nil
+
+	return blockTransactions.Receipts[index], nil
 }
 
 func DeleteTxsAndReceipts(batch db.IndexedBatch, blockNum, numTxs uint64) error {
-	// remove txs and receipts
-	for i := range numTxs {
-		key := db.BlockNumIndexKey{
-			Number: blockNum,
-			Index:  i,
-		}
-		txn, err := TransactionsByBlockNumberAndIndexBucket.Get(batch, key)
-		if err != nil {
-			return err
-		}
+	blockTransactions, err := BlockTransactionsBucket.Get(batch, blockNum)
+	if err != nil {
+		return err
+	}
 
-		if err := TransactionsByBlockNumberAndIndexBucket.Delete(batch, key); err != nil {
-			return err
-		}
-		if err := ReceiptsByBlockNumberAndIndexBucket.Delete(batch, key); err != nil {
-			return err
-		}
+	if err := BlockTransactionsBucket.Delete(batch, blockNum); err != nil {
+		return err
+	}
 
-		txHash := (*felt.TransactionHash)(txn.Hash())
+	for _, tx := range blockTransactions.Transactions {
+		txHash := (*felt.TransactionHash)(tx.Hash())
 		if err := TransactionBlockNumbersAndIndicesByHashBucket.Delete(batch, txHash); err != nil {
 			return err
 		}
 
-		if l1handler, ok := txn.(*L1HandlerTransaction); ok {
+		if l1handler, ok := tx.(*L1HandlerTransaction); ok {
 			if err := DeleteL1HandlerTxnHashByMsgHash(batch, l1handler.MessageHash()); err != nil {
 				return err
 			}
@@ -390,32 +383,25 @@ func WriteBlockHeader(w db.KeyValueWriter, header *Header) error {
 
 // Returns all transactions in a given block
 func GetTxsByBlockNum(r db.KeyValueReader, blockNum uint64) ([]Transaction, error) {
-	txs := []Transaction{}
-	txSeq := TransactionsByBlockNumberAndIndexBucket.Prefix().Add(blockNum).Scan(r)
-
-	for tx, err := range txSeq {
-		if err != nil {
-			return nil, err
-		}
-		txs = append(txs, tx.Value)
+	blockTransactions, err := BlockTransactionsBucket.Get(r, blockNum)
+	if err != nil {
+		return nil, err
 	}
 
-	return txs, nil
+	return blockTransactions.Transactions, nil
 }
 
 // Returns all receipts in a given block
-func GetReceiptsByBlockNum(r db.KeyValueReader, blockNum uint64) ([]*TransactionReceipt, error) {
-	receipts := []*TransactionReceipt{}
-	receiptSeq := ReceiptsByBlockNumberAndIndexBucket.Prefix().Add(blockNum).Scan(r)
-
-	for receipt, err := range receiptSeq {
-		if err != nil {
-			return nil, err
-		}
-		receipts = append(receipts, &receipt.Value)
+func GetReceiptsByBlockNum(
+	r db.KeyValueReader,
+	blockNum uint64,
+) ([]*TransactionReceipt, error) {
+	blockTransactions, err := BlockTransactionsBucket.Get(r, blockNum)
+	if err != nil {
+		return nil, err
 	}
 
-	return receipts, nil
+	return blockTransactions.Receipts, nil
 }
 
 func GetBlockByNumber(r db.KeyValueReader, blockNum uint64) (*Block, error) {
@@ -424,57 +410,71 @@ func GetBlockByNumber(r db.KeyValueReader, blockNum uint64) (*Block, error) {
 		return nil, err
 	}
 
-	txs, err := GetTxsByBlockNum(r, blockNum)
-	if err != nil {
-		return nil, err
-	}
-
-	receipts, err := GetReceiptsByBlockNum(r, blockNum)
+	blockTransactions, err := BlockTransactionsBucket.Get(r, blockNum)
 	if err != nil {
 		return nil, err
 	}
 
 	return &Block{
 		Header:       header,
-		Transactions: txs,
-		Receipts:     receipts,
+		Transactions: blockTransactions.Transactions,
+		Receipts:     blockTransactions.Receipts,
 	}, nil
 }
 
-func WriteTxAndReceipt(
+func WriteTransactionsAndReceipts(
 	w db.KeyValueWriter,
-	num, index uint64,
-	tx Transaction,
-	receipt *TransactionReceipt,
+	blockNumber uint64,
+	transactions []Transaction,
+	receipts []*TransactionReceipt,
 ) error {
-	txHash := (*felt.TransactionHash)(tx.Hash())
-	key := db.BlockNumIndexKey{
-		Number: num,
-		Index:  index,
+	for index, tx := range transactions {
+		txHash := (*felt.TransactionHash)(tx.Hash())
+		key := db.BlockNumIndexKey{
+			Number: blockNumber,
+			Index:  uint64(index),
+		}
+
+		if err := TransactionBlockNumbersAndIndicesByHashBucket.Put(w, txHash, &key); err != nil {
+			return err
+		}
 	}
 
-	if err := TransactionBlockNumbersAndIndicesByHashBucket.Put(w, txHash, &key); err != nil {
+	blockTransactions := BlockTransactions{
+		Transactions: transactions,
+		Receipts:     receipts,
+	}
+	if err := BlockTransactionsBucket.Put(w, blockNumber, &blockTransactions); err != nil {
 		return err
 	}
 
-	if err := TransactionsByBlockNumberAndIndexBucket.Put(w, key, &tx); err != nil {
-		return err
+	return nil
+}
+
+func GetTxByBlockNumberAndIndex(
+	r db.KeyValueReader,
+	blockNumber uint64,
+	index uint64,
+) (Transaction, error) {
+	blockTransactions, err := BlockTransactionsBucket.Get(r, blockNumber)
+	if err != nil {
+		return nil, err
 	}
 
-	if err := ReceiptsByBlockNumberAndIndexBucket.Put(w, key, receipt); err != nil {
-		return err
+	if index >= uint64(len(blockTransactions.Transactions)) {
+		return nil, db.ErrKeyNotFound
 	}
 
-	return nil
+	return blockTransactions.Transactions[index], nil
 }
 
 func GetTxByHash(r db.KeyValueReader, hash *felt.TransactionHash) (Transaction, error) {
-	val, err := TransactionBlockNumbersAndIndicesByHashBucket.RawValue().Get(r, hash)
+	blockNumIndex, err := TransactionBlockNumbersAndIndicesByHashBucket.Get(r, hash)
 	if err != nil {
 		return nil, err
 	}
 
-	return TransactionsByBlockNumberAndIndexBucket.RawKey().Get(r, val)
+	return GetTxByBlockNumberAndIndex(r, blockNumIndex.Number, blockNumIndex.Index)
 }
 
 func GetAggregatedBloomFilter(r db.KeyValueReader, fromBlock, toBLock uint64) (AggregatedBloomFilter, error) {

core/block_transaction.go

@@ -0,0 +1,6 @@
+package core
+
+type BlockTransactions struct {
+	Transactions []Transaction         `cbor:"1,keyasint,omitempty"`
+	Receipts     []*TransactionReceipt `cbor:"2,keyasint,omitempty"`
+}

core/typed_buckets.go

@@ -158,3 +158,10 @@ var ClassHashToCasmHashV2Bucket = typed.NewBucket(
 	key.SierraClassHash,
 	value.CasmClassHash,
 )
+
+// Bucket 40: Block number (uint64) -> Block transactions (BlockTransactions)
+var BlockTransactionsBucket = typed.NewBucket(
+	db.BlockTransactions,
+	key.Cbor[uint64](),
+	value.Cbor[BlockTransactions](),
+)

db/buckets.go

@@ -49,6 +49,7 @@ const (
 	AggregatedBloomFilters // maps block range to AggregatedBloomFilter
 	RunningEventFilter     // aggregated filter not full yet
 	ClassHashToCasmHashV2  // blake2s casm class hashes of the all sierra classes
+	BlockTransactions      // maps block number to transactions and receipts
 )
 
 // Key flattens a prefix and series of byte arrays into a single []byte.

db/typed/key/cbor.go

@@ -0,0 +1,13 @@
+package key
+
+import "github.com/NethermindEth/juno/encoder"
+
+type cborSerializer[K any] struct{}
+
+func (cborSerializer[K]) Marshal(value K) []byte {
+	data, err := encoder.Marshal(value)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}

db/typed/key/key.go

@@ -13,6 +13,10 @@ var Bytes = BytesSerializer{}
 
 var Uint64 = uint64Serializer{}
 
+func Cbor[K any]() cborSerializer[K] {
+	return cborSerializer[K]{}
+}
+
 func Marshal[K marshaler[K]]() marshalSerializer[K] {
 	return marshalSerializer[K]{}
 }

rpc/v6/init_test.go

@@ -0,0 +1,5 @@
+package rpcv6_test
+
+import (
+	_ "github.com/NethermindEth/juno/encoder/registry"
+)