Merge branch 'develop' into jm/tfr-mon

op-bindings/predeploys/addresses.go

@@ -5,7 +5,6 @@ import "github.com/ethereum/go-ethereum/common"
 const (
 	L2ToL1MessagePasser           = "0x4200000000000000000000000000000000000016"
 	DeployerWhitelist             = "0x4200000000000000000000000000000000000002"
-	LegacyERC20ETH                = "0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000"
 	WETH9                         = "0x4200000000000000000000000000000000000006"
 	L2CrossDomainMessenger        = "0x4200000000000000000000000000000000000007"
 	L2StandardBridge              = "0x4200000000000000000000000000000000000010"
@@ -26,7 +25,6 @@ const (
 var (
 	L2ToL1MessagePasserAddr           = common.HexToAddress(L2ToL1MessagePasser)
 	DeployerWhitelistAddr             = common.HexToAddress(DeployerWhitelist)
-	LegacyERC20ETHAddr                = common.HexToAddress(LegacyERC20ETH)
 	WETH9Addr                         = common.HexToAddress(WETH9)
 	L2CrossDomainMessengerAddr        = common.HexToAddress(L2CrossDomainMessenger)
 	L2StandardBridgeAddr              = common.HexToAddress(L2StandardBridge)
@@ -49,27 +47,17 @@ var (
 // IsProxied returns true for predeploys that will sit behind a proxy contract
 func IsProxied(predeployAddr common.Address) bool {
 	switch predeployAddr {
-	case LegacyERC20ETHAddr:
 	case WETH9Addr:
 	case GovernanceTokenAddr:
-	case ProxyAdminAddr:
 	default:
 		return true
 	}
 	return false
 }
 
-// IsDeprecated returns true for predeploys we should skip in post-bedrock genesis generation
-func IsDeprecated(predeployAddr common.Address) bool {
-	// TODO: confirm if we can safely add the remaining deprecated predeploys here
-	// (see https://github.com/ethereum-optimism/optimism/blob/develop/specs/predeploys.md#overview)
-	return predeployAddr == LegacyERC20ETHAddr
-}
-
 func init() {
 	Predeploys["L2ToL1MessagePasser"] = &L2ToL1MessagePasserAddr
 	Predeploys["DeployerWhitelist"] = &DeployerWhitelistAddr
-	Predeploys["LegacyERC20ETH"] = &LegacyERC20ETHAddr
 	Predeploys["WETH9"] = &WETH9Addr
 	Predeploys["L2CrossDomainMessenger"] = &L2CrossDomainMessengerAddr
 	Predeploys["L2StandardBridge"] = &L2StandardBridgeAddr

op-chain-ops/genesis/layer_two.go

 package genesis
 
 import (
-	"errors"
 	"fmt"
-	"math/big"
 
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
 
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/immutables"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/state"
 )
 
-// BuildL2DeveloperGenesis will build the developer Optimism Genesis
-// Block. Suitable for devnets.
-func BuildL2DeveloperGenesis(config *DeployConfig, l1StartBlock *types.Block) (*core.Genesis, error) {
+// BuildL2DeveloperGenesis will build the L2 genesis block.
+func BuildL2Genesis(config *DeployConfig, l1StartBlock *types.Block) (*core.Genesis, error) {
 	genspec, err := NewL2Genesis(config, l1StartBlock)
 	if err != nil {
 		return nil, err
 	}
 
 	db := state.NewMemoryStateDB(genspec)
-
 	if config.FundDevAccounts {
 		FundDevAccounts(db)
-	}
 		SetPrecompileBalances(db)
-
-	storage, err := NewL2StorageConfig(config, l1StartBlock)
-	if err != nil {
-		return nil, err
-	}
-
-	immutable, err := NewL2ImmutableConfig(config, l1StartBlock)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := SetL2Proxies(db); err != nil {
-		return nil, err
-	}
-
-	if err := SetImplementations(db, storage, immutable); err != nil {
-		return nil, err
 	}
 
-	if err := SetDevOnlyL2Implementations(db, storage, immutable); err != nil {
-		return nil, err
-	}
-
-	return db.Genesis(), nil
-}
-
-// BuildL2MainnetGenesis will build an L2 Genesis suitable for a Superchain mainnet that does not
-// require a pre-bedrock migration & supports optional governance token predeploy. Details:
-//
-//   - Creates proxies for predeploys in the address space:
-//     [0x4200000000000000000000000000000000000000, 0x4200000000000000000000000000000000000800)
-//
-//   - All predeploy proxies owned by the ProxyAdmin
-//
-//   - Predeploys as per the spec except for no LegacyERC20ETH predeploy at
-//     0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000
-//
-//   - optional governance token at 0x4200000000000000000000000000000000000042 if
-//     config.EnableGovernance is true (& otherwise a no-impl proxy remains at this address)
-//
-//   - no accounts are pre-funded
-func BuildL2MainnetGenesis(config *DeployConfig, l1StartBlock *types.Block) (*core.Genesis, error) {
-	genspec, err := NewL2Genesis(config, l1StartBlock)
-	if err != nil {
-		return nil, err
-	}
-
-	db := state.NewMemoryStateDB(genspec)
-
 	storage, err := NewL2StorageConfig(config, l1StartBlock)
 	if err != nil {
 		return nil, err
@@ -90,20 +36,10 @@ func BuildL2MainnetGenesis(config *DeployConfig, l1StartBlock *types.Block) (*co
 	}
 
 	// Set up the proxies
-	depBytecode, err := bindings.GetDeployedBytecode("Proxy")
+	err = setProxies(db, predeploys.ProxyAdminAddr, bigL2PredeployNamespace, 2048)
 	if err != nil {
 		return nil, err
 	}
-	if len(depBytecode) == 0 {
-		return nil, errors.New("Proxy has empty bytecode")
-	}
-	for i := uint64(0); i <= 2048; i++ {
-		bigAddr := new(big.Int).Or(bigL2PredeployNamespace, new(big.Int).SetUint64(i))
-		addr := common.BigToAddress(bigAddr)
-		db.CreateAccount(addr)
-		db.SetCode(addr, depBytecode)
-		db.SetState(addr, AdminSlot, predeploys.ProxyAdminAddr.Hash())
-	}
 
 	// Set up the implementations
 	deployResults, err := immutables.BuildOptimism(immutable)
@@ -112,9 +48,6 @@ func BuildL2MainnetGenesis(config *DeployConfig, l1StartBlock *types.Block) (*co
 	}
 	for name, predeploy := range predeploys.Predeploys {
 		addr := *predeploy
-		if predeploys.IsDeprecated(addr) {
-			continue
-		}
 		if addr == predeploys.GovernanceTokenAddr && !config.EnableGovernance {
 			// there is no governance token configured, so skip the governance token predeploy
 			log.Warn("Governance is not enabled, skipping governance token predeploy.")

op-chain-ops/genesis/layer_two_test.go

@@ -28,58 +28,8 @@ func init() {
 
 var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 
-func TestBuildL2DeveloperGenesis(t *testing.T) {
-	config, err := genesis.NewDeployConfig("./testdata/test-deploy-config-devnet-l1.json")
-	require.Nil(t, err)
-
-	backend := backends.NewSimulatedBackend(
-		core.GenesisAlloc{
-			crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
-		},
-		15000000,
-	)
-	block, err := backend.BlockByNumber(context.Background(), common.Big0)
-	require.NoError(t, err)
-
-	gen, err := genesis.BuildL2DeveloperGenesis(config, block)
-	require.Nil(t, err)
-	require.NotNil(t, gen)
-
-	proxyBytecode, err := bindings.GetDeployedBytecode("Proxy")
-	require.NoError(t, err)
-
-	for name, address := range predeploys.Predeploys {
-		addr := *address
-
-		account, ok := gen.Alloc[addr]
-		require.Equal(t, true, ok)
-		require.Greater(t, len(account.Code), 0)
-
-		if name == "GovernanceToken" || name == "LegacyERC20ETH" || name == "ProxyAdmin" || name == "WETH9" {
-			continue
-		}
-
-		adminSlot, ok := account.Storage[genesis.AdminSlot]
-		require.Equal(t, true, ok, name)
-		require.Equal(t, predeploys.ProxyAdminAddr.Hash(), adminSlot)
-		require.Equal(t, proxyBytecode, account.Code)
-	}
-	require.Equal(t, 2343, len(gen.Alloc))
-
-	if writeFile {
-		file, _ := json.MarshalIndent(gen, "", " ")
-		_ = os.WriteFile("genesis.json", file, 0644)
-	}
-}
-
-func TestBuildL2DeveloperGenesisDevAccountsFunding(t *testing.T) {
-	config, err := genesis.NewDeployConfig("./testdata/test-deploy-config-devnet-l1.json")
-	require.Nil(t, err)
-	config.FundDevAccounts = false
-
-	err = config.InitDeveloperDeployedAddresses()
-	require.NoError(t, err)
-
+// Tests the BuildL2MainnetGenesis factory with the provided config.
+func testBuildL2Genesis(t *testing.T, config *genesis.DeployConfig) *core.Genesis {
 	backend := backends.NewSimulatedBackend(
 		core.GenesisAlloc{
 			crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
@@ -89,29 +39,7 @@ func TestBuildL2DeveloperGenesisDevAccountsFunding(t *testing.T) {
 	block, err := backend.BlockByNumber(context.Background(), common.Big0)
 	require.NoError(t, err)
 
-	gen, err := genesis.BuildL2DeveloperGenesis(config, block)
-	require.NoError(t, err)
-	require.Equal(t, 2321, len(gen.Alloc))
-}
-
-// Tests the BuildL2MainnetGenesis factory. enableGovernance is used to override enableGovernance
-// config option. When false, the test confirms the governance token predeploy address instead
-// holds a proxy contract.
-func testBuildL2Genesis(t *testing.T, enableGovernance bool) {
-	config, err := genesis.NewDeployConfig("./testdata/test-deploy-config-devnet-l1.json")
-	require.Nil(t, err)
-	config.EnableGovernance = enableGovernance
-
-	backend := backends.NewSimulatedBackend(
-		core.GenesisAlloc{
-			crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
-		},
-		15000000,
-	)
-	block, err := backend.BlockByNumber(context.Background(), common.Big0)
-	require.NoError(t, err)
-
-	gen, err := genesis.BuildL2MainnetGenesis(config, block)
+	gen, err := genesis.BuildL2Genesis(config, block)
 	require.Nil(t, err)
 	require.NotNil(t, gen)
 
@@ -122,17 +50,12 @@ func testBuildL2Genesis(t *testing.T, enableGovernance bool) {
 		addr := *predeploy
 
 		account, ok := gen.Alloc[addr]
-		if predeploys.IsDeprecated(addr) && !predeploys.IsProxied(addr) {
-			// deprecated, non-proxied predeploys should have no account
-			require.Equal(t, false, ok, name)
-			continue
-		}
 		require.Equal(t, true, ok, name)
 		require.Greater(t, len(account.Code), 0)
 
 		adminSlot, ok := account.Storage[genesis.AdminSlot]
 		isProxy := predeploys.IsProxied(addr) ||
-			(!enableGovernance && addr == predeploys.GovernanceTokenAddr)
+			(!config.EnableGovernance && addr == predeploys.GovernanceTokenAddr)
 		if isProxy {
 			require.Equal(t, true, ok, name)
 			require.Equal(t, predeploys.ProxyAdminAddr.Hash(), adminSlot)
@@ -142,18 +65,39 @@ func testBuildL2Genesis(t *testing.T, enableGovernance bool) {
 			require.NotEqual(t, proxyBytecode, account.Code, name)
 		}
 	}
-	require.Equal(t, 2063, len(gen.Alloc))
 
 	if writeFile {
 		file, _ := json.MarshalIndent(gen, "", " ")
 		_ = os.WriteFile("genesis.json", file, 0644)
 	}
+	return gen
+}
+
+func TestBuildL2DeveloperGenesis(t *testing.T) {
+	config, err := genesis.NewDeployConfig("./testdata/test-deploy-config-devnet-l1.json")
+	require.Nil(t, err)
+	config.EnableGovernance = false
+	config.FundDevAccounts = true
+	err = config.InitDeveloperDeployedAddresses()
+	require.NoError(t, err)
+	gen := testBuildL2Genesis(t, config)
+	require.Equal(t, 2342, len(gen.Alloc))
 }
 
 func TestBuildL2MainnetGenesis(t *testing.T) {
-	testBuildL2Genesis(t, true)
+	config, err := genesis.NewDeployConfig("./testdata/test-deploy-config-devnet-l1.json")
+	require.Nil(t, err)
+	config.EnableGovernance = true
+	config.FundDevAccounts = false
+	gen := testBuildL2Genesis(t, config)
+	require.Equal(t, 2064, len(gen.Alloc))
 }
 
 func TestBuildL2MainnetNoGovernanceGenesis(t *testing.T) {
-	testBuildL2Genesis(t, false)
+	config, err := genesis.NewDeployConfig("./testdata/test-deploy-config-devnet-l1.json")
+	require.Nil(t, err)
+	config.EnableGovernance = false
+	config.FundDevAccounts = false
+	gen := testBuildL2Genesis(t, config)
+	require.Equal(t, 2064, len(gen.Alloc))
 }

op-chain-ops/genesis/setters.go

@@ -2,12 +2,10 @@ package genesis
 
 import (
 	"errors"
-	"fmt"
 	"math/big"
 
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 
-	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/immutables"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/state"
 	"github.com/ethereum/go-ethereum/common"
@@ -15,19 +13,6 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 )
 
-// UntouchableCodeHashes contains code hashes of all the contracts
-// that should not be touched by the migration process.
-type ChainHashMap map[uint64]common.Hash
-
-var (
-	// UntouchablePredeploys are addresses in the predeploy namespace
-	// that should not be touched by the migration process.
-	UntouchablePredeploys = map[common.Address]bool{
-		predeploys.GovernanceTokenAddr: true,
-		predeploys.WETH9Addr:           true,
-	}
-)
-
 // FundDevAccounts will fund each of the development accounts.
 func FundDevAccounts(db vm.StateDB) {
 	for _, account := range DevAccounts {
@@ -36,14 +21,6 @@ func FundDevAccounts(db vm.StateDB) {
 	}
 }
 
-// SetL2Proxies will set each of the proxies in the state. It requires
-// a Proxy and ProxyAdmin deployment present so that the Proxy bytecode
-// can be set in state and the ProxyAdmin can be set as the admin of the
-// Proxy.
-func SetL2Proxies(db vm.StateDB) error {
-	return setProxies(db, predeploys.ProxyAdminAddr, bigL2PredeployNamespace, 2048)
-}
-
 // SetL1Proxies will set each of the proxies in the state. It requires
 // a Proxy and ProxyAdmin deployment present so that the Proxy bytecode
 // can be set in state and the ProxyAdmin can be set as the admin of the
@@ -65,11 +42,6 @@ func setProxies(db vm.StateDB, proxyAdminAddr common.Address, namespace *big.Int
 		bigAddr := new(big.Int).Or(namespace, new(big.Int).SetUint64(i))
 		addr := common.BigToAddress(bigAddr)
 
-		if UntouchablePredeploys[addr] {
-			log.Info("Skipping setting proxy", "address", addr)
-			continue
-		}
-
 		if !db.Exist(addr) {
 			db.CreateAccount(addr)
 		}
@@ -82,87 +54,6 @@ func setProxies(db vm.StateDB, proxyAdminAddr common.Address, namespace *big.Int
 	return nil
 }
 
-func SetLegacyETH(db vm.StateDB, storage state.StorageConfig, immutable immutables.ImmutableConfig) error {
-	deployResults, err := immutables.BuildOptimism(immutable)
-	if err != nil {
-		return err
-	}
-
-	return setupPredeploy(db, deployResults, storage, "LegacyERC20ETH", predeploys.LegacyERC20ETHAddr, predeploys.LegacyERC20ETHAddr)
-}
-
-// SetImplementations will set the implementations of the contracts in the state
-// and configure the proxies to point to the implementations. It also sets
-// the appropriate storage values for each contract at the proxy address.
-func SetImplementations(db vm.StateDB, storage state.StorageConfig, immutable immutables.ImmutableConfig) error {
-	deployResults, err := immutables.BuildOptimism(immutable)
-	if err != nil {
-		return err
-	}
-
-	for name, address := range predeploys.Predeploys {
-		if UntouchablePredeploys[*address] {
-			continue
-		}
-
-		if *address == predeploys.LegacyERC20ETHAddr {
-			continue
-		}
-
-		codeAddr, err := AddressToCodeNamespace(*address)
-		if err != nil {
-			return fmt.Errorf("error converting to code namespace: %w", err)
-		}
-
-		if !db.Exist(codeAddr) {
-			db.CreateAccount(codeAddr)
-		}
-
-		db.SetState(*address, ImplementationSlot, codeAddr.Hash())
-
-		if err := setupPredeploy(db, deployResults, storage, name, *address, codeAddr); err != nil {
-			return err
-		}
-
-		code := db.GetCode(codeAddr)
-		if len(code) == 0 {
-			return fmt.Errorf("code not set for %s", name)
-		}
-	}
-	return nil
-}
-
-func SetDevOnlyL2Implementations(db vm.StateDB, storage state.StorageConfig, immutable immutables.ImmutableConfig) error {
-	deployResults, err := immutables.BuildOptimism(immutable)
-	if err != nil {
-		return err
-	}
-
-	for name, address := range predeploys.Predeploys {
-		if !UntouchablePredeploys[*address] {
-			continue
-		}
-
-		db.CreateAccount(*address)
-
-		if err := setupPredeploy(db, deployResults, storage, name, *address, *address); err != nil {
-			return err
-		}
-
-		code := db.GetCode(*address)
-		if len(code) == 0 {
-			return fmt.Errorf("code not set for %s", name)
-		}
-	}
-
-	db.CreateAccount(predeploys.LegacyERC20ETHAddr)
-	if err := setupPredeploy(db, deployResults, storage, "LegacyERC20ETH", predeploys.LegacyERC20ETHAddr, predeploys.LegacyERC20ETHAddr); err != nil {
-		return fmt.Errorf("error setting up legacy eth: %w", err)
-	}
-
-	return nil
-}
-
 // SetPrecompileBalances will set a single wei at each precompile address.
 // This is an optimization to make calling them cheaper. This should only
 // be used for devnets.

op-e2e/e2eutils/setup.go

@@ -185,7 +185,7 @@ func Setup(t require.TestingT, deployParams *DeployParams, alloc *AllocParams) *
 
 	l1Block := l1Genesis.ToBlock()
 
-	l2Genesis, err := genesis.BuildL2DeveloperGenesis(deployConf, l1Block)
+	l2Genesis, err := genesis.BuildL2Genesis(deployConf, l1Block)
 	require.NoError(t, err, "failed to create l2 genesis")
 	if alloc.PrefundTestUsers {
 		for _, addr := range deployParams.Addresses.All() {

op-e2e/op_geth.go

@@ -53,7 +53,7 @@ func NewOpGeth(t *testing.T, ctx context.Context, cfg *SystemConfig) (*OpGeth, e
 	require.Nil(t, err)
 	l1Block := l1Genesis.ToBlock()
 
-	l2Genesis, err := genesis.BuildL2DeveloperGenesis(cfg.DeployConfig, l1Block)
+	l2Genesis, err := genesis.BuildL2Genesis(cfg.DeployConfig, l1Block)
 	require.Nil(t, err)
 	l2GenesisBlock := l2Genesis.ToBlock()
 

op-e2e/setup.go

@@ -359,7 +359,7 @@ func (cfg SystemConfig) Start(_opts ...SystemConfigOption) (*System, error) {
 	}
 
 	l1Block := l1Genesis.ToBlock()
-	l2Genesis, err := genesis.BuildL2DeveloperGenesis(cfg.DeployConfig, l1Block)
+	l2Genesis, err := genesis.BuildL2Genesis(cfg.DeployConfig, l1Block)
 	if err != nil {
 		return nil, err
 	}

op-node/cmd/genesis/cmd.go

@@ -61,7 +61,7 @@ var Subcommands = cli.Commands{
 			}
 
 			l1StartBlock := l1Genesis.ToBlock()
-			l2Genesis, err := genesis.BuildL2DeveloperGenesis(config, l1StartBlock)
+			l2Genesis, err := genesis.BuildL2Genesis(config, l1StartBlock)
 			if err != nil {
 				return err
 			}
@@ -144,7 +144,7 @@ var Subcommands = cli.Commands{
 			}
 
 			// Build the developer L2 genesis block
-			l2Genesis, err := genesis.BuildL2DeveloperGenesis(config, l1StartBlock)
+			l2Genesis, err := genesis.BuildL2Genesis(config, l1StartBlock)
 			if err != nil {
 				return fmt.Errorf("error creating l2 developer genesis: %w", err)
 			}

packages/contracts-bedrock/.gas-snapshot

@@ -2,9 +2,9 @@ Bytes_slice_Test:test_slice_acrossMultipleWords_works() (gas: 9413)
 Bytes_slice_Test:test_slice_acrossWords_works() (gas: 1430)
 Bytes_slice_Test:test_slice_fromNonZeroIdx_works() (gas: 17240)
 Bytes_slice_Test:test_slice_fromZeroIdx_works() (gas: 20826)
-Bytes_toNibbles_Test:test_toNibbles_expectedResult128Bytes_works() (gas: 129874)
-Bytes_toNibbles_Test:test_toNibbles_expectedResult5Bytes_works() (gas: 6132)
-Bytes_toNibbles_Test:test_toNibbles_zeroLengthInput_works() (gas: 944)
+Bytes_toNibbles_Test:test_toNibbles_expectedResult128Bytes_works() (gas: 78882)
+Bytes_toNibbles_Test:test_toNibbles_expectedResult5Bytes_works() (gas: 3992)
+Bytes_toNibbles_Test:test_toNibbles_zeroLengthInput_works() (gas: 823)
 CrossDomainMessenger_BaseGas_Test:test_baseGas_succeeds() (gas: 20412)
 CrossDomainOwnable2_Test:test_onlyOwner_notMessenger_reverts() (gas: 8416)
 CrossDomainOwnable2_Test:test_onlyOwner_notOwner2_reverts() (gas: 57515)
@@ -43,7 +43,7 @@ GasBenchMark_L1StandardBridge_Finalize:test_finalizeETHWithdrawal_benchmark() (g
 GasBenchMark_L2OutputOracle:test_proposeL2Output_benchmark() (gas: 88513)
 GasBenchMark_OptimismPortal:test_depositTransaction_benchmark() (gas: 75225)
 GasBenchMark_OptimismPortal:test_depositTransaction_benchmark_1() (gas: 75662)
-GasBenchMark_OptimismPortal:test_proveWithdrawalTransaction_benchmark() (gas: 169237)
+GasBenchMark_OptimismPortal:test_proveWithdrawalTransaction_benchmark() (gas: 143113)
 GasPriceOracle_Test:test_baseFee_succeeds() (gas: 8325)
 GasPriceOracle_Test:test_decimals_succeeds() (gas: 6167)
 GasPriceOracle_Test:test_gasPrice_succeeds() (gas: 8294)
@@ -207,25 +207,25 @@ LegacyERC20ETH_Test:test_transferFrom_doesNotExist_reverts() (gas: 12957)
 LegacyERC20ETH_Test:test_transfer_doesNotExist_reverts() (gas: 10755)
 LegacyMessagePasser_Test:test_passMessageToL1_succeeds() (gas: 34524)
 MerkleTrie_get_Test:test_get_corruptedProof_reverts() (gas: 5736)
-MerkleTrie_get_Test:test_get_extraProofElements_reverts() (gas: 60631)
+MerkleTrie_get_Test:test_get_extraProofElements_reverts() (gas: 58975)
 MerkleTrie_get_Test:test_get_invalidDataRemainder_reverts() (gas: 35852)
-MerkleTrie_get_Test:test_get_invalidInternalNodeHash_reverts() (gas: 50810)
-MerkleTrie_get_Test:test_get_nonexistentKey1_reverts() (gas: 59671)
-MerkleTrie_get_Test:test_get_nonexistentKey2_reverts() (gas: 23385)
-MerkleTrie_get_Test:test_get_smallerPathThanKey1_reverts() (gas: 53525)
-MerkleTrie_get_Test:test_get_smallerPathThanKey2_reverts() (gas: 55006)
-MerkleTrie_get_Test:test_get_validProof10_succeeds() (gas: 50593)
-MerkleTrie_get_Test:test_get_validProof1_succeeds() (gas: 61688)
-MerkleTrie_get_Test:test_get_validProof2_succeeds() (gas: 71579)
-MerkleTrie_get_Test:test_get_validProof3_succeeds() (gas: 32827)
-MerkleTrie_get_Test:test_get_validProof4_succeeds() (gas: 23623)
-MerkleTrie_get_Test:test_get_validProof5_succeeds() (gas: 84262)
-MerkleTrie_get_Test:test_get_validProof6_succeeds() (gas: 73021)
-MerkleTrie_get_Test:test_get_validProof7_succeeds() (gas: 79719)
-MerkleTrie_get_Test:test_get_validProof8_succeeds() (gas: 50550)
-MerkleTrie_get_Test:test_get_validProof9_succeeds() (gas: 50550)
-MerkleTrie_get_Test:test_get_wrongKeyProof_reverts() (gas: 53871)
-MerkleTrie_get_Test:test_get_zeroBranchValueLength_reverts() (gas: 43248)
+MerkleTrie_get_Test:test_get_invalidInternalNodeHash_reverts() (gas: 49706)
+MerkleTrie_get_Test:test_get_nonexistentKey1_reverts() (gas: 54839)
+MerkleTrie_get_Test:test_get_nonexistentKey2_reverts() (gas: 16723)
+MerkleTrie_get_Test:test_get_smallerPathThanKey1_reverts() (gas: 51472)
+MerkleTrie_get_Test:test_get_smallerPathThanKey2_reverts() (gas: 52953)
+MerkleTrie_get_Test:test_get_validProof10_succeeds() (gas: 48937)
+MerkleTrie_get_Test:test_get_validProof1_succeeds() (gas: 56062)
+MerkleTrie_get_Test:test_get_validProof2_succeeds() (gas: 65953)
+MerkleTrie_get_Test:test_get_validProof3_succeeds() (gas: 27356)
+MerkleTrie_get_Test:test_get_validProof4_succeeds() (gas: 18152)
+MerkleTrie_get_Test:test_get_validProof5_succeeds() (gas: 80776)
+MerkleTrie_get_Test:test_get_validProof6_succeeds() (gas: 69535)
+MerkleTrie_get_Test:test_get_validProof7_succeeds() (gas: 76233)
+MerkleTrie_get_Test:test_get_validProof8_succeeds() (gas: 48894)
+MerkleTrie_get_Test:test_get_validProof9_succeeds() (gas: 48894)
+MerkleTrie_get_Test:test_get_wrongKeyProof_reverts() (gas: 50782)
+MerkleTrie_get_Test:test_get_zeroBranchValueLength_reverts() (gas: 41747)
 MerkleTrie_get_Test:test_get_zeroLengthKey_reverts() (gas: 3632)
 MintManager_constructor_Test:test_constructor_succeeds() (gas: 10579)
 MintManager_mint_Test:test_mint_afterPeriodElapsed_succeeds() (gas: 148117)
@@ -265,26 +265,26 @@ OptimismPortalUpgradeable_Test:test_initialize_cannotInitImpl_reverts() (gas: 10
 OptimismPortalUpgradeable_Test:test_initialize_cannotInitProxy_reverts() (gas: 15918)
 OptimismPortalUpgradeable_Test:test_params_initValuesOnProxy_succeeds() (gas: 21774)
 OptimismPortalUpgradeable_Test:test_upgradeToAndCall_upgrading_succeeds() (gas: 180547)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_ifOutputRootChanges_reverts() (gas: 204022)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_ifOutputTimestampIsNotFinalized_reverts() (gas: 207475)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_ifOutputRootChanges_reverts() (gas: 177898)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_ifOutputTimestampIsNotFinalized_reverts() (gas: 181351)
 OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_ifWithdrawalNotProven_reverts() (gas: 41731)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_ifWithdrawalProofNotOldEnough_reverts() (gas: 199419)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_onInsufficientGas_reverts() (gas: 205848)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_onRecentWithdrawal_reverts() (gas: 180184)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_onReentrancy_reverts() (gas: 243823)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_onReplay_reverts() (gas: 245561)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_ifWithdrawalProofNotOldEnough_reverts() (gas: 173295)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_onInsufficientGas_reverts() (gas: 179724)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_onRecentWithdrawal_reverts() (gas: 154060)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_onReentrancy_reverts() (gas: 217699)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_onReplay_reverts() (gas: 219437)
 OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_paused_reverts() (gas: 53510)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_provenWithdrawalHash_succeeds() (gas: 234996)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_targetFails_fails() (gas: 8797746687696163867)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_timestampLessThanL2OracleStart_reverts() (gas: 196997)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_provenWithdrawalHash_succeeds() (gas: 208872)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_targetFails_fails() (gas: 8797746687696162662)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_timestampLessThanL2OracleStart_reverts() (gas: 170873)
 OptimismPortal_FinalizeWithdrawal_Test:test_proveWithdrawalTransaction_onInvalidOutputRootProof_reverts() (gas: 85690)
-OptimismPortal_FinalizeWithdrawal_Test:test_proveWithdrawalTransaction_onInvalidWithdrawalProof_reverts() (gas: 137350)
+OptimismPortal_FinalizeWithdrawal_Test:test_proveWithdrawalTransaction_onInvalidWithdrawalProof_reverts() (gas: 111226)
 OptimismPortal_FinalizeWithdrawal_Test:test_proveWithdrawalTransaction_onSelfCall_reverts() (gas: 52947)
 OptimismPortal_FinalizeWithdrawal_Test:test_proveWithdrawalTransaction_paused_reverts() (gas: 73673)
-OptimismPortal_FinalizeWithdrawal_Test:test_proveWithdrawalTransaction_replayProveChangedOutputRootAndOutputIndex_succeeds() (gas: 346739)
-OptimismPortal_FinalizeWithdrawal_Test:test_proveWithdrawalTransaction_replayProveChangedOutputRoot_succeeds() (gas: 279571)
-OptimismPortal_FinalizeWithdrawal_Test:test_proveWithdrawalTransaction_replayProve_reverts() (gas: 192548)
-OptimismPortal_FinalizeWithdrawal_Test:test_proveWithdrawalTransaction_validWithdrawalProof_succeeds() (gas: 180486)
+OptimismPortal_FinalizeWithdrawal_Test:test_proveWithdrawalTransaction_replayProveChangedOutputRootAndOutputIndex_succeeds() (gas: 294491)
+OptimismPortal_FinalizeWithdrawal_Test:test_proveWithdrawalTransaction_replayProveChangedOutputRoot_succeeds() (gas: 227323)
+OptimismPortal_FinalizeWithdrawal_Test:test_proveWithdrawalTransaction_replayProve_reverts() (gas: 166424)
+OptimismPortal_FinalizeWithdrawal_Test:test_proveWithdrawalTransaction_validWithdrawalProof_succeeds() (gas: 154362)
 OptimismPortal_Test:test_constructor_succeeds() (gas: 19402)
 OptimismPortal_Test:test_depositTransaction_contractCreation_reverts() (gas: 14342)
 OptimismPortal_Test:test_depositTransaction_createWithZeroValueForContract_succeeds() (gas: 76726)

packages/contracts-bedrock/contracts/L1/OptimismPortal.sol

@@ -140,7 +140,7 @@ contract OptimismPortal is Initializable, ResourceMetering, Semver {
     }
 
     /**
-     * @custom:semver 1.6.0
+     * @custom:semver 1.7.0
      *
      * @param _l2Oracle                  Address of the L2OutputOracle contract.
      * @param _guardian                  Address that can pause deposits and withdrawals.
@@ -152,7 +152,7 @@ contract OptimismPortal is Initializable, ResourceMetering, Semver {
         address _guardian,
         bool _paused,
         SystemConfig _config
-    ) Semver(1, 6, 0) {
+    ) Semver(1, 7, 0) {
         L2_ORACLE = _l2Oracle;
         GUARDIAN = _guardian;
         SYSTEM_CONFIG = _config;

packages/contracts-bedrock/contracts/libraries/Bytes.sol

@@ -112,20 +112,50 @@ library Bytes {
      * @return Resulting nibble array.
      */
     function toNibbles(bytes memory _bytes) internal pure returns (bytes memory) {
-        uint256 bytesLength = _bytes.length;
-        bytes memory nibbles = new bytes(bytesLength * 2);
-        bytes1 b;
-
-        for (uint256 i = 0; i < bytesLength; ) {
-            b = _bytes[i];
-            nibbles[i * 2] = b >> 4;
-            nibbles[i * 2 + 1] = b & 0x0f;
-            unchecked {
-                ++i;
+        bytes memory _nibbles;
+        assembly {
+            // Grab a free memory offset for the new array
+            _nibbles := mload(0x40)
+
+            // Load the length of the passed bytes array from memory
+            let bytesLength := mload(_bytes)
+
+            // Calculate the length of the new nibble array
+            // This is the length of the input array times 2
+            let nibblesLength := shl(0x01, bytesLength)
+
+            // Update the free memory pointer to allocate memory for the new array.
+            // To do this, we add the length of the new array + 32 bytes for the array length
+            // rounded up to the nearest 32 byte boundary to the current free memory pointer.
+            mstore(0x40, add(_nibbles, and(not(0x1F), add(nibblesLength, 0x3F))))
+
+            // Store the length of the new array in memory
+            mstore(_nibbles, nibblesLength)
+
+            // Store the memory offset of the _bytes array's contents on the stack
+            let bytesStart := add(_bytes, 0x20)
+
+            // Store the memory offset of the nibbles array's contents on the stack
+            let nibblesStart := add(_nibbles, 0x20)
+
+            // Loop through each byte in the input array
+            for {
+                let i := 0x00
+            } lt(i, bytesLength) {
+                i := add(i, 0x01)
+            } {
+                // Get the starting offset of the next 2 bytes in the nibbles array
+                let offset := add(nibblesStart, shl(0x01, i))
+                // Load the byte at the current index within the `_bytes` array
+                let b := byte(0x00, mload(add(bytesStart, i)))
+
+                // Pull out the first nibble and store it in the new array
+                mstore8(offset, shr(0x04, b))
+                // Pull out the second nibble and store it in the new array
+                mstore8(add(offset, 0x01), and(b, 0x0F))
             }
         }
-
-        return nibbles;
+        return _nibbles;
     }
 
     /**

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

@@ -182,49 +182,6 @@ contract Bytes_slice_Test is Test {
 }
 
 contract Bytes_toNibbles_Test is Test {
-    /**
-     * @notice Diffs the test Solidity version of `toNibbles` against the Yul version.
-     *
-     * @param _bytes The `bytes` array to convert to nibbles.
-     *
-     * @return Yul version of `toNibbles` applied to `_bytes`.
-     */
-    function _toNibblesYul(bytes memory _bytes) internal pure returns (bytes memory) {
-        // Allocate memory for the `nibbles` array.
-        bytes memory nibbles = new bytes(_bytes.length << 1);
-
-        assembly {
-            // Load the length of the passed bytes array from memory
-            let bytesLength := mload(_bytes)
-
-            // Store the memory offset of the _bytes array's contents on the stack
-            let bytesStart := add(_bytes, 0x20)
-
-            // Store the memory offset of the nibbles array's contents on the stack
-            let nibblesStart := add(nibbles, 0x20)
-
-            // Loop through each byte in the input array
-            for {
-                let i := 0x00
-            } lt(i, bytesLength) {
-                i := add(i, 0x01)
-            } {
-                // Get the starting offset of the next 2 bytes in the nibbles array
-                let offset := add(nibblesStart, shl(0x01, i))
-
-                // Load the byte at the current index within the `_bytes` array
-                let b := byte(0x00, mload(add(bytesStart, i)))
-
-                // Pull out the first nibble and store it in the new array
-                mstore8(offset, shr(0x04, b))
-                // Pull out the second nibble and store it in the new array
-                mstore8(add(offset, 0x01), and(b, 0x0F))
-            }
-        }
-
-        return nibbles;
-    }
-
     /**
      * @notice Tests that, given an input of 5 bytes, the `toNibbles` function returns an array of
      *         10 nibbles corresponding to the input data.
@@ -272,11 +229,49 @@ contract Bytes_toNibbles_Test is Test {
     }
 
     /**
-     * @notice Test that the `toNibbles` function in the `Bytes` library is equivalent to the Yul
-     *         implementation.
+     * @notice Tests that the `toNibbles` function correctly updates the free memory pointer depending
+     *         on the length of the resulting array.
      */
-    function testDiff_toNibbles_succeeds(bytes memory _input) public {
-        assertEq(Bytes.toNibbles(_input), _toNibblesYul(_input));
+    function testFuzz_toNibbles_memorySafety_succeeds(bytes memory _input) public {
+        // Grab the free memory pointer before the `toNibbles` operation
+        uint64 initPtr;
+        assembly {
+            initPtr := mload(0x40)
+        }
+        uint64 expectedPtr = uint64(initPtr + 0x20 + ((_input.length * 2 + 0x1F) & ~uint256(0x1F)));
+
+        // Ensure that all memory outside of the expected range is safe.
+        vm.expectSafeMemory(initPtr, expectedPtr);
+
+        // Pull out each individual nibble from the input bytes array
+        bytes memory nibbles = Bytes.toNibbles(_input);
+
+        // Grab the free memory pointer after the `toNibbles` operation
+        uint64 finalPtr;
+        assembly {
+            finalPtr := mload(0x40)
+        }
+
+        // The free memory pointer should have been updated properly
+        if (_input.length == 0) {
+            // If the input length is zero, only 32 bytes of memory should have been allocated.
+            assertEq(finalPtr, initPtr + 0x20);
+        } else {
+            // If the input length is greater than zero, the memory allocated should be the
+            // length of the input * 2 + 32 bytes for the length field.
+            //
+            // Note that we use a slightly less efficient, but equivalent method of rounding
+            // up `_length` to the next multiple of 32 than is used in the `toNibbles` function.
+            // This is to diff test the method used in `toNibbles`.
+            uint64 _expectedPtr = uint64(initPtr + 0x20 + (((_input.length * 2 + 0x1F) >> 5) << 5));
+            assertEq(finalPtr, _expectedPtr);
+
+            // Sanity check for equivalence of the rounding methods.
+            assertEq(_expectedPtr, expectedPtr);
+        }
+
+        // The nibbles length should be equal to `_length * 2`
+        assertEq(nibbles.length, _input.length << 1);
     }
 }
 

packages/contracts-bedrock/tasks/check-l2.ts

@@ -465,46 +465,6 @@ const check = {
     await checkProxy(hre, 'L1Block', signer.provider)
     await assertProxy(hre, 'L1Block', signer.provider)
   },
-  // LegacyERC20ETH
-  // - not behind a proxy
-  // - check name
-  // - check symbol
-  // - check decimals
-  // - check BRIDGE
-  // - check REMOTE_TOKEN
-  // - totalSupply should be set to 0
-  LegacyERC20ETH: async (hre: HardhatRuntimeEnvironment, signer: Signer) => {
-    const LegacyERC20ETH = await hre.ethers.getContractAt(
-      'LegacyERC20ETH',
-      predeploys.LegacyERC20ETH,
-      signer
-    )
-
-    const name = await LegacyERC20ETH.name()
-    assert(name === 'Ether')
-    console.log(`  - name: ${name}`)
-
-    const symbol = await LegacyERC20ETH.symbol()
-    assert(symbol === 'ETH')
-    console.log(`  - symbol: ${symbol}`)
-
-    const decimals = await LegacyERC20ETH.decimals()
-    assert(decimals === 18)
-    console.log(`  - decimals: ${decimals}`)
-
-    const BRIDGE = await LegacyERC20ETH.BRIDGE()
-    assert(BRIDGE === predeploys.L2StandardBridge)
-
-    const REMOTE_TOKEN = await LegacyERC20ETH.REMOTE_TOKEN()
-    assert(REMOTE_TOKEN === hre.ethers.constants.AddressZero)
-
-    const totalSupply = await LegacyERC20ETH.totalSupply()
-    assert(totalSupply.eq(0))
-    console.log(`  - totalSupply: ${totalSupply}`)
-
-    await checkProxy(hre, 'LegacyERC20ETH', signer.provider)
-    // No proxy at this address, don't call assertProxy
-  },
   // WETH9
   // - check name
   // - check symbol

specs/predeploys.md

@@ -62,7 +62,7 @@ or `Bedrock`. Deprecated contracts should not be used.
 | L2ToL1MessagePasser           | 0x4200000000000000000000000000000000000016 | Bedrock    | No         | Yes     |
 | L2ERC721Bridge                | 0x4200000000000000000000000000000000000014 | Legacy     | No         | Yes     |
 | OptimismMintableERC721Factory | 0x4200000000000000000000000000000000000017 | Bedrock    | No         | Yes     |
-| ProxyAdmin                    | 0x4200000000000000000000000000000000000018 | Bedrock    | No         | No      |
+| ProxyAdmin                    | 0x4200000000000000000000000000000000000018 | Bedrock    | No         | Yes     |
 | BaseFeeVault                  | 0x4200000000000000000000000000000000000019 | Bedrock    | No         | Yes     |
 | L1FeeVault                    | 0x420000000000000000000000000000000000001a | Bedrock    | No         | Yes     |