Feature/inject ger after n blocks (#885)

* new smc events

* etherman implementation + unit tests

* processBackwardLETSovereign

* unsetClaim

* processSetClaimSovereign

* tools

* Tool working properly + implementation verified

* mocks

* fix test

Author: ARR552

bridgectrl/bridgectrl.go

@@ -18,18 +18,18 @@ const (
 type BridgeController struct {
 	exitTrees     []*MerkleTree
 	rollupsTree   *MerkleTree
-	merkleTreeIDs map[uint32]uint8
+	merkleTreeIDs map[uint32]uint32
 }
 
 // NewBridgeController creates new BridgeController.
 func NewBridgeController(ctx context.Context, cfg Config, networkIDs []uint32, mtStore interface{}) (*BridgeController, error) {
 	var (
-		merkleTreeIDs = make(map[uint32]uint8)
+		merkleTreeIDs = make(map[uint32]uint32)
 		exitTrees     []*MerkleTree
 	)
 
 	for i, networkID := range networkIDs {
-		merkleTreeIDs[networkID] = uint8(i) // nolint:gosec
+		merkleTreeIDs[networkID] = uint32(i) // nolint:gosec
 		mt, err := NewMerkleTree(ctx, mtStore.(merkleTreeStore), cfg.Height, networkID)
 		if err != nil {
 			return nil, err
@@ -49,7 +49,7 @@ func NewBridgeController(ctx context.Context, cfg Config, networkIDs []uint32, m
 	}, nil
 }
 
-func (bt *BridgeController) GetMerkleTreeID(networkID uint32) (uint8, error) {
+func (bt *BridgeController) GetMerkleTreeID(networkID uint32) (uint32, error) {
 	tID, found := bt.merkleTreeIDs[networkID]
 	if !found {
 		return 0, gerror.ErrNetworkNotRegister
@@ -59,7 +59,7 @@ func (bt *BridgeController) GetMerkleTreeID(networkID uint32) (uint8, error) {
 
 // AddDeposit adds deposit information to the bridge tree.
 func (bt *BridgeController) AddDeposit(ctx context.Context, deposit *etherman.Deposit, dbTx interface{}) error {
-	leaf := hashDeposit(deposit)
+	leaf := HashDeposit(deposit)
 	tID, err := bt.GetMerkleTreeID(deposit.NetworkID)
 	if err != nil {
 		return err
@@ -85,9 +85,12 @@ func (bt *BridgeController) RollbackMT(ctx context.Context, networkID uint32, db
 	return bt.exitTrees[tID].rollbackMT(ctx, networkID, dbTx)
 }
 
-// GetExitRoot returns the dedicated merkle tree's root.
-// only use for the test purpose
-func (bt *BridgeController) GetExitRoot(ctx context.Context, tID uint8, dbTx interface{}) ([]byte, error) {
+// GetExitRoot returns the dedicated merkle tree's root given the networkID.
+func (bt *BridgeController) GetExitRoot(ctx context.Context, networkID uint32, dbTx interface{}) ([]byte, error) {
+	tID, err := bt.GetMerkleTreeID(networkID)
+	if err != nil {
+		return nil, err
+	}
 	return bt.exitTrees[tID].getRoot(ctx, dbTx)
 }
 

bridgectrl/bridgectrl_test.go

@@ -74,7 +74,7 @@ func TestBridgeTree(t *testing.T) {
 				DepositCount:       uint32(i), // nolint:gosec
 				Metadata:           common.FromHex(testVector.Metadata),
 			}
-			leafHash := hashDeposit(deposit)
+			leafHash := HashDeposit(deposit)
 			assert.Equal(t, testVector.ExpectedHash, hex.EncodeToString(leafHash[:]))
 			depositID, err := testStore.AddDeposit(ctx, deposit, nil)
 			require.NoError(t, err)

bridgectrl/hash.go

@@ -34,7 +34,7 @@ func generateZeroHashes(height uint8) [][KeyLen]byte {
 	return zeroHashes
 }
 
-func hashDeposit(deposit *etherman.Deposit) [KeyLen]byte {
+func HashDeposit(deposit *etherman.Deposit) [KeyLen]byte {
 	var res [KeyLen]byte
 	origNet := make([]byte, 4) //nolint:mnd
 	binary.BigEndian.PutUint32(origNet, uint32(deposit.OriginalNetwork))

bridgectrl/merkletree_test.go

@@ -77,7 +77,7 @@ func TestLeafHash(t *testing.T) {
 				DepositCount:       uint32(ti + 1), // nolint:gosec
 				Metadata:           common.FromHex(testVector.Metadata),
 			}
-			leafHash := hashDeposit(deposit)
+			leafHash := HashDeposit(deposit)
 			assert.Equal(t, testVector.ExpectedHash[2:], hex.EncodeToString(leafHash[:]))
 		})
 	}
@@ -134,7 +134,7 @@ func TestMTAddLeaf(t *testing.T) {
 			require.NoError(t, err)
 			assert.Equal(t, hex.EncodeToString(curRoot), testVector.CurrentRoot[2:])
 
-			leafHash := hashDeposit(deposit)
+			leafHash := HashDeposit(deposit)
 			err = mt.addLeaf(ctx, depositIDs[len(depositIDs)-1], leafHash, uint32(len(testVector.ExistingLeaves)), nil) // nolint:gosec
 			require.NoError(t, err)
 			newRoot, err := mt.getRoot(ctx, nil)
@@ -183,7 +183,7 @@ func TestMTGetProof(t *testing.T) {
 				}
 				depositID, err := testStore.AddDeposit(ctx, deposit, nil)
 				require.NoError(t, err)
-				leafHash := hashDeposit(deposit)
+				leafHash := HashDeposit(deposit)
 				if li == int(testVector.Index) {
 					cur = leafHash
 				}
@@ -396,7 +396,7 @@ func TestCheckMerkleProof(t *testing.T) {
 		DepositCount:       0,
 		Metadata:           []byte{},
 	}
-	leafHash := hashDeposit(deposit)
+	leafHash := HashDeposit(deposit)
 	smtProof := [][KeyLen]byte{
 		common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"),
 		common.HexToHash("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5"),
@@ -453,7 +453,7 @@ func TestCheckMerkleProof2(t *testing.T) {
 		DepositCount:       0,
 		Metadata:           []byte{},
 	}
-	leafBytes := hashDeposit(deposit)
+	leafBytes := HashDeposit(deposit)
 	leafHash := common.BytesToHash(leafBytes[:])
 	t.Log("leafHash: ", leafHash)
 	assert.Equal(t, expectedLeafHash, leafHash)

db/pgstorage/migrations/0020.sql

@@ -0,0 +1,29 @@
+-- +migrate Up
+
+CREATE TABLE IF NOT EXISTS sync.backward_let(
+    id                   BIGSERIAL,
+    block_id             BIGINT REFERENCES sync.block (id) ON DELETE CASCADE,
+    previous_deposit_cnt BIGINT,
+    previous_root        BYTEA,
+    new_deposit_cnt      BIGINT,
+    new_root             BYTEA,
+    PRIMARY KEY (id)
+);
+
+CREATE TABLE IF NOT EXISTS sync.set_unset_claim(
+    id               BIGSERIAL,
+    block_id         BIGINT REFERENCES sync.block (id) ON DELETE CASCADE,
+    mainnet_flag     BOOLEAN,
+    rollup_index     BIGINT,
+    index            BIGINT,
+    global_index     VARCHAR(255),
+    type             VARCHAR(255), -- "SET" or "UNSET"
+    PRIMARY KEY (id)
+);
+
+-- +migrate Down
+
+DROP TABLE IF EXISTS sync.backward_let;
+DROP TABLE IF EXISTS sync.set_unset_claim;
+
+

db/pgstorage/migrations/0020_test.go

@@ -0,0 +1,69 @@
+package migrations_test
+
+import (
+	"database/sql"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type migrationTest0020 struct{}
+
+func (m migrationTest0020) InsertData(db *sql.DB) error {
+	block := "INSERT INTO sync.block (id, block_num, block_hash, network_id) VALUES(1, 1, decode('C9B5033799ADF3739383A0489EFBE8A0D4D5E4478778A4F4304562FD51AE4C07','hex'), 0);"
+	if _, err := db.Exec(block); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (m migrationTest0020) RunAssertsAfterMigrationUp(t *testing.T, db *sql.DB) {
+	insertBackwardLET := `INSERT INTO sync.backward_let(block_id, previous_deposit_cnt, previous_root, new_deposit_cnt, new_root)
+		VALUES(1, 2, decode('A9B5033799ADF3739383A0489EFBE8A0D4D5E4478778A4F4304562FD51AE4C08','hex'), 1, decode('B9B5033799ADF3739383A0489EFBE8A0D4D5E4478778A4F4304562FD51AE4C09','hex'));`
+	_, err := db.Exec(insertBackwardLET)
+	assert.NoError(t, err)
+	insertSetClaim := `INSERT INTO sync.set_unset_claim(block_id, mainnet_flag, rollup_index, index, global_index, type)
+		VALUES(1, true, 0, 11, '18446744073709551627', 'SET');`
+	_, err = db.Exec(insertSetClaim)
+	assert.NoError(t, err)
+	insertUnSetClaim := `INSERT INTO sync.set_unset_claim(block_id, mainnet_flag, rollup_index, index, global_index, type)
+		VALUES(1, false, 4294967295, 4294967295, '18446744073709551615', 'UNSET');`
+	_, err = db.Exec(insertUnSetClaim)
+
+	assert.NoError(t, err)
+	var count uint32
+	selectCount := "SELECT count(*) FROM sync.backward_let"
+	err = db.QueryRow(selectCount).Scan(&count)
+	assert.NoError(t, err)
+	assert.Equal(t, uint32(1), count)
+
+	selectCount1 := "SELECT count(*) FROM sync.set_unset_claim WHERE type='SET'"
+	err = db.QueryRow(selectCount1).Scan(&count)
+	assert.NoError(t, err)
+	assert.Equal(t, uint32(1), count)
+
+	selectCount2 := "SELECT count(*) FROM sync.set_unset_claim WHERE type='UNSET'"
+	err = db.QueryRow(selectCount2).Scan(&count)
+	assert.NoError(t, err)
+	assert.Equal(t, uint32(1), count)
+
+	selectCount3 := "SELECT count(*) FROM sync.set_unset_claim"
+	err = db.QueryRow(selectCount3).Scan(&count)
+	assert.NoError(t, err)
+	assert.Equal(t, uint32(2), count)
+}
+
+func (m migrationTest0020) RunAssertsAfterMigrationDown(t *testing.T, db *sql.DB) {
+	var count uint32
+	selectCount := "SELECT count(*) FROM sync.backward_let"
+	err := db.QueryRow(selectCount).Scan(&count)
+	assert.Error(t, err)
+	
+	selectCount1 := "SELECT count(*) FROM sync.set_unset_claim"
+	err = db.QueryRow(selectCount1).Scan(&count)
+	assert.Error(t, err)
+}
+
+func TestMigration0020(t *testing.T) {
+	runMigrationTest(t, 20, migrationTest0020{})
+}

db/pgstorage/pgstorage.go

@@ -921,6 +921,50 @@ func (p *PostgresStorage) GetSyncStatus(ctx context.Context, dbTx interface{}) (
 	return status, nil
 }
 
+// ResetDeposits resets the state to a depositCount.
+func (p *PostgresStorage) ResetDeposits(ctx context.Context, depositCount uint32, networkID uint32, dbTx interface{}) error {
+	if networkID == 0 {
+		return errors.New("cannot reset L1 deposits")
+	}
+	const resetSQL = "DELETE FROM sync.deposit WHERE deposit_cnt >= $1 AND network_id = $2"
+	e := p.getExecQuerier(dbTx)
+	_, err := e.Exec(ctx, resetSQL, depositCount, networkID)
+	return err
+}
+
+// AddBackwardLET adds a new BackwardLET event to the db.
+func (p *PostgresStorage) AddBackwardLET(ctx context.Context, backwardLET *etherman.BackwardLET, dbTx interface{}) error {
+	const addExitRootSQL = "INSERT INTO sync.backward_let(block_id, previous_deposit_cnt, previous_root, new_deposit_cnt, new_root) VALUES ($1, $2, $3, $4, $5)"
+	e := p.getExecQuerier(dbTx)
+	_, err := e.Exec(ctx, addExitRootSQL, backwardLET.BlockID, backwardLET.PreviousDepositCount, backwardLET.PreviousRoot, backwardLET.NewDepositCount, backwardLET.NewRoot)
+	return err
+}
+
+// AddSetClaim adds a new SetClaim event to the db.
+func (p *PostgresStorage) AddSetClaim(ctx context.Context, setClaim *etherman.SetClaim, dbTx interface{}) error {
+	return p.addSetUnsetClaim(ctx, "SET", setClaim.BlockID, setClaim.MainnetFlag, setClaim.RollupIndex, setClaim.Index, setClaim.GlobalIndex, dbTx)
+}
+
+// AddUnsetClaim adds a new UnsetClaim event to the db.
+func (p *PostgresStorage) AddUnsetClaim(ctx context.Context, unsetClaim *etherman.UnsetClaim, dbTx interface{}) error {
+	return p.addSetUnsetClaim(ctx, "UNSET", unsetClaim.BlockID, unsetClaim.MainnetFlag, unsetClaim.RollupIndex, unsetClaim.Index, unsetClaim.GlobalIndex, dbTx)
+}
+
+func (p *PostgresStorage) addSetUnsetClaim(ctx context.Context, eventType string, blockID uint64, mainnetFlag bool, rollupIndex, index uint32, globalIndex *big.Int, dbTx interface{}) error {
+	const addExitRootSQL = "INSERT INTO sync.set_unset_claim(block_id, mainnet_flag, rollup_index, index, global_index, type) VALUES($1, $2, $3, $4, $5, $6)"
+	e := p.getExecQuerier(dbTx)
+	_, err := e.Exec(ctx, addExitRootSQL, blockID, mainnetFlag, rollupIndex, index, globalIndex.String(), eventType)
+	return err
+}
+
+// DeleteClaimByGlobalIndex resets the state to a depositCount.
+func (p *PostgresStorage) DeleteClaimByGlobalIndex(ctx context.Context, globalIndex *big.Int, networkID uint32, dbTx interface{}) error {
+	const resetSQL = "DELETE FROM sync.claim WHERE global_index = $1 AND network_id = $2"
+	e := p.getExecQuerier(dbTx)
+	_, err := e.Exec(ctx, resetSQL, globalIndex.String(), networkID)
+	return err
+}
+
 // UpdateDepositsStatusForTesting updates the ready_for_claim status of all deposits for testing.
 func (p *PostgresStorage) UpdateDepositsStatusForTesting(ctx context.Context, dbTx interface{}) error {
 	const updateDepositsStatusSQL = "UPDATE sync.deposit SET ready_for_claim = true;"