Feature/backward let endpoint + forwardLET implementation (#887)

* backwardLET endpoint

* ForwardLET

* ForwardLET working

* fix new endpoint

* linter

Author: ARR552

bridgectrl/pb/query.pb.go

@@ -29,8 +29,8 @@ func (m migrationTest0020) RunAssertsAfterMigrationUp(t *testing.T, db *sql.DB)
 	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)

bridgectrl/pb/query.pb.gw.go

@@ -0,0 +1,16 @@
+-- +migrate Up
+
+CREATE TABLE IF NOT EXISTS sync.forward_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,
+    new_raw_leaves       BYTEA,
+    PRIMARY KEY (id)
+);
+
+-- +migrate Down
+
+DROP TABLE IF EXISTS sync.forward_let;

bridgectrl/pb/query_grpc.pb.go

@@ -0,0 +1,42 @@
+package migrations_test
+
+import (
+	"database/sql"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type migrationTest0021 struct{}
+
+func (m migrationTest0021) 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 migrationTest0021) RunAssertsAfterMigrationUp(t *testing.T, db *sql.DB) {
+	insertForwardLET := `INSERT INTO sync.forward_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(insertForwardLET)
+	assert.NoError(t, err)
+	
+	var count uint32
+	selectCount := "SELECT count(*) FROM sync.forward_let"
+	err = db.QueryRow(selectCount).Scan(&count)
+	assert.NoError(t, err)
+	assert.Equal(t, uint32(1), count)
+}
+
+func (m migrationTest0021) RunAssertsAfterMigrationDown(t *testing.T, db *sql.DB) {
+	var count uint32
+	selectCount := "SELECT count(*) FROM sync.forward_let"
+	err := db.QueryRow(selectCount).Scan(&count)
+	assert.Error(t, err)
+}
+
+func TestMigration0021(t *testing.T) {
+	runMigrationTest(t, 21, migrationTest0021{})
+}

db/pgstorage/migrations/0020_test.go

@@ -940,6 +940,14 @@ func (p *PostgresStorage) AddBackwardLET(ctx context.Context, backwardLET *ether
 	return err
 }
 
+// AddForwardLET adds a new ForwardLET event to the db.
+func (p *PostgresStorage) AddForwardLET(ctx context.Context, forwardLET *etherman.ForwardLET, dbTx interface{}) error {
+	const addExitRootSQL = "INSERT INTO sync.forward_let(block_id, previous_deposit_cnt, previous_root, new_deposit_cnt, new_root, new_raw_leaves) VALUES ($1, $2, $3, $4, $5, $6)"
+	e := p.getExecQuerier(dbTx)
+	_, err := e.Exec(ctx, addExitRootSQL, forwardLET.BlockID, forwardLET.PreviousDepositCount, forwardLET.PreviousRoot, forwardLET.NewDepositCount, forwardLET.NewRoot, forwardLET.NewRawLeaves)
+	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)
@@ -965,6 +973,16 @@ func (p *PostgresStorage) DeleteClaimByGlobalIndex(ctx context.Context, globalIn
 	return err
 }
 
+func (p *PostgresStorage) GetLastComputedRoot(ctx context.Context, networkID uint32, dbTx interface{}) (common.Hash, error) {
+	const query = "SELECT root FROM mt.root WHERE network = $1 ORDER BY deposit_id desc LIMIT 1;"
+	var root common.Hash
+	err := p.getExecQuerier(dbTx).QueryRow(ctx, query, networkID).Scan(&root)
+	if err != nil {
+		return common.Hash{}, fmt.Errorf("error getting the root from db: %v", err)
+	}
+	return root, nil
+}
+
 // 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;"

db/pgstorage/migrations/0021.sql

@@ -361,6 +361,40 @@ func TestAddBackwardLET(t *testing.T) {
 	assert.Equal(t, uint32(1), count)
 }
 
+func TestAddForwardLET(t *testing.T) {
+	data := `INSERT INTO sync.block
+	(id, block_num, block_hash, network_id)
+	VALUES(1, 1, decode('5C7831','hex'), 0);
+	`
+	dbCfg := NewConfigFromEnv()
+	ctx := context.Background()
+	err := InitOrReset(ctx, dbCfg)
+	require.NoError(t, err)
+
+	store, err := NewPostgresStorage(ctx, dbCfg)
+	require.NoError(t, err)
+
+	_, err = store.Exec(ctx, data)
+	require.NoError(t, err)
+
+	fLET := &etherman.ForwardLET{
+		BlockID: 1,
+    	PreviousDepositCount: 3,
+    	PreviousRoot: common.HexToHash("0x6282FACE883070640F802CE8A2C42593AA18D3A691C61BA006EC477D6E5FEE1F"),
+    	NewDepositCount: 1,
+    	NewRoot: common.HexToHash("0xAA82FACE883070640F802CE8A2C42593AA18D3A691C61BA006EC477D6E5FEECC"),
+		NewRawLeaves: []byte("Random bytes to fill the db field"),
+	}
+	err = store.AddForwardLET(ctx, fLET, nil)
+	require.NoError(t, err)
+
+	var count uint32
+	selectCount := "SELECT count(*) FROM sync.forward_let"
+	err = store.QueryRow(ctx, selectCount).Scan(&count)
+	assert.NoError(t, err)
+	assert.Equal(t, uint32(1), count)
+}
+
 func TestAddSetUnsetClaim(t *testing.T) {
 	data := `INSERT INTO sync.block
 	(id, block_num, block_hash, network_id)