Merge branch 'develop' into refcell/op-challenger

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
 

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-e2e/system_fpp_test.go

@@ -71,6 +71,8 @@ func testVerifyL2OutputRootEmptyBlock(t *testing.T, detached bool) {
 
 	// 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))

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/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
-}

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