From d7b831808d8cdee4abc529bef6f1bdb849289606 Mon Sep 17 00:00:00 2001 From: Barsan Date: Sun, 1 Nov 2026 19:37:50 +0000 Subject: [PATCH] test(migration): remove unused txlayout package --- .../blocktransactions_test.go | 187 ++++++++++- .../txlayout/transaction_layout.go | 311 ------------------ .../txlayout/transaction_layout_test.go | 277 ---------------- 3 files changed, 173 insertions(+), 602 deletions(-) delete mode 100644 migration/blocktransactions/txlayout/transaction_layout.go delete mode 100644 migration/blocktransactions/txlayout/transaction_layout_test.go diff --git a/migration/blocktransactions/blocktransactions_test.go b/migration/blocktransactions/blocktransactions_test.go index 12d9af9880..188070f83f 100644 --- a/migration/blocktransactions/blocktransactions_test.go +++ b/migration/blocktransactions/blocktransactions_test.go @@ -11,11 +11,11 @@ import ( "github.com/NethermindEth/juno/adapters/testutils" "github.com/NethermindEth/juno/blockchain/networks" "github.com/NethermindEth/juno/core" + "github.com/NethermindEth/juno/core/felt" "github.com/NethermindEth/juno/db" "github.com/NethermindEth/juno/db/pebblev2" "github.com/NethermindEth/juno/db/typed/prefix" "github.com/NethermindEth/juno/migration/blocktransactions" - "github.com/NethermindEth/juno/migration/blocktransactions/txlayout" "github.com/NethermindEth/juno/utils/log" conciter "github.com/sourcegraph/conc/iter" "github.com/stretchr/testify/require" @@ -116,7 +116,7 @@ func runTestBlockTransactionsMigration( ) require.NoError( t, - txlayout.TransactionLayoutPerTx.WriteTransactionsAndReceipts( + writePerTxTransactionsAndReceipts( batch, uint64(blockNumber), allTransactions[blockNumber], @@ -130,12 +130,11 @@ func runTestBlockTransactionsMigration( snapshot := openSnapshot(t, dir) t.Run("PerTx layout should contain data", func(t *testing.T) { - assertData( + assertPerTxData( t, snapshot, allTransactions, allReceipts, - txlayout.TransactionLayoutPerTx, ) }) @@ -190,24 +189,21 @@ func runTestBlockTransactionsMigration( snapshot := openSnapshot(t, dir) t.Run("Combined layout should contain data", func(t *testing.T) { - assertData( + assertCombinedData( t, snapshot, allTransactions, allReceipts, - txlayout.TransactionLayoutCombined, ) }) t.Run("PerTx layout should be empty", func(t *testing.T) { assertEmptyBucket( t, - //nolint:staticcheck,nolintlint // old transaction layout core.DeprecatedTransactionsByBlockNumberAndIndexBucket.Prefix().Scan(snapshot), ) assertEmptyBucket( t, - //nolint:staticcheck,nolintlint // old transaction layout core.DeprecatedReceiptsByBlockNumberAndIndexBucket.Prefix().Scan(snapshot), ) }) @@ -217,12 +213,175 @@ func runTestBlockTransactionsMigration( }) } -func assertData( +//nolint:staticcheck // Intentionally testing deprecated per-tx layout buckets. +func writePerTxTransactionsAndReceipts( + w db.KeyValueWriter, + blockNumber uint64, + transactions []core.Transaction, + receipts []*core.TransactionReceipt, +) error { + for index, tx := range transactions { + txHash := (*felt.TransactionHash)(tx.Hash()) + key := db.BlockNumIndexKey{ + Number: blockNumber, + Index: uint64(index), + } + + if err := core.TransactionBlockNumbersAndIndicesByHashBucket.Put( + w, + txHash, + &key, + ); err != nil { + return err + } + + if err := core.DeprecatedTransactionsByBlockNumberAndIndexBucket.Put( + w, + key, + &tx, + ); err != nil { + return err + } + + if err := core.DeprecatedReceiptsByBlockNumberAndIndexBucket.Put( + w, + key, + receipts[index], + ); err != nil { + return err + } + } + return nil +} + +//nolint:staticcheck // Intentionally reading from deprecated per-tx layout bucket. +func perTxTransactionsByBlockNumber( + r db.KeyValueReader, + blockNum uint64, +) ([]core.Transaction, error) { + var transactions []core.Transaction + iterator := core.DeprecatedTransactionsByBlockNumberAndIndexBucket. + Prefix(). + Add(blockNum). + Scan(r) + for entry, err := range iterator { + if err != nil { + return nil, err + } + transactions = append(transactions, entry.Value) + } + return transactions, nil +} + +//nolint:staticcheck // Intentionally reading from deprecated per-tx layout bucket. +func perTxTransactionByBlockAndIndex( + r db.KeyValueReader, + blockNumber, index uint64, +) (core.Transaction, error) { + key := db.BlockNumIndexKey{ + Number: blockNumber, + Index: index, + } + return core.DeprecatedTransactionsByBlockNumberAndIndexBucket.Get(r, key) +} + +//nolint:staticcheck // Intentionally reading from deprecated per-tx layout bucket. +func perTxReceiptsByBlockNumber( + r db.KeyValueReader, + blockNum uint64, +) ([]*core.TransactionReceipt, error) { + var receipts []*core.TransactionReceipt + iterator := core.DeprecatedReceiptsByBlockNumberAndIndexBucket. + Prefix(). + Add(blockNum). + Scan(r) + for entry, err := range iterator { + if err != nil { + return nil, err + } + receipts = append(receipts, &entry.Value) + } + return receipts, nil +} + +//nolint:staticcheck // Intentionally reading from deprecated per-tx layout bucket. +func perTxReceiptByBlockAndIndex( + r db.KeyValueReader, + blockNumber, index uint64, +) (*core.TransactionReceipt, error) { + key := db.BlockNumIndexKey{ + Number: blockNumber, + Index: index, + } + receipt, err := core.DeprecatedReceiptsByBlockNumberAndIndexBucket.Get(r, key) + if err != nil { + return nil, err + } + return &receipt, nil +} + +func combinedTransactionsByBlockNumber( + r db.KeyValueReader, + blockNum uint64, +) ([]core.Transaction, error) { + return core.BlockTransactionsAllTransactionsPartialBucket.Get(r, blockNum, struct{}{}) +} + +func combinedTransactionByBlockAndIndex( + r db.KeyValueReader, + blockNumber, index uint64, +) (core.Transaction, error) { + return core.BlockTransactionsTransactionPartialBucket.Get(r, blockNumber, int(index)) +} + +func combinedReceiptsByBlockNumber( + r db.KeyValueReader, + blockNum uint64, +) ([]*core.TransactionReceipt, error) { + return core.BlockTransactionsAllReceiptsPartialBucket.Get(r, blockNum, struct{}{}) +} + +func combinedReceiptByBlockAndIndex( + r db.KeyValueReader, + blockNumber, index uint64, +) (*core.TransactionReceipt, error) { + return core.BlockTransactionsReceiptPartialBucket.Get(r, blockNumber, int(index)) +} + +func assertPerTxData( + t *testing.T, + snapshot db.KeyValueReader, + allTransactions [][]core.Transaction, + allReceipts [][]*core.TransactionReceipt, +) { + t.Helper() + + t.Run("Transactions", func(t *testing.T) { + assertCurrentLayout( + t, + snapshot, + allTransactions, + perTxTransactionsByBlockNumber, + perTxTransactionByBlockAndIndex, + ) + }) + + t.Run("Receipts", func(t *testing.T) { + assertCurrentLayout( + t, + snapshot, + allReceipts, + perTxReceiptsByBlockNumber, + perTxReceiptByBlockAndIndex, + ) + }) +} + +func assertCombinedData( t *testing.T, snapshot db.KeyValueReader, allTransactions [][]core.Transaction, allReceipts [][]*core.TransactionReceipt, - layout txlayout.TransactionLayout, ) { t.Helper() @@ -231,8 +390,8 @@ func assertData( t, snapshot, allTransactions, - layout.TransactionsByBlockNumber, - layout.TransactionByBlockAndIndex, + combinedTransactionsByBlockNumber, + combinedTransactionByBlockAndIndex, ) }) @@ -241,8 +400,8 @@ func assertData( t, snapshot, allReceipts, - layout.ReceiptsByBlockNumber, - layout.ReceiptByBlockAndIndex, + combinedReceiptsByBlockNumber, + combinedReceiptByBlockAndIndex, ) }) } diff --git a/migration/blocktransactions/txlayout/transaction_layout.go b/migration/blocktransactions/txlayout/transaction_layout.go deleted file mode 100644 index eae4ed9e6e..0000000000 --- a/migration/blocktransactions/txlayout/transaction_layout.go +++ /dev/null @@ -1,311 +0,0 @@ -// Package txlayout is a frozen copy of the transaction layout logic that was -// originally defined as core.TransactionLayout, introduced in -// https://github.com/NethermindEth/juno/pull/3304. -// -// Juno now exclusively uses a combined layout to store transactions and -// receipts in the database. The original TransactionLayout type was removed -// from core, but migrations and tests still need to read and write data in -// both the old (per-transaction) and new (combined) layouts. -// -// This package preserves that capability for use by migration code and tests. -// It should NOT be used by any new production code paths. -package txlayout - -import ( - "errors" - "fmt" - "iter" - - "github.com/NethermindEth/juno/core" - "github.com/NethermindEth/juno/core/felt" - "github.com/NethermindEth/juno/db" -) - -type TransactionLayout int - -const ( - // TransactionLayoutPerTx stores each transaction and receipt in separate DB entries - TransactionLayoutPerTx TransactionLayout = iota - // TransactionLayoutCombined stores all transactions and receipts per block in a single entry - TransactionLayoutCombined -) - -var ErrUnknownTransactionLayout = errors.New("unknown transaction layout") - -// TransactionByBlockAndIndex returns a transaction by block number and index -func (l TransactionLayout) TransactionByBlockAndIndex( - r db.KeyValueReader, - blockNumber uint64, - index uint64, -) (core.Transaction, error) { - switch l { - case TransactionLayoutCombined: - return core.BlockTransactionsTransactionPartialBucket.Get(r, blockNumber, int(index)) - - case TransactionLayoutPerTx: - key := db.BlockNumIndexKey{ - Number: blockNumber, - Index: index, - } - //nolint:staticcheck,nolintlint // old transaction layout - return core.DeprecatedTransactionsByBlockNumberAndIndexBucket.Get(r, key) - - default: - return nil, fmt.Errorf("%w: %d", ErrUnknownTransactionLayout, l) - } -} - -// ReceiptByBlockAndIndex returns a receipt by block number and transaction index -func (l TransactionLayout) ReceiptByBlockAndIndex( - r db.KeyValueReader, - blockNumber uint64, - index uint64, -) (*core.TransactionReceipt, error) { - switch l { - case TransactionLayoutCombined: - return core.BlockTransactionsReceiptPartialBucket.Get(r, blockNumber, int(index)) - - case TransactionLayoutPerTx: - key := db.BlockNumIndexKey{ - Number: blockNumber, - Index: index, - } - //nolint:staticcheck,nolintlint // old transaction layout - receipt, err := core.DeprecatedReceiptsByBlockNumberAndIndexBucket.Get(r, key) - if err != nil { - return nil, err - } - return &receipt, nil - - default: - return nil, fmt.Errorf("%w: %d", ErrUnknownTransactionLayout, l) - } -} - -// TransactionsByBlockNumber returns all transactions in a given block -func (l TransactionLayout) TransactionsByBlockNumber( - r db.KeyValueReader, - blockNum uint64, -) ([]core.Transaction, error) { - switch l { - case TransactionLayoutCombined: - return core.BlockTransactionsAllTransactionsPartialBucket.Get(r, blockNum, struct{}{}) - - case TransactionLayoutPerTx: - var transactions []core.Transaction - //nolint:staticcheck,nolintlint // old transaction layout - iterator := core.DeprecatedTransactionsByBlockNumberAndIndexBucket.Prefix().Add(blockNum).Scan(r) - for entry, err := range iterator { - if err != nil { - return nil, err - } - transactions = append(transactions, entry.Value) - } - return transactions, nil - - default: - return nil, fmt.Errorf("%w: %d", ErrUnknownTransactionLayout, l) - } -} - -// TransactionsByBlockNumberIter returns an iterator over all transactions in a given block -func (l TransactionLayout) TransactionsByBlockNumberIter( - r db.KeyValueReader, - blockNum uint64, -) iter.Seq2[core.Transaction, error] { - switch l { - case TransactionLayoutCombined: - blockTransactions, err := core.BlockTransactionsBucket.Get(r, blockNum) - if err != nil { - return func(yield func(core.Transaction, error) bool) { - yield(nil, err) - } - } - return blockTransactions.Transactions().Iter() - - case TransactionLayoutPerTx: - return func(yield func(core.Transaction, error) bool) { - //nolint:staticcheck,nolintlint // old transaction layout - iterator := core.DeprecatedTransactionsByBlockNumberAndIndexBucket.Prefix().Add(blockNum).Scan(r) - for entry, err := range iterator { - if !yield(entry.Value, err) { - return - } - } - } - - default: - return func(yield func(core.Transaction, error) bool) { - yield(nil, fmt.Errorf("%w: %d", ErrUnknownTransactionLayout, l)) - } - } -} - -// ReceiptsByBlockNumber returns all receipts in a given block -func (l TransactionLayout) ReceiptsByBlockNumber( - r db.KeyValueReader, - blockNum uint64, -) ([]*core.TransactionReceipt, error) { - switch l { - case TransactionLayoutCombined: - return core.BlockTransactionsAllReceiptsPartialBucket.Get(r, blockNum, struct{}{}) - - case TransactionLayoutPerTx: - var receipts []*core.TransactionReceipt - //nolint:staticcheck,nolintlint // old transaction layout - iterator := core.DeprecatedReceiptsByBlockNumberAndIndexBucket.Prefix().Add(blockNum).Scan(r) - for entry, err := range iterator { - if err != nil { - return nil, err - } - receipts = append(receipts, &entry.Value) - } - return receipts, nil - - default: - return nil, fmt.Errorf("%w: %d", ErrUnknownTransactionLayout, l) - } -} - -// BlockByNumber returns a full block by number -func (l TransactionLayout) BlockByNumber( - r db.KeyValueReader, - blockNum uint64, -) (*core.Block, error) { - header, err := core.GetBlockHeaderByNumber(r, blockNum) - if err != nil { - return nil, err - } - - allTransactions, err := l.TransactionsByBlockNumber(r, blockNum) - if err != nil { - return nil, err - } - - allReceipts, err := l.ReceiptsByBlockNumber(r, blockNum) - if err != nil { - return nil, err - } - - return &core.Block{ - Header: header, - Transactions: allTransactions, - Receipts: allReceipts, - }, nil -} - -// WriteTransactionsAndReceipts writes transactions and receipts for a block -func (l TransactionLayout) WriteTransactionsAndReceipts( - w db.KeyValueWriter, - blockNumber uint64, - transactions []core.Transaction, - receipts []*core.TransactionReceipt, -) error { - for index, tx := range transactions { - txHash := (*felt.TransactionHash)(tx.Hash()) - key := db.BlockNumIndexKey{ - Number: blockNumber, - Index: uint64(index), - } - - if err := core.TransactionBlockNumbersAndIndicesByHashBucket.Put(w, txHash, &key); err != nil { - return err - } - } - - switch l { - case TransactionLayoutCombined: - blockTransactions, err := core.NewBlockTransactions(transactions, receipts) - if err != nil { - return err - } - - return core.BlockTransactionsBucket.Put(w, blockNumber, &blockTransactions) - - case TransactionLayoutPerTx: - for index, tx := range transactions { - key := db.BlockNumIndexKey{ - Number: blockNumber, - Index: uint64(index), - } - - //nolint:staticcheck,nolintlint // old transaction layout - err := core.DeprecatedTransactionsByBlockNumberAndIndexBucket.Put(w, key, &tx) - if err != nil { - return err - } - //nolint:staticcheck,nolintlint // old transaction layout - err = core.DeprecatedReceiptsByBlockNumberAndIndexBucket.Put(w, key, receipts[index]) - if err != nil { - return err - } - } - - return nil - - default: - return fmt.Errorf("%w: %d", ErrUnknownTransactionLayout, l) - } -} - -// DeleteTxsAndReceipts deletes all transactions and receipts for a block -func (l TransactionLayout) DeleteTxsAndReceipts( - reader db.KeyValueReader, - writer db.Batch, - blockNum uint64, -) error { - // Delete hash mappings using the existing iterator - for tx, err := range l.TransactionsByBlockNumberIter(reader, blockNum) { - if err != nil { - return err - } - txHash := (*felt.TransactionHash)(tx.Hash()) - err := core.TransactionBlockNumbersAndIndicesByHashBucket.Delete(writer, txHash) - if err != nil { - return err - } - if l1handler, ok := tx.(*core.L1HandlerTransaction); ok { - err := core.DeleteL1HandlerTxnHashByMsgHash(writer, l1handler.MessageHash()) - if err != nil { - return err - } - } - } - - // Layout-specific deletions - switch l { - case TransactionLayoutCombined: - return core.BlockTransactionsBucket.Delete(writer, blockNum) - - case TransactionLayoutPerTx: - //nolint:staticcheck,nolintlint // old transaction layout - err := core.DeprecatedTransactionsByBlockNumberAndIndexBucket. - Prefix(). - Add(blockNum). - DeletePrefix(writer) - if err != nil { - return err - } - //nolint:staticcheck,nolintlint // old transaction layout - return core.DeprecatedReceiptsByBlockNumberAndIndexBucket. - Prefix(). - Add(blockNum). - DeletePrefix(writer) - - default: - return fmt.Errorf("%w: %d", ErrUnknownTransactionLayout, l) - } -} - -// TransactionByHash returns a transaction by its hash -func (l TransactionLayout) TransactionByHash( - r db.KeyValueReader, - hash *felt.TransactionHash, -) (core.Transaction, error) { - blockNumIndex, err := core.TransactionBlockNumbersAndIndicesByHashBucket.Get(r, hash) - if err != nil { - return nil, err - } - - return l.TransactionByBlockAndIndex(r, blockNumIndex.Number, blockNumIndex.Index) -} diff --git a/migration/blocktransactions/txlayout/transaction_layout_test.go b/migration/blocktransactions/txlayout/transaction_layout_test.go deleted file mode 100644 index 1f49508c4e..0000000000 --- a/migration/blocktransactions/txlayout/transaction_layout_test.go +++ /dev/null @@ -1,277 +0,0 @@ -package txlayout_test - -import ( - "testing" - - "github.com/NethermindEth/juno/adapters/testutils" - "github.com/NethermindEth/juno/core" - "github.com/NethermindEth/juno/core/felt" - "github.com/NethermindEth/juno/db" - "github.com/NethermindEth/juno/db/pebblev2" - "github.com/NethermindEth/juno/migration/blocktransactions/txlayout" - _ "github.com/NethermindEth/juno/utils/cbor/registry" - "github.com/stretchr/testify/require" -) - -const ( - txCount = 50 - chainHeight = 10 -) - -func layoutName(l txlayout.TransactionLayout) string { - switch l { - case txlayout.TransactionLayoutPerTx: - return "PerTx" - case txlayout.TransactionLayoutCombined: - return "Combined" - default: - return "Unknown" - } -} - -func assertByBlockIndex[T any]( - t *testing.T, - database db.KeyValueReader, - expectedErr bool, - expected [][]T, - get func(database db.KeyValueReader, blockNumber, index uint64) (T, error), -) { - t.Helper() - for blockNum := range chainHeight { - for i, expected := range expected[blockNum] { - actual, err := get(database, uint64(blockNum), uint64(i)) - if expectedErr { - require.Error(t, err) - } else { - require.NoError(t, err) - require.Equal(t, expected, actual) - } - } - } -} - -func assertByTransactionHash( - t *testing.T, - database db.KeyValueReader, - expectedErr bool, - expected [][]core.Transaction, - layout txlayout.TransactionLayout, -) { - t.Helper() - assertByBlockIndex( - t, - database, - expectedErr, - expected, - func(database db.KeyValueReader, blockNumber, index uint64) (core.Transaction, error) { - hash := (*felt.TransactionHash)(expected[blockNumber][index].Hash()) - return layout.TransactionByHash(database, hash) - }, - ) -} - -func assertByBlockNumber[T any]( - t *testing.T, - database db.KeyValueReader, - expectedErr bool, - expected [][]T, - get func(database db.KeyValueReader, blockNumber uint64) ([]T, error), -) { - t.Helper() - for blockNum := range chainHeight { - actual, err := get(database, uint64(blockNum)) - if expectedErr { - require.Error(t, err) - } else { - require.NoError(t, err) - require.Equal(t, expected[blockNum], actual) - } - } -} - -func runTestTransactionLayout( - t *testing.T, - transactions [][]core.Transaction, - receipts [][]*core.TransactionReceipt, - headers []*core.Header, - layout txlayout.TransactionLayout, -) { - t.Run(layoutName(layout), func(t *testing.T) { - database, err := pebblev2.New(t.TempDir()) - require.NoError(t, err) - defer database.Close() - - // WRITE - t.Run("WriteTransactionsAndReceipts", func(t *testing.T) { - for blockNum := range chainHeight { - require.NoError( - t, - layout.WriteTransactionsAndReceipts( - database, - uint64(blockNum), - transactions[blockNum], - receipts[blockNum], - ), - ) - } - }) - - // READ - t.Run("TransactionByBlockAndIndex", func(t *testing.T) { - assertByBlockIndex(t, database, false, transactions, layout.TransactionByBlockAndIndex) - }) - - t.Run("ReceiptByBlockAndIndex", func(t *testing.T) { - assertByBlockIndex(t, database, false, receipts, layout.ReceiptByBlockAndIndex) - }) - - t.Run("TransactionsByBlockNumber", func(t *testing.T) { - assertByBlockNumber(t, database, false, transactions, layout.TransactionsByBlockNumber) - }) - - t.Run("TransactionsByBlockNumberIter", func(t *testing.T) { - for blockNum := range chainHeight { - var actual []core.Transaction - iter := layout.TransactionsByBlockNumberIter(database, uint64(blockNum)) - for tx, err := range iter { - require.NoError(t, err) - actual = append(actual, tx) - } - require.Equal(t, transactions[blockNum], actual) - } - }) - - t.Run("ReceiptsByBlockNumber", func(t *testing.T) { - assertByBlockNumber(t, database, false, receipts, layout.ReceiptsByBlockNumber) - }) - - t.Run("TransactionByHash", func(t *testing.T) { - assertByTransactionHash(t, database, false, transactions, layout) - }) - - t.Run("BlockByNumber", func(t *testing.T) { - // First, write all block headers - for blockNum := range chainHeight { - require.NoError(t, core.WriteBlockHeaderByNumber(database, headers[blockNum])) - } - - // Now test BlockByNumber for all blocks - for blockNum := range chainHeight { - block, err := layout.BlockByNumber(database, uint64(blockNum)) - require.NoError(t, err) - require.Equal(t, headers[blockNum], block.Header) - require.Equal(t, transactions[blockNum], block.Transactions) - require.Equal(t, receipts[blockNum], block.Receipts) - } - }) - - // NON-EXISTENT BLOCK - t.Run("NonExistentBlock_TransactionsByBlockNumber", func(t *testing.T) { - if layout == txlayout.TransactionLayoutPerTx { - t.Skip("PerTx layout returns empty slice for non-existent blocks") - } - _, err := layout.TransactionsByBlockNumber(database, uint64(999)) - require.Error(t, err) - }) - - t.Run("NonExistentBlock_ReceiptsByBlockNumber", func(t *testing.T) { - if layout == txlayout.TransactionLayoutPerTx { - t.Skip("PerTx layout returns empty slice for non-existent blocks") - } - _, err := layout.ReceiptsByBlockNumber(database, uint64(999)) - require.Error(t, err) - }) - - t.Run("NonExistentBlock_TransactionsByBlockNumberIter", func(t *testing.T) { - for _, err := range layout.TransactionsByBlockNumberIter(database, uint64(999)) { - require.Error(t, err) - } - }) - - // DELETE - t.Run("DeleteTxsAndReceipts", func(t *testing.T) { - // Delete all blocks - for blockNum := range chainHeight { - //nolint:staticcheck // SA1019: needed since it's used by old state - require.NoError(t, database.Update(func(batch db.IndexedBatch) error { - return layout.DeleteTxsAndReceipts(database, batch, uint64(blockNum)) - })) - } - - // Verify transactions are deleted - assertByBlockIndex(t, database, true, transactions, layout.TransactionByBlockAndIndex) - - // Verify receipts are deleted - assertByBlockIndex(t, database, true, receipts, layout.ReceiptByBlockAndIndex) - - // After all blocks deleted, verify all transaction hash lookups fail - assertByTransactionHash(t, database, true, transactions, layout) - }) - }) -} - -func TestTransactionLayout(t *testing.T) { - // Generate fixtures for all blocks ONCE - transactions := make([][]core.Transaction, chainHeight) - receipts := make([][]*core.TransactionReceipt, chainHeight) - headers := make([]*core.Header, chainHeight) - for blockNum := range chainHeight { - transactions[blockNum] = testutils.GetCoreTransactions(t, txCount) - receipts[blockNum] = testutils.GetCoreReceipts(t, txCount) - headers[blockNum] = &core.Header{ - Hash: felt.NewRandom[felt.Felt](), - Number: uint64(blockNum), - } - } - - runTestTransactionLayout(t, transactions, receipts, headers, txlayout.TransactionLayoutPerTx) - runTestTransactionLayout(t, transactions, receipts, headers, txlayout.TransactionLayoutCombined) -} - -func TestTransactionLayout_UnknownLayout(t *testing.T) { - database, err := pebblev2.New(t.TempDir()) - require.NoError(t, err) - defer database.Close() - - unknownLayout := txlayout.TransactionLayout(99) - - t.Run("TransactionByBlockAndIndex", func(t *testing.T) { - _, err := unknownLayout.TransactionByBlockAndIndex(database, 0, 0) - require.ErrorIs(t, err, txlayout.ErrUnknownTransactionLayout) - }) - - t.Run("ReceiptByBlockAndIndex", func(t *testing.T) { - _, err := unknownLayout.ReceiptByBlockAndIndex(database, 0, 0) - require.ErrorIs(t, err, txlayout.ErrUnknownTransactionLayout) - }) - - t.Run("TransactionsByBlockNumber", func(t *testing.T) { - _, err := unknownLayout.TransactionsByBlockNumber(database, 0) - require.ErrorIs(t, err, txlayout.ErrUnknownTransactionLayout) - }) - - t.Run("TransactionsByBlockNumberIter", func(t *testing.T) { - isFirstIteration := true - for _, err := range unknownLayout.TransactionsByBlockNumberIter(database, 0) { - require.True(t, isFirstIteration) - isFirstIteration = false - require.ErrorIs(t, err, txlayout.ErrUnknownTransactionLayout) - } - }) - - t.Run("ReceiptsByBlockNumber", func(t *testing.T) { - _, err := unknownLayout.ReceiptsByBlockNumber(database, 0) - require.ErrorIs(t, err, txlayout.ErrUnknownTransactionLayout) - }) - - t.Run("WriteTransactionsAndReceipts", func(t *testing.T) { - err := unknownLayout.WriteTransactionsAndReceipts(database, 0, nil, nil) - require.ErrorIs(t, err, txlayout.ErrUnknownTransactionLayout) - }) - - t.Run("DeleteTxsAndReceipts", func(t *testing.T) { - batch := database.NewBatch() - err := unknownLayout.DeleteTxsAndReceipts(database, batch, 0) - require.ErrorIs(t, err, txlayout.ErrUnknownTransactionLayout) - }) -}