Ler2block

bridgesync/bridgesync.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/0xPolygon/cdk/etherman"
 	"github.com/0xPolygon/cdk/sync"
+	tree "github.com/0xPolygon/cdk/tree/types"
 	"github.com/ethereum/go-ethereum/common"
 )
 
@@ -97,7 +98,7 @@ func newBridgeSync(
 	maxRetryAttemptsAfterError int,
 	syncFullClaims bool,
 ) (*BridgeSync, error) {
-	processor, err := newProcessor(ctx, dbPath, l1OrL2ID)
+	processor, err := newProcessor(dbPath, l1OrL2ID)
 	if err != nil {
 		return nil, err
 	}
@@ -155,14 +156,26 @@ func (s *BridgeSync) GetLastProcessedBlock(ctx context.Context) (uint64, error)
 	return s.processor.GetLastProcessedBlock(ctx)
 }
 
-func (s *BridgeSync) GetBridgeIndexByRoot(ctx context.Context, root common.Hash) (uint32, error) {
-	return s.processor.exitTree.GetIndexByRoot(ctx, root)
+func (s *BridgeSync) GetBridgeRootByHash(ctx context.Context, root common.Hash) (tree.Root, error) {
+	return s.processor.exitTree.GetRootByHash(ctx, root)
 }
 
-func (s *BridgeSync) GetClaimsAndBridges(ctx context.Context, fromBlock, toBlock uint64) ([]Event, error) {
-	return s.processor.GetClaimsAndBridges(ctx, fromBlock, toBlock)
+func (s *BridgeSync) GetClaims(ctx context.Context, fromBlock, toBlock uint64) ([]Claim, error) {
+	return s.processor.GetClaims(ctx, fromBlock, toBlock)
+}
+
+func (s *BridgeSync) GetBridges(ctx context.Context, fromBlock, toBlock uint64) ([]Bridge, error) {
+	return s.processor.GetBridges(ctx, fromBlock, toBlock)
 }
 
 func (s *BridgeSync) GetProof(ctx context.Context, depositCount uint32, localExitRoot common.Hash) ([32]common.Hash, error) {
 	return s.processor.exitTree.GetProof(ctx, depositCount, localExitRoot)
 }
+
+func (p *processor) GetBlockByLER(ctx context.Context, ler common.Hash) (uint64, error) {
+	root, err := p.exitTree.GetRootByHash(ctx, ler)
+	if err != nil {
+		return 0, err
+	}
+	return root.BlockNum, nil
+}

bridgesync/downloader.go

@@ -10,7 +10,7 @@ import (
 	"github.com/0xPolygon/cdk-contracts-tooling/contracts/etrog/polygonzkevmbridgev2"
 	rpcTypes "github.com/0xPolygon/cdk-rpc/types"
 	"github.com/0xPolygon/cdk/sync"
-	"github.com/0xPolygon/cdk/tree"
+	tree "github.com/0xPolygon/cdk/tree/types"
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
@@ -57,6 +57,8 @@ func buildAppender(client EthClienter, bridge common.Address, syncFullClaims boo
 			)
 		}
 		b.Events = append(b.Events, Event{Bridge: &Bridge{
+			BlockNum:           b.Num,
+			BlockPos:           uint64(l.Index),
 			LeafType:           bridge.LeafType,
 			OriginNetwork:      bridge.OriginNetwork,
 			OriginAddress:      bridge.OriginAddress,
@@ -78,6 +80,8 @@ func buildAppender(client EthClienter, bridge common.Address, syncFullClaims boo
 			)
 		}
 		claim := &Claim{
+			BlockNum:           b.Num,
+			BlockPos:           uint64(l.Index),
 			GlobalIndex:        claimEvent.GlobalIndex,
 			OriginNetwork:      claimEvent.OriginNetwork,
 			OriginAddress:      claimEvent.OriginAddress,
@@ -100,6 +104,8 @@ func buildAppender(client EthClienter, bridge common.Address, syncFullClaims boo
 			)
 		}
 		claim := &Claim{
+			BlockNum:           b.Num,
+			BlockPos:           uint64(l.Index),
 			GlobalIndex:        big.NewInt(int64(claimEvent.Index)),
 			OriginNetwork:      claimEvent.OriginNetwork,
 			OriginAddress:      claimEvent.OriginAddress,

bridgesync/e2e_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"math/big"
+	"path"
 	"testing"
 	"time"
 
@@ -45,7 +46,7 @@ func newSimulatedClient(t *testing.T, auth *bind.TransactOpts) (
 
 func TestBridgeEventE2E(t *testing.T) {
 	ctx := context.Background()
-	dbPathSyncer := t.TempDir()
+	dbPathSyncer := path.Join(t.TempDir(), "file::memory:?cache=shared")
 	dbPathReorg := t.TempDir()
 	privateKey, err := crypto.GenerateKey()
 	require.NoError(t, err)
@@ -65,6 +66,7 @@ func TestBridgeEventE2E(t *testing.T) {
 	expectedBridges := []bridgesync.Bridge{}
 	for i := 0; i < 100; i++ {
 		bridge := bridgesync.Bridge{
+			BlockNum:           uint64(2 + i),
 			Amount:             big.NewInt(0),
 			DepositCount:       uint32(i),
 			DestinationNetwork: 3,
@@ -107,14 +109,8 @@ func TestBridgeEventE2E(t *testing.T) {
 	// Get bridges
 	lastBlock, err := client.Client().BlockNumber(ctx)
 	require.NoError(t, err)
-	events, err := syncer.GetClaimsAndBridges(ctx, 0, lastBlock)
+	actualBridges, err := syncer.GetBridges(ctx, 0, lastBlock)
 	require.NoError(t, err)
-	actualBridges := []bridgesync.Bridge{}
-	for _, event := range events {
-		if event.Bridge != nil {
-			actualBridges = append(actualBridges, *event.Bridge)
-		}
-	}
 
 	// Assert bridges
 	require.Equal(t, expectedBridges, actualBridges)

bridgesync/migrations/bridgesync0001.sql

@@ -0,0 +1,42 @@
+-- +migrate Down
+DROP TABLE IF EXISTS block;
+DROP TABLE IF EXISTS claim;
+DROP TABLE IF EXISTS bridge;
+
+-- +migrate Up
+CREATE TABLE block (
+    num   BIGINT PRIMARY KEY
+);
+
+CREATE TABLE bridge (
+	block_num           INTEGER NOT NULL REFERENCES block(num) ON DELETE CASCADE,
+	block_pos           INTEGER NOT NULL,
+	leaf_type           INTEGER NOT NULL,
+	origin_network      INTEGER NOT NULL,
+	origin_address      VARCHAR NOT NULL,
+	destination_network INTEGER NOT NULL,
+	destination_address VARCHAR NOT NULL,
+	amount              DECIMAL(78, 0) NOT NULL,
+	metadata            BLOB,
+	deposit_count       INTEGER NOT NULL,
+	PRIMARY KEY (block_num, block_pos)
+);
+
+CREATE TABLE claim (
+	block_num               INTEGER NOT NULL REFERENCES block(num) ON DELETE CASCADE,
+	block_pos               INTEGER NOT NULL,
+	global_index            DECIMAL(78, 0) NOT NULL,
+	origin_network          INTEGER NOT NULL,
+	origin_address          VARCHAR NOT NULL,
+	destination_address     VARCHAR NOT NULL,
+	amount                  DECIMAL(78, 0) NOT NULL,
+	proof_local_exit_root   VARCHAR,
+	proof_rollup_exit_root  VARCHAR,
+	mainnet_exit_root       VARCHAR,
+	rollup_exit_root        VARCHAR,
+	global_exit_root        VARCHAR,
+	destination_network     INTEGER NOT NULL,
+	metadata                BLOB,
+	is_message              BOOLEAN,
+	PRIMARY KEY (block_num, block_pos)
+);

bridgesync/migrations/bridgesync0001_test.go

@@ -0,0 +1,61 @@
+package migrations
+
+import (
+	"context"
+	"path"
+	"testing"
+
+	"github.com/0xPolygon/cdk/db"
+	"github.com/stretchr/testify/require"
+)
+
+func Test001(t *testing.T) {
+	dbPath := path.Join(t.TempDir(), "file::memory:?cache=shared")
+
+	err := RunMigrations(dbPath)
+	require.NoError(t, err)
+	db, err := db.NewSQLiteDB(dbPath)
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	tx, err := db.BeginTx(ctx, nil)
+	require.NoError(t, err)
+
+	_, err = tx.Exec(`
+		INSERT INTO block (num) VALUES (1);
+
+		INSERT INTO bridge (
+			block_num,
+			block_pos,
+			leaf_type,
+			origin_network,
+			origin_address,
+			destination_network,
+			destination_address,
+			amount,
+			metadata,
+			deposit_count
+		) VALUES (1, 0, 0, 0, '0x0000', 0, '0x0000', 0, NULL, 0);
+
+		INSERT INTO claim (
+			block_num,
+			block_pos,
+    		global_index,
+			origin_network,
+			origin_address,
+			destination_address,
+			amount,
+			proof_local_exit_root,
+			proof_rollup_exit_root,
+			mainnet_exit_root,
+			rollup_exit_root,
+			global_exit_root,
+			destination_network,
+			metadata,
+			is_message
+		) VALUES (1, 0, 0, 0, '0x0000', '0x0000', 0, '0x000,0x000', '0x000,0x000', '0x000', '0x000', '0x0', 0, NULL, FALSE);
+	`)
+	require.NoError(t, err)
+	err = tx.Commit()
+	require.NoError(t, err)
+}

bridgesync/migrations/migrations.go

@@ -0,0 +1,35 @@
+package migrations
+
+import (
+	"strings"
+
+	"github.com/0xPolygon/cdk/db"
+	treeMigrations "github.com/0xPolygon/cdk/tree/migrations"
+	migrate "github.com/rubenv/sql-migrate"
+
+	_ "embed"
+)
+
+const upDownSeparator = "-- +migrate Up"
+
+//go:embed bridgesync0001.sql
+var mig001 string
+var mig001splitted = strings.Split(mig001, upDownSeparator)
+
+var bridgeMigrations = &migrate.MemoryMigrationSource{
+	Migrations: []*migrate.Migration{
+		{
+			Id:   "bridgesync001",
+			Up:   []string{mig001splitted[1]},
+			Down: []string{mig001splitted[0]},
+		},
+	},
+}
+
+func RunMigrations(dbPath string) error {
+	migs := append(
+		bridgeMigrations.Migrations,
+		treeMigrations.Migrations.Migrations...,
+	)
+	return db.RunMigrations(dbPath, &migrate.MemoryMigrationSource{Migrations: migs})
+}