Merge branch 'develop' into dependabot/go_modules/gorm.io/gorm-1.25.3

indexer/api/api.go

 package api
 
 import (
-	"encoding/json"
+	"fmt"
 	"net/http"
 
+	"github.com/ethereum-optimism/optimism/indexer/api/routes"
 	"github.com/ethereum-optimism/optimism/indexer/database"
-	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
 	"github.com/go-chi/chi/v5"
 )
 
-type PaginationResponse struct {
-	// TODO type this better
-	Data        interface{} `json:"data"`
-	Cursor      string      `json:"cursor"`
-	HasNextPage bool        `json:"hasNextPage"`
-}
-
-func (a *Api) L1DepositsHandler(w http.ResponseWriter, r *http.Request) {
-	bv := a.BridgeTransfersView
-	address := common.HexToAddress(chi.URLParam(r, "address"))
-
-	// limit := getIntFromQuery(r, "limit", 10)
-	// cursor := r.URL.Query().Get("cursor")
-	// sortDirection := r.URL.Query().Get("sortDirection")
-
-	deposits, err := bv.L1BridgeDepositsByAddress(address)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	// This is not the shape of the response we want!!!
-	// will add in the individual features in future prs 1 by 1
-	response := PaginationResponse{
-		Data: deposits,
-		// Cursor:      nextCursor,
-		HasNextPage: false,
-	}
-
-	jsonResponse(w, response, http.StatusOK)
-}
-
-func (a *Api) L2WithdrawalsHandler(w http.ResponseWriter, r *http.Request) {
-	bv := a.BridgeTransfersView
-	address := common.HexToAddress(chi.URLParam(r, "address"))
-
-	// limit := getIntFromQuery(r, "limit", 10)
-	// cursor := r.URL.Query().Get("cursor")
-	// sortDirection := r.URL.Query().Get("sortDirection")
-
-	withdrawals, err := bv.L2BridgeWithdrawalsByAddress(address)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	// This is not the shape of the response we want!!!
-	// will add in the individual features in future prs 1 by 1
-	response := PaginationResponse{
-		Data: withdrawals,
-		// Cursor:      nextCursor,
-		HasNextPage: false,
-	}
-
-	jsonResponse(w, response, http.StatusOK)
-}
-
-func (a *Api) HealthzHandler(w http.ResponseWriter, r *http.Request) {
-	jsonResponse(w, "ok", http.StatusOK)
-}
-
-func jsonResponse(w http.ResponseWriter, data interface{}, statusCode int) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(statusCode)
-	if err := json.NewEncoder(w).Encode(data); err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-	}
-}
+const ethereumAddressRegex = `^0x[a-fA-F0-9]{40}$`
 
 type Api struct {
 	Router *chi.Mux
-	BridgeTransfersView database.BridgeTransfersView
 }
 
