Merge branch 'develop' of https://github.com/ethereum-optimism/optimism into develop

README.md

@@ -12,7 +12,7 @@
 
 [Optimism](https://www.optimism.io/) is a project dedicated to scaling Ethereum's technology and expanding its ability to coordinate people from across the world to build effective decentralized economies and governance systems. The [Optimism Collective](https://app.optimism.io/announcement) builds open-source software for running L2 blockchains and aims to address key governance and economic challenges in the wider cryptocurrency ecosystem. Optimism operates on the principle of **impact=profit**, the idea that individuals who positively impact the Collective should be proportionally rewarded with profit. **Change the incentives and you change the world.**
 
-In this repository, you'll find numerous core components of the OP Stack, the decentralized software stack maintained by the Optimism Collective that powers Optimism and forms the backbone of blockchains like [OP Mainnet](https://explorer.optimism.io/) and [Base](https://www.coinbase.com/blog/introducing-base). Designed to be "aggressively open source," the OP Stack encourages you to explore, modify, extend, and test the code as needed. Although not all elements of the OP Stack are contained here, many of its essential components can be found within this repository. By collaborating on free, open software and shared standards, the Optimism Collective aims to prevent siloed software development and rapidly accelerate the development of the Ethereum ecosystem. Come contribute, build the future, and redefine power, together.
+In this repository, you'll find numerous core components of the OP Stack, the decentralized software stack maintained by the Optimism Collective that powers Optimism and forms the backbone of blockchains like [OP Mainnet](https://explorer.optimism.io/) and [Base](https://base.org). Designed to be "aggressively open source," the OP Stack encourages you to explore, modify, extend, and test the code as needed. Although not all elements of the OP Stack are contained here, many of its essential components can be found within this repository. By collaborating on free, open software and shared standards, the Optimism Collective aims to prevent siloed software development and rapidly accelerate the development of the Ethereum ecosystem. Come contribute, build the future, and redefine power, together.
 
 ## Documentation
 

go.mod

@@ -9,15 +9,15 @@ require (
 	github.com/docker/docker v20.10.24+incompatible
 	github.com/docker/go-connections v0.4.0
 	github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3
-	github.com/ethereum/go-ethereum v1.11.5
+	github.com/ethereum/go-ethereum v1.11.6
 	github.com/fsnotify/fsnotify v1.6.0
-	github.com/golang/snappy v0.0.4
+	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb
 	github.com/google/go-cmp v0.5.9
 	github.com/google/gofuzz v1.2.1-0.20220503160820-4a35382e8fc8
 	github.com/hashicorp/go-multierror v1.1.1
 	github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d
 	github.com/hashicorp/golang-lru/v2 v2.0.1
-	github.com/holiman/uint256 v1.2.0
+	github.com/holiman/uint256 v1.2.2-0.20230321075855-87b91420868c
 	github.com/ipfs/go-datastore v0.6.0
 	github.com/ipfs/go-ds-leveldb v0.5.0
 	github.com/libp2p/go-libp2p v0.25.1
@@ -35,7 +35,7 @@ require (
 	golang.org/x/crypto v0.6.0
 	golang.org/x/exp v0.0.0-20230213192124-5e25df0256eb
 	golang.org/x/sync v0.1.0
-	golang.org/x/term v0.5.0
+	golang.org/x/term v0.6.0
 	golang.org/x/time v0.0.0-20220922220347-f3bd1da661af
 )
 
@@ -90,8 +90,8 @@ require (
 	github.com/hashicorp/go-bexpr v0.1.11 // indirect
 	github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
 	github.com/huin/goupnp v1.1.0 // indirect
-	github.com/influxdata/influxdb v1.8.3 // indirect
 	github.com/influxdata/influxdb-client-go/v2 v2.4.0 // indirect
+	github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c // indirect
 	github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 // indirect
 	github.com/ipfs/go-cid v0.3.2 // indirect
 	github.com/ipfs/go-log v1.0.5 // indirect
@@ -175,12 +175,13 @@ require (
 	go.uber.org/fx v1.19.1 // indirect
 	go.uber.org/multierr v1.9.0 // indirect
 	go.uber.org/zap v1.24.0 // indirect
-	golang.org/x/mod v0.8.0 // indirect
-	golang.org/x/net v0.7.0 // indirect
-	golang.org/x/sys v0.5.0 // indirect
-	golang.org/x/text v0.7.0 // indirect
-	golang.org/x/tools v0.6.0 // indirect
+	golang.org/x/mod v0.9.0 // indirect
+	golang.org/x/net v0.8.0 // indirect
+	golang.org/x/sys v0.6.0 // indirect
+	golang.org/x/text v0.8.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
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
@@ -189,6 +190,6 @@ require (
 	nhooyr.io/websocket v1.8.7 // indirect
 )
 
-replace github.com/ethereum/go-ethereum v1.11.5 => github.com/ethereum-optimism/op-geth v1.101105.1-0.20230420183214-24ae687be390
+replace github.com/ethereum/go-ethereum v1.11.6 => github.com/ethereum-optimism/op-geth v1.101105.2-0.20230502202351-9cc072e922f6
 
-//replace github.com/ethereum/go-ethereum v1.11.5 => ../go-ethereum
+//replace github.com/ethereum/go-ethereum v1.11.6 => ../go-ethereum

op-batcher/Dockerfile

-FROM --platform=$BUILDPLATFORM golang:1.19.0-alpine3.15 as builder
+FROM --platform=$BUILDPLATFORM golang:1.19.9-alpine3.16 as builder
 
 ARG VERSION=v0.0.0
 
@@ -23,7 +23,7 @@ ARG TARGETOS TARGETARCH
 
 RUN make op-batcher VERSION="$VERSION" GOOS=$TARGETOS GOARCH=$TARGETARCH
 
-FROM alpine:3.15
+FROM alpine:3.16
 
 COPY --from=builder /app/op-batcher/bin/op-batcher /usr/local/bin
 

op-chain-ops/Dockerfile

-FROM golang:1.19.0-alpine3.15 as builder
+FROM golang:1.19.9-alpine3.15 as builder
 
 RUN apk add --no-cache make gcc musl-dev linux-headers git jq bash
 

op-chain-ops/cmd/check-migration-quick/main.go

+package main
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+
+	"github.com/mattn/go-isatty"
+	"github.com/urfave/cli"
+
+	"github.com/ethereum-optimism/optimism/op-chain-ops/db"
+	"github.com/ethereum-optimism/optimism/op-chain-ops/genesis"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+func main() {
+	log.Root().SetHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(isatty.IsTerminal(os.Stderr.Fd()))))
+
+	app := &cli.App{
+		Name:  "check-migration-quick",
+		Usage: "Quick check for a migrated database that only checks the header magic in the extradata",
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:     "db-path",
+				Usage:    "Path to database",
+				Required: true,
+			},
+			&cli.IntFlag{
+				Name:  "db-cache",
+				Usage: "LevelDB cache size in mb",
+				Value: 1024,
+			},
+			&cli.IntFlag{
+				Name:  "db-handles",
+				Usage: "LevelDB number of handles",
+				Value: 60,
+			},
+		},
+		Action: func(ctx *cli.Context) error {
+			dbCache := ctx.Int("db-cache")
+			dbHandles := ctx.Int("db-handles")
+
+			ldb, err := db.Open(ctx.String("db-path"), dbCache, dbHandles)
+			if err != nil {
+				return err
+			}
+
+			hash := rawdb.ReadHeadHeaderHash(ldb)
+			log.Info("Reading chain tip from database", "hash", hash)
+			num := rawdb.ReadHeaderNumber(ldb, hash)
+			if num == nil {
+				return fmt.Errorf("cannot find header number for %s", hash)
+			}
+
+			header := rawdb.ReadHeader(ldb, hash, *num)
+			log.Info("Read header from database", "number", *num)
+
+			log.Info(
+				"Header info",
+				"parentHash", header.ParentHash.Hex(),
+				"root", header.Root.Hex(),
+				"number", header.Number,
+				"gasLimit", header.GasLimit,
+				"time", header.Time,
+				"extra", hexutil.Encode(header.Extra),
+			)
+
+			if !bytes.Equal(header.Extra, genesis.BedrockTransitionBlockExtraData) {
+				return fmt.Errorf("expected extra data to be %x, but got %x", genesis.BedrockTransitionBlockExtraData, header.Extra)
+			}
+
+			if err := ldb.Close(); err != nil {
+				return err
+			}
+
+			return nil
+		},
+	}
+
+	if err := app.Run(os.Args); err != nil {
+		log.Crit("error in migration", "err", err)
+	}
+}

