remove getbridge

bridgesync/bridgesync.go

@@ -203,18 +203,11 @@ func (s *BridgeSync) Start(ctx context.Context) {
 	s.driver.Sync(ctx)
 }
 
-func (s *BridgeSync) GetBridge(ctx context.Context, depositCount uint64) (Bridge, error) {
-	if s.processor.isHalted() {
-		return Bridge{}, sync.ErrInconsistentState
-	}
-	return s.processor.GetBridge(ctx, depositCount)
-}
-
-func (s *BridgeSync) GetBridgesPaged(ctx context.Context, page uint64, pageSize uint64) ([]Bridge, error) {
+func (s *BridgeSync) GetBridgesPaged(ctx context.Context, page, pageSize, depositCount uint64) ([]Bridge, error) {
 	if s.processor.isHalted() {
 		return nil, sync.ErrInconsistentState
 	}
-	return s.processor.GetBridgesPaged(ctx, page, pageSize)
+	return s.processor.GetBridgesPaged(ctx, page, pageSize, depositCount)
 }
 
 func (s *BridgeSync) GetLastProcessedBlock(ctx context.Context) (uint64, error) {

bridgesync/bridgesync_test.go

@@ -143,8 +143,5 @@ func TestGetBridgesPublishedTopLevel(t *testing.T) {
 	require.True(t, errors.Is(err, sync.ErrInconsistentState))
 }
 
-func TestGetBridge(t *testing.T) {
-}
-
 func TestGetBridgePaged(t *testing.T) {
 }

bridgesync/processor.go

@@ -160,9 +160,9 @@ func (p *processor) GetBridges(
 	return bridges, nil
 }
 
-func (p *processor) GetBridgesPaged(
-	ctx context.Context, page, pageSize uint64,
-) ([]Bridge, error) {
+func (p *processor) GetClaims(
+	ctx context.Context, fromBlock, toBlock uint64,
+) ([]Claim, error) {
 	tx, err := p.db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
 	if err != nil {
 		return nil, err
@@ -172,25 +172,25 @@ func (p *processor) GetBridgesPaged(
 			log.Warnf("error rolling back tx: %v", err)
 		}
 	}()
-	rows, err := p.queryPaged(tx, page, pageSize, "bridge")
+	rows, err := p.queryBlockRange(tx, fromBlock, toBlock, "claim")
 	if err != nil {
 		return nil, err
 	}
-	bridgePtrs := []*Bridge{}
-	if err = meddler.ScanAll(rows, &bridgePtrs); err != nil {
+	claimPtrs := []*Claim{}
+	if err = meddler.ScanAll(rows, &claimPtrs); err != nil {
 		return nil, err
 	}
-	bridgesIface := db.SlicePtrsToSlice(bridgePtrs)
-	bridges, ok := bridgesIface.([]Bridge)
+	claimsIface := db.SlicePtrsToSlice(claimPtrs)
+	claims, ok := claimsIface.([]Claim)
 	if !ok {
-		return nil, errors.New("failed to convert from []*Bridge to []Bridge")
+		return nil, errors.New("failed to convert from []*Claim to []Claim")
 	}
-	return bridges, nil
+	return claims, nil
 }
 
-func (p *processor) GetClaims(
-	ctx context.Context, fromBlock, toBlock uint64,
-) ([]Claim, error) {
+func (p *processor) GetBridgesPaged(
+	ctx context.Context, page, pageSize, depositCount uint64,
+) ([]Bridge, error) {
 	tx, err := p.db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
 	if err != nil {
 		return nil, err
@@ -200,27 +200,40 @@ func (p *processor) GetClaims(
 			log.Warnf("error rolling back tx: %v", err)
 		}
 	}()
-	rows, err := p.queryBlockRange(tx, fromBlock, toBlock, "claim")
+	orderBy := "deposit_count"
+	order := "DESC"
+	whereClause := ""
+	if depositCount > 0 {
+		whereClause = fmt.Sprintf("WHERE deposit_count = %d", depositCount)
+	}
+	rows, err := p.queryPaged(tx, page, pageSize, "bridge", orderBy, order, whereClause)
 	if err != nil {
 		return nil, err
 	}
-	claimPtrs := []*Claim{}
-	if err = meddler.ScanAll(rows, &claimPtrs); err != nil {
+	bridgePtrs := []*Bridge{}
+	if err = meddler.ScanAll(rows, &bridgePtrs); err != nil {
 		return nil, err
 	}
-	claimsIface := db.SlicePtrsToSlice(claimPtrs)
-	claims, ok := claimsIface.([]Claim)
+	bridgesIface := db.SlicePtrsToSlice(bridgePtrs)
+	bridges, ok := bridgesIface.([]Bridge)
 	if !ok {
-		return nil, errors.New("failed to convert from []*Claim to []Claim")
+		return nil, errors.New("failed to convert from []*Bridge to []Bridge")
 	}
-	return claims, nil
+	return bridges, nil
 }
 
-func (p *processor) queryPaged(tx db.Querier, page, pageSize uint64, table string) (*sql.Rows, error) {
-	rows, err := tx.Query(fmt.Sprintf(`
-		SELECT * FROM %s
-		LIMIT $1 OFFSET $2;
-	`, table), pageSize, (page-1)*pageSize)
+func (p *processor) queryPaged(
+	tx db.Querier,
+	page, pageSize uint64,
+	table, orderBy, order, whereClause string,
+) (*sql.Rows, error) {
+	rows, err := tx.Query(`
+		SELECT *
+		FROM $1
+		$2
+		ORDER BY $3 $4
+		LIMIT $5 OFFSET $6;
+	`, table, whereClause, orderBy, order, pageSize, (page-1)*pageSize)
 	if err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
 			return nil, db.ErrNotFound
@@ -258,16 +271,6 @@ func (p *processor) isBlockProcessed(tx db.Querier, blockNum uint64) error {
 	return nil
 }
 
-func (p *processor) GetBridge(ctx context.Context, depositCount uint64) (Bridge, error) {
-	var bridge Bridge
-	row := p.db.QueryRow("SELECT * FROM bridge where deposit_count = $1;", depositCount)
-	err := row.Scan(&bridge)
-	if errors.Is(err, sql.ErrNoRows) {
-		return Bridge{}, nil
-	}
-	return bridge, err
-}
-
 // GetLastProcessedBlock returns the last processed block by the processor, including blocks
 // that don't have events
 func (p *processor) GetLastProcessedBlock(ctx context.Context) (uint64, error) {

rpc/bridge.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/0xPolygon/cdk-rpc/rpc"
+	"github.com/agglayer/aggkit/bridgesync"
 	"github.com/agglayer/aggkit/claimsponsor"
 	"github.com/agglayer/aggkit/log"
 	"github.com/agglayer/aggkit/rpc/types"
@@ -148,39 +149,14 @@ func (b *BridgeEndpoints) InjectedInfoAfterIndex(networkID uint32, l1InfoTreeInd
 	)
 }
 
-func (b *BridgeEndpoints) GetBridge(networkID uint32, depositCount uint64) (interface{}, rpc.Error) {
-	ctx, cancel := context.WithTimeout(context.Background(), b.readTimeout)
-	defer cancel()
-
-	// TODO - Do we need metrics?
-
-	if networkID == 0 {
-		bridge, err := b.bridgeL1.GetBridge(ctx, depositCount)
-		if err != nil {
-			return nil, rpc.NewRPCError(rpc.DefaultErrorCode, fmt.Sprintf("failed to get deposit, error: %s", err))
-		}
-		return bridge, nil
-	} else if networkID == b.networkID {
-		bridge, err := b.bridgeL2.GetBridge(ctx, depositCount)
-		if err != nil {
-			return nil, rpc.NewRPCError(rpc.DefaultErrorCode, fmt.Sprintf("failed to get deposit, error: %s", err))
-		}
-		return bridge, nil
-	}
-	return nil, rpc.NewRPCError(
-		rpc.DefaultErrorCode,
-		fmt.Sprintf("this client does not support network %d", networkID),
-	)
-}
-
-func (b *BridgeEndpoints) GetBridges(networkID uint32, page uint64, pageSize uint64) (interface{}, rpc.Error) {
+func (b *BridgeEndpoints) GetBridges(page, pageSize, depositCount, networkID uint64) (interface{}, rpc.Error) {
 	// Force valid page: must be at least 1
 	if page < 1 {
 		page = 1
 	}
 
-	// pageSize must be in [1..50]; otherwise, default to 20
-	if pageSize < 1 || pageSize > 50 {
+	// pageSize must be in [1..200]; otherwise, default to 20
+	if pageSize < 1 || pageSize > 200 {
 		pageSize = 20
 	}
 
@@ -189,9 +165,27 @@ func (b *BridgeEndpoints) GetBridges(networkID uint32, page uint64, pageSize uin
 
 	// TODO - Do we need metrics?
 
-	bridges, err := b.bridgeL1.GetBridgesPaged(ctx, page, pageSize)
-	if err != nil {
-		return nil, rpc.NewRPCError(rpc.DefaultErrorCode, fmt.Sprintf("failed to get deposit, error: %s", err))
+	var (
+		bridges []bridgesync.Bridge
+		err     error
+	)
+
+	switch {
+	case networkID == 0:
+		bridges, err = b.bridgeL1.GetBridgesPaged(ctx, page, pageSize, depositCount)
+		if err != nil {
+			return nil, rpc.NewRPCError(rpc.DefaultErrorCode, fmt.Sprintf("failed to get deposit, error: %s", err))
+		}
+	case networkID == uint64(b.networkID):
+		bridges, err = b.bridgeL2.GetBridgesPaged(ctx, page, pageSize, depositCount)
+		if err != nil {
+			return nil, rpc.NewRPCError(rpc.DefaultErrorCode, fmt.Sprintf("failed to get deposit, error: %s", err))
+		}
+	default:
+		return zeroHex, rpc.NewRPCError(
+			rpc.DefaultErrorCode,
+			fmt.Sprintf("this client does not support network %d", networkID),
+		)
 	}
 	return bridges, nil
 }

rpc/bridge_interfaces.go

@@ -15,8 +15,7 @@ import (
 type Bridger interface {
 	GetProof(ctx context.Context, depositCount uint32, localExitRoot common.Hash) (tree.Proof, error)
 	GetRootByLER(ctx context.Context, ler common.Hash) (*tree.Root, error)
-	GetBridge(ctx context.Context, depositCount uint64) (bridgesync.Bridge, error)
-	GetBridgesPaged(ctx context.Context, page uint64, pageSize uint64) ([]bridgesync.Bridge, error)
+	GetBridgesPaged(ctx context.Context, page, pageSize, depositCount uint64) ([]bridgesync.Bridge, error)
 }
 
 type LastGERer interface {