diff --git a/bridgesync/migrations/migrations.go b/bridgesync/migrations/migrations.go
index b0c611d8..588948b8 100644
--- a/bridgesync/migrations/migrations.go
+++ b/bridgesync/migrations/migrations.go
@@ -27,9 +27,8 @@ var bridgeMigrations = &migrate.MemoryMigrationSource{
 }
 
 func RunMigrations(dbPath string) error {
-	migs := append(
+	return db.RunMigrations(dbPath, &migrate.MemoryMigrationSource{Migrations: append(
 		bridgeMigrations.Migrations,
 		treeMigrations.Migrations.Migrations...,
-	)
-	return db.RunMigrations(dbPath, &migrate.MemoryMigrationSource{Migrations: migs})
+	)})
 }
diff --git a/bridgesync/processor.go b/bridgesync/processor.go
index 53d1b044..942ec9b1 100644
--- a/bridgesync/processor.go
+++ b/bridgesync/processor.go
@@ -120,34 +120,36 @@ func newProcessor(dbPath, loggerPrefix string) (*processor, error) {
 func (p *processor) GetBridges(
 	ctx context.Context, fromBlock, toBlock uint64,
 ) ([]Bridge, error) {
-	tx, err := p.db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
+	bridgePtrs := []*Bridge{}
+	bridgesIface, err := p.getTypeFromBlockToBlock(ctx, fromBlock, toBlock, "bridge", bridgePtrs)
 	if err != nil {
 		return nil, err
 	}
-	defer func() {
-		if err := tx.Rollback(); err != nil {
-			log.Warnf("error rolling back tx: %v", err)
-		}
-	}()
-
-	if err = p.isBlockProcessed(tx, toBlock); err != nil {
-		return nil, err
-	}
-
-	bridges := []*Bridge{}
-	err = meddler.QueryAll(tx, &bridges, `
-		SELECT * FROM bridge
-		WHERE block_num >= $1 AND block_num <= $2;
-	 `, fromBlock, toBlock)
-	if errors.Is(err, sql.ErrNoRows) {
-		return nil, ErrNotFound
+	bridges, ok := bridgesIface.([]Bridge)
+	if !ok {
+		return nil, errors.New("failed to convert from []*Bridge to []Bridge")
 	}
-	return db.SlicePtrsToSlice(bridges).([]Bridge), err
+	return bridges, nil
 }
 
 func (p *processor) GetClaims(
 	ctx context.Context, fromBlock, toBlock uint64,
 ) ([]Claim, error) {
+	claimPtrs := []*Claim{}
+	claimsIface, err := p.getTypeFromBlockToBlock(ctx, fromBlock, toBlock, "claim", claimPtrs)
+	if err != nil {
+		return nil, err
+	}
+	claims, ok := claimsIface.([]Claim)
+	if !ok {
+		return nil, errors.New("failed to convert from []*Claim to []Claim")
+	}
+	return claims, nil
+}
+
+func (p *processor) getTypeFromBlockToBlock(
+	ctx context.Context, fromBlock, toBlock uint64, table string, typeToQuery interface{},
+) (interface{}, error) {
 	tx, err := p.db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
 	if err != nil {
 		return nil, err
@@ -162,15 +164,18 @@ func (p *processor) GetClaims(
 		return nil, err
 	}
 
-	claims := []*Claim{}
-	err = meddler.QueryAll(tx, &claims, `
-		SELECT * FROM claim
+	err = meddler.QueryAll(tx, typeToQuery, `
+		SELECT * FROM `+table+`
 		WHERE block_num >= $1 AND block_num <= $2;
 	 `, fromBlock, toBlock)
-	if errors.Is(err, sql.ErrNoRows) {
-		return nil, ErrNotFound
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, ErrNotFound
+		}
+		return nil, err
 	}
-	return db.SlicePtrsToSlice(claims).([]Claim), err
+
+	return db.SlicePtrsToSlice(typeToQuery), nil
 }
 
 func (p *processor) isBlockProcessed(tx db.DBer, blockNum uint64) error {
@@ -249,7 +254,10 @@ func (p *processor) ProcessBlock(ctx context.Context, block sync.Block) error {
 		return err
 	}
 	for _, e := range block.Events {
-		event := e.(Event)
+		event, ok := e.(Event)
+		if !ok {
+			return errors.New("failed to convert sync.Block.Event to Event")
+		}
 		if event.Bridge != nil {
 			if err = p.exitTree.AddLeaf(tx, block.Num, event.Pos, types.Leaf{
 				Index: event.Bridge.DepositCount,
diff --git a/bridgesync/processor_test.go b/bridgesync/processor_test.go
index fd16f32c..5578cee5 100644
--- a/bridgesync/processor_test.go
+++ b/bridgesync/processor_test.go
@@ -397,7 +397,7 @@ var (
 type processAction interface {
 	method() string
 	desc() string
-	execute(t *testing.T) //nolint:thelper
+	execute(t *testing.T)
 }
 
 // GetClaims
@@ -470,7 +470,7 @@ func (a *getLastProcessedBlockAction) desc() string {
 	return a.description
 }
 
-func (a *getLastProcessedBlockAction) execute(t *testing.T) { //nolint:thelper
+func (a *getLastProcessedBlockAction) execute(t *testing.T) {
 	t.Helper()
 
 	actualLastProcessedBlock, actualErr := a.p.GetLastProcessedBlock(a.ctx)
@@ -495,7 +495,7 @@ func (a *reorgAction) desc() string {
 	return a.description
 }
 
-func (a *reorgAction) execute(t *testing.T) { //nolint:thelper
+func (a *reorgAction) execute(t *testing.T) {
 	t.Helper()
 
 	actualErr := a.p.Reorg(context.Background(), a.firstReorgedBlock)
@@ -519,7 +519,7 @@ func (a *processBlockAction) desc() string {
 	return a.description
 }
 
-func (a *processBlockAction) execute(t *testing.T) { //nolint:thelper
+func (a *processBlockAction) execute(t *testing.T) {
 	t.Helper()
 
 	actualErr := a.p.ProcessBlock(context.Background(), a.block)
@@ -529,7 +529,10 @@ func (a *processBlockAction) execute(t *testing.T) { //nolint:thelper
 func eventsToBridges(events []interface{}) []Bridge {
 	bridges := []Bridge{}
 	for _, event := range events {
-		e := event.(Event)
+		e, ok := event.(Event)
+		if !ok {
+			panic("should be ok")
+		}
 		if e.Bridge != nil {
 			bridges = append(bridges, *e.Bridge)
 		}
@@ -540,7 +543,10 @@ func eventsToBridges(events []interface{}) []Bridge {
 func eventsToClaims(events []interface{}) []Claim {
 	claims := []Claim{}
 	for _, event := range events {
-		e := event.(Event)
+		e, ok := event.(Event)
+		if !ok {
+			panic("should be ok")
+		}
 		if e.Claim != nil {
 			claims = append(claims, *e.Claim)
 		}
diff --git a/db/sqlite.go b/db/sqlite.go
index ef5ad9e7..e30e9e26 100644
--- a/db/sqlite.go
+++ b/db/sqlite.go
@@ -6,6 +6,10 @@ import (
 	_ "github.com/mattn/go-sqlite3"
 )
 
+const (
+	UniqueConstrain = 1555
+)
+
 // NewSQLiteDB creates a new SQLite DB
 func NewSQLiteDB(dbPath string) (*sql.DB, error) {
 	initMeddler()
diff --git a/tree/migrations/migrations.go b/tree/migrations/migrations.go
index ffdb1d0e..0b47c890 100644
--- a/tree/migrations/migrations.go
+++ b/tree/migrations/migrations.go
@@ -36,8 +36,8 @@ func MigrationsWithPrefix(prefix string) []*migrate.Migration {
 	return []*migrate.Migration{
 		{
 			Id:   prefix + "tree001",
-			Up:   []string{strings.Replace(mig001splitted[1], dbPrefixReplacer, prefix, -1)},
-			Down: []string{strings.Replace(mig001splitted[0], dbPrefixReplacer, prefix, -1)},
+			Up:   []string{strings.ReplaceAll(mig001splitted[1], dbPrefixReplacer, prefix)},
+			Down: []string{strings.ReplaceAll(mig001splitted[0], dbPrefixReplacer, prefix)},
 		},
 	}
 }
diff --git a/tree/tree.go b/tree/tree.go
index 6d10834b..3a75e844 100644
--- a/tree/tree.go
+++ b/tree/tree.go
@@ -9,7 +9,6 @@ import (
 	"github.com/0xPolygon/cdk/db"
 	"github.com/0xPolygon/cdk/tree/types"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/mattn/go-sqlite3"
 	"github.com/russross/meddler"
 	"golang.org/x/crypto/sha3"
 )
@@ -157,8 +156,7 @@ func (t *Tree) storeNodes(tx *db.Tx, nodes []types.TreeNode) error {
 	for i := 0; i < len(nodes); i++ {
 		if err := meddler.Insert(tx, t.rhtTable, &nodes[i]); err != nil {
 			if sqliteErr, ok := db.SQLiteErr(err); ok {
-				uniqueConstraint := sqlite3.ErrNoExtended(1555) // 1555 is the error code for primary key violation
-				if sqliteErr.ExtendedCode == uniqueConstraint {
+				if sqliteErr.ExtendedCode == db.UniqueConstrain {
 					// ignore repeated entries. This is likely to happen due to not
 					// cleaning RHT when reorg
 					continue