feijoa: l1infotree recursive

cmd/run.go

@@ -511,14 +511,20 @@ func newState(ctx context.Context, c *config.Config, etherman *etherman.Client,
 	}
 	stateDb := pgstatestorage.NewPostgresStorage(stateCfg, sqlDB)
 
-	st := state.NewState(stateCfg, stateDb, executorClient, stateTree, eventLog, nil)
+	st := state.NewState(stateCfg, stateDb, executorClient, stateTree, eventLog, nil, nil)
 	// This is to force to build cache, and check that DB is ok before starting the application
 	l1InfoRoot, err := st.GetCurrentL1InfoRoot(ctx, nil)
 	if err != nil {
 		log.Fatal("error getting current L1InfoRoot. Error: ", err)
 	}
 	log.Infof("Starting L1InfoRoot: %v", l1InfoRoot.String())
 
+	l1InfoTreeRecursiveRoot, err := st.GetCurrentL1InfoTreeRecursiveRoot(ctx, nil)
+	if err != nil {
+		log.Fatal("error getting current l1InfoTreeRecursiveRoot. Error: ", err)
+	}
+	log.Infof("Starting l1InfoTreeRecursiveRoot: %v", l1InfoTreeRecursiveRoot.String())
+
 	forkIDIntervals, err := forkIDIntervals(ctx, st, etherman, c.NetworkConfig.Genesis.BlockNumber)
 	if err != nil {
 		log.Fatal("error getting forkIDs. Error: ", err)

db/migrations/state/0013_test.go

@@ -8,21 +8,19 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-const (
-	blockHashValue         = "0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1"
-	mainExitRootValue      = "0x83fc198de31e1b2b1a8212d2430fbb7766c13d9ad305637dea3759065606475d"
-	rollupExitRootValue    = "0xadb91a6a1fce56eaea561002bc9a993f4e65a7710bd72f4eee3067cbd73a743c"
-	globalExitRootValue    = "0x5bf4af1a651a2a74b36e6eb208481f94c69fc959f756223dfa49608061937585"
-	previousBlockHashValue = "0xe865e912b504572a4d80ad018e29797e3c11f00bf9ae2549548a25779c9d7e57"
-	l1InfoRootValue        = "0x2b9484b83c6398033241865b015fb9430eb3e159182a6075d00c924845cc393e"
-)
-
 // this migration changes length of the token name
-type migrationTest0013 struct{}
+type migrationTest0013 struct {
+	blockHashValue         string
+	mainExitRootValue      string
+	rollupExitRootValue    string
+	globalExitRootValue    string
+	previousBlockHashValue string
+	l1InfoRootValue        string
+}
 
 func (m migrationTest0013) insertBlock(blockNumber uint64, db *sql.DB) error {
 	const addBlock = "INSERT INTO state.block (block_num, received_at, block_hash) VALUES ($1, $2, $3)"
-	if _, err := db.Exec(addBlock, blockNumber, time.Now(), blockHashValue); err != nil {
+	if _, err := db.Exec(addBlock, blockNumber, time.Now(), m.blockHashValue); err != nil {
 		return err
 	}
 	return nil
@@ -45,10 +43,10 @@ func (m migrationTest0013) InsertData(db *sql.DB) error {
 	if err = m.insertBlock(uint64(124), db); err != nil {
 		return err
 	}
-	if err = m.insertRowInOldTable(db, []interface{}{123, time.Now(), mainExitRootValue, rollupExitRootValue, globalExitRootValue}); err != nil {
+	if err = m.insertRowInOldTable(db, []interface{}{123, time.Now(), m.mainExitRootValue, m.rollupExitRootValue, m.globalExitRootValue}); err != nil {
 		return err
 	}
-	if err = m.insertRowInOldTable(db, []interface{}{124, time.Now(), mainExitRootValue, rollupExitRootValue, globalExitRootValue}); err != nil {
+	if err = m.insertRowInOldTable(db, []interface{}{124, time.Now(), m.mainExitRootValue, m.rollupExitRootValue, m.globalExitRootValue}); err != nil {
 		return err
 	}
 
@@ -113,16 +111,16 @@ func (m migrationTest0013) RunAssertsAfterMigrationUp(t *testing.T, db *sql.DB)
 	assert.NoError(t, err)
 	err = m.insertBlock(uint64(127), db)
 	assert.NoError(t, err)
-	prevBlockHash := previousBlockHashValue
-	l1InfoRoot := l1InfoRootValue
-	err = m.insertRowInMigratedTable(db, []interface{}{125, time.Now(), mainExitRootValue, rollupExitRootValue, globalExitRootValue, prevBlockHash, l1InfoRoot, 1})
+	prevBlockHash := m.previousBlockHashValue
+	l1InfoRoot := m.l1InfoRootValue
+	err = m.insertRowInMigratedTable(db, []interface{}{125, time.Now(), m.mainExitRootValue, m.rollupExitRootValue, m.globalExitRootValue, prevBlockHash, l1InfoRoot, 1})
 	assert.NoError(t, err)
 	// insert duplicated l1_info_root
-	err = m.insertRowInMigratedTable(db, []interface{}{126, time.Now(), mainExitRootValue, rollupExitRootValue, globalExitRootValue, prevBlockHash, l1InfoRoot, 1})
+	err = m.insertRowInMigratedTable(db, []interface{}{126, time.Now(), m.mainExitRootValue, m.rollupExitRootValue, m.globalExitRootValue, prevBlockHash, l1InfoRoot, 1})
 	assert.Error(t, err)
 
 	// insert in the old way must work
-	err = m.insertRowInOldTable(db, []interface{}{127, time.Now(), mainExitRootValue, rollupExitRootValue, globalExitRootValue})
+	err = m.insertRowInOldTable(db, []interface{}{127, time.Now(), m.mainExitRootValue, m.rollupExitRootValue, m.globalExitRootValue})
 	assert.NoError(t, err)
 
 	sqlSelect := `SELECT prev_block_hash, l1_info_root FROM state.exit_root WHERE l1_info_tree_index = $1`
@@ -185,5 +183,13 @@ func (m migrationTest0013) RunAssertsAfterMigrationDown(t *testing.T, db *sql.DB
 }
 
 func TestMigration0013(t *testing.T) {
-	runMigrationTest(t, 13, migrationTest0013{})
+	m := migrationTest0013{
+		blockHashValue:         "0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1",
+		mainExitRootValue:      "0x83fc198de31e1b2b1a8212d2430fbb7766c13d9ad305637dea3759065606475d",
+		rollupExitRootValue:    "0xadb91a6a1fce56eaea561002bc9a993f4e65a7710bd72f4eee3067cbd73a743c",
+		globalExitRootValue:    "0x5bf4af1a651a2a74b36e6eb208481f94c69fc959f756223dfa49608061937585",
+		previousBlockHashValue: "0xe865e912b504572a4d80ad018e29797e3c11f00bf9ae2549548a25779c9d7e57",
+		l1InfoRootValue:        "0x2b9484b83c6398033241865b015fb9430eb3e159182a6075d00c924845cc393e",
+	}
+	runMigrationTest(t, 13, m)
 }

db/migrations/state/0018_test.go

@@ -7,7 +7,9 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-type migrationTest0018 struct{}
+type migrationTest0018 struct {
+	migrationBase
+}
 
 func (m migrationTest0018) InsertData(db *sql.DB) error {
 	const insertBatch1 = `
@@ -46,16 +48,7 @@ func (m migrationTest0018) InsertData(db *sql.DB) error {
 }
 
 func (m migrationTest0018) RunAssertsAfterMigrationUp(t *testing.T, db *sql.DB) {
-	assertTableNotExists(t, db, "state", "proof")
-
-	assertTableExists(t, db, "state", "blob_inner")
-	assertTableExists(t, db, "state", "batch_proof")
-	assertTableExists(t, db, "state", "blob_inner_proof")
-	assertTableExists(t, db, "state", "blob_outer_proof")
-
-	assertColumnExists(t, db, "state", "virtual_batch", "blob_inner_num")
-	assertColumnExists(t, db, "state", "virtual_batch", "prev_l1_it_root")
-	assertColumnExists(t, db, "state", "virtual_batch", "prev_l1_it_index")
+	m.AssertNewAndRemovedItemsAfterMigrationUp(t, db)
 
 	// Insert blobInner 1
 	const insertBlobInner = `INSERT INTO state.blob_inner (blob_inner_num, data, block_num) VALUES (1, E'\\x1234', 1);`
@@ -80,16 +73,7 @@ func (m migrationTest0018) RunAssertsAfterMigrationUp(t *testing.T, db *sql.DB)
 func (m migrationTest0018) RunAssertsAfterMigrationDown(t *testing.T, db *sql.DB) {
 	var result int
 
-	assertTableExists(t, db, "state", "proof")
-
-	assertTableNotExists(t, db, "state", "blob_inner")
-	assertTableNotExists(t, db, "state", "batch_proof")
-	assertTableNotExists(t, db, "state", "blob_inner_proof")
-	assertTableNotExists(t, db, "state", "blob_outer_proof")
-
-	assertColumnNotExists(t, db, "state", "virtual_batch", "blob_inner_num")
-	assertColumnNotExists(t, db, "state", "virtual_batch", "prev_l1_it_root")
-	assertColumnNotExists(t, db, "state", "virtual_batch", "prev_l1_it_index")
+	m.AssertNewAndRemovedItemsAfterMigrationDown(t, db)
 
 	// Check column blob_inner_num doesn't exists in state.virtual_batch table
 	const getBlobInnerNumColumn = `SELECT count(*) FROM information_schema.columns WHERE table_name='virtual_batch' and column_name='blob_inner_num'`
@@ -111,5 +95,25 @@ func (m migrationTest0018) RunAssertsAfterMigrationDown(t *testing.T, db *sql.DB
 }
 
 func TestMigration0018(t *testing.T) {
-	runMigrationTest(t, 18, migrationTest0018{})
+	m := migrationTest0018{
+		migrationBase: migrationBase{
+			removedTables: []tableMetadata{
+				{"state", "proof"},
+			},
+
+			newTables: []tableMetadata{
+				{"state", "blob_inner"},
+				{"state", "batch_proof"},
+				{"state", "blob_inner_proof"},
+				{"state", "blob_outer_proof"},
+			},
+
+			newColumns: []columnMetadata{
+				{"state", "virtual_batch", "blob_inner_num"},
+				{"state", "virtual_batch", "prev_l1_it_root"},
+				{"state", "virtual_batch", "prev_l1_it_index"},
+			},
+		},
+	}
+	runMigrationTest(t, 18, m)
 }

db/migrations/state/0019.sql

@@ -0,0 +1,12 @@
+-- +migrate Up
+
+-- +migrate Up
+ALTER TABLE state.exit_root
+    ADD COLUMN IF NOT EXISTS l1_info_tree_recursive_index BIGINT DEFAULT NULL UNIQUE;
+CREATE INDEX IF NOT EXISTS idx_exit_root_l1_info_tree_recursive_index ON state.exit_root (l1_info_tree_recursive_index);
+
+-- +migrate Down
+ALTER TABLE state.exit_root
+    DROP COLUMN IF EXISTS l1_info_tree_recursive_index;
+DROP INDEX IF EXISTS state.idx_exit_root_l1_info_tree_recursive_index;
+

db/migrations/state/0019_test.go

@@ -0,0 +1,106 @@
+package migrations_test
+
+import (
+	"database/sql"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type migrationTest0019 struct {
+	migrationBase
+
+	blockHashValue         string
+	mainExitRootValue      string
+	rollupExitRootValue    string
+	globalExitRootValue    string
+	previousBlockHashValue string
+	l1InfoRootValue        string
+}
+
+func (m migrationTest0019) insertBlock(blockNumber uint64, db *sql.DB) error {
+	const addBlock = "INSERT INTO state.block (block_num, received_at, block_hash) VALUES ($1, $2, $3)"
+	if _, err := db.Exec(addBlock, blockNumber, time.Now(), m.blockHashValue); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (m migrationTest0019) insertRowInOldTable(db *sql.DB, args ...interface{}) error {
+	sql := `
+    INSERT INTO state.exit_root (block_num, "timestamp", mainnet_exit_root, rollup_exit_root, global_exit_root, prev_block_hash, l1_info_root, l1_info_tree_index)
+                         VALUES (       $1,          $2,                $3,               $4,               $5,              $6,           $7,                 $8);`
+
+	_, err := db.Exec(sql, args...)
+	return err
+}
+
+func (m migrationTest0019) insertRowInMigratedTable(db *sql.DB, args ...interface{}) error {
+	sql := `
+    INSERT INTO state.exit_root (block_num, "timestamp", mainnet_exit_root, rollup_exit_root, global_exit_root, prev_block_hash, l1_info_root, l1_info_tree_index, l1_info_tree_recursive_index)
+                         VALUES (       $1,          $2,                $3,               $4,               $5,              $6,           $7,                 $8,                        $9);`
+
+	_, err := db.Exec(sql, args...)
+	return err
+}
+
+func (m migrationTest0019) InsertData(db *sql.DB) error {
+	var err error
+	for i := uint64(1); i <= 6; i++ {
+		if err = m.insertBlock(i, db); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (m migrationTest0019) RunAssertsAfterMigrationUp(t *testing.T, db *sql.DB) {
+	m.AssertNewAndRemovedItemsAfterMigrationUp(t, db)
+
+	var nilL1InfoTreeIndex *uint = nil
+	err := m.insertRowInOldTable(db, 1, time.Now().UTC(), m.mainExitRootValue, m.rollupExitRootValue, m.globalExitRootValue, m.previousBlockHashValue, m.l1InfoRootValue, nilL1InfoTreeIndex)
+	assert.NoError(t, err)
+
+	err = m.insertRowInOldTable(db, 2, time.Now().UTC(), m.mainExitRootValue, m.rollupExitRootValue, m.globalExitRootValue, m.previousBlockHashValue, m.l1InfoRootValue, uint(1))
+	assert.NoError(t, err)
+
+	err = m.insertRowInMigratedTable(db, 3, time.Now().UTC(), m.mainExitRootValue, m.rollupExitRootValue, m.globalExitRootValue, m.previousBlockHashValue, m.l1InfoRootValue, nilL1InfoTreeIndex, 1)
+	assert.NoError(t, err)
+}
+
+func (m migrationTest0019) RunAssertsAfterMigrationDown(t *testing.T, db *sql.DB) {
+	m.AssertNewAndRemovedItemsAfterMigrationDown(t, db)
+
+	var nilL1InfoTreeIndex *uint = nil
+	err := m.insertRowInOldTable(db, 4, time.Now().UTC(), m.mainExitRootValue, m.rollupExitRootValue, m.globalExitRootValue, m.previousBlockHashValue, m.l1InfoRootValue, nilL1InfoTreeIndex)
+	assert.NoError(t, err)
+
+	err = m.insertRowInOldTable(db, 5, time.Now().UTC(), m.mainExitRootValue, m.rollupExitRootValue, m.globalExitRootValue, m.previousBlockHashValue, m.l1InfoRootValue, uint(2))
+	assert.NoError(t, err)
+
+	err = m.insertRowInMigratedTable(db, 6, time.Now().UTC(), m.mainExitRootValue, m.rollupExitRootValue, m.globalExitRootValue, m.previousBlockHashValue, m.l1InfoRootValue, nilL1InfoTreeIndex, 2)
+	assert.Error(t, err)
+}
+
+func TestMigration0019(t *testing.T) {
+	m := migrationTest0019{
+		migrationBase: migrationBase{
+			newIndexes: []string{
+				"idx_exit_root_l1_info_tree_recursive_index",
+			},
+			newColumns: []columnMetadata{
+				{"state", "exit_root", "l1_info_tree_recursive_index"},
+			},
+		},
+
+		blockHashValue:         "0x29e885edaf8e4b51e1d2e05f9da28161d2fb4f6b1d53827d9b80a23cf2d7d9f1",
+		mainExitRootValue:      "0x83fc198de31e1b2b1a8212d2430fbb7766c13d9ad305637dea3759065606475d",
+		rollupExitRootValue:    "0xadb91a6a1fce56eaea561002bc9a993f4e65a7710bd72f4eee3067cbd73a743c",
+		globalExitRootValue:    "0x5bf4af1a651a2a74b36e6eb208481f94c69fc959f756223dfa49608061937585",
+		previousBlockHashValue: "0xe865e912b504572a4d80ad018e29797e3c11f00bf9ae2549548a25779c9d7e57",
+		l1InfoRootValue:        "0x2b9484b83c6398033241865b015fb9430eb3e159182a6075d00c924845cc393e",
+	}
+	runMigrationTest(t, 19, m)
+}