Merge branch 'develop' into felipe/rewrite-debug-getRawReceipts

indexer/cmd/indexer-refresh/README.md

+# indexer/cmd/indexer-refresh
+
+Entrypoint for the new WIP indexer.   After project is deployed and stable we will delete the [indexer/main.go](../indexer/main.go) file and move [indexer-refresh/main.go](./main.go) in it's place.
+

indexer/cmd/indexer-refresh/main.go

+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/urfave/cli"
+
+	"github.com/ethereum-optimism/optimism/indexer"
+	"github.com/ethereum-optimism/optimism/indexer/flags"
+)
+
+var (
+	GitVersion = ""
+	GitCommit  = ""
+	GitDate    = ""
+)
+
+func main() {
+	// Set up logger with a default INFO level in case we fail to parse flags.
+	// Otherwise the final crtiical log won't show what the parsing error was.
+	log.Root().SetHandler(
+		log.LvlFilterHandler(
+			log.LvlInfo,
+			log.StreamHandler(os.Stdout, log.TerminalFormat(true)),
+		),
+	)
+
+	app := cli.NewApp()
+	app.Flags = flags.Flags
+	app.Version = fmt.Sprintf("%s-%s", GitVersion, params.VersionWithCommit(GitCommit, GitDate))
+	app.Name = "indexer"
+	app.Usage = "Indexer Service"
+	app.Description = "Service for indexing deposits and withdrawals " +
+		"by account on L1 and L2"
+
+	app.Action = indexer.Main(GitVersion)
+	err := app.Run(os.Args)
+	if err != nil {
+		log.Crit("Application failed", "message", err)
+	}
+}

indexer/cmd/indexer/main.go

@@ -8,8 +8,8 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/urfave/cli"
 
-	"github.com/ethereum-optimism/optimism/indexer"
 	"github.com/ethereum-optimism/optimism/indexer/flags"