op-chain-ops/deployer/deployer.go

@@ -51,7 +51,6 @@ func NewBackendWithGenesisTimestamp(ts uint64) *backends.SimulatedBackend {
 		DAOForkBlock:        nil,
 		DAOForkSupport:      false,
 		EIP150Block:         big.NewInt(0),
-		EIP150Hash:          common.Hash{},
 		EIP155Block:         big.NewInt(0),
 		EIP158Block:         big.NewInt(0),
 		ByzantiumBlock:      big.NewInt(0),

op-chain-ops/eof/eof_crawler.go

@@ -94,7 +94,10 @@ func IndexEOFContracts(dbPath string, out string) error {
 		}
 
 		// Attempt to get the address of the account from the trie
-		addrBytes := st.Get(it.Key)
+		addrBytes, err := st.Get(it.Key)
+		if err != nil {
+			return fmt.Errorf("load address for account: %w", err)
+		}
 		if addrBytes == nil {
 			// Preimage missing! Cannot continue.
 			missingPreimages++

op-chain-ops/genesis/genesis.go

@@ -39,7 +39,6 @@ func NewL2Genesis(config *DeployConfig, block *types.Block) (*core.Genesis, erro
 		DAOForkBlock:                  nil,
 		DAOForkSupport:                false,
 		EIP150Block:                   big.NewInt(0),
-		EIP150Hash:                    common.Hash{},
 		EIP155Block:                   big.NewInt(0),
 		EIP158Block:                   big.NewInt(0),
 		ByzantiumBlock:                big.NewInt(0),
@@ -109,7 +108,6 @@ func NewL1Genesis(config *DeployConfig) (*core.Genesis, error) {
 		DAOForkBlock:        nil,
 		DAOForkSupport:      false,
 		EIP150Block:         big.NewInt(0),
-		EIP150Hash:          common.Hash{},
 		EIP155Block:         big.NewInt(0),
 		EIP158Block:         big.NewInt(0),
 		ByzantiumBlock:      big.NewInt(0),

op-e2e/system_fpp_test.go

@@ -27,6 +27,121 @@ func TestVerifyL2OutputRootDetached(t *testing.T) {
 	testVerifyL2OutputRoot(t, true)
 }
 
+func TestVerifyL2OutputRootEmptyBlock(t *testing.T) {
+	testVerifyL2OutputRootEmptyBlock(t, false)
+}
+
+func TestVerifyL2OutputRootEmptyBlockDetached(t *testing.T) {
+	testVerifyL2OutputRootEmptyBlock(t, true)
+}
+
+// TestVerifyL2OutputRootEmptyBlock asserts that the program can verify the output root of an empty block
+// induced by missing batches.
+// Setup is as follows:
+// - create initial conditions and agreed l2 state
+// - stop the batch submitter to induce empty blocks
+// - wait for the seq window to expire so we can observe empty blocks
+// - select an empty block as our claim
+// - reboot the batch submitter
+// - update the state root via a tx
+// - run program
+func testVerifyL2OutputRootEmptyBlock(t *testing.T, detached bool) {
+	InitParallel(t)
+	ctx := context.Background()
+
+	cfg := DefaultSystemConfig(t)
+	// We don't need a verifier - just the sequencer is enough
+	delete(cfg.Nodes, "verifier")
+	// Use a small sequencer window size to avoid test timeout while waiting for empty blocks
+	// But not too small to ensure that our claim and subsequent state change is published
+	cfg.DeployConfig.SequencerWindowSize = 16
+
+	sys, err := cfg.Start()
+	require.Nil(t, err, "Error starting up system")
+	defer sys.Close()
+
+	log := testlog.Logger(t, log.LvlInfo)
+	log.Info("genesis", "l2", sys.RollupConfig.Genesis.L2, "l1", sys.RollupConfig.Genesis.L1, "l2_time", sys.RollupConfig.Genesis.L2Time)
+
+	l1Client := sys.Clients["l1"]
+	l2Seq := sys.Clients["sequencer"]
+	rollupRPCClient, err := rpc.DialContext(context.Background(), sys.RollupNodes["sequencer"].HTTPEndpoint())
+	require.Nil(t, err)
+	rollupClient := sources.NewRollupClient(client.NewBaseRPCClient(rollupRPCClient))
+
+	// Avoids flaky test by avoiding reorgs at epoch 0
+	t.Log("Wait for safe head to advance once for setup")
+	// Safe head doesn't exist at genesis. Wait for the first one before proceeding
+	require.NoError(t, waitForSafeHead(ctx, 1, rollupClient))
+	ss, err := l2Seq.BlockByNumber(ctx, big.NewInt(int64(rpc.SafeBlockNumber)))
+	require.NoError(t, err)
+	require.NoError(t, waitForSafeHead(ctx, ss.NumberU64()+cfg.DeployConfig.SequencerWindowSize+1, rollupClient))
+
+	t.Log("Sending transactions to setup existing state, prior to challenged period")
+	aliceKey := cfg.Secrets.Alice
+	receipt := SendL2Tx(t, cfg, l2Seq, aliceKey, func(opts *TxOpts) {
+		opts.ToAddr = &cfg.Secrets.Addresses().Bob
+		opts.Value = big.NewInt(1_000)
+	})
+	require.NoError(t, waitForSafeHead(ctx, receipt.BlockNumber.Uint64(), rollupClient))
+
+	t.Logf("Capture current L2 head as agreed starting point. l2Head=%x l2BlockNumber=%v", receipt.BlockHash, receipt.BlockNumber)
+	l2Head := receipt.BlockHash
+
+	t.Log("=====Stopping batch submitter=====")
+	err = sys.BatchSubmitter.Stop(ctx)
+	require.NoError(t, err, "could not stop batch submitter")
+
+	// Wait for the sequencer to catch up with the current L1 head so we know all submitted batches are processed
+	t.Log("Wait for sequencer to catch up with last submitted batch")
+	l1HeadNum, err := l1Client.BlockNumber(ctx)
+	require.NoError(t, err)
+	_, err = waitForL1OriginOnL2(l1HeadNum, l2Seq, 30*time.Second)
+	require.NoError(t, err)
+
+	// Get the current safe head now that the batcher is stopped
+	safeBlock, err := l2Seq.BlockByNumber(ctx, big.NewInt(int64(rpc.SafeBlockNumber)))
+	require.NoError(t, err)
+
+	// Wait for safe head to start advancing again when the sequencing window elapses, for at least three blocks
+	t.Log("Wait for safe head to advance after sequencing window elapses")
+	require.NoError(t, waitForSafeHead(ctx, safeBlock.NumberU64()+3, rollupClient))
+
+	// Use the 2nd empty block as our L2 claim block
+	t.Log("Determine L2 claim")
+	l2ClaimBlock, err := l2Seq.BlockByNumber(ctx, big.NewInt(int64(safeBlock.NumberU64()+2)))
+	require.NoError(t, err, "get L2 claim block number")
+	l2ClaimBlockNumber := l2ClaimBlock.Number().Uint64()
+	l2Output, err := rollupClient.OutputAtBlock(ctx, l2ClaimBlockNumber)
+	require.NoError(t, err, "could not get expected output")
+	l2Claim := l2Output.OutputRoot
+
+	t.Log("=====Restarting batch submitter=====")
+	err = sys.BatchSubmitter.Start()
+	require.NoError(t, err, "could not start batch submitter")
+
+	t.Log("Add a transaction to the next batch after sequence of empty blocks")
+	receipt = SendL2Tx(t, cfg, l2Seq, aliceKey, func(opts *TxOpts) {
+		opts.ToAddr = &cfg.Secrets.Addresses().Bob
+		opts.Value = big.NewInt(1_000)
+		opts.Nonce = 1
+	})
+	require.NoError(t, waitForSafeHead(ctx, receipt.BlockNumber.Uint64(), rollupClient))
+
+	t.Log("Determine L1 head that includes batch after sequence of empty blocks")
+	l1HeadBlock, err := l1Client.BlockByNumber(ctx, nil)
+	require.NoError(t, err, "get l1 head block")
+	l1Head := l1HeadBlock.Hash()
+
+	testFaultProofProgramScenario(t, ctx, sys, &FaultProofProgramTestScenario{
+		L1Head:             l1Head,
+		L2Head:             l2Head,
+		L2Claim:            common.Hash(l2Claim),
+		L2ClaimBlockNumber: l2ClaimBlockNumber,
+		Detached:           detached,
+	})
+}
+
 func testVerifyL2OutputRoot(t *testing.T, detached bool) {
 	InitParallel(t)
 	ctx := context.Background()
@@ -96,19 +211,39 @@ func testVerifyL2OutputRoot(t *testing.T, detached bool) {
 	require.NoError(t, err, "get l1 head block")
 	l1Head := l1HeadBlock.Hash()
 
+	testFaultProofProgramScenario(t, ctx, sys, &FaultProofProgramTestScenario{
+		L1Head:             l1Head,
+		L2Head:             l2Head,
+		L2Claim:            common.Hash(l2Claim),
+		L2ClaimBlockNumber: l2ClaimBlockNumber,
+		Detached:           detached,
+	})
+}
+
+type FaultProofProgramTestScenario struct {
+	L1Head             common.Hash
+	L2Head             common.Hash
+	L2Claim            common.Hash
+	L2ClaimBlockNumber uint64
+	Detached           bool
+}
+
+// testFaultProofProgramScenario runs the fault proof program in several contexts, given a test scenario.
+func testFaultProofProgramScenario(t *testing.T, ctx context.Context, sys *System, s *FaultProofProgramTestScenario) {
 	preimageDir := t.TempDir()
-	fppConfig := oppconf.NewConfig(sys.RollupConfig, sys.L2GenesisCfg.Config, l1Head, l2Head, common.Hash(l2Claim), l2ClaimBlockNumber)
+	fppConfig := oppconf.NewConfig(sys.RollupConfig, sys.L2GenesisCfg.Config, s.L1Head, s.L2Head, common.Hash(s.L2Claim), s.L2ClaimBlockNumber)
 	fppConfig.L1URL = sys.NodeEndpoint("l1")
 	fppConfig.L2URL = sys.NodeEndpoint("sequencer")
 	fppConfig.DataDir = preimageDir
-	if detached {
+	if s.Detached {
 		// When running in detached mode we need to compile the client executable since it will be called directly.
 		fppConfig.ExecCmd = BuildOpProgramClient(t)
 	}
 
 	// Check the FPP confirms the expected output
 	t.Log("Running fault proof in fetching mode")
-	err = opp.FaultProofProgram(ctx, log, fppConfig)
+	log := testlog.Logger(t, log.LvlInfo)
+	err := opp.FaultProofProgram(ctx, log, fppConfig)
 	require.NoError(t, err)
 
 	t.Log("Shutting down network")
@@ -131,7 +266,7 @@ func testVerifyL2OutputRoot(t *testing.T, detached bool) {
 	t.Log("Running fault proof with invalid claim")
 	fppConfig.L2Claim = common.Hash{0xaa}
 	err = opp.FaultProofProgram(ctx, log, fppConfig)
-	if detached {
+	if s.Detached {
 		require.Error(t, err, "exit status 1")
 	} else {
 		require.ErrorIs(t, err, driver.ErrClaimNotValid)
@@ -139,7 +274,7 @@ func testVerifyL2OutputRoot(t *testing.T, detached bool) {
 }
 
 func waitForSafeHead(ctx context.Context, safeBlockNum uint64, rollupClient *sources.RollupClient) error {
-	ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	ctx, cancel := context.WithTimeout(ctx, 60*time.Second)
 	defer cancel()
 	for {
 		seqStatus, err := rollupClient.SyncStatus(ctx)

op-exporter/Dockerfile

-FROM golang:1.19.0-alpine3.15 as builder
+FROM golang:1.19.9-alpine3.16 as builder
 
 # build from root of repo
 COPY ./op-exporter /app
@@ -7,7 +7,7 @@ WORKDIR /app/
 RUN apk --no-cache add make bash jq git
 RUN make build
 
-FROM alpine:3.15
+FROM alpine:3.16
 RUN apk --no-cache add ca-certificates
 WORKDIR /root/
 COPY --from=builder /app/op-exporter /usr/local/bin/

op-node/Dockerfile

-FROM --platform=$BUILDPLATFORM golang:1.19.0-alpine3.15 as builder
+FROM --platform=$BUILDPLATFORM golang:1.19.9-alpine3.16 as builder
 
 ARG VERSION=v0.0.0
 
@@ -21,7 +21,7 @@ ARG TARGETOS TARGETARCH
 
 RUN make op-node VERSION="$VERSION" GOOS=$TARGETOS GOARCH=$TARGETARCH
 
-FROM alpine:3.15
+FROM alpine:3.16
 
 COPY --from=builder /app/op-node/bin/op-node /usr/local/bin
 

op-program/Dockerfile

-FROM --platform=$BUILDPLATFORM golang:1.19.0-alpine3.15 as builder
+FROM --platform=$BUILDPLATFORM golang:1.19.9-alpine3.16 as builder
 
 ARG VERSION=v0.0.0
 
@@ -22,7 +22,7 @@ ARG TARGETOS TARGETARCH
 
 RUN make op-program VERSION="$VERSION" GOOS=$TARGETOS GOARCH=$TARGETARCH
 
-FROM alpine:3.15
+FROM alpine:3.16
 
 COPY --from=builder /app/op-program/bin/op-program /usr/local/bin
 

op-program/client/l2/cache.go

@@ -6,7 +6,9 @@ import (
 	"github.com/hashicorp/golang-lru/v2/simplelru"
 )
 
-const blockCacheSize = 2_000
+// blockCacheSize should be set large enough to handle the pipeline reset process of walking back from L2 head to find
+// the L1 origin that is old enough to start buffering channel data from.
+const blockCacheSize = 3_000
 const nodeCacheSize = 100_000
 const codeCacheSize = 10_000
 

op-program/client/program.go

@@ -43,8 +43,8 @@ func RunProgram(logger log.Logger, preimageOracle io.ReadWriter, preimageHinter
 
 	pClient := preimage.NewOracleClient(preimageOracle)
 	hClient := preimage.NewHintWriter(preimageHinter)
-	l1PreimageOracle := l1.NewPreimageOracle(pClient, hClient)
-	l2PreimageOracle := l2.NewPreimageOracle(pClient, hClient)
+	l1PreimageOracle := l1.NewCachingOracle(l1.NewPreimageOracle(pClient, hClient))
+	l2PreimageOracle := l2.NewCachingOracle(l2.NewPreimageOracle(pClient, hClient))
 
 	bootInfo := NewBootstrapClient(pClient).BootInfo()
 	logger.Info("Program Bootstrapped", "bootInfo", bootInfo)

op-program/host/config/chaincfg.go

@@ -3,7 +3,6 @@ package config
 import (
 	"math/big"
 
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/params"
 )
 
@@ -13,7 +12,6 @@ var OPGoerliChainConfig = &params.ChainConfig{
 	DAOForkBlock:                  nil,
 	DAOForkSupport:                false,
 	EIP150Block:                   big.NewInt(0),
-	EIP150Hash:                    common.Hash{},
 	EIP155Block:                   big.NewInt(0),
 	EIP158Block:                   big.NewInt(0),
 	ByzantiumBlock:                big.NewInt(0),

op-program/host/l1/l1.go

-package l1
-
-import (
-	"context"
-
-	"github.com/ethereum-optimism/optimism/op-node/client"
-	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
-	"github.com/ethereum-optimism/optimism/op-node/sources"
-	cll1 "github.com/ethereum-optimism/optimism/op-program/client/l1"
-	"github.com/ethereum-optimism/optimism/op-program/host/config"
-	"github.com/ethereum-optimism/optimism/op-program/preimage"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-func NewFetchingOracle(ctx context.Context, logger log.Logger, cfg *config.Config) (cll1.Oracle, error) {
-	rpc, err := client.NewRPC(ctx, logger, cfg.L1URL)
-	if err != nil {
-		return nil, err
-	}
-
-	source, err := sources.NewL1Client(rpc, logger, nil, sources.L1ClientDefaultConfig(cfg.Rollup, cfg.L1TrustRPC, cfg.L1RPCKind))
-	if err != nil {
-		return nil, err
-	}
-	return NewFetchingL1Oracle(ctx, logger, source), nil
-}
-
-func NewSource(logger log.Logger, oracle preimage.Oracle, hint preimage.Hinter, l1Head common.Hash) derive.L1Fetcher {
-	l1Oracle := cll1.NewCachingOracle(cll1.NewPreimageOracle(oracle, hint))
-	return cll1.NewOracleL1Client(logger, l1Oracle, l1Head)
-}

op-program/host/l2/l2.go

-package l2
-
-import (
-	"context"
-	"fmt"
-
-	cll2 "github.com/ethereum-optimism/optimism/op-program/client/l2"
-	"github.com/ethereum-optimism/optimism/op-program/host/config"
-	"github.com/ethereum-optimism/optimism/op-program/preimage"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-func NewEngine(logger log.Logger, pre preimage.Oracle, hint preimage.Hinter, cfg *config.Config) (*cll2.OracleEngine, error) {
-	oracle := cll2.NewCachingOracle(cll2.NewPreimageOracle(pre, hint))
-	engineBackend, err := cll2.NewOracleBackedL2Chain(logger, oracle, cfg.L2ChainConfig, cfg.L2Head)
-	if err != nil {
-		return nil, fmt.Errorf("create l2 chain: %w", err)
-	}
-	return cll2.NewOracleEngine(cfg.Rollup, logger, engineBackend), nil
-}
-
-func NewFetchingOracle(ctx context.Context, logger log.Logger, cfg *config.Config) (cll2.Oracle, error) {
-	oracle, err := NewFetchingL2Oracle(ctx, logger, cfg.L2URL, cfg.L2Head)
-	if err != nil {
-		return nil, fmt.Errorf("connect l2 oracle: %w", err)
-	}
-	return oracle, nil
-}

op-proposer/Dockerfile

-FROM --platform=$BUILDPLATFORM golang:1.19.0-alpine3.15 as builder
+FROM --platform=$BUILDPLATFORM golang:1.19.9-alpine3.16 as builder
 
 ARG VERSION=v0.0.0
 
@@ -22,7 +22,7 @@ ARG TARGETOS TARGETARCH
 
 RUN make op-proposer VERSION="$VERSION" GOOS=$TARGETOS GOARCH=$TARGETARCH
 
-FROM alpine:3.15
+FROM alpine:3.16
 
 COPY --from=builder /app/op-proposer/bin/op-proposer /usr/local/bin
 

op-wheel/Dockerfile

-FROM golang:1.19.0-alpine3.15 as builder
+FROM golang:1.19.9-alpine3.16 as builder
 
 RUN apk add --no-cache make gcc musl-dev linux-headers
 
@@ -14,7 +14,7 @@ WORKDIR /app/op-wheel
 
 RUN go build -o op-wheel ./cmd/main.go
 
-FROM alpine:3.15
+FROM alpine:3.16
 
 COPY --from=builder /app/op-wheel/op-wheel /usr/local/bin
 

ops-bedrock/Dockerfile.stateviz

-FROM golang:1.18.0-alpine3.15 as builder
+FROM golang:1.19.9-alpine3.16 as builder
 
 RUN apk add --no-cache make gcc musl-dev linux-headers git jq bash
 
@@ -14,7 +14,7 @@ COPY ./op-node /app/op-node
 
 RUN go build -o ./bin/stateviz ./cmd/stateviz
 
-FROM alpine:3.15
+FROM alpine:3.16
 
 COPY --from=builder /app/op-node/bin/stateviz /usr/local/bin
 

ops-bedrock/docker-compose.yml

@@ -121,7 +121,6 @@ services:
       OP_BATCHER_L1_ETH_RPC: http://l1:8545
       OP_BATCHER_L2_ETH_RPC: http://l2:8545
       OP_BATCHER_ROLLUP_RPC: http://op-node:8545
-      OFFLINE_GAS_ESTIMATION: false
       OP_BATCHER_MAX_CHANNEL_DURATION: 1
       OP_BATCHER_SUB_SAFETY_MARGIN: 4 # SWS is 15, ChannelTimeout is 40
       OP_BATCHER_POLL_INTERVAL: 1s

packages/contracts-bedrock/scripts/differential-testing/differential-testing.go

@@ -266,7 +266,7 @@ func main() {
 		checkErr(err, "Error creating secure trie")
 
 		// Put a "true" bool in the storage slot
-		state.Update(hash.Bytes(), []byte{0x01})
+		state.UpdateStorage(common.Address{}, hash.Bytes(), []byte{0x01})
 
 		// Create a secure trie for the world state
 		world, err := trie.NewStateTrie(
@@ -283,7 +283,7 @@ func main() {
 		}
 		writer := new(bytes.Buffer)
 		checkErr(account.EncodeRLP(writer), "Error encoding account")
-		world.Update(predeploys.L2ToL1MessagePasserAddr.Bytes(), writer.Bytes())
+		world.UpdateStorage(common.Address{}, predeploys.L2ToL1MessagePasserAddr.Bytes(), writer.Bytes())
 
 		// Get the proof
 		var proof proofList