Merge branch 'develop' into refcell/abigenrc

.circleci/config.yml

@@ -760,7 +760,7 @@ jobs:
         description: Go Module Name
         type: string
     docker:
-      - image: cimg/go:1.19
+      - image: cimg/go:1.20
     steps:
       - checkout
       - run:
@@ -818,6 +818,12 @@ jobs:
       - run:
           name: git submodules
           command: git submodule update --init --recursive
+      - run:
+          name: print go's available MIPS targets
+          command: go tool dist list | grep mips
+      - run:
+          name: generate cannon prestate
+          command: make cannon-prestate
       - run:
           name: generate L1 state
           command: make devnet-allocs
@@ -895,6 +901,9 @@ jobs:
       - run:
           name: git submodules
           command: git submodule update --init --recursive
+      - run:
+          name: generate cannon prestate
+          command: make cannon-prestate
       - run:
           name: generate L1 state
           command: make devnet-allocs
@@ -962,6 +971,9 @@ jobs:
           name: Install and build
           command: |
             pnpm install && pnpm build
+      - run:
+          name: generate cannon prestate
+          command: make cannon-prestate
       - run:
           name: Bring up the stack
           command: make devnet-up
@@ -1118,14 +1130,14 @@ jobs:
 
   bedrock-go-tests:
     docker:
-      - image: cimg/go:1.19
+      - image: cimg/go:1.20
     resource_class: medium
     steps:
       - run: echo Done
 
   fpp-verify:
     docker:
-      - image: cimg/go:1.19
+      - image: cimg/go:1.20
     steps:
       - checkout
       - run:

Makefile

@@ -16,6 +16,9 @@ build-ts: submodules
 	pnpm build
 .PHONY: build-ts
 
+ci-builder:
+	docker build -t ci-builder -f ops/docker/ci-builder/Dockerfile .
+
 submodules:
 	# CI will checkout submodules on its own (and fails on these commands)
 	if [ -z "$$GITHUB_ENV" ]; then \

cannon/example/claim/go.mod

@@ -5,8 +5,8 @@ go 1.20
 require github.com/ethereum-optimism/optimism v0.0.0
 
 require (
-	golang.org/x/crypto v0.8.0 // indirect
-	golang.org/x/sys v0.7.0 // indirect
+	golang.org/x/crypto v0.12.0 // indirect
+	golang.org/x/sys v0.11.0 // indirect
 )
 
 replace github.com/ethereum-optimism/optimism v0.0.0 => ../../..

cannon/example/claim/go.sum

 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
-golang.org/x/crypto v0.8.0 h1:pd9TJtTueMTVQXzk8E2XESSMQDj/U7OUu0PqJqPXQjQ=
-golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE=
-golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
-golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+golang.org/x/crypto v0.12.0 h1:tFM/ta59kqch6LlvYnPa0yx5a83cL2nHflFhYKvv9Yk=
+golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
+golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
+golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

cannon/example/hello/go.mod

 module hello
 
+go 1.20

cannon/mipsevm/witness.go