+	"github.com/ethereum-optimism/optimism/indexer/legacy"
 )
 
 var (
@@ -36,7 +36,7 @@ func main() {
 	app.Description = "Service for indexing deposits and withdrawals " +
 		"by account on L1 and L2"
 
-	app.Action = indexer.Main(GitVersion)
+	app.Action = legacy.Main(GitVersion)
 	err := app.Run(os.Args)
 	if err != nil {
 		log.Crit("Application failed", "message", err)

indexer/docker-compose.yml

@@ -38,13 +38,27 @@ services:
       - INDEXER_REST_HOSTNAME=0.0.0.0
       - INDEXER_REST_PORT=8080
       - INDEXER_BEDROCK_L1_STANDARD_BRIDGE=0
-      - INDEXER_BEDROCK_L1_STANDARD_BRIDGE=0x636Af16bf2f682dD3109e60102b8E1A089FedAa8
-      - INDEXER_BEDROCK_OPTIMISM_PORTAL=0xB7040fd32359688346A3D1395a42114cf8E3b9b2
+      - INDEXER_BEDROCK_L1_STANDARD_BRIDGE=${INDEXER_BEDROCK_L1_STANDARD_BRIDGE:-0x636Af16bf2f682dD3109e60102b8E1A089FedAa8}
+      - INDEXER_BEDROCK_OPTIMISM_PORTAL=${INDEXER_BEDROCK_OPTIMISM_PORTAL:-0xB7040fd32359688346A3D1395a42114cf8E3b9b2}
+      - INDEXER_L1_ADDRESS_MANAGER_ADDRESS=${INDEXER_L1_ADDRESS_MANAGER_ADDRESS:-0xdE1FCfB0851916CA5101820A69b13a4E276bd81F}
     ports:
       - 8080:8080
     depends_on:
       postgres:
         condition: service_healthy
         
+  ui:
+    build:
+      context: ..
+      dockerfile: indexer/ui/Dockerfile
+    environment:
+      - DATABASE_URL=${DATABASE_URL:-postgresql://db_username:db_password@postgres:5432/db_name}
+    ports:
+      - 5555:5555
+    healthcheck:
+      test: wget localhost:5555 -q -O - > /dev/null 2>&1
+    depends_on:
+      postgres:
+        condition: service_healthy
 volumes:
   postgres_data:

indexer/example.env

@@ -2,3 +2,5 @@
 INDEXER_L1_ETH_RPC=FILL_ME_IN
 INDEXER_L2_ETH_RPC=FILL_ME_IN
 
+# Fill in to use prisma studio ui with a db other than the default
+# DATABASE_URL=FILL_ME_IN

indexer/indexer.go

@@ -2,28 +2,12 @@ package indexer
 
 import (
 	"context"
-	"fmt"
-	"math/big"
-	"net"
-	"net/http"
 	"os"
-	"strconv"
 	"time"
 
-	"github.com/ethereum-optimism/optimism/indexer/services"
-	"github.com/ethereum/go-ethereum/common"
-
-	"github.com/ethereum-optimism/optimism/indexer/metrics"
-	"github.com/ethereum-optimism/optimism/indexer/server"
-	"github.com/rs/cors"
-
-	database "github.com/ethereum-optimism/optimism/indexer/db"
-	"github.com/ethereum-optimism/optimism/indexer/services/l1"
-	"github.com/ethereum-optimism/optimism/indexer/services/l2"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rpc"
-	"github.com/gorilla/mux"
 	"github.com/urfave/cli"
 )
 
@@ -39,30 +23,7 @@ const (
 // e.g. GitVersion, to be captured and used once the function is executed.
 func Main(gitVersion string) func(ctx *cli.Context) error {
 	return func(ctx *cli.Context) error {
-		cfg, err := NewConfig(ctx)
-		if err != nil {
-			return err
-		}
-
 		log.Info("Initializing indexer")
-
-		indexer, err := NewIndexer(cfg)
-		if err != nil {
-			log.Error("Unable to create indexer", "error", err)
-			return err
-		}
-
-		log.Info("Starting indexer")
-
-		if err := indexer.Start(); err != nil {
-			return err
-		}
-		defer indexer.Stop()
-
-		log.Info("Indexer started")
-
-		<-(chan struct{})(nil)
-
 		return nil
 	}
 }
@@ -70,35 +31,23 @@ func Main(gitVersion string) func(ctx *cli.Context) error {
 // Indexer is a service that configures the necessary resources for
 // running the Sync and BlockHandler sub-services.
 type Indexer struct {
-	ctx      context.Context
-	cfg      Config
 	l1Client *ethclient.Client
 	l2Client *ethclient.Client
-
-	l1IndexingService *l1.Service
-	l2IndexingService *l2.Service
-	airdropService    *services.Airdrop
-
-	router  *mux.Router
-	metrics *metrics.Metrics
-	db      *database.Database
-	server  *http.Server
 }
 
 // NewIndexer initializes the Indexer, gathering any resources
 // that will be needed by the TxIndexer and StateIndexer
 // sub-services.
-func NewIndexer(cfg Config) (*Indexer, error) {
+func NewIndexer() (*Indexer, error) {
 	ctx := context.Background()
 
-	var logHandler log.Handler
-	if cfg.LogTerminal {
-		logHandler = log.StreamHandler(os.Stdout, log.TerminalFormat(true))
-	} else {
-		logHandler = log.StreamHandler(os.Stdout, log.JSONFormat())
-	}
-
-	logLevel, err := log.LvlFromString(cfg.LogLevel)
+	var logHandler log.Handler = log.StreamHandler(os.Stdout, log.TerminalFormat(true))
+	// TODO https://linear.app/optimism/issue/DX-55/api-implement-rest-api-with-mocked-data
+	// do json format too
+	// TODO https://linear.app/optimism/issue/DX-55/api-implement-rest-api-with-mocked-data
+	// pass in loglevel from config
+	// logHandler = log.StreamHandler(os.Stdout, log.JSONFormat())
+	logLevel, err := log.LvlFromString("info")
 	if err != nil {
 		return nil, err
 	}
@@ -107,182 +56,43 @@ func NewIndexer(cfg Config) (*Indexer, error) {
 
 	// Connect to L1 and L2 providers. Perform these last since they are the
 	// most expensive.
-	l1Client, rawl1Client, err := dialEthClientWithTimeout(ctx, cfg.L1EthRpc)
-	if err != nil {
-		return nil, err
-	}
-
-	l2Client, l2RPC, err := dialEthClientWithTimeout(ctx, cfg.L2EthRpc)
-	if err != nil {
-		return nil, err
-	}
-
-	m := metrics.NewMetrics(nil)
-
-	if cfg.MetricsServerEnable {
-		go func() {
-			_, err := m.Serve(cfg.MetricsHostname, cfg.MetricsPort)
-			if err != nil {
-				log.Error("metrics server failed to start", "err", err)
-			}
-		}()
-		log.Info("metrics server enabled", "host", cfg.MetricsHostname, "port", cfg.MetricsPort)
-	}
-
-	dsn := fmt.Sprintf("host=%s port=%d dbname=%s sslmode=disable",
-		cfg.DBHost, cfg.DBPort, cfg.DBName)
-	if cfg.DBUser != "" {
-		dsn += fmt.Sprintf(" user=%s", cfg.DBUser)
-	}
-	if cfg.DBPassword != "" {
-		dsn += fmt.Sprintf(" password=%s", cfg.DBPassword)
-	}
-	db, err := database.NewDatabase(dsn)
-	if err != nil {
-		return nil, err
-	}
-
-	var addrManager services.AddressManager
-	if cfg.Bedrock {
-		addrManager, err = services.NewBedrockAddresses(
-			l1Client,
-			cfg.BedrockL1StandardBridgeAddress,
-			cfg.BedrockOptimismPortalAddress,
-		)
-	} else {
-		addrManager, err = services.NewLegacyAddresses(l1Client, common.HexToAddress(cfg.L1AddressManagerAddress))
-	}
+	// TODO https://linear.app/optimism/issue/DX-55/api-implement-rest-api-with-mocked-data
+	// pass in rpc url from config
+	l1Client, _, err := dialEthClientWithTimeout(ctx, "http://localhost:8545")
 	if err != nil {
 		return nil, err
 	}
 
-	l1IndexingService, err := l1.NewService(l1.ServiceConfig{
-		Context:            ctx,
-		Metrics:            m,
-		L1Client:           l1Client,
-		RawL1Client:        rawl1Client,
-		ChainID:            new(big.Int).SetUint64(cfg.ChainID),
-		AddressManager:     addrManager,
-		DB:                 db,
-		ConfDepth:          cfg.L1ConfDepth,
-		MaxHeaderBatchSize: cfg.MaxHeaderBatchSize,
-		StartBlockNumber:   cfg.L1StartBlockNumber,
-		Bedrock:            cfg.Bedrock,
-	})
+	// TODO https://linear.app/optimism/issue/DX-55/api-implement-rest-api-with-mocked-data
+	// pass in rpc url from config
+	l2Client, _, err := dialEthClientWithTimeout(ctx, "http://localhost:9545")
 	if err != nil {
 		return nil, err
 	}
 
-	l2IndexingService, err := l2.NewService(l2.ServiceConfig{
-		Context:            ctx,
-		Metrics:            m,
-		L2RPC:              l2RPC,
-		L2Client:           l2Client,
-		DB:                 db,
-		ConfDepth:          cfg.L2ConfDepth,
-		MaxHeaderBatchSize: cfg.MaxHeaderBatchSize,
-		StartBlockNumber:   uint64(0),
-		Bedrock:            cfg.Bedrock,
-	})
 	if err != nil {
 		return nil, err
 	}
 
 	return &Indexer{
-		ctx:               ctx,
-		cfg:               cfg,
-		l1Client:          l1Client,
-		l2Client:          l2Client,
-		l1IndexingService: l1IndexingService,
-		l2IndexingService: l2IndexingService,
-		airdropService:    services.NewAirdrop(db, m),
-		router:            mux.NewRouter(),
-		metrics:           m,
-		db:                db,
+		l1Client: l1Client,
+		l2Client: l2Client,
 	}, nil
 }
 
 // Serve spins up a REST API server at the given hostname and port.
 func (b *Indexer) Serve() error {
-	c := cors.New(cors.Options{
-		AllowedOrigins: []string{"*"},
-	})
-
-	b.router.HandleFunc("/v1/l1/status", b.l1IndexingService.GetIndexerStatus).Methods("GET")
-	b.router.HandleFunc("/v1/l2/status", b.l2IndexingService.GetIndexerStatus).Methods("GET")
-	b.router.HandleFunc("/v1/deposits/0x{address:[a-fA-F0-9]{40}}", b.l1IndexingService.GetDeposits).Methods("GET")
-	b.router.HandleFunc("/v1/withdrawal/0x{hash:[a-fA-F0-9]{64}}", b.l2IndexingService.GetWithdrawalBatch).Methods("GET")
-	b.router.HandleFunc("/v1/withdrawals/0x{address:[a-fA-F0-9]{40}}", b.l2IndexingService.GetWithdrawals).Methods("GET")
-	b.router.HandleFunc("/v1/airdrops/0x{address:[a-fA-F0-9]{40}}", b.airdropService.GetAirdrop)
-	b.router.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(200)
-		_, err := w.Write([]byte("OK"))
-		if err != nil {
-			log.Error("Error handling /healthz", "error", err)
-		}
-	})
-
-	middleware := server.LoggingMiddleware(b.metrics, log.New("service", "server"))
-
-	port := strconv.FormatUint(b.cfg.RESTPort, 10)
-	addr := net.JoinHostPort(b.cfg.RESTHostname, port)
-
-	b.server = &http.Server{
-		Addr:    addr,
-		Handler: middleware(c.Handler(b.router)),
-	}
-
-	errCh := make(chan error, 1)
-
-	go func() {
-		errCh <- b.server.ListenAndServe()
-	}()
-
-	// Capture server startup errors
-	<-time.After(10 * time.Millisecond)
-
-	select {
-	case err := <-errCh:
-		return err
-	default:
-		log.Info("indexer REST server listening on", "addr", addr)
-		return nil
-	}
+	return nil
 }
 
 // Start starts the starts the indexing service on L1 and L2 chains and also
 // starts the REST server.
 func (b *Indexer) Start() error {
-	if b.cfg.DisableIndexer {
-		log.Info("indexer disabled, only serving data")
-	} else {
-		err := b.l1IndexingService.Start()
-		if err != nil {
-			return err
-		}
-		err = b.l2IndexingService.Start()
-		if err != nil {
-			return err
-		}
-	}
-
-	return b.Serve()
+	return nil
 }
 
 // Stop stops the indexing service on L1 and L2 chains.
 func (b *Indexer) Stop() {
-	b.db.Close()
-
-	if b.server != nil {
-		// background context here so it waits for
-		// conns to close
-		_ = b.server.Shutdown(context.Background())
-	}
-
-	if !b.cfg.DisableIndexer {
-		b.l1IndexingService.Stop()
-		b.l2IndexingService.Stop()
-	}
 }
 
 // dialL1EthClientWithTimeout attempts to dial the L1 provider using the

indexer/integration_tests/bedrock_test.go

@@ -20,8 +20,8 @@ import (
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/stretchr/testify/require"
 
-	"github.com/ethereum-optimism/optimism/indexer"
 	"github.com/ethereum-optimism/optimism/indexer/db"
+	"github.com/ethereum-optimism/optimism/indexer/legacy"
 	"github.com/ethereum-optimism/optimism/indexer/services/l1"
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
@@ -60,7 +60,7 @@ func TestBedrockIndexer(t *testing.T) {
 	l2Opts, err := bind.NewKeyedTransactorWithChainID(cfg.Secrets.Alice, cfg.L2ChainIDBig())
 	require.NoError(t, err)
 
-	idxrCfg := indexer.Config{
+	idxrCfg := legacy.Config{
 		ChainID:                        cfg.DeployConfig.L1ChainID,
 		L1EthRpc:                       sys.Nodes["l1"].HTTPEndpoint(),
 		L2EthRpc:                       sys.Nodes["sequencer"].HTTPEndpoint(),
@@ -83,7 +83,7 @@ func TestBedrockIndexer(t *testing.T) {
 		BedrockL1StandardBridgeAddress: cfg.DeployConfig.L1StandardBridgeProxy,
 		BedrockOptimismPortalAddress:   cfg.DeployConfig.OptimismPortalProxy,
 	}
-	idxr, err := indexer.NewIndexer(idxrCfg)
+	idxr, err := legacy.NewIndexer(idxrCfg)
 	require.NoError(t, err)
 
 	errCh := make(chan error, 1)

indexer/config.go → indexer/legacy/config.go

-package indexer
+package legacy
 
 import (
 	"errors"

indexer/config_test.go → indexer/legacy/config_test.go

-package indexer_test
+package legacy_test
 
 import (
 	"fmt"
 	"testing"
 
-	indexer "github.com/ethereum-optimism/optimism/indexer"
+	legacy "github.com/ethereum-optimism/optimism/indexer/legacy"
 	"github.com/stretchr/testify/require"
 )
 
 var validateConfigTests = []struct {
 	name   string
-	cfg    indexer.Config
+	cfg    legacy.Config
 	expErr error
 }{
 	{
 		name: "bad log level",
-		cfg: indexer.Config{
+		cfg: legacy.Config{
 			LogLevel: "unknown",
 		},
 		expErr: fmt.Errorf("unknown level: unknown"),
@@ -27,7 +27,7 @@ var validateConfigTests = []struct {
 func TestValidateConfig(t *testing.T) {
 	for _, test := range validateConfigTests {
 		t.Run(test.name, func(t *testing.T) {
-			err := indexer.ValidateConfig(&test.cfg)
+			err := legacy.ValidateConfig(&test.cfg)
 			require.Equal(t, err, test.expErr)
 		})
 	}

indexer/legacy/indexer.go

+package legacy
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"net"
+	"net/http"
+	"os"
+	"strconv"
+	"time"
+
+	"github.com/ethereum-optimism/optimism/indexer/services"
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/ethereum-optimism/optimism/indexer/metrics"
+	"github.com/ethereum-optimism/optimism/indexer/server"
+	"github.com/rs/cors"
+
+	database "github.com/ethereum-optimism/optimism/indexer/db"
+	"github.com/ethereum-optimism/optimism/indexer/services/l1"
+	"github.com/ethereum-optimism/optimism/indexer/services/l2"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/gorilla/mux"
+	"github.com/urfave/cli"
+)
+
+const (
+	// defaultDialTimeout is default duration the service will wait on
+	// startup to make a connection to either the L1 or L2 backends.
+	defaultDialTimeout = 5 * time.Second
+)
+
+// Main is the entrypoint into the indexer service. This method returns
+// a closure that executes the service and blocks until the service exits. The
+// use of a closure allows the parameters bound to the top-level main package,
+// e.g. GitVersion, to be captured and used once the function is executed.
+func Main(gitVersion string) func(ctx *cli.Context) error {
+	return func(ctx *cli.Context) error {
+		cfg, err := NewConfig(ctx)
+		if err != nil {
+			return err
+		}
+
+		log.Info("Initializing indexer")
+
+		indexer, err := NewIndexer(cfg)
+		if err != nil {
+			log.Error("Unable to create indexer", "error", err)
+			return err
+		}
+
+		log.Info("Starting indexer")
+
+		if err := indexer.Start(); err != nil {
+			return err
+		}
+		defer indexer.Stop()
+
+		log.Info("Indexer started")
+
+		<-(chan struct{})(nil)
+
+		return nil
+	}
+}
+
+// Indexer is a service that configures the necessary resources for
+// running the Sync and BlockHandler sub-services.
+type Indexer struct {
+	ctx      context.Context
+	cfg      Config
+	l1Client *ethclient.Client
+	l2Client *ethclient.Client
+
+	l1IndexingService *l1.Service
+	l2IndexingService *l2.Service
+	airdropService    *services.Airdrop
+
+	router  *mux.Router
+	metrics *metrics.Metrics
+	db      *database.Database
+	server  *http.Server
+}
+
+// NewIndexer initializes the Indexer, gathering any resources
+// that will be needed by the TxIndexer and StateIndexer
+// sub-services.
+func NewIndexer(cfg Config) (*Indexer, error) {
+	ctx := context.Background()
+
+	var logHandler log.Handler
+	if cfg.LogTerminal {
+		logHandler = log.StreamHandler(os.Stdout, log.TerminalFormat(true))
+	} else {
+		logHandler = log.StreamHandler(os.Stdout, log.JSONFormat())
+	}
+
+	logLevel, err := log.LvlFromString(cfg.LogLevel)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Root().SetHandler(log.LvlFilterHandler(logLevel, logHandler))
+
+	// Connect to L1 and L2 providers. Perform these last since they are the
+	// most expensive.
+	l1Client, rawl1Client, err := dialEthClientWithTimeout(ctx, cfg.L1EthRpc)
+	if err != nil {
+		return nil, err
+	}
+
+	l2Client, l2RPC, err := dialEthClientWithTimeout(ctx, cfg.L2EthRpc)
+	if err != nil {
+		return nil, err
+	}
+
+	m := metrics.NewMetrics(nil)
+
+	if cfg.MetricsServerEnable {
+		go func() {
+			_, err := m.Serve(cfg.MetricsHostname, cfg.MetricsPort)
+			if err != nil {
+				log.Error("metrics server failed to start", "err", err)
+			}
+		}()
+		log.Info("metrics server enabled", "host", cfg.MetricsHostname, "port", cfg.MetricsPort)
+	}
+
+	dsn := fmt.Sprintf("host=%s port=%d dbname=%s sslmode=disable",
+		cfg.DBHost, cfg.DBPort, cfg.DBName)
+	if cfg.DBUser != "" {
+		dsn += fmt.Sprintf(" user=%s", cfg.DBUser)
+	}
+	if cfg.DBPassword != "" {
+		dsn += fmt.Sprintf(" password=%s", cfg.DBPassword)
+	}
+	db, err := database.NewDatabase(dsn)
+	if err != nil {
+		return nil, err
+	}
+
+	var addrManager services.AddressManager
+	if cfg.Bedrock {
+		addrManager, err = services.NewBedrockAddresses(
+			l1Client,
+			cfg.BedrockL1StandardBridgeAddress,
+			cfg.BedrockOptimismPortalAddress,
+		)
+	} else {
+		addrManager, err = services.NewLegacyAddresses(l1Client, common.HexToAddress(cfg.L1AddressManagerAddress))
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	l1IndexingService, err := l1.NewService(l1.ServiceConfig{
+		Context:            ctx,
+		Metrics:            m,
+		L1Client:           l1Client,
+		RawL1Client:        rawl1Client,
+		ChainID:            new(big.Int).SetUint64(cfg.ChainID),
+		AddressManager:     addrManager,
+		DB:                 db,
+		ConfDepth:          cfg.L1ConfDepth,
+		MaxHeaderBatchSize: cfg.MaxHeaderBatchSize,
+		StartBlockNumber:   cfg.L1StartBlockNumber,
+		Bedrock:            cfg.Bedrock,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	l2IndexingService, err := l2.NewService(l2.ServiceConfig{
+		Context:            ctx,
+		Metrics:            m,
+		L2RPC:              l2RPC,
+		L2Client:           l2Client,
+		DB:                 db,
+		ConfDepth:          cfg.L2ConfDepth,
+		MaxHeaderBatchSize: cfg.MaxHeaderBatchSize,
+		StartBlockNumber:   uint64(0),
+		Bedrock:            cfg.Bedrock,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &Indexer{
+		ctx:               ctx,
+		cfg:               cfg,
+		l1Client:          l1Client,
+		l2Client:          l2Client,
+		l1IndexingService: l1IndexingService,
+		l2IndexingService: l2IndexingService,
+		airdropService:    services.NewAirdrop(db, m),
+		router:            mux.NewRouter(),
+		metrics:           m,
+		db:                db,
+	}, nil
+}
+
+// Serve spins up a REST API server at the given hostname and port.
+func (b *Indexer) Serve() error {
+	c := cors.New(cors.Options{
+		AllowedOrigins: []string{"*"},
+	})
+
+	b.router.HandleFunc("/v1/l1/status", b.l1IndexingService.GetIndexerStatus).Methods("GET")
+	b.router.HandleFunc("/v1/l2/status", b.l2IndexingService.GetIndexerStatus).Methods("GET")
+	b.router.HandleFunc("/v1/deposits/0x{address:[a-fA-F0-9]{40}}", b.l1IndexingService.GetDeposits).Methods("GET")
+	b.router.HandleFunc("/v1/withdrawal/0x{hash:[a-fA-F0-9]{64}}", b.l2IndexingService.GetWithdrawalBatch).Methods("GET")
+	b.router.HandleFunc("/v1/withdrawals/0x{address:[a-fA-F0-9]{40}}", b.l2IndexingService.GetWithdrawals).Methods("GET")
+	b.router.HandleFunc("/v1/airdrops/0x{address:[a-fA-F0-9]{40}}", b.airdropService.GetAirdrop)
+	b.router.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(200)
+		_, err := w.Write([]byte("OK"))
+		if err != nil {
+			log.Error("Error handling /healthz", "error", err)
+		}
+	})
+
+	middleware := server.LoggingMiddleware(b.metrics, log.New("service", "server"))
+
+	port := strconv.FormatUint(b.cfg.RESTPort, 10)
+	addr := net.JoinHostPort(b.cfg.RESTHostname, port)
+
+	b.server = &http.Server{
+		Addr:    addr,
+		Handler: middleware(c.Handler(b.router)),
+	}
+
+	errCh := make(chan error, 1)
+
+	go func() {
+		errCh <- b.server.ListenAndServe()
+	}()
+
+	// Capture server startup errors
+	<-time.After(10 * time.Millisecond)
+
+	select {
+	case err := <-errCh:
+		return err
+	default:
+		log.Info("indexer REST server listening on", "addr", addr)
+		return nil
+	}
+}
+
+// Start starts the starts the indexing service on L1 and L2 chains and also
+// starts the REST server.
+func (b *Indexer) Start() error {
+	if b.cfg.DisableIndexer {
+		log.Info("indexer disabled, only serving data")
+	} else {
+		err := b.l1IndexingService.Start()
+		if err != nil {
+			return err
+		}
+		err = b.l2IndexingService.Start()
+		if err != nil {
+			return err
+		}
+	}
+
+	return b.Serve()
+}
+
+// Stop stops the indexing service on L1 and L2 chains.
+func (b *Indexer) Stop() {
+	b.db.Close()
+
+	if b.server != nil {
+		// background context here so it waits for
+		// conns to close
+		_ = b.server.Shutdown(context.Background())
+	}
+
+	if !b.cfg.DisableIndexer {
+		b.l1IndexingService.Stop()
+		b.l2IndexingService.Stop()
+	}
+}
+
+// dialL1EthClientWithTimeout attempts to dial the L1 provider using the
+// provided URL. If the dial doesn't complete within defaultDialTimeout seconds,
+// this method will return an error.
+func dialEthClientWithTimeout(ctx context.Context, url string) (
+	*ethclient.Client, *rpc.Client, error) {
+
+	ctxt, cancel := context.WithTimeout(ctx, defaultDialTimeout)
+	defer cancel()
+
+	c, err := rpc.DialContext(ctxt, url)
+	if err != nil {
+		return nil, nil, err
+	}
+	return ethclient.NewClient(c), c, nil
+}

indexer/ui/Dockerfile

+FROM node:18.16.0-bullseye-slim
+
+WORKDIR /app
+
+RUN echo {} > package.json && \
+  npm install prisma
+
+COPY indexer/ui/schema.prisma schema.prisma
+
+RUN npx prisma generate --schema schema.prisma
+
+CMD ["npx", "prisma", "studio", "--port", "5555", "--hostname", "0.0.0.0", "--schema", "schema.prisma" ]

indexer/ui/README.md

+## @eth-optimism/indexer-ui
+
+A simple UI for exploring the indexer DB using [Prisma studio](https://www.prisma.io)
+
+## Usage
+
+Included in the docker-compose file as `ui` service
+
+```bash
+docker-compose up
+```
+
+Prisma can be viewed at [localhost:5555](http://localhost:5555)
+
+## Update the schema
+
+The [prisma schema](https://www.prisma.io/docs/reference/api-reference/prisma-schema-reference) is what allows prisma to work. It is automatically generated from the db schema.
+
+To update the schema to the latest db schema simply pass in the database url to [prisma pull](https://www.prisma.io/docs/reference/api-reference/command-reference#db-pull). Prisma pull will introspect the schema and generate a prisma schema
+
+```bash
+DATABASE_URL=postgresql://db_username:db_password@postgres:5432/db_name npx prisma db pull
+```
+
+## Other functionality
+
+We mostly just use prisma as a UI. But brisma provides much other functionality that can be useful including.
+
+- Ability to change the [db schema](https://www.prisma.io/docs/reference/api-reference/command-reference#db-push) direction from modifying the [schema.prisma](./schema.prisma) in place. This can be a fast way to [start prototyping](https://www.prisma.io/docs/guides/migrate/prototyping-schema-db-push)
+- Ability to [seed the database](https://www.prisma.io/docs/guides/migrate/seed-database)
+- Ability to write quick scripts with [prisma client](https://www.prisma.io/docs/reference/api-reference/prisma-client-reference)
+
+## Running prisma studio outside of docker
+
+Prisma can also be run with [npx](https://docs.npmjs.com/cli/v8/commands/npx)
+
+```bash
+npx prisma studio --schema indexer/ui/schema.prisma
+```

indexer/ui/schema.prisma

+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model airdrops {
+  address                String @id @db.VarChar(42)
+  voter_amount           String @default("0") @db.VarChar
+  multisig_signer_amount String @default("0") @db.VarChar
+  gitcoin_amount         String @default("0") @db.VarChar
+  active_bridged_amount  String @default("0") @db.VarChar
+  op_user_amount         String @default("0") @db.VarChar
+  op_repeat_user_amount  String @default("0") @db.VarChar
+  op_og_amount           String @default("0") @db.VarChar
+  bonus_amount           String @default("0") @db.VarChar
+  total_amount           String @db.VarChar
+}
+
+model deposits {
+  guid         String    @id @db.VarChar
+  from_address String    @db.VarChar
+  to_address   String    @db.VarChar
+  l1_token     String    @db.VarChar
+  l2_token     String    @db.VarChar
+  amount       String    @db.VarChar
+  data         Bytes
+  log_index    Int
+  block_hash   String    @db.VarChar
+  tx_hash      String    @db.VarChar
+  l1_blocks    l1_blocks @relation(fields: [block_hash], references: [hash], onDelete: NoAction, onUpdate: NoAction)
+  l1_tokens    l1_tokens @relation(fields: [l1_token], references: [address], onDelete: NoAction, onUpdate: NoAction)
+}
+
+model l1_blocks {
+  hash          String          @id @db.VarChar
+  parent_hash   String          @db.VarChar
+  number        Int             @unique(map: "l1_blocks_number")
+  timestamp     Int
+  deposits      deposits[]
+  state_batches state_batches[]
+}
+
+model l1_tokens {
+  address  String     @id @db.VarChar
+  name     String     @db.VarChar
+  symbol   String     @db.VarChar
+  decimals Int
+  deposits deposits[]
+}
+
+model l2_blocks {
+  hash        String        @id @db.VarChar
+  parent_hash String        @db.VarChar
+  number      Int           @unique(map: "l2_blocks_number")
+  timestamp   Int
+  withdrawals withdrawals[]
+}
+
+model l2_tokens {
+  address     String        @id
+  name        String
+  symbol      String
+  decimals    Int
+  withdrawals withdrawals[]
+}
+
+model state_batches {
+  index       Int           @id
+  root        String        @db.VarChar
+  size        Int
+  prev_total  Int
+  extra_data  Bytes
+  block_hash  String        @db.VarChar
+  l1_blocks   l1_blocks     @relation(fields: [block_hash], references: [hash], onDelete: NoAction, onUpdate: NoAction)
+  withdrawals withdrawals[]
+
+  @@index([block_hash], map: "state_batches_block_hash")
+  @@index([prev_total], map: "state_batches_prev_total")
+  @@index([size], map: "state_batches_size")
+}
+
+model withdrawals {
+  guid                              String         @id @db.VarChar
+  from_address                      String         @db.VarChar
+  to_address                        String         @db.VarChar
+  l1_token                          String         @db.VarChar
+  l2_token                          String         @db.VarChar
+  amount                            String         @db.VarChar
+  data                              Bytes
+  log_index                         Int
+  block_hash                        String         @db.VarChar
+  tx_hash                           String         @db.VarChar
+  state_batch                       Int?
+  br_withdrawal_hash                String?        @db.VarChar
+  br_withdrawal_proven_tx_hash      String?        @db.VarChar
+  br_withdrawal_proven_log_index    Int?
+  br_withdrawal_finalized_tx_hash   String?        @db.VarChar
+  br_withdrawal_finalized_log_index Int?
+  br_withdrawal_finalized_success   Boolean?
+  l2_blocks                         l2_blocks      @relation(map: "l2", fields: [block_hash], references: [hash], onDelete: NoAction, onUpdate: NoAction)
+  l2_tokens                         l2_tokens      @relation(fields: [l2_token], references: [address], onDelete: NoAction, onUpdate: NoAction)
+  state_batches                     state_batches? @relation(fields: [state_batch], references: [index], onDelete: NoAction, onUpdate: NoAction)
+
+  @@index([br_withdrawal_hash], map: "withdrawals_br_withdrawal_hash")
+}

op-batcher/batcher/batch_submitter.go

@@ -4,9 +4,6 @@ import (
 	"context"
 	"fmt"
 	_ "net/http/pprof"
-	"os"
-	"os/signal"
-	"syscall"
 
 	gethrpc "github.com/ethereum/go-ethereum/rpc"
 	"github.com/urfave/cli"
@@ -16,6 +13,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-batcher/rpc"
 	opservice "github.com/ethereum-optimism/optimism/op-service"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
+	"github.com/ethereum-optimism/optimism/op-service/opio"
 	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
 	oprpc "github.com/ethereum-optimism/optimism/op-service/rpc"
 )
@@ -98,14 +96,7 @@ func Main(version string, cliCtx *cli.Context) error {
 	m.RecordInfo(version)
 	m.RecordUp()
 
-	interruptChannel := make(chan os.Signal, 1)
-	signal.Notify(interruptChannel, []os.Signal{
-		os.Interrupt,
-		os.Kill,
-		syscall.SIGTERM,
-		syscall.SIGQUIT,
-	}...)
-	<-interruptChannel
+	opio.BlockOnInterrupts()
 	if err := server.Stop(); err != nil {
 		l.Error("Error shutting down http server: %w", err)
 	}

op-bindings/Makefile

@@ -30,7 +30,8 @@ bindings: l1block-bindings \
 	optimism-mintable-erc721-factory-bindings \
 	l1-fee-vault-bindings \
 	basefee-vault-bindings \
-	legacy-erc20-eth-bindings
+	legacy-erc20-eth-bindings \
+	dispute-game-factory-bindings
 
 version:
 	forge --version
@@ -122,6 +123,9 @@ deployer-whitelist-bindings: compile
 l1-blocknumber-bindings: compile
 	./gen_bindings.sh contracts/legacy/L1BlockNumber.sol:L1BlockNumber $(pkg)
 
+dispute-game-factory-bindings: compile
+	./gen_bindings.sh contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory $(pkg)
+
 more:
 	go run ./gen/main.go \
 		-artifacts ../packages/contracts-bedrock/artifacts \

op-bindings/bindings/disputegamefactory.go

+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package bindings
+
+import (
+	"errors"
+	"math/big"
+	"strings"
+
+	ethereum "github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/event"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var (
+	_ = errors.New
+	_ = big.NewInt
+	_ = strings.NewReader
+	_ = ethereum.NotFound
+	_ = bind.Bind
+	_ = common.Big1
+	_ = types.BloomLookup
+	_ = event.NewSubscription
+)
+
+// DisputeGameFactoryMetaData contains all meta data concerning the DisputeGameFactory contract.
+var DisputeGameFactoryMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"Hash\",\"name\":\"uuid\",\"type\":\"bytes32\"}],\"name\":\"GameAlreadyExists\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"enumGameType\",\"name\":\"gameType\",\"type\":\"uint8\"}],\"name\":\"NoImplementation\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"disputeProxy\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"enumGameType\",\"name\":\"gameType\",\"type\":\"uint8\"},{\"indexed\":true,\"internalType\":\"Claim\",\"name\":\"rootClaim\",\"type\":\"bytes32\"}],\"name\":\"DisputeGameCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"impl\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"enumGameType\",\"name\":\"gameType\",\"type\":\"uint8\"}],\"name\":\"ImplementationSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"enumGameType\",\"name\":\"gameType\",\"type\":\"uint8\"},{\"internalType\":\"Claim\",\"name\":\"rootClaim\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"create\",\"outputs\":[{\"internalType\":\"contractIDisputeGame\",\"name\":\"proxy\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumGameType\",\"name\":\"\",\"type\":\"uint8\"}],\"name\":\"gameImpls\",\"outputs\":[{\"internalType\":\"contractIDisputeGame\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumGameType\",\"name\":\"gameType\",\"type\":\"uint8\"},{\"internalType\":\"Claim\",\"name\":\"rootClaim\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"games\",\"outputs\":[{\"internalType\":\"contractIDisputeGame\",\"name\":\"_proxy\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumGameType\",\"name\":\"gameType\",\"type\":\"uint8\"},{\"internalType\":\"Claim\",\"name\":\"rootClaim\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"getGameUUID\",\"outputs\":[{\"internalType\":\"Hash\",\"name\":\"_uuid\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumGameType\",\"name\":\"gameType\",\"type\":\"uint8\"},{\"internalType\":\"contractIDisputeGame\",\"name\":\"impl\",\"type\":\"address\"}],\"name\":\"setImplementation\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
+	Bin: "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",
+}
+
+// DisputeGameFactoryABI is the input ABI used to generate the binding from.
+// Deprecated: Use DisputeGameFactoryMetaData.ABI instead.
+var DisputeGameFactoryABI = DisputeGameFactoryMetaData.ABI
+
+// DisputeGameFactoryBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use DisputeGameFactoryMetaData.Bin instead.
+var DisputeGameFactoryBin = DisputeGameFactoryMetaData.Bin
+
+// DeployDisputeGameFactory deploys a new Ethereum contract, binding an instance of DisputeGameFactory to it.
+func DeployDisputeGameFactory(auth *bind.TransactOpts, backend bind.ContractBackend, _owner common.Address) (common.Address, *types.Transaction, *DisputeGameFactory, error) {
+	parsed, err := DisputeGameFactoryMetaData.GetAbi()
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	if parsed == nil {
+		return common.Address{}, nil, nil, errors.New("GetABI returned nil")
+	}
+
+	address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(DisputeGameFactoryBin), backend, _owner)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &DisputeGameFactory{DisputeGameFactoryCaller: DisputeGameFactoryCaller{contract: contract}, DisputeGameFactoryTransactor: DisputeGameFactoryTransactor{contract: contract}, DisputeGameFactoryFilterer: DisputeGameFactoryFilterer{contract: contract}}, nil
+}
+
+// DisputeGameFactory is an auto generated Go binding around an Ethereum contract.
+type DisputeGameFactory struct {
+	DisputeGameFactoryCaller     // Read-only binding to the contract
+	DisputeGameFactoryTransactor // Write-only binding to the contract
+	DisputeGameFactoryFilterer   // Log filterer for contract events
+}
+
+// DisputeGameFactoryCaller is an auto generated read-only Go binding around an Ethereum contract.
+type DisputeGameFactoryCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DisputeGameFactoryTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type DisputeGameFactoryTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DisputeGameFactoryFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type DisputeGameFactoryFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DisputeGameFactorySession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type DisputeGameFactorySession struct {
+	Contract     *DisputeGameFactory // Generic contract binding to set the session for
+	CallOpts     bind.CallOpts       // Call options to use throughout this session
+	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
+}
+
+// DisputeGameFactoryCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type DisputeGameFactoryCallerSession struct {
+	Contract *DisputeGameFactoryCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts             // Call options to use throughout this session
+}
+
+// DisputeGameFactoryTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type DisputeGameFactoryTransactorSession struct {
+	Contract     *DisputeGameFactoryTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts             // Transaction auth options to use throughout this session
+}
+
+// DisputeGameFactoryRaw is an auto generated low-level Go binding around an Ethereum contract.
+type DisputeGameFactoryRaw struct {
+	Contract *DisputeGameFactory // Generic contract binding to access the raw methods on
+}
+
+// DisputeGameFactoryCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type DisputeGameFactoryCallerRaw struct {
+	Contract *DisputeGameFactoryCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// DisputeGameFactoryTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type DisputeGameFactoryTransactorRaw struct {
+	Contract *DisputeGameFactoryTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewDisputeGameFactory creates a new instance of DisputeGameFactory, bound to a specific deployed contract.
+func NewDisputeGameFactory(address common.Address, backend bind.ContractBackend) (*DisputeGameFactory, error) {
+	contract, err := bindDisputeGameFactory(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &DisputeGameFactory{DisputeGameFactoryCaller: DisputeGameFactoryCaller{contract: contract}, DisputeGameFactoryTransactor: DisputeGameFactoryTransactor{contract: contract}, DisputeGameFactoryFilterer: DisputeGameFactoryFilterer{contract: contract}}, nil
+}
+
+// NewDisputeGameFactoryCaller creates a new read-only instance of DisputeGameFactory, bound to a specific deployed contract.
+func NewDisputeGameFactoryCaller(address common.Address, caller bind.ContractCaller) (*DisputeGameFactoryCaller, error) {
+	contract, err := bindDisputeGameFactory(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &DisputeGameFactoryCaller{contract: contract}, nil
+}
+
+// NewDisputeGameFactoryTransactor creates a new write-only instance of DisputeGameFactory, bound to a specific deployed contract.
+func NewDisputeGameFactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*DisputeGameFactoryTransactor, error) {
+	contract, err := bindDisputeGameFactory(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &DisputeGameFactoryTransactor{contract: contract}, nil
+}
+
+// NewDisputeGameFactoryFilterer creates a new log filterer instance of DisputeGameFactory, bound to a specific deployed contract.
+func NewDisputeGameFactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*DisputeGameFactoryFilterer, error) {
+	contract, err := bindDisputeGameFactory(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &DisputeGameFactoryFilterer{contract: contract}, nil
+}
+
+// bindDisputeGameFactory binds a generic wrapper to an already deployed contract.
+func bindDisputeGameFactory(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := abi.JSON(strings.NewReader(DisputeGameFactoryABI))
+	if err != nil {
+		return nil, err
+	}
+	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (_DisputeGameFactory *DisputeGameFactoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _DisputeGameFactory.Contract.DisputeGameFactoryCaller.contract.Call(opts, result, method, params...)
+}
+
+// Transfer initiates a plain transaction to move funds to the contract, calling
+// its default method if one is available.
+func (_DisputeGameFactory *DisputeGameFactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _DisputeGameFactory.Contract.DisputeGameFactoryTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_DisputeGameFactory *DisputeGameFactoryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _DisputeGameFactory.Contract.DisputeGameFactoryTransactor.contract.Transact(opts, method, params...)
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (_DisputeGameFactory *DisputeGameFactoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _DisputeGameFactory.Contract.contract.Call(opts, result, method, params...)
+}
+
+// Transfer initiates a plain transaction to move funds to the contract, calling
+// its default method if one is available.
+func (_DisputeGameFactory *DisputeGameFactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _DisputeGameFactory.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_DisputeGameFactory *DisputeGameFactoryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _DisputeGameFactory.Contract.contract.Transact(opts, method, params...)
+}
+
+// GameImpls is a free data retrieval call binding the contract method 0xdfa162d3.
+//
+// Solidity: function gameImpls(uint8 ) view returns(address)
+func (_DisputeGameFactory *DisputeGameFactoryCaller) GameImpls(opts *bind.CallOpts, arg0 uint8) (common.Address, error) {
+	var out []interface{}
+	err := _DisputeGameFactory.contract.Call(opts, &out, "gameImpls", arg0)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// GameImpls is a free data retrieval call binding the contract method 0xdfa162d3.
+//
+// Solidity: function gameImpls(uint8 ) view returns(address)
+func (_DisputeGameFactory *DisputeGameFactorySession) GameImpls(arg0 uint8) (common.Address, error) {
+	return _DisputeGameFactory.Contract.GameImpls(&_DisputeGameFactory.CallOpts, arg0)
+}
+
+// GameImpls is a free data retrieval call binding the contract method 0xdfa162d3.
+//
+// Solidity: function gameImpls(uint8 ) view returns(address)
+func (_DisputeGameFactory *DisputeGameFactoryCallerSession) GameImpls(arg0 uint8) (common.Address, error) {
+	return _DisputeGameFactory.Contract.GameImpls(&_DisputeGameFactory.CallOpts, arg0)
+}
+
+// Games is a free data retrieval call binding the contract method 0xc49d5271.
+//
+// Solidity: function games(uint8 gameType, bytes32 rootClaim, bytes extraData) view returns(address _proxy)
+func (_DisputeGameFactory *DisputeGameFactoryCaller) Games(opts *bind.CallOpts, gameType uint8, rootClaim [32]byte, extraData []byte) (common.Address, error) {
+	var out []interface{}
+	err := _DisputeGameFactory.contract.Call(opts, &out, "games", gameType, rootClaim, extraData)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// Games is a free data retrieval call binding the contract method 0xc49d5271.
+//
+// Solidity: function games(uint8 gameType, bytes32 rootClaim, bytes extraData) view returns(address _proxy)
+func (_DisputeGameFactory *DisputeGameFactorySession) Games(gameType uint8, rootClaim [32]byte, extraData []byte) (common.Address, error) {
+	return _DisputeGameFactory.Contract.Games(&_DisputeGameFactory.CallOpts, gameType, rootClaim, extraData)
+}
+
+// Games is a free data retrieval call binding the contract method 0xc49d5271.
+//
+// Solidity: function games(uint8 gameType, bytes32 rootClaim, bytes extraData) view returns(address _proxy)
+func (_DisputeGameFactory *DisputeGameFactoryCallerSession) Games(gameType uint8, rootClaim [32]byte, extraData []byte) (common.Address, error) {
+	return _DisputeGameFactory.Contract.Games(&_DisputeGameFactory.CallOpts, gameType, rootClaim, extraData)
+}
+
+// GetGameUUID is a free data retrieval call binding the contract method 0x26daafbe.
+//
+// Solidity: function getGameUUID(uint8 gameType, bytes32 rootClaim, bytes extraData) pure returns(bytes32 _uuid)
+func (_DisputeGameFactory *DisputeGameFactoryCaller) GetGameUUID(opts *bind.CallOpts, gameType uint8, rootClaim [32]byte, extraData []byte) ([32]byte, error) {
+	var out []interface{}
+	err := _DisputeGameFactory.contract.Call(opts, &out, "getGameUUID", gameType, rootClaim, extraData)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// GetGameUUID is a free data retrieval call binding the contract method 0x26daafbe.
+//
+// Solidity: function getGameUUID(uint8 gameType, bytes32 rootClaim, bytes extraData) pure returns(bytes32 _uuid)
+func (_DisputeGameFactory *DisputeGameFactorySession) GetGameUUID(gameType uint8, rootClaim [32]byte, extraData []byte) ([32]byte, error) {
+	return _DisputeGameFactory.Contract.GetGameUUID(&_DisputeGameFactory.CallOpts, gameType, rootClaim, extraData)
+}
+
+// GetGameUUID is a free data retrieval call binding the contract method 0x26daafbe.
+//
+// Solidity: function getGameUUID(uint8 gameType, bytes32 rootClaim, bytes extraData) pure returns(bytes32 _uuid)
+func (_DisputeGameFactory *DisputeGameFactoryCallerSession) GetGameUUID(gameType uint8, rootClaim [32]byte, extraData []byte) ([32]byte, error) {
+	return _DisputeGameFactory.Contract.GetGameUUID(&_DisputeGameFactory.CallOpts, gameType, rootClaim, extraData)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_DisputeGameFactory *DisputeGameFactoryCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _DisputeGameFactory.contract.Call(opts, &out, "owner")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_DisputeGameFactory *DisputeGameFactorySession) Owner() (common.Address, error) {
+	return _DisputeGameFactory.Contract.Owner(&_DisputeGameFactory.CallOpts)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_DisputeGameFactory *DisputeGameFactoryCallerSession) Owner() (common.Address, error) {
+	return _DisputeGameFactory.Contract.Owner(&_DisputeGameFactory.CallOpts)
+}
+
+// Create is a paid mutator transaction binding the contract method 0x3142e55e.
+//
+// Solidity: function create(uint8 gameType, bytes32 rootClaim, bytes extraData) returns(address proxy)
+func (_DisputeGameFactory *DisputeGameFactoryTransactor) Create(opts *bind.TransactOpts, gameType uint8, rootClaim [32]byte, extraData []byte) (*types.Transaction, error) {
+	return _DisputeGameFactory.contract.Transact(opts, "create", gameType, rootClaim, extraData)
+}
+
+// Create is a paid mutator transaction binding the contract method 0x3142e55e.
+//
+// Solidity: function create(uint8 gameType, bytes32 rootClaim, bytes extraData) returns(address proxy)
+func (_DisputeGameFactory *DisputeGameFactorySession) Create(gameType uint8, rootClaim [32]byte, extraData []byte) (*types.Transaction, error) {
+	return _DisputeGameFactory.Contract.Create(&_DisputeGameFactory.TransactOpts, gameType, rootClaim, extraData)
+}
+
+// Create is a paid mutator transaction binding the contract method 0x3142e55e.
+//
+// Solidity: function create(uint8 gameType, bytes32 rootClaim, bytes extraData) returns(address proxy)
+func (_DisputeGameFactory *DisputeGameFactoryTransactorSession) Create(gameType uint8, rootClaim [32]byte, extraData []byte) (*types.Transaction, error) {
+	return _DisputeGameFactory.Contract.Create(&_DisputeGameFactory.TransactOpts, gameType, rootClaim, extraData)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_DisputeGameFactory *DisputeGameFactoryTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _DisputeGameFactory.contract.Transact(opts, "renounceOwnership")
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_DisputeGameFactory *DisputeGameFactorySession) RenounceOwnership() (*types.Transaction, error) {
+	return _DisputeGameFactory.Contract.RenounceOwnership(&_DisputeGameFactory.TransactOpts)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_DisputeGameFactory *DisputeGameFactoryTransactorSession) RenounceOwnership() (*types.Transaction, error) {
+	return _DisputeGameFactory.Contract.RenounceOwnership(&_DisputeGameFactory.TransactOpts)
+}
+
+// SetImplementation is a paid mutator transaction binding the contract method 0x45583b7a.
+//
+// Solidity: function setImplementation(uint8 gameType, address impl) returns()
+func (_DisputeGameFactory *DisputeGameFactoryTransactor) SetImplementation(opts *bind.TransactOpts, gameType uint8, impl common.Address) (*types.Transaction, error) {
+	return _DisputeGameFactory.contract.Transact(opts, "setImplementation", gameType, impl)
+}
+
+// SetImplementation is a paid mutator transaction binding the contract method 0x45583b7a.
+//
+// Solidity: function setImplementation(uint8 gameType, address impl) returns()
+func (_DisputeGameFactory *DisputeGameFactorySession) SetImplementation(gameType uint8, impl common.Address) (*types.Transaction, error) {
+	return _DisputeGameFactory.Contract.SetImplementation(&_DisputeGameFactory.TransactOpts, gameType, impl)
+}
+
+// SetImplementation is a paid mutator transaction binding the contract method 0x45583b7a.
+//
+// Solidity: function setImplementation(uint8 gameType, address impl) returns()
+func (_DisputeGameFactory *DisputeGameFactoryTransactorSession) SetImplementation(gameType uint8, impl common.Address) (*types.Transaction, error) {
+	return _DisputeGameFactory.Contract.SetImplementation(&_DisputeGameFactory.TransactOpts, gameType, impl)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_DisputeGameFactory *DisputeGameFactoryTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
+	return _DisputeGameFactory.contract.Transact(opts, "transferOwnership", newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_DisputeGameFactory *DisputeGameFactorySession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _DisputeGameFactory.Contract.TransferOwnership(&_DisputeGameFactory.TransactOpts, newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_DisputeGameFactory *DisputeGameFactoryTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _DisputeGameFactory.Contract.TransferOwnership(&_DisputeGameFactory.TransactOpts, newOwner)
+}
+
+// DisputeGameFactoryDisputeGameCreatedIterator is returned from FilterDisputeGameCreated and is used to iterate over the raw logs and unpacked data for DisputeGameCreated events raised by the DisputeGameFactory contract.
+type DisputeGameFactoryDisputeGameCreatedIterator struct {
+	Event *DisputeGameFactoryDisputeGameCreated // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *DisputeGameFactoryDisputeGameCreatedIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(DisputeGameFactoryDisputeGameCreated)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(DisputeGameFactoryDisputeGameCreated)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error returns any retrieval or parsing error occurred during filtering.
+func (it *DisputeGameFactoryDisputeGameCreatedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *DisputeGameFactoryDisputeGameCreatedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// DisputeGameFactoryDisputeGameCreated represents a DisputeGameCreated event raised by the DisputeGameFactory contract.
+type DisputeGameFactoryDisputeGameCreated struct {
+	DisputeProxy common.Address
+	GameType     uint8
+	RootClaim    [32]byte
+	Raw          types.Log // Blockchain specific contextual infos
+}
+
+// FilterDisputeGameCreated is a free log retrieval operation binding the contract event 0xfad0599ff449d8d9685eadecca8cb9e00924c5fd8367c1c09469824939e1ffec.
+//
+// Solidity: event DisputeGameCreated(address indexed disputeProxy, uint8 indexed gameType, bytes32 indexed rootClaim)
+func (_DisputeGameFactory *DisputeGameFactoryFilterer) FilterDisputeGameCreated(opts *bind.FilterOpts, disputeProxy []common.Address, gameType []uint8, rootClaim [][32]byte) (*DisputeGameFactoryDisputeGameCreatedIterator, error) {
+
+	var disputeProxyRule []interface{}
+	for _, disputeProxyItem := range disputeProxy {
+		disputeProxyRule = append(disputeProxyRule, disputeProxyItem)
+	}
+	var gameTypeRule []interface{}
+	for _, gameTypeItem := range gameType {
+		gameTypeRule = append(gameTypeRule, gameTypeItem)
+	}
+	var rootClaimRule []interface{}
+	for _, rootClaimItem := range rootClaim {
+		rootClaimRule = append(rootClaimRule, rootClaimItem)
+	}
+
+	logs, sub, err := _DisputeGameFactory.contract.FilterLogs(opts, "DisputeGameCreated", disputeProxyRule, gameTypeRule, rootClaimRule)
+	if err != nil {
+		return nil, err
+	}
+	return &DisputeGameFactoryDisputeGameCreatedIterator{contract: _DisputeGameFactory.contract, event: "DisputeGameCreated", logs: logs, sub: sub}, nil
+}
+
+// WatchDisputeGameCreated is a free log subscription operation binding the contract event 0xfad0599ff449d8d9685eadecca8cb9e00924c5fd8367c1c09469824939e1ffec.
+//
+// Solidity: event DisputeGameCreated(address indexed disputeProxy, uint8 indexed gameType, bytes32 indexed rootClaim)
+func (_DisputeGameFactory *DisputeGameFactoryFilterer) WatchDisputeGameCreated(opts *bind.WatchOpts, sink chan<- *DisputeGameFactoryDisputeGameCreated, disputeProxy []common.Address, gameType []uint8, rootClaim [][32]byte) (event.Subscription, error) {
+
+	var disputeProxyRule []interface{}
+	for _, disputeProxyItem := range disputeProxy {
+		disputeProxyRule = append(disputeProxyRule, disputeProxyItem)
+	}
+	var gameTypeRule []interface{}
+	for _, gameTypeItem := range gameType {
+		gameTypeRule = append(gameTypeRule, gameTypeItem)
+	}
+	var rootClaimRule []interface{}
+	for _, rootClaimItem := range rootClaim {
+		rootClaimRule = append(rootClaimRule, rootClaimItem)
+	}
+
+	logs, sub, err := _DisputeGameFactory.contract.WatchLogs(opts, "DisputeGameCreated", disputeProxyRule, gameTypeRule, rootClaimRule)
+	if err != nil {
+		return nil, err
+	}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(DisputeGameFactoryDisputeGameCreated)
+				if err := _DisputeGameFactory.contract.UnpackLog(event, "DisputeGameCreated", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// ParseDisputeGameCreated is a log parse operation binding the contract event 0xfad0599ff449d8d9685eadecca8cb9e00924c5fd8367c1c09469824939e1ffec.
+//
+// Solidity: event DisputeGameCreated(address indexed disputeProxy, uint8 indexed gameType, bytes32 indexed rootClaim)
+func (_DisputeGameFactory *DisputeGameFactoryFilterer) ParseDisputeGameCreated(log types.Log) (*DisputeGameFactoryDisputeGameCreated, error) {
+	event := new(DisputeGameFactoryDisputeGameCreated)
+	if err := _DisputeGameFactory.contract.UnpackLog(event, "DisputeGameCreated", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// DisputeGameFactoryImplementationSetIterator is returned from FilterImplementationSet and is used to iterate over the raw logs and unpacked data for ImplementationSet events raised by the DisputeGameFactory contract.
+type DisputeGameFactoryImplementationSetIterator struct {
+	Event *DisputeGameFactoryImplementationSet // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *DisputeGameFactoryImplementationSetIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(DisputeGameFactoryImplementationSet)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(DisputeGameFactoryImplementationSet)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error returns any retrieval or parsing error occurred during filtering.
+func (it *DisputeGameFactoryImplementationSetIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *DisputeGameFactoryImplementationSetIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// DisputeGameFactoryImplementationSet represents a ImplementationSet event raised by the DisputeGameFactory contract.
+type DisputeGameFactoryImplementationSet struct {
+	Impl     common.Address
+	GameType uint8
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterImplementationSet is a free log retrieval operation binding the contract event 0x623713f72f6e427a8044bb8b3bd6834357cf285decbaa21bcc73c1d0632c4d84.
+//
+// Solidity: event ImplementationSet(address indexed impl, uint8 indexed gameType)
+func (_DisputeGameFactory *DisputeGameFactoryFilterer) FilterImplementationSet(opts *bind.FilterOpts, impl []common.Address, gameType []uint8) (*DisputeGameFactoryImplementationSetIterator, error) {
+
+	var implRule []interface{}
+	for _, implItem := range impl {
+		implRule = append(implRule, implItem)
+	}
+	var gameTypeRule []interface{}
+	for _, gameTypeItem := range gameType {
+		gameTypeRule = append(gameTypeRule, gameTypeItem)
+	}
+
+	logs, sub, err := _DisputeGameFactory.contract.FilterLogs(opts, "ImplementationSet", implRule, gameTypeRule)
+	if err != nil {
+		return nil, err
+	}
+	return &DisputeGameFactoryImplementationSetIterator{contract: _DisputeGameFactory.contract, event: "ImplementationSet", logs: logs, sub: sub}, nil
+}
+
+// WatchImplementationSet is a free log subscription operation binding the contract event 0x623713f72f6e427a8044bb8b3bd6834357cf285decbaa21bcc73c1d0632c4d84.
+//
+// Solidity: event ImplementationSet(address indexed impl, uint8 indexed gameType)
+func (_DisputeGameFactory *DisputeGameFactoryFilterer) WatchImplementationSet(opts *bind.WatchOpts, sink chan<- *DisputeGameFactoryImplementationSet, impl []common.Address, gameType []uint8) (event.Subscription, error) {
+
+	var implRule []interface{}
+	for _, implItem := range impl {
+		implRule = append(implRule, implItem)
+	}
+	var gameTypeRule []interface{}
+	for _, gameTypeItem := range gameType {
+		gameTypeRule = append(gameTypeRule, gameTypeItem)
+	}
+
+	logs, sub, err := _DisputeGameFactory.contract.WatchLogs(opts, "ImplementationSet", implRule, gameTypeRule)
+	if err != nil {
+		return nil, err
+	}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(DisputeGameFactoryImplementationSet)
+				if err := _DisputeGameFactory.contract.UnpackLog(event, "ImplementationSet", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// ParseImplementationSet is a log parse operation binding the contract event 0x623713f72f6e427a8044bb8b3bd6834357cf285decbaa21bcc73c1d0632c4d84.
+//
+// Solidity: event ImplementationSet(address indexed impl, uint8 indexed gameType)
+func (_DisputeGameFactory *DisputeGameFactoryFilterer) ParseImplementationSet(log types.Log) (*DisputeGameFactoryImplementationSet, error) {
+	event := new(DisputeGameFactoryImplementationSet)
+	if err := _DisputeGameFactory.contract.UnpackLog(event, "ImplementationSet", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// DisputeGameFactoryOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the DisputeGameFactory contract.
+type DisputeGameFactoryOwnershipTransferredIterator struct {
+	Event *DisputeGameFactoryOwnershipTransferred // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *DisputeGameFactoryOwnershipTransferredIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(DisputeGameFactoryOwnershipTransferred)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(DisputeGameFactoryOwnershipTransferred)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error returns any retrieval or parsing error occurred during filtering.
+func (it *DisputeGameFactoryOwnershipTransferredIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *DisputeGameFactoryOwnershipTransferredIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// DisputeGameFactoryOwnershipTransferred represents a OwnershipTransferred event raised by the DisputeGameFactory contract.
+type DisputeGameFactoryOwnershipTransferred struct {
+	PreviousOwner common.Address
+	NewOwner      common.Address
+	Raw           types.Log // Blockchain specific contextual infos
+}
+
+// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
+//
+// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
+func (_DisputeGameFactory *DisputeGameFactoryFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*DisputeGameFactoryOwnershipTransferredIterator, error) {
+
+	var previousOwnerRule []interface{}
+	for _, previousOwnerItem := range previousOwner {
+		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
+	}
+	var newOwnerRule []interface{}
+	for _, newOwnerItem := range newOwner {
+		newOwnerRule = append(newOwnerRule, newOwnerItem)
+	}
+
+	logs, sub, err := _DisputeGameFactory.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
+	if err != nil {
+		return nil, err
+	}
+	return &DisputeGameFactoryOwnershipTransferredIterator{contract: _DisputeGameFactory.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
+}
+
+// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
+//
+// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
+func (_DisputeGameFactory *DisputeGameFactoryFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *DisputeGameFactoryOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {
+
+	var previousOwnerRule []interface{}
+	for _, previousOwnerItem := range previousOwner {
+		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
+	}
+	var newOwnerRule []interface{}
+	for _, newOwnerItem := range newOwner {
+		newOwnerRule = append(newOwnerRule, newOwnerItem)
+	}
+
+	logs, sub, err := _DisputeGameFactory.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
+	if err != nil {
+		return nil, err
+	}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(DisputeGameFactoryOwnershipTransferred)
+				if err := _DisputeGameFactory.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
+//
+// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
+func (_DisputeGameFactory *DisputeGameFactoryFilterer) ParseOwnershipTransferred(log types.Log) (*DisputeGameFactoryOwnershipTransferred, error) {
+	event := new(DisputeGameFactoryOwnershipTransferred)
+	if err := _DisputeGameFactory.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}

op-challenger/challenger/challenger.go

@@ -43,9 +43,9 @@ type Challenger struct {
 	l2ooABI          *abi.ABI
 
 	// dispute game factory contract
-	// dgfContract     *bindings.DisputeGameFactoryCaller
+	dgfContract     *bindings.DisputeGameFactoryCaller
 	dgfContractAddr common.Address
-	// dgfABI          *abi.ABI
+	dgfABI          *abi.ABI
 
 	networkTimeout time.Duration
 }
@@ -79,6 +79,12 @@ func NewChallenger(cfg config.Config, l log.Logger, m metrics.Metricer) (*Challe
 		return nil, err
 	}
 
+	dgfContract, err := bindings.NewDisputeGameFactoryCaller(cfg.DGFAddress, l1Client)
+	if err != nil {
+		cancel()
+		return nil, err
+	}
+
 	cCtx, cCancel := context.WithTimeout(ctx, cfg.NetworkTimeout)
 	defer cCancel()
 	version, err := l2ooContract.Version(&bind.CallOpts{Context: cCtx})
@@ -88,7 +94,13 @@ func NewChallenger(cfg config.Config, l log.Logger, m metrics.Metricer) (*Challe
 	}
 	l.Info("Connected to L2OutputOracle", "address", cfg.L2OOAddress, "version", version)
 
-	parsed, err := bindings.L2OutputOracleMetaData.GetAbi()
+	parsedL2oo, err := bindings.L2OutputOracleMetaData.GetAbi()
+	if err != nil {
+		cancel()
+		return nil, err
+	}
+
+	parsedDgf, err := bindings.DisputeGameFactoryMetaData.GetAbi()
 	if err != nil {
 		cancel()
 		return nil, err
@@ -110,9 +122,11 @@ func NewChallenger(cfg config.Config, l log.Logger, m metrics.Metricer) (*Challe
 
 		l2ooContract:     l2ooContract,
 		l2ooContractAddr: cfg.L2OOAddress,
-		l2ooABI:          parsed,
+		l2ooABI:          parsedL2oo,
 
+		dgfContract:     dgfContract,
 		dgfContractAddr: cfg.DGFAddress,
+		dgfABI:          parsedDgf,
 
 		networkTimeout: cfg.NetworkTimeout,
 	}, nil

op-challenger/challenger/entrypoint.go

@@ -4,14 +4,12 @@ import (
 	"context"
 	"fmt"
 	_ "net/http/pprof"
-	"os"
-	"os/signal"
-	"syscall"
 
 	"github.com/ethereum/go-ethereum/log"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/config"
 	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
+	"github.com/ethereum-optimism/optimism/op-service/opio"
 	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
 	oprpc "github.com/ethereum-optimism/optimism/op-service/rpc"
 )
@@ -73,14 +71,7 @@ func Main(logger log.Logger, version string, cfg *config.Config) error {
 	m.RecordInfo(version)
 	m.RecordUp()
 
-	interruptChannel := make(chan os.Signal, 1)
-	signal.Notify(interruptChannel, []os.Signal{
-		os.Interrupt,
-		os.Kill,
-		syscall.SIGTERM,
-		syscall.SIGQUIT,
-	}...)
-	<-interruptChannel
+	opio.BlockOnInterrupts()
 	cancel()
 
 	return nil

op-node/cmd/main.go

@@ -4,9 +4,7 @@ import (
 	"context"
 	"net"
 	"os"
-	"os/signal"
 	"strconv"
-	"syscall"
 
 	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
 	"github.com/ethereum-optimism/optimism/op-node/cmd/doc"
@@ -25,6 +23,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/version"
 	opservice "github.com/ethereum-optimism/optimism/op-service"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
+	"github.com/ethereum-optimism/optimism/op-service/opio"
 	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
 )
 
@@ -162,14 +161,7 @@ func RollupNodeMain(ctx *cli.Context) error {
 		defer pprofCancel()
 	}
 
-	interruptChannel := make(chan os.Signal, 1)
-	signal.Notify(interruptChannel, []os.Signal{
-		os.Interrupt,
-		os.Kill,
-		syscall.SIGTERM,
-		syscall.SIGQUIT,
-	}...)
-	<-interruptChannel
+	opio.BlockOnInterrupts()
 
 	return nil
 

op-node/flags/p2p_flags.go

@@ -40,7 +40,7 @@ var (
 			"Should be provided in following format: <threshold>:<label>;<threshold>:<label>;..." +
 			"For example: -40:graylist;-20:restricted;0:nopx;20:friend;",
 		Required: false,
-		Value:    "-40:graylist;-20:restricted;0:nopx;20:friend;",
+		Value:    "-40:<=-40;-10:<=-10;-5:<=-05;-0.05:<=-00.05;0:<=0;0.05:<=00.05;5:<=05;10:<=10;20:<=20;100:>20;",
 		EnvVar:   p2pEnv("SCORE_BANDS"),
 	}
 

op-node/p2p/peer_scorer.go

@@ -143,9 +143,9 @@ func (s *scorer) SnapshotHook() pubsub.ExtendedPeerScoreInspectFn {
 			}
 			if topSnap, ok := snap.Topics[blocksTopicName]; ok {
 				diff.Blocks.TimeInMesh = float64(topSnap.TimeInMesh) / float64(time.Second)
-				diff.Blocks.MeshMessageDeliveries = uint64(topSnap.MeshMessageDeliveries)
-				diff.Blocks.FirstMessageDeliveries = uint64(topSnap.FirstMessageDeliveries)
-				diff.Blocks.InvalidMessageDeliveries = uint64(topSnap.InvalidMessageDeliveries)
+				diff.Blocks.MeshMessageDeliveries = topSnap.MeshMessageDeliveries
+				diff.Blocks.FirstMessageDeliveries = topSnap.FirstMessageDeliveries
+				diff.Blocks.InvalidMessageDeliveries = topSnap.InvalidMessageDeliveries
 			}
 			if err := s.peerStore.SetScore(id, &diff); err != nil {
 				s.log.Warn("Unable to update peer gossip score", "err", err)

op-node/p2p/store/iface.go

@@ -11,9 +11,9 @@ import (
 
 type TopicScores struct {
 	TimeInMesh               float64 `json:"timeInMesh"` // in seconds
-	FirstMessageDeliveries   uint64  `json:"firstMessageDeliveries"`
-	MeshMessageDeliveries    uint64  `json:"meshMessageDeliveries"`
-	InvalidMessageDeliveries uint64  `json:"invalidMessageDeliveries"`
+	FirstMessageDeliveries   float64 `json:"firstMessageDeliveries"`
+	MeshMessageDeliveries    float64 `json:"meshMessageDeliveries"`
+	InvalidMessageDeliveries float64 `json:"invalidMessageDeliveries"`
 }
 
 type GossipScores struct {

op-proposer/proposer/l2_output_submitter.go

@@ -6,10 +6,7 @@ import (
 	"fmt"
 	"math/big"
 	_ "net/http/pprof"
-	"os"
-	"os/signal"
 	"sync"
-	"syscall"
 	"time"
 
 	"github.com/ethereum/go-ethereum/accounts/abi"
@@ -27,6 +24,7 @@ import (
 	opservice "github.com/ethereum-optimism/optimism/op-service"
 	opclient "github.com/ethereum-optimism/optimism/op-service/client"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
+	"github.com/ethereum-optimism/optimism/op-service/opio"
 	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
 	oprpc "github.com/ethereum-optimism/optimism/op-service/rpc"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
@@ -103,14 +101,7 @@ func Main(version string, cliCtx *cli.Context) error {
 	m.RecordInfo(version)
 	m.RecordUp()
 
-	interruptChannel := make(chan os.Signal, 1)
-	signal.Notify(interruptChannel, []os.Signal{
-		os.Interrupt,
-		os.Kill,
-		syscall.SIGTERM,
-		syscall.SIGQUIT,
-	}...)
-	<-interruptChannel
+	opio.BlockOnInterrupts()
 	cancel()
 
 	return nil

op-service/opio/interrupts.go

+package opio
+
+import (
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+// DefaultInterruptSignals is a set of default interrupt signals.
+var DefaultInterruptSignals = []os.Signal{
+	os.Interrupt,
+	os.Kill,
+	syscall.SIGTERM,
+	syscall.SIGQUIT,
+}
+
+// BlockOnInterrupts blocks until a SIGTERM is received.
+// Passing in signals will override the default signals.
+func BlockOnInterrupts(signals ...os.Signal) {
+	if len(signals) == 0 {
+		signals = DefaultInterruptSignals
+	}
+	interruptChannel := make(chan os.Signal, 1)
+	signal.Notify(interruptChannel, signals...)
+	<-interruptChannel
+}

op-wheel/engine/engine.go

@@ -2,6 +2,7 @@ package engine
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"math/big"
 	"time"
@@ -18,6 +19,28 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 )
 
+type PayloadAttributesV2 struct {
+	Timestamp             uint64              `json:"timestamp"`
+	Random                common.Hash         `json:"prevRandao"`
+	SuggestedFeeRecipient common.Address      `json:"suggestedFeeRecipient"`
+	Withdrawals           []*types.Withdrawal `json:"withdrawals"`
+}
+
+func (p PayloadAttributesV2) MarshalJSON() ([]byte, error) {
+	type PayloadAttributes struct {
+		Timestamp             hexutil.Uint64      `json:"timestamp"             gencodec:"required"`
+		Random                common.Hash         `json:"prevRandao"            gencodec:"required"`
+		SuggestedFeeRecipient common.Address      `json:"suggestedFeeRecipient" gencodec:"required"`
+		Withdrawals           []*types.Withdrawal `json:"withdrawals"`
+	}
+	var enc PayloadAttributes
+	enc.Timestamp = hexutil.Uint64(p.Timestamp)
+	enc.Random = p.Random
+	enc.SuggestedFeeRecipient = p.SuggestedFeeRecipient
+	enc.Withdrawals = make([]*types.Withdrawal, 0)
+	return json.Marshal(&enc)
+}
+
 func DialClient(ctx context.Context, endpoint string, jwtSecret [32]byte) (client.RPC, error) {
 	auth := node.NewJWTAuth(jwtSecret)
 
@@ -69,7 +92,7 @@ func headSafeFinalized(ctx context.Context, client client.RPC) (head *types.Bloc
 
 func insertBlock(ctx context.Context, client client.RPC, payload *engine.ExecutableData) error {
 	var payloadResult *engine.PayloadStatusV1
-	if err := client.CallContext(ctx, &payloadResult, "engine_newPayloadV1", payload); err != nil {
+	if err := client.CallContext(ctx, &payloadResult, "engine_newPayloadV2", payload); err != nil {
 		return fmt.Errorf("failed to insert block %d: %w", payload.Number, err)
 	}
 	if payloadResult.Status != string(eth.ExecutionValid) {
@@ -80,7 +103,7 @@ func insertBlock(ctx context.Context, client client.RPC, payload *engine.Executa
 
 func updateForkchoice(ctx context.Context, client client.RPC, head, safe, finalized common.Hash) error {
 	var post engine.ForkChoiceResponse
-	if err := client.CallContext(ctx, &post, "engine_forkchoiceUpdatedV1",
+	if err := client.CallContext(ctx, &post, "engine_forkchoiceUpdatedV2",
 		engine.ForkchoiceStateV1{
 			HeadBlockHash:      head,
 			SafeBlockHash:      safe,
@@ -112,21 +135,17 @@ func BuildBlock(ctx context.Context, client client.RPC, status *StatusData, sett
 		}
 	}
 	var pre engine.ForkChoiceResponse
-	if err := client.CallContext(ctx, &pre, "engine_forkchoiceUpdatedV1",
+	if err := client.CallContext(ctx, &pre, "engine_forkchoiceUpdatedV2",
 		engine.ForkchoiceStateV1{
 			HeadBlockHash:      status.Head.Hash,
 			SafeBlockHash:      status.Safe.Hash,
 			FinalizedBlockHash: status.Finalized.Hash,
-		}, engine.PayloadAttributes{
+		}, PayloadAttributesV2{
 			Timestamp:             timestamp,
 			Random:                settings.Random,
 			SuggestedFeeRecipient: settings.FeeRecipient,
-			// TODO: maybe use the L2 fields to hack in tx embedding CLI option?
-			//Transactions:          nil,
-			//NoTxPool:              false,
-			//GasLimit:              nil,
 		}); err != nil {
-		return nil, fmt.Errorf("failed to set forkchoice with new block: %w", err)
+		return nil, fmt.Errorf("failed to set forkchoice when building new block: %w", err)
 	}
 	if pre.PayloadStatus.Status != string(eth.ExecutionValid) {
 		return nil, fmt.Errorf("pre-block forkchoice update was not valid: %v", pre.PayloadStatus.ValidationError)
@@ -139,19 +158,19 @@ func BuildBlock(ctx context.Context, client client.RPC, status *StatusData, sett
 	case <-time.After(settings.BuildTime):
 	}
 
-	var payload *engine.ExecutableData
-	if err := client.CallContext(ctx, &payload, "engine_getPayloadV1", pre.PayloadID); err != nil {
+	var payload *engine.ExecutionPayloadEnvelope
+	if err := client.CallContext(ctx, &payload, "engine_getPayloadV2", pre.PayloadID); err != nil {
 		return nil, fmt.Errorf("failed to get payload %v, %d time after instructing engine to build it: %w", pre.PayloadID, settings.BuildTime, err)
 	}
 
-	if err := insertBlock(ctx, client, payload); err != nil {
+	if err := insertBlock(ctx, client, payload.ExecutionPayload); err != nil {
 		return nil, err
 	}
-	if err := updateForkchoice(ctx, client, payload.BlockHash, status.Safe.Hash, status.Finalized.Hash); err != nil {
+	if err := updateForkchoice(ctx, client, payload.ExecutionPayload.BlockHash, status.Safe.Hash, status.Finalized.Hash); err != nil {
 		return nil, err
 	}
 
-	return payload, nil
+	return payload.ExecutionPayload, nil
 }
 
 func Auto(ctx context.Context, metrics Metricer, client client.RPC, log log.Logger, shutdown <-chan struct{}, settings *BlockBuildingSettings) error {

packages/contracts-bedrock/contracts/test/invariants/AddressAliasHelper.t.sol

+pragma solidity 0.8.15;
+
+import { Test } from "forge-std/Test.sol";
+import { StdInvariant } from "forge-std/StdInvariant.sol";
+import { AddressAliasHelper } from "../../vendor/AddressAliasHelper.sol";
+
+contract AddressAliasHelper_Converter {
+    bool public failedRoundtrip;
+
+    /**
+     * @dev Allows the actor to convert L1 to L2 addresses and vice versa.
+     */
+    function convertRoundTrip(address addr) external {
+        // Alias our address
+        address aliasedAddr = AddressAliasHelper.applyL1ToL2Alias(addr);
+
+        // Unalias our address
+        address undoneAliasAddr = AddressAliasHelper.undoL1ToL2Alias(aliasedAddr);
+
+        // If our round trip aliasing did not return the original result, set our state.
+        if (addr != undoneAliasAddr) {
+            failedRoundtrip = true;
+        }
+    }
+}
+
+contract AddressAliasHelper_AddressAliasing_Invariant is StdInvariant, Test {
+    AddressAliasHelper_Converter internal actor;
+
+    function setUp() public {
+        // Create a converter actor.
+        actor = new AddressAliasHelper_Converter();
+
+        targetContract(address(actor));
+
+        bytes4[] memory selectors = new bytes4[](1);
+        selectors[0] = actor.convertRoundTrip.selector;
+        FuzzSelector memory selector = FuzzSelector({ addr: address(actor), selectors: selectors });
+        targetSelector(selector);
+    }
+
+    /**
+     * @custom:invariant Address aliases are always able to be undone.
+     *
+     * Asserts that an address that has been aliased with `applyL1ToL2Alias` can always
+     * be unaliased with `undoL1ToL2Alias`.
+     */
+    function invariant_round_trip_aliasing() external {
+        // ASSERTION: The round trip aliasing done in testRoundTrip(...) should never fail.
+        assertEq(actor.failedRoundtrip(), false);
+    }
+}

packages/contracts-bedrock/contracts/test/invariants/Burn.Eth.t.sol

+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.15;
+
+import { StdUtils } from "forge-std/StdUtils.sol";
+import { Test } from "forge-std/Test.sol";
+import { Vm } from "forge-std/Vm.sol";
+
+import { StdInvariant } from "forge-std/StdInvariant.sol";
+import { Burn } from "../../libraries/Burn.sol";
+
+contract Burn_EthBurner is StdUtils {
+    Vm internal vm;
+    bool public failedEthBurn;
+
+    constructor(Vm _vm) {
+        vm = _vm;
+    }
+
+    /**
+     * @notice Takes an integer amount of eth to burn through the Burn library and
+     * updates the contract state if an incorrect amount of eth moved from the contract
+     */
+    function burnEth(uint256 _value) external {
+        uint256 preBurnvalue = bound(_value, 0, type(uint128).max);
+
+        // Give the burner some ether for gas being used
+        vm.deal(address(this), preBurnvalue);
+
+        // cache the contract's eth balance
+        uint256 preBurnBalance = address(this).balance;
+
+        uint256 value = bound(preBurnvalue, 0, preBurnBalance);
+
+        // execute a burn of _value eth
+        Burn.eth(value);
+
+        // check that exactly value eth was transfered from the contract
+        unchecked {
+            if (address(this).balance != preBurnBalance - value) {
+                failedEthBurn = true;
+            }
+        }
+    }
+}
+
+contract Burn_BurnEth_Invariant is StdInvariant, Test {
+    Burn_EthBurner internal actor;
+
+    function setUp() public {
+        // Create a Eth burner actor.
+
+        actor = new Burn_EthBurner(vm);
+
+        targetContract(address(actor));
+
+        bytes4[] memory selectors = new bytes4[](1);
+        selectors[0] = actor.burnEth.selector;
+        FuzzSelector memory selector = FuzzSelector({ addr: address(actor), selectors: selectors });
+        targetSelector(selector);
+    }
+
+    /**
+     * @custom:invariant `eth(uint256)` always burns the exact amount of eth passed.
+     *
+     * Asserts that when `Burn.eth(uint256)` is called, it always burns the exact amount
+     * of ETH passed to the function.
+     */
+    function invariant_burn_eth() external {
+        // ASSERTION: The amount burned should always match the amount passed exactly
+        assertEq(actor.failedEthBurn(), false);
+    }
+}

packages/contracts-bedrock/contracts/test/invariants/Burn.Gas.t.sol

+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.15;
+
+import { StdUtils } from "forge-std/StdUtils.sol";
+import { Test } from "forge-std/Test.sol";
+import { Vm } from "forge-std/Vm.sol";
+
+import { StdInvariant } from "forge-std/StdInvariant.sol";
+import { Burn } from "../../libraries/Burn.sol";
+
+contract Burn_GasBurner is StdUtils {
+    Vm internal vm;
+    bool public failedGasBurn;
+
+    constructor(Vm _vm) {
+        vm = _vm;
+    }
+
+    /**
+     * @notice Takes an integer amount of gas to burn through the Burn library and
+     * updates the contract state if at least that amount of gas was not burned
+     * by the library
+     */
+    function burnGas(uint256 _value) external {
+        // cap the value to the max resource limit
+        uint256 MAX_RESOURCE_LIMIT = 8_000_000;
+        uint256 value = bound(_value, 0, MAX_RESOURCE_LIMIT);
+
+        // cache the contract's current remaining gas
+        uint256 preBurnGas = gasleft();
+
+        // execute the gas burn
+        Burn.gas(value);
+
+        // cache the remaining gas post burn
+        uint256 postBurnGas = gasleft();
+
+        // check that at least value gas was burnt (and that there was no underflow)
+        unchecked {
+            if (postBurnGas - preBurnGas <= value && preBurnGas - value > preBurnGas) {
+                failedGasBurn = true;
+            }
+        }
+    }
+}
+
+contract Burn_BurnGas_Invariant is StdInvariant, Test {
+    Burn_GasBurner internal actor;
+
+    function setUp() public {
+        // Create a gas burner actor.
+        actor = new Burn_GasBurner(vm);
+
+        targetContract(address(actor));
+
+        bytes4[] memory selectors = new bytes4[](1);
+        selectors[0] = actor.burnGas.selector;
+        FuzzSelector memory selector = FuzzSelector({ addr: address(actor), selectors: selectors });
+        targetSelector(selector);
+    }
+
+    /**
+     * @custom:invariant `gas(uint256)` always burns at least the amount of gas passed.
+     *
+     * Asserts that when `Burn.gas(uint256)` is called, it always burns at least the amount
+     * of gas passed to the function.
+     */
+    function invariant_burn_gas() external {
+        // ASSERTION: The amount burned should always match the amount passed exactly
+        assertEq(actor.failedGasBurn(), false);
+    }
+}

packages/contracts-bedrock/invariant-docs/AddressAliasHelper.md

+# `AddressAliasHelper` Invariants
+
+## Address aliases are always able to be undone.
+**Test:** [`AddressAliasHelper.t.sol#L48`](../contracts/test/invariants/AddressAliasHelper.t.sol#L48)
+
+Asserts that an address that has been aliased with `applyL1ToL2Alias` can always be unaliased with `undoL1ToL2Alias`. 

packages/contracts-bedrock/invariant-docs/Burn.Eth.md

+# `Burn.Eth` Invariants
+
+## `eth(uint256)` always burns the exact amount of eth passed.
+**Test:** [`Burn.Eth.t.sol#L68`](../contracts/test/invariants/Burn.Eth.t.sol#L68)
+
+Asserts that when `Burn.eth(uint256)` is called, it always burns the exact amount of ETH passed to the function. 

packages/contracts-bedrock/invariant-docs/Burn.Gas.md

+# `Burn.Gas` Invariants
+
+## `gas(uint256)` always burns at least the amount of gas passed.
+**Test:** [`Burn.Gas.t.sol#L68`](../contracts/test/invariants/Burn.Gas.t.sol#L68)
+
+Asserts that when `Burn.gas(uint256)` is called, it always burns at least the amount of gas passed to the function. 

packages/contracts-bedrock/invariant-docs/README.md

@@ -6,7 +6,10 @@ This directory contains documentation for all defined invariant tests within `co
 <!-- START autoTOC -->
 
 ## Table of Contents
+- [AddressAliasHelper](./AddressAliasHelper.md)
 - [AddressAliasing](./AddressAliasing.md)
+- [Burn.Eth](./Burn.Eth.md)
+- [Burn.Gas](./Burn.Gas.md)
 - [Burn](./Burn.md)
 - [CrossDomainMessenger](./CrossDomainMessenger.md)
 - [Encoding](./Encoding.md)