indexer: rm AddressManager, StateCommitmentChain (#3276)

indexer/config.go

@@ -36,9 +36,6 @@ type Config struct {
 	// L2EthRpc is the HTTP provider URL for L1.
 	L2EthRpc string
 
-	// L1AddressManagerAddress is the address of the address manager for L1.
-	L1AddressManagerAddress string
-
 	// L2GenesisBlockHash is the l2 genesis block hash.
 	L2GenesisBlockHash string
 
@@ -121,18 +118,17 @@ type Config struct {
 func NewConfig(ctx *cli.Context) (Config, error) {
 	cfg := Config{
 		/* Required Flags */
-		BuildEnv:                ctx.GlobalString(flags.BuildEnvFlag.Name),
-		EthNetworkName:          ctx.GlobalString(flags.EthNetworkNameFlag.Name),
-		ChainID:                 ctx.GlobalInt64(flags.ChainIDFlag.Name),
-		L1EthRpc:                ctx.GlobalString(flags.L1EthRPCFlag.Name),
-		L2EthRpc:                ctx.GlobalString(flags.L2EthRPCFlag.Name),
-		L1AddressManagerAddress: ctx.GlobalString(flags.L1AddressManagerAddressFlag.Name),
-		L2GenesisBlockHash:      ctx.GlobalString(flags.L2GenesisBlockHashFlag.Name),
-		DBHost:                  ctx.GlobalString(flags.DBHostFlag.Name),
-		DBPort:                  ctx.GlobalUint64(flags.DBPortFlag.Name),
-		DBUser:                  ctx.GlobalString(flags.DBUserFlag.Name),
-		DBPassword:              ctx.GlobalString(flags.DBPasswordFlag.Name),
-		DBName:                  ctx.GlobalString(flags.DBNameFlag.Name),
+		BuildEnv:           ctx.GlobalString(flags.BuildEnvFlag.Name),
+		EthNetworkName:     ctx.GlobalString(flags.EthNetworkNameFlag.Name),
+		ChainID:            ctx.GlobalInt64(flags.ChainIDFlag.Name),
+		L1EthRpc:           ctx.GlobalString(flags.L1EthRPCFlag.Name),
+		L2EthRpc:           ctx.GlobalString(flags.L2EthRPCFlag.Name),
+		L2GenesisBlockHash: ctx.GlobalString(flags.L2GenesisBlockHashFlag.Name),
+		DBHost:             ctx.GlobalString(flags.DBHostFlag.Name),
+		DBPort:             ctx.GlobalUint64(flags.DBPortFlag.Name),
+		DBUser:             ctx.GlobalString(flags.DBUserFlag.Name),
+		DBPassword:         ctx.GlobalString(flags.DBPasswordFlag.Name),
+		DBName:             ctx.GlobalString(flags.DBNameFlag.Name),
 		/* Optional Flags */
 		DisableIndexer:      ctx.GlobalBool(flags.DisableIndexer.Name),
 		LogLevel:            ctx.GlobalString(flags.LogLevelFlag.Name),

indexer/flags/flags.go

@@ -46,12 +46,6 @@ var (
 		Required: true,
 		EnvVar:   prefixEnvVar("L2_ETH_RPC"),
 	}
-	L1AddressManagerAddressFlag = cli.StringFlag{
-		Name:     "l1-address-manager-address",
-		Usage:    "Address of the L1 address manager",
-		Required: true,
-		EnvVar:   prefixEnvVar("L1_ADDRESS_MANAGER_ADDRESS"),
-	}
 	L2GenesisBlockHashFlag = cli.StringFlag{
 		Name:     "l2-genesis-block-hash",
 		Usage:    "Genesis block hash of the L2 chain",
@@ -187,7 +181,6 @@ var requiredFlags = []cli.Flag{
 	ChainIDFlag,
 	L1EthRPCFlag,
 	L2EthRPCFlag,
-	L1AddressManagerAddressFlag,
 	L2GenesisBlockHashFlag,
 	DBHostFlag,
 	DBPortFlag,

indexer/indexer.go

@@ -159,23 +159,17 @@ func NewIndexer(cfg Config, gitVersion string) (*Indexer, error) {
 		return nil, err
 	}
 
-	l1AddressManagerAddress, err := ParseAddress(cfg.L1AddressManagerAddress)
-	if err != nil {
-		return nil, err
-	}
-
 	l1IndexingService, err := l1.NewService(l1.ServiceConfig{
-		Context:               ctx,
-		Metrics:               m,
-		L1Client:              l1Client,
-		RawL1Client:           rawl1Client,
-		ChainID:               big.NewInt(cfg.ChainID),
-		AddressManagerAddress: l1AddressManagerAddress,
-		DB:                    db,
-		ConfDepth:             cfg.ConfDepth,
-		MaxHeaderBatchSize:    cfg.MaxHeaderBatchSize,
-		StartBlockNumber:      cfg.StartBlockNumber,
-		StartBlockHash:        cfg.StartBlockHash,
+		Context:            ctx,
+		Metrics:            m,
+		L1Client:           l1Client,
+		RawL1Client:        rawl1Client,
+		ChainID:            big.NewInt(cfg.ChainID),
+		DB:                 db,
+		ConfDepth:          cfg.ConfDepth,
+		MaxHeaderBatchSize: cfg.MaxHeaderBatchSize,
+		StartBlockNumber:   cfg.StartBlockNumber,
+		StartBlockHash:     cfg.StartBlockHash,
 	})
 	if err != nil {
 		return nil, err

indexer/services/l1/bridge/addresses.go

-package bridge
-
-import (
-	"fmt"
-
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/common"
-)
-
-var zeroAddr common.Address
-
-var standardContracts = []string{
-	"Proxy__OVM_L1CrossDomainMessenger",
-	"Proxy__OVM_L1StandardBridge",
-	"StateCommitmentChain",
-	"CanonicalTransactionChain",
-	"BondManager",
-}
-
-type Addresses struct {
-	addrs map[string]common.Address
-}
-
-func NewAddresses(client bind.ContractBackend, addrMgrAddr common.Address) (*Addresses, error) {
-	ret := &Addresses{
-		addrs: make(map[string]common.Address),
-	}
-	ret.addrs["AddressManager"] = addrMgrAddr
-
-	mgr, err := bindings.NewAddressManager(addrMgrAddr, client)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, contractName := range standardContracts {
-		contractAddr, err := mgr.GetAddress(nil, contractName)
-		if err != nil {
-			return nil, fmt.Errorf("error getting contract %s: %v", contractName, err)
-		}
-		if contractAddr == zeroAddr {
-			return nil, fmt.Errorf("contract %s is not deployed", contractName)
-		}
-		ret.addrs[contractName] = contractAddr
-	}
-
-	return ret, nil
-}
-
-func (a *Addresses) AddressManager() common.Address {
-	return a.addrs["AddressManager"]
-}
-
-func (a *Addresses) L1CrossDomainMessenger() common.Address {
-	return a.addrs["Proxy__OVM_L1CrossDomainMessenger"]
-}
-
-func (a *Addresses) L1StandardBridge() common.Address {
-	return a.addrs["Proxy__OVM_L1StandardBridge"]
-}
-
-func (a *Addresses) StateCommitmentChain() common.Address {
-	return a.addrs["StateCommitmentChain"]
-}
-
-func (a *Addresses) CanonicalTransactionChain() common.Address {
-	return a.addrs["CanonicalTransactionChain"]
-}
-
-func (a *Addresses) BondManager() common.Address {
-	return a.addrs["BondManager"]
-}

indexer/services/l1/bridge/bridge.go

@@ -6,7 +6,6 @@ import (
 	"math/big"
 
 	"github.com/ethereum-optimism/optimism/indexer/bindings/l1bridge"
-	"github.com/ethereum-optimism/optimism/indexer/bindings/scc"
 	"github.com/ethereum-optimism/optimism/indexer/db"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
@@ -26,6 +25,8 @@ type implConfig struct {
 	addr common.Address
 }
 
+var addrs map[string]common.Address
+
 var customBridgeCfgs = map[uint64][]*implConfig{
 	// Mainnet
 	1: {
@@ -40,10 +41,10 @@ var customBridgeCfgs = map[uint64][]*implConfig{
 	},
 }
 
-func BridgesByChainID(chainID *big.Int, client bind.ContractBackend, addrs *Addresses, ctx context.Context) (map[string]Bridge, error) {
+func BridgesByChainID(chainID *big.Int, client bind.ContractBackend, ctx context.Context) (map[string]Bridge, error) {
 	allCfgs := []*implConfig{
-		{"Standard", "StandardBridge", addrs.L1StandardBridge()},
-		{"ETH", "ETHBridge", addrs.L1StandardBridge()},
+		{"Standard", "StandardBridge", addrs["L1StandardBridge"]},
+		{"ETH", "ETHBridge", addrs["L1StandardBridge"]},
 	}
 	allCfgs = append(allCfgs, customBridgeCfgs[chainID.Uint64()]...)
 
@@ -84,11 +85,3 @@ func BridgesByChainID(chainID *big.Int, client bind.ContractBackend, addrs *Addr
 	}
 	return bridges, nil
 }
-
-func StateCommitmentChainScanner(client bind.ContractFilterer, addrs *Addresses) (*scc.StateCommitmentChainFilterer, error) {
-	filter, err := scc.NewStateCommitmentChainFilterer(addrs.StateCommitmentChain(), client)
-	if err != nil {
-		return nil, err
-	}
-	return filter, nil
-}

indexer/services/l1/bridge/filter.go

@@ -5,7 +5,6 @@ import (
 	"time"
 
 	"github.com/ethereum-optimism/optimism/indexer/bindings/l1bridge"
-	"github.com/ethereum-optimism/optimism/indexer/bindings/scc"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 )
 
@@ -13,22 +12,6 @@ import (
 // calls.
 var clientRetryInterval = 5 * time.Second
 
-// FilterStateBatchAppendedWithRetry retries the given func until it succeeds,
-// waiting for clientRetryInterval duration after every call.
-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.FilterStateBatchAppended(opts, nil)
-		cancel()
-		if err == nil {
-			return res, nil
-		}
-		logger.Error("Error fetching filter", "err", err)
-		time.Sleep(clientRetryInterval)
-	}
-}
-
 // FilterETHDepositInitiatedWithRetry retries the given func until it succeeds,
 // waiting for clientRetryInterval duration after every call.
 func FilterETHDepositInitiatedWithRetry(ctx context.Context, filterer *l1bridge.L1StandardBridgeFilterer, opts *bind.FilterOpts) (*l1bridge.L1StandardBridgeETHDepositInitiatedIterator, error) {

indexer/services/l1/query.go

 package l1
 
 import (
-	"context"
-
 	"github.com/ethereum-optimism/optimism/indexer/bindings/l1erc20"
 	"github.com/ethereum/go-ethereum/ethclient"
 
-	"github.com/ethereum-optimism/optimism/indexer/bindings/scc"
 	"github.com/ethereum-optimism/optimism/indexer/db"
-	"github.com/ethereum-optimism/optimism/indexer/services/l1/bridge"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
@@ -40,31 +36,3 @@ func QueryERC20(address common.Address, client *ethclient.Client) (*db.Token, er
 		Decimals: decimals,
 	}, nil
 }
-
-func QueryStateBatches(filterer *scc.StateCommitmentChainFilterer, startHeight, endHeight uint64, ctx context.Context) (map[common.Hash][]db.StateBatch, error) {
-	batches := make(map[common.Hash][]db.StateBatch)
-
-	iter, err := bridge.FilterStateBatchAppendedWithRetry(ctx, filterer, &bind.FilterOpts{
-		Start: startHeight,
-		End:   &endHeight,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	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,
-			})
-	}
-	if err := iter.Error(); err != nil {
-		return nil, err
-	}
-	return batches, nil
-}

indexer/services/l1/service.go

@@ -14,7 +14,6 @@ import (
 	"github.com/ethereum-optimism/optimism/indexer/metrics"
 	"github.com/prometheus/client_golang/prometheus"
 
-	"github.com/ethereum-optimism/optimism/indexer/bindings/scc"
 	"github.com/ethereum-optimism/optimism/indexer/server"
 	"github.com/ethereum-optimism/optimism/indexer/services/l1/bridge"
 
@@ -66,17 +65,16 @@ type Driver interface {
 }
 
 type ServiceConfig struct {
-	Context               context.Context
-	Metrics               *metrics.Metrics
-	L1Client              *ethclient.Client
-	RawL1Client           *rpc.Client
-	ChainID               *big.Int
-	AddressManagerAddress common.Address
-	ConfDepth             uint64
-	MaxHeaderBatchSize    uint64
-	StartBlockNumber      uint64
-	StartBlockHash        string
-	DB                    *db.Database
+	Context            context.Context
+	Metrics            *metrics.Metrics
+	L1Client           *ethclient.Client
+	RawL1Client        *rpc.Client
+	ChainID            *big.Int
+	ConfDepth          uint64
+	MaxHeaderBatchSize uint64
+	StartBlockNumber   uint64
+	StartBlockHash     string
+	DB                 *db.Database
 }
 
 type Service struct {
@@ -85,7 +83,6 @@ type Service struct {
 	cancel func()
 
 	bridges        map[string]bridge.Bridge
-	batchScanner   *scc.StateCommitmentChainFilterer
 	latestHeader   uint64
 	headerSelector *ConfirmedHeaderSelector
 
@@ -116,24 +113,7 @@ func NewService(cfg ServiceConfig) (*Service, error) {
 		return nil, fmt.Errorf("chain ID configured with %d but got %d", cfg.ChainID, chainID)
 	}
 
-	addrs, err := bridge.NewAddresses(cfg.L1Client, cfg.AddressManagerAddress)
-	if err != nil {
-		cancel()
-		return nil, err
-	}
-
-	bridges, err := bridge.BridgesByChainID(cfg.ChainID, cfg.L1Client, addrs, ctx)
-	if err != nil {
-		cancel()
-		return nil, err
-	}
-
-	batchScanner, err := bridge.StateCommitmentChainScanner(cfg.L1Client, addrs)
-	if err != nil {
-		cancel()
-		return nil, err
-	}
-
+	var bridges map[string]bridge.Bridge
 	logger.Info("Scanning bridges for deposits", "bridges", bridges)
 
 	confirmedHeaderSelector, err := NewConfirmedHeaderSelector(HeaderSelectorConfig{
@@ -151,7 +131,6 @@ func NewService(cfg ServiceConfig) (*Service, error) {
 		ctx:            ctx,
 		cancel:         cancel,
 		bridges:        bridges,
-		batchScanner:   batchScanner,
 		headerSelector: confirmedHeaderSelector,
 		metrics:        cfg.Metrics,
 		tokenCache: map[common.Address]*db.Token{
@@ -284,66 +263,6 @@ func (s *Service) Update(newHeader *types.Header) error {
 		}
 	}
 
-	stateBatches, err := QueryStateBatches(s.batchScanner, startHeight, endHeight, s.ctx)
-	if err != nil {
-		logger.Error("Error querying state batches", "err", err)
-	}
-
-	for i, header := range headers {
-		blockHash := header.Hash
-		number := header.Number.Uint64()
-		deposits := depositsByBlockHash[blockHash]
-		batches := stateBatches[blockHash]
-
-		if len(deposits) == 0 && len(batches) == 0 && i != len(headers)-1 {
-			continue
-		}
-
-		block := &db.IndexedL1Block{
-			Hash:       blockHash,
-			ParentHash: header.ParentHash,
-			Number:     number,
-			Timestamp:  header.Time,
-			Deposits:   deposits,
-		}
-
-		err := s.cfg.DB.AddIndexedL1Block(block)
-		if err != nil {
-			logger.Error(
-				"Unable to import ",
-				"block", number,
-				"hash", blockHash, "err", err,
-				"block", block,
-			)
-			return err
-		}
-
-		err = s.cfg.DB.AddStateBatch(batches)
-		if err != nil {
-			logger.Error(
-				"Unable to import state append batch",
-				"block", number,
-				"hash", blockHash, "err", err,
-				"block", block,
-			)
-			return err
-		}
-		s.metrics.RecordStateBatches(len(batches))
-
-		logger.Debug("Imported ",
-			"block", number, "hash", blockHash, "deposits", len(block.Deposits))
-		for _, deposit := range block.Deposits {
-			token := s.tokenCache[deposit.L1Token]
-			logger.Info(
-				"indexed deposit",
-				"tx_hash", deposit.TxHash,
-				"symbol", token.Symbol,
-				"amount", deposit.Amount,
-			)
-			s.metrics.RecordDeposit(deposit.L1Token)
-		}
-	}
-
 	newHeaderNumber := newHeader.Number.Uint64()
 	s.metrics.SetL1SyncHeight(endHeight)
 	s.metrics.SetL1SyncPercent(endHeight, newHeaderNumber)