@@ -26,13 +26,21 @@ func uint32ToBytes32(v uint32) []byte {
 }
 
 func (wit *StepWitness) EncodeStepInput() []byte {
+	abiStateLen := len(wit.State)
+	if abiStateLen%32 != 0 {
+		abiStateLen += 32 - (abiStateLen % 32)
+	}
+	// pad state to 32 byte multiple per ABI
+	abiState := make([]byte, abiStateLen)
+	copy(abiState, wit.State)
+
 	var input []byte
 	input = append(input, StepBytes4...)
-	input = append(input, uint32ToBytes32(32*2)...)                           // state data offset in bytes
-	input = append(input, uint32ToBytes32(32*2+32+uint32(len(wit.State)))...) // proof data offset in bytes
+	input = append(input, uint32ToBytes32(32*2)...)                          // state data offset in bytes
+	input = append(input, uint32ToBytes32(32*2+32+uint32(len(abiState)))...) // proof data offset in bytes
 
 	input = append(input, uint32ToBytes32(uint32(len(wit.State)))...) // state data length in bytes
-	input = append(input, wit.State[:]...)
+	input = append(input, abiState[:]...)
 	input = append(input, uint32ToBytes32(uint32(len(wit.MemProof)))...) // proof data length in bytes
 	input = append(input, wit.MemProof[:]...)
 	return input

go.mod

@@ -23,7 +23,7 @@ require (
 	github.com/ipfs/go-datastore v0.6.0
 	github.com/ipfs/go-ds-leveldb v0.5.0
 	github.com/jackc/pgtype v1.14.0
-	github.com/jackc/pgx/v5 v5.3.1
+	github.com/jackc/pgx/v5 v5.4.3
 	github.com/lib/pq v1.10.9
 	github.com/libp2p/go-libp2p v0.25.1
 	github.com/libp2p/go-libp2p-pubsub v0.9.3
@@ -40,10 +40,10 @@ require (
 	github.com/stretchr/testify v1.8.4
 	github.com/urfave/cli v1.22.14
 	github.com/urfave/cli/v2 v2.25.7
-	golang.org/x/crypto v0.8.0
+	golang.org/x/crypto v0.12.0
 	golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df
 	golang.org/x/sync v0.3.0
-	golang.org/x/term v0.7.0
+	golang.org/x/term v0.11.0
 	golang.org/x/time v0.3.0
 	gorm.io/driver/postgres v1.5.2
 	gorm.io/gorm v1.25.2
@@ -185,9 +185,9 @@ require (
 	go.uber.org/multierr v1.9.0 // indirect
 	go.uber.org/zap v1.24.0 // indirect
 	golang.org/x/mod v0.11.0 // indirect
-	golang.org/x/net v0.9.0 // indirect
-	golang.org/x/sys v0.7.0 // indirect
-	golang.org/x/text v0.9.0 // indirect
+	golang.org/x/net v0.10.0 // indirect
+	golang.org/x/sys v0.11.0 // indirect
+	golang.org/x/text v0.12.0 // indirect
 	golang.org/x/tools v0.7.0 // indirect
 	google.golang.org/protobuf v1.28.1 // indirect
 	gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect

go.sum

@@ -405,8 +405,8 @@ github.com/jackc/pgx/v4 v4.0.0-20190421002000-1b8f0016e912/go.mod h1:no/Y67Jkk/9
 github.com/jackc/pgx/v4 v4.0.0-pre1.0.20190824185557-6972a5742186/go.mod h1:X+GQnOEnf1dqHGpw7JmHqHc1NxDoalibchSk9/RWuDc=
 github.com/jackc/pgx/v4 v4.12.1-0.20210724153913-640aa07df17c h1:Dznn52SgVIVst9UyOT9brctYUgxs+CvVfPaC3jKrA50=
 github.com/jackc/pgx/v4 v4.12.1-0.20210724153913-640aa07df17c/go.mod h1:1QD0+tgSXP7iUjYm9C1NxKhny7lq6ee99u/z+IHFcgs=
-github.com/jackc/pgx/v5 v5.3.1 h1:Fcr8QJ1ZeLi5zsPZqQeUZhNhxfkkKBOgJuYkJHoBOtU=
-github.com/jackc/pgx/v5 v5.3.1/go.mod h1:t3JDKnCBlYIc0ewLF0Q7B8MXmoIaBOZj/ic7iHozM/8=
+github.com/jackc/pgx/v5 v5.4.3 h1:cxFyXhxlvAifxnkKKdlxv8XqUf59tDlYjnV5YYfsJJY=
+github.com/jackc/pgx/v5 v5.4.3/go.mod h1:Ig06C2Vu0t5qXC60W8sqIthScaEnFvojjj9dSljmHRA=
 github.com/jackc/puddle v0.0.0-20190413234325-e4ced69a3a2b/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
 github.com/jackc/puddle v0.0.0-20190608224051-11cab39313c9/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
 github.com/jackc/puddle v1.1.3/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
@@ -860,8 +860,8 @@ golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm
 golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.8.0 h1:pd9TJtTueMTVQXzk8E2XESSMQDj/U7OUu0PqJqPXQjQ=
-golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE=
+golang.org/x/crypto v0.12.0 h1:tFM/ta59kqch6LlvYnPa0yx5a83cL2nHflFhYKvv9Yk=
+golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df h1:UA2aFVmmsIlefxMk29Dp2juaUSth8Pyn3Tq5Y5mJGME=
 golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc=
@@ -911,8 +911,8 @@ golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985/go.mod h1:9nx3DQGgdP8bBQD5qx
 golang.org/x/net v0.0.0-20211008194852-3b03d305991f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
 golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM=
-golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
+golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@@ -982,13 +982,13 @@ golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
-golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
+golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.7.0 h1:BEvjmm5fURWqcfbSKTdpkDXYBrUS1c0m8agp14W48vQ=
-golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
+golang.org/x/term v0.11.0 h1:F9tnn/DA/Im8nCwm+fX+1/eBwi4qFjRT++MhtVC4ZX0=
+golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
@@ -997,8 +997,8 @@ golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=
+golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=

indexer/api/api.go

@@ -16,17 +16,15 @@ type PaginationResponse struct {
 	HasNextPage bool        `json:"hasNextPage"`
 }
 
-func (a *Api) DepositsHandler(w http.ResponseWriter, r *http.Request) {
-	bv := a.bridgeView
-
+func (a *Api) L1DepositsHandler(w http.ResponseWriter, r *http.Request) {
+	bv := a.BridgeTransfersView
 	address := common.HexToAddress(chi.URLParam(r, "address"))
 
 	// limit := getIntFromQuery(r, "limit", 10)
 	// cursor := r.URL.Query().Get("cursor")
 	// sortDirection := r.URL.Query().Get("sortDirection")
 
-	deposits, err := bv.DepositsByAddress(address)
-
+	deposits, err := bv.L1BridgeDepositsByAddress(address)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
@@ -43,17 +41,15 @@ func (a *Api) DepositsHandler(w http.ResponseWriter, r *http.Request) {
 	jsonResponse(w, response, http.StatusOK)
 }
 
-func (a *Api) WithdrawalsHandler(w http.ResponseWriter, r *http.Request) {
-	bv := a.bridgeView
-
+func (a *Api) L2WithdrawalsHandler(w http.ResponseWriter, r *http.Request) {
+	bv := a.BridgeTransfersView
 	address := common.HexToAddress(chi.URLParam(r, "address"))
 
 	// limit := getIntFromQuery(r, "limit", 10)
 	// cursor := r.URL.Query().Get("cursor")
 	// sortDirection := r.URL.Query().Get("sortDirection")
 
-	withdrawals, err := bv.WithdrawalsByAddress(address)
-
+	withdrawals, err := bv.L2BridgeWithdrawalsByAddress(address)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
@@ -83,22 +79,20 @@ func jsonResponse(w http.ResponseWriter, data interface{}, statusCode int) {
 }
 
 type Api struct {
-	Router     *chi.Mux
-	bridgeView database.BridgeView
+	Router              *chi.Mux
+	BridgeTransfersView database.BridgeTransfersView
 }
 
-func NewApi(bv database.BridgeView) *Api {
+func NewApi(bv database.BridgeTransfersView) *Api {
 	r := chi.NewRouter()
 
-	api := &Api{
-		Router:     r,
-		bridgeView: bv,
-	}
+	api := &Api{Router: r, BridgeTransfersView: bv}
+
 	// these regex are .+ because I wasn't sure what they should be
 	// don't want a regex for addresses because would prefer to validate the address
 	// with go-ethereum and throw a friendly error message
-	r.Get("/api/v0/deposits/{address:.+}", api.DepositsHandler)
-	r.Get("/api/v0/withdrawals/{address:.+}", api.WithdrawalsHandler)
+	r.Get("/api/v0/deposits/{address:.+}", api.L1DepositsHandler)
+	r.Get("/api/v0/withdrawals/{address:.+}", api.L2WithdrawalsHandler)
 	r.Get("/healthz", api.HealthzHandler)
 
 	return api

indexer/api/api_test.go

@@ -12,89 +12,67 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-// MockBridgeView mocks the BridgeView interface
-type MockBridgeView struct{}
+// MockBridgeTransfersView mocks the BridgeTransfersView interface
+type MockBridgeTransfersView struct{}
 
 const (
 	guid1 = "8408b6d2-7c90-4cfc-8604-b2204116cb6a"
 	guid2 = "8408b6d2-7c90-4cfc-8604-b2204116cb6b"
 )
 
-// DepositsByAddress mocks returning deposits by an address
-func (mbv *MockBridgeView) DepositsByAddress(address common.Address) ([]*database.DepositWithTransactionHashes, error) {
-	return []*database.DepositWithTransactionHashes{
-		{
-			Deposit: database.Deposit{
-				GUID:                 uuid.MustParse(guid1),
-				InitiatedL1EventGUID: uuid.MustParse(guid2),
-				Tx:                   database.Transaction{},
-				TokenPair:            database.TokenPair{},
-			},
-			L1TransactionHash: common.HexToHash("0x123"),
-		},
-	}, nil
-}
-
-// DepositsByAddress mocks returning deposits by an address
-func (mbv *MockBridgeView) DepositByMessageNonce(nonce *big.Int) (*database.Deposit, error) {
-	return &database.Deposit{
+var (
+	deposit = database.L1BridgeDeposit{
 		GUID:                 uuid.MustParse(guid1),
 		InitiatedL1EventGUID: uuid.MustParse(guid2),
 		Tx:                   database.Transaction{},
 		TokenPair:            database.TokenPair{},
-	}, nil
+	}
+
+	withdrawal = database.L2BridgeWithdrawal{
+		GUID:                 uuid.MustParse(guid2),
+		InitiatedL2EventGUID: uuid.MustParse(guid1),
+		WithdrawalHash:       common.HexToHash("0x456"),
+		Tx:                   database.Transaction{},
+		TokenPair:            database.TokenPair{},
+	}
+)
+
+func (mbv *MockBridgeTransfersView) L1BridgeDeposit(hash common.Hash) (*database.L1BridgeDeposit, error) {
+	return &deposit, nil
 }
 
-// LatestDepositMessageNonce mocks returning the latest cross domain message nonce for a deposit
-func (mbv *MockBridgeView) LatestDepositMessageNonce() (*big.Int, error) {
-	return big.NewInt(0), nil
+func (mbv *MockBridgeTransfersView) L1BridgeDepositByCrossDomainMessengerNonce(nonce *big.Int) (*database.L1BridgeDeposit, error) {
+	return &deposit, nil
 }
 
-// WithdrawalsByAddress mocks returning withdrawals by an address
-func (mbv *MockBridgeView) WithdrawalsByAddress(address common.Address) ([]*database.WithdrawalWithTransactionHashes, error) {
-	return []*database.WithdrawalWithTransactionHashes{
+func (mbv *MockBridgeTransfersView) L1BridgeDepositsByAddress(address common.Address) ([]*database.L1BridgeDepositWithTransactionHashes, error) {
+	return []*database.L1BridgeDepositWithTransactionHashes{
 		{
-			Withdrawal: database.Withdrawal{
-				GUID:                 uuid.MustParse(guid2),
-				InitiatedL2EventGUID: uuid.MustParse(guid1),
-				WithdrawalHash:       common.HexToHash("0x456"),
-				Tx:                   database.Transaction{},
-				TokenPair:            database.TokenPair{},
-			},
-			L2TransactionHash: common.HexToHash("0x789"),
+			L1BridgeDeposit:   deposit,
+			L1TransactionHash: common.HexToHash("0x123"),
 		},
 	}, nil
 }
 
-// WithdrawalsByMessageNonce mocks returning withdrawals by a withdrawal hash
-func (mbv *MockBridgeView) WithdrawalByMessageNonce(nonce *big.Int) (*database.Withdrawal, error) {
-	return &database.Withdrawal{
-		GUID:                 uuid.MustParse(guid2),
-		InitiatedL2EventGUID: uuid.MustParse(guid1),
-		WithdrawalHash:       common.HexToHash("0x456"),
-		Tx:                   database.Transaction{},
-		TokenPair:            database.TokenPair{},
-	}, nil
+func (mbv *MockBridgeTransfersView) L2BridgeWithdrawalByWithdrawalHash(address common.Hash) (*database.L2BridgeWithdrawal, error) {
+	return &withdrawal, nil
 }
 
-// WithdrawalsByHash mocks returning withdrawals by a withdrawal hash
-func (mbv *MockBridgeView) WithdrawalByHash(address common.Hash) (*database.Withdrawal, error) {
-	return &database.Withdrawal{
-		GUID:                 uuid.MustParse(guid2),
-		InitiatedL2EventGUID: uuid.MustParse(guid1),
-		WithdrawalHash:       common.HexToHash("0x456"),
-		Tx:                   database.Transaction{},
-		TokenPair:            database.TokenPair{},
-	}, nil
+func (mbv *MockBridgeTransfersView) L2BridgeWithdrawalByCrossDomainMessengerNonce(nonce *big.Int) (*database.L2BridgeWithdrawal, error) {
+	return &withdrawal, nil
 }
 
-// LatestWithdrawalMessageNonce mocks returning the latest cross domain message nonce for a withdrawal
-func (mbv *MockBridgeView) LatestWithdrawalMessageNonce() (*big.Int, error) {
-	return big.NewInt(0), nil
+func (mbv *MockBridgeTransfersView) L2BridgeWithdrawalsByAddress(address common.Address) ([]*database.L2BridgeWithdrawalWithTransactionHashes, error) {
+	return []*database.L2BridgeWithdrawalWithTransactionHashes{
+		{
+			L2BridgeWithdrawal: withdrawal,
+			L2TransactionHash:  common.HexToHash("0x789"),
+		},
+	}, nil
 }
 
 func TestHealthz(t *testing.T) {
-	api := NewApi(&MockBridgeView{})
+	api := NewApi(&MockBridgeTransfersView{})
 	request, err := http.NewRequest("GET", "/healthz", nil)
 	assert.Nil(t, err)
 
@@ -104,8 +82,8 @@ func TestHealthz(t *testing.T) {
 	assert.Equal(t, http.StatusOK, responseRecorder.Code)
 }
 
-func TestDepositsHandler(t *testing.T) {
-	api := NewApi(&MockBridgeView{})
+func TestL1BridgeDepositsHandler(t *testing.T) {
+	api := NewApi(&MockBridgeTransfersView{})
 	request, err := http.NewRequest("GET", "/api/v0/deposits/0x123", nil)
 	assert.Nil(t, err)
 
@@ -115,8 +93,8 @@ func TestDepositsHandler(t *testing.T) {
 	assert.Equal(t, http.StatusOK, responseRecorder.Code)
 }
 
-func TestWithdrawalsHandler(t *testing.T) {
-	api := NewApi(&MockBridgeView{})
+func TestL2BridgeWithdrawalsByAddressHandler(t *testing.T) {
+	api := NewApi(&MockBridgeTransfersView{})
 	request, err := http.NewRequest("GET", "/api/v0/withdrawals/0x123", nil)
 	assert.Nil(t, err)
 

indexer/cli/cli.go

@@ -23,15 +23,16 @@ type Cli struct {
 }
 
 func runIndexer(ctx *cli.Context) error {
+	logger := log.NewLogger(log.ReadCLIConfig(ctx))
+
 	configPath := ctx.String(ConfigFlag.Name)
 	cfg, err := config.LoadConfig(configPath)
 	if err != nil {
+		logger.Error("failed to load config", "err", err)
 		return err
 	}
 
-	// setup logger
-	cfg.Logger = log.NewLogger(log.ReadCLIConfig(ctx))
-
+	cfg.Logger = logger
 	indexer, err := indexer.NewIndexer(cfg)
 	if err != nil {
 		return err
@@ -47,17 +48,20 @@ func runIndexer(ctx *cli.Context) error {
 }
 
 func runApi(ctx *cli.Context) error {
-	configPath := ctx.String(ConfigFlag.Name)
-	conf, err := config.LoadConfig(configPath)
-
-	fmt.Println(conf)
+	logger := log.NewLogger(log.ReadCLIConfig(ctx))
 
+	configPath := ctx.String(ConfigFlag.Name)
+	cfg, err := config.LoadConfig(configPath)
 	if err != nil {
-		panic(err)
+		logger.Error("failed to load config", "err", err)
+		return err
 	}
 
+	cfg.Logger = logger
+	fmt.Println(cfg)
+
 	// finish me
-	return nil
+	return err
 }
 
 var (

indexer/database/db.go

@@ -10,9 +10,9 @@ import (
 type DB struct {
 	gorm *gorm.DB
 
-	Blocks         BlocksDB
-	ContractEvents ContractEventsDB
-	Bridge         BridgeDB
+	Blocks          BlocksDB
+	ContractEvents  ContractEventsDB
+	BridgeTransfers BridgeTransfersDB
 }
 
 func NewDB(dsn string) (*DB, error) {
@@ -31,10 +31,10 @@ func NewDB(dsn string) (*DB, error) {
 	}
 
 	db := &DB{
-		gorm:           gorm,
-		Blocks:         newBlocksDB(gorm),
-		ContractEvents: newContractEventsDB(gorm),
-		Bridge:         newBridgeDB(gorm),
+		gorm:            gorm,
+		Blocks:          newBlocksDB(gorm),
+		ContractEvents:  newContractEventsDB(gorm),
+		BridgeTransfers: newBridgeTransfersDB(gorm),
 	}
 
 	return db, nil
@@ -59,9 +59,9 @@ func (db *DB) Close() error {
 
 func dbFromGormTx(tx *gorm.DB) *DB {
 	return &DB{
-		gorm:           tx,
-		Blocks:         newBlocksDB(tx),
-		ContractEvents: newContractEventsDB(tx),
-		Bridge:         newBridgeDB(tx),
+		gorm:            tx,
+		Blocks:          newBlocksDB(tx),
+		ContractEvents:  newContractEventsDB(tx),
+		BridgeTransfers: newBridgeTransfersDB(tx),
 	}
 }

indexer/e2e_test/bridge_e2e_test.go

-package e2e_tests
-
-import (
-	"context"
-	"math/big"
-	"testing"
-	"time"
-
-	"github.com/ethereum-optimism/optimism/indexer/processor"
-	"github.com/ethereum-optimism/optimism/op-service/client/utils"
-
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
-	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
-	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
-
-	"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/params"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestE2EBridge(t *testing.T) {
-	testSuite := createE2ETestSuite(t)
-
-	l1Client := testSuite.OpSys.Clients["l1"]
-	l2Client := testSuite.OpSys.Clients["sequencer"]
-
-	l1StandardBridge, err := bindings.NewL1StandardBridge(testSuite.OpCfg.L1Deployments.L1StandardBridgeProxy, l1Client)
-	require.NoError(t, err)
-
-	l2StandardBridge, err := bindings.NewL2StandardBridge(predeploys.L2StandardBridgeAddr, l2Client)
-	require.NoError(t, err)
-
-	// pre-emptively conduct a deposit & withdrawal to speed up the test
-	setupCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	aliceAddr := testSuite.OpCfg.Secrets.Addresses().Alice
-
-	l1Opts, err := bind.NewKeyedTransactorWithChainID(testSuite.OpCfg.Secrets.Alice, testSuite.OpCfg.L1ChainIDBig())
-	require.NoError(t, err)
-	l2Opts, err := bind.NewKeyedTransactorWithChainID(testSuite.OpCfg.Secrets.Alice, testSuite.OpCfg.L2ChainIDBig())
-	require.NoError(t, err)
-
-	l1Opts.Value = big.NewInt(params.Ether)
-	l2Opts.Value = big.NewInt(params.Ether)
-
-	depositTx, err := l1StandardBridge.DepositETH(l1Opts, 200_000, []byte{byte(1)})
-	require.NoError(t, err)
-
-	withdrawTx, err := l2StandardBridge.Withdraw(l2Opts, processor.EthAddress, big.NewInt(params.Ether), 200_000, []byte{byte(1)})
-	require.NoError(t, err)
-
-	depositReceipt, err := utils.WaitReceiptOK(setupCtx, l1Client, depositTx.Hash())
-	require.NoError(t, err)
-
-	withdrawalReceipt, err := utils.WaitReceiptOK(setupCtx, l2Client, withdrawTx.Hash())
-	require.NoError(t, err)
-
-	t.Run("indexes ETH deposits", func(t *testing.T) {
-		testCtx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
-		defer cancel()
-
-		// Pause the L2Processor so that we can test for finalization separately. A pause is
-		// required since deposit inclusion is apart of the L2 block derivation process
-		testSuite.Indexer.L2Processor.PauseForTest()
-
-		// (1) Test Deposit Initiation
-
-		// wait for processor catchup
-		require.NoError(t, utils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
-			l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
-			return l1Header != nil && l1Header.Number.Uint64() >= depositReceipt.BlockNumber.Uint64(), nil
-		}))
-
-		aliceDeposits, err := testSuite.DB.Bridge.DepositsByAddress(aliceAddr)
-		require.NoError(t, err)
-		require.Len(t, aliceDeposits, 1)
-		require.Equal(t, depositTx.Hash(), aliceDeposits[0].L1TransactionHash)
-		require.Empty(t, aliceDeposits[0].FinalizedL2TransactionHash)
-
-		deposit := aliceDeposits[0].Deposit
-		require.Nil(t, deposit.FinalizedL2EventGUID)
-		require.Equal(t, processor.EthAddress, deposit.TokenPair.L1TokenAddress)
-		require.Equal(t, processor.EthAddress, deposit.TokenPair.L2TokenAddress)
-		require.Equal(t, big.NewInt(params.Ether), deposit.Tx.Amount.Int)
-		require.Equal(t, aliceAddr, deposit.Tx.FromAddress)
-		require.Equal(t, aliceAddr, deposit.Tx.ToAddress)
-		require.Equal(t, byte(1), deposit.Tx.Data[0])
-
-		// (2) Test Deposit Finalization
-		testSuite.Indexer.L2Processor.ResumeForTest()
-
-		// finalization hash can be deterministically derived from TransactionDeposited log
-		var depositTxHash common.Hash
-		for _, log := range depositReceipt.Logs {
-			if log.Topics[0] == derive.DepositEventABIHash {
-				deposit, err := derive.UnmarshalDepositLogEvent(log)
-				require.NoError(t, err)
-				depositTxHash = types.NewTx(deposit).Hash()
-				break
-			}
-		}
-
-		// wait for the l2 processor to catch this deposit in the derivation process
-		_, err = utils.WaitReceiptOK(testCtx, l2Client, depositTxHash)
-		require.NoError(t, err)
-		l2Height, err := l2Client.BlockNumber(testCtx)
-		require.NoError(t, err)
-		require.NoError(t, utils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
-			l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
-			return l2Header != nil && l2Header.Number.Uint64() >= l2Height, nil
-		}))
-
-		aliceDeposits, err = testSuite.DB.Bridge.DepositsByAddress(aliceAddr)
-		require.NoError(t, err)
-		require.Equal(t, depositTxHash, aliceDeposits[0].FinalizedL2TransactionHash)
-		require.NotNil(t, aliceDeposits[0].Deposit.FinalizedL2EventGUID)
-	})
-
-	t.Run("indexes ETH withdrawals", func(t *testing.T) {
-		testCtx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
-		defer cancel()
-
-		// (1) Test Withdrawal Initiation
-
-		// wait for processor catchup
-		require.NoError(t, utils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
-			l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
-			return l2Header != nil && l2Header.Number.Uint64() >= withdrawalReceipt.BlockNumber.Uint64(), nil
-		}))
-
-		aliceWithdrawals, err := testSuite.DB.Bridge.WithdrawalsByAddress(aliceAddr)
-		require.NoError(t, err)
-		require.Len(t, aliceWithdrawals, 1)
-		require.Equal(t, withdrawTx.Hash(), aliceWithdrawals[0].L2TransactionHash)
-		require.Empty(t, aliceWithdrawals[0].ProvenL1TransactionHash)
-		require.Empty(t, aliceWithdrawals[0].FinalizedL1TransactionHash)
-
-		withdrawal := aliceWithdrawals[0].Withdrawal
-		require.Nil(t, withdrawal.ProvenL1EventGUID)
-		require.Nil(t, withdrawal.FinalizedL1EventGUID)
-		require.Equal(t, processor.EthAddress, withdrawal.TokenPair.L1TokenAddress)
-		require.Equal(t, processor.EthAddress, withdrawal.TokenPair.L2TokenAddress)
-		require.Equal(t, big.NewInt(params.Ether), withdrawal.Tx.Amount.Int)
-		require.Equal(t, aliceAddr, withdrawal.Tx.FromAddress)
-		require.Equal(t, aliceAddr, withdrawal.Tx.ToAddress)
-		require.Equal(t, byte(1), withdrawal.Tx.Data[0])
-
-		// (2) Test Withdrawal Proven
-
-		// prove & wait for processor catchup
-		withdrawParams, proveReceipt := op_e2e.ProveWithdrawal(t, *testSuite.OpCfg, l1Client, testSuite.OpSys.Nodes["sequencer"], testSuite.OpCfg.Secrets.Alice, withdrawalReceipt)
-		require.NoError(t, utils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
-			l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
-			return l1Header != nil && l1Header.Number.Uint64() >= proveReceipt.BlockNumber.Uint64(), nil
-		}))
-
-		aliceWithdrawals, err = testSuite.DB.Bridge.WithdrawalsByAddress(aliceAddr)
-		require.NoError(t, err)
-		require.Empty(t, aliceWithdrawals[0].FinalizedL1TransactionHash)
-		require.Equal(t, proveReceipt.TxHash, aliceWithdrawals[0].ProvenL1TransactionHash)
-
-		// (3) Test Withdrawal Finalization
-
-		// finalize & wait for processor catchup
-		finalizeReceipt := op_e2e.FinalizeWithdrawal(t, *testSuite.OpCfg, l1Client, testSuite.OpCfg.Secrets.Alice, proveReceipt, withdrawParams)
-		require.NoError(t, utils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
-			l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
-			return l1Header != nil && l1Header.Number.Uint64() >= finalizeReceipt.BlockNumber.Uint64(), nil
-		}))
-
-		aliceWithdrawals, err = testSuite.DB.Bridge.WithdrawalsByAddress(aliceAddr)
-		require.NoError(t, err)
-		require.Equal(t, finalizeReceipt.TxHash, aliceWithdrawals[0].FinalizedL1TransactionHash)
-	})
-}

indexer/e2e_test/blocks_e2e_test.go → indexer/e2e_tests/blocks_e2e_test.go

@@ -23,25 +23,19 @@ import (
 func TestE2EBlockHeaders(t *testing.T) {
 	testSuite := createE2ETestSuite(t)
 
-	l1Client := testSuite.OpSys.Clients["l1"]
-	l2Client := testSuite.OpSys.Clients["sequencer"]
-	l2OutputOracle, err := bindings.NewL2OutputOracleCaller(testSuite.OpCfg.L1Deployments.L2OutputOracleProxy, l1Client)
+	l2OutputOracle, err := bindings.NewL2OutputOracle(testSuite.OpCfg.L1Deployments.L2OutputOracleProxy, testSuite.L1Client)
 	require.NoError(t, err)
 
-	// a minute for total setup to finish
-	setupCtx, cancel := context.WithTimeout(context.Background(), time.Minute)
-	defer cancel()
-
 	// wait for at least 10 L2 blocks to be created & posted on L1
-	require.NoError(t, utils.WaitFor(setupCtx, time.Second, func() (bool, error) {
-		l2Height, err := l2OutputOracle.LatestBlockNumber(&bind.CallOpts{Context: setupCtx})
+	require.NoError(t, utils.WaitFor(context.Background(), time.Second, func() (bool, error) {
+		l2Height, err := l2OutputOracle.LatestBlockNumber(&bind.CallOpts{Context: context.Background()})
 		return l2Height != nil && l2Height.Uint64() >= 9, err
 	}))
 
 	// ensure the processors are caught up to this state
-	l1Height, err := l1Client.BlockNumber(setupCtx)
+	l1Height, err := testSuite.L1Client.BlockNumber(context.Background())
 	require.NoError(t, err)
-	require.NoError(t, utils.WaitFor(setupCtx, time.Second, func() (bool, error) {
+	require.NoError(t, utils.WaitFor(context.Background(), time.Second, func() (bool, error) {
 		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
 		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
 		return (l1Header != nil && l1Header.Number.Uint64() >= l1Height) && (l2Header != nil && l2Header.Number.Uint64() >= 9), nil
@@ -60,7 +54,7 @@ func TestE2EBlockHeaders(t *testing.T) {
 			require.NoError(t, err)
 			require.NotNil(t, indexedHeader)
 
-			header, err := l2Client.HeaderByNumber(context.Background(), height)
+			header, err := testSuite.L2Client.HeaderByNumber(context.Background(), height)
 			require.NoError(t, err)
 			require.NotNil(t, indexedHeader)
 
@@ -93,7 +87,7 @@ func TestE2EBlockHeaders(t *testing.T) {
 			require.NotEmpty(t, output.L1ContractEventGUID)
 
 			// we may as well check the integrity of the output root
-			l2Block, err := l2Client.BlockByNumber(context.Background(), blockNumber)
+			l2Block, err := testSuite.L2Client.BlockByNumber(context.Background(), blockNumber)
 			require.NoError(t, err)
 			messagePasserStorageHash, err := l2EthClient.StorageHash(predeploys.L2ToL1MessagePasserAddr, blockNumber)
 			require.NoError(t, err)
@@ -111,12 +105,10 @@ func TestE2EBlockHeaders(t *testing.T) {
 		testCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 		defer cancel()
 
-		devContracts := make([]common.Address, 0)
-		testSuite.OpCfg.L1Deployments.ForEach(func(name string, address common.Address) {
-			devContracts = append(devContracts, address)
-		})
-		logFilter := ethereum.FilterQuery{FromBlock: big.NewInt(0), ToBlock: big.NewInt(int64(l1Height)), Addresses: devContracts}
-		logs, err := l1Client.FilterLogs(testCtx, logFilter) // []types.Log
+		l1Contracts := []common.Address{}
+		testSuite.OpCfg.L1Deployments.ForEach(func(name string, addr common.Address) { l1Contracts = append(l1Contracts, addr) })
+		logFilter := ethereum.FilterQuery{FromBlock: big.NewInt(0), ToBlock: big.NewInt(int64(l1Height)), Addresses: l1Contracts}
+		logs, err := testSuite.L1Client.FilterLogs(testCtx, logFilter) // []types.Log
 		require.NoError(t, err)
 
 		for _, log := range logs {
@@ -128,7 +120,7 @@ func TestE2EBlockHeaders(t *testing.T) {
 			require.Equal(t, log.Index, uint(contractEvent.LogIndex))
 
 			// ensure the block is also indexed
-			block, err := l1Client.BlockByNumber(testCtx, big.NewInt(int64(log.BlockNumber)))
+			block, err := testSuite.L1Client.BlockByNumber(testCtx, big.NewInt(int64(log.BlockNumber)))
 			require.NoError(t, err)
 
 			require.Equal(t, block.Time(), contractEvent.Timestamp)

indexer/e2e_tests/bridge_transfers_e2e_test.go

+package e2e_tests
+
+import (
+	"context"
+	"math/big"
+	"testing"
+	"time"
+
+	e2etest_utils "github.com/ethereum-optimism/optimism/indexer/e2e_tests/utils"
+	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
+	"github.com/ethereum-optimism/optimism/op-node/withdrawals"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
+	"github.com/ethereum-optimism/optimism/op-service/client/utils"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/params"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestE2EBridgeTransfersStandardBridgeETHDeposit(t *testing.T) {
+	testSuite := createE2ETestSuite(t)
+
+	l1StandardBridge, err := bindings.NewL1StandardBridge(testSuite.OpCfg.L1Deployments.L1StandardBridgeProxy, testSuite.L1Client)
+	require.NoError(t, err)
+
+	// 1 ETH transfer
+	aliceAddr := testSuite.OpCfg.Secrets.Addresses().Alice
+	l1Opts, err := bind.NewKeyedTransactorWithChainID(testSuite.OpCfg.Secrets.Alice, testSuite.OpCfg.L1ChainIDBig())
+	require.NoError(t, err)
+	l1Opts.Value = big.NewInt(params.Ether)
+
+	// Pause the L2Processor so that we can test for finalization separately. A pause is
+	// required since deposit inclusion is apart of the L2 block derivation process
+	testSuite.Indexer.L2Processor.PauseForTest()
+
+	// (1) Test Deposit Initiation
+	depositTx, err := l1StandardBridge.DepositETH(l1Opts, 200_000, []byte{byte(1)})
+	require.NoError(t, err)
+	depositReceipt, err := utils.WaitReceiptOK(context.Background(), testSuite.L1Client, depositTx.Hash())
+	require.NoError(t, err)
+
+	depositInfo, err := e2etest_utils.ParseDepositInfo(depositReceipt)
+	require.NoError(t, err)
+
+	// wait for processor catchup
+	require.NoError(t, utils.WaitFor(context.Background(), 500*time.Millisecond, func() (bool, error) {
+		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		return l1Header != nil && l1Header.Number.Uint64() >= depositReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	aliceDeposits, err := testSuite.DB.BridgeTransfers.L1BridgeDepositsByAddress(aliceAddr)
+	require.NoError(t, err)
+	require.Len(t, aliceDeposits, 1)
+	require.Equal(t, depositTx.Hash(), aliceDeposits[0].L1TransactionHash)
+	require.Empty(t, aliceDeposits[0].FinalizedL2TransactionHash)
+
+	deposit := aliceDeposits[0].L1BridgeDeposit
+	require.Equal(t, predeploys.LegacyERC20ETHAddr, deposit.TokenPair.L1TokenAddress)
+	require.Equal(t, predeploys.LegacyERC20ETHAddr, deposit.TokenPair.L2TokenAddress)
+	require.Equal(t, big.NewInt(params.Ether), deposit.Tx.Amount.Int)
+	require.Equal(t, aliceAddr, deposit.Tx.FromAddress)
+	require.Equal(t, aliceAddr, deposit.Tx.ToAddress)
+	require.Equal(t, byte(1), deposit.Tx.Data[0])
+
+	// (2) Test Deposit Finalization
+	require.Nil(t, deposit.FinalizedL2EventGUID)
+	testSuite.Indexer.L2Processor.ResumeForTest()
+
+	// wait for the l2 processor to catch this deposit in the derivation process
+	depositReceipt, err = utils.WaitReceiptOK(context.Background(), testSuite.L2Client, types.NewTx(depositInfo.DepositTx).Hash())
+	require.NoError(t, err)
+	require.NoError(t, utils.WaitFor(context.Background(), 500*time.Millisecond, func() (bool, error) {
+		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
+		return l2Header != nil && l2Header.Number.Uint64() >= depositReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	aliceDeposits, err = testSuite.DB.BridgeTransfers.L1BridgeDepositsByAddress(aliceAddr)
+	require.NoError(t, err)
+	require.NotNil(t, aliceDeposits[0].L1BridgeDeposit.FinalizedL2EventGUID)
+	require.Equal(t, types.NewTx(depositInfo.DepositTx).Hash(), aliceDeposits[0].FinalizedL2TransactionHash)
+}
+
+func TestE2EBridgeTransfersStandardBridgeETHWithdrawal(t *testing.T) {
+	testSuite := createE2ETestSuite(t)
+
+	optimismPortal, err := bindings.NewOptimismPortal(testSuite.OpCfg.L1Deployments.OptimismPortalProxy, testSuite.L1Client)
+	require.NoError(t, err)
+	l2StandardBridge, err := bindings.NewL2StandardBridge(predeploys.L2StandardBridgeAddr, testSuite.L2Client)
+	require.NoError(t, err)
+
+	// 1 ETH transfer
+	aliceAddr := testSuite.OpCfg.Secrets.Addresses().Alice
+	l2Opts, err := bind.NewKeyedTransactorWithChainID(testSuite.OpCfg.Secrets.Alice, testSuite.OpCfg.L2ChainIDBig())
+	require.NoError(t, err)
+	l2Opts.Value = big.NewInt(params.Ether)
+
+	// Ensure L1 has enough funds for the withdrawal by depositing an equal amount into the OptimismPortal
+	l1Opts, err := bind.NewKeyedTransactorWithChainID(testSuite.OpCfg.Secrets.Alice, testSuite.OpCfg.L1ChainIDBig())
+	require.NoError(t, err)
+	l1Opts.Value = l2Opts.Value
+	depositTx, err := optimismPortal.Receive(l1Opts)
+	require.NoError(t, err)
+	_, err = utils.WaitReceiptOK(context.Background(), testSuite.L1Client, depositTx.Hash())
+	require.NoError(t, err)
+
+	// (1) Test Withdrawal Initiation
+	withdrawTx, err := l2StandardBridge.Withdraw(l2Opts, predeploys.LegacyERC20ETHAddr, l2Opts.Value, 200_000, []byte{byte(1)})
+	require.NoError(t, err)
+	withdrawReceipt, err := utils.WaitReceiptOK(context.Background(), testSuite.L2Client, withdrawTx.Hash())
+	require.NoError(t, err)
+
+	// wait for processor catchup
+	require.NoError(t, utils.WaitFor(context.Background(), 500*time.Millisecond, func() (bool, error) {
+		l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
+		return l2Header != nil && l2Header.Number.Uint64() >= withdrawReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	aliceWithdrawals, err := testSuite.DB.BridgeTransfers.L2BridgeWithdrawalsByAddress(aliceAddr)
+	require.NoError(t, err)
+	require.Len(t, aliceWithdrawals, 1)
+	require.Equal(t, withdrawTx.Hash(), aliceWithdrawals[0].L2TransactionHash)
+
+	msgPassed, err := withdrawals.ParseMessagePassed(withdrawReceipt)
+	require.NoError(t, err)
+	withdrawalHash, err := withdrawals.WithdrawalHash(msgPassed)
+	require.NoError(t, err)
+
+	withdrawal := aliceWithdrawals[0].L2BridgeWithdrawal
+	require.Equal(t, withdrawalHash, withdrawal.WithdrawalHash)
+	require.Equal(t, predeploys.LegacyERC20ETHAddr, withdrawal.TokenPair.L1TokenAddress)
+	require.Equal(t, predeploys.LegacyERC20ETHAddr, withdrawal.TokenPair.L2TokenAddress)
+	require.Equal(t, big.NewInt(params.Ether), withdrawal.Tx.Amount.Int)
+	require.Equal(t, aliceAddr, withdrawal.Tx.FromAddress)
+	require.Equal(t, aliceAddr, withdrawal.Tx.ToAddress)
+	require.Equal(t, byte(1), withdrawal.Tx.Data[0])
+
+	// (2) Test Withdrawal Proven/Finalized. Test the sql join queries to populate the right transaction
+	require.Nil(t, withdrawal.ProvenL1EventGUID)
+	require.Nil(t, withdrawal.FinalizedL1EventGUID)
+	require.Empty(t, aliceWithdrawals[0].ProvenL1TransactionHash)
+	require.Empty(t, aliceWithdrawals[0].FinalizedL1TransactionHash)
+
+	// wait for processor catchup
+	proveReceipt, finalizeReceipt := op_e2e.ProveAndFinalizeWithdrawal(t, *testSuite.OpCfg, testSuite.L1Client, testSuite.OpSys.Nodes["sequencer"], testSuite.OpCfg.Secrets.Alice, withdrawReceipt)
+	require.NoError(t, utils.WaitFor(context.Background(), 500*time.Millisecond, func() (bool, error) {
+		l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+		return l1Header != nil && l1Header.Number.Uint64() >= finalizeReceipt.BlockNumber.Uint64(), nil
+	}))
+
+	aliceWithdrawals, err = testSuite.DB.BridgeTransfers.L2BridgeWithdrawalsByAddress(aliceAddr)
+	require.NoError(t, err)
+	require.NotNil(t, aliceWithdrawals[0].L2BridgeWithdrawal.ProvenL1EventGUID)
+	require.NotNil(t, aliceWithdrawals[0].L2BridgeWithdrawal.FinalizedL1EventGUID)
+	require.Equal(t, proveReceipt.TxHash, aliceWithdrawals[0].ProvenL1TransactionHash)
+	require.Equal(t, finalizeReceipt.TxHash, aliceWithdrawals[0].FinalizedL1TransactionHash)
+}

indexer/e2e_test/setup.go → indexer/e2e_tests/setup.go

@@ -17,6 +17,7 @@ import (
 
 	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 
 	_ "github.com/jackc/pgx/v5/stdlib"
@@ -33,6 +34,10 @@ type E2ETestSuite struct {
 	// Rollup
 	OpCfg *op_e2e.SystemConfig
 	OpSys *op_e2e.System
+
+	// Clients
+	L1Client *ethclient.Client
+	L2Client *ethclient.Client
 }
 
 func createE2ETestSuite(t *testing.T) E2ETestSuite {
@@ -48,16 +53,9 @@ func createE2ETestSuite(t *testing.T) E2ETestSuite {
 	opSys, err := opCfg.Start()
 	require.NoError(t, err)
 
-	l1Contracts := processor.L1Contracts{
-		OptimismPortal:         opCfg.L1Deployments.OptimismPortalProxy,
-		L2OutputOracle:         opCfg.L1Deployments.L2OutputOracleProxy,
-		L1CrossDomainMessenger: opCfg.L1Deployments.L1CrossDomainMessengerProxy,
-		L1StandardBridge:       opCfg.L1Deployments.L1StandardBridgeProxy,
-		L1ERC721Bridge:         opCfg.L1Deployments.L1ERC721BridgeProxy,
-	}
-
 	// Indexer Configuration and Start
 	indexerCfg := config.Config{
+		Logger: logger,
 		DB: config.DBConfig{
 			Host: "127.0.0.1",
 			Port: 5432,
@@ -68,9 +66,14 @@ func createE2ETestSuite(t *testing.T) E2ETestSuite {
 			L1RPC: opSys.Nodes["l1"].HTTPEndpoint(),
 			L2RPC: opSys.Nodes["sequencer"].HTTPEndpoint(),
 		},
-		Logger: logger,
 		Chain: config.ChainConfig{
-			L1Contracts: l1Contracts,
+			L1Contracts: processor.L1Contracts{
+				OptimismPortal:         opCfg.L1Deployments.OptimismPortalProxy,
+				L2OutputOracle:         opCfg.L1Deployments.L2OutputOracleProxy,
+				L1CrossDomainMessenger: opCfg.L1Deployments.L1CrossDomainMessengerProxy,
+				L1StandardBridge:       opCfg.L1Deployments.L1StandardBridgeProxy,
+				L1ERC721Bridge:         opCfg.L1Deployments.L1ERC721BridgeProxy,
+			},
 		},
 	}
 
@@ -99,11 +102,13 @@ func createE2ETestSuite(t *testing.T) E2ETestSuite {
 	})
 
 	return E2ETestSuite{
-		t:       t,
-		DB:      db,
-		Indexer: indexer,
-		OpCfg:   &opCfg,
-		OpSys:   opSys,
+		t:        t,
+		DB:       db,
+		Indexer:  indexer,
+		OpCfg:    &opCfg,
+		OpSys:    opSys,
+		L1Client: opSys.Clients["l1"],
+		L2Client: opSys.Clients["sequencer"],
 	}
 }
 

indexer/e2e_tests/utils/deposits.go

+package utils
+
+import (
+	"errors"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type DepositInfo struct {
+	*bindings.OptimismPortalTransactionDeposited
+	DepositTx *types.DepositTx
+}
+
+func ParseDepositInfo(depositReceipt *types.Receipt) (*DepositInfo, error) {
+	optimismPortal, err := bindings.NewOptimismPortal(common.Address{}, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, log := range depositReceipt.Logs {
+		if log.Topics[0] == derive.DepositEventABIHash {
+			portalTxDeposited, err := optimismPortal.ParseTransactionDeposited(*log)
+			if err != nil {
+				return nil, err
+			}
+			depositTx, err := derive.UnmarshalDepositLogEvent(log)
+			if err != nil {
+				return nil, err
+			}
+
+			return &DepositInfo{portalTxDeposited, depositTx}, nil
+		}
+	}
+
+	return nil, errors.New("cannot find deposit event in receipt")
+}

indexer/indexer.go

@@ -72,21 +72,30 @@ func NewIndexer(cfg config.Config) (*Indexer, error) {
 // Start starts the indexing service on L1 and L2 chains
 func (i *Indexer) Run(ctx context.Context) error {
 	var wg sync.WaitGroup
-	errCh := make(chan error)
+	errCh := make(chan error, 1)
 
 	// If either processor errors out, we stop
 	processorCtx, cancel := context.WithCancel(ctx)
 	run := func(start func(ctx context.Context) error) {
 		wg.Add(1)
-		defer wg.Done()
+		defer func() {
+			if err := recover(); err != nil {
+				i.log.Error("halting indexer on panic", "err", err)
+				errCh <- fmt.Errorf("panic: %v", err)
+			}
+
+			wg.Done()
+		}()
 
 		err := start(processorCtx)
 		if err != nil {
 			i.log.Error("halting indexer on error", "err", err)
-
 			cancel()
-			errCh <- err
 		}
+
+		// Send a value down regardless if we've received an error or halted
+		// via cancellation where err == nil
+		errCh <- err
 	}
 
 	// Kick off the processors

indexer/migrations/20230523_create_schema.sql

@@ -67,12 +67,12 @@ CREATE TABLE IF NOT EXISTS output_proposals (
  * BRIDGING DATA
  */
 
-CREATE TABLE IF NOT EXISTS deposits (
+CREATE TABLE IF NOT EXISTS l1_bridge_deposits (
 	guid                 VARCHAR PRIMARY KEY NOT NULL,
 
     -- Event causing the deposit
-    initiated_l1_event_guid VARCHAR NOT NULL REFERENCES l1_contract_events(guid),
-    sent_message_nonce      UINT256 UNIQUE,
+    initiated_l1_event_guid      VARCHAR NOT NULL REFERENCES l1_contract_events(guid),
+    cross_domain_messenger_nonce UINT256 UNIQUE,
 
     -- Finalization marker for the deposit
     finalized_l2_event_guid VARCHAR REFERENCES l2_contract_events(guid),
@@ -88,12 +88,12 @@ CREATE TABLE IF NOT EXISTS deposits (
     timestamp        INTEGER NOT NULL CHECK (timestamp > 0)
 );
 
-CREATE TABLE IF NOT EXISTS withdrawals (
+CREATE TABLE IF NOT EXISTS l2_bridge_withdrawals (
 	guid                VARCHAR PRIMARY KEY NOT NULL,
 
     -- Event causing this withdrawal
-    initiated_l2_event_guid VARCHAR NOT NULL REFERENCES l2_contract_events(guid),
-    sent_message_nonce      UINT256 UNIQUE,
+    initiated_l2_event_guid      VARCHAR NOT NULL REFERENCES l2_contract_events(guid),
+    cross_domain_messenger_nonce UINT256 UNIQUE,
 
     -- Multistep (bedrock) process of a withdrawal
     withdrawal_hash      VARCHAR NOT NULL,

indexer/processor/l1_processor.go

@@ -255,13 +255,13 @@ func l1BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 		return err
 	}
 
-	deposits := make([]*database.Deposit, len(initiatedDepositEvents))
+	deposits := make([]*database.L1BridgeDeposit, len(initiatedDepositEvents))
 	for i, initiatedBridgeEvent := range initiatedDepositEvents {
-		deposits[i] = &database.Deposit{
-			GUID:                 uuid.New(),
-			InitiatedL1EventGUID: initiatedBridgeEvent.RawEvent.GUID,
-			SentMessageNonce:     database.U256{Int: initiatedBridgeEvent.CrossDomainMessengerNonce},
-			TokenPair:            database.TokenPair{L1TokenAddress: initiatedBridgeEvent.LocalToken, L2TokenAddress: initiatedBridgeEvent.RemoteToken},
+		deposits[i] = &database.L1BridgeDeposit{
+			GUID:                      uuid.New(),
+			InitiatedL1EventGUID:      initiatedBridgeEvent.RawEvent.GUID,
+			CrossDomainMessengerNonce: database.U256{Int: initiatedBridgeEvent.CrossDomainMessengerNonce},
+			TokenPair:                 database.TokenPair{L1TokenAddress: initiatedBridgeEvent.LocalToken, L2TokenAddress: initiatedBridgeEvent.RemoteToken},
 			Tx: database.Transaction{
 				FromAddress: initiatedBridgeEvent.From,
 				ToAddress:   initiatedBridgeEvent.To,
@@ -274,7 +274,7 @@ func l1BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 
 	if len(deposits) > 0 {
 		processLog.Info("detected L1StandardBridge deposits", "num", len(deposits))
-		err := db.Bridge.StoreDeposits(deposits)
+		err := db.BridgeTransfers.StoreL1BridgeDeposits(deposits)
 		if err != nil {
 			return err
 		}
@@ -286,47 +286,39 @@ func l1BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 		return err
 	}
 
-	// we manually keep track since not every proven withdrawal is a standard bridge withdrawal
+	latestL2Header, err := db.Blocks.LatestL2BlockHeader()
+	if err != nil {
+		return err
+	} else if len(provenWithdrawalEvents) > 0 && latestL2Header == nil {
+		return errors.New("no indexed L2 state to process any proven L1 transactions")
+	}
+
 	numProvenWithdrawals := 0
 	for _, provenWithdrawalEvent := range provenWithdrawalEvents {
 		withdrawalHash := provenWithdrawalEvent.WithdrawalHash
-		withdrawal, err := db.Bridge.WithdrawalByHash(withdrawalHash)
+		withdrawal, err := db.BridgeTransfers.L2BridgeWithdrawalByWithdrawalHash(withdrawalHash)
 		if err != nil {
 			return err
-		}
-
-		// Check if the L2Processor is behind or really has missed an event. We can compare against the
-		// OptimismPortal#ProvenWithdrawal on-chain mapping relative to the latest indexed L2 height
-		if withdrawal == nil {
-
-			// This needs to be updated to read from config as well as correctly identify if the CrossDomainMessenger message is a standard
-			// bridge message. This will easier to do once we index passed messages separately which will include the right To/From fields
+		} else if withdrawal == nil {
+			// NOTE: This needs to be updated to identify if this CrossDomainMessenger message is a StandardBridge message. This
+			// will be easier to do once we index cross domain messages and track its lifecyle separately
 			if provenWithdrawalEvent.From != common.HexToAddress("0x4200000000000000000000000000000000000007") || provenWithdrawalEvent.To != l1Contracts.L1CrossDomainMessenger {
 				// non-bridge withdrawal
 				continue
 			}
 
-			// Query for the the proven withdrawal on-chain
-			provenWithdrawal, err := OptimismPortalQueryProvenWithdrawal(rawEthClient, l1Contracts.OptimismPortal, withdrawalHash)
-			if err != nil {
-				return err
-			}
-
-			latestL2Header, err := db.Blocks.LatestL2BlockHeader()
-			if err != nil {
-				return err
-			}
-
-			if latestL2Header == nil || provenWithdrawal.L2OutputIndex.Cmp(latestL2Header.Number.Int) > 0 {
-				processLog.Warn("behind on indexed L2 withdrawals")
+			// Check if the L2Processor is behind or really has missed an event. Since L2 timestamps
+			// are derived from L1, we can simply compare timestamps
+			if provenWithdrawalEvent.RawEvent.Timestamp > latestL2Header.Timestamp {
+				processLog.Warn("behind on indexed L2StandardBridge withdrawals")
 				return errors.New("waiting for L2Processor to catch up")
 			} else {
-				processLog.Crit("missing indexed withdrawal for this proven event")
+				processLog.Crit("missing indexed L2StandardBridge withdrawal for this proven event")
 				return errors.New("missing withdrawal message")
 			}
 		}
 
-		err = db.Bridge.MarkProvenWithdrawalEvent(withdrawal.GUID, provenWithdrawalEvent.RawEvent.GUID)
+		err = db.BridgeTransfers.MarkProvenL2BridgeWithdrawalEvent(withdrawal.GUID, provenWithdrawalEvent.RawEvent.GUID)
 		if err != nil {
 			return err
 		}
@@ -346,7 +338,7 @@ func l1BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 
 	for _, finalizedBridgeEvent := range finalizedWithdrawalEvents {
 		nonce := finalizedBridgeEvent.CrossDomainMessengerNonce
-		withdrawal, err := db.Bridge.WithdrawalByMessageNonce(nonce)
+		withdrawal, err := db.BridgeTransfers.L2BridgeWithdrawalByCrossDomainMessengerNonce(nonce)
 		if err != nil {
 			processLog.Error("error querying associated withdrawal messsage using nonce", "cross_domain_messenger_nonce", nonce)
 			return err
@@ -359,7 +351,7 @@ func l1BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 			return errors.New("missing withdrawal message")
 		}
 
-		err = db.Bridge.MarkFinalizedWithdrawalEvent(withdrawal.GUID, finalizedBridgeEvent.RawEvent.GUID)
+		err = db.BridgeTransfers.MarkFinalizedL2BridgeWithdrawalEvent(withdrawal.GUID, finalizedBridgeEvent.RawEvent.GUID)
 		if err != nil {
 			processLog.Error("error finalizing withdrawal", "err", err)
 			return err

indexer/processor/l2_processor.go

@@ -183,7 +183,7 @@ func l2BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 		return err
 	}
 
-	withdrawals := make([]*database.Withdrawal, len(initiatedWithdrawalEvents))
+	withdrawals := make([]*database.L2BridgeWithdrawal, len(initiatedWithdrawalEvents))
 	for i, initiatedBridgeEvent := range initiatedWithdrawalEvents {
 		log := events.eventLog[initiatedBridgeEvent.RawEvent.GUID]
 
@@ -195,12 +195,12 @@ func l2BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 			return err
 		}
 
-		withdrawals[i] = &database.Withdrawal{
-			GUID:                 uuid.New(),
-			InitiatedL2EventGUID: initiatedBridgeEvent.RawEvent.GUID,
-			SentMessageNonce:     database.U256{Int: initiatedBridgeEvent.CrossDomainMessengerNonce},
-			WithdrawalHash:       msgPassedData.WithdrawalHash,
-			TokenPair:            database.TokenPair{L1TokenAddress: initiatedBridgeEvent.LocalToken, L2TokenAddress: initiatedBridgeEvent.RemoteToken},
+		withdrawals[i] = &database.L2BridgeWithdrawal{
+			GUID:                      uuid.New(),
+			InitiatedL2EventGUID:      initiatedBridgeEvent.RawEvent.GUID,
+			CrossDomainMessengerNonce: database.U256{Int: initiatedBridgeEvent.CrossDomainMessengerNonce},
+			WithdrawalHash:            msgPassedData.WithdrawalHash,
+			TokenPair:                 database.TokenPair{L1TokenAddress: initiatedBridgeEvent.LocalToken, L2TokenAddress: initiatedBridgeEvent.RemoteToken},
 			Tx: database.Transaction{
 				FromAddress: initiatedBridgeEvent.From,
 				ToAddress:   initiatedBridgeEvent.To,
@@ -213,7 +213,7 @@ func l2BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 
 	if len(withdrawals) > 0 {
 		processLog.Info("detected L2StandardBridge withdrawals", "num", len(withdrawals))
-		err := db.Bridge.StoreWithdrawals(withdrawals)
+		err := db.BridgeTransfers.StoreL2BridgeWithdrawals(withdrawals)
 		if err != nil {
 			return err
 		}
@@ -225,30 +225,33 @@ func l2BridgeProcessContractEvents(processLog log.Logger, db *database.DB, ethCl
 		return err
 	}
 
+	latestL1Header, err := db.Blocks.LatestL1BlockHeader()
+	if err != nil {
+		return err
+	} else if len(finalizationBridgeEvents) > 0 && latestL1Header == nil {
+		return errors.New("no indexed L1 state to process any L2 bridge finalizations")
+	}
+
 	for _, finalizedBridgeEvent := range finalizationBridgeEvents {
 		nonce := finalizedBridgeEvent.CrossDomainMessengerNonce
 
-		deposit, err := db.Bridge.DepositByMessageNonce(nonce)
+		deposit, err := db.BridgeTransfers.L1BridgeDepositByCrossDomainMessengerNonce(nonce)
 		if err != nil {
 			processLog.Error("error querying associated deposit messsage using nonce", "cross_domain_messenger_nonce", nonce)
 			return err
 		} else if deposit == nil {
-			latestNonce, err := db.Bridge.LatestDepositMessageNonce()
-			if err != nil {
-				return err
-			}
-
-			// Check if the L1Processor is behind or really has missed an event
-			if latestNonce == nil || nonce.Cmp(latestNonce) > 0 {
-				processLog.Warn("behind on indexed L1 deposits")
+			// Check if the L1Processor is behind or really has missed an event. Since L2 timestamps
+			// are derived from L1, we can simply compare timestamps
+			if finalizedBridgeEvent.RawEvent.Timestamp > latestL1Header.Timestamp {
+				processLog.Warn("behind on indexed L1StandardBridge deposits")
 				return errors.New("waiting for L1Processor to catch up")
 			} else {
-				processLog.Crit("missing indexed deposit for this finalization event")
+				processLog.Crit("missing indexed L1StandardBridge deposit for this finalization event")
 				return errors.New("missing deposit message")
 			}
 		}
 
-		err = db.Bridge.MarkFinalizedDepositEvent(deposit.GUID, finalizedBridgeEvent.RawEvent.GUID)
+		err = db.BridgeTransfers.MarkFinalizedL1BridgeDepositEvent(deposit.GUID, finalizedBridgeEvent.RawEvent.GUID)
 		if err != nil {
 			processLog.Error("error finalizing deposit", "err", err)
 			return err

op-bindings/bindings/alphabetvm.go

@@ -31,7 +31,7 @@ var (
 // AlphabetVMMetaData contains all meta data concerning the AlphabetVM contract.
 var AlphabetVMMetaData = &bind.MetaData{
 	ABI: "[{\"inputs\":[{\"internalType\":\"Claim\",\"name\":\"_absolutePrestate\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"oracle\",\"outputs\":[{\"internalType\":\"contractIPreimageOracle\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_stateData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"step\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"postState_\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
-	Bin: "0x60a060405234801561001057600080fd5b5060405161039838038061039883398101604081905261002f9161007a565b608081905261003c610062565b600080546001600160a01b0319166001600160a01b039290921691909117905550610093565b6460016000f36000908152600580601b83f091505090565b60006020828403121561008c57600080fd5b5051919050565b6080516102eb6100ad600039600060ad01526102eb6000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c80637dc0d1d01461003b578063f8e0cb9614610085575b600080fd5b60005461005b9073ffffffffffffffffffffffffffffffffffffffff1681565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020015b60405180910390f35b6100986100933660046101a8565b6100a6565b60405190815260200161007c565b60008060007f000000000000000000000000000000000000000000000000000000000000000087876040516100dc929190610214565b60405180910390200361010057600091506100f986880188610224565b905061011f565b61010c8688018861023d565b90925090508161011b8161028e565b9250505b8161012b8260016102c6565b6040805160208101939093528201526060016040516020818303038152906040528051906020012092505050949350505050565b60008083601f84011261017157600080fd5b50813567ffffffffffffffff81111561018957600080fd5b6020830191508360208285010111156101a157600080fd5b9250929050565b600080600080604085870312156101be57600080fd5b843567ffffffffffffffff808211156101d657600080fd5b6101e28883890161015f565b909650945060208701359150808211156101fb57600080fd5b506102088782880161015f565b95989497509550505050565b8183823760009101908152919050565b60006020828403121561023657600080fd5b5035919050565b6000806040838503121561025057600080fd5b50508035926020909101359150565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82036102bf576102bf61025f565b5060010190565b600082198211156102d9576102d961025f565b50019056fea164736f6c634300080f000a",
+	Bin: "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",
 }
 
 // AlphabetVMABI is the input ABI used to generate the binding from.

op-chain-ops/genesis/config.go

@@ -470,6 +470,7 @@ func NewDeployConfigWithNetwork(network, path string) (*DeployConfig, error) {
 // L1Deployments represents a set of L1 contracts that are deployed.
 type L1Deployments struct {
 	AddressManager                    common.Address `json:"AddressManager"`
+	BlockOracle                       common.Address `json:"BlockOracle"`
 	DisputeGameFactory                common.Address `json:"DisputeGameFactory"`
 	DisputeGameFactoryProxy           common.Address `json:"DisputeGameFactoryProxy"`
 	L1CrossDomainMessenger            common.Address `json:"L1CrossDomainMessenger"`
@@ -512,7 +513,7 @@ func (d *L1Deployments) Check() error {
 	for i := 0; i < val.NumField(); i++ {
 		name := val.Type().Field(i).Name
 		// Skip the non production ready contracts
-		if name == "DisputeGameFactory" || name == "DisputeGameFactoryProxy" {
+		if name == "DisputeGameFactory" || name == "DisputeGameFactoryProxy" || name == "BlockOracle" {
 			continue
 		}
 		if val.Field(i).Interface().(common.Address) == (common.Address{}) {

op-chain-ops/srcmap/solutil.go

@@ -220,6 +220,13 @@ func (s *SourceMapTracer) info(codeAddr *common.Address, pc uint64) string {
 }
 
 func (s *SourceMapTracer) CaptureState(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, rData []byte, depth int, err error) {
+	if op.IsPush() {
+		start := uint64(op) - uint64(vm.PUSH1) + 1
+		end := pc + 1 + start
+		val := scope.Contract.Code[pc+1 : end]
+		fmt.Fprintf(s.out, "%-40s : pc %x opcode %s (%x)\n", s.info(scope.Contract.CodeAddr, pc), pc, op.String(), val)
+		return
+	}
 	fmt.Fprintf(s.out, "%-40s : pc %x opcode %s\n", s.info(scope.Contract.CodeAddr, pc), pc, op.String())
 }
 

op-challenger/cmd/main_test.go

@@ -13,17 +13,16 @@ import (
 )
 
 var (
-	l1EthRpc                   = "http://example.com:8545"
-	gameAddressValue           = "0xaa00000000000000000000000000000000000000"
-	preimageOracleAddressValue = "0xbb00000000000000000000000000000000000000"
-	cannonBin                  = "./bin/cannon"
-	cannonServer               = "./bin/op-program"
-	cannonPreState             = "./pre.json"
-	cannonDatadir              = "./test_data"
-	cannonL2                   = "http://example.com:9545"
-	alphabetTrace              = "abcdefghijz"
-	agreeWithProposedOutput    = "true"
-	gameDepth                  = "4"
+	l1EthRpc                = "http://example.com:8545"
+	gameAddressValue        = "0xaa00000000000000000000000000000000000000"
+	cannonBin               = "./bin/cannon"
+	cannonServer            = "./bin/op-program"
+	cannonPreState          = "./pre.json"
+	cannonDatadir           = "./test_data"
+	cannonL2                = "http://example.com:9545"
+	alphabetTrace           = "abcdefghijz"
+	agreeWithProposedOutput = "true"
+	gameDepth               = "4"
 )
 
 func TestLogLevel(t *testing.T) {
@@ -43,14 +42,14 @@ func TestLogLevel(t *testing.T) {
 
 func TestDefaultCLIOptionsMatchDefaultConfig(t *testing.T) {
 	cfg := configForArgs(t, addRequiredArgs(config.TraceTypeAlphabet))
-	defaultCfg := config.NewConfig(l1EthRpc, common.HexToAddress(gameAddressValue), common.HexToAddress(preimageOracleAddressValue), config.TraceTypeAlphabet, true, 4)
+	defaultCfg := config.NewConfig(l1EthRpc, common.HexToAddress(gameAddressValue), config.TraceTypeAlphabet, true, 4)
 	// Add in the extra CLI options required when using alphabet trace type
 	defaultCfg.AlphabetTrace = alphabetTrace
 	require.Equal(t, defaultCfg, cfg)
 }
 
 func TestDefaultConfigIsValid(t *testing.T) {
-	cfg := config.NewConfig(l1EthRpc, common.HexToAddress(gameAddressValue), common.HexToAddress(preimageOracleAddressValue), config.TraceTypeAlphabet, true, 4)
+	cfg := config.NewConfig(l1EthRpc, common.HexToAddress(gameAddressValue), config.TraceTypeAlphabet, true, 4)
 	// Add in options that are required based on the specific trace type
 	// To avoid needing to specify unused options, these aren't included in the params for NewConfig
 	cfg.AlphabetTrace = alphabetTrace
@@ -140,26 +139,6 @@ func TestGameDepth(t *testing.T) {
 	})
 }
 
-func TestPreimageOracleAddress(t *testing.T) {
-	t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
-		configForArgs(t, addRequiredArgsExcept(config.TraceTypeAlphabet, "--preimage-oracle-address"))
-	})
-
-	t.Run("Required", func(t *testing.T) {
-		verifyArgsInvalid(t, "flag preimage-oracle-address is required", addRequiredArgsExcept(config.TraceTypeCannon, "--preimage-oracle-address"))
-	})
-
-	t.Run("Valid", func(t *testing.T) {
-		addr := common.Address{0xbb, 0xcc, 0xdd}
-		cfg := configForArgs(t, addRequiredArgsExcept(config.TraceTypeCannon, "--preimage-oracle-address", "--preimage-oracle-address="+addr.Hex()))
-		require.Equal(t, addr, cfg.PreimageOracleAddress)
-	})
-
-	t.Run("Invalid", func(t *testing.T) {
-		verifyArgsInvalid(t, "invalid address: foo", addRequiredArgsExcept(config.TraceTypeCannon, "--preimage-oracle-address", "--preimage-oracle-address=foo"))
-	})
-}
-
 func TestCannonBin(t *testing.T) {
 	t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
 		configForArgs(t, addRequiredArgsExcept(config.TraceTypeAlphabet, "--cannon-bin"))
@@ -288,7 +267,6 @@ func requiredArgs(traceType config.TraceType) map[string]string {
 		"--agree-with-proposed-output": agreeWithProposedOutput,
 		"--l1-eth-rpc":                 l1EthRpc,
 		"--game-address":               gameAddressValue,
-		"--preimage-oracle-address":    preimageOracleAddressValue,
 		"--trace-type":                 traceType.String(),
 	}
 	switch traceType {

op-challenger/config/config.go

@@ -61,7 +61,6 @@ const DefaultCannonSnapshotFreq = uint(10_000)
 type Config struct {
 	L1EthRpc                string         // L1 RPC Url
 	GameAddress             common.Address // Address of the fault game
-	PreimageOracleAddress   common.Address // Address of the pre-image oracle
 	AgreeWithProposedOutput bool           // Temporary config if we agree or disagree with the posted output
 	GameDepth               int            // Depth of the game tree
 
@@ -84,15 +83,13 @@ type Config struct {
 func NewConfig(
 	l1EthRpc string,
 	gameAddress common.Address,
-	preimageOracleAddress common.Address,
 	traceType TraceType,
 	agreeWithProposedOutput bool,
 	gameDepth int,
 ) Config {
 	return Config{
-		L1EthRpc:              l1EthRpc,
-		GameAddress:           gameAddress,
-		PreimageOracleAddress: preimageOracleAddress,
+		L1EthRpc:    l1EthRpc,
+		GameAddress: gameAddress,
 
 		AgreeWithProposedOutput: agreeWithProposedOutput,
 		GameDepth:               gameDepth,
@@ -116,9 +113,6 @@ func (c Config) Check() error {
 		return ErrMissingTraceType
 	}
 	if c.TraceType == TraceTypeCannon {
-		if c.PreimageOracleAddress == (common.Address{}) {
-			return ErrMissingPreimageOracleAddress
-		}
 		if c.CannonBin == "" {
 			return ErrMissingCannonBin
 		}

op-challenger/config/config_test.go

@@ -11,7 +11,6 @@ import (
 var (
 	validL1EthRpc              = "http://localhost:8545"
 	validGameAddress           = common.HexToAddress("0x7bdd3b028C4796eF0EAf07d11394d0d9d8c24139")
-	validPreimageOracleAddress = common.HexToAddress("0x7bdd3b028C4796eF0EAf07d11394d0d9d8c24139")
 	validAlphabetTrace         = "abcdefgh"
 	validCannonBin             = "./bin/cannon"
 	validCannonOpProgramBin    = "./bin/op-program"
@@ -23,7 +22,7 @@ var (
 )
 
 func validConfig(traceType TraceType) Config {
-	cfg := NewConfig(validL1EthRpc, validGameAddress, validPreimageOracleAddress, traceType, agreeWithProposedOutput, gameDepth)
+	cfg := NewConfig(validL1EthRpc, validGameAddress, traceType, agreeWithProposedOutput, gameDepth)
 	switch traceType {
 	case TraceTypeAlphabet:
 		cfg.AlphabetTrace = validAlphabetTrace
@@ -74,12 +73,6 @@ func TestAlphabetTraceRequired(t *testing.T) {
 	require.ErrorIs(t, config.Check(), ErrMissingAlphabetTrace)
 }
 
-func TestCannonPreimageOracleAddressRequired(t *testing.T) {
-	config := validConfig(TraceTypeCannon)
-	config.PreimageOracleAddress = common.Address{}
-	require.ErrorIs(t, config.Check(), ErrMissingPreimageOracleAddress)
-}
-
 func TestCannonBinRequired(t *testing.T) {
 	config := validConfig(TraceTypeCannon)
 	config.CannonBin = ""

op-challenger/fault/abi_test.go

@@ -36,6 +36,7 @@ func setupFaultDisputeGame() (common.Address, *bind.TransactOpts, *backends.Simu
 	_, _, contract, err := bindings.DeployFaultDisputeGame(
 		opts,
 		backend,
+		uint8(0),             // Game Type ID
 		[32]byte{0x01},       // Absolute Prestate Claim
 		big.NewInt(15),       // Max Game Depth
 		uint64(604800),       // 7 days

op-challenger/fault/agent.go

@@ -23,16 +23,18 @@ type Agent struct {
 	solver                  *solver.Solver
 	loader                  Loader
 	responder               Responder
+	updater                 types.OracleUpdater
 	maxDepth                int
 	agreeWithProposedOutput bool
 	log                     log.Logger
 }
 
-func NewAgent(loader Loader, maxDepth int, trace types.TraceProvider, responder Responder, agreeWithProposedOutput bool, log log.Logger) *Agent {
+func NewAgent(loader Loader, maxDepth int, trace types.TraceProvider, responder Responder, updater types.OracleUpdater, agreeWithProposedOutput bool, log log.Logger) *Agent {
 	return &Agent{
 		solver:                  solver.NewSolver(maxDepth, trace),
 		loader:                  loader,
 		responder:               responder,
+		updater:                 updater,
 		maxDepth:                maxDepth,
 		agreeWithProposedOutput: agreeWithProposedOutput,
 		log:                     log,
@@ -132,6 +134,17 @@ func (a *Agent) step(ctx context.Context, claim types.Claim, game types.Game) er
 		return nil
 	}
 
+	oracleData, err := a.solver.GetOracleData(ctx, claim)
+	if err != nil {
+		a.log.Debug("Failed to get oracle data", "err", err)
+		return nil
+	}
+
+	a.log.Info("Updating oracle data", "oracleKey", oracleData.OracleKey, "oracleData", oracleData.OracleData)
+	if err := a.updater.UpdateOracle(ctx, *oracleData); err != nil {
+		return fmt.Errorf("failed to load oracle data: %w", err)
+	}
+
 	a.log.Info("Attempting step", "claim_depth", claim.Depth(), "maxDepth", a.maxDepth)
 	step, err := a.solver.AttemptStep(ctx, claim, agreeWithClaimLevel)
 	if err != nil {

op-challenger/fault/cannon/executor.go

@@ -56,31 +56,44 @@ func NewExecutor(logger log.Logger, cfg *config.Config, inputs localGameInputs)
 }
 
 func (e *Executor) GenerateProof(ctx context.Context, dir string, i uint64) error {
-	start, err := e.selectSnapshot(e.logger, filepath.Join(e.dataDir, snapsDir), e.absolutePreState, i)
+	snapshotDir := filepath.Join(dir, snapsDir)
+	start, err := e.selectSnapshot(e.logger, snapshotDir, e.absolutePreState, i)
 	if err != nil {
 		return fmt.Errorf("find starting snapshot: %w", err)
 	}
+	proofDir := filepath.Join(dir, proofsDir)
+	dataDir := filepath.Join(e.dataDir, preimagesDir)
 	args := []string{
 		"run",
 		"--input", start,
+		"--output", filepath.Join(dir, "out.json"),
+		"--meta", "",
 		"--proof-at", "=" + strconv.FormatUint(i, 10),
 		"--stop-at", "=" + strconv.FormatUint(i+1, 10),
-		"--proof-fmt", filepath.Join(dir, proofsDir, "%d.json"),
+		"--proof-fmt", filepath.Join(proofDir, "%d.json"),
 		"--snapshot-at", "%" + strconv.FormatUint(uint64(e.snapshotFreq), 10),
-		"--snapshot-fmt", filepath.Join(e.dataDir, snapsDir, "%d.json"),
+		"--snapshot-fmt", filepath.Join(snapshotDir, "%d.json"),
 		"--",
 		e.server,
 		"--l1", e.l1,
 		"--l2", e.l2,
-		"--datadir", filepath.Join(e.dataDir, preimagesDir),
+		"--datadir", dataDir,
 		"--l1.head", e.inputs.l1Head.Hex(),
 		"--l2.head", e.inputs.l2Head.Hex(),
 		"--l2.outputroot", e.inputs.l2OutputRoot.Hex(),
 		"--l2.claim", e.inputs.l2Claim.Hex(),
 		"--l2.blocknumber", e.inputs.l2BlockNumber.Text(10),
-		"--l2.chainid", e.inputs.l2ChainId.Text(10),
 	}
 
+	if err := os.MkdirAll(snapshotDir, 0755); err != nil {
+		return fmt.Errorf("could not create snapshot directory %v: %w", snapshotDir, err)
+	}
+	if err := os.MkdirAll(dataDir, 0755); err != nil {
+		return fmt.Errorf("could not create preimage cache directory %v: %w", dataDir, err)
+	}
+	if err := os.MkdirAll(proofDir, 0755); err != nil {
+		return fmt.Errorf("could not create proofs directory %v: %w", proofDir, err)
+	}
 	e.logger.Info("Generating trace", "proof", i, "cmd", e.cannon, "args", args)
 	return e.cmdExecutor(ctx, e.logger.New("proof", i), e.cannon, args...)
 }

op-challenger/fault/cannon/executor_test.go

@@ -20,7 +20,7 @@ const execTestCannonPrestate = "/foo/pre.json"
 
 func TestGenerateProof(t *testing.T) {
 	input := "starting.json"
-	cfg := config.NewConfig("http://localhost:8888", common.Address{0xaa}, common.Address{0xbb}, config.TraceTypeCannon, true, 5)
+	cfg := config.NewConfig("http://localhost:8888", common.Address{0xaa}, config.TraceTypeCannon, true, 5)
 	cfg.CannonDatadir = t.TempDir()
 	cfg.CannonAbsolutePreState = "pre.json"
 	cfg.CannonBin = "./bin/cannon"
@@ -30,7 +30,6 @@ func TestGenerateProof(t *testing.T) {
 
 	inputs := localGameInputs{
 		l1Head:        common.Hash{0x11},
-		l2ChainId:     big.NewInt(2342),
 		l2Head:        common.Hash{0x22},
 		l2OutputRoot:  common.Hash{0x33},
 		l2Claim:       common.Hash{0x44},
@@ -54,9 +53,15 @@ func TestGenerateProof(t *testing.T) {
 	}
 	err := executor.GenerateProof(context.Background(), cfg.CannonDatadir, 150_000_000)
 	require.NoError(t, err)
+	require.DirExists(t, filepath.Join(cfg.CannonDatadir, preimagesDir))
+	require.DirExists(t, filepath.Join(cfg.CannonDatadir, proofsDir))
+	require.DirExists(t, filepath.Join(cfg.CannonDatadir, snapsDir))
 	require.Equal(t, cfg.CannonBin, binary)
 	require.Equal(t, "run", subcommand)
 	require.Equal(t, input, args["--input"])
+	require.Contains(t, args, "--meta")
+	require.Equal(t, "", args["--meta"])
+	require.Equal(t, filepath.Join(cfg.CannonDatadir, "out.json"), args["--output"])
 	require.Equal(t, "=150000000", args["--proof-at"])
 	require.Equal(t, "=150000001", args["--stop-at"])
 	require.Equal(t, "%500", args["--snapshot-at"])
@@ -73,7 +78,6 @@ func TestGenerateProof(t *testing.T) {
 	require.Equal(t, inputs.l2OutputRoot.Hex(), args["--l2.outputroot"])
 	require.Equal(t, inputs.l2Claim.Hex(), args["--l2.claim"])
 	require.Equal(t, "3333", args["--l2.blocknumber"])
-	require.Equal(t, "2342", args["--l2.chainid"])
 }
 
 func TestRunCmdLogsOutput(t *testing.T) {

op-challenger/fault/cannon/local.go

@@ -13,7 +13,6 @@ import (
 
 type localGameInputs struct {
 	l1Head        common.Hash
-	l2ChainId     *big.Int
 	l2Head        common.Hash
 	l2OutputRoot  common.Hash
 	l2Claim       common.Hash
@@ -39,10 +38,6 @@ func fetchLocalInputs(ctx context.Context, gameAddr common.Address, caller GameI
 	if err != nil {
 		return localGameInputs{}, fmt.Errorf("fetch L1 head for game %v: %w", gameAddr, err)
 	}
-	l2ChainId, err := l2Client.ChainID(ctx)
-	if err != nil {
-		return localGameInputs{}, fmt.Errorf("fetch L2 chain ID: %w", err)
-	}
 
 	proposals, err := caller.Proposals(opts)
 	if err != nil {
@@ -58,7 +53,6 @@ func fetchLocalInputs(ctx context.Context, gameAddr common.Address, caller GameI
 
 	return localGameInputs{
 		l1Head:        l1Head,
-		l2ChainId:     l2ChainId,
 		l2Head:        l2Head,
 		l2OutputRoot:  agreedOutput.OutputRoot,
 		l2Claim:       claimedOutput.OutputRoot,

op-challenger/fault/cannon/local_test.go

@@ -40,7 +40,6 @@ func TestFetchLocalInputs(t *testing.T) {
 	require.NoError(t, err)
 
 	require.Equal(t, l1Client.l1Head, inputs.l1Head)
-	require.Equal(t, l2Client.chainID, inputs.l2ChainId)
 	require.Equal(t, l2Client.header.Hash(), inputs.l2Head)
 	require.EqualValues(t, l1Client.starting.OutputRoot, inputs.l2OutputRoot)
 	require.EqualValues(t, l1Client.disputed.OutputRoot, inputs.l2Claim)

op-challenger/fault/cannon/updater.go

@@ -8,6 +8,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-challenger/fault/types"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
@@ -28,8 +29,36 @@ type cannonUpdater struct {
 	preimageOracleAddr common.Address
 }
 
-// NewOracleUpdater returns a new updater.
+// NewOracleUpdater returns a new updater. The pre-image oracle address is loaded from the fault dispute game.
 func NewOracleUpdater(
+	ctx context.Context,
+	logger log.Logger,
+	txMgr txmgr.TxManager,
+	fdgAddr common.Address,
+	client bind.ContractCaller,
+) (*cannonUpdater, error) {
+	gameCaller, err := bindings.NewFaultDisputeGameCaller(fdgAddr, client)
+	if err != nil {
+		return nil, fmt.Errorf("create caller for game %v: %w", fdgAddr, err)
+	}
+	opts := &bind.CallOpts{Context: ctx}
+	vm, err := gameCaller.VM(opts)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load VM address from game %v: %w", fdgAddr, err)
+	}
+	mipsCaller, err := bindings.NewMIPSCaller(vm, client)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create MIPS caller for address %v: %w", vm, err)
+	}
+	oracleAddr, err := mipsCaller.Oracle(opts)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load pre-image oracle address from game %v: %w", fdgAddr, err)
+	}
+	return NewOracleUpdaterWithOracle(logger, txMgr, fdgAddr, oracleAddr)
+}
+
+// NewOracleUpdaterWithOracle returns a new updater using a specified pre-image oracle address.
+func NewOracleUpdaterWithOracle(
 	logger log.Logger,
 	txMgr txmgr.TxManager,
 	fdgAddr common.Address,

op-challenger/fault/cannon/updater_test.go

@@ -64,7 +64,7 @@ func newTestCannonUpdater(t *testing.T, sendFails bool) (*cannonUpdater, *mockTx
 		from:      mockFdgAddress,
 		sendFails: sendFails,
 	}
-	updater, err := NewOracleUpdater(logger, txMgr, mockFdgAddress, mockPreimageOracleAddress)
+	updater, err := NewOracleUpdaterWithOracle(logger, txMgr, mockFdgAddress, mockPreimageOracleAddress)
 	require.NoError(t, err)
 	return updater, txMgr
 }

op-challenger/fault/service.go

@@ -49,7 +49,7 @@ func NewService(ctx context.Context, logger log.Logger, cfg *config.Config) (*se
 		if err != nil {
 			return nil, fmt.Errorf("create cannon trace provider: %w", err)
 		}
-		updater, err = cannon.NewOracleUpdater(logger, txMgr, cfg.GameAddress, cfg.PreimageOracleAddress)
+		updater, err = cannon.NewOracleUpdater(ctx, logger, txMgr, cfg.GameAddress, client)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create the cannon updater: %w", err)
 		}
@@ -64,8 +64,7 @@ func NewService(ctx context.Context, logger log.Logger, cfg *config.Config) (*se
 }
 
 // newTypedService creates a new Service from a provided trace provider.
-func newTypedService(ctx context.Context, logger log.Logger, cfg *config.Config, client *ethclient.Client, provider types.TraceProvider, uploader types.OracleUpdater, txMgr txmgr.TxManager) (*service, error) {
-
+func newTypedService(ctx context.Context, logger log.Logger, cfg *config.Config, client *ethclient.Client, provider types.TraceProvider, updater types.OracleUpdater, txMgr txmgr.TxManager) (*service, error) {
 	contract, err := bindings.NewFaultDisputeGameCaller(cfg.GameAddress, client)
 	if err != nil {
 		return nil, fmt.Errorf("failed to bind the fault dispute game contract: %w", err)
@@ -83,7 +82,7 @@ func newTypedService(ctx context.Context, logger log.Logger, cfg *config.Config,
 		return nil, fmt.Errorf("failed to bind the fault contract: %w", err)
 	}
 
-	agent := NewAgent(loader, cfg.GameDepth, provider, responder, cfg.AgreeWithProposedOutput, gameLogger)
+	agent := NewAgent(loader, cfg.GameDepth, provider, responder, updater, cfg.AgreeWithProposedOutput, gameLogger)
 
 	return &service{
 		agent:                   agent,

op-challenger/fault/solver/solver.go

@@ -28,6 +28,12 @@ func NewSolver(gameDepth int, traceProvider types.TraceProvider) *Solver {
 	}
 }
 
+// GetOracleData returns the oracle data for the provided claim.
+// It passes through to the [TraceProvider] by finding the trace index for the claim.
+func (s *Solver) GetOracleData(ctx context.Context, claim types.Claim) (*types.PreimageOracleData, error) {
+	return s.trace.GetOracleData(ctx, claim.TraceIndex(s.gameDepth))
+}
+
 // NextMove returns the next move to make given the current state of the game.
 func (s *Solver) NextMove(ctx context.Context, claim types.Claim, agreeWithClaimLevel bool) (*types.Claim, error) {
 	if agreeWithClaimLevel {

op-challenger/flags/flags.go

@@ -10,7 +10,6 @@ import (
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/urfave/cli/v2"
 )
 
@@ -59,11 +58,6 @@ var (
 		Usage:   "Correct Alphabet Trace (alphabet trace type only)",
 		EnvVars: prefixEnvVars("ALPHABET"),
 	}
-	PreimageOracleAddressFlag = &cli.StringFlag{
-		Name:    "preimage-oracle-address",
-		Usage:   "Address of the Preimage Oracle contract (only required for cannon).",
-		EnvVars: prefixEnvVars("PREIMAGE_ORACLE_ADDRESS"),
-	}
 	CannonBinFlag = &cli.StringFlag{
 		Name:    "cannon-bin",
 		Usage:   "Path to cannon executable to use when generating trace data (cannon trace type only)",
@@ -109,7 +103,6 @@ var requiredFlags = []cli.Flag{
 // optionalFlags is a list of unchecked cli flags
 var optionalFlags = []cli.Flag{
 	AlphabetFlag,
-	PreimageOracleAddressFlag,
 	CannonBinFlag,
 	CannonServerFlag,
 	CannonPreStateFlag,
@@ -137,9 +130,6 @@ func CheckRequired(ctx *cli.Context) error {
 	gameType := config.TraceType(strings.ToLower(ctx.String(TraceTypeFlag.Name)))
 	switch gameType {
 	case config.TraceTypeCannon:
-		if !ctx.IsSet(PreimageOracleAddressFlag.Name) {
-			return fmt.Errorf("flag %s is required", PreimageOracleAddressFlag.Name)
-		}
 		if !ctx.IsSet(CannonBinFlag.Name) {
 			return fmt.Errorf("flag %s is required", CannonBinFlag.Name)
 		}
@@ -179,21 +169,11 @@ func NewConfigFromCLI(ctx *cli.Context) (*config.Config, error) {
 
 	traceTypeFlag := config.TraceType(strings.ToLower(ctx.String(TraceTypeFlag.Name)))
 
-	preimageOracleAddress := common.Address{}
-	preimageOracleValue := ctx.String(PreimageOracleAddressFlag.Name)
-	if traceTypeFlag == config.TraceTypeCannon || preimageOracleValue != "" {
-		preimageOracleAddress, err = opservice.ParseAddress(preimageOracleValue)
-		if err != nil {
-			return nil, err
-		}
-	}
-
 	return &config.Config{
 		// Required Flags
 		L1EthRpc:                ctx.String(L1EthRpcFlag.Name),
 		TraceType:               traceTypeFlag,
 		GameAddress:             dgfAddress,
-		PreimageOracleAddress:   preimageOracleAddress,
 		AlphabetTrace:           ctx.String(AlphabetFlag.Name),
 		CannonBin:               ctx.String(CannonBinFlag.Name),
 		CannonServer:            ctx.String(CannonServerFlag.Name),

op-e2e/e2eutils/disputegame/deploy.go

-package disputegame
-
-import (
-	"context"
-	"math/big"
-	"time"
-
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-	"github.com/ethereum-optimism/optimism/op-chain-ops/deployer"
-	"github.com/ethereum-optimism/optimism/op-e2e/config"
-	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
-	"github.com/ethereum-optimism/optimism/op-service/client/utils"
-	"github.com/ethereum-optimism/optimism/op-service/clock"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/stretchr/testify/require"
-)
-
-// deployDisputeGameContracts deploys the DisputeGameFactory, AlphabetVM and FaultDisputeGame contracts
-// It configures the alphabet fault game as game type 0 (faultGameType)
-// If/when the dispute game factory becomes a predeployed contract this can be removed and just use the
-// predeployed version
-func deployDisputeGameContracts(require *require.Assertions, ctx context.Context, clock *clock.AdvancingClock, client *ethclient.Client, opts *bind.TransactOpts, gameDuration uint64) (*bindings.DisputeGameFactory, *big.Int) {
-	ctx, cancel := context.WithTimeout(ctx, 5*time.Minute)
-	defer cancel()
-	// Deploy the proxy
-	_, tx, proxy, err := bindings.DeployProxy(opts, client, deployer.TestAddress)
-	require.NoError(err)
-	proxyAddr, err := bind.WaitDeployed(ctx, client, tx)
-	require.NoError(err)
-
-	// Deploy the dispute game factory implementation
-	_, tx, _, err = bindings.DeployDisputeGameFactory(opts, client)
-	require.NoError(err)
-	factoryAddr, err := bind.WaitDeployed(ctx, client, tx)
-	require.NoError(err)
-
-	// Point the proxy at the implementation and create bindings going via the proxy
-	disputeGameFactoryAbi, err := bindings.DisputeGameFactoryMetaData.GetAbi()
-	require.NoError(err)
-	data, err := disputeGameFactoryAbi.Pack("initialize", deployer.TestAddress)
-	require.NoError(err)
-	tx, err = proxy.UpgradeToAndCall(opts, factoryAddr, data)
-	require.NoError(err)
-	_, err = utils.WaitReceiptOK(ctx, client, tx.Hash())
-	require.NoError(err)
-	factory, err := bindings.NewDisputeGameFactory(proxyAddr, client)
-	require.NoError(err)
-
-	// Now setup the fault dispute game type
-	// Start by deploying the AlphabetVM
-	_, tx, _, err = bindings.DeployAlphabetVM(opts, client, alphabetVMAbsolutePrestateClaim)
-	require.NoError(err)
-	alphaVMAddr, err := bind.WaitDeployed(ctx, client, tx)
-	require.NoError(err)
-
-	l2OutputOracle, err := bindings.NewL2OutputOracle(config.L1Deployments.L2OutputOracleProxy, client)
-	require.NoError(err)
-
-	// Deploy the block hash oracle
-	_, tx, _, err = bindings.DeployBlockOracle(opts, client)
-	require.NoError(err)
-	blockHashOracleAddr, err := bind.WaitDeployed(ctx, client, tx)
-	require.NoError(err)
-	blockHashOracle, err := bindings.NewBlockOracle(blockHashOracleAddr, client)
-	require.NoError(err)
-
-	// Deploy the fault dispute game implementation
-	_, tx, _, err = bindings.DeployFaultDisputeGame(
-		opts,
-		client,
-		alphabetVMAbsolutePrestateClaim,
-		big.NewInt(alphabetGameDepth),
-		gameDuration,
-		alphaVMAddr,
-		config.L1Deployments.L2OutputOracleProxy,
-		blockHashOracleAddr,
-	)
-	require.NoError(err)
-	faultDisputeGameAddr, err := bind.WaitDeployed(ctx, client, tx)
-	require.NoError(err)
-
-	// Create a proposer transactor
-	secrets, err := e2eutils.DefaultMnemonicConfig.Secrets()
-	require.NoError(err)
-	chainId, err := client.ChainID(ctx)
-	require.NoError(err)
-	proposerOpts, err := bind.NewKeyedTransactorWithChainID(secrets.Proposer, chainId)
-	require.NoError(err)
-
-	// Propose 2 outputs
-	for i := uint8(0); i < 2; i++ {
-		nextBlockNumber, err := l2OutputOracle.NextBlockNumber(&bind.CallOpts{Pending: true, Context: ctx})
-		require.NoError(err)
-		block, err := client.BlockByNumber(ctx, big.NewInt(int64(i)))
-		require.NoError(err)
-
-		tx, err = l2OutputOracle.ProposeL2Output(proposerOpts, [32]byte{i + 1}, nextBlockNumber, block.Hash(), block.Number())
-		require.NoError(err)
-		_, err = utils.WaitReceiptOK(ctx, client, tx.Hash())
-		require.NoError(err)
-	}
-
-	// Set the fault game type implementation
-	tx, err = factory.SetImplementation(opts, faultGameType, faultDisputeGameAddr)
-	require.NoError(err)
-	_, err = utils.WaitReceiptOK(ctx, client, tx.Hash())
-	require.NoError(err, "wait for final transaction to be included and OK")
-
-	// Warp 15 seconds ahead for a diff in the timestamp.
-	clock.AdvanceTime(15 * time.Second)
-
-	// Store the current block in the oracle
-	tx, err = blockHashOracle.Checkpoint(opts)
-	require.NoError(err)
-	r, err := utils.WaitReceiptOK(ctx, client, tx.Hash())
-	require.NoError(err, "failed to store block in blockoracle")
-
-	return factory, new(big.Int).Sub(r.BlockNumber, big.NewInt(1))
-}

op-e2e/e2eutils/disputegame/helper.go

@@ -10,15 +10,14 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/deployer"
+	"github.com/ethereum-optimism/optimism/op-chain-ops/genesis"
 	"github.com/ethereum-optimism/optimism/op-challenger/config"
 	"github.com/ethereum-optimism/optimism/op-challenger/fault/alphabet"
 	"github.com/ethereum-optimism/optimism/op-challenger/fault/types"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/challenger"
 	"github.com/ethereum-optimism/optimism/op-service/client/utils"
-	"github.com/ethereum-optimism/optimism/op-service/clock"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/stretchr/testify/require"
 )
@@ -35,48 +34,90 @@ const (
 	StatusDefenderWins
 )
 
-var alphabetVMAbsolutePrestate = common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000060")
-var alphabetVMAbsolutePrestateClaim = crypto.Keccak256Hash(alphabetVMAbsolutePrestate)
+func (s Status) String() string {
+	switch s {
+	case StatusInProgress:
+		return "In Progress"
+	case StatusChallengerWins:
+		return "Challenger Wins"
+	case StatusDefenderWins:
+		return "Defender Wins"
+	default:
+		return fmt.Sprintf("Unknown status: %v", int(s))
+	}
+}
+
 var CorrectAlphabet = "abcdefghijklmnop"
 
 type FactoryHelper struct {
-	t       *testing.T
-	require *require.Assertions
-	client  *ethclient.Client
-	opts    *bind.TransactOpts
-	factory *bindings.DisputeGameFactory
-	l1Head  *big.Int
+	t           *testing.T
+	require     *require.Assertions
+	client      *ethclient.Client
+	opts        *bind.TransactOpts
+	factory     *bindings.DisputeGameFactory
+	blockOracle *bindings.BlockOracle
+	l2oo        *bindings.L2OutputOracleCaller
 }
 
-func NewFactoryHelper(t *testing.T, ctx context.Context, clock *clock.AdvancingClock, client *ethclient.Client, gameDuration uint64) *FactoryHelper {
+func NewFactoryHelper(t *testing.T, ctx context.Context, deployments *genesis.L1Deployments, client *ethclient.Client) *FactoryHelper {
 	require := require.New(t)
 	chainID, err := client.ChainID(ctx)
 	require.NoError(err)
 	opts, err := bind.NewKeyedTransactorWithChainID(deployer.TestKey, chainID)
 	require.NoError(err)
 
-	factory, l1Head := deployDisputeGameContracts(require, ctx, clock, client, opts, gameDuration)
+	require.NotNil(deployments, "No deployments")
+	factory, err := bindings.NewDisputeGameFactory(deployments.DisputeGameFactoryProxy, client)
+	require.NoError(err)
+	blockOracle, err := bindings.NewBlockOracle(deployments.BlockOracle, client)
+	require.NoError(err)
+	l2oo, err := bindings.NewL2OutputOracleCaller(deployments.L2OutputOracleProxy, client)
+	require.NoError(err, "Error creating l2oo caller")
 
+	//factory, l1Head := deployDisputeGameContracts(require, ctx, clock, client, opts, gameDuration)
 	return &FactoryHelper{
-		t:       t,
-		require: require,
-		client:  client,
-		opts:    opts,
-		factory: factory,
-		l1Head:  l1Head,
+		t:           t,
+		require:     require,
+		client:      client,
+		opts:        opts,
+		factory:     factory,
+		blockOracle: blockOracle,
+		l2oo:        l2oo,
 	}
 }
 
 func (h *FactoryHelper) StartAlphabetGame(ctx context.Context, claimedAlphabet string) *FaultGameHelper {
-	ctx, cancel := context.WithTimeout(ctx, 1*time.Minute)
+	// Wait for two output proposals to be published
+	ctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
 	defer cancel()
-	trace := alphabet.NewTraceProvider(claimedAlphabet, 4)
+	err := utils.WaitFor(ctx, time.Second, func() (bool, error) {
+		index, err := h.l2oo.LatestOutputIndex(&bind.CallOpts{Context: ctx})
+		if err != nil {
+			h.t.Logf("Could not get latest output index: %v", err.Error())
+			return false, nil
+		}
+		h.t.Logf("Latest output index: %v", index)
+		return index.Cmp(big.NewInt(1)) >= 0, nil
+	})
+	h.require.NoError(err, "Did not get two output roots")
+
+	ctx, cancel = context.WithTimeout(ctx, 1*time.Minute)
+	defer cancel()
+
+	// Store the current block in the oracle
+	tx, err := h.blockOracle.Checkpoint(h.opts)
+	h.require.NoError(err)
+	r, err := utils.WaitReceiptOK(ctx, h.client, tx.Hash())
+	h.require.NoError(err, "failed to store block in blockoracle")
+	l1Head := new(big.Int).Sub(r.BlockNumber, big.NewInt(1))
+
+	trace := alphabet.NewTraceProvider(claimedAlphabet, alphabetGameDepth)
 	rootClaim, err := trace.Get(ctx, lastAlphabetTraceIndex)
 	h.require.NoError(err, "get root claim")
 	extraData := make([]byte, 64)
 	binary.BigEndian.PutUint64(extraData[24:], uint64(8))
-	binary.BigEndian.PutUint64(extraData[56:], h.l1Head.Uint64())
-	tx, err := h.factory.Create(h.opts, faultGameType, rootClaim, extraData)
+	binary.BigEndian.PutUint64(extraData[56:], l1Head.Uint64())
+	tx, err = h.factory.Create(h.opts, faultGameType, rootClaim, extraData)
 	h.require.NoError(err, "create fault dispute game")
 	rcpt, err := utils.WaitReceiptOK(ctx, h.client, tx.Hash())
 	h.require.NoError(err, "wait for create fault dispute game receipt to be OK")
@@ -128,6 +169,12 @@ func (g *FaultGameHelper) StartChallenger(ctx context.Context, l1Endpoint string
 	return c
 }
 
+func (g *FaultGameHelper) GameDuration(ctx context.Context) time.Duration {
+	duration, err := g.game.GAMEDURATION(&bind.CallOpts{Context: ctx})
+	g.require.NoError(err, "failed to get game duration")
+	return time.Duration(duration) * time.Second
+}
+
 func (g *FaultGameHelper) WaitForClaimCount(ctx context.Context, count int64) {
 	ctx, cancel := context.WithTimeout(ctx, 1*time.Minute)
 	defer cancel()
@@ -190,6 +237,7 @@ func (g *FaultGameHelper) Resolve(ctx context.Context) {
 }
 
 func (g *FaultGameHelper) WaitForGameStatus(ctx context.Context, expected Status) {
+	g.t.Logf("Waiting for game %v to have status %v", g.addr, expected)
 	ctx, cancel := context.WithTimeout(ctx, 1*time.Minute)
 	defer cancel()
 	err := utils.WaitFor(ctx, 1*time.Second, func() (bool, error) {
@@ -199,7 +247,7 @@ func (g *FaultGameHelper) WaitForGameStatus(ctx context.Context, expected Status
 		if err != nil {
 			return false, fmt.Errorf("game status unavailable: %w", err)
 		}
-
+		g.t.Logf("Game %v has state %v, waiting for state %v", g.addr, Status(status), expected)
 		return expected == Status(status), nil
 	})
 	g.require.NoError(err, "wait for game status")

op-e2e/faultproof_test.go

@@ -3,7 +3,6 @@ package op_e2e
 import (
 	"context"
 	"testing"
-	"time"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/config"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
@@ -17,13 +16,13 @@ func TestResolveDisputeGame(t *testing.T) {
 	InitParallel(t)
 
 	ctx := context.Background()
-	sys, l1Client := startL1OnlySystem(t)
+	sys, l1Client := startFaultDisputeSystem(t)
 	t.Cleanup(sys.Close)
 
-	gameDuration := 24 * time.Hour
-	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys.TimeTravelClock, l1Client, uint64(gameDuration.Seconds()))
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys.cfg.L1Deployments, l1Client)
 	game := disputeGameFactory.StartAlphabetGame(ctx, "zyxwvut")
 	require.NotNil(t, game)
+	gameDuration := game.GameDuration(ctx)
 
 	game.WaitForGameStatus(ctx, disputegame.StatusInProgress)
 
@@ -115,13 +114,13 @@ func TestChallengerCompleteDisputeGame(t *testing.T) {
 			InitParallel(t)
 
 			ctx := context.Background()
-			sys, l1Client := startL1OnlySystem(t)
+			sys, l1Client := startFaultDisputeSystem(t)
 			t.Cleanup(sys.Close)
 
-			gameDuration := 24 * time.Hour
-			disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys.TimeTravelClock, l1Client, uint64(gameDuration.Seconds()))
+			disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys.cfg.L1Deployments, l1Client)
 			game := disputeGameFactory.StartAlphabetGame(ctx, test.rootClaimAlphabet)
 			require.NotNil(t, game)
+			gameDuration := game.GameDuration(ctx)
 
 			game.StartChallenger(ctx, sys.NodeEndpoint("l1"), "Defender", func(c *config.Config) {
 				c.TxMgrConfig.PrivateKey = e2eutils.EncodePrivKeyToString(sys.cfg.Secrets.Mallory)
@@ -144,13 +143,13 @@ func TestChallengerCompleteDisputeGame(t *testing.T) {
 	}
 }
 
-func startL1OnlySystem(t *testing.T) (*System, *ethclient.Client) {
+func startFaultDisputeSystem(t *testing.T) (*System, *ethclient.Client) {
 	cfg := DefaultSystemConfig(t)
-	cfg.DeployConfig.L1BlockTime = 1
 	delete(cfg.Nodes, "verifier")
-	delete(cfg.Nodes, "sequencer")
 	cfg.SupportL1TimeTravel = true
+	cfg.DeployConfig.L2OutputOracleSubmissionInterval = 2
+	cfg.NonFinalizedProposals = true // Submit output proposals asap
 	sys, err := cfg.Start()
-	require.Nil(t, err, "Error starting up system")
+	require.NoError(t, err, "Error starting up system")
 	return sys, sys.Clients["l1"]
 }

packages/contracts-bedrock/.storage-layout

@@ -63,6 +63,9 @@
 | finalizedWithdrawals | mapping(bytes32 => bool)                                   | 51   | 0      | 32    | src/L1/OptimismPortal.sol:OptimismPortal |
 | provenWithdrawals    | mapping(bytes32 => struct OptimismPortal.ProvenWithdrawal) | 52   | 0      | 32    | src/L1/OptimismPortal.sol:OptimismPortal |
 | paused               | bool                                                       | 53   | 0      | 1     | src/L1/OptimismPortal.sol:OptimismPortal |
+| l2Oracle             | contract L2OutputOracle                                    | 53   | 1      | 20    | src/L1/OptimismPortal.sol:OptimismPortal |
+| systemConfig         | contract SystemConfig                                      | 54   | 0      | 20    | src/L1/OptimismPortal.sol:OptimismPortal |
+| guardian             | address                                                    | 55   | 0      | 20    | src/L1/OptimismPortal.sol:OptimismPortal |
 
 =======================
 ➡ src/L1/SystemConfig.sol:SystemConfig

packages/contracts-bedrock/deploy-config/devnetL1.json

@@ -43,7 +43,7 @@
   "eip1559Elasticity": 6,
   "l1GenesisBlockTimestamp": "0x64c811bf",
   "l2GenesisRegolithTimeOffset": "0x0",
-  "faultGameAbsolutePrestate": 96,
+  "faultGameAbsolutePrestate": "0x41c7ae758795765c6664a5d39bf63841c71ff191e9189522bad8ebff5d4eca98",
   "faultGameMaxDepth": 4,
-  "faultGameMaxDuration": 120
+  "faultGameMaxDuration": 300
 }

packages/contracts-bedrock/scripts/Deploy.s.sol

@@ -292,24 +292,11 @@ contract Deploy is Deployer {
 
     /// @notice Deploy the OptimismPortal
     function deployOptimismPortal() broadcast() public returns (address) {
-        address l2OutputOracleProxy = mustGetAddress("L2OutputOracleProxy");
-        address systemConfigProxy = mustGetAddress("SystemConfigProxy");
+        OptimismPortal portal = new OptimismPortal();
 
-        address guardian = cfg.portalGuardian();
-        if (guardian.code.length == 0) {
-            console.log("Portal guardian has no code: %s", guardian);
-        }
-
-        OptimismPortal portal = new OptimismPortal({
-            _l2Oracle: L2OutputOracle(l2OutputOracleProxy),
-            _guardian: guardian,
-            _paused: true,
-            _config: SystemConfig(systemConfigProxy)
-        });
-
-        require(address(portal.L2_ORACLE()) == l2OutputOracleProxy);
-        require(portal.GUARDIAN() == guardian);
-        require(address(portal.SYSTEM_CONFIG()) == systemConfigProxy);
+        require(address(portal.L2_ORACLE()) == address(0));
+        require(portal.GUARDIAN() == address(0));
+        require(address(portal.SYSTEM_CONFIG()) == address(0));
         require(portal.paused() == true);
 
         save("OptimismPortal", address(portal));
@@ -681,10 +668,23 @@ contract Deploy is Deployer {
         address l2OutputOracleProxy = mustGetAddress("L2OutputOracleProxy");
         address systemConfigProxy = mustGetAddress("SystemConfigProxy");
 
+        address guardian = cfg.portalGuardian();
+        if (guardian.code.length == 0) {
+            console.log("Portal guardian has no code: %s", guardian);
+        }
+
         proxyAdmin.upgradeAndCall({
             _proxy: payable(optimismPortalProxy),
             _implementation: optimismPortal,
-            _data: abi.encodeCall(OptimismPortal.initialize, (false))
+            _data: abi.encodeCall(
+                OptimismPortal.initialize,
+                (
+                    L2OutputOracle(l2OutputOracleProxy),
+                    guardian,
+                    SystemConfig(systemConfigProxy),
+                    false
+                )
+            )
         });
 
         OptimismPortal portal = OptimismPortal(payable(optimismPortalProxy));
@@ -721,19 +721,37 @@ contract Deploy is Deployer {
 
     /// @notice Sets the implementation for the `FAULT` game type in the `DisputeGameFactory`
     function setFaultGameImplementation() onlyDevnet broadcast() public {
+        // Create the absolute prestate dump
+        string memory filePath = string.concat(vm.projectRoot(), "/../../op-program/bin/prestate-proof.json");
+        bytes32 mipsAbsolutePrestate;
+        string[] memory commands = new string[](3);
+        commands[0] = "bash";
+        commands[1] = "-c";
+        commands[2] = string.concat("[[ -f ", filePath, " ]] && echo \"present\"");
+        if (vm.ffi(commands).length == 0) {
+            revert("Cannon prestate dump not found, generate it with `make cannon-prestate` in the monorepo root.");
+        }
+        commands[2] = string.concat("cat ", filePath, " | jq -r .pre");
+        mipsAbsolutePrestate = abi.decode(vm.ffi(commands), (bytes32));
+        console.log("Absolute prestate: %s", vm.toString(mipsAbsolutePrestate));
+
         DisputeGameFactory factory = DisputeGameFactory(mustGetAddress("DisputeGameFactoryProxy"));
-        Claim absolutePrestate = Claim.wrap(bytes32(cfg.faultGameAbsolutePrestate()));
-        IBigStepper faultVm = IBigStepper(new AlphabetVM(absolutePrestate));
-        if (address(factory.gameImpls(GameTypes.FAULT)) == address(0)) {
-            factory.setImplementation(GameTypes.FAULT, new FaultDisputeGame({
-                _absolutePrestate: absolutePrestate,
-                _maxGameDepth: cfg.faultGameMaxDepth(),
-                _gameDuration: Duration.wrap(uint64(cfg.faultGameMaxDuration())),
-                _vm: faultVm,
-                _l2oo: L2OutputOracle(mustGetAddress("L2OutputOracleProxy")),
-                _blockOracle: BlockOracle(mustGetAddress("BlockOracle"))
-            }));
-            console.log("DisputeGameFactory: set `FaultDisputeGame` implementation");
+        for (uint8 i; i < 2; i++) {
+            Claim absolutePrestate = Claim.wrap(i == 0 ? bytes32(cfg.faultGameAbsolutePrestate()) : mipsAbsolutePrestate);
+            IBigStepper faultVm = IBigStepper(i == 0 ? address(new AlphabetVM(absolutePrestate)) : mustGetAddress("Mips"));
+            GameType gameType = GameType.wrap(i);
+            if (address(factory.gameImpls(gameType)) == address(0)) {
+                factory.setImplementation(gameType, new FaultDisputeGame({
+                    _gameType: gameType,
+                    _absolutePrestate: absolutePrestate,
+                    _maxGameDepth: i == 0 ? 4 : cfg.faultGameMaxDepth(), // The max depth of the alphabet game is always 4
+                    _gameDuration: Duration.wrap(uint64(cfg.faultGameMaxDuration())),
+                    _vm: faultVm,
+                    _l2oo: L2OutputOracle(mustGetAddress("L2OutputOracleProxy")),
+                    _blockOracle: BlockOracle(mustGetAddress("BlockOracle"))
+                }));
+                console.log("DisputeGameFactoryProxy: set `FaultDisputeGame` implementation (Backend: %s | GameType: %s)", i == 0 ? "AlphabetVM" : "MIPS", vm.toString(i));
+            }
         }
     }
 }

packages/contracts-bedrock/semver-lock.json

@@ -3,7 +3,7 @@
   "src/L1/L1ERC721Bridge.sol": "0xac9d8e236a1b35c358f9800834f65375cf4270155e817cf3d0f2bac1968f9107",
   "src/L1/L1StandardBridge.sol": "0x26fd79e041c403f4bc68758c410fcc801975e7648c0b51a2c4a6e8c44fabcbfd",
   "src/L1/L2OutputOracle.sol": "0xd6c5eb38732077c4705f46a61be68a7beccc069a99ed1d07b8e1fc6e1de8ffa6",
-  "src/L1/OptimismPortal.sol": "0x06c324c474d251a1ef0a1a6a22013964c5b2b871e641bbedf447f231e3f44dcc",
+  "src/L1/OptimismPortal.sol": "0xeaa47a63e8a3bcfdb7dfd3e6c8608369e34e362d9de82f3acf13cbc27c070bf7",
   "src/L1/SystemConfig.sol": "0x8e2b5103d2eb93b74af2e2f96a4505e637cdc3c44d80cf5ec2eca70060e1deff",
   "src/L2/BaseFeeVault.sol": "0xa596e60762f16192cfa86459fcb9f4da9d8f756106eedac643a1ffeafbbfcc5f",
   "src/L2/GasPriceOracle.sol": "0xc735a8bf01ad8bca194345748537bfd9924909c0342bc133c4a31e2fb8cb9882",
@@ -14,7 +14,7 @@
   "src/L2/L2StandardBridge.sol": "0x73a4fea3dca8ac7d7ba32e38aadeb69bd344042666a40a75e8c28849f01999e5",
   "src/L2/L2ToL1MessagePasser.sol": "0xed800b600cb3f67e18a1ab10750e3934a8b3e42178f422bcacfde770a6e8e8bd",
   "src/L2/SequencerFeeVault.sol": "0xd57c143b1f042400430b991b806bf971628e6980406c751e82d19ae80eeb4e8d",
-  "src/dispute/FaultDisputeGame.sol": "0x53ef150202f3e22dd0bd92a520c4eaa95752f5fd9d6b22f56d27958b71bb23ec",
+  "src/dispute/FaultDisputeGame.sol": "0x2a7f367443752f841d734f339a596c4ad93e16f7df0230f1cdd5e6f0b4b58368",
   "src/legacy/DeployerWhitelist.sol": "0x5e80f7b13ef73f06c63bd9b118a49da1ff06a5c0fcf8067b5a3365d731c23765",
   "src/legacy/L1BlockNumber.sol": "0x84cc587148de5920dfcd19da44d28e769f0e4d08ca2bcc93f18aa78c6cc2ebe6",
   "src/legacy/LegacyMessagePasser.sol": "0x2692b50b227e5f75a53439c0cf303498edfd4fc087555b3fc9bc4bceb518229b",

packages/contracts-bedrock/src/cannon/MIPS.sol

@@ -478,8 +478,8 @@ contract MIPS {
     function proofOffset(uint8 _proofIndex) internal pure returns (uint256 offset_) {
         unchecked {
             // A proof of 32 bit memory, with 32-byte leaf values, is (32-5)=27 bytes32 entries.
-            // And the leaf value itself needs to be encoded as well. And proof.offset == 358
-            offset_ = 358 + (uint256(_proofIndex) * (28 * 32));
+            // And the leaf value itself needs to be encoded as well. And proof.offset == 388
+            offset_ = 388 + (uint256(_proofIndex) * (28 * 32));
             uint256 s = 0;
             assembly { s := calldatasize() }
             require(s >= (offset_ + 28 * 32), "check that there is enough calldata");
@@ -614,7 +614,7 @@ contract MIPS {
                 if iszero(eq(stateData.offset, 100)) { // 32*3+4=100 expected state data offset
                     revert(0,0)
                 }
-                if iszero(eq(proof.offset, 358)) { // 100+32+226=358 expected proof offset
+                if iszero(eq(proof.offset, 388)) { // 100+32+256=388 expected proof offset
                     revert(0,0)
                 }
 

packages/contracts-bedrock/src/dispute/DisputeGameFactory.sol

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.15;
 
-import "../libraries/DisputeTypes.sol";
-import "../libraries/DisputeErrors.sol";
-
 import { ClonesWithImmutableArgs } from "@cwia/ClonesWithImmutableArgs.sol";
 import {
     OwnableUpgradeable
 } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
-import { Semver } from "../universal/Semver.sol";
+import { Semver } from "src/universal/Semver.sol";
 
 import { IDisputeGame } from "./interfaces/IDisputeGame.sol";
 import { IDisputeGameFactory } from "./interfaces/IDisputeGameFactory.sol";
 
+import "src/libraries/DisputeTypes.sol";
+import "src/libraries/DisputeErrors.sol";
+
 /// @title DisputeGameFactory
 /// @notice A factory contract for creating `IDisputeGame` contracts. All created dispute games
 ///         are stored in both a mapping and an append only array. The timestamp of the creation
@@ -37,7 +37,7 @@ contract DisputeGameFactory is OwnableUpgradeable, IDisputeGameFactory, Semver {
     GameId[] internal _disputeGameList;
 
     /// @notice constructs a new DisputeGameFactory contract.
-    constructor() OwnableUpgradeable() Semver(0, 0, 2) {
+    constructor() OwnableUpgradeable() Semver(0, 0, 3) {
         initialize(address(0));
     }
 
@@ -88,9 +88,7 @@ contract DisputeGameFactory is OwnableUpgradeable, IDisputeGameFactory, Semver {
         IDisputeGame impl = gameImpls[gameType];
 
         // If there is no implementation to clone for the given `GameType`, revert.
-        if (address(impl) == address(0)) {
-            revert NoImplementation(gameType);
-        }
+        if (address(impl) == address(0)) revert NoImplementation(gameType);
 
         // Clone the implementation contract and initialize it with the given parameters.
         proxy = IDisputeGame(address(impl).clone(abi.encodePacked(rootClaim, extraData)));
@@ -100,9 +98,7 @@ contract DisputeGameFactory is OwnableUpgradeable, IDisputeGameFactory, Semver {
         Hash uuid = getGameUUID(gameType, rootClaim, extraData);
 
         // If a dispute game with the same UUID already exists, revert.
-        if (GameId.unwrap(_disputeGames[uuid]) != bytes32(0)) {
-            revert GameAlreadyExists(uuid);
-        }
+        if (GameId.unwrap(_disputeGames[uuid]) != bytes32(0)) revert GameAlreadyExists(uuid);
 
         GameId slot = _packSlot(address(proxy), block.timestamp);
 

packages/contracts-bedrock/src/dispute/interfaces/IBigStepper.sol

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.15;
 
-import { IPreimageOracle } from "../../cannon/interfaces/IPreimageOracle.sol";
+import { IPreimageOracle } from "src/cannon/interfaces/IPreimageOracle.sol";
 
 /// @title IBigStepper
 /// @notice An interface for a contract with a state transition function that

packages/contracts-bedrock/src/dispute/interfaces/IDisputeGame.sol

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.15;
 
-import "../../libraries/DisputeTypes.sol";
-
 import { IBondManager } from "./IBondManager.sol";
 import { IInitializable } from "./IInitializable.sol";
 
+import "src/libraries/DisputeTypes.sol";
+
 /// @title IDisputeGame
 /// @notice The generic interface for a DisputeGame contract.
 interface IDisputeGame is IInitializable {
@@ -25,7 +25,7 @@ interface IDisputeGame is IInitializable {
     /// @dev The reference impl should be entirely different depending on the type (fault, validity)
     ///      i.e. The game type should indicate the security model.
     /// @return gameType_ The type of proof system being used.
-    function gameType() external pure returns (GameType gameType_);
+    function gameType() external view returns (GameType gameType_);
 
     /// @notice Getter for the root claim.
     /// @dev `clones-with-immutable-args` argument #1
@@ -58,7 +58,7 @@ interface IDisputeGame is IInitializable {
     /// @return extraData_ Any extra data supplied to the dispute game contract by the creator.
     function gameData()
         external
-        pure
+        view
         returns (
             GameType gameType_,
             Claim rootClaim_,

packages/contracts-bedrock/src/dispute/interfaces/IDisputeGameFactory.sol

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.15;
 
-import "../../libraries/DisputeTypes.sol";
-
 import { IDisputeGame } from "./IDisputeGame.sol";
 
+import "src/libraries/DisputeTypes.sol";
+
 /// @title IDisputeGameFactory
 /// @notice The interface for a DisputeGameFactory contract.
 interface IDisputeGameFactory {

packages/contracts-bedrock/src/dispute/lib/LibClock.sol

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.15;
 
-import "../../libraries/DisputeTypes.sol";
+import "src/libraries/DisputeTypes.sol";
 
 /// @title LibClock
 /// @notice This library contains helper functions for working with the `Clock` type.

packages/contracts-bedrock/src/dispute/lib/LibHashing.sol

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.15;
 
-import "../../libraries/DisputeTypes.sol";
+import "src/libraries/DisputeTypes.sol";
 
 /// @title Hashing
 /// @notice This library contains all of the hashing utilities used in the Cannon contracts.

packages/contracts-bedrock/src/dispute/lib/LibPosition.sol

 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.15;
 
-import "../../libraries/DisputeTypes.sol";
+import "src/libraries/DisputeTypes.sol";
 
 /// @title LibPosition
 /// @notice This library contains helper functions for working with the `Position` type.

packages/contracts-bedrock/src/libraries/DisputeErrors.sol

@@ -58,6 +58,9 @@ error ValidStep();
 ///         not contain the disputed output root.
 error L1HeadTooOld();
 
+/// @notice Thrown when an invalid local identifier is passed to the `addLocalData` function.
+error InvalidLocalIdent();
+
 ////////////////////////////////////////////////////////////////
 //              `AttestationDisputeGame` Errors               //
 ////////////////////////////////////////////////////////////////

packages/contracts-bedrock/test/L2OutputOracle.t.sol

@@ -454,7 +454,7 @@ contract L2OutputOracleUpgradeable_Test is L2OutputOracle_Initializer {
         vm.startPrank(multisig);
         proxy.upgradeToAndCall(
             address(nextImpl),
-            abi.encodeWithSelector(NextImpl.initialize.selector)
+            abi.encodeWithSelector(NextImpl.initialize.selector, 2)
         );
         assertEq(proxy.implementation(), address(nextImpl));
 

packages/fee-estimation/CHANGELOG.md

 # @eth-optimism/fee-estimation
 
+## 0.15.2
+
+### Patch Changes
+
+- [#6609](https://github.com/ethereum-optimism/optimism/pull/6609) [`0e83c4452`](https://github.com/ethereum-optimism/optimism/commit/0e83c44522e1a13e4d5c1395fd4dc9dbae8be08d) Thanks [@roninjin10](https://github.com/roninjin10)! - Fixed bug with 'estimateFees' not taking into account the l2 gas price
+
 ## 0.15.1
 
 ### Patch Changes

packages/fee-estimation/README.md

@@ -37,11 +37,9 @@ yarn add @eth-optimism/fee-estimation
 ### Basic Usage
 
 ```ts
-import {
-  estimateFees,
-} from '@eth-optimism/fee-estimation'
-import {optimistABI} from '@eth-optimism/contracts-ts'
-import {viemClient} from './viem-client'
+import { estimateFees } from '@eth-optimism/fee-estimation'
+import { optimistABI } from '@eth-optimism/contracts-ts'
+import { viemClient } from './viem-client'
 
 const optimistOwnerAddress =
   '0x77194aa25a06f932c10c0f25090f3046af2c85a6' as const

packages/fee-estimation/package.json

 {
   "name": "@eth-optimism/fee-estimation",
-  "version": "0.15.1",
+  "version": "0.15.2",
   "description": "Lightweight library for doing OP-Chain gas estimation",
   "license": "MIT",
   "repository": {