Skip to content

feat: Combined layout for transactions #3304

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
infrmtcs wants to merge 1 commit into
base: dat/migrate-block-transactions
Choose a base branch
from
Open

feat: Combined layout for transactions #3304

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
40 changes: 20 additions & 20 deletions blockchain/blockchain.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -191,19 +191,13 @@ 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.GetTransactionByBlockNumberAndIndex(b.database, blockNumber, index)
}

// TransactionByHash gets the transaction for a given hash.
func (b *Blockchain) TransactionByHash(hash *felt.Felt) (core.Transaction, error) {
b.listener.OnRead("TransactionByHash")
return core.GetTxByHash(b.database, (*felt.TransactionHash)(hash))
return core.GetTransactionByHash(b.database, (*felt.TransactionHash)(hash))
}

// Receipt gets the transaction receipt for a given transaction hash.
Expand All @@ -216,7 +210,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
}
Expand Down Expand Up @@ -263,11 +257,14 @@ 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
}
err := core.WriteTransactionsAndReceipts(
txn,
block.Number,
block.Transactions,
block.Receipts,
)
if err != nil {
return err
}

if err := core.WriteStateUpdateByBlockNum(txn, block.Number, stateUpdate); err != nil {
Expand All @@ -282,7 +279,7 @@ func (b *Blockchain) Store(
return err
}

err := storeCasmClassHashesV2ForBlock(txn, block.ProtocolVersion, newClasses, stateUpdate)
err = storeCasmClassHashesV2ForBlock(txn, block.ProtocolVersion, newClasses, stateUpdate)
if err != nil {
return err
}
Expand Down Expand Up @@ -732,11 +729,14 @@ 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
}
err := core.WriteTransactionsAndReceipts(
txn,
block.Number,
block.Transactions,
block.Receipts,
)
if err != nil {
return err
}

// Store state update
Expand Down
141 changes: 74 additions & 67 deletions core/accessors.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -246,48 +246,41 @@ func DeleteBlockHeaderByNumber(w db.KeyValueWriter, number uint64) error {
return w.Delete(db.BlockHeaderByNumberKey(number))
}

// TODO: Return TransactionReceipt instead of *TransactionReceipt.
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
}
return &receipt, nil
return blockTransactions.Receipts().Get(int(index))
}

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
}

transactions, err := blockTransactions.Transactions().All()
if err != nil {
return err
}

txHash := (*felt.TransactionHash)(txn.Hash())
for _, tx := range transactions {
txHash := (*felt.TransactionHash)(tx.Hash())
if err := TransactionBlockNumbersAndIndicesByHashBucket.Delete(batch, txHash); err != nil {
Copy link
Collaborator

@rodrodros rodrodros Dec 10, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

nitpick: I know this line is outside the scope of the PR but could you split the assignment from the if

Copy link
Contributor Author

@infrmtcs infrmtcs Dec 28, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Is there any particular reason why we favor breaking it into 2 lines? IMO it's a good feature to scope the declaration of err, which avoid (possibly) wrong reuse of err.

return err
}

if l1handler, ok := txn.(*L1HandlerTransaction); ok {
if l1handler, ok := tx.(*L1HandlerTransaction); ok {
if err := DeleteL1HandlerTxnHashByMsgHash(batch, l1handler.MessageHash()); err != nil {
Copy link
Collaborator

@rodrodros rodrodros Dec 10, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Similarly here

return err
}
Expand Down Expand Up @@ -390,33 +383,26 @@ 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)
func GetTransactionsByBlockNum(r db.KeyValueReader, blockNum uint64) ([]Transaction, error) {
blockTransactions, err := BlockTransactionsBucket.Get(r, blockNum)
if err != nil {
return nil, err
}

return txs, nil
return blockTransactions.Transactions().All()
}

// 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().All()
}

func GetBlockByNumber(r db.KeyValueReader, blockNum uint64) (*Block, error) {
Expand All @@ -425,57 +411,78 @@ func GetBlockByNumber(r db.KeyValueReader, blockNum uint64) (*Block, error) {
return nil, err
}

txs, err := GetTxsByBlockNum(r, blockNum)
blockTransactions, err := BlockTransactionsBucket.Get(r, blockNum)
if err != nil {
return nil, err
}

allTransactions, err := blockTransactions.Transactions().All()
if err != nil {
return nil, err
}

receipts, err := GetReceiptsByBlockNum(r, blockNum)
allReceipts, err := blockTransactions.Receipts().All()
if err != nil {
return nil, err
}

return &Block{
Header: header,
Transactions: txs,
Receipts: receipts,
Transactions: allTransactions,
Receipts: allReceipts,
}, 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 {
return err
}
}

if err := TransactionsByBlockNumberAndIndexBucket.Put(w, key, &tx); err != nil {
blockTransactions, err := NewBlockTransactions(transactions, receipts)
if err != nil {
return err
}

if err := ReceiptsByBlockNumberAndIndexBucket.Put(w, key, receipt); err != nil {
if err := BlockTransactionsBucket.Put(w, blockNumber, &blockTransactions); err != nil {
return err
}

return nil
}

func GetTxByHash(r db.KeyValueReader, hash *felt.TransactionHash) (Transaction, error) {
val, err := TransactionBlockNumbersAndIndicesByHashBucket.RawValue().Get(r, hash)
func GetTransactionByBlockNumberAndIndex(
r db.KeyValueReader,
blockNumber uint64,
index uint64,
) (Transaction, error) {
blockTransactions, err := BlockTransactionsBucket.Get(r, blockNumber)
if err != nil {
return nil, err
}

return blockTransactions.Transactions().Get(int(index))
}

func GetTransactionByHash(r db.KeyValueReader, hash *felt.TransactionHash) (Transaction, error) {
blockNumIndex, err := TransactionBlockNumbersAndIndicesByHashBucket.Get(r, hash)
if err != nil {
return nil, err
}

return TransactionsByBlockNumberAndIndexBucket.RawKey().Get(r, val)
return GetTransactionByBlockNumberAndIndex(r, blockNumIndex.Number, blockNumIndex.Index)
}

func GetAggregatedBloomFilter(r db.KeyValueReader, fromBlock, toBLock uint64) (AggregatedBloomFilter, error) {
Expand Down
6 changes: 4 additions & 2 deletions migration/migration.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,6 +22,7 @@ import (
"github.com/NethermindEth/juno/core/trie"
"github.com/NethermindEth/juno/db"
"github.com/NethermindEth/juno/encoder"
"github.com/NethermindEth/juno/migration/blocktransactions"
"github.com/NethermindEth/juno/starknet"
"github.com/NethermindEth/juno/utils"
"github.com/bits-and-blooms/bitset"
Expand Down Expand Up @@ -84,6 +85,7 @@ var defaultMigrations = []Migration{
MigrationFunc(removePendingBlock),
MigrationFunc(reconstructAggregatedBloomFilters),
MigrationFunc(calculateCasmClassHashesV2),
blocktransactions.BlockTransactionsMigration{},
}

var ErrCallWithNewTransaction = errors.New("call with new transaction")
Expand Down Expand Up @@ -172,7 +174,7 @@ func migrateIfNeeded(
}
}

return nil
return ctx.Err()
}

func closeMigrationServer(srv *http.Server, log utils.SimpleLogger) {
Expand Down Expand Up @@ -559,7 +561,7 @@ func calculateBlockCommitments(txn db.IndexedBatch, network *utils.Network) erro
func calculateL1MsgHashes2(txn db.IndexedBatch, n *utils.Network) error {
processBlockFunc := func(blockNumber uint64, txnLock *sync.Mutex) error {
txnLock.Lock()
txns, err := core.GetTxsByBlockNum(txn, blockNumber)
txns, err := core.GetTransactionsByBlockNum(txn, blockNumber)
txnLock.Unlock()
if err != nil {
return err
Expand Down