indexer: Upgrade L1 services (#3667)

indexer/indexer.go

@@ -22,7 +22,7 @@ import (
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rpc"
-	sentry "github.com/getsentry/sentry-go"
+	"github.com/getsentry/sentry-go"
 	"github.com/gorilla/mux"
 	"github.com/urfave/cli"
 )
@@ -169,7 +169,6 @@ func NewIndexer(cfg Config, gitVersion string) (*Indexer, error) {
 		ConfDepth:          cfg.ConfDepth,
 		MaxHeaderBatchSize: cfg.MaxHeaderBatchSize,
 		StartBlockNumber:   cfg.StartBlockNumber,
-		StartBlockHash:     cfg.StartBlockHash,
 	})
 	if err != nil {
 		return nil, err

indexer/metrics/metrics.go

@@ -21,6 +21,8 @@ type Metrics struct {
 
 	WithdrawalsCount *prometheus.CounterVec
 
+	StateBatchesCount prometheus.Counter
+
 	L1CatchingUp prometheus.Gauge
 
 	L2CatchingUp prometheus.Gauge
@@ -72,6 +74,12 @@ func NewMetrics(monitoredTokens map[string]string) *Metrics {
 			"symbol",
 		}),
 
+		StateBatchesCount: promauto.NewCounter(prometheus.CounterOpts{
+			Name:      "state_batches_count",
+			Help:      "The number of state batches indexed.",
+			Namespace: metricsNamespace,
+		}),
+
 		L1CatchingUp: promauto.NewGauge(prometheus.GaugeOpts{
 			Name:      "l1_catching_up",
 			Help:      "Whether or not L1 is far behind the chain tip.",
@@ -160,6 +168,10 @@ func (m *Metrics) RecordWithdrawal(addr common.Address) {
 	m.WithdrawalsCount.WithLabelValues(sym).Inc()
 }
 
+func (m *Metrics) RecordStateBatches(count int) {
+	m.StateBatchesCount.Add(float64(count))
+}
+
 func (m *Metrics) SetL1CatchingUp(state bool) {
 	var catchingUp float64
 	if state {

indexer/services/l1/bridge/bridge.go

@@ -5,10 +5,10 @@ import (
 	"errors"
 	"math/big"
 
+	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
 	"github.com/ethereum-optimism/optimism/indexer/db"
+	"github.com/ethereum-optimism/optimism/indexer/services"
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
-
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
@@ -19,7 +19,7 @@ type DepositsMap map[common.Hash][]db.Deposit
 
 // WithdrawalsMap is a collection of withdrawal objects keyed
 // on block hashes.
-type WithdrawalsMap map[common.Hash][]db.Withdrawal
+type InitiatedWithdrawalMap map[common.Hash][]db.Withdrawal
 
 // FinalizedWithdrawalsMap is a collection of finalized withdrawal
 // objected keyed on block hashes.
@@ -27,80 +27,63 @@ type FinalizedWithdrawalsMap map[common.Hash][]db.FinalizedWithdrawal
 
 type Bridge interface {
 	Address() common.Address
-	GetDepositsByBlockRange(uint64, uint64) (DepositsMap, error)
-	GetWithdrawalsByBlockRange(uint64, uint64) (WithdrawalsMap, error)
+	GetDepositsByBlockRange(context.Context, uint64, uint64) (DepositsMap, error)
 	String() string
 }
 
 type implConfig struct {
 	name string
 	impl string
-	addr string
-}
-
-var defaultBridgeCfgs = map[uint64][]*implConfig{
-	// Devnet
-	900: {
-		{"Standard", "StandardBridge", predeploys.DevL1StandardBridge},
-		{"ETH", "ETHBridge", predeploys.DevL1StandardBridge},
-	},
-	// Goerli
-	5: {
-		{"Standard", "StandardBridge", "0xFf94B6C486350aD92561Ba09bad3a59df764Da92"},
-		{"ETH", "ETHBridge", "0xFf94B6C486350aD92561Ba09bad3a59df764Da92"},
-	},
+	addr common.Address
 }
 
 var customBridgeCfgs = map[uint64][]*implConfig{
 	// Mainnet
 	1: {
-		{"BitBTC", "StandardBridge", "0xaBA2c5F108F7E820C049D5Af70B16ac266c8f128"},
-		{"DAI", "StandardBridge", "0x10E6593CDda8c58a1d0f14C5164B376352a55f2F"},
+		{"BitBTC", "StandardBridge", common.HexToAddress("0xaBA2c5F108F7E820C049D5Af70B16ac266c8f128")},
+		{"DAI", "StandardBridge", common.HexToAddress("0x10E6593CDda8c58a1d0f14C5164B376352a55f2F")},
+		{"wstETH", "StandardBridge", common.HexToAddress("0x76943C0D61395d8F2edF9060e1533529cAe05dE6")},
 	},
 	// Kovan
 	42: {
-		{"BitBTC", "StandardBridge", "0x0b651A42F32069d62d5ECf4f2a7e5Bd3E9438746"},
-		{"USX", "StandardBridge", "0x40E862341b2416345F02c41Ac70df08525150dC7"},
-		{"DAI", "StandardBridge", "0xb415e822C4983ecD6B1c1596e8a5f976cf6CD9e3"},
+		{"BitBTC", "StandardBridge", common.HexToAddress("0x0b651A42F32069d62d5ECf4f2a7e5Bd3E9438746")},
+		{"USX", "StandardBridge", common.HexToAddress("0x40E862341b2416345F02c41Ac70df08525150dC7")},
+		{"DAI", "StandardBridge", common.HexToAddress("0xb415e822C4983ecD6B1c1596e8a5f976cf6CD9e3")},
+		{"wstETH", "StandardBridge", common.HexToAddress("0x65321bf24210b81500230dCEce14Faa70a9f50a7")},
 	},
 }
 
-func BridgesByChainID(chainID *big.Int, client bind.ContractBackend, ctx context.Context) (map[string]Bridge, error) {
-	allCfgs := make([]*implConfig, 0)
-	allCfgs = append(allCfgs, defaultBridgeCfgs[chainID.Uint64()]...)
+func BridgesByChainID(chainID *big.Int, client bind.ContractBackend, addrs services.AddressManager) (map[string]Bridge, error) {
+	l1SBAddr, _ := addrs.L1StandardBridge()
+	allCfgs := []*implConfig{
+		{"Standard", "StandardBridge", l1SBAddr},
+		{"ETH", "ETHBridge", l1SBAddr},
+	}
 	allCfgs = append(allCfgs, customBridgeCfgs[chainID.Uint64()]...)
 
 	bridges := make(map[string]Bridge)
 	for _, bridge := range allCfgs {
 		switch bridge.impl {
 		case "StandardBridge":
-			l1StandardBridgeAddress := common.HexToAddress(bridge.addr)
-			l1StandardBridgeFilter, err := bindings.NewL1StandardBridgeFilterer(l1StandardBridgeAddress, client)
+			l1SB, err := bindings.NewL1StandardBridge(bridge.addr, client)
 			if err != nil {
 				return nil, err
 			}
-
 			standardBridge := &StandardBridge{
 				name:     bridge.name,
-				ctx:      ctx,
-				address:  l1StandardBridgeAddress,
-				client:   client,
-				filterer: l1StandardBridgeFilter,
+				address:  bridge.addr,
+				contract: l1SB,
 			}
 			bridges[bridge.name] = standardBridge
 		case "ETHBridge":
-			l1StandardBridgeAddress := common.HexToAddress(bridge.addr)
-			l1EthBridgeFilter, err := bindings.NewL1StandardBridgeFilterer(l1StandardBridgeAddress, client)
+			l1SB, err := bindings.NewL1StandardBridge(bridge.addr, client)
 			if err != nil {
 				return nil, err
 			}
-
 			ethBridge := &EthBridge{
 				name:     bridge.name,
-				ctx:      ctx,
-				address:  l1StandardBridgeAddress,
-				client:   client,
-				filterer: l1EthBridgeFilter,
+				address:  bridge.addr,
+				contract: l1SB,
 			}
 			bridges[bridge.name] = ethBridge
 		default:
@@ -109,3 +92,12 @@ func BridgesByChainID(chainID *big.Int, client bind.ContractBackend, ctx context
 	}
 	return bridges, nil
 }
+
+func StateCommitmentChainScanner(client bind.ContractFilterer, addrs services.AddressManager) (*scc.StateCommitmentChainFilterer, error) {
+	sccAddr, _ := addrs.StateCommitmentChain()
+	filter, err := scc.NewStateCommitmentChainFilterer(sccAddr, client)
+	if err != nil {
+		return nil, err
+	}
+	return filter, nil
+}

indexer/services/l1/bridge/bridge.go.orig

+package bridge
+
+import (
+	"context"
+	"errors"
+	"math/big"
+
+	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
+	"github.com/ethereum-optimism/optimism/indexer/db"
+	"github.com/ethereum-optimism/optimism/indexer/services"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+// DepositsMap is a collection of deposit objects keyed
+// on block hashes.
+type DepositsMap map[common.Hash][]db.Deposit
+<<<<<<< HEAD
+
+// WithdrawalsMap is a collection of withdrawal objects keyed
+// on block hashes.
+type WithdrawalsMap map[common.Hash][]db.Withdrawal
+
+// FinalizedWithdrawalsMap is a collection of finalized withdrawal
+// objected keyed on block hashes.
+=======
+type InitiatedWithdrawalMap map[common.Hash][]db.Withdrawal
+>>>>>>> 22c039efc (indexer: Upgrade L1 services)
+type FinalizedWithdrawalsMap map[common.Hash][]db.FinalizedWithdrawal
+
+type Bridge interface {
+	Address() common.Address
+	GetDepositsByBlockRange(context.Context, uint64, uint64) (DepositsMap, error)
+	String() string
+}
+
+type implConfig struct {
+	name string
+	impl string
+	addr common.Address
+}
+
+var customBridgeCfgs = map[uint64][]*implConfig{
+	// Mainnet
+	1: {
+		{"BitBTC", "StandardBridge", common.HexToAddress("0xaBA2c5F108F7E820C049D5Af70B16ac266c8f128")},
+		{"DAI", "StandardBridge", common.HexToAddress("0x10E6593CDda8c58a1d0f14C5164B376352a55f2F")},
+		{"wstETH", "StandardBridge", common.HexToAddress("0x76943C0D61395d8F2edF9060e1533529cAe05dE6")},
+	},
+	// Kovan
+	42: {
+		{"BitBTC", "StandardBridge", common.HexToAddress("0x0b651A42F32069d62d5ECf4f2a7e5Bd3E9438746")},
+		{"USX", "StandardBridge", common.HexToAddress("0x40E862341b2416345F02c41Ac70df08525150dC7")},
+		{"DAI", "StandardBridge", common.HexToAddress("0xb415e822C4983ecD6B1c1596e8a5f976cf6CD9e3")},
+		{"wstETH", "StandardBridge", common.HexToAddress("0x65321bf24210b81500230dCEce14Faa70a9f50a7")},
+	},
+}
+
+func BridgesByChainID(chainID *big.Int, client bind.ContractBackend, addrs services.AddressManager) (map[string]Bridge, error) {
+	l1SBAddr, _ := addrs.L1StandardBridge()
+	allCfgs := []*implConfig{
+		{"Standard", "StandardBridge", l1SBAddr},
+		{"ETH", "ETHBridge", l1SBAddr},
+	}
+	allCfgs = append(allCfgs, customBridgeCfgs[chainID.Uint64()]...)
+
+	bridges := make(map[string]Bridge)
+	for _, bridge := range allCfgs {
+		switch bridge.impl {
+		case "StandardBridge":
+			l1SB, err := bindings.NewL1StandardBridge(bridge.addr, client)
+			if err != nil {
+				return nil, err
+			}
+			standardBridge := &StandardBridge{
+				name:     bridge.name,
+				address:  bridge.addr,
+				contract: l1SB,
+			}
+			bridges[bridge.name] = standardBridge
+		case "ETHBridge":
+			l1SB, err := bindings.NewL1StandardBridge(bridge.addr, client)
+			if err != nil {
+				return nil, err
+			}
+			ethBridge := &EthBridge{
+				name:     bridge.name,
+				address:  bridge.addr,
+				contract: l1SB,
+			}
+			bridges[bridge.name] = ethBridge
+		default:
+			return nil, errors.New("unsupported bridge")
+		}
+	}
+	return bridges, nil
+}
+
+func StateCommitmentChainScanner(client bind.ContractFilterer, addrs services.AddressManager) (*scc.StateCommitmentChainFilterer, error) {
+	sccAddr, _ := addrs.StateCommitmentChain()
+	filter, err := scc.NewStateCommitmentChainFilterer(sccAddr, client)
+	if err != nil {
+		return nil, err
+	}
+	return filter, nil
+}

indexer/services/l1/bridge/eth_bridge.go

@@ -5,33 +5,40 @@ import (
 
 	"github.com/ethereum-optimism/optimism/indexer/db"
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-service/backoff"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
 
 type EthBridge struct {
 	name     string
-	ctx      context.Context
 	address  common.Address
-	client   bind.ContractFilterer
-	filterer *bindings.L1StandardBridgeFilterer
+	contract *bindings.L1StandardBridge
 }
 
 func (e *EthBridge) Address() common.Address {
 	return e.address
 }
 
-func (e *EthBridge) GetDepositsByBlockRange(start, end uint64) (DepositsMap, error) {
+func (e *EthBridge) GetDepositsByBlockRange(ctx context.Context, start, end uint64) (DepositsMap, error) {
 	depositsByBlockhash := make(DepositsMap)
+	opts := &bind.FilterOpts{
+		Context: ctx,
+		Start:   start,
+		End:     &end,
+	}
 
-	iter, err := FilterETHDepositInitiatedWithRetry(e.ctx, e.filterer, &bind.FilterOpts{
-		Start: start,
-		End:   &end,
+	var iter *bindings.L1StandardBridgeETHDepositInitiatedIterator
+	err := backoff.Do(3, backoff.Exponential(), func() error {
+		var err error
+		iter, err = e.contract.FilterETHDepositInitiated(opts, nil, nil)
+		return err
 	})
 	if err != nil {
-		logger.Error("Error fetching filter", "err", err)
+		return nil, err
 	}
 
+	defer iter.Close()
 	for iter.Next() {
 		depositsByBlockhash[iter.Event.Raw.BlockHash] = append(
 			depositsByBlockhash[iter.Event.Raw.BlockHash], db.Deposit{
@@ -43,41 +50,8 @@ func (e *EthBridge) GetDepositsByBlockRange(start, end uint64) (DepositsMap, err
 				LogIndex:    iter.Event.Raw.Index,
 			})
 	}
-	if err := iter.Error(); err != nil {
-		return nil, err
-	}
-
-	return depositsByBlockhash, nil
-}
-
-func (s *EthBridge) GetWithdrawalsByBlockRange(start, end uint64) (WithdrawalsMap, error) {
-	withdrawalsByBlockHash := make(WithdrawalsMap)
-
-	iter, err := FilterETHWithdrawalFinalizedWithRetry(s.ctx, s.filterer, &bind.FilterOpts{
-		Start: start,
-		End:   &end,
-	})
-
-	if err != nil {
-		logger.Error("Error fetching filter", "err", err)
-	}
-
-	for iter.Next() {
-		withdrawalsByBlockHash[iter.Event.Raw.BlockHash] = append(
-			withdrawalsByBlockHash[iter.Event.Raw.BlockHash], db.Withdrawal{
-				TxHash:      iter.Event.Raw.TxHash,
-				FromAddress: iter.Event.From,
-				ToAddress:   iter.Event.To,
-				Amount:      iter.Event.Amount,
-				Data:        iter.Event.ExtraData,
-				LogIndex:    iter.Event.Raw.Index,
-			})
-	}
-	if err := iter.Error(); err != nil {
-		return nil, err
-	}
 
-	return withdrawalsByBlockHash, nil
+	return depositsByBlockhash, iter.Error()
 }
 
 func (e *EthBridge) String() string {

indexer/services/l1/bridge/filter.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"time"
 
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 )
 
@@ -12,61 +12,13 @@ import (
 // calls.
 var clientRetryInterval = 5 * time.Second
 
-// FilterETHDepositInitiatedWithRetry retries the given func until it succeeds,
+// FilterStateBatchAppendedWithRetry retries the given func until it succeeds,
 // waiting for clientRetryInterval duration after every call.
-func FilterETHDepositInitiatedWithRetry(ctx context.Context, filterer *bindings.L1StandardBridgeFilterer, opts *bind.FilterOpts) (*bindings.L1StandardBridgeETHDepositInitiatedIterator, error) {
+func FilterStateBatchAppendedWithRetry(ctx context.Context, filterer *scc.StateCommitmentChainFilterer, opts *bind.FilterOpts) (*scc.StateCommitmentChainStateBatchAppendedIterator, error) {
 	for {
 		ctxt, cancel := context.WithTimeout(ctx, DefaultConnectionTimeout)
 		opts.Context = ctxt
-		res, err := filterer.FilterETHDepositInitiated(opts, nil, nil)
-		cancel()
-		if err == nil {
-			return res, nil
-		}
-		logger.Error("Error fetching filter", "err", err)
-		time.Sleep(clientRetryInterval)
-	}
-}
-
-// FilterERC20DepositInitiatedWithRetry retries the given func until it succeeds,
-// waiting for clientRetryInterval duration after every call.
-func FilterERC20DepositInitiatedWithRetry(ctx context.Context, filterer *bindings.L1StandardBridgeFilterer, opts *bind.FilterOpts) (*bindings.L1StandardBridgeERC20DepositInitiatedIterator, error) {
-	for {
-		ctxt, cancel := context.WithTimeout(ctx, DefaultConnectionTimeout)
-		opts.Context = ctxt
-		res, err := filterer.FilterERC20DepositInitiated(opts, nil, nil, nil)
-		cancel()
-		if err == nil {
-			return res, nil
-		}
-		logger.Error("Error fetching filter", "err", err)
-		time.Sleep(clientRetryInterval)
-	}
-}
-
-// FilterETHWithdrawalFinalizedWithRetry retries the given func until it succeeds,
-// waiting for clientRetryInterval duration after every call.
-func FilterETHWithdrawalFinalizedWithRetry(ctx context.Context, filterer *bindings.L1StandardBridgeFilterer, opts *bind.FilterOpts) (*bindings.L1StandardBridgeETHWithdrawalFinalizedIterator, error) {
-	for {
-		ctxt, cancel := context.WithTimeout(ctx, DefaultConnectionTimeout)
-		opts.Context = ctxt
-		res, err := filterer.FilterETHWithdrawalFinalized(opts, nil, nil)
-		cancel()
-		if err == nil {
-			return res, nil
-		}
-		logger.Error("Error fetching filter", "err", err)
-		time.Sleep(clientRetryInterval)
-	}
-}
-
-// FilterERC20WithdrawalFinalizedWithRetry retries the given func until it succeeds,
-// waiting for clientRetryInterval duration after every call.
-func FilterERC20WithdrawalFinalizedWithRetry(ctx context.Context, filterer *bindings.L1StandardBridgeFilterer, opts *bind.FilterOpts) (*bindings.L1StandardBridgeERC20WithdrawalFinalizedIterator, error) {
-	for {
-		ctxt, cancel := context.WithTimeout(ctx, DefaultConnectionTimeout)
-		opts.Context = ctxt
-		res, err := filterer.FilterERC20WithdrawalFinalized(opts, nil, nil, nil)
+		res, err := filterer.FilterStateBatchAppended(opts, nil)
 		cancel()
 		if err == nil {
 			return res, nil

indexer/services/l1/bridge/standard_bridge.go

@@ -5,33 +5,40 @@ import (
 
 	"github.com/ethereum-optimism/optimism/indexer/db"
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-service/backoff"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
 
 type StandardBridge struct {
 	name     string
-	ctx      context.Context
 	address  common.Address
-	client   bind.ContractFilterer
-	filterer *bindings.L1StandardBridgeFilterer
+	contract *bindings.L1StandardBridge
 }
 
 func (s *StandardBridge) Address() common.Address {
 	return s.address
 }
 
-func (s *StandardBridge) GetDepositsByBlockRange(start, end uint64) (DepositsMap, error) {
+func (s *StandardBridge) GetDepositsByBlockRange(ctx context.Context, start, end uint64) (DepositsMap, error) {
 	depositsByBlockhash := make(DepositsMap)
+	opts := &bind.FilterOpts{
+		Context: ctx,
+		Start:   start,
+		End:     &end,
+	}
 
-	iter, err := FilterERC20DepositInitiatedWithRetry(s.ctx, s.filterer, &bind.FilterOpts{
-		Start: start,
-		End:   &end,
+	var iter *bindings.L1StandardBridgeERC20DepositInitiatedIterator
+	err := backoff.Do(3, backoff.Exponential(), func() error {
+		var err error
+		iter, err = s.contract.FilterERC20DepositInitiated(opts, nil, nil, nil)
+		return err
 	})
 	if err != nil {
-		logger.Error("Error fetching filter", "err", err)
+		return nil, err
 	}
 
+	defer iter.Close()
 	for iter.Next() {
 		depositsByBlockhash[iter.Event.Raw.BlockHash] = append(
 			depositsByBlockhash[iter.Event.Raw.BlockHash], db.Deposit{
@@ -45,43 +52,8 @@ func (s *StandardBridge) GetDepositsByBlockRange(start, end uint64) (DepositsMap
 				LogIndex:    iter.Event.Raw.Index,
 			})
 	}
-	if err := iter.Error(); err != nil {
-		return nil, err
-	}
-
-	return depositsByBlockhash, nil
-}
-
-func (s *StandardBridge) GetWithdrawalsByBlockRange(start, end uint64) (WithdrawalsMap, error) {
-	withdrawalsByBlockHash := make(WithdrawalsMap)
-
-	iter, err := FilterERC20WithdrawalFinalizedWithRetry(s.ctx, s.filterer, &bind.FilterOpts{
-		Start: start,
-		End:   &end,
-	})
-
-	if err != nil {
-		logger.Error("Error fetching filter", "err", err)
-	}
-
-	for iter.Next() {
-		withdrawalsByBlockHash[iter.Event.Raw.BlockHash] = append(
-			withdrawalsByBlockHash[iter.Event.Raw.BlockHash], db.Withdrawal{
-				TxHash:      iter.Event.Raw.TxHash,
-				L1Token:     iter.Event.L1Token,
-				L2Token:     iter.Event.L2Token,
-				FromAddress: iter.Event.From,
-				ToAddress:   iter.Event.To,
-				Amount:      iter.Event.Amount,
-				Data:        iter.Event.ExtraData,
-				LogIndex:    iter.Event.Raw.Index,
-			})
-	}
-	if err := iter.Error(); err != nil {
-		return nil, err
-	}
 
-	return withdrawalsByBlockHash, nil
+	return depositsByBlockhash, iter.Error()
 }
 
 func (s *StandardBridge) String() string {

indexer/services/l1/confirmed_headers.go

@@ -17,9 +17,8 @@ import (
 )
 
 const (
-	DefaultConnectionTimeout        = 30 * time.Second
-	DefaultConfDepth         uint64 = 20
-	DefaultMaxBatchSize             = 100
+	DefaultConnectionTimeout = 30 * time.Second
+	DefaultMaxBatchSize      = 100
 )
 
 type NewHeader struct {

indexer/services/l1/query.go

 package l1
 
 import (
-	"github.com/ethereum/go-ethereum/ethclient"
+	"context"
 
+	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
 	"github.com/ethereum-optimism/optimism/indexer/db"
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/indexer/services/l1/bridge"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
 
-func QueryERC20(address common.Address, client *ethclient.Client) (*db.Token, error) {
-	contract, err := bindings.NewERC20(address, client)
-	if err != nil {
-		return nil, err
-	}
-
-	name, err := contract.Name(&bind.CallOpts{})
-	if err != nil {
-		return nil, err
-	}
+func QueryStateBatches(filterer *scc.StateCommitmentChainFilterer, startHeight, endHeight uint64, ctx context.Context) (map[common.Hash][]db.StateBatch, error) {
+	batches := make(map[common.Hash][]db.StateBatch)
 
-	symbol, err := contract.Symbol(&bind.CallOpts{})
+	iter, err := bridge.FilterStateBatchAppendedWithRetry(ctx, filterer, &bind.FilterOpts{
+		Start: startHeight,
+		End:   &endHeight,
+	})
 	if err != nil {
 		return nil, err
 	}
 
-	decimals, err := contract.Decimals(&bind.CallOpts{})
-	if err != nil {
-		return nil, err
+	defer iter.Close()
+	for iter.Next() {
+		batches[iter.Event.Raw.BlockHash] = append(
+			batches[iter.Event.Raw.BlockHash], db.StateBatch{
+				Index:     iter.Event.BatchIndex,
+				Root:      iter.Event.BatchRoot,
+				Size:      iter.Event.BatchSize,
+				PrevTotal: iter.Event.PrevTotalElements,
+				ExtraData: iter.Event.ExtraData,
+				BlockHash: iter.Event.Raw.BlockHash,
+			})
 	}
-
-	return &db.Token{
-		Name:     name,
-		Symbol:   symbol,
-		Decimals: decimals,
-	}, nil
+	return batches, iter.Error()
 }