-func NewApi(bv database.BridgeTransfersView) *Api {
+func NewApi(bv database.BridgeTransfersView, logger log.Logger) *Api {
+	logger.Info("Initializing API...")
+
 	r := chi.NewRouter()
 
-	api := &Api{Router: r, BridgeTransfersView: bv}
+	h := routes.NewRoutes(logger, bv)
 
-	// these regex are .+ because I wasn't sure what they should be
-	// don't want a regex for addresses because would prefer to validate the address
-	// with go-ethereum and throw a friendly error message
-	r.Get("/api/v0/deposits/{address:.+}", api.L1DepositsHandler)
-	r.Get("/api/v0/withdrawals/{address:.+}", api.L2WithdrawalsHandler)
-	r.Get("/healthz", api.HealthzHandler)
+	api := &Api{Router: r}
 
-	return api
+	r.Get("/healthz", h.HealthzHandler)
+	r.Get(fmt.Sprintf("/api/v0/deposits/{address:%s}", ethereumAddressRegex), h.L1DepositsHandler)
+	r.Get(fmt.Sprintf("/api/v0/withdrawals/{address:%s}", ethereumAddressRegex), h.L2WithdrawalsHandler)
 
+	return api
 }
 
 func (a *Api) Listen(port string) error {

indexer/api/api_test.go

 package api
 
 import (
+	"fmt"
 	"math/big"
 	"net/http"
 	"net/http/httptest"
 	"testing"
 
 	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
 	"github.com/stretchr/testify/assert"
 )
 
 // MockBridgeTransfersView mocks the BridgeTransfersView interface
 type MockBridgeTransfersView struct{}
 
+var mockAddress = "0x4204204204204204204204204204204204204204"
+
 var (
 	deposit = database.L1BridgeDeposit{
 		TransactionSourceHash:     common.HexToHash("abc"),
@@ -23,7 +28,7 @@ var (
 	}
 
 	withdrawal = database.L2BridgeWithdrawal{
-		TransactionWithdrawalHash: common.HexToHash("0x456"),
+		TransactionWithdrawalHash: common.HexToHash("0x420"),
 		CrossDomainMessengerNonce: &database.U256{Int: big.NewInt(0)},
 		Tx:                        database.Transaction{},
 		TokenPair:                 database.TokenPair{},
@@ -65,7 +70,8 @@ func (mbv *MockBridgeTransfersView) L2BridgeWithdrawalsByAddress(address common.
 }
 
 func TestHealthz(t *testing.T) {
-	api := NewApi(&MockBridgeTransfersView{})
+	logger := testlog.Logger(t, log.LvlInfo)
+	api := NewApi(&MockBridgeTransfersView{}, logger)
 	request, err := http.NewRequest("GET", "/healthz", nil)
 	assert.Nil(t, err)
 
@@ -76,8 +82,9 @@ func TestHealthz(t *testing.T) {
 }
 
 func TestL1BridgeDepositsHandler(t *testing.T) {
-	api := NewApi(&MockBridgeTransfersView{})
-	request, err := http.NewRequest("GET", "/api/v0/deposits/0x123", nil)
+	logger := testlog.Logger(t, log.LvlInfo)
+	api := NewApi(&MockBridgeTransfersView{}, logger)
+	request, err := http.NewRequest("GET", fmt.Sprintf("/api/v0/deposits/%s", mockAddress), nil)
 	assert.Nil(t, err)
 
 	responseRecorder := httptest.NewRecorder()
@@ -87,8 +94,9 @@ func TestL1BridgeDepositsHandler(t *testing.T) {
 }
 
 func TestL2BridgeWithdrawalsByAddressHandler(t *testing.T) {
-	api := NewApi(&MockBridgeTransfersView{})
-	request, err := http.NewRequest("GET", "/api/v0/withdrawals/0x123", nil)
+	logger := testlog.Logger(t, log.LvlInfo)
+	api := NewApi(&MockBridgeTransfersView{}, logger)
+	request, err := http.NewRequest("GET", fmt.Sprintf("/api/v0/withdrawals/%s", mockAddress), nil)
 	assert.Nil(t, err)
 
 	responseRecorder := httptest.NewRecorder()

indexer/api/routes/common.go

+package routes
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/ethereum/go-ethereum/log"
+)
+
+// lazily typing numbers fixme
+type Transaction struct {
+	Timestamp       uint64 `json:"timestamp"`
+	TransactionHash string `json:"transactionHash"`
+}
+
+type Block struct {
+	BlockNumber int64  `json:"number"`
+	BlockHash   string `json:"hash"`
+	// ParentBlockHash   string `json:"parentHash"`
+}
+
+type Extensions struct {
+	OptimismBridgeAddress string `json:"OptimismBridgeAddress"`
+}
+
+type TokenInfo struct {
+	// TODO lazily typing ints go through them all with fine tooth comb once api is up
+	ChainId    int        `json:"chainId"`
+	Address    string     `json:"address"`
+	Name       string     `json:"name"`
+	Symbol     string     `json:"symbol"`
+	Decimals   int        `json:"decimals"`
+	Extensions Extensions `json:"extensions"`
+}
+
+func jsonResponse(w http.ResponseWriter, logger log.Logger, data interface{}, statusCode int) {
+	w.Header().Set("Content-Type", "application/json")
+	jsonData, err := json.Marshal(data)
+	if err != nil {
+		http.Error(w, "Internal server error", http.StatusInternalServerError)
+		logger.Error("Failed to marshal JSON: %v", err)
+		return
+	}
+
+	w.WriteHeader(statusCode)
+	_, err = w.Write(jsonData)
+	if err != nil {
+		http.Error(w, "Internal server error", http.StatusInternalServerError)
+		logger.Error("Failed to write JSON data", err)
+		return
+	}
+}

indexer/api/routes/deposits.go

+package routes
+
+import (
+	"net/http"
+
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/go-chi/chi/v5"
+)
+
+type DepositItem struct {
+	Guid string `json:"guid"`
+	From string `json:"from"`
+	To   string `json:"to"`
+	// TODO could consider OriginTx to be more generic to handling L2 to L2 deposits
+	// this seems more clear today though
+	Tx      Transaction `json:"Tx"`
+	Block   Block       `json:"Block"`
+	Amount  string      `json:"amount"`
+	L1Token TokenInfo   `json:"l1Token"`
+	L2Token TokenInfo   `json:"l2Token"`
+}
+
+type DepositResponse struct {
+	Cursor      string        `json:"cursor"`
+	HasNextPage bool          `json:"hasNextPage"`
+	Items       []DepositItem `json:"items"`
+}
+
+// TODO this is original spec but maybe include the l2 block info too for the relayed tx
+// FIXME make a pure function that returns a struct instead of newWithdrawalResponse
+func newDepositResponse(deposits []*database.L1BridgeDepositWithTransactionHashes) DepositResponse {
+	items := make([]DepositItem, len(deposits))
+	for _, deposit := range deposits {
+		item := DepositItem{
+			Guid: deposit.L1BridgeDeposit.TransactionSourceHash.String(),
+			Block: Block{
+				BlockNumber: 420420,  // TODO
+				BlockHash:   "0x420", // TODO
+
+			},
+			Tx: Transaction{
+				TransactionHash: "0x420", // TODO
+				Timestamp:       deposit.L1BridgeDeposit.Tx.Timestamp,
+			},
+			From:   deposit.L1BridgeDeposit.Tx.FromAddress.String(),
+			To:     deposit.L1BridgeDeposit.Tx.ToAddress.String(),
+			Amount: deposit.L1BridgeDeposit.Tx.Amount.Int.String(),
+			L1Token: TokenInfo{
+				ChainId:  1,
+				Address:  deposit.L1BridgeDeposit.TokenPair.L1TokenAddress.String(),
+				Name:     "TODO",
+				Symbol:   "TODO",
+				Decimals: 420,
+				Extensions: Extensions{
+					OptimismBridgeAddress: "0x420", // TODO
+				},
+			},
+			L2Token: TokenInfo{
+				ChainId:  10,
+				Address:  deposit.L1BridgeDeposit.TokenPair.L2TokenAddress.String(),
+				Name:     "TODO",
+				Symbol:   "TODO",
+				Decimals: 420,
+				Extensions: Extensions{
+					OptimismBridgeAddress: "0x420", // TODO
+				},
+			},
+		}
+		items = append(items, item)
+	}
+
+	return DepositResponse{
+		Cursor:      "42042042-4204-4204-4204-420420420420", // TODO
+		HasNextPage: false,                                  // TODO
+		Items:       items,
+	}
+}
+
+func (h Routes) L1DepositsHandler(w http.ResponseWriter, r *http.Request) {
+	address := common.HexToAddress(chi.URLParam(r, "address"))
+
+	deposits, err := h.BridgeTransfersView.L1BridgeDepositsByAddress(address)
+	if err != nil {
+		http.Error(w, "Internal server error reading deposits", http.StatusInternalServerError)
+		h.Logger.Error("Unable to read deposits from DB")
+		h.Logger.Error(err.Error())
+		return
+	}
+
+	response := newDepositResponse(deposits)
+
+	jsonResponse(w, h.Logger, response, http.StatusOK)
+}

indexer/api/routes/healthz.go

+package routes
+
+import (
+	"net/http"
+)
+
+func (h Routes) HealthzHandler(w http.ResponseWriter, r *http.Request) {
+	jsonResponse(w, h.Logger, "ok", http.StatusOK)
+}

indexer/api/routes/routes.go

+package routes
+
+import (
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+type Routes struct {
+	Logger              log.Logger
+	BridgeTransfersView database.BridgeTransfersView
+}
+
+func NewRoutes(logger log.Logger, bv database.BridgeTransfersView) Routes {
+	return Routes{
+		Logger:              logger,
+		BridgeTransfersView: bv,
+	}
+}

indexer/api/routes/withdrawals.go

+package routes
+
+import (
+	"net/http"
+
+	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/go-chi/chi/v5"
+)
+
+type Proof struct {
+	TransactionHash string `json:"transactionHash"`
+	BlockTimestamp  uint64 `json:"blockTimestamp"`
+	BlockNumber     int    `json:"blockNumber"`
+}
+
+type Claim struct {
+	TransactionHash string `json:"transactionHash"`
+	BlockTimestamp  uint64 `json:"blockTimestamp"`
+	BlockNumber     int    `json:"blockNumber"`
+}
+
+type WithdrawalItem struct {
+	Guid            string      `json:"guid"`
+	Tx              Transaction `json:"Tx"`
+	Block           Block       `json:"Block"`
+	From            string      `json:"from"`
+	To              string      `json:"to"`
+	TransactionHash string      `json:"transactionHash"`
+	Amount          string      `json:"amount"`
+	Proof           Proof       `json:"proof"`
+	Claim           Claim       `json:"claim"`
+	WithdrawalState string      `json:"withdrawalState"`
+	L1Token         TokenInfo   `json:"l1Token"`
+	L2Token         TokenInfo   `json:"l2Token"`
+}
+
+type WithdrawalResponse struct {
+	Cursor      string           `json:"cursor"`
+	HasNextPage bool             `json:"hasNextPage"`
+	Items       []WithdrawalItem `json:"items"`
+}
+
+// FIXME make a pure function that returns a struct instead of newWithdrawalResponse
+func newWithdrawalResponse(withdrawals []*database.L2BridgeWithdrawalWithTransactionHashes) WithdrawalResponse {
+	items := make([]WithdrawalItem, len(withdrawals))
+	for _, withdrawal := range withdrawals {
+		item := WithdrawalItem{
+			Guid: withdrawal.L2BridgeWithdrawal.TransactionWithdrawalHash.String(),
+			Block: Block{
+				BlockNumber: 420420,  // TODO
+				BlockHash:   "0x420", // TODO
+
+			},
+			Tx: Transaction{
+				TransactionHash: "0x420", // TODO
+				Timestamp:       withdrawal.L2BridgeWithdrawal.Tx.Timestamp,
+			},
+			From:            withdrawal.L2BridgeWithdrawal.Tx.FromAddress.String(),
+			To:              withdrawal.L2BridgeWithdrawal.Tx.ToAddress.String(),
+			TransactionHash: withdrawal.L2TransactionHash.String(),
+			Amount:          withdrawal.L2BridgeWithdrawal.Tx.Amount.Int.String(),
+			Proof: Proof{
+				TransactionHash: withdrawal.ProvenL1TransactionHash.String(),
+				BlockTimestamp:  withdrawal.L2BridgeWithdrawal.Tx.Timestamp,
+				BlockNumber:     420, // TODO Block struct instead
+			},
+			Claim: Claim{
+				TransactionHash: withdrawal.FinalizedL1TransactionHash.String(),
+				BlockTimestamp:  withdrawal.L2BridgeWithdrawal.Tx.Timestamp, // Using L2 timestamp for now, might need adjustment
+				BlockNumber:     420,                                        // TODO block struct
+			},
+			WithdrawalState: "COMPLETE", // TODO
+			L1Token: TokenInfo{
+				ChainId:  1,
+				Address:  withdrawal.L2BridgeWithdrawal.TokenPair.L1TokenAddress.String(),
+				Name:     "Example", // TODO
+				Symbol:   "EXAMPLE", // TODO
+				Decimals: 18,        // TODO
+				Extensions: Extensions{
+					OptimismBridgeAddress: "0x636Af16bf2f682dD3109e60102b8E1A089FedAa8",
+				},
+			},
+			L2Token: TokenInfo{
+				ChainId:  10,
+				Address:  withdrawal.L2BridgeWithdrawal.TokenPair.L2TokenAddress.String(),
+				Name:     "Example", // TODO
+				Symbol:   "EXAMPLE", // TODO
+				Decimals: 18,        // TODO
+				Extensions: Extensions{
+					OptimismBridgeAddress: "0x36Af16bf2f682dD3109e60102b8E1A089FedAa86",
+				},
+			},
+		}
+		items = append(items, item)
+	}
+
+	return WithdrawalResponse{
+		Cursor:      "42042042-0420-4204-2042-420420420420", // TODO
+		HasNextPage: true,                                   // TODO
+		Items:       items,
+	}
+}
+
+func (h Routes) L2WithdrawalsHandler(w http.ResponseWriter, r *http.Request) {
+	address := common.HexToAddress(chi.URLParam(r, "address"))
+
+	withdrawals, err := h.BridgeTransfersView.L2BridgeWithdrawalsByAddress(address)
+	if err != nil {
+		http.Error(w, "Internal server error fetching withdrawals", http.StatusInternalServerError)
+		h.Logger.Error("Unable to read deposits from DB")
+		h.Logger.Error(err.Error())
+		return
+	}
+
+	response := newWithdrawalResponse(withdrawals)
+
+	jsonResponse(w, h.Logger, response, http.StatusOK)
+}

indexer/cli/cli.go

@@ -3,12 +3,14 @@ package cli
 import (
 	"context"
 	"fmt"
+	"strconv"
 
 	"github.com/ethereum-optimism/optimism/indexer"
+	"github.com/ethereum-optimism/optimism/indexer/api"
 	"github.com/ethereum-optimism/optimism/indexer/config"
+	"github.com/ethereum-optimism/optimism/indexer/database"
 	"github.com/ethereum-optimism/optimism/op-service/log"
 	"github.com/ethereum-optimism/optimism/op-service/opio"
-
 	"github.com/ethereum/go-ethereum/params"
 
 	"github.com/urfave/cli/v2"
@@ -23,17 +25,28 @@ type Cli struct {
 }
 
 func runIndexer(ctx *cli.Context) error {
-	logger := log.NewLogger(log.ReadCLIConfig(ctx))
+	logger := log.NewLogger(log.CLIConfig{
+		Level:  "warn",
+		Color:  false,
+		Format: "terminal",
+	})
 
 	configPath := ctx.String(ConfigFlag.Name)
-	cfg, err := config.LoadConfig(configPath)
+	cfg, err := config.LoadConfig(logger, configPath)
 	if err != nil {
 		logger.Error("failed to load config", "err", err)
 		return err
 	}
 
-	cfg.Logger = logger
-	indexer, err := indexer.NewIndexer(cfg)
+	logger = log.NewLogger(cfg.Logger)
+
+	db, err := database.NewDB(cfg.DB)
+
+	if err != nil {
+		return err
+	}
+
+	indexer, err := indexer.NewIndexer(cfg.Chain, cfg.RPCs, db, logger)
 	if err != nil {
 		return err
 	}
@@ -51,17 +64,21 @@ func runApi(ctx *cli.Context) error {
 	logger := log.NewLogger(log.ReadCLIConfig(ctx))
 
 	configPath := ctx.String(ConfigFlag.Name)
-	cfg, err := config.LoadConfig(configPath)
+	cfg, err := config.LoadConfig(logger, configPath)
 	if err != nil {
 		logger.Error("failed to load config", "err", err)
 		return err
 	}
 
-	cfg.Logger = logger
-	fmt.Println(cfg)
+	db, err := database.NewDB(cfg.DB)
 
-	// finish me
-	return err
+	if err != nil {
+		logger.Crit("Failed to connect to database", "err", err)
+	}
+
+	server := api.NewApi(db.BridgeTransfers, logger)
+
+	return server.Listen(strconv.Itoa(cfg.API.Port))
 }
 
 var (
@@ -81,7 +98,7 @@ func (c *Cli) Run(args []string) error {
 }
 
 func NewCli(GitVersion string, GitCommit string, GitDate string) *Cli {
-	flags := append([]cli.Flag{ConfigFlag}, log.CLIFlags("INDEXER")...)
+	flags := []cli.Flag{ConfigFlag}
 	app := &cli.App{
 		Version:     fmt.Sprintf("%s-%s", GitVersion, params.VersionWithCommit(GitCommit, GitDate)),
 		Description: "An indexer of all optimism events with a serving api layer",

indexer/config/config.go

 package config
 
 import (
+	"fmt"
 	"os"
+	"reflect"
 
 	"github.com/BurntSushi/toml"
 
-	"github.com/ethereum-optimism/optimism/indexer/processor"
-	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum-optimism/optimism/op-service/log"
+	"github.com/ethereum/go-ethereum/common"
+	geth_log "github.com/ethereum/go-ethereum/log"
 	"github.com/joho/godotenv"
 )
 
+// in future presets can just be onchain config and fetched on initialization
+
 // Config represents the `indexer.toml` file used to configure the indexer
 type Config struct {
 	Chain   ChainConfig
@@ -17,14 +22,42 @@ type Config struct {
 	DB      DBConfig
 	API     APIConfig
 	Metrics MetricsConfig
-	Logger  log.Logger `toml:"-"`
+	Logger  log.CLIConfig
+}
+
+// fetch this via onchain config from RPCsConfig and remove from config in future
+type L1Contracts struct {
+	OptimismPortal         common.Address
+	L2OutputOracle         common.Address
+	L1CrossDomainMessenger common.Address
+	L1StandardBridge       common.Address
+	L1ERC721Bridge         common.Address
+
+	// Some more contracts -- ProxyAdmin, SystemConfig, etcc
+	// Ignore the auxiliary contracts?
+
+	// Legacy contracts? We'll add this in to index the legacy chain.
+	// Remove afterwards?
+}
+
+func (c L1Contracts) ToSlice() []common.Address {
+	fields := reflect.VisibleFields(reflect.TypeOf(c))
+	v := reflect.ValueOf(c)
+
+	contracts := make([]common.Address, len(fields))
+	for i, field := range fields {
+		contracts[i] = (v.FieldByName(field.Name).Interface()).(common.Address)
+	}
+
+	return contracts
 }
 
 // ChainConfig configures of the chain being indexed
 type ChainConfig struct {
 	// Configure known chains with the l2 chain id
 	Preset int
-	L1Contracts processor.L1Contracts
+	// Configure custom chains via providing the L1Contract addresses
+	L1Contracts L1Contracts
 }
 
 // RPCsConfig configures the RPC urls
@@ -55,32 +88,38 @@ type MetricsConfig struct {
 }
 
 // LoadConfig loads the `indexer.toml` config file from a given path
-func LoadConfig(path string) (Config, error) {
+func LoadConfig(logger geth_log.Logger, path string) (Config, error) {
 	if err := godotenv.Load(); err != nil {
-		log.Warn("Unable to load .env file", err)
-		log.Info("Continuing without .env file")
+		logger.Warn("Unable to load .env file", err)
+		logger.Info("Continuing without .env file")
 	} else {
-		log.Info("Loaded .env file")
+		logger.Info("Loaded .env file")
 	}
 
 	var conf Config
 
-	// Read the config file.
 	data, err := os.ReadFile(path)
 	if err != nil {
 		return conf, err
 	}
 
-	// Replace environment variables.
 	data = []byte(os.ExpandEnv(string(data)))
 
-	// Decode the TOML data.
 	if _, err := toml.Decode(string(data), &conf); err != nil {
-		log.Info("Failed to decode config file", "message", err)
+		logger.Info("Failed to decode config file", "message", err)
 		return conf, err
 	}
 
-	log.Debug("Loaded config file", conf)
+	if conf.Chain.Preset != 0 {
+		knownContracts, ok := presetL1Contracts[conf.Chain.Preset]
+		if ok {
+			conf.Chain.L1Contracts = knownContracts
+		} else {
+			return conf, fmt.Errorf("unknown preset: %d", conf.Chain.Preset)
+		}
+	}
+
+	logger.Debug("Loaded config file", conf)
 
 	return conf, nil
 }

indexer/config/config_test.go

 package config
 
 import (
+	"fmt"
 	"os"
 	"testing"
 
+	"github.com/ethereum-optimism/optimism/op-node/testlog"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
 	"github.com/stretchr/testify/require"
 )
 
 func TestLoadConfig(t *testing.T) {
+	logger := testlog.Logger(t, log.LvlInfo)
 	tmpfile, err := os.CreateTemp("", "test.toml")
 	require.NoError(t, err)
 	defer os.Remove(tmpfile.Name())
@@ -15,7 +20,7 @@ func TestLoadConfig(t *testing.T) {
 
 	testData := `
 		[chain]
-		preset = 1234
+		preset = 420
 
 		[rpcs]
 		l1-rpc = "https://l1.example.com"
@@ -45,10 +50,15 @@ func TestLoadConfig(t *testing.T) {
 	err = tmpfile.Close()
 	require.NoError(t, err)
 
-	conf, err := LoadConfig(tmpfile.Name())
+	conf, err := LoadConfig(logger, tmpfile.Name())
 	require.NoError(t, err)
 
-	require.Equal(t, conf.Chain.Preset, 1234)
+	require.Equal(t, conf.Chain.Preset, 420)
+	require.Equal(t, conf.Chain.L1Contracts.OptimismPortal.String(), presetL1Contracts[420].OptimismPortal.String())
+	require.Equal(t, conf.Chain.L1Contracts.L1CrossDomainMessenger.String(), presetL1Contracts[420].L1CrossDomainMessenger.String())
+	require.Equal(t, conf.Chain.L1Contracts.L1ERC721Bridge.String(), presetL1Contracts[420].L1ERC721Bridge.String())
+	require.Equal(t, conf.Chain.L1Contracts.L1StandardBridge.String(), presetL1Contracts[420].L1StandardBridge.String())
+	require.Equal(t, conf.Chain.L1Contracts.L2OutputOracle.String(), presetL1Contracts[420].L2OutputOracle.String())
 	require.Equal(t, conf.RPCs.L1RPC, "https://l1.example.com")
 	require.Equal(t, conf.RPCs.L2RPC, "https://l2.example.com")
 	require.Equal(t, conf.DB.Host, "127.0.0.1")
@@ -61,3 +71,69 @@ func TestLoadConfig(t *testing.T) {
 	require.Equal(t, conf.Metrics.Host, "127.0.0.1")
 	require.Equal(t, conf.Metrics.Port, 7300)
 }
+
+func TestLoadConfig_WithoutPreset(t *testing.T) {
+	tmpfile, err := os.CreateTemp("", "test_without_preset.toml")
+	require.NoError(t, err)
+	defer os.Remove(tmpfile.Name())
+	defer tmpfile.Close()
+
+	testData := `
+        [chain]
+        l1contracts = { OptimismPortal = "0x4205Fc579115071764c7423A4f12eDde41f106Ed", L2OutputOracle = "0x42097868233d1aa22e815a266982f2cf17685a27", L1CrossDomainMessenger = "0x420ce71c97B33Cc4729CF772ae268934F7ab5fA1", L1StandardBridge = "0x4209fc46f92E8a1c0deC1b1747d010903E884bE1", L1ERC721Bridge ="0x420749f83b81B301cAb5f48EB8516B986DAef23D" }
+
+        [rpcs]
+        l1-rpc = "https://l1.example.com"
+        l2-rpc = "https://l2.example.com"
+    `
+
+	data := []byte(testData)
+	err = os.WriteFile(tmpfile.Name(), data, 0644)
+	require.NoError(t, err)
+	defer os.Remove(tmpfile.Name())
+
+	err = tmpfile.Close()
+	require.NoError(t, err)
+
+	logger := testlog.Logger(t, log.LvlInfo)
+	conf, err := LoadConfig(logger, tmpfile.Name())
+	require.NoError(t, err)
+
+	require.Equal(t, conf.Chain.L1Contracts.OptimismPortal.String(), common.HexToAddress("0x4205Fc579115071764c7423A4f12eDde41f106Ed").String())
+	require.Equal(t, conf.Chain.L1Contracts.L2OutputOracle.String(), common.HexToAddress("0x42097868233d1aa22e815a266982f2cf17685a27").String())
+	require.Equal(t, conf.Chain.L1Contracts.L1CrossDomainMessenger.String(), common.HexToAddress("0x420ce71c97B33Cc4729CF772ae268934F7ab5fA1").String())
+	require.Equal(t, conf.Chain.L1Contracts.L1StandardBridge.String(), common.HexToAddress("0x4209fc46f92E8a1c0deC1b1747d010903E884bE1").String())
+	require.Equal(t, conf.Chain.L1Contracts.L1ERC721Bridge.String(), common.HexToAddress("0x420749f83b81B301cAb5f48EB8516B986DAef23D").String())
+	require.Equal(t, conf.Chain.Preset, 0)
+}
+
+func TestLoadConfig_WithUnknownPreset(t *testing.T) {
+	tmpfile, err := os.CreateTemp("", "test_bad_preset.toml")
+	require.NoError(t, err)
+	defer os.Remove(tmpfile.Name())
+	defer tmpfile.Close()
+
+	testData := `
+        [chain]
+        preset = 1234567890  # this preset doesn't exist
+
+        [rpcs]
+        l1-rpc = "https://l1.example.com"
+        l2-rpc = "https://l2.example.com"
+    `
+
+	data := []byte(testData)
+	err = os.WriteFile(tmpfile.Name(), data, 0644)
+	require.NoError(t, err)
+	defer os.Remove(tmpfile.Name())
+
+	err = tmpfile.Close()
+	require.NoError(t, err)
+
+	logger := testlog.Logger(t, log.LvlInfo)
+	conf, err := LoadConfig(logger, tmpfile.Name())
+	var faultyPreset = 1234567890
+	require.Equal(t, conf.Chain.Preset, faultyPreset)
+	require.Error(t, err)
+	require.Equal(t, fmt.Sprintf("unknown preset: %d", faultyPreset), err.Error())
+}

indexer/config/presets.go

+package config
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+)
+
+// in future presets can just be onchain config and fetched on initialization
+
+// Mapping of l2 chain ids to their preset chain configurations
+var presetL1Contracts = map[int]L1Contracts{
+	// OP Mainnet
+	10: {
+		OptimismPortal:         common.HexToAddress("0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"),
+		L2OutputOracle:         common.HexToAddress("0xdfe97868233d1aa22e815a266982f2cf17685a27"),
+		L1CrossDomainMessenger: common.HexToAddress("0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1"),
+		L1StandardBridge:       common.HexToAddress("0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"),
+		L1ERC721Bridge:         common.HexToAddress("0x5a7749f83b81B301cAb5f48EB8516B986DAef23D"),
+	},
+	// OP Goerli
+	420: {
+		OptimismPortal:         common.HexToAddress("0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"),
+		L2OutputOracle:         common.HexToAddress("0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0"),
+		L1CrossDomainMessenger: common.HexToAddress("0x5086d1eEF304eb5284A0f6720f79403b4e9bE294"),
+		L1StandardBridge:       common.HexToAddress("0x636Af16bf2f682dD3109e60102b8E1A089FedAa8"),
+		L1ERC721Bridge:         common.HexToAddress("0x8DD330DdE8D9898d43b4dc840Da27A07dF91b3c9"),
+	},
+	// Base Mainnet
+	8453: {
+		OptimismPortal:         common.HexToAddress("0x49048044D57e1C92A77f79988d21Fa8fAF74E97e"),
+		L2OutputOracle:         common.HexToAddress("0x56315b90c40730925ec5485cf004d835058518A0"),
+		L1CrossDomainMessenger: common.HexToAddress("0x866E82a600A1414e583f7F13623F1aC5d58b0Afa"),
+		L1StandardBridge:       common.HexToAddress("0x3154Cf16ccdb4C6d922629664174b904d80F2C35"),
+		// FIXME update this to the correct address
+		L1ERC721Bridge: common.HexToAddress("0x0000000000000000000000000000000000000000"),
+	},
+	// Base Goerli
+	84531: {
+		OptimismPortal:         common.HexToAddress("0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA"),
+		L2OutputOracle:         common.HexToAddress("0x2A35891ff30313CcFa6CE88dcf3858bb075A2298"),
+		L1CrossDomainMessenger: common.HexToAddress("0x8e5693140eA606bcEB98761d9beB1BC87383706D"),
+		L1StandardBridge:       common.HexToAddress("0xfA6D8Ee5BE770F84FC001D098C4bD604Fe01284a"),
+		// FIXME update this to the correct address
+		L1ERC721Bridge: common.HexToAddress("0x0000000000000000000000000000000000000000"),
+	},
+	// Zora mainnet
+	7777777: {
+		OptimismPortal:         common.HexToAddress("0x1a0ad011913A150f69f6A19DF447A0CfD9551054"),
+		L2OutputOracle:         common.HexToAddress("0x9E6204F750cD866b299594e2aC9eA824E2e5f95c"),
+		L1CrossDomainMessenger: common.HexToAddress("0xdC40a14d9abd6F410226f1E6de71aE03441ca506"),
+		L1StandardBridge:       common.HexToAddress("0x3e2Ea9B92B7E48A52296fD261dc26fd995284631"),
+		// FIXME update this to the correct address
+		L1ERC721Bridge: common.HexToAddress("0x0000000000000000000000000000000000000000"),
+	},
+	// Zora goerli
+	999: {
+		OptimismPortal:         common.HexToAddress("0xDb9F51790365e7dc196e7D072728df39Be958ACe"),
+		L2OutputOracle:         common.HexToAddress("0xdD292C9eEd00f6A32Ff5245d0BCd7f2a15f24e00"),
+		L1CrossDomainMessenger: common.HexToAddress("0xD87342e16352D33170557A7dA1e5fB966a60FafC"),
+		L1StandardBridge:       common.HexToAddress("0x7CC09AC2452D6555d5e0C213Ab9E2d44eFbFc956"),
+		// FIXME update this to the correct address
+		L1ERC721Bridge: common.HexToAddress("0x0000000000000000000000000000000000000000"),
+	},
+}

indexer/database/db.go

@@ -2,6 +2,9 @@
 package database
 
 import (
+	"fmt"
+
+	"github.com/ethereum-optimism/optimism/indexer/config"
 	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
@@ -17,7 +20,14 @@ type DB struct {
 	BridgeTransactions BridgeTransactionsDB
 }
 
-func NewDB(dsn string) (*DB, error) {
+func NewDB(dbConfig config.DBConfig) (*DB, error) {
+	dsn := fmt.Sprintf("host=%s port=%d dbname=%s sslmode=disable", dbConfig.Host, dbConfig.Port, dbConfig.Name)
+	if dbConfig.User != "" {
+		dsn += fmt.Sprintf(" user=%s", dbConfig.User)
+	}
+	if dbConfig.Password != "" {
+		dsn += fmt.Sprintf(" password=%s", dbConfig.Password)
+	}
 	gorm, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
 		// The indexer will explicitly manage the transaction
 		// flow processing blocks

indexer/docker-compose.yml

@@ -17,6 +17,29 @@ services:
       - postgres_data:/data/postgres
 
   indexer:
+    build:
+      context: ..
+      dockerfile: indexer/Dockerfile.refresh
+    command: ["indexer-refresh", "processor"]
+    # healthcheck:
+    # Add healthcheck once figure out good way how
+    # maybe after we add metrics?
+    ports:
+      - 8080:8080
+    environment:
+      - INDEXER_DB_PORT=5432
+      - INDEXER_DB_USER=db_username
+      - INDEXER_DB_PASSWORD=db_password
+      - INDEXER_DB_NAME=db_name
+      - INDEXER_DB_HOST=postgres
+      - INDEXER_CONFIG=/configs/indexer.toml
+    volumes:
+      - ./indexer.toml:/configs/indexer.toml
+    depends_on:
+      postgres:
+        condition: service_healthy
+
+  api:
     build:
       context: ..
       dockerfile: indexer/Dockerfile

indexer/e2e_tests/setup.go

@@ -13,10 +13,10 @@ import (
 	"github.com/ethereum-optimism/optimism/indexer"
 	"github.com/ethereum-optimism/optimism/indexer/config"
 	"github.com/ethereum-optimism/optimism/indexer/database"
-	"github.com/ethereum-optimism/optimism/indexer/processor"
 
 	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
+	op_log "github.com/ethereum-optimism/optimism/op-service/log"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 
@@ -59,7 +59,10 @@ func createE2ETestSuite(t *testing.T) E2ETestSuite {
 
 	// Indexer Configuration and Start
 	indexerCfg := config.Config{
-		Logger: logger,
+
+		Logger: op_log.CLIConfig{
+			Level: "warn",
+		},
 		DB: config.DBConfig{
 			Host: "127.0.0.1",
 			Port: 5432,
@@ -71,7 +74,7 @@ func createE2ETestSuite(t *testing.T) E2ETestSuite {
 			L2RPC: opSys.Nodes["sequencer"].HTTPEndpoint(),
 		},
 		Chain: config.ChainConfig{
-			L1Contracts: processor.L1Contracts{
+			L1Contracts: config.L1Contracts{
 				OptimismPortal:         opCfg.L1Deployments.OptimismPortalProxy,
 				L2OutputOracle:         opCfg.L1Deployments.L2OutputOracleProxy,
 				L1CrossDomainMessenger: opCfg.L1Deployments.L1CrossDomainMessengerProxy,
@@ -81,9 +84,14 @@ func createE2ETestSuite(t *testing.T) E2ETestSuite {
 		},
 	}
 
-	db, err := database.NewDB(fmt.Sprintf("postgres://%s@localhost:5432/%s?sslmode=disable", dbUser, dbName))
+	db, err := database.NewDB(indexerCfg.DB)
 	require.NoError(t, err)
-	indexer, err := indexer.NewIndexer(indexerCfg)
+	indexer, err := indexer.NewIndexer(
+		indexerCfg.Chain,
+		indexerCfg.RPCs,
+		db,
+		logger,
+	)
 	require.NoError(t, err)
 
 	indexerStoppedCh := make(chan interface{}, 1)

indexer/indexer.go

@@ -24,44 +24,31 @@ type Indexer struct {
 }
 
 // NewIndexer initializes an instance of the Indexer
-func NewIndexer(cfg config.Config) (*Indexer, error) {
-	dsn := fmt.Sprintf("host=%s port=%d dbname=%s sslmode=disable", cfg.DB.Host, cfg.DB.Port, cfg.DB.Name)
-	if cfg.DB.User != "" {
-		dsn += fmt.Sprintf(" user=%s", cfg.DB.User)
-	}
-	if cfg.DB.Password != "" {
-		dsn += fmt.Sprintf(" password=%s", cfg.DB.Password)
-	}
-
-	db, err := database.NewDB(dsn)
-	if err != nil {
-		return nil, err
-	}
-
-	l1Contracts := cfg.Chain.L1Contracts
-	l1EthClient, err := node.DialEthClient(cfg.RPCs.L1RPC)
+func NewIndexer(chainConfig config.ChainConfig, rpcsConfig config.RPCsConfig, db *database.DB, logger log.Logger) (*Indexer, error) {
+	l1Contracts := chainConfig.L1Contracts
+	l1EthClient, err := node.DialEthClient(rpcsConfig.L1RPC)
 	if err != nil {
 		return nil, err
 	}
-	l1Processor, err := processor.NewL1Processor(cfg.Logger, l1EthClient, db, l1Contracts)
+	l1Processor, err := processor.NewL1Processor(logger, l1EthClient, db, l1Contracts)
 	if err != nil {
 		return nil, err
 	}
 
 	// L2Processor (predeploys). Although most likely the right setting, make this configurable?
 	l2Contracts := processor.L2ContractPredeploys()
-	l2EthClient, err := node.DialEthClient(cfg.RPCs.L2RPC)
+	l2EthClient, err := node.DialEthClient(rpcsConfig.L2RPC)
 	if err != nil {
 		return nil, err
 	}
-	l2Processor, err := processor.NewL2Processor(cfg.Logger, l2EthClient, db, l2Contracts)
+	l2Processor, err := processor.NewL2Processor(logger, l2EthClient, db, l2Contracts)
 	if err != nil {
 		return nil, err
 	}
 
 	indexer := &Indexer{
 		db:          db,
-		log:         cfg.Logger,
+		log:         logger,
 		L1Processor: l1Processor,
 		L2Processor: l2Processor,
 	}

indexer/indexer.toml

+# Chain configures l1 chain addresses
+# Can configure them manually or use a preset l2 ChainId for known chains including OP Mainnet, OP Goerli, Base, Base Goerli, Zora, and Zora goerli
 [chain]
+# OP Goerli
 preset = 420
-
 [rpcs]
 l1-rpc = "${INDEXER_RPC_URL_L1}"
 l2-rpc = "${INDEXER_RPC_URL_L2}"
@@ -20,3 +22,11 @@ port = 8080
 host = "127.0.0.1"
 port = 7300
 
+[logger]
+# Log level: trace, debug, info, warn, error, crit. Capitals are accepted too.
+level = "info"
+# Color the log output. Defaults to true if terminal is detected.
+color = true
+# Format the log output. Supported formats: 'text', 'terminal', 'logfmt', 'json', 'json-pretty'
+format = "terminal"
+

indexer/processor/l1_processor.go

@@ -6,8 +6,8 @@ import (
 	"errors"
 	"fmt"
 	"math/big"
-	"reflect"
 
+	"github.com/ethereum-optimism/optimism/indexer/config"
 	"github.com/ethereum-optimism/optimism/indexer/database"
 	"github.com/ethereum-optimism/optimism/indexer/node"
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
@@ -23,32 +23,6 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 )
 
-type L1Contracts struct {
-	OptimismPortal         common.Address
-	L2OutputOracle         common.Address
-	L1CrossDomainMessenger common.Address
-	L1StandardBridge       common.Address
-	L1ERC721Bridge         common.Address
-
-	// Some more contracts -- ProxyAdmin, SystemConfig, etcc
-	// Ignore the auxiliary contracts?
-
-	// Legacy contracts? We'll add this in to index the legacy chain.
-	// Remove afterwards?
-}
-
-func (c L1Contracts) ToSlice() []common.Address {
-	fields := reflect.VisibleFields(reflect.TypeOf(c))
-	v := reflect.ValueOf(c)
-
-	contracts := make([]common.Address, len(fields))
-	for i, field := range fields {
-		contracts[i] = (v.FieldByName(field.Name).Interface()).(common.Address)
-	}
-
-	return contracts
-}
-
 type checkpointAbi struct {
 	l2OutputOracle             *abi.ABI
 	legacyStateCommitmentChain *abi.ABI
@@ -58,7 +32,7 @@ type L1Processor struct {
 	processor
 }
 
-func NewL1Processor(logger log.Logger, ethClient node.EthClient, db *database.DB, l1Contracts L1Contracts) (*L1Processor, error) {
+func NewL1Processor(logger log.Logger, ethClient node.EthClient, db *database.DB, l1Contracts config.L1Contracts) (*L1Processor, error) {
 	l1ProcessLog := logger.New("processor", "l1")
 	l1ProcessLog.Info("initializing processor")
 
@@ -107,7 +81,7 @@ func NewL1Processor(logger log.Logger, ethClient node.EthClient, db *database.DB
 	return l1Processor, nil
 }
 
-func l1ProcessFn(processLog log.Logger, ethClient node.EthClient, l1Contracts L1Contracts, checkpointAbi checkpointAbi) ProcessFn {
+func l1ProcessFn(processLog log.Logger, ethClient node.EthClient, l1Contracts config.L1Contracts, checkpointAbi checkpointAbi) ProcessFn {
 	rawEthClient := ethclient.NewClient(ethClient.RawRpcClient())
 
 	contractAddrs := l1Contracts.ToSlice()
@@ -261,7 +235,7 @@ func l1ProcessFn(processLog log.Logger, ethClient node.EthClient, l1Contracts L1
 	}
 }
 
-func l1ProcessContractEventsBridgeTransactions(processLog log.Logger, db *database.DB, l1Contracts L1Contracts, events *ProcessedContractEvents) error {
+func l1ProcessContractEventsBridgeTransactions(processLog log.Logger, db *database.DB, l1Contracts config.L1Contracts, events *ProcessedContractEvents) error {
 	// (1) Process New Deposits
 	portalDeposits, err := OptimismPortalTransactionDepositEvents(events)
 	if err != nil {
@@ -294,6 +268,7 @@ func l1ProcessContractEventsBridgeTransactions(processLog log.Logger, db *databa
 				TransactionSourceHash: depositTx.SourceHash,
 				Tx:                    transactionDeposits[i].Tx,
 				TokenPair: database.TokenPair{
+					// TODO index eth token if it doesn't exist
 					L1TokenAddress: predeploys.LegacyERC20ETHAddr,
 					L2TokenAddress: predeploys.LegacyERC20ETHAddr,
 				},
@@ -492,6 +467,7 @@ func l1ProcessContractEventsStandardBridge(processLog log.Logger, db *database.D
 		deposits[i] = &database.L1BridgeDeposit{
 			TransactionSourceHash:     depositTx.SourceHash,
 			CrossDomainMessengerNonce: &database.U256{Int: initiatedBridgeEvent.CrossDomainMessengerNonce},
+			// TODO index the tokens pairs if they don't exist
 			TokenPair: database.TokenPair{L1TokenAddress: initiatedBridgeEvent.LocalToken, L2TokenAddress: initiatedBridgeEvent.RemoteToken},
 			Tx: database.Transaction{
 				FromAddress: initiatedBridgeEvent.From,

packages/core-utils/package.json

@@ -49,7 +49,7 @@
     "node-fetch": "^2.6.7"
   },
   "devDependencies": {
-    "@types/node": "^12.12.6",
+    "@types/node": "^20.5.0",
     "mocha": "^10.0.0"
   }
 }