Merge branch 'develop' into action-test-conflict-blocks

.changeset/weak-crabs-reflect.md

+---
+'minimum-balance-agent': patch
+---
+
+Created the Balance Monitoring package

.github/mergify.yml

 queue_rules:
   - name: default
-    speculative_checks: 3
     conditions: []
 
 pull_request_rules:
@@ -11,6 +10,7 @@ pull_request_rules:
         - "#approved-reviews-by>=1"
         - "#changes-requested-reviews-by=0"
         - "label!=do-not-merge"
+        - "label!=multiple-reviewers"
         - "label!=mergify-ignore"
         - "base=develop"
         - or:

integration-tests/contracts/FakeOptimismMintableERC721.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.9;
 
 import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
-import { OptimismMintableERC721 } from "@eth-optimism/contracts-periphery/contracts/universal/op-erc721/OptimismMintableERC721.sol";
+import { OptimismMintableERC721 } from "@eth-optimism/contracts-bedrock/contracts/universal/OptimismMintableERC721.sol";
 import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
 contract FakeOptimismMintableERC721 is OptimismMintableERC721 {

integration-tests/package.json

@@ -30,6 +30,7 @@
   "devDependencies": {
     "@babel/eslint-parser": "^7.5.4",
     "@eth-optimism/contracts": "^0.5.39",
+    "@eth-optimism/contracts-bedrock": "0.11.0",
     "@eth-optimism/contracts-periphery": "^1.0.4",
     "@eth-optimism/core-utils": "0.12.0",
     "@eth-optimism/sdk": "1.8.0",

integration-tests/test/nft-bridge.spec.ts

@@ -4,10 +4,10 @@ import { ethers } from 'hardhat'
 import { getChainId } from '@eth-optimism/core-utils'
 import { predeploys } from '@eth-optimism/contracts'
 import Artifact__TestERC721 from '@eth-optimism/contracts-periphery/artifacts/contracts/testing/helpers/TestERC721.sol/TestERC721.json'
-import Artifact__L1ERC721Bridge from '@eth-optimism/contracts-periphery/artifacts/contracts/L1/L1ERC721Bridge.sol/L1ERC721Bridge.json'
-import Artifact__L2ERC721Bridge from '@eth-optimism/contracts-periphery/artifacts/contracts/L2/L2ERC721Bridge.sol/L2ERC721Bridge.json'
-import Artifact__OptimismMintableERC721Factory from '@eth-optimism/contracts-periphery/artifacts/contracts/universal/op-erc721/OptimismMintableERC721Factory.sol/OptimismMintableERC721Factory.json'
-import Artifact__OptimismMintableERC721 from '@eth-optimism/contracts-periphery/artifacts/contracts/universal/op-erc721/OptimismMintableERC721.sol/OptimismMintableERC721.json'
+import Artifact__L1ERC721Bridge from '@eth-optimism/contracts-bedrock/artifacts/contracts/L1/L1ERC721Bridge.sol/L1ERC721Bridge.json'
+import Artifact__L2ERC721Bridge from '@eth-optimism/contracts-bedrock/artifacts/contracts/L2/L2ERC721Bridge.sol/L2ERC721Bridge.json'
+import Artifact__OptimismMintableERC721Factory from '@eth-optimism/contracts-bedrock/artifacts/contracts/universal/OptimismMintableERC721Factory.sol/OptimismMintableERC721Factory.json'
+import Artifact__OptimismMintableERC721 from '@eth-optimism/contracts-bedrock/artifacts/contracts/universal/OptimismMintableERC721.sol/OptimismMintableERC721.json'
 
 /* Imports: Internal */
 import { expect } from './shared/setup'

op-chain-ops/genesis/layer_one.go

@@ -82,9 +82,10 @@ func BuildL1DeveloperGenesis(config *DeployConfig) (*core.Genesis, error) {
 		uint642Big(config.GasPriceOracleScalar),
 		config.BatchSenderAddress.Hash(),
 		gasLimit,
+		config.P2PSequencerAddress,
 	)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("cannot abi encode initialize for SystemConfig: %w", err)
 	}
 	if _, err := upgradeProxy(
 		backend,
@@ -106,7 +107,7 @@ func BuildL1DeveloperGenesis(config *DeployConfig) (*core.Genesis, error) {
 		uint642Big(uint64(config.L1GenesisBlockTimestamp)),
 	)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("cannot abi encode initialize for L2OutputOracle: %w", err)
 	}
 	if _, err := upgradeProxy(
 		backend,
@@ -124,7 +125,7 @@ func BuildL1DeveloperGenesis(config *DeployConfig) (*core.Genesis, error) {
 	}
 	data, err = portalABI.Pack("initialize")
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("cannot abi encode initialize for OptimismPortal: %w", err)
 	}
 	if _, err := upgradeProxy(
 		backend,
@@ -144,7 +145,7 @@ func BuildL1DeveloperGenesis(config *DeployConfig) (*core.Genesis, error) {
 		config.FinalSystemOwner,
 	)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("cannot abi encode initialize for L1CrossDomainMessenger: %w", err)
 	}
 	if _, err := upgradeProxy(
 		backend,
@@ -268,6 +269,7 @@ func deployL1Contracts(config *DeployConfig, backend *backends.SimulatedBackend)
 				uint642Big(config.GasPriceOracleScalar),
 				config.BatchSenderAddress.Hash(), // left-padded 32 bytes value, version is zero anyway
 				gasLimit,
+				config.P2PSequencerAddress,
 			},
 		},
 		{
@@ -329,6 +331,7 @@ func l1Deployer(backend *backends.SimulatedBackend, opts *bind.TransactOpts, dep
 			deployment.Args[2].(*big.Int),
 			deployment.Args[3].(common.Hash),
 			deployment.Args[4].(uint64),
+			deployment.Args[5].(common.Address),
 		)
 	case "L2OutputOracle":
 		_, tx, _, err = bindings.DeployL2OutputOracle(
@@ -397,6 +400,10 @@ func l1Deployer(backend *backends.SimulatedBackend, opts *bind.TransactOpts, dep
 		}
 	}
 
+	if err != nil {
+		err = fmt.Errorf("cannot deploy %s: %w", deployment.Name, err)
+	}
+
 	return tx, err
 }
 

op-heartbeat/go.mod

@@ -6,6 +6,7 @@ require (
 	github.com/ethereum-optimism/optimism/op-node v0.10.1
 	github.com/ethereum-optimism/optimism/op-service v0.10.1
 	github.com/ethereum/go-ethereum v1.10.26
+	github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d
 	github.com/prometheus/client_golang v1.14.0
 	github.com/stretchr/testify v1.8.0
 	github.com/urfave/cli v1.22.10

op-heartbeat/go.sum

@@ -159,6 +159,7 @@ github.com/hashicorp/go-bexpr v0.1.11 h1:6DqdA/KBjurGby9yTY0bmkathya0lfwF2SeuubC
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d h1:dg1dEPuWpEqDnvIw251EVy4zlP8gWbsGj4BsUKCRpYs=
+github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
 github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao=
 github.com/holiman/uint256 v1.2.0 h1:gpSYcPLWGv4sG43I2mVLiDZCNDh/EpGjSk8tmtxitHM=
 github.com/huin/goupnp v1.0.3 h1:N8No57ls+MnjlB+JPiCVSOyy/ot7MJTqlo7rn+NYSqQ=

op-node/sources/batching.go

@@ -73,6 +73,7 @@ func (ibc *IterativeBatchCall[K, V, O]) Reset() {
 		scheduled <- r
 	}
 
+	atomic.StoreUint32(&ibc.completed, 0)
 	ibc.requestsValues = requestsValues
 	ibc.scheduled = scheduled
 	if len(ibc.requestsKeys) == 0 {

op-service/rpc/server.go

@@ -2,6 +2,7 @@ package rpc
 
 import (
 	"context"
+	"crypto/tls"
 	"encoding/json"
 	"fmt"
 	"net"
@@ -11,6 +12,7 @@ import (
 
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
+	optls "github.com/ethereum-optimism/optimism/op-service/tls"
 
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/node"
@@ -32,10 +34,19 @@ type Server struct {
 	httpRecorder   opmetrics.HTTPRecorder
 	httpServer     *http.Server
 	log            log.Logger
+	tls            *ServerTLSConfig
+	middlewares    []Middleware
+}
+
+type ServerTLSConfig struct {
+	Config    *tls.Config
+	CLIConfig *optls.CLIConfig // paths to certificate and key files
 }
 
 type ServerOption func(b *Server)
 
+type Middleware func(next http.Handler) http.Handler
+
 func WithAPIs(apis []rpc.API) ServerOption {
 	return func(b *Server) {
 		b.apis = apis
@@ -90,6 +101,22 @@ func WithLogger(lgr log.Logger) ServerOption {
 	}
 }
 
+// WithTLSConfig configures TLS for the RPC server
+// If this option is passed, the server will use ListenAndServeTLS
+func WithTLSConfig(tls *ServerTLSConfig) ServerOption {
+	return func(b *Server) {
+		b.tls = tls
+	}
+}
+
+// WithMiddleware adds an http.Handler to the rpc server handler stack
+// The added middleware is invoked directly before the RPC callback
+func WithMiddleware(middleware func(http.Handler) (hdlr http.Handler)) ServerOption {
+	return func(b *Server) {
+		b.middlewares = append(b.middlewares, middleware)
+	}
+}
+
 func NewServer(host string, port int, appVersion string, opts ...ServerOption) *Server {
 	endpoint := net.JoinHostPort(host, strconv.Itoa(port))
 	bs := &Server{
@@ -109,6 +136,9 @@ func NewServer(host string, port int, appVersion string, opts ...ServerOption) *
 	for _, opt := range opts {
 		opt(bs)
 	}
+	if bs.tls != nil {
+		bs.httpServer.TLSConfig = bs.tls.Config
+	}
 	bs.AddAPI(rpc.API{
 		Namespace: "health",
 		Service: &healthzAPI{
@@ -132,16 +162,34 @@ func (b *Server) Start() error {
 		return fmt.Errorf("error registering APIs: %w", err)
 	}
 
-	nodeHdlr := node.NewHTTPHandlerStack(srv, b.corsHosts, b.vHosts, b.jwtSecret)
+	// rpc middleware
+	var nodeHdlr http.Handler = srv
+	for _, middleware := range b.middlewares {
+		nodeHdlr = middleware(nodeHdlr)
+	}
+	nodeHdlr = node.NewHTTPHandlerStack(nodeHdlr, b.corsHosts, b.vHosts, b.jwtSecret)
+
 	mux := http.NewServeMux()
 	mux.Handle(b.rpcPath, nodeHdlr)
 	mux.Handle(b.healthzPath, b.healthzHandler)
-	metricsMW := oplog.NewLoggingMiddleware(b.log, opmetrics.NewHTTPRecordingMiddleware(b.httpRecorder, mux))
-	b.httpServer.Handler = metricsMW
+
+	// http middleware
+	var handler http.Handler = mux
+	handler = optls.NewPeerTLSMiddleware(handler)
+	handler = opmetrics.NewHTTPRecordingMiddleware(b.httpRecorder, handler)
+	handler = oplog.NewLoggingMiddleware(b.log, handler)
+	b.httpServer.Handler = handler
+
 	errCh := make(chan error, 1)
 	go func() {
-		if err := b.httpServer.ListenAndServe(); err != nil {
-			errCh <- err
+		if b.tls != nil {
+			if err := b.httpServer.ListenAndServeTLS(b.tls.CLIConfig.TLSCert, b.tls.CLIConfig.TLSKey); err != nil {
+				errCh <- err
+			}
+		} else {
+			if err := b.httpServer.ListenAndServe(); err != nil {
+				errCh <- err
+			}
 		}
 	}()
 

op-service/tls/cli.go

+// This file contains CLI and env TLS configurations that can be used by clients or servers
+package tls
+
+import (
+	"errors"
+
+	"github.com/urfave/cli"
+
+	opservice "github.com/ethereum-optimism/optimism/op-service"
+)
+
+const (
+	TLSCaCertFlagName = "tls.ca"
+	TLSCertFlagName   = "tls.cert"
+	TLSKeyFlagName    = "tls.key"
+)
+
+func CLIFlags(envPrefix string) []cli.Flag {
+	return []cli.Flag{
+		cli.StringFlag{
+			Name:   TLSCaCertFlagName,
+			Usage:  "tls ca cert path",
+			Value:  "tls/ca.crt",
+			EnvVar: opservice.PrefixEnvVar(envPrefix, "TLS_CA"),
+		},
+		cli.StringFlag{
+			Name:   TLSCertFlagName,
+			Usage:  "tls cert path",
+			Value:  "tls/tls.crt",
+			EnvVar: opservice.PrefixEnvVar(envPrefix, "TLS_CERT"),
+		},
+		cli.StringFlag{
+			Name:   TLSKeyFlagName,
+			Usage:  "tls key",
+			Value:  "tls/tls.key",
+			EnvVar: opservice.PrefixEnvVar(envPrefix, "TLS_KEY"),
+		},
+	}
+}
+
+type CLIConfig struct {
+	TLSCaCert string
+	TLSCert   string
+	TLSKey    string
+}
+
+func (c CLIConfig) Check() error {
+	if c.TLSEnabled() && (c.TLSCaCert == "" || c.TLSCert == "" || c.TLSKey == "") {
+		return errors.New("all tls flags must be set if at least one is set")
+	}
+
+	return nil
+}
+
+func (c CLIConfig) TLSEnabled() bool {
+	return !(c.TLSCaCert == "" && c.TLSCert == "" && c.TLSKey == "")
+}
+
+func ReadCLIConfig(ctx *cli.Context) CLIConfig {
+	return CLIConfig{
+		TLSCaCert: ctx.GlobalString(TLSCaCertFlagName),
+		TLSCert:   ctx.GlobalString(TLSCertFlagName),
+		TLSKey:    ctx.GlobalString(TLSKeyFlagName),
+	}
+}

op-service/tls/tlsinfo.go

+package tls
+
+import (
+	"context"
+	"crypto/x509"
+	"net/http"
+)
+
+// PeerTLSInfo contains request-scoped peer certificate data
+// It can be used by downstream http.Handlers to authorize access for TLS-authenticated clients
+type PeerTLSInfo struct {
+	LeafCertificate *x509.Certificate
+}
+
+type peerTLSInfoContextKey struct{}
+
+// NewPeerTLSMiddleware returns an http.Handler that extracts the peer's certificate data into PeerTLSInfo and attaches it to the request-scoped context.
+// PeerTLSInfo will only be populated if the http.Server is listening with ListenAndServeTLS
+// This is useful for ethereum-go/rpc endpoints because the http.Request object isn't accessible in the registered service.
+func NewPeerTLSMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		peerTlsInfo := PeerTLSInfo{}
+		if r.TLS != nil && len(r.TLS.PeerCertificates) > 0 {
+			peerTlsInfo.LeafCertificate = r.TLS.PeerCertificates[0]
+		}
+		ctx := context.WithValue(r.Context(), peerTLSInfoContextKey{}, peerTlsInfo)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+// PeerTLSInfoFromContext extracts PeerTLSInfo from the context
+// Result will only be populated if NewPeerTLSMiddleware has been added to the handler stack.
+func PeerTLSInfoFromContext(ctx context.Context) PeerTLSInfo {
+	info, _ := ctx.Value(peerTLSInfoContextKey{}).(PeerTLSInfo)
+	return info
+}

ops/check-changed/.gitignore

+venv
\ No newline at end of file

ops/check-changed/main.py

+import logging.config
+import os
+import re
+import subprocess
+import sys
+
+from github import Github
+
+WHITELISTED_BRANCHES = {
+    'master',
+    'develop'
+}
+
+LOGGING_CONFIG = {
+    'version': 1,
+    'disable_existing_loggers': True,
+    'formatters': {
+        'standard': {
+            'format': '%(asctime)s [%(levelname)s]: %(message)s'
+        },
+    },
+    'handlers': {
+        'default': {
+            'level': 'INFO',
+            'formatter': 'standard',
+            'class': 'logging.StreamHandler',
+            'stream': 'ext://sys.stderr'
+        },
+    },
+    'loggers': {
+        '': {
+            'handlers': ['default'],
+            'level': 'INFO',
+            'propagate': False
+        },
+    }
+}
+
+logging.config.dictConfig(LOGGING_CONFIG)
+log = logging.getLogger(__name__)
+
+
+def main():
+    patterns = sys.argv[1].split(',')
+    patterns.append(r'^\.circleci/\.*')
+
+    fp = os.path.realpath(__file__)
+    monorepo_path = os.path.realpath(os.path.join(fp, '..', '..'))
+
+    log.info('Discovered monorepo path: %s', monorepo_path)
+    current_branch = git_cmd('rev-parse --abbrev-ref HEAD', monorepo_path)
+    log.info('Current branch: %s', current_branch)
+
+    if current_branch in WHITELISTED_BRANCHES:
+        log.info('Current branch %s is whitelisted, triggering build', current_branch)
+        exit_build()
+
+    pr_urls = os.getenv('CIRCLE_PULL_REQUESTS', None)
+    pr_urls = pr_urls.split(',') if pr_urls else []
+    if len(pr_urls) == 0:
+        log.info('Not a PR build, skipping build')
+        exit_nobuild()
+    if len(pr_urls) > 1:
+        log.warning('Multiple PR URLs found, choosing the first one. PRs found:')
+        for url in pr_urls:
+            log.warning(url)
+
+    gh_token = os.getenv('GITHUB_ACCESS_TOKEN')
+    if gh_token is None:
+        log.info('No GitHub access token found - likely a fork. Triggering build')
+        exit_build()
+
+    g = Github(gh_token)
+    try:
+        g.get_user()
+        repo = g.get_repo(os.getenv('CIRCLE_PROJECT_USERNAME') + '/' + os.getenv('CIRCLE_PROJECT_REPONAME'))
+    except Exception:
+        log.exception('Failed to get repo from GitHub')
+        exit_build()
+
+    pr = repo.get_pull(int(pr_urls[0].split('/')[-1]))
+    log.info('Found PR: %s', pr.url)
+
+    base_sha = pr.base.sha
+    head_sha = pr.head.sha
+
+    diffs = git_cmd('diff --name-only {}...{}'.format(base_sha, head_sha), monorepo_path).split('\n')
+    log.info('Found diff. Checking for matches...')
+    for diff in diffs:
+        if match_path(diff, patterns):
+            log.info('Match found, triggering build')
+            exit_build()
+        else:
+            log.info('❌ no match found on %s', diff)
+
+    log.info('No matches found, skipping build')
+    exit_nobuild()
+
+
+def git_cmd(cmd, cwd):
+    return subprocess.check_output(['git'] + cmd.split(' '), cwd=cwd).decode('utf-8').strip()
+
+
+def match_path(path, patterns):
+    for pattern in patterns:
+        if re.search(pattern, path):
+            log.info('✅ match found on %s: %s', path, pattern)
+            return True
+    return False
+
+
+def exit_build():
+    sys.exit(0)
+
+
+def exit_nobuild():
+    subprocess.check_call(['circleci', 'step', 'halt'])
+    sys.exit(0)
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except Exception:
+        log.exception('Unhandled exception, triggering build')
+        exit_build()

ops/check-changed/requirements.txt

+certifi==2022.12.7
+cffi==1.15.1
+charset-normalizer==2.1.1
+Deprecated==1.2.13
+idna==3.4
+pycparser==2.21
+PyGithub==1.57
+PyJWT==2.6.0
+PyNaCl==1.5.0
+requests==2.28.1
+urllib3==1.26.13
+wrapt==1.14.1

packages/balance-monitor/.env.example

+CHAINID=
+L1_RPC_URL=
+
+SEQUENCER_ADDRESS=
+SEQUENCER_WARNING_THRESHOLD=
+SEQUENCER_DANGER_THRESHOLD=
+
+PROPOSER_ADDRESS=
+PROPOSER_WARNING_THRESHOLD=
+PROPOSER_DANGER_THRESHOLD=
+

packages/balance-monitor/.eslintignore

+node_modules
+

packages/balance-monitor/.eslintrc.js

+module.exports = {
+  extends: '../../.eslintrc.js',
+  ignorePatterns: ['src/contract-artifacts.ts'],
+}

packages/balance-monitor/.gitignore

+node_modules
+dist
+forta.config.json

packages/balance-monitor/.prettierignore

+node_modules

packages/balance-monitor/.prettierrc.js

+module.exports = {
+  ...require('../../.prettierrc.js'),
+}

packages/balance-monitor/README.md

+# Minimum Balance Agent
+
+## Description
+
+A forta agent which detects when a specified account balance is below 0.5 ETH
+
+## Running
+
+1. Copy `.env.example` into `.env` and set the values as desired.
+2. `yarn run start:prod`
+
+
+## Alerts
+
+- `OPTIMISM-BALANCE-WARNING-[ACCOUNT_NAME]`
+  - `ACCOUNT_NAME` is either `SEQUENCER` or `PROPOSER`
+  - Fired when the specified account balance is below the configured WARNING threshold
+  - Severity is always set to "info"
+  - Type is always set to "info"
+  - Metadata "balance" field contains amount of wei in account
+
+- `OPTIMISM-BALANCE-DANGER-[ACCOUNT_NAME]`
+  - Fired when the specified account balance is below the configured DANGER threshold
+  - Severity is always set to "high"
+  - Type is always set to "info"
+  - Metadata "balance" field contains amount of wei in account

packages/balance-monitor/package.json

+{
+  "name": "minimum-balance-agent",
+  "version": "0.0.1",
+  "description": "Forta Agent that reports whether certain accounts have fallen below some balance",
+  "scripts": {
+    "build": "echo 'todo'",
+    "start": "yarn run start:dev",
+    "start:dev": "nodemon --watch src --watch forta.config.json -e js,ts,json  --exec 'yarn run build && forta-agent run'",
+    "start:prod": "forta-agent run --prod",
+    "tx": "yarn run build && forta-agent run --tx",
+    "block": "yarn run build && forta-agent run --block",
+    "range": "yarn run build && forta-agent run --range",
+    "test": "echo 'todo'"
+  },
+  "dependencies": {
+    "ethers": "^5.7.2",
+    "forta-agent": "^0.1.1"
+  },
+  "devDependencies": {
+    "@types/nodemon": "^1.19.0",
+    "nodemon": "^2.0.8",
+    "typescript": "^4.3.4"
+  }
+}

packages/balance-monitor/tsconfig.json

+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist"
+  },
+  "include": [
+    "src/**/*"
+  ]
+}

packages/contracts-bedrock/.gas-snapshot

@@ -379,7 +379,8 @@ SequencerFeeVault_Test:test_minWithdrawalAmount_succeeds() (gas: 5420)
 SequencerFeeVault_Test:test_receive_succeeds() (gas: 17336)
 SequencerFeeVault_Test:test_withdraw_notEnough_reverts() (gas: 9309)
 SequencerFeeVault_Test:test_withdraw_succeeds() (gas: 159816)
-SystemConfig_Initialize_TestFail:test_initialize_lowGasLimit_reverts() (gas: 61707)
-SystemConfig_Setters_TestFail:test_setBatcherHash_notOwner_reverts() (gas: 10501)
-SystemConfig_Setters_TestFail:test_setGasConfig_notOwner_reverts() (gas: 10576)
-SystemConfig_Setters_TestFail:test_setGasLimit_notOwner_reverts() (gas: 10592)
+SystemConfig_Initialize_TestFail:test_initialize_lowGasLimit_reverts() (gas: 61952)
+SystemConfig_Setters_TestFail:test_setBatcherHash_notOwner_reverts() (gas: 10523)
+SystemConfig_Setters_TestFail:test_setGasConfig_notOwner_reverts() (gas: 10510)
+SystemConfig_Setters_TestFail:test_setGasLimit_notOwner_reverts() (gas: 10614)
+SystemConfig_Setters_TestFail:test_setUnsafeBlockSigner_notOwner_reverts() (gas: 10638)

packages/contracts-bedrock/.storage-layout

@@ -104,27 +104,29 @@
 ➡ contracts/L1/SystemConfig.sol:SystemConfig
 =======================
 
-+---------------+-------------+------+--------+-------+--------------------------------------------+
-| Name          | Type        | Slot | Offset | Bytes | Contract                                   |
-+==================================================================================================+
-| _initialized  | uint8       | 0    | 0      | 1     | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
-| _initializing | bool        | 0    | 1      | 1     | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
-| __gap         | uint256[50] | 1    | 0      | 1600  | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
-| _owner        | address     | 51   | 0      | 20    | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
-| __gap         | uint256[49] | 52   | 0      | 1568  | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
-| overhead      | uint256     | 101  | 0      | 32    | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
-| scalar        | uint256     | 102  | 0      | 32    | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
-| batcherHash   | bytes32     | 103  | 0      | 32    | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
-| gasLimit      | uint64      | 104  | 0      | 8     | contracts/L1/SystemConfig.sol:SystemConfig |
-+---------------+-------------+------+--------+-------+--------------------------------------------+
++-------------------+-------------+------+--------+-------+--------------------------------------------+
+| Name              | Type        | Slot | Offset | Bytes | Contract                                   |
++======================================================================================================+
+| _initialized      | uint8       | 0    | 0      | 1     | contracts/L1/SystemConfig.sol:SystemConfig |
+|-------------------+-------------+------+--------+-------+--------------------------------------------|
+| _initializing     | bool        | 0    | 1      | 1     | contracts/L1/SystemConfig.sol:SystemConfig |
+|-------------------+-------------+------+--------+-------+--------------------------------------------|
+| __gap             | uint256[50] | 1    | 0      | 1600  | contracts/L1/SystemConfig.sol:SystemConfig |
+|-------------------+-------------+------+--------+-------+--------------------------------------------|
+| _owner            | address     | 51   | 0      | 20    | contracts/L1/SystemConfig.sol:SystemConfig |
+|-------------------+-------------+------+--------+-------+--------------------------------------------|
+| __gap             | uint256[49] | 52   | 0      | 1568  | contracts/L1/SystemConfig.sol:SystemConfig |
+|-------------------+-------------+------+--------+-------+--------------------------------------------|
+| overhead          | uint256     | 101  | 0      | 32    | contracts/L1/SystemConfig.sol:SystemConfig |
+|-------------------+-------------+------+--------+-------+--------------------------------------------|
+| scalar            | uint256     | 102  | 0      | 32    | contracts/L1/SystemConfig.sol:SystemConfig |
+|-------------------+-------------+------+--------+-------+--------------------------------------------|
+| unsafeBlockSigner | address     | 103  | 0      | 20    | contracts/L1/SystemConfig.sol:SystemConfig |
+|-------------------+-------------+------+--------+-------+--------------------------------------------|
+| batcherHash       | bytes32     | 104  | 0      | 32    | contracts/L1/SystemConfig.sol:SystemConfig |
+|-------------------+-------------+------+--------+-------+--------------------------------------------|
+| gasLimit          | uint64      | 105  | 0      | 8     | contracts/L1/SystemConfig.sol:SystemConfig |
++-------------------+-------------+------+--------+-------+--------------------------------------------+
 
 =======================
 ➡ contracts/legacy/DeployerWhitelist.sol:DeployerWhitelist

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

@@ -16,14 +16,17 @@ contract SystemConfig is OwnableUpgradeable, Semver {
     /**
      * @notice Enum representing different types of updates.
      *
-     * @custom:value BATCHER    Represents an update to the batcher hash.
-     * @custom:value GAS_CONFIG Represents an update to txn fee config on L2.
-     * @custom:value GAS_LIMIT  Represents an update to gas limit on L2.
+     * @custom:value BATCHER              Represents an update to the batcher hash.
+     * @custom:value GAS_CONFIG           Represents an update to txn fee config on L2.
+     * @custom:value GAS_LIMIT            Represents an update to gas limit on L2.
+     * @custom:value UNSAFE_BLOCK_SIGNER  Represents an update to the signer key for unsafe
+     *                                    block distrubution.
      */
     enum UpdateType {
         BATCHER,
         GAS_CONFIG,
-        GAS_LIMIT
+        GAS_LIMIT,
+        UNSAFE_BLOCK_SIGNER
     }
 
     /**
@@ -48,6 +51,13 @@ contract SystemConfig is OwnableUpgradeable, Semver {
      */
     uint256 public scalar;
 
+    /**
+     * @notice Address corresponding to the key that can propagate unsafe blocks
+     *         across the p2p network. This value should not be tightly packed
+     *         into a storage slot with another value to make state proofs more simple.
+     */
+    address public unsafeBlockSigner;
+
     /**
      * @notice Identifier for the batcher. For version 1 of this configuration, this is represented
      *         as an address left-padded with zeros to 32 bytes.
@@ -82,9 +92,10 @@ contract SystemConfig is OwnableUpgradeable, Semver {
         uint256 _overhead,
         uint256 _scalar,
         bytes32 _batcherHash,
-        uint64 _gasLimit
+        uint64 _gasLimit,
+        address _unsafeBlockSigner
     ) Semver(1, 0, 0) {
-        initialize(_owner, _overhead, _scalar, _batcherHash, _gasLimit);
+        initialize(_owner, _overhead, _scalar, _batcherHash, _gasLimit, _unsafeBlockSigner);
     }
 
     /**
@@ -101,7 +112,8 @@ contract SystemConfig is OwnableUpgradeable, Semver {
         uint256 _overhead,
         uint256 _scalar,
         bytes32 _batcherHash,
-        uint64 _gasLimit
+        uint64 _gasLimit,
+        address _unsafeBlockSigner
     ) public initializer {
         require(_gasLimit >= MINIMUM_GAS_LIMIT, "SystemConfig: gas limit too low");
         __Ownable_init();
@@ -110,6 +122,7 @@ contract SystemConfig is OwnableUpgradeable, Semver {
         scalar = _scalar;
         batcherHash = _batcherHash;
         gasLimit = _gasLimit;
+        unsafeBlockSigner = _unsafeBlockSigner;
     }
 
     /**
@@ -139,6 +152,13 @@ contract SystemConfig is OwnableUpgradeable, Semver {
         emit ConfigUpdate(VERSION, UpdateType.GAS_CONFIG, data);
     }
 
+    function setUnsafeBlockSigner(address _unsafeBlockSigner) external onlyOwner {
+        unsafeBlockSigner = _unsafeBlockSigner;
+
+        bytes memory data = abi.encode(_unsafeBlockSigner);
+        emit ConfigUpdate(VERSION, UpdateType.UNSAFE_BLOCK_SIGNER, data);
+    }
+
     /**
      * @notice Updates the L2 gas limit.
      *

packages/contracts-bedrock/contracts/deployment/SystemDictator.sol

@@ -78,6 +78,7 @@ contract SystemDictator is OwnableUpgradeable {
         uint256 scalar;
         bytes32 batcherHash;
         uint64 gasLimit;
+        address unsafeBlockSigner;
     }
 
     /**
@@ -353,7 +354,8 @@ contract SystemDictator is OwnableUpgradeable {
                     config.systemConfigConfig.overhead,
                     config.systemConfigConfig.scalar,
                     config.systemConfigConfig.batcherHash,
-                    config.systemConfigConfig.gasLimit
+                    config.systemConfigConfig.gasLimit,
+                    config.systemConfigConfig.unsafeBlockSigner
                 )
             )
         );

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

@@ -13,7 +13,8 @@ contract SystemConfig_Init is CommonTest {
             _overhead: 2100,
             _scalar: 1000000,
             _batcherHash: bytes32(hex"abcd"),
-            _gasLimit: 9_000_000
+            _gasLimit: 9_000_000,
+            _unsafeBlockSigner: address(1)
         });
     }
 }
@@ -29,7 +30,8 @@ contract SystemConfig_Initialize_TestFail is CommonTest {
             _overhead: 0,
             _scalar: 0,
             _batcherHash: bytes32(hex""),
-            _gasLimit: MINIMUM_GAS_LIMIT - 1
+            _gasLimit: MINIMUM_GAS_LIMIT - 1,
+            _unsafeBlockSigner: address(1)
         });
     }
 }
@@ -49,6 +51,11 @@ contract SystemConfig_Setters_TestFail is SystemConfig_Init {
         vm.expectRevert("Ownable: caller is not the owner");
         sysConf.setGasLimit(0);
     }
+
+    function test_setUnsafeBlockSigner_notOwner_reverts() external {
+        vm.expectRevert("Ownable: caller is not the owner");
+        sysConf.setUnsafeBlockSigner(address(0x20));
+    }
 }
 
 contract SystemConfig_Setters_Test is SystemConfig_Init {
@@ -94,4 +101,17 @@ contract SystemConfig_Setters_Test is SystemConfig_Init {
         sysConf.setGasLimit(newGasLimit);
         assertEq(sysConf.gasLimit(), newGasLimit);
     }
+
+    function testFuzz_setUnsafeBlockSigner_succeeds(address newUnsafeSigner) external {
+        vm.expectEmit(true, true, true, true);
+        emit ConfigUpdate(
+            0,
+            SystemConfig.UpdateType.UNSAFE_BLOCK_SIGNER,
+            abi.encode(newUnsafeSigner)
+        );
+
+        vm.prank(sysConf.owner());
+        sysConf.setUnsafeBlockSigner(newUnsafeSigner);
+        assertEq(sysConf.unsafeBlockSigner(), newUnsafeSigner);
+    }
 }

packages/contracts-bedrock/deploy/017-SystemConfigImpl.ts

@@ -17,6 +17,7 @@ const deployFn: DeployFunction = async (hre) => {
       hre.deployConfig.gasPriceOracleScalar,
       batcherHash,
       hre.deployConfig.l2GenesisBlockGasLimit,
+      hre.deployConfig.p2pSequencerAddress,
     ],
     postDeployAction: async (contract) => {
       await assertContractVariable(
@@ -35,6 +36,11 @@ const deployFn: DeployFunction = async (hre) => {
         hre.deployConfig.gasPriceOracleScalar
       )
       await assertContractVariable(contract, 'batcherHash', batcherHash)
+      await assertContractVariable(
+        contract,
+        'unsafeBlockSigner',
+        hre.deployConfig.p2pSequencerAddress
+      )
     },
   })
 }

packages/contracts-bedrock/deploy/019-SystemDictatorInit.ts

@@ -99,6 +99,7 @@ const deployFn: DeployFunction = async (hre) => {
         32
       ),
       gasLimit: hre.deployConfig.l2GenesisBlockGasLimit,
+      unsafeBlockSigner: hre.deployConfig.p2pSequencerAddress,
     },
   }
 

packages/contracts-bedrock/deploy/020-SystemDictatorSteps.ts

@@ -31,6 +31,7 @@ const deployFn: DeployFunction = async (hre) => {
     L1ERC721BridgeProxy,
     L1ERC721BridgeProxyWithSigner,
     L1ERC721Bridge,
+    SystemConfigProxy,
   ] = await getContractsFromArtifacts(hre, [
     {
       name: 'SystemDictatorProxy',
@@ -89,6 +90,11 @@ const deployFn: DeployFunction = async (hre) => {
       iface: 'L1ERC721Bridge',
       signerOrProvider: deployer,
     },
+    {
+      name: 'SystemConfigProxy',
+      iface: 'SystemConfig',
+      signerOrProvider: deployer,
+    },
   ])
 
   // If we have the key for the controller then we don't need to wait for external txns.
@@ -498,6 +504,40 @@ const deployFn: DeployFunction = async (hre) => {
         'messenger',
         L1CrossDomainMessenger.address
       )
+
+      // Check the SystemConfig was initialized properly.
+      await assertContractVariable(
+        SystemConfigProxy,
+        'owner',
+        hre.deployConfig.finalSystemOwner
+      )
+
+      await assertContractVariable(
+        SystemConfigProxy,
+        'overhead',
+        hre.deployConfig.gasPriceOracleOverhead
+      )
+
+      await assertContractVariable(
+        SystemConfigProxy,
+        'scalar',
+        hre.deployConfig.gasPriceOracleScalar
+      )
+
+      await assertContractVariable(
+        SystemConfigProxy,
+        'batcherHash',
+        ethers.utils.hexZeroPad(
+          hre.deployConfig.batchSenderAddress.toLowerCase(),
+          32
+        )
+      )
+
+      await assertContractVariable(
+        SystemConfigProxy,
+        'gasLimit',
+        hre.deployConfig.l2GenesisBlockGasLimit
+      )
     },
   })
 

packages/contracts-periphery/contracts/L1/L1ERC721Bridge.sol

-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.15;
-
-import { ERC721Bridge } from "../universal/op-erc721/ERC721Bridge.sol";
-import { IERC721 } from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
-import { L2ERC721Bridge } from "../L2/L2ERC721Bridge.sol";
-import { Semver } from "@eth-optimism/contracts-bedrock/contracts/universal/Semver.sol";
-
-/**
- * @title L1ERC721Bridge
- * @notice The L1 ERC721 bridge is a contract which works together with the L2 ERC721 bridge to
- *         make it possible to transfer ERC721 tokens from Ethereum to Optimism. This contract
- *         acts as an escrow for ERC721 tokens deposited into L2.
- */
-contract L1ERC721Bridge is ERC721Bridge, Semver {
-    /**
-     * @notice Mapping of L1 token to L2 token to ID to boolean, indicating if the given L1 token
-     *         by ID was deposited for a given L2 token.
-     */
-    mapping(address => mapping(address => mapping(uint256 => bool))) public deposits;
-
-    /**
-     * @custom:semver 1.0.0
-     *
-     * @param _messenger   Address of the CrossDomainMessenger on this network.
-     * @param _otherBridge Address of the ERC721 bridge on the other network.
-     */
-    constructor(address _messenger, address _otherBridge)
-        Semver(1, 0, 0)
-        ERC721Bridge(_messenger, _otherBridge)
-    {}
-
-    /*************************
-     * Cross-chain Functions *
-     *************************/
-
-    /**
-     * @notice Completes an ERC721 bridge from the other domain and sends the ERC721 token to the
-     *         recipient on this domain.
-     *
-     * @param _localToken  Address of the ERC721 token on this domain.
-     * @param _remoteToken Address of the ERC721 token on the other domain.
-     * @param _from        Address that triggered the bridge on the other domain.
-     * @param _to          Address to receive the token on this domain.
-     * @param _tokenId     ID of the token being deposited.
-     * @param _extraData   Optional data to forward to L2. Data supplied here will not be used to
-     *                     execute any code on L2 and is only emitted as extra data for the
-     *                     convenience of off-chain tooling.
-     */
-    function finalizeBridgeERC721(
-        address _localToken,
-        address _remoteToken,
-        address _from,
-        address _to,
-        uint256 _tokenId,
-        bytes calldata _extraData
-    ) external onlyOtherBridge {
-        require(_localToken != address(this), "L1ERC721Bridge: local token cannot be self");
-
-        // Checks that the L1/L2 NFT pair has a token ID that is escrowed in the L1 Bridge.
-        require(
-            deposits[_localToken][_remoteToken][_tokenId] == true,
-            "L1ERC721Bridge: Token ID is not escrowed in the L1 Bridge"
-        );
-
-        // Mark that the token ID for this L1/L2 token pair is no longer escrowed in the L1
-        // Bridge.
-        deposits[_localToken][_remoteToken][_tokenId] = false;
-
-        // When a withdrawal is finalized on L1, the L1 Bridge transfers the NFT to the
-        // withdrawer.
-        IERC721(_localToken).safeTransferFrom(address(this), _to, _tokenId);
-
-        // slither-disable-next-line reentrancy-events
-        emit ERC721BridgeFinalized(_localToken, _remoteToken, _from, _to, _tokenId, _extraData);
-    }
-
-    /**
-     * @inheritdoc ERC721Bridge
-     */
-    function _initiateBridgeERC721(
-        address _localToken,
-        address _remoteToken,
-        address _from,
-        address _to,
-        uint256 _tokenId,
-        uint32 _minGasLimit,
-        bytes calldata _extraData
-    ) internal override {
-        require(_remoteToken != address(0), "ERC721Bridge: remote token cannot be address(0)");
-
-        // Construct calldata for _l2Token.finalizeBridgeERC721(_to, _tokenId)
-        bytes memory message = abi.encodeWithSelector(
-            L2ERC721Bridge.finalizeBridgeERC721.selector,
-            _remoteToken,
-            _localToken,
-            _from,
-            _to,
-            _tokenId,
-            _extraData
-        );
-
-        // Lock token into bridge
-        deposits[_localToken][_remoteToken][_tokenId] = true;
-        IERC721(_localToken).transferFrom(_from, address(this), _tokenId);
-
-        // Send calldata into L2
-        messenger.sendMessage(otherBridge, message, _minGasLimit);
-        emit ERC721BridgeInitiated(_localToken, _remoteToken, _from, _to, _tokenId, _extraData);
-    }
-}

packages/contracts-periphery/contracts/L2/L2ERC721Bridge.sol

-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.15;
-
-import { ERC721Bridge } from "../universal/op-erc721/ERC721Bridge.sol";
-import { ERC165Checker } from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
-import { L1ERC721Bridge } from "../L1/L1ERC721Bridge.sol";
-import { IOptimismMintableERC721 } from "../universal/op-erc721/IOptimismMintableERC721.sol";
-import { Semver } from "@eth-optimism/contracts-bedrock/contracts/universal/Semver.sol";
-
-/**
- * @title L2ERC721Bridge
- * @notice The L2 ERC721 bridge is a contract which works together with the L1 ERC721 bridge to
- *         make it possible to transfer ERC721 tokens from Ethereum to Optimism. This contract
- *         acts as a minter for new tokens when it hears about deposits into the L1 ERC721 bridge.
- *         This contract also acts as a burner for tokens being withdrawn.
- *         **WARNING**: Do not bridge an ERC721 that was originally deployed on Optimism. This
- *         bridge ONLY supports ERC721s originally deployed on Ethereum. Users will need to
- *         wait for the one-week challenge period to elapse before their Optimism-native NFT
- *         can be refunded on L2.
- */
-contract L2ERC721Bridge is ERC721Bridge, Semver {
-    /**
-     * @custom:semver 1.0.0
-     *
-     * @param _messenger   Address of the CrossDomainMessenger on this network.
-     * @param _otherBridge Address of the ERC721 bridge on the other network.
-     */
-    constructor(address _messenger, address _otherBridge)
-        Semver(1, 0, 0)
-        ERC721Bridge(_messenger, _otherBridge)
-    {}
-
-    /**
-     * @notice Completes an ERC721 bridge from the other domain and sends the ERC721 token to the
-     *         recipient on this domain.
-     *
-     * @param _localToken  Address of the ERC721 token on this domain.
-     * @param _remoteToken Address of the ERC721 token on the other domain.
-     * @param _from        Address that triggered the bridge on the other domain.
-     * @param _to          Address to receive the token on this domain.
-     * @param _tokenId     ID of the token being deposited.
-     * @param _extraData   Optional data to forward to L1. Data supplied here will not be used to
-     *                     execute any code on L1 and is only emitted as extra data for the
-     *                     convenience of off-chain tooling.
-     */
-    function finalizeBridgeERC721(
-        address _localToken,
-        address _remoteToken,
-        address _from,
-        address _to,
-        uint256 _tokenId,
-        bytes calldata _extraData
-    ) external onlyOtherBridge {
-        require(_localToken != address(this), "L2ERC721Bridge: local token cannot be self");
-
-        // Note that supportsInterface makes a callback to the _localToken address which is user
-        // provided.
-        require(
-            ERC165Checker.supportsInterface(_localToken, type(IOptimismMintableERC721).interfaceId),
-            "L2ERC721Bridge: local token interface is not compliant"
-        );
-
-        require(
-            _remoteToken == IOptimismMintableERC721(_localToken).remoteToken(),
-            "L2ERC721Bridge: wrong remote token for Optimism Mintable ERC721 local token"
-        );
-
-        // When a deposit is finalized, we give the NFT with the same tokenId to the account
-        // on L2. Note that safeMint makes a callback to the _to address which is user provided.
-        IOptimismMintableERC721(_localToken).safeMint(_to, _tokenId);
-
-        // slither-disable-next-line reentrancy-events
-        emit ERC721BridgeFinalized(_localToken, _remoteToken, _from, _to, _tokenId, _extraData);
-    }
-
-    /**
-     * @inheritdoc ERC721Bridge
-     */
-    function _initiateBridgeERC721(
-        address _localToken,
-        address _remoteToken,
-        address _from,
-        address _to,
-        uint256 _tokenId,
-        uint32 _minGasLimit,
-        bytes calldata _extraData
-    ) internal override {
-        require(_remoteToken != address(0), "ERC721Bridge: remote token cannot be address(0)");
-
-        // Check that the withdrawal is being initiated by the NFT owner
-        require(
-            _from == IOptimismMintableERC721(_localToken).ownerOf(_tokenId),
-            "Withdrawal is not being initiated by NFT owner"
-        );
-
-        // Construct calldata for l1ERC721Bridge.finalizeBridgeERC721(_to, _tokenId)
-        // slither-disable-next-line reentrancy-events
-        address remoteToken = IOptimismMintableERC721(_localToken).remoteToken();
-        require(
-            remoteToken == _remoteToken,
-            "L2ERC721Bridge: remote token does not match given value"
-        );
-
-        // When a withdrawal is initiated, we burn the withdrawer's NFT to prevent subsequent L2
-        // usage
-        // slither-disable-next-line reentrancy-events
-        IOptimismMintableERC721(_localToken).burn(_from, _tokenId);
-
-        bytes memory message = abi.encodeWithSelector(
-            L1ERC721Bridge.finalizeBridgeERC721.selector,
-            remoteToken,
-            _localToken,
-            _from,
-            _to,
-            _tokenId,
-            _extraData
-        );
-
-        // Send message to L1 bridge
-        // slither-disable-next-line reentrancy-events
-        messenger.sendMessage(otherBridge, message, _minGasLimit);
-
-        // slither-disable-next-line reentrancy-events
-        emit ERC721BridgeInitiated(_localToken, remoteToken, _from, _to, _tokenId, _extraData);
-    }
-}

packages/contracts-periphery/contracts/universal/op-erc721/ERC721Bridge.sol

-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.15;
-
-import {
-    CrossDomainMessenger
-} from "@eth-optimism/contracts-bedrock/contracts/universal/CrossDomainMessenger.sol";
-import { Address } from "@openzeppelin/contracts/utils/Address.sol";
-
-/**
- * @title ERC721Bridge
- * @notice ERC721Bridge is a base contract for the L1 and L2 ERC721 bridges.
- */
-abstract contract ERC721Bridge {
-    /**
-     * @notice Emitted when an ERC721 bridge to the other network is initiated.
-     *
-     * @param localToken  Address of the token on this domain.
-     * @param remoteToken Address of the token on the remote domain.
-     * @param from        Address that initiated bridging action.
-     * @param to          Address to receive the token.
-     * @param tokenId     ID of the specific token deposited.
-     * @param extraData   Extra data for use on the client-side.
-     */
-    event ERC721BridgeInitiated(
-        address indexed localToken,
-        address indexed remoteToken,
-        address indexed from,
-        address to,
-        uint256 tokenId,
-        bytes extraData
-    );
-
-    /**
-     * @notice Emitted when an ERC721 bridge from the other network is finalized.
-     *
-     * @param localToken  Address of the token on this domain.
-     * @param remoteToken Address of the token on the remote domain.
-     * @param from        Address that initiated bridging action.
-     * @param to          Address to receive the token.
-     * @param tokenId     ID of the specific token deposited.
-     * @param extraData   Extra data for use on the client-side.
-     */
-    event ERC721BridgeFinalized(
-        address indexed localToken,
-        address indexed remoteToken,
-        address indexed from,
-        address to,
-        uint256 tokenId,
-        bytes extraData
-    );
-
-    /**
-     * @notice Messenger contract on this domain.
-     */
-    CrossDomainMessenger public immutable messenger;
-
-    /**
-     * @notice Address of the bridge on the other network.
-     */
-    address public immutable otherBridge;
-
-    /**
-     * @notice Reserve extra slots (to a total of 50) in the storage layout for future upgrades.
-     */
-    uint256[49] private __gap;
-
-    /**
-     * @notice Ensures that the caller is a cross-chain message from the other bridge.
-     */
-    modifier onlyOtherBridge() {
-        require(
-            msg.sender == address(messenger) && messenger.xDomainMessageSender() == otherBridge,
-            "ERC721Bridge: function can only be called from the other bridge"
-        );
-        _;
-    }
-
-    /**
-     * @param _messenger   Address of the CrossDomainMessenger on this network.
-     * @param _otherBridge Address of the ERC721 bridge on the other network.
-     */
-    constructor(address _messenger, address _otherBridge) {
-        require(_messenger != address(0), "ERC721Bridge: messenger cannot be address(0)");
-        require(_otherBridge != address(0), "ERC721Bridge: other bridge cannot be address(0)");
-
-        messenger = CrossDomainMessenger(_messenger);
-        otherBridge = _otherBridge;
-    }
-
-    /**
-     * @notice Initiates a bridge of an NFT to the caller's account on the other chain. Note that
-     *         this function can only be called by EOAs. Smart contract wallets should use the
-     *         `bridgeERC721To` function after ensuring that the recipient address on the remote
-     *         chain exists. Also note that the current owner of the token on this chain must
-     *         approve this contract to operate the NFT before it can be bridged.
-     *         **WARNING**: Do not bridge an ERC721 that was originally deployed on Optimism. This
-     *         bridge only supports ERC721s originally deployed on Ethereum. Users will need to
-     *         wait for the one-week challenge period to elapse before their Optimism-native NFT
-     *         can be refunded on L2.
-     *
-     * @param _localToken  Address of the ERC721 on this domain.
-     * @param _remoteToken Address of the ERC721 on the remote domain.
-     * @param _tokenId     Token ID to bridge.
-     * @param _minGasLimit Minimum gas limit for the bridge message on the other domain.
-     * @param _extraData   Optional data to forward to the other chain. Data supplied here will not
-     *                     be used to execute any code on the other chain and is only emitted as
-     *                     extra data for the convenience of off-chain tooling.
-     */
-    function bridgeERC721(
-        address _localToken,
-        address _remoteToken,
-        uint256 _tokenId,
-        uint32 _minGasLimit,
-        bytes calldata _extraData
-    ) external {
-        // Modifier requiring sender to be EOA. This prevents against a user error that would occur
-        // if the sender is a smart contract wallet that has a different address on the remote chain
-        // (or doesn't have an address on the remote chain at all). The user would fail to receive
-        // the NFT if they use this function because it sends the NFT to the same address as the
-        // caller. This check could be bypassed by a malicious contract via initcode, but it takes
-        // care of the user error we want to avoid.
-        require(!Address.isContract(msg.sender), "ERC721Bridge: account is not externally owned");
-
-        _initiateBridgeERC721(
-            _localToken,
-            _remoteToken,
-            msg.sender,
-            msg.sender,
-            _tokenId,
-            _minGasLimit,
-            _extraData
-        );
-    }
-
-    /**
-     * @notice Initiates a bridge of an NFT to some recipient's account on the other chain. Note
-     *         that the current owner of the token on this chain must approve this contract to
-     *         operate the NFT before it can be bridged.
-     *         **WARNING**: Do not bridge an ERC721 that was originally deployed on Optimism. This
-     *         bridge only supports ERC721s originally deployed on Ethereum. Users will need to
-     *         wait for the one-week challenge period to elapse before their Optimism-native NFT
-     *         can be refunded on L2.
-     *
-     * @param _localToken  Address of the ERC721 on this domain.
-     * @param _remoteToken Address of the ERC721 on the remote domain.
-     * @param _to          Address to receive the token on the other domain.
-     * @param _tokenId     Token ID to bridge.
-     * @param _minGasLimit Minimum gas limit for the bridge message on the other domain.
-     * @param _extraData   Optional data to forward to the other chain. Data supplied here will not
-     *                     be used to execute any code on the other chain and is only emitted as
-     *                     extra data for the convenience of off-chain tooling.
-     */
-    function bridgeERC721To(
-        address _localToken,
-        address _remoteToken,
-        address _to,
-        uint256 _tokenId,
-        uint32 _minGasLimit,
-        bytes calldata _extraData
-    ) external {
-        require(_to != address(0), "ERC721Bridge: nft recipient cannot be address(0)");
-
-        _initiateBridgeERC721(
-            _localToken,
-            _remoteToken,
-            msg.sender,
-            _to,
-            _tokenId,
-            _minGasLimit,
-            _extraData
-        );
-    }
-
-    /**
-     * @notice Internal function for initiating a token bridge to the other domain.
-     *
-     * @param _localToken  Address of the ERC721 on this domain.
-     * @param _remoteToken Address of the ERC721 on the remote domain.
-     * @param _from        Address of the sender on this domain.
-     * @param _to          Address to receive the token on the other domain.
-     * @param _tokenId     Token ID to bridge.
-     * @param _minGasLimit Minimum gas limit for the bridge message on the other domain.
-     * @param _extraData   Optional data to forward to the other domain. Data supplied here will
-     *                     not be used to execute any code on the other domain and is only emitted
-     *                     as extra data for the convenience of off-chain tooling.
-     */
-    function _initiateBridgeERC721(
-        address _localToken,
-        address _remoteToken,
-        address _from,
-        address _to,
-        uint256 _tokenId,
-        uint32 _minGasLimit,
-        bytes calldata _extraData
-    ) internal virtual;
-}

packages/contracts-periphery/contracts/universal/op-erc721/IOptimismMintableERC721.sol

-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
-import {
-    IERC721Enumerable
-} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
-
-/**
- * @title IOptimismMintableERC721
- * @notice Interface for contracts that are compatible with the OptimismMintableERC721 standard.
- *         Tokens that follow this standard can be easily transferred across the ERC721 bridge.
- */
-interface IOptimismMintableERC721 is IERC721Enumerable {
-    /**
-     * @notice Emitted when a token is minted.
-     *
-     * @param account Address of the account the token was minted to.
-     * @param tokenId Token ID of the minted token.
-     */
-    event Mint(address indexed account, uint256 tokenId);
-
-    /**
-     * @notice Emitted when a token is burned.
-     *
-     * @param account Address of the account the token was burned from.
-     * @param tokenId Token ID of the burned token.
-     */
-    event Burn(address indexed account, uint256 tokenId);
-
-    /**
-     * @notice Chain ID of the chain where the remote token is deployed.
-     */
-    function remoteChainId() external view returns (uint256);
-
-    /**
-     * @notice Address of the token on the remote domain.
-     */
-    function remoteToken() external view returns (address);
-
-    /**
-     * @notice Address of the ERC721 bridge on this network.
-     */
-    function bridge() external view returns (address);
-
-    /**
-     * @notice Mints some token ID for a user, checking first that contract recipients
-     *         are aware of the ERC721 protocol to prevent tokens from being forever locked.
-     *
-     * @param _to      Address of the user to mint the token for.
-     * @param _tokenId Token ID to mint.
-     */
-    function safeMint(address _to, uint256 _tokenId) external;
-
-    /**
-     * @notice Burns a token ID from a user.
-     *
-     * @param _from    Address of the user to burn the token from.
-     * @param _tokenId Token ID to burn.
-     */
-    function burn(address _from, uint256 _tokenId) external;
-}

packages/contracts-periphery/contracts/universal/op-erc721/OptimismMintableERC721.sol

-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
-import {
-    ERC721Enumerable
-} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
-import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
-import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
-import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
-import { IOptimismMintableERC721 } from "./IOptimismMintableERC721.sol";
-
-/**
- * @title OptimismMintableERC721
- * @notice This contract is the remote representation for some token that lives on another network,
- *         typically an Optimism representation of an Ethereum-based token. Standard reference
- *         implementation that can be extended or modified according to your needs.
- */
-contract OptimismMintableERC721 is ERC721Enumerable, IOptimismMintableERC721 {
-    /**
-     * @inheritdoc IOptimismMintableERC721
-     */
-    uint256 public immutable remoteChainId;
-
-    /**
-     * @inheritdoc IOptimismMintableERC721
-     */
-    address public immutable remoteToken;
-
-    /**
-     * @inheritdoc IOptimismMintableERC721
-     */
-    address public immutable bridge;
-
-    /**
-     * @notice Base token URI for this token.
-     */
-    string public baseTokenURI;
-
-    /**
-     * @param _bridge        Address of the bridge on this network.
-     * @param _remoteChainId Chain ID where the remote token is deployed.
-     * @param _remoteToken   Address of the corresponding token on the other network.
-     * @param _name          ERC721 name.
-     * @param _symbol        ERC721 symbol.
-     */
-    constructor(
-        address _bridge,
-        uint256 _remoteChainId,
-        address _remoteToken,
-        string memory _name,
-        string memory _symbol
-    ) ERC721(_name, _symbol) {
-        require(_bridge != address(0), "OptimismMintableERC721: bridge cannot be address(0)");
-        require(_remoteChainId != 0, "OptimismMintableERC721: remote chain id cannot be zero");
-        require(
-            _remoteToken != address(0),
-            "OptimismMintableERC721: remote token cannot be address(0)"
-        );
-
-        remoteChainId = _remoteChainId;
-        remoteToken = _remoteToken;
-        bridge = _bridge;
-
-        // Creates a base URI in the format specified by EIP-681:
-        // https://eips.ethereum.org/EIPS/eip-681
-        baseTokenURI = string(
-            abi.encodePacked(
-                "ethereum:",
-                Strings.toHexString(uint160(_remoteToken), 20),
-                "@",
-                Strings.toString(_remoteChainId),
-                "/tokenURI?uint256="
-            )
-        );
-    }
-
-    /**
-     * @notice Modifier that prevents callers other than the bridge from calling the function.
-     */
-    modifier onlyBridge() {
-        require(msg.sender == bridge, "OptimismMintableERC721: only bridge can call this function");
-        _;
-    }
-
-    /**
-     * @inheritdoc IOptimismMintableERC721
-     */
-    function safeMint(address _to, uint256 _tokenId) external virtual onlyBridge {
-        _safeMint(_to, _tokenId);
-
-        emit Mint(_to, _tokenId);
-    }
-
-    /**
-     * @inheritdoc IOptimismMintableERC721
-     */
-    function burn(address _from, uint256 _tokenId) external virtual onlyBridge {
-        _burn(_tokenId);
-
-        emit Burn(_from, _tokenId);
-    }
-
-    /**
-     * @notice Checks if a given interface ID is supported by this contract.
-     *
-     * @param _interfaceId The interface ID to check.
-     *
-     * @return True if the interface ID is supported, false otherwise.
-     */
-    function supportsInterface(bytes4 _interfaceId)
-        public
-        view
-        override(ERC721Enumerable, IERC165)
-        returns (bool)
-    {
-        bytes4 iface1 = type(IERC165).interfaceId;
-        bytes4 iface2 = type(IOptimismMintableERC721).interfaceId;
-        return
-            _interfaceId == iface1 ||
-            _interfaceId == iface2 ||
-            super.supportsInterface(_interfaceId);
-    }
-
-    /**
-     * @notice Returns the base token URI.
-     *
-     * @return Base token URI.
-     */
-    function _baseURI() internal view virtual override returns (string memory) {
-        return baseTokenURI;
-    }
-}

packages/contracts-periphery/contracts/universal/op-erc721/OptimismMintableERC721Factory.sol

-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.15;
-
-import { OptimismMintableERC721 } from "./OptimismMintableERC721.sol";
-import { Semver } from "@eth-optimism/contracts-bedrock/contracts/universal/Semver.sol";
-
-/**
- * @title OptimismMintableERC721Factory
- * @notice Factory contract for creating OptimismMintableERC721 contracts.
- */
-contract OptimismMintableERC721Factory is Semver {
-    /**
-     * @notice Emitted whenever a new OptimismMintableERC721 contract is created.
-     *
-     * @param localToken  Address of the token on the this domain.
-     * @param remoteToken Address of the token on the remote domain.
-     * @param deployer    Address of the initiator of the deployment
-     */
-    event OptimismMintableERC721Created(
-        address indexed localToken,
-        address indexed remoteToken,
-        address deployer
-    );
-
-    /**
-     * @notice Address of the ERC721 bridge on this network.
-     */
-    address public immutable bridge;
-
-    /**
-     * @notice Chain ID for the remote network.
-     */
-    uint256 public immutable remoteChainId;
-
-    /**
-     * @notice Tracks addresses created by this factory.
-     */
-    mapping(address => bool) public isOptimismMintableERC721;
-
-    /**
-     * @custom:semver 1.0.0
-     *
-     * @param _bridge Address of the ERC721 bridge on this network.
-     */
-    constructor(address _bridge, uint256 _remoteChainId) Semver(1, 0, 0) {
-        require(
-            _bridge != address(0),
-            "OptimismMintableERC721Factory: bridge cannot be address(0)"
-        );
-        require(
-            _remoteChainId != 0,
-            "OptimismMintableERC721Factory: remote chain id cannot be zero"
-        );
-
-        bridge = _bridge;
-        remoteChainId = _remoteChainId;
-    }
-
-    /**
-     * @notice Creates an instance of the standard ERC721.
-     *
-     * @param _remoteToken Address of the corresponding token on the other domain.
-     * @param _name        ERC721 name.
-     * @param _symbol      ERC721 symbol.
-     */
-    function createOptimismMintableERC721(
-        address _remoteToken,
-        string memory _name,
-        string memory _symbol
-    ) external returns (address) {
-        require(
-            _remoteToken != address(0),
-            "OptimismMintableERC721Factory: L1 token address cannot be address(0)"
-        );
-
-        address localToken = address(
-            new OptimismMintableERC721(bridge, remoteChainId, _remoteToken, _name, _symbol)
-        );
-
-        isOptimismMintableERC721[localToken] = true;
-        emit OptimismMintableERC721Created(localToken, _remoteToken, msg.sender);
-
-        return localToken;
-    }
-}

packages/contracts-periphery/deploy/nft-bridge/L1ERC721BridgeImplementation.ts

-/* Imports: External */
-import { DeployFunction } from 'hardhat-deploy/dist/types'
-import { HardhatRuntimeEnvironment } from 'hardhat/types'
-import '@eth-optimism/hardhat-deploy-config'
-import '@nomiclabs/hardhat-ethers'
-import 'hardhat-deploy'
-import fetch from 'node-fetch'
-
-import {
-  isTargetL1Network,
-  predeploy,
-  getProxyAdmin,
-  validateERC721Bridge,
-} from '../../src/nft-bridge-deploy-helpers'
-
-// Handle the `ops` deployment
-const getL1CrossDomainMessengerProxyDeployment = async (
-  hre: HardhatRuntimeEnvironment
-) => {
-  const network = hre.network.name
-  if (network === 'ops-l1') {
-    const res = await fetch(
-      'http://localhost:8080/deployments/local/Proxy__OVM_L1CrossDomainMessenger.json'
-    )
-    return res.json()
-  } else {
-    return hre.deployments.get('Proxy__OVM_L1CrossDomainMessenger')
-  }
-}
-
-const deployFn: DeployFunction = async (hre) => {
-  const { deployer } = await hre.getNamedAccounts()
-  const { deploy } = hre.deployments
-  const { getAddress } = hre.ethers.utils
-
-  if (!isTargetL1Network(hre.network.name)) {
-    console.log(`Deploying to unsupported network ${hre.network.name}`)
-    return
-  }
-
-  console.log(`Deploying L1ERC721Bridge to ${hre.network.name}`)
-  console.log(`Using deployer ${deployer}`)
-
-  const Deployment__L1ERC721BridgeProxy = await hre.deployments.get(
-    'L1ERC721BridgeProxy'
-  )
-
-  const L1ERC721BridgeProxy = await hre.ethers.getContractAt(
-    'Proxy',
-    Deployment__L1ERC721BridgeProxy.address
-  )
-
-  const admin = await L1ERC721BridgeProxy.callStatic.admin()
-  if (getAddress(admin) !== getAddress(deployer)) {
-    throw new Error('deployer is not proxy admin')
-  }
-
-  // Get the address of the currently deployed L1CrossDomainMessenger.
-  // This should be the address of the proxy
-  const Deployment__L1CrossDomainMessengerProxy =
-    await getL1CrossDomainMessengerProxyDeployment(hre)
-
-  const L1CrossDomainMessengerProxyAddress =
-    Deployment__L1CrossDomainMessengerProxy.address
-
-  // Deploy the L1ERC721Bridge. The arguments are
-  // - messenger
-  // - otherBridge
-  // Since this is the L1ERC721Bridge, the otherBridge is the
-  // predeploy address
-  await deploy('L1ERC721Bridge', {
-    from: deployer,
-    args: [L1CrossDomainMessengerProxyAddress, predeploy],
-    log: true,
-    waitConfirmations: 1,
-  })
-
-  const Deployment__L1ERC721Bridge = await hre.deployments.get('L1ERC721Bridge')
-  console.log(
-    `L1ERC721Bridge deployed to ${Deployment__L1ERC721Bridge.address}`
-  )
-
-  await validateERC721Bridge(hre, Deployment__L1ERC721Bridge.address, {
-    messenger: L1CrossDomainMessengerProxyAddress,
-    otherBridge: predeploy,
-  })
-
-  {
-    // Upgrade the Proxy to the newly deployed implementation
-    const tx = await L1ERC721BridgeProxy.upgradeTo(
-      Deployment__L1ERC721Bridge.address
-    )
-    const receipt = await tx.wait()
-    console.log(`L1ERC721BridgeProxy upgraded: ${receipt.transactionHash}`)
-  }
-
-  {
-    // Set the admin correctly
-    const newAdmin = getProxyAdmin(hre.network.name)
-    const tx = await L1ERC721BridgeProxy.changeAdmin(newAdmin)
-    const receipt = await tx.wait()
-    console.log(`L1ERC721BridgeProxy admin updated: ${receipt.transactionHash}`)
-  }
-
-  await validateERC721Bridge(hre, L1ERC721BridgeProxy.address, {
-    messenger: L1CrossDomainMessengerProxyAddress,
-    otherBridge: predeploy,
-  })
-}
-
-deployFn.tags = ['L1ERC721BridgeImplementation']
-deployFn.dependencies = ['L1ERC721BridgeProxy']
-
-export default deployFn

packages/contracts-periphery/deploy/nft-bridge/L1ERC721BridgeProxy.ts

-/* Imports: External */
-import { DeployFunction } from 'hardhat-deploy/dist/types'
-import '@eth-optimism/hardhat-deploy-config'
-import '@nomiclabs/hardhat-ethers'
-import 'hardhat-deploy'
-
-import { isTargetL1Network } from '../../src/nft-bridge-deploy-helpers'
-
-const deployFn: DeployFunction = async (hre) => {
-  const { deployer } = await hre.getNamedAccounts()
-  const { deploy } = hre.deployments
-
-  if (!isTargetL1Network(hre.network.name)) {
-    console.log(`Deploying to unsupported network ${hre.network.name}`)
-    return
-  }
-
-  console.log(`Deploying L1ERC721BridgeProxy to ${hre.network.name}`)
-  console.log(`Using deployer ${deployer}`)
-
-  await deploy('L1ERC721BridgeProxy', {
-    contract: 'Proxy',
-    from: deployer,
-    args: [deployer],
-    log: true,
-    waitConfirmations: 1,
-  })
-
-  const Deployment__L1ERC721BridgeProxy = await hre.deployments.get(
-    'L1ERC721BridgeProxy'
-  )
-  console.log(
-    `L1ERC721BridgeProxy deployed to ${Deployment__L1ERC721BridgeProxy.address}`
-  )
-}
-
-deployFn.tags = ['L1ERC721BridgeProxy']
-
-export default deployFn

packages/contracts-periphery/deploy/nft-bridge/L2ERC721BridgeImplementation.ts

-/* Imports: External */
-import { DeployFunction } from 'hardhat-deploy/dist/types'
-import '@eth-optimism/hardhat-deploy-config'
-import '@nomiclabs/hardhat-ethers'
-import 'hardhat-deploy'
-import { predeploys } from '@eth-optimism/contracts'
-
-import {
-  isTargetL2Network,
-  predeploy,
-  validateERC721Bridge,
-  getProxyAdmin,
-} from '../../src/nft-bridge-deploy-helpers'
-
-const deployFn: DeployFunction = async (hre) => {
-  const { deployer } = await hre.getNamedAccounts()
-  const { getAddress } = hre.ethers.utils
-
-  if (!isTargetL2Network(hre.network.name)) {
-    console.log(`Deploying to unsupported network ${hre.network.name}`)
-    return
-  }
-
-  console.log(`Deploying L2ERC721Bridge to ${hre.network.name}`)
-  console.log(`Using deployer ${deployer}`)
-
-  const L2ERC721BridgeProxy = await hre.ethers.getContractAt('Proxy', predeploy)
-
-  // Check to make sure that the admin of the proxy is the deployer.
-  // The deployer of the L2ERC721Bridge should be the same as the
-  // admin of the L2ERC721BridgeProxy so that it is easy to upgrade
-  // the implementation. The admin is then changed depending on the
-  // network after the L2ERC721BridgeProxy is upgraded to the implementation
-  const admin = await L2ERC721BridgeProxy.callStatic.admin()
-
-  if (getAddress(admin) !== getAddress(deployer)) {
-    throw new Error(`Unexpected admin ${admin}`)
-  }
-
-  const Deployment__L1ERC721Bridge = await hre.companionNetworks[
-    'l1'
-  ].deployments.get('L1ERC721BridgeProxy')
-
-  const L1ERC721BridgeAddress = Deployment__L1ERC721Bridge.address
-
-  // Deploy the L2ERC721Bridge implementation
-  await hre.deployments.deploy('L2ERC721Bridge', {
-    from: deployer,
-    args: [predeploys.L2CrossDomainMessenger, L1ERC721BridgeAddress],
-    log: true,
-    waitConfirmations: 1,
-  })
-
-  const Deployment__L2ERC721Bridge = await hre.deployments.get('L2ERC721Bridge')
-  console.log(
-    `L2ERC721Bridge deployed to ${Deployment__L2ERC721Bridge.address}`
-  )
-
-  await validateERC721Bridge(hre, Deployment__L2ERC721Bridge.address, {
-    messenger: predeploys.L2CrossDomainMessenger,
-    otherBridge: L1ERC721BridgeAddress,
-  })
-
-  {
-    // Upgrade the implementation of the proxy to the newly deployed
-    // L2ERC721Bridge
-    const tx = await L2ERC721BridgeProxy.upgradeTo(
-      Deployment__L2ERC721Bridge.address
-    )
-    const receipt = await tx.wait()
-    console.log(
-      `Upgraded the implementation of the L2ERC721BridgeProxy: ${receipt.transactionhash}`
-    )
-  }
-
-  await validateERC721Bridge(hre, L2ERC721BridgeProxy.address, {
-    messenger: predeploys.L2CrossDomainMessenger,
-    otherBridge: L1ERC721BridgeAddress,
-  })
-
-  {
-    const newAdmin = getProxyAdmin(hre.network.name)
-    console.log(`Changing admin to ${newAdmin}`)
-    const tx = await L2ERC721BridgeProxy.changeAdmin(newAdmin)
-    const receipt = await tx.wait()
-    console.log(
-      `Changed admin of the L2ERC721BridgeProxy: ${receipt.transactionHash}`
-    )
-  }
-}
-
-deployFn.tags = ['L2ERC721BridgeImplementation']
-deployFn.dependencies = ['L2ERC721BridgeProxy', 'L1ERC721BridgeProxy']
-
-export default deployFn

packages/contracts-periphery/deploy/nft-bridge/L2ERC721BridgeProxy.ts

-/* Imports: External */
-import { DeployFunction } from 'hardhat-deploy/dist/types'
-import '@eth-optimism/hardhat-deploy-config'
-import '@nomiclabs/hardhat-ethers'
-import 'hardhat-deploy'
-
-const predeploy = '0x4200000000000000000000000000000000000014'
-
-const deployFn: DeployFunction = async (hre) => {
-  const { deployer } = await hre.getNamedAccounts()
-  const { getAddress } = hre.ethers.utils
-
-  console.log(`Deploying L2ERC721BridgeProxy to ${hre.network.name}`)
-  console.log(`Using deployer ${deployer}`)
-
-  // Check to make sure that the Proxy has not been deployed yet
-  const pre = await hre.ethers.provider.getCode(predeploy, 'latest')
-  if (pre !== '0x') {
-    console.log(`Code already deployed to ${predeploy}`)
-    return
-  }
-
-  // A special deployer account must be used
-  const mainnetDeployer = getAddress(
-    '0x53A6eecC2dD4795Fcc68940ddc6B4d53Bd88Bd9E'
-  )
-  const goerliDeployer = getAddress(
-    '0x5c679a57e018f5f146838138d3e032ef4913d551'
-  )
-  const kovanDeployer = getAddress('0xa81224490b9fa4930a2e920550cd1c9106bb6d9e')
-  const localDeployer = getAddress('0xdfc82d475833a50de90c642770f34a9db7deb725')
-
-  // Deploy the L2ERC721BridgeProxy as a predeploy address
-  if (hre.network.name === 'optimism') {
-    if (getAddress(deployer) !== mainnetDeployer) {
-      throw new Error(`Incorrect deployer: ${deployer}`)
-    }
-  } else if (hre.network.name === 'optimism-goerli') {
-    if (getAddress(deployer) !== goerliDeployer) {
-      throw new Error(`Incorrect deployer: ${deployer}`)
-    }
-  } else if (hre.network.name === 'ops-l2') {
-    if (getAddress(deployer) !== localDeployer) {
-      throw new Error(`Incorrect deployer: ${deployer}`)
-    }
-  } else if (hre.network.name === 'optimism-kovan') {
-    if (getAddress(deployer) !== kovanDeployer) {
-      throw new Error(`Incorrect deployer: ${deployer}`)
-    }
-  } else {
-    throw new Error(`Unknown network: ${hre.network.name}`)
-  }
-
-  // Set the deployer as the admin of the Proxy. This is
-  // temporary, the admin will be updated when deploying
-  // the implementation
-  await hre.deployments.deploy('L2ERC721BridgeProxy', {
-    contract: 'Proxy',
-    from: deployer,
-    args: [deployer],
-    log: true,
-    waitConfirmations: 1,
-  })
-
-  // Check that the Proxy was deployed to the correct address
-  const code = await hre.ethers.provider.getCode(predeploy)
-  if (code === '0x') {
-    throw new Error('Code is not set at expected predeploy address')
-  }
-  console.log(`L2ERC721BridgeProxy deployed to ${predeploy}`)
-}
-
-deployFn.tags = ['L2ERC721BridgeProxy']
-
-export default deployFn

packages/contracts-periphery/deploy/nft-bridge/OptimismMintableERC721FactoryImplementation.ts

-/* Imports: External */
-import { DeployFunction } from 'hardhat-deploy/dist/types'
-import '@eth-optimism/hardhat-deploy-config'
-import '@nomiclabs/hardhat-ethers'
-import 'hardhat-deploy'
-
-import { getProxyAdmin, predeploy } from '../../src/nft-bridge-deploy-helpers'
-
-const deployFn: DeployFunction = async (hre) => {
-  const { deployer } = await hre.getNamedAccounts()
-  const { getAddress } = hre.ethers.utils
-
-  console.log(`Deploying OptimismMintableERC721Factory to ${hre.network.name}`)
-  console.log(`Using deployer ${deployer}`)
-
-  const Deployment__OptimismMintableERC721FactoryProxy =
-    await hre.deployments.get('OptimismMintableERC721FactoryProxy')
-
-  const OptimismMintableERC721FactoryProxy = await hre.ethers.getContractAt(
-    'Proxy',
-    Deployment__OptimismMintableERC721FactoryProxy.address
-  )
-
-  // Check that the admin of the OptimismMintableERC721FactoryProxy is the
-  // deployer. This makes it easy to upgrade the implementation of the proxy
-  // and then transfer the admin privilege after deploying the implementation
-  const admin = await OptimismMintableERC721FactoryProxy.callStatic.admin()
-  if (getAddress(admin) !== getAddress(deployer)) {
-    throw new Error('deployer is not proxy admin')
-  }
-
-  let remoteChainId: number
-  if (hre.network.name === 'optimism') {
-    remoteChainId = 1
-  } else if (hre.network.name === 'optimism-goerli') {
-    remoteChainId = 5
-  } else if (hre.network.name === 'ops-l2') {
-    remoteChainId = 31337
-  } else if (hre.network.name === 'optimism-kovan') {
-    remoteChainId = 42
-  } else {
-    remoteChainId = hre.deployConfig.remoteChainId
-  }
-
-  if (typeof remoteChainId !== 'number') {
-    throw new Error('remoteChainId not defined')
-  }
-
-  await hre.deployments.deploy('OptimismMintableERC721Factory', {
-    from: deployer,
-    args: [predeploy, remoteChainId],
-    log: true,
-    waitConfirmations: 1,
-  })
-
-  const Deployment__OptimismMintableERC721Factory = await hre.deployments.get(
-    'OptimismMintableERC721Factory'
-  )
-  console.log(
-    `OptimismMintableERC721Factory deployed to ${Deployment__OptimismMintableERC721Factory.address}`
-  )
-
-  {
-    // Upgrade the Proxy to the newly deployed implementation
-    const tx = await OptimismMintableERC721FactoryProxy.upgradeTo(
-      Deployment__OptimismMintableERC721Factory.address
-    )
-    const receipt = await tx.wait()
-    console.log(
-      `OptimismMintableERC721FactoryProxy upgraded: ${receipt.transactionHash}`
-    )
-  }
-
-  {
-    const newAdmin = getProxyAdmin(hre.network.name)
-    const tx = await OptimismMintableERC721FactoryProxy.changeAdmin(newAdmin)
-    const receipt = await tx.wait()
-    console.log(
-      `OptimismMintableERC721FactoryProxy admin updated: ${receipt.transactionHash}`
-    )
-  }
-}
-
-deployFn.tags = ['OptimismMintableERC721FactoryImplementation']
-deployFn.dependencies = ['OptimismMintableERC721FactoryProxy']
-
-export default deployFn

packages/contracts-periphery/deploy/nft-bridge/OptimismMintableERC721FactoryProxy.ts

-/* Imports: External */
-import { DeployFunction } from 'hardhat-deploy/dist/types'
-import '@eth-optimism/hardhat-deploy-config'
-import '@nomiclabs/hardhat-ethers'
-import 'hardhat-deploy'
-
-const deployFn: DeployFunction = async (hre) => {
-  const { deployer } = await hre.getNamedAccounts()
-  const { deploy } = hre.deployments
-
-  console.log(
-    `Deploying OptimismMintableERC721FactoryProxy to ${hre.network.name}`
-  )
-  console.log(`Using deployer ${deployer}`)
-
-  // Deploy the OptimismMintableERC721FactoryProxy with
-  // the deployer as the admin. The admin and implementation
-  // will be updated with the deployment of the implementation
-  await deploy('OptimismMintableERC721FactoryProxy', {
-    contract: 'Proxy',
-    from: deployer,
-    args: [deployer],
-    log: true,
-    waitConfirmations: 1,
-  })
-
-  const Deployment__OptimismMintableERC721FactoryProxy =
-    await hre.deployments.get('OptimismMintableERC721FactoryProxy')
-  console.log(
-    `OptimismMintableERC721FactoryProxy deployed to ${Deployment__OptimismMintableERC721FactoryProxy.address}`
-  )
-}
-
-deployFn.tags = ['OptimismMintableERC721FactoryProxy']
-
-export default deployFn

packages/contracts-periphery/package.json

@@ -55,7 +55,6 @@
   },
   "devDependencies": {
     "@defi-wonderland/smock": "^2.0.7",
-    "@eth-optimism/contracts": "^0.5.39",
     "@eth-optimism/contracts-bedrock": "0.10.0",
     "@eth-optimism/core-utils": "^0.12.0",
     "@eth-optimism/hardhat-deploy-config": "^0.2.5",

packages/contracts-periphery/test/contracts/universal/OptimismMintableERC721.spec.ts

-/* External Imports */
-import { ethers } from 'hardhat'
-import { Signer, Contract } from 'ethers'
-import { smock, FakeContract } from '@defi-wonderland/smock'
-
-/* Internal Imports */
-import { expect } from '../../setup'
-
-const TOKEN_ID = 10
-const DUMMY_L1ERC721_ADDRESS: string =
-  '0x0034223412342234223422342234223422342234'
-
-describe('OptimismMintableERC721', () => {
-  let l2BridgeImpersonator: Signer
-  let alice: Signer
-  let Fake__L2ERC721Bridge: FakeContract
-  let OptimismMintableERC721: Contract
-  let l2BridgeImpersonatorAddress: string
-  let aliceAddress: string
-  let baseUri: string
-  const remoteChainId = 100
-
-  let Factory__OptimismMintableERC721
-  before(async () => {
-    ;[l2BridgeImpersonator, alice] = await ethers.getSigners()
-    l2BridgeImpersonatorAddress = await l2BridgeImpersonator.getAddress()
-    aliceAddress = await alice.getAddress()
-
-    baseUri = ''.concat(
-      'ethereum:',
-      DUMMY_L1ERC721_ADDRESS,
-      '@',
-      remoteChainId.toString(),
-      '/tokenURI?uint256='
-    )
-
-    Factory__OptimismMintableERC721 = await ethers.getContractFactory(
-      'OptimismMintableERC721'
-    )
-    OptimismMintableERC721 = await Factory__OptimismMintableERC721.deploy(
-      l2BridgeImpersonatorAddress,
-      remoteChainId,
-      DUMMY_L1ERC721_ADDRESS,
-      'L2ERC721',
-      'ERC'
-    )
-
-    // Get a new fake L2 bridge
-    Fake__L2ERC721Bridge = await smock.fake<Contract>(
-      'L2ERC721Bridge',
-      // This allows us to use an ethers override {from: Fake__L2ERC721Bridge.address} to mock calls
-      { address: await l2BridgeImpersonator.getAddress() }
-    )
-
-    // mint an nft to alice
-    await OptimismMintableERC721.connect(l2BridgeImpersonator).safeMint(
-      aliceAddress,
-      TOKEN_ID,
-      {
-        from: Fake__L2ERC721Bridge.address,
-      }
-    )
-  })
-
-  describe('constructor', () => {
-    it('should revert if bridge is address(0)', async () => {
-      await expect(
-        Factory__OptimismMintableERC721.deploy(
-          ethers.constants.AddressZero,
-          remoteChainId,
-          DUMMY_L1ERC721_ADDRESS,
-          'L2ERC721',
-          'ERC'
-        )
-      ).to.be.revertedWith(
-        'OptimismMintableERC721: bridge cannot be address(0)'
-      )
-    })
-
-    it('should revert if remote chain id is address(0)', async () => {
-      await expect(
-        Factory__OptimismMintableERC721.deploy(
-          l2BridgeImpersonatorAddress,
-          0,
-          DUMMY_L1ERC721_ADDRESS,
-          'L2ERC721',
-          'ERC'
-        )
-      ).to.be.revertedWith(
-        'OptimismMintableERC721: remote chain id cannot be zero'
-      )
-    })
-
-    it('should revert if remote token is address(0)', async () => {
-      await expect(
-        Factory__OptimismMintableERC721.deploy(
-          l2BridgeImpersonatorAddress,
-          remoteChainId,
-          ethers.constants.AddressZero,
-          'L2ERC721',
-          'ERC'
-        )
-      ).to.be.revertedWith(
-        'OptimismMintableERC721: remote token cannot be address(0)'
-      )
-    })
-
-    it('should be able to create a standard ERC721 contract with the correct parameters', async () => {
-      expect(await OptimismMintableERC721.bridge()).to.equal(
-        l2BridgeImpersonatorAddress
-      )
-      expect(await OptimismMintableERC721.remoteToken()).to.equal(
-        DUMMY_L1ERC721_ADDRESS
-      )
-      expect(await OptimismMintableERC721.name()).to.equal('L2ERC721')
-      expect(await OptimismMintableERC721.symbol()).to.equal('ERC')
-      expect(await OptimismMintableERC721.baseTokenURI()).to.equal(baseUri)
-
-      // alice has been minted an nft
-      expect(await OptimismMintableERC721.ownerOf(TOKEN_ID)).to.equal(
-        aliceAddress
-      )
-    })
-  })
-
-  describe('mint and burn', () => {
-    it('should not allow anyone but the L2 bridge to mint and burn', async () => {
-      await expect(
-        OptimismMintableERC721.connect(alice).safeMint(aliceAddress, 100)
-      ).to.be.revertedWith(
-        'OptimismMintableERC721: only bridge can call this function'
-      )
-      await expect(
-        OptimismMintableERC721.connect(alice).burn(aliceAddress, 100)
-      ).to.be.revertedWith(
-        'OptimismMintableERC721: only bridge can call this function'
-      )
-    })
-  })
-
-  describe('supportsInterface', () => {
-    it('should return the correct interface support', async () => {
-      // ERC165
-      expect(await OptimismMintableERC721.supportsInterface(0x01ffc9a7)).to.be
-        .true
-
-      // OptimismMintableERC721
-      expect(await OptimismMintableERC721.supportsInterface(0xe49bc7f8)).to.be
-        .true
-
-      // ERC721
-      expect(await OptimismMintableERC721.supportsInterface(0x80ac58cd)).to.be
-        .true
-
-      // Some bad interface
-      expect(await OptimismMintableERC721.supportsInterface(0xffffffff)).to.be
-        .false
-    })
-  })
-
-  describe('tokenURI', () => {
-    it('should return the correct token uri', async () => {
-      const tokenUri = baseUri.concat(TOKEN_ID.toString())
-      expect(await OptimismMintableERC721.tokenURI(TOKEN_ID)).to.equal(tokenUri)
-    })
-  })
-})

packages/contracts-periphery/test/contracts/universal/OptimismMintableERC721Factory.spec.ts

-/* External Imports */
-import { ethers } from 'hardhat'
-import { Signer, ContractFactory, Contract } from 'ethers'
-import {
-  smock,
-  MockContractFactory,
-  MockContract,
-} from '@defi-wonderland/smock'
-
-/* Internal Imports */
-import { expect } from '../../setup'
-
-const DUMMY_L2_BRIDGE_ADDRESS: string = ethers.utils.getAddress(
-  '0x' + 'acdc'.repeat(10)
-)
-
-describe('OptimismMintableERC721Factory', () => {
-  let signer: Signer
-  let Factory__L1ERC721: MockContractFactory<ContractFactory>
-  let L1ERC721: MockContract<Contract>
-  let OptimismMintableERC721Factory: Contract
-  let baseURI: string
-  const remoteChainId = 100
-
-  let Factory__OptimismMintableERC721Factory: ContractFactory
-  beforeEach(async () => {
-    ;[signer] = await ethers.getSigners()
-
-    // deploy an ERC721 contract on L1
-    Factory__L1ERC721 = await smock.mock(
-      '@openzeppelin/contracts/token/ERC721/ERC721.sol:ERC721'
-    )
-    L1ERC721 = await Factory__L1ERC721.deploy('L1ERC721', 'ERC')
-
-    Factory__OptimismMintableERC721Factory = await ethers.getContractFactory(
-      'OptimismMintableERC721Factory'
-    )
-    OptimismMintableERC721Factory =
-      await Factory__OptimismMintableERC721Factory.deploy(
-        DUMMY_L2_BRIDGE_ADDRESS,
-        remoteChainId
-      )
-
-    baseURI = ''.concat(
-      'ethereum:',
-      L1ERC721.address.toLowerCase(),
-      '@',
-      remoteChainId.toString(),
-      '/tokenURI?uint256='
-    )
-  })
-
-  it('should revert if bridge is initialized as address(0)', async () => {
-    await expect(
-      Factory__OptimismMintableERC721Factory.deploy(
-        ethers.constants.AddressZero,
-        remoteChainId
-      )
-    ).to.be.revertedWith(
-      'OptimismMintableERC721Factory: bridge cannot be address(0)'
-    )
-  })
-
-  it('should revert if remote chain id is initialized as zero', async () => {
-    await expect(
-      Factory__OptimismMintableERC721Factory.deploy(DUMMY_L2_BRIDGE_ADDRESS, 0)
-    ).to.be.revertedWith(
-      'OptimismMintableERC721Factory: remote chain id cannot be zero'
-    )
-  })
-
-  it('should be deployed with the correct constructor argument', async () => {
-    expect(await OptimismMintableERC721Factory.bridge()).to.equal(
-      DUMMY_L2_BRIDGE_ADDRESS
-    )
-  })
-
-  it('should be able to create a standard ERC721 contract', async () => {
-    const tx = await OptimismMintableERC721Factory.createOptimismMintableERC721(
-      L1ERC721.address,
-      'L2ERC721',
-      'ERC'
-    )
-    const receipt = await tx.wait()
-
-    // Get the OptimismMintableERC721Created event
-    const erc721CreatedEvent = receipt.events[0]
-
-    // Expect there to be an event emitted for the standard token creation
-    expect(erc721CreatedEvent.event).to.be.eq('OptimismMintableERC721Created')
-
-    // Get the L2 ERC721 address from the emitted event and check it was created correctly
-    const l2ERC721Address = erc721CreatedEvent.args.localToken
-    const OptimismMintableERC721 = new Contract(
-      l2ERC721Address,
-      (await ethers.getContractFactory('OptimismMintableERC721')).interface,
-      signer
-    )
-
-    expect(await OptimismMintableERC721.bridge()).to.equal(
-      DUMMY_L2_BRIDGE_ADDRESS
-    )
-    expect(await OptimismMintableERC721.remoteToken()).to.equal(
-      L1ERC721.address
-    )
-    expect(await OptimismMintableERC721.name()).to.equal('L2ERC721')
-    expect(await OptimismMintableERC721.symbol()).to.equal('ERC')
-    expect(await OptimismMintableERC721.baseTokenURI()).to.equal(baseURI)
-
-    expect(
-      await OptimismMintableERC721Factory.isOptimismMintableERC721(
-        OptimismMintableERC721.address
-      )
-    ).to.equal(true)
-  })
-
-  it('should not be able to create a standard token with a 0 address for l1 token', async () => {
-    await expect(
-      OptimismMintableERC721Factory.createOptimismMintableERC721(
-        ethers.constants.AddressZero,
-        'L2ERC721',
-        'ERC'
-      )
-    ).to.be.revertedWith(
-      'OptimismMintableERC721Factory: L1 token address cannot be address(0)'
-    )
-  })
-})