Merge branch 'develop' into action-testing-user

.changeset/chatty-impalas-report.md

----
-'@eth-optimism/contracts-bedrock': patch
----
-
-Use uint64 for arithmetic in XDM's baseGas

.changeset/chilly-cups-agree.md

----
-'@eth-optimism/sdk': patch
----
-
-Adds contract addresses for the Bedrock Alpha testnet

.changeset/five-grapes-march.md

----
-'@eth-optimism/contracts-bedrock': patch
-'@eth-optimism/sdk': patch
----
-
-Rename the event emitted in the L2ToL1MessagePasser

.changeset/green-doors-brake.md

----
-'@eth-optimism/contracts-periphery': patch
----
-
-Goerli nft bridge deployment

.changeset/khaki-bottles-matter.md

----
-'@eth-optimism/l2geth': patch
----
-
-add --rpc.evmtimeout flag to configure timeout for eth_call

.changeset/lazy-drinks-drop.md

----
-'@eth-optimism/integration-tests': patch
-'@eth-optimism/contracts-periphery': patch
----
-
-Fix erc721 factory to match erc21 factory

.changeset/mighty-planets-pump.md

----
-"@eth-optimism/contracts-periphery": patch
----
-
-mainnet nft bridge deployments

.changeset/red-trains-run.md

----
-'@eth-optimism/endpoint-monitor': major
----
-
-Initial release of endpoint monitor

.changeset/serious-pianos-complain.md

----
-'@eth-optimism/ci-builder': patch
----
-
-Pin slither version to 0.9.0

.circleci/config.yml

@@ -432,7 +432,7 @@ jobs:
           name: Test
           command: |
             mkdir -p /test-results
-            gotestsum --junitfile /test-results/tests.xml
+            DB_USER=postgres gotestsum --junitfile /test-results/tests.xml
           working_directory: <<parameters.working_directory>>
       - when:
           condition:

endpoint-monitor/CHANGELOG.md

 # @eth-optimism/endpoint-monitor
+
+## 1.0.0
+
+### Major Changes
+
+- a10c2b49: Initial release of endpoint monitor

endpoint-monitor/package.json

 {
   "name": "@eth-optimism/endpoint-monitor",
-  "version": "0.0.0",
+  "version": "1.0.0",
   "private": true,
   "dependencies": {}
 }

indexer/CHANGELOG.md

 # @eth-optimism/indexer
 
+## 0.3.0
+
+### Minor Changes
+
+- 19e581d8: Bedrock support
+
 ## 0.2.0
 
 ### Minor Changes

indexer/config.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"time"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/urfave/cli"
 
@@ -20,15 +21,8 @@ var (
 type Config struct {
 	/* Required Params */
 
-	// BuildEnv identifies the environment this binary is intended for, i.e.
-	// production, development, etc.
-	BuildEnv string
-
-	// EthNetworkName identifies the intended Ethereum network.
-	EthNetworkName string
-
 	// ChainID identifies the chain being indexed.
-	ChainID int64
+	ChainID uint64
 
 	// L1EthRpc is the HTTP provider URL for L1.
 	L1EthRpc string
@@ -36,8 +30,8 @@ type Config struct {
 	// L2EthRpc is the HTTP provider URL for L1.
 	L2EthRpc string
 
-	// L2GenesisBlockHash is the l2 genesis block hash.
-	L2GenesisBlockHash string
+	// L1AddressManagerAddress is the address of the address manager for L1.
+	L1AddressManagerAddress string
 
 	// PollInterval is the delay between querying L2 for more transaction
 	// and creating a new batch.
@@ -68,22 +62,8 @@ type Config struct {
 	// are printed using JSON.
 	LogTerminal bool
 
-	// SentryEnable if true, logs any error messages to sentry. SentryDsn
-	// must also be set if SentryEnable is true.
-	SentryEnable bool
-
-	// SentryDsn is the sentry Data Source Name.
-	SentryDsn string
-
-	// SentryTraceRate the frequency with which Sentry should flush buffered
-	// events.
-	SentryTraceRate time.Duration
-
-	// StartBlockNumber is the block number to start indexing from.
-	StartBlockNumber uint64
-
-	// StartBlockHash is the block hash to start indexing from.
-	StartBlockHash string
+	// L1StartBlockNumber is the block number to start indexing L1 from.
+	L1StartBlockNumber uint64
 
 	// ConfDepth is the number of confirmations after which headers are
 	// considered confirmed.
@@ -111,6 +91,13 @@ type Config struct {
 
 	// DisableIndexer enables/disables the indexer.
 	DisableIndexer bool
+
+	// Bedrock enabled Bedrock indexing.
+	Bedrock bool
+
+	BedrockL1StandardBridgeAddress common.Address
+
+	BedrockOptimismPortalAddress common.Address
 }
 
 // NewConfig parses the Config from the provided flags or environment variables.
@@ -118,33 +105,30 @@ type Config struct {
 func NewConfig(ctx *cli.Context) (Config, error) {
 	cfg := Config{
 		/* Required Flags */
-		BuildEnv:           ctx.GlobalString(flags.BuildEnvFlag.Name),
-		EthNetworkName:     ctx.GlobalString(flags.EthNetworkNameFlag.Name),
-		ChainID:            ctx.GlobalInt64(flags.ChainIDFlag.Name),
-		L1EthRpc:           ctx.GlobalString(flags.L1EthRPCFlag.Name),
-		L2EthRpc:           ctx.GlobalString(flags.L2EthRPCFlag.Name),
-		L2GenesisBlockHash: ctx.GlobalString(flags.L2GenesisBlockHashFlag.Name),
-		DBHost:             ctx.GlobalString(flags.DBHostFlag.Name),
-		DBPort:             ctx.GlobalUint64(flags.DBPortFlag.Name),
-		DBUser:             ctx.GlobalString(flags.DBUserFlag.Name),
-		DBPassword:         ctx.GlobalString(flags.DBPasswordFlag.Name),
-		DBName:             ctx.GlobalString(flags.DBNameFlag.Name),
+		ChainID:                 ctx.GlobalUint64(flags.ChainIDFlag.Name),
+		L1EthRpc:                ctx.GlobalString(flags.L1EthRPCFlag.Name),
+		L2EthRpc:                ctx.GlobalString(flags.L2EthRPCFlag.Name),
+		L1AddressManagerAddress: ctx.GlobalString(flags.L1AddressManagerAddressFlag.Name),
+		DBHost:                  ctx.GlobalString(flags.DBHostFlag.Name),
+		DBPort:                  ctx.GlobalUint64(flags.DBPortFlag.Name),
+		DBUser:                  ctx.GlobalString(flags.DBUserFlag.Name),
+		DBPassword:              ctx.GlobalString(flags.DBPasswordFlag.Name),
+		DBName:                  ctx.GlobalString(flags.DBNameFlag.Name),
 		/* Optional Flags */
-		DisableIndexer:      ctx.GlobalBool(flags.DisableIndexer.Name),
-		LogLevel:            ctx.GlobalString(flags.LogLevelFlag.Name),
-		LogTerminal:         ctx.GlobalBool(flags.LogTerminalFlag.Name),
-		SentryEnable:        ctx.GlobalBool(flags.SentryEnableFlag.Name),
-		SentryDsn:           ctx.GlobalString(flags.SentryDsnFlag.Name),
-		SentryTraceRate:     ctx.GlobalDuration(flags.SentryTraceRateFlag.Name),
-		StartBlockNumber:    ctx.GlobalUint64(flags.StartBlockNumberFlag.Name),
-		StartBlockHash:      ctx.GlobalString(flags.StartBlockHashFlag.Name),
-		ConfDepth:           ctx.GlobalUint64(flags.ConfDepthFlag.Name),
-		MaxHeaderBatchSize:  ctx.GlobalUint64(flags.MaxHeaderBatchSizeFlag.Name),
-		MetricsServerEnable: ctx.GlobalBool(flags.MetricsServerEnableFlag.Name),
-		RESTHostname:        ctx.GlobalString(flags.RESTHostnameFlag.Name),
-		RESTPort:            ctx.GlobalUint64(flags.RESTPortFlag.Name),
-		MetricsHostname:     ctx.GlobalString(flags.MetricsHostnameFlag.Name),
-		MetricsPort:         ctx.GlobalUint64(flags.MetricsPortFlag.Name),
+		Bedrock:                        ctx.GlobalBool(flags.BedrockFlag.Name),
+		BedrockL1StandardBridgeAddress: common.HexToAddress(ctx.GlobalString(flags.BedrockL1StandardBridgeAddress.Name)),
+		BedrockOptimismPortalAddress:   common.HexToAddress(ctx.GlobalString(flags.BedrockOptimismPortalAddress.Name)),
+		DisableIndexer:                 ctx.GlobalBool(flags.DisableIndexer.Name),
+		LogLevel:                       ctx.GlobalString(flags.LogLevelFlag.Name),
+		LogTerminal:                    ctx.GlobalBool(flags.LogTerminalFlag.Name),
+		L1StartBlockNumber:             ctx.GlobalUint64(flags.L1StartBlockNumberFlag.Name),
+		ConfDepth:                      ctx.GlobalUint64(flags.ConfDepthFlag.Name),
+		MaxHeaderBatchSize:             ctx.GlobalUint64(flags.MaxHeaderBatchSizeFlag.Name),
+		MetricsServerEnable:            ctx.GlobalBool(flags.MetricsServerEnableFlag.Name),
+		RESTHostname:                   ctx.GlobalString(flags.RESTHostnameFlag.Name),
+		RESTPort:                       ctx.GlobalUint64(flags.RESTPortFlag.Name),
+		MetricsHostname:                ctx.GlobalString(flags.MetricsHostnameFlag.Name),
+		MetricsPort:                    ctx.GlobalUint64(flags.MetricsPortFlag.Name),
 	}
 
 	err := ValidateConfig(&cfg)
@@ -168,9 +152,8 @@ func ValidateConfig(cfg *Config) error {
 		return err
 	}
 
-	// Ensure the Sentry Data Source Name is set when using Sentry.
-	if cfg.SentryEnable && cfg.SentryDsn == "" {
-		return ErrSentryDSNNotSet
+	if cfg.Bedrock && (cfg.BedrockL1StandardBridgeAddress == common.Address{} || cfg.BedrockOptimismPortalAddress == common.Address{}) {
+		return errors.New("must specify l1 standard bridge and optimism portal addresses in bedrock mode")
 	}
 
 	return nil

indexer/db/db.go

@@ -197,6 +197,12 @@ func (d *Database) AddIndexedL1Block(block *IndexedL1Block) error {
 	VALUES
 		($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
 	`
+
+	const updateWithdrawalStatement = `
+	UPDATE withdrawals SET (br_withdrawal_finalized_tx_hash, br_withdrawal_finalized_log_index, br_withdrawal_finalized_success) = ($1, $2, $3)
+	WHERE br_withdrawal_hash = $4
+	`
+
 	return txn(d.db, func(tx *sql.Tx) error {
 		_, err := tx.Exec(
 			insertBlockStatement,
@@ -209,26 +215,39 @@ func (d *Database) AddIndexedL1Block(block *IndexedL1Block) error {
 			return err
 		}
 
-		if len(block.Deposits) == 0 {
-			return nil
+		if len(block.Deposits) > 0 {
+			for _, deposit := range block.Deposits {
+				_, err = tx.Exec(
+					insertDepositStatement,
+					NewGUID(),
+					deposit.FromAddress.String(),
+					deposit.ToAddress.String(),
+					deposit.L1Token.String(),
+					deposit.L2Token.String(),
+					deposit.Amount.String(),
+					deposit.TxHash.String(),
+					deposit.LogIndex,
+					block.Hash.String(),
+					deposit.Data,
+				)
+				if err != nil {
+					return err
+				}
+			}
 		}
 
-		for _, deposit := range block.Deposits {
-			_, err = tx.Exec(
-				insertDepositStatement,
-				NewGUID(),
-				deposit.FromAddress.String(),
-				deposit.ToAddress.String(),
-				deposit.L1Token.String(),
-				deposit.L2Token.String(),
-				deposit.Amount.String(),
-				deposit.TxHash.String(),
-				deposit.LogIndex,
-				block.Hash.String(),
-				deposit.Data,
-			)
-			if err != nil {
-				return err
+		if len(block.FinalizedWithdrawals) > 0 {
+			for _, wd := range block.FinalizedWithdrawals {
+				_, err = tx.Exec(
+					updateWithdrawalStatement,
+					wd.TxHash.String(),
+					wd.LogIndex,
+					wd.Success,
+					wd.WithdrawalHash.String(),
+				)
+				if err != nil {
+					return err
+				}
 			}
 		}
 
@@ -459,19 +478,21 @@ func (d *Database) GetWithdrawalBatch(hash common.Hash) (*StateBatchJSON, error)
 
 // GetWithdrawalsByAddress returns the list of Withdrawals indexed for the given
 // address paginated by the given params.
-func (d *Database) GetWithdrawalsByAddress(address common.Address, page PaginationParam) (*PaginatedWithdrawals, error) {
+func (d *Database) GetWithdrawalsByAddress(address common.Address, page PaginationParam, state FinalizationState) (*PaginatedWithdrawals, error) {
 	selectWithdrawalsStatement := fmt.Sprintf(`
 	SELECT
 	    withdrawals.guid, withdrawals.from_address, withdrawals.to_address,
 		withdrawals.amount, withdrawals.tx_hash, withdrawals.data,
 		withdrawals.l1_token, withdrawals.l2_token,
 		l2_tokens.name, l2_tokens.symbol, l2_tokens.decimals,
-		l2_blocks.number, l2_blocks.timestamp, withdrawals.br_withdrawal_hash
+		l2_blocks.number, l2_blocks.timestamp, withdrawals.br_withdrawal_hash,
+		withdrawals.br_withdrawal_finalized_tx_hash, withdrawals.br_withdrawal_finalized_log_index,
+		withdrawals.br_withdrawal_finalized_success
 	FROM withdrawals
 		INNER JOIN l2_blocks ON withdrawals.block_hash=l2_blocks.hash
 		INNER JOIN l2_tokens ON withdrawals.l2_token=l2_tokens.address
 	WHERE withdrawals.from_address = $1 %s ORDER BY l2_blocks.timestamp LIMIT $2 OFFSET $3;
-	`, FinalizationStateAny.SQL())
+	`, state.SQL())
 	var withdrawals []WithdrawalJSON
 
 	err := txn(d.db, func(tx *sql.Tx) error {
@@ -485,13 +506,16 @@ func (d *Database) GetWithdrawalsByAddress(address common.Address, page Paginati
 			var withdrawal WithdrawalJSON
 			var l2Token Token
 			var wdHash sql.NullString
+			var finTxHash sql.NullString
+			var finLogIndex sql.NullInt32
+			var finSuccess sql.NullBool
 			if err := rows.Scan(
 				&withdrawal.GUID, &withdrawal.FromAddress, &withdrawal.ToAddress,
 				&withdrawal.Amount, &withdrawal.TxHash, &withdrawal.Data,
 				&withdrawal.L1Token, &l2Token.Address,
 				&l2Token.Name, &l2Token.Symbol, &l2Token.Decimals,
 				&withdrawal.BlockNumber, &withdrawal.BlockTimestamp,
-				&wdHash,
+				&wdHash, &finTxHash, &finLogIndex, &finSuccess,
 			); err != nil {
 				return err
 			}
@@ -499,6 +523,16 @@ func (d *Database) GetWithdrawalsByAddress(address common.Address, page Paginati
 			if wdHash.Valid {
 				withdrawal.BedrockWithdrawalHash = &wdHash.String
 			}
+			if finTxHash.Valid {
+				withdrawal.BedrockFinalizedTxHash = &finTxHash.String
+			}
+			if finLogIndex.Valid {
+				idx := int(finLogIndex.Int32)
+				withdrawal.BedrockFinalizedLogIndex = &idx
+			}
+			if finSuccess.Valid {
+				withdrawal.BedrockFinalizedSuccess = &finSuccess.Bool
+			}
 			withdrawals = append(withdrawals, withdrawal)
 		}
 

indexer/db/eth.go

 package db
 
-import "github.com/ethereum/go-ethereum/common"
+import (
+	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
+	"github.com/ethereum/go-ethereum/common"
+)
 
 var ETHL1Address common.Address
 
@@ -13,14 +16,10 @@ var ETHL1Token = &Token{
 	Decimals: 18,
 }
 
-// ETHL2Address is a placeholder address for differentiating ETH transactions
-// from ERC20 transactions on L2.
-var ETHL2Address = common.HexToAddress("0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000")
-
 // ETHL2Token is a placeholder token for differentiating ETH transactions from
 // ERC20 transactions on L2.
 var ETHL2Token = &Token{
-	Address:  ETHL2Address.String(),
+	Address:  predeploys.LegacyERC20ETH,
 	Name:     "Ethereum",
 	Symbol:   "ETH",
 	Decimals: 18,

indexer/db/l1block.go

@@ -6,11 +6,12 @@ import (
 
 // IndexedL1Block contains the L1 block including the deposits in it.
 type IndexedL1Block struct {
-	Hash       common.Hash
-	ParentHash common.Hash
-	Number     uint64
-	Timestamp  uint64
-	Deposits   []Deposit
+	Hash                 common.Hash
+	ParentHash           common.Hash
+	Number               uint64
+	Timestamp            uint64
+	Deposits             []Deposit
+	FinalizedWithdrawals []FinalizedWithdrawal
 }
 
 // String returns the block hash for the indexed l1 block.

indexer/db/sql.go

@@ -125,8 +125,8 @@ CREATE TABLE IF NOT EXISTS airdrops (
 const updateWithdrawalsTable = `
 ALTER TABLE withdrawals ADD COLUMN IF NOT EXISTS br_withdrawal_hash VARCHAR NULL;
 ALTER TABLE withdrawals ADD COLUMN IF NOT EXISTS br_withdrawal_finalized_tx_hash VARCHAR NULL;
-ALTER TABLE withdrawals ADD COLUMN IF NOT EXISTS br_withdrawal_finalized_log_index BOOLEAN NULL;
-ALTER TABLE withdrawals ADD COLUMN IF NOT EXISTS br_withdrawal_success BOOLEAN NULL;
+ALTER TABLE withdrawals ADD COLUMN IF NOT EXISTS br_withdrawal_finalized_log_index INTEGER NULL;
+ALTER TABLE withdrawals ADD COLUMN IF NOT EXISTS br_withdrawal_finalized_success BOOLEAN NULL;
 CREATE INDEX IF NOT EXISTS withdrawals_br_withdrawal_hash ON withdrawals(br_withdrawal_hash);
 `
 

indexer/db/withdrawal.go

@@ -27,19 +27,22 @@ func (w Withdrawal) String() string {
 
 // WithdrawalJSON contains Withdrawal data suitable for JSON serialization.
 type WithdrawalJSON struct {
-	GUID                  string          `json:"guid"`
-	FromAddress           string          `json:"from"`
-	ToAddress             string          `json:"to"`
-	L1Token               string          `json:"l1Token"`
-	L2Token               *Token          `json:"l2Token"`
-	Amount                string          `json:"amount"`
-	Data                  []byte          `json:"data"`
-	LogIndex              uint64          `json:"logIndex"`
-	BlockNumber           uint64          `json:"blockNumber"`
-	BlockTimestamp        string          `json:"blockTimestamp"`
-	TxHash                string          `json:"transactionHash"`
-	Batch                 *StateBatchJSON `json:"batch"`
-	BedrockWithdrawalHash *string         `json:"bedrockWithdrawalHash"`
+	GUID                     string          `json:"guid"`
+	FromAddress              string          `json:"from"`
+	ToAddress                string          `json:"to"`
+	L1Token                  string          `json:"l1Token"`
+	L2Token                  *Token          `json:"l2Token"`
+	Amount                   string          `json:"amount"`
+	Data                     []byte          `json:"data"`
+	LogIndex                 uint64          `json:"logIndex"`
+	BlockNumber              uint64          `json:"blockNumber"`
+	BlockTimestamp           string          `json:"blockTimestamp"`
+	TxHash                   string          `json:"transactionHash"`
+	Batch                    *StateBatchJSON `json:"batch"`
+	BedrockWithdrawalHash    *string         `json:"bedrockWithdrawalHash"`
+	BedrockFinalizedTxHash   *string         `json:"bedrockFinalizedTxHash"`
+	BedrockFinalizedLogIndex *int            `json:"bedrockFinalizedLogIndex"`
+	BedrockFinalizedSuccess  *bool           `json:"bedrockFinalizedSuccess"`
 }
 
 type FinalizationState int
@@ -64,9 +67,9 @@ func ParseFinalizationState(in string) FinalizationState {
 func (f FinalizationState) SQL() string {
 	switch f {
 	case FinalizationStateFinalized:
-		return "AND withdrawals.l1_block_hash IS NOT NULL"
+		return "AND withdrawals.br_withdrawal_finalized_tx_hash IS NOT NULL"
 	case FinalizationStateUnfinalized:
-		return "AND withdrawals.l2_block_hash IS NULL"
+		return "AND withdrawals.br_withdrawal_finalized_tx_hash IS NULL"
 	}
 
 	return ""

indexer/flags/flags.go

@@ -46,11 +46,11 @@ var (
 		Required: true,
 		EnvVar:   prefixEnvVar("L2_ETH_RPC"),
 	}
-	L2GenesisBlockHashFlag = cli.StringFlag{
-		Name:     "l2-genesis-block-hash",
-		Usage:    "Genesis block hash of the L2 chain",
+	L1AddressManagerAddressFlag = cli.StringFlag{
+		Name:     "l1-address-manager-address",
+		Usage:    "Address of the L1 address manager",
 		Required: true,
-		EnvVar:   prefixEnvVar("L2_GENESIS_BLOCK_HASH"),
+		EnvVar:   prefixEnvVar("L1_ADDRESS_MANAGER_ADDRESS"),
 	}
 	DBHostFlag = cli.StringFlag{
 		Name:     "db-host",
@@ -83,6 +83,23 @@ var (
 		EnvVar:   prefixEnvVar("DB_NAME"),
 	}
 
+	/* Bedrock Flags */
+	BedrockFlag = cli.BoolFlag{
+		Name:   "bedrock",
+		Usage:  "Whether or not this indexer should operate in Bedrock mode",
+		EnvVar: prefixEnvVar("BEDROCK"),
+	}
+	BedrockL1StandardBridgeAddress = cli.BoolFlag{
+		Name:   "bedrock.l1-standard-bridge-address",
+		Usage:  "Address of the L1 standard bridge",
+		EnvVar: prefixEnvVar("BEDROCK_L1_STANDARD_BRIDGE"),
+	}
+	BedrockOptimismPortalAddress = cli.BoolFlag{
+		Name:   "bedrock.portal-address",
+		Usage:  "Address of the portal",
+		EnvVar: prefixEnvVar("BEDROCK_OPTIMISM_PORTAL"),
+	}
+
 	/* Optional Flags */
 
 	DisableIndexer = cli.BoolFlag{
@@ -120,18 +137,12 @@ var (
 		Value:  50 * time.Millisecond,
 		EnvVar: prefixEnvVar("SENTRY_TRACE_RATE"),
 	}
-	StartBlockNumberFlag = cli.Uint64Flag{
+	L1StartBlockNumberFlag = cli.Uint64Flag{
 		Name:   "start-block-number",
 		Usage:  "The block number to start indexing from. Must be use together with start block hash",
 		Value:  0,
 		EnvVar: prefixEnvVar("START_BLOCK_NUMBER"),
 	}
-	StartBlockHashFlag = cli.StringFlag{
-		Name:   "start-block-hash",
-		Usage:  "The block hash to start indexing from. Must be use together with start block number",
-		Value:  "0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3",
-		EnvVar: prefixEnvVar("START_BLOCK_HASH"),
-	}
 	ConfDepthFlag = cli.Uint64Flag{
 		Name:   "conf-depth",
 		Usage:  "The number of confirmations after which headers are considered confirmed",
@@ -181,7 +192,7 @@ var requiredFlags = []cli.Flag{
 	ChainIDFlag,
 	L1EthRPCFlag,
 	L2EthRPCFlag,
-	L2GenesisBlockHashFlag,
+	L1AddressManagerAddressFlag,
 	DBHostFlag,
 	DBPortFlag,
 	DBUserFlag,
@@ -190,6 +201,9 @@ var requiredFlags = []cli.Flag{
 }
 
 var optionalFlags = []cli.Flag{
+	BedrockFlag,
+	BedrockL1StandardBridgeAddress,
+	BedrockOptimismPortalAddress,
 	DisableIndexer,
 	LogLevelFlag,
 	LogTerminalFlag,
@@ -198,8 +212,7 @@ var optionalFlags = []cli.Flag{
 	SentryTraceRateFlag,
 	ConfDepthFlag,
 	MaxHeaderBatchSizeFlag,
-	StartBlockNumberFlag,
-	StartBlockHashFlag,
+	L1StartBlockNumberFlag,
 	RESTHostnameFlag,
 	RESTPortFlag,
 	MetricsServerEnableFlag,

indexer/indexer.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/ethereum-optimism/optimism/indexer/services"
+	"github.com/ethereum/go-ethereum/common"
 
 	"github.com/ethereum-optimism/optimism/indexer/metrics"
 	"github.com/ethereum-optimism/optimism/indexer/server"
@@ -22,7 +23,6 @@ import (
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rpc"
-	sentry "github.com/getsentry/sentry-go"
 	"github.com/gorilla/mux"
 	"github.com/urfave/cli"
 )
@@ -44,15 +44,9 @@ func Main(gitVersion string) func(ctx *cli.Context) error {
 			return err
 		}
 
-		// The call to defer is done here so that any errors logged from
-		// this point on are posted to Sentry before exiting.
-		if cfg.SentryEnable {
-			defer sentry.Flush(2 * time.Second)
-		}
-
 		log.Info("Initializing indexer")
 
-		indexer, err := NewIndexer(cfg, gitVersion)
+		indexer, err := NewIndexer(cfg)
 		if err != nil {
 			log.Error("Unable to create indexer", "error", err)
 			return err
@@ -87,32 +81,18 @@ type Indexer struct {
 
 	router  *mux.Router
 	metrics *metrics.Metrics
+	db      *database.Database
+	server  *http.Server
 }
 
 // NewIndexer initializes the Indexer, gathering any resources
 // that will be needed by the TxIndexer and StateIndexer
 // sub-services.
-func NewIndexer(cfg Config, gitVersion string) (*Indexer, error) {
+func NewIndexer(cfg Config) (*Indexer, error) {
 	ctx := context.Background()
 
-	// Set up our logging. If Sentry is enabled, we will use our custom
-	// log handler that logs to stdout and forwards any error messages to
-	// Sentry for collection. Otherwise, logs will only be posted to stdout.
 	var logHandler log.Handler
-	if cfg.SentryEnable {
-		err := sentry.Init(sentry.ClientOptions{
-			Dsn:              cfg.SentryDsn,
-			Environment:      cfg.EthNetworkName,
-			Release:          "indexer@" + gitVersion,
-			TracesSampleRate: traceRateToFloat64(cfg.SentryTraceRate),
-			Debug:            false,
-		})
-		if err != nil {
-			return nil, err
-		}
-
-		logHandler = SentryStreamHandler(os.Stdout, log.JSONFormat())
-	} else if cfg.LogTerminal {
+	if cfg.LogTerminal {
 		logHandler = log.StreamHandler(os.Stdout, log.TerminalFormat(true))
 	} else {
 		logHandler = log.StreamHandler(os.Stdout, log.JSONFormat())
@@ -149,8 +129,11 @@ func NewIndexer(cfg Config, gitVersion string) (*Indexer, error) {
 		log.Info("metrics server enabled", "host", cfg.MetricsHostname, "port", cfg.MetricsPort)
 	}
 
-	dsn := fmt.Sprintf("host=%s port=%d user=%s dbname=%s sslmode=disable",
-		cfg.DBHost, cfg.DBPort, cfg.DBUser, cfg.DBName)
+	dsn := fmt.Sprintf("host=%s port=%d dbname=%s sslmode=disable",
+		cfg.DBHost, cfg.DBPort, cfg.DBName)
+	if cfg.DBUser != "" {
+		dsn += fmt.Sprintf(" user=%s", cfg.DBUser)
+	}
 	if cfg.DBPassword != "" {
 		dsn += fmt.Sprintf(" password=%s", cfg.DBPassword)
 	}
@@ -159,17 +142,32 @@ func NewIndexer(cfg Config, gitVersion string) (*Indexer, error) {
 		return nil, err
 	}
 
+	var addrManager services.AddressManager
+	if cfg.Bedrock {
+		addrManager, err = services.NewBedrockAddresses(
+			l1Client,
+			cfg.BedrockL1StandardBridgeAddress,
+			cfg.BedrockOptimismPortalAddress,
+		)
+	} else {
+		addrManager, err = services.NewLegacyAddresses(l1Client, common.HexToAddress(cfg.L1AddressManagerAddress))
+	}
+	if err != nil {
+		return nil, err
+	}
+
 	l1IndexingService, err := l1.NewService(l1.ServiceConfig{
 		Context:            ctx,
 		Metrics:            m,
 		L1Client:           l1Client,
 		RawL1Client:        rawl1Client,
-		ChainID:            big.NewInt(cfg.ChainID),
+		ChainID:            new(big.Int).SetUint64(cfg.ChainID),
+		AddressManager:     addrManager,
 		DB:                 db,
 		ConfDepth:          cfg.ConfDepth,
 		MaxHeaderBatchSize: cfg.MaxHeaderBatchSize,
-		StartBlockNumber:   cfg.StartBlockNumber,
-		StartBlockHash:     cfg.StartBlockHash,
+		StartBlockNumber:   cfg.L1StartBlockNumber,
+		Bedrock:            cfg.Bedrock,
 	})
 	if err != nil {
 		return nil, err
@@ -184,7 +182,7 @@ func NewIndexer(cfg Config, gitVersion string) (*Indexer, error) {
 		ConfDepth:          cfg.ConfDepth,
 		MaxHeaderBatchSize: cfg.MaxHeaderBatchSize,
 		StartBlockNumber:   uint64(0),
-		StartBlockHash:     cfg.L2GenesisBlockHash,
+		Bedrock:            cfg.Bedrock,
 	})
 	if err != nil {
 		return nil, err
@@ -200,6 +198,7 @@ func NewIndexer(cfg Config, gitVersion string) (*Indexer, error) {
 		airdropService:    services.NewAirdrop(db, m),
 		router:            mux.NewRouter(),
 		metrics:           m,
+		db:                db,
 	}, nil
 }
 
@@ -212,7 +211,7 @@ func (b *Indexer) Serve() error {
 	b.router.HandleFunc("/v1/l1/status", b.l1IndexingService.GetIndexerStatus).Methods("GET")
 	b.router.HandleFunc("/v1/l2/status", b.l2IndexingService.GetIndexerStatus).Methods("GET")
 	b.router.HandleFunc("/v1/deposits/0x{address:[a-fA-F0-9]{40}}", b.l1IndexingService.GetDeposits).Methods("GET")
-	b.router.HandleFunc("/v1/withdrawal/0x{hash:[a-fA-F0-9]{64}}", b.l2IndexingService.GetWithdrawalStatus).Methods("GET")
+	b.router.HandleFunc("/v1/withdrawal/0x{hash:[a-fA-F0-9]{64}}", b.l2IndexingService.GetWithdrawalBatch).Methods("GET")
 	b.router.HandleFunc("/v1/withdrawals/0x{address:[a-fA-F0-9]{40}}", b.l2IndexingService.GetWithdrawals).Methods("GET")
 	b.router.HandleFunc("/v1/airdrops/0x{address:[a-fA-F0-9]{40}}", b.airdropService.GetAirdrop)
 	b.router.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
@@ -228,8 +227,27 @@ func (b *Indexer) Serve() error {
 	port := strconv.FormatUint(b.cfg.RESTPort, 10)
 	addr := net.JoinHostPort(b.cfg.RESTHostname, port)
 
-	log.Info("indexer REST server listening on", "addr", addr)
-	return http.ListenAndServe(addr, middleware(c.Handler(b.router)))
+	b.server = &http.Server{
+		Addr:    addr,
+		Handler: middleware(c.Handler(b.router)),
+	}
+
+	errCh := make(chan error, 1)
+
+	go func() {
+		errCh <- b.server.ListenAndServe()
+	}()
+
+	// Capture server startup errors
+	<-time.After(10 * time.Millisecond)
+
+	select {
+	case err := <-errCh:
+		return err
+	default:
+		log.Info("indexer REST server listening on", "addr", addr)
+		return nil
+	}
 }
 
 // Start starts the starts the indexing service on L1 and L2 chains and also
@@ -253,6 +271,14 @@ func (b *Indexer) Start() error {
 
 // Stop stops the indexing service on L1 and L2 chains.
 func (b *Indexer) Stop() {
+	b.db.Close()
+
+	if b.server != nil {
+		// background context here so it waits for
+		// conns to close
+		_ = b.server.Shutdown(context.Background())
+	}
+
 	if !b.cfg.DisableIndexer {
 		b.l1IndexingService.Stop()
 		b.l2IndexingService.Stop()
@@ -274,14 +300,3 @@ func dialEthClientWithTimeout(ctx context.Context, url string) (
 	}
 	return ethclient.NewClient(c), c, nil
 }
-
-// traceRateToFloat64 converts a time.Duration into a valid float64 for the
-// Sentry client. The client only accepts values between 0.0 and 1.0, so this
-// method clamps anything greater than 1 second to 1.0.
-func traceRateToFloat64(rate time.Duration) float64 {
-	rate64 := float64(rate) / float64(time.Second)
-	if rate64 > 1.0 {
-		rate64 = 1.0
-	}
-	return rate64
-}

indexer/integration_tests/bedrock_test.go

+package integration_tests
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"net/http"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/ethereum-optimism/optimism/indexer"
+	"github.com/ethereum-optimism/optimism/indexer/db"
+	"github.com/ethereum-optimism/optimism/indexer/services/l1"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
+	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	"github.com/ethereum-optimism/optimism/op-node/withdrawals"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/stretchr/testify/require"
+
+	_ "github.com/lib/pq"
+)
+
+func TestBedrockIndexer(t *testing.T) {
+	dbParams := createTestDB(t)
+
+	cfg := op_e2e.DefaultSystemConfig(t)
+	cfg.DeployConfig.FinalizationPeriodSeconds = 2
+	sys, err := cfg.Start()
+	require.NoError(t, err)
+	defer sys.Close()
+
+	l1Client := sys.Clients["l1"]
+	l2Client := sys.Clients["sequencer"]
+	fromAddr := cfg.Secrets.Addresses().Alice
+
+	// wait a couple of blocks
+	require.NoError(t, e2eutils.WaitBlock(e2eutils.TimeoutCtx(t, 30*time.Second), l2Client, 10))
+
+	l1SB, err := bindings.NewL1StandardBridge(predeploys.DevL1StandardBridgeAddr, l1Client)
+	require.NoError(t, err)
+	l2SB, err := bindings.NewL2StandardBridge(predeploys.L2StandardBridgeAddr, l2Client)
+	require.NoError(t, err)
+	portal, err := bindings.NewOptimismPortal(predeploys.DevOptimismPortalAddr, l1Client)
+	require.NoError(t, err)
+	l1Opts, err := bind.NewKeyedTransactorWithChainID(cfg.Secrets.Alice, cfg.L1ChainIDBig())
+	require.NoError(t, err)
+	l2Opts, err := bind.NewKeyedTransactorWithChainID(cfg.Secrets.Alice, cfg.L2ChainIDBig())
+	require.NoError(t, err)
+
+	idxrCfg := indexer.Config{
+		ChainID:                        cfg.DeployConfig.L1ChainID,
+		L1EthRpc:                       sys.Nodes["l1"].HTTPEndpoint(),
+		L2EthRpc:                       sys.Nodes["sequencer"].HTTPEndpoint(),
+		PollInterval:                   time.Second,
+		DBHost:                         dbParams.Host,
+		DBPort:                         dbParams.Port,
+		DBUser:                         dbParams.User,
+		DBPassword:                     dbParams.Password,
+		DBName:                         dbParams.Name,
+		LogLevel:                       "info",
+		LogTerminal:                    true,
+		L1StartBlockNumber:             0,
+		ConfDepth:                      1,
+		MaxHeaderBatchSize:             2,
+		RESTHostname:                   "127.0.0.1",
+		RESTPort:                       7980,
+		DisableIndexer:                 false,
+		Bedrock:                        true,
+		BedrockL1StandardBridgeAddress: predeploys.DevL1StandardBridgeAddr,
+		BedrockOptimismPortalAddress:   predeploys.DevOptimismPortalAddr,
+	}
+	idxr, err := indexer.NewIndexer(idxrCfg)
+	require.NoError(t, err)
+
+	errCh := make(chan error, 1)
+	go func() {
+		errCh <- idxr.Start()
+	}()
+
+	t.Cleanup(func() {
+		idxr.Stop()
+		require.NoError(t, <-errCh)
+	})
+
+	makeURL := func(path string) string {
+		return fmt.Sprintf("http://%s:%d/%s", idxrCfg.RESTHostname, idxrCfg.RESTPort, path)
+	}
+
+	t.Run("deposit ETH", func(t *testing.T) {
+		l1Opts.Value = big.NewInt(params.Ether)
+		depTx, err := l1SB.DepositETH(l1Opts, 200_000, nil)
+		require.NoError(t, err)
+		depReceipt, err := e2eutils.WaitReceiptOK(e2eutils.TimeoutCtx(t, 10*time.Second), l1Client, depTx.Hash())
+		require.NoError(t, err)
+		require.Greaterf(t, len(depReceipt.Logs), 0, "must have logs")
+		var l2Hash common.Hash
+		for _, eLog := range depReceipt.Logs {
+			if len(eLog.Topics) == 0 || eLog.Topics[0] != derive.DepositEventABIHash {
+				continue
+			}
+
+			depLog, err := derive.UnmarshalDepositLogEvent(eLog)
+			require.NoError(t, err)
+			tx := types.NewTx(depLog)
+			l2Hash = tx.Hash()
+		}
+		require.NotEqual(t, common.Hash{}, l2Hash)
+		_, err = e2eutils.WaitReceiptOK(e2eutils.TimeoutCtx(t, 15*time.Second), l2Client, l2Hash)
+		require.NoError(t, err)
+
+		// Poll for indexer deposit
+		var depPage *db.PaginatedDeposits
+		require.NoError(t, e2eutils.WaitFor(e2eutils.TimeoutCtx(t, 30*time.Second), 100*time.Millisecond, func() (bool, error) {
+			res := new(db.PaginatedDeposits)
+			err := getJSON(makeURL(fmt.Sprintf("v1/deposits/%s", fromAddr)), res)
+			if err != nil {
+				return false, err
+			}
+
+			if len(res.Deposits) == 0 {
+				return false, nil
+			}
+
+			depPage = res
+			return true, nil
+		}))
+
+		// Make sure deposit is what we expect
+		require.Equal(t, 1, len(depPage.Deposits))
+		deposit := depPage.Deposits[0]
+		require.Equal(t, big.NewInt(params.Ether).String(), deposit.Amount)
+		require.Equal(t, depTx.Hash().String(), deposit.TxHash)
+		require.Equal(t, depReceipt.BlockNumber.Uint64(), deposit.BlockNumber)
+		require.Equal(t, fromAddr.String(), deposit.FromAddress)
+		require.Equal(t, fromAddr.String(), deposit.ToAddress)
+		require.EqualValues(t, db.ETHL1Token, deposit.L1Token)
+		require.Equal(t, l1.ZeroAddress.String(), deposit.L2Token)
+		require.NotEmpty(t, deposit.GUID)
+
+		// Perform withdrawal through bridge
+		l2Opts.Value = big.NewInt(0.5 * params.Ether)
+		wdTx, err := l2SB.Withdraw(l2Opts, predeploys.LegacyERC20ETHAddr, big.NewInt(0.5*params.Ether), 0, nil)
+		require.NoError(t, err)
+		wdReceipt, err := e2eutils.WaitReceiptOK(e2eutils.TimeoutCtx(t, 30*time.Second), l2Client, wdTx.Hash())
+		require.NoError(t, err)
+
+		var wdPage *db.PaginatedWithdrawals
+		require.NoError(t, e2eutils.WaitFor(e2eutils.TimeoutCtx(t, 30*time.Second), 100*time.Millisecond, func() (bool, error) {
+			res := new(db.PaginatedWithdrawals)
+			err := getJSON(makeURL(fmt.Sprintf("v1/withdrawals/%s", fromAddr)), res)
+			if err != nil {
+				return false, err
+			}
+
+			if len(res.Withdrawals) == 0 {
+				return false, nil
+			}
+
+			wdPage = res
+			return true, nil
+		}))
+
+		require.Equal(t, 1, len(wdPage.Withdrawals))
+		withdrawal := wdPage.Withdrawals[0]
+		require.Nil(t, withdrawal.BedrockFinalizedTxHash)
+		require.Equal(t, big.NewInt(0.5*params.Ether).String(), withdrawal.Amount)
+		require.Equal(t, wdTx.Hash().String(), withdrawal.TxHash)
+		require.Equal(t, wdReceipt.BlockNumber.Uint64(), withdrawal.BlockNumber)
+		// use fromaddr twice here because the user is withdrawing
+		// to themselves
+		require.Equal(t, fromAddr.String(), withdrawal.FromAddress)
+		require.Equal(t, fromAddr.String(), withdrawal.ToAddress)
+		require.EqualValues(t, l1.ZeroAddress.String(), withdrawal.L1Token)
+		require.Equal(t, db.ETHL2Token, withdrawal.L2Token)
+		require.NotEmpty(t, withdrawal.GUID)
+
+		finBlockNum, err := withdrawals.WaitForFinalizationPeriod(
+			e2eutils.TimeoutCtx(t, time.Minute),
+			l1Client,
+			predeploys.DevOptimismPortalAddr,
+			wdReceipt.BlockNumber,
+		)
+		require.NoError(t, err)
+		finHeader, err := l2Client.HeaderByNumber(context.Background(), big.NewInt(int64(finBlockNum)))
+		require.NoError(t, err)
+
+		rpcClient, err := rpc.Dial(sys.Nodes["sequencer"].HTTPEndpoint())
+		require.NoError(t, err)
+		proofClient := withdrawals.NewClient(rpcClient)
+		wParams, err := withdrawals.FinalizeWithdrawalParameters(context.Background(), proofClient, wdTx.Hash(), finHeader)
+		require.NoError(t, err)
+
+		l1Opts.Value = big.NewInt(0)
+		finTx, err := portal.FinalizeWithdrawalTransaction(
+			l1Opts,
+			bindings.TypesWithdrawalTransaction{
+				Nonce:    wParams.Nonce,
+				Sender:   wParams.Sender,
+				Target:   wParams.Target,
+				Value:    wParams.Value,
+				GasLimit: wParams.GasLimit,
+				Data:     wParams.Data,
+			},
+			wParams.BlockNumber,
+			wParams.OutputRootProof,
+			wParams.WithdrawalProof,
+		)
+		require.NoError(t, err)
+
+		finReceipt, err := e2eutils.WaitReceiptOK(e2eutils.TimeoutCtx(t, time.Minute), l1Client, finTx.Hash())
+		require.NoError(t, err)
+
+		wdPage = nil
+		require.NoError(t, e2eutils.WaitFor(e2eutils.TimeoutCtx(t, 30*time.Second), 100*time.Millisecond, func() (bool, error) {
+			res := new(db.PaginatedWithdrawals)
+			err := getJSON(makeURL(fmt.Sprintf("v1/withdrawals/%s", fromAddr)), res)
+			if err != nil {
+				return false, err
+			}
+
+			if res.Withdrawals[0].BedrockFinalizedTxHash == nil {
+				return false, nil
+			}
+
+			wdPage = res
+			return true, nil
+		}))
+
+		wd := wdPage.Withdrawals[0]
+		require.Equal(t, finReceipt.TxHash.String(), *wd.BedrockFinalizedTxHash)
+		require.True(t, *wd.BedrockFinalizedSuccess)
+
+		wdPage = new(db.PaginatedWithdrawals)
+		err = getJSON(makeURL(fmt.Sprintf("v1/withdrawals/%s?finalized=false", fromAddr)), wdPage)
+		require.NoError(t, err)
+		require.Equal(t, 0, len(wdPage.Withdrawals))
+	})
+}
+
+type testDBParams struct {
+	Host     string
+	Port     uint64
+	User     string
+	Password string
+	Name     string
+}
+
+func createTestDB(t *testing.T) *testDBParams {
+	user := os.Getenv("DB_USER")
+	name := fmt.Sprintf("indexer_test_%d", time.Now().Unix())
+
+	dsn := "postgres://"
+	if user != "" {
+		dsn += user
+		dsn += "@"
+	}
+	dsn += "localhost:5432?sslmode=disable"
+	pg, err := sql.Open(
+		"postgres",
+		dsn,
+	)
+	require.NoError(t, err)
+
+	_, err = pg.Exec("CREATE DATABASE " + name)
+	require.NoError(t, err)
+
+	t.Cleanup(func() {
+		_, err = pg.Exec("DROP DATABASE " + name)
+		require.NoError(t, err)
+		pg.Close()
+	})
+
+	return &testDBParams{
+		Host: "localhost",
+		Port: 5432,
+		Name: name,
+		User: user,
+	}
+}
+
+func getJSON(url string, out interface{}) error {
+	res, err := http.Get(url)
+	if err != nil {
+		return err
+	}
+
+	if res.StatusCode != 200 {
+		return fmt.Errorf("non-200 status code %d", res.StatusCode)
+	}
+
+	defer res.Body.Close()
+	dec := json.NewDecoder(res.Body)
+	return dec.Decode(out)
+}

indexer/metrics/metrics.go

@@ -21,6 +21,8 @@ type Metrics struct {
 
 	WithdrawalsCount *prometheus.CounterVec
 
+	StateBatchesCount prometheus.Counter
+
 	L1CatchingUp prometheus.Gauge
 
 	L2CatchingUp prometheus.Gauge
@@ -72,6 +74,12 @@ func NewMetrics(monitoredTokens map[string]string) *Metrics {
 			"symbol",
 		}),
 
+		StateBatchesCount: promauto.NewCounter(prometheus.CounterOpts{
+			Name:      "state_batches_count",
+			Help:      "The number of state batches indexed.",
+			Namespace: metricsNamespace,
+		}),
+
 		L1CatchingUp: promauto.NewGauge(prometheus.GaugeOpts{
 			Name:      "l1_catching_up",
 			Help:      "Whether or not L1 is far behind the chain tip.",
@@ -160,6 +168,10 @@ func (m *Metrics) RecordWithdrawal(addr common.Address) {
 	m.WithdrawalsCount.WithLabelValues(sym).Inc()
 }
 
+func (m *Metrics) RecordStateBatches(count int) {
+	m.StateBatchesCount.Add(float64(count))
+}
+
 func (m *Metrics) SetL1CatchingUp(state bool) {
 	var catchingUp float64
 	if state {

indexer/package.json

 {
   "name": "@eth-optimism/indexer",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "private": true,
   "license": "MIT"
 }

indexer/sentry_log.go

-package indexer
-
-import (
-	"errors"
-	"io"
-
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/getsentry/sentry-go"
-)
-
-var jsonFmt = log.JSONFormat()
-
-// SentryStreamHandler creates a log.Handler that behaves similarly to
-// log.StreamHandler, however it writes any log with severity greater than or
-// equal to log.LvlError to Sentry. In that case, the passed log.Record is
-// encoded using JSON rather than the default terminal output, so that it can be
-// captured for debugging in the Sentry dashboard.
-func SentryStreamHandler(wr io.Writer, fmtr log.Format) log.Handler {
-	h := log.FuncHandler(func(r *log.Record) error {
-		_, err := wr.Write(fmtr.Format(r))
-		// If this record's severity is log.LvlError or higher,
-		// serialize the record using JSON and write it to Sentry. We
-		// also capture the error message separately so that it's easy
-		// to parse what the error is in the dashboard.
-		//
-		// NOTE: The log.Lvl* constants are defined in reverse order of
-		// their severity, i.e. zero (log.LvlCrit) is the highest
-		// severity.
-		if r.Lvl <= log.LvlError {
-			sentry.WithScope(func(scope *sentry.Scope) {
-				scope.SetExtra("context", jsonFmt.Format(r))
-				sentry.CaptureException(errors.New(r.Msg))
-			})
-		}
-		return err
-	})
-	return log.LazyHandler(log.SyncHandler(h))
-}

indexer/services/addresses.go

+package services
+
+import (
+	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type AddressManager interface {
+	L1StandardBridge() (common.Address, *bindings.L1StandardBridge)
+	StateCommitmentChain() (common.Address, *scc.StateCommitmentChain)
+	OptimismPortal() (common.Address, *bindings.OptimismPortal)
+}
+
+type LegacyAddresses struct {
+	l1SB     *bindings.L1StandardBridge
+	l1SBAddr common.Address
+	scc      *scc.StateCommitmentChain
+	sccAddr  common.Address
+}
+
+var _ AddressManager = (*LegacyAddresses)(nil)
+
+func NewLegacyAddresses(client bind.ContractBackend, addrMgrAddr common.Address) (AddressManager, error) {
+	mgr, err := bindings.NewAddressManager(addrMgrAddr, client)
+	if err != nil {
+		return nil, err
+	}
+
+	l1SBAddr, err := mgr.GetAddress(nil, "Proxy__OVM_L1StandardBridge")
+	if err != nil {
+		return nil, err
+	}
+	sccAddr, err := mgr.GetAddress(nil, "StateCommitmentChain")
+	if err != nil {
+		return nil, err
+	}
+	l1SB, err := bindings.NewL1StandardBridge(l1SBAddr, client)
+	if err != nil {
+		return nil, err
+	}
+	sccContract, err := scc.NewStateCommitmentChain(sccAddr, client)
+	if err != nil {
+		return nil, err
+	}
+
+	return &LegacyAddresses{
+		l1SB:     l1SB,
+		l1SBAddr: l1SBAddr,
+		scc:      sccContract,
+		sccAddr:  sccAddr,
+	}, nil
+}
+
+func (a *LegacyAddresses) L1StandardBridge() (common.Address, *bindings.L1StandardBridge) {
+	return a.l1SBAddr, a.l1SB
+}
+
+func (a *LegacyAddresses) StateCommitmentChain() (common.Address, *scc.StateCommitmentChain) {
+	return a.sccAddr, a.scc
+}
+
+func (a *LegacyAddresses) OptimismPortal() (common.Address, *bindings.OptimismPortal) {
+	panic("OptimismPortal not configured on legacy networks - this is a programmer error")
+}
+
+type BedrockAddresses struct {
+	l1SB       *bindings.L1StandardBridge
+	l1SBAddr   common.Address
+	portal     *bindings.OptimismPortal
+	portalAddr common.Address
+}
+
+var _ AddressManager = (*BedrockAddresses)(nil)
+
+func NewBedrockAddresses(client bind.ContractBackend, l1SBAddr, portalAddr common.Address) (AddressManager, error) {
+	l1SB, err := bindings.NewL1StandardBridge(l1SBAddr, client)
+	if err != nil {
+		return nil, err
+	}
+	portal, err := bindings.NewOptimismPortal(portalAddr, client)
+	if err != nil {
+		return nil, err
+	}
+
+	return &BedrockAddresses{
+		l1SB:       l1SB,
+		l1SBAddr:   l1SBAddr,
+		portal:     portal,
+		portalAddr: portalAddr,
+	}, nil
+}
+
+func (b *BedrockAddresses) L1StandardBridge() (common.Address, *bindings.L1StandardBridge) {
+	return b.l1SBAddr, b.l1SB
+}
+
+func (b *BedrockAddresses) StateCommitmentChain() (common.Address, *scc.StateCommitmentChain) {
+	panic("SCC not configured on legacy networks - this is a programmer error")
+}
+
+func (b *BedrockAddresses) OptimismPortal() (common.Address, *bindings.OptimismPortal) {
+	return b.portalAddr, b.portal
+}

indexer/services/l1/bridge/bridge.go

@@ -5,93 +5,85 @@ import (
 	"errors"
 	"math/big"
 
+	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
 	"github.com/ethereum-optimism/optimism/indexer/db"
+	"github.com/ethereum-optimism/optimism/indexer/services"
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
-
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
 
+// DepositsMap is a collection of deposit objects keyed
+// on block hashes.
 type DepositsMap map[common.Hash][]db.Deposit
-type WithdrawalsMap map[common.Hash][]db.Withdrawal // Finalizations
+
+// WithdrawalsMap is a collection of withdrawal objects keyed
+// on block hashes.
+type InitiatedWithdrawalMap map[common.Hash][]db.Withdrawal
+
+// FinalizedWithdrawalsMap is a collection of finalized withdrawal
+// objected keyed on block hashes.
+type FinalizedWithdrawalsMap map[common.Hash][]db.FinalizedWithdrawal
 
 type Bridge interface {
 	Address() common.Address
-	GetDepositsByBlockRange(uint64, uint64) (DepositsMap, error)
-	GetWithdrawalsByBlockRange(uint64, uint64) (WithdrawalsMap, error)
+	GetDepositsByBlockRange(context.Context, uint64, uint64) (DepositsMap, error)
 	String() string
 }
 
 type implConfig struct {
 	name string
 	impl string
-	addr string
-}
-
-var defaultBridgeCfgs = map[uint64][]*implConfig{
-	// Devnet
-	900: {
-		{"Standard", "StandardBridge", predeploys.DevL1StandardBridge},
-		{"ETH", "ETHBridge", predeploys.DevL1StandardBridge},
-	},
-	// Goerli
-	5: {
-		{"Standard", "StandardBridge", "0xFf94B6C486350aD92561Ba09bad3a59df764Da92"},
-		{"ETH", "ETHBridge", "0xFf94B6C486350aD92561Ba09bad3a59df764Da92"},
-	},
+	addr common.Address
 }
 
 var customBridgeCfgs = map[uint64][]*implConfig{
 	// Mainnet
 	1: {
-		{"BitBTC", "StandardBridge", "0xaBA2c5F108F7E820C049D5Af70B16ac266c8f128"},
-		{"DAI", "StandardBridge", "0x10E6593CDda8c58a1d0f14C5164B376352a55f2F"},
+		{"BitBTC", "StandardBridge", common.HexToAddress("0xaBA2c5F108F7E820C049D5Af70B16ac266c8f128")},
+		{"DAI", "StandardBridge", common.HexToAddress("0x10E6593CDda8c58a1d0f14C5164B376352a55f2F")},
+		{"wstETH", "StandardBridge", common.HexToAddress("0x76943C0D61395d8F2edF9060e1533529cAe05dE6")},
 	},
 	// Kovan
 	42: {
-		{"BitBTC", "StandardBridge", "0x0b651A42F32069d62d5ECf4f2a7e5Bd3E9438746"},
-		{"USX", "StandardBridge", "0x40E862341b2416345F02c41Ac70df08525150dC7"},
-		{"DAI", "StandardBridge", "0xb415e822C4983ecD6B1c1596e8a5f976cf6CD9e3"},
+		{"BitBTC", "StandardBridge", common.HexToAddress("0x0b651A42F32069d62d5ECf4f2a7e5Bd3E9438746")},
+		{"USX", "StandardBridge", common.HexToAddress("0x40E862341b2416345F02c41Ac70df08525150dC7")},
+		{"DAI", "StandardBridge", common.HexToAddress("0xb415e822C4983ecD6B1c1596e8a5f976cf6CD9e3")},
+		{"wstETH", "StandardBridge", common.HexToAddress("0x65321bf24210b81500230dCEce14Faa70a9f50a7")},
 	},
 }
 
-func BridgesByChainID(chainID *big.Int, client bind.ContractBackend, ctx context.Context) (map[string]Bridge, error) {
-	allCfgs := make([]*implConfig, 0)
-	allCfgs = append(allCfgs, defaultBridgeCfgs[chainID.Uint64()]...)
+func BridgesByChainID(chainID *big.Int, client bind.ContractBackend, addrs services.AddressManager) (map[string]Bridge, error) {
+	l1SBAddr, _ := addrs.L1StandardBridge()
+	allCfgs := []*implConfig{
+		{"Standard", "StandardBridge", l1SBAddr},
+		{"ETH", "ETHBridge", l1SBAddr},
+	}
 	allCfgs = append(allCfgs, customBridgeCfgs[chainID.Uint64()]...)
 
 	bridges := make(map[string]Bridge)
 	for _, bridge := range allCfgs {
 		switch bridge.impl {
 		case "StandardBridge":
-			l1StandardBridgeAddress := common.HexToAddress(bridge.addr)
-			l1StandardBridgeFilter, err := bindings.NewL1StandardBridgeFilterer(l1StandardBridgeAddress, client)
+			l1SB, err := bindings.NewL1StandardBridge(bridge.addr, client)
 			if err != nil {
 				return nil, err
 			}
-
 			standardBridge := &StandardBridge{
 				name:     bridge.name,
-				ctx:      ctx,
-				address:  l1StandardBridgeAddress,
-				client:   client,
-				filterer: l1StandardBridgeFilter,
+				address:  bridge.addr,
+				contract: l1SB,
 			}
 			bridges[bridge.name] = standardBridge
 		case "ETHBridge":
-			l1StandardBridgeAddress := common.HexToAddress(bridge.addr)
-			l1EthBridgeFilter, err := bindings.NewL1StandardBridgeFilterer(l1StandardBridgeAddress, client)
+			l1SB, err := bindings.NewL1StandardBridge(bridge.addr, client)
 			if err != nil {
 				return nil, err
 			}
-
 			ethBridge := &EthBridge{
 				name:     bridge.name,
-				ctx:      ctx,
-				address:  l1StandardBridgeAddress,
-				client:   client,
-				filterer: l1EthBridgeFilter,
+				address:  bridge.addr,
+				contract: l1SB,
 			}
 			bridges[bridge.name] = ethBridge
 		default:
@@ -100,3 +92,12 @@ func BridgesByChainID(chainID *big.Int, client bind.ContractBackend, ctx context
 	}
 	return bridges, nil
 }
+
+func StateCommitmentChainScanner(client bind.ContractFilterer, addrs services.AddressManager) (*scc.StateCommitmentChainFilterer, error) {
+	sccAddr, _ := addrs.StateCommitmentChain()
+	filter, err := scc.NewStateCommitmentChainFilterer(sccAddr, client)
+	if err != nil {
+		return nil, err
+	}
+	return filter, nil
+}

indexer/services/l1/bridge/bridge.go.orig

+package bridge
+
+import (
+	"context"
+	"errors"
+	"math/big"
+
+	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
+	"github.com/ethereum-optimism/optimism/indexer/db"
+	"github.com/ethereum-optimism/optimism/indexer/services"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+// DepositsMap is a collection of deposit objects keyed
+// on block hashes.
+type DepositsMap map[common.Hash][]db.Deposit
+<<<<<<< HEAD
+
+// WithdrawalsMap is a collection of withdrawal objects keyed
+// on block hashes.
+type WithdrawalsMap map[common.Hash][]db.Withdrawal
+
+// FinalizedWithdrawalsMap is a collection of finalized withdrawal
+// objected keyed on block hashes.
+=======
+type InitiatedWithdrawalMap map[common.Hash][]db.Withdrawal
+>>>>>>> 22c039efc (indexer: Upgrade L1 services)
+type FinalizedWithdrawalsMap map[common.Hash][]db.FinalizedWithdrawal
+
+type Bridge interface {
+	Address() common.Address
+	GetDepositsByBlockRange(context.Context, uint64, uint64) (DepositsMap, error)
+	String() string
+}
+
+type implConfig struct {
+	name string
+	impl string
+	addr common.Address
+}
+
+var customBridgeCfgs = map[uint64][]*implConfig{
+	// Mainnet
+	1: {
+		{"BitBTC", "StandardBridge", common.HexToAddress("0xaBA2c5F108F7E820C049D5Af70B16ac266c8f128")},
+		{"DAI", "StandardBridge", common.HexToAddress("0x10E6593CDda8c58a1d0f14C5164B376352a55f2F")},
+		{"wstETH", "StandardBridge", common.HexToAddress("0x76943C0D61395d8F2edF9060e1533529cAe05dE6")},
+	},
+	// Kovan
+	42: {
+		{"BitBTC", "StandardBridge", common.HexToAddress("0x0b651A42F32069d62d5ECf4f2a7e5Bd3E9438746")},
+		{"USX", "StandardBridge", common.HexToAddress("0x40E862341b2416345F02c41Ac70df08525150dC7")},
+		{"DAI", "StandardBridge", common.HexToAddress("0xb415e822C4983ecD6B1c1596e8a5f976cf6CD9e3")},
+		{"wstETH", "StandardBridge", common.HexToAddress("0x65321bf24210b81500230dCEce14Faa70a9f50a7")},
+	},
+}
+
+func BridgesByChainID(chainID *big.Int, client bind.ContractBackend, addrs services.AddressManager) (map[string]Bridge, error) {
+	l1SBAddr, _ := addrs.L1StandardBridge()
+	allCfgs := []*implConfig{
+		{"Standard", "StandardBridge", l1SBAddr},
+		{"ETH", "ETHBridge", l1SBAddr},
+	}
+	allCfgs = append(allCfgs, customBridgeCfgs[chainID.Uint64()]...)
+
+	bridges := make(map[string]Bridge)
+	for _, bridge := range allCfgs {
+		switch bridge.impl {
+		case "StandardBridge":
+			l1SB, err := bindings.NewL1StandardBridge(bridge.addr, client)
+			if err != nil {
+				return nil, err
+			}
+			standardBridge := &StandardBridge{
+				name:     bridge.name,
+				address:  bridge.addr,
+				contract: l1SB,
+			}
+			bridges[bridge.name] = standardBridge
+		case "ETHBridge":
+			l1SB, err := bindings.NewL1StandardBridge(bridge.addr, client)
+			if err != nil {
+				return nil, err
+			}
+			ethBridge := &EthBridge{
+				name:     bridge.name,
+				address:  bridge.addr,
+				contract: l1SB,
+			}
+			bridges[bridge.name] = ethBridge
+		default:
+			return nil, errors.New("unsupported bridge")
+		}
+	}
+	return bridges, nil
+}
+
+func StateCommitmentChainScanner(client bind.ContractFilterer, addrs services.AddressManager) (*scc.StateCommitmentChainFilterer, error) {
+	sccAddr, _ := addrs.StateCommitmentChain()
+	filter, err := scc.NewStateCommitmentChainFilterer(sccAddr, client)
+	if err != nil {
+		return nil, err
+	}
+	return filter, nil
+}

indexer/services/l1/bridge/eth_bridge.go

@@ -5,33 +5,40 @@ import (
 
 	"github.com/ethereum-optimism/optimism/indexer/db"
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-service/backoff"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
 
 type EthBridge struct {
 	name     string
-	ctx      context.Context
 	address  common.Address
-	client   bind.ContractFilterer
-	filterer *bindings.L1StandardBridgeFilterer
+	contract *bindings.L1StandardBridge
 }
 
 func (e *EthBridge) Address() common.Address {
 	return e.address
 }
 
-func (e *EthBridge) GetDepositsByBlockRange(start, end uint64) (DepositsMap, error) {
+func (e *EthBridge) GetDepositsByBlockRange(ctx context.Context, start, end uint64) (DepositsMap, error) {
 	depositsByBlockhash := make(DepositsMap)
+	opts := &bind.FilterOpts{
+		Context: ctx,
+		Start:   start,
+		End:     &end,
+	}
 
-	iter, err := FilterETHDepositInitiatedWithRetry(e.ctx, e.filterer, &bind.FilterOpts{
-		Start: start,
-		End:   &end,
+	var iter *bindings.L1StandardBridgeETHDepositInitiatedIterator
+	err := backoff.Do(3, backoff.Exponential(), func() error {
+		var err error
+		iter, err = e.contract.FilterETHDepositInitiated(opts, nil, nil)
+		return err
 	})
 	if err != nil {
-		logger.Error("Error fetching filter", "err", err)
+		return nil, err
 	}
 
+	defer iter.Close()
 	for iter.Next() {
 		depositsByBlockhash[iter.Event.Raw.BlockHash] = append(
 			depositsByBlockhash[iter.Event.Raw.BlockHash], db.Deposit{
@@ -43,41 +50,8 @@ func (e *EthBridge) GetDepositsByBlockRange(start, end uint64) (DepositsMap, err
 				LogIndex:    iter.Event.Raw.Index,
 			})
 	}
-	if err := iter.Error(); err != nil {
-		return nil, err
-	}
-
-	return depositsByBlockhash, nil
-}
-
-func (s *EthBridge) GetWithdrawalsByBlockRange(start, end uint64) (WithdrawalsMap, error) {
-	withdrawalsByBlockHash := make(WithdrawalsMap)
-
-	iter, err := FilterETHWithdrawalFinalizedWithRetry(s.ctx, s.filterer, &bind.FilterOpts{
-		Start: start,
-		End:   &end,
-	})
-
-	if err != nil {
-		logger.Error("Error fetching filter", "err", err)
-	}
-
-	for iter.Next() {
-		withdrawalsByBlockHash[iter.Event.Raw.BlockHash] = append(
-			withdrawalsByBlockHash[iter.Event.Raw.BlockHash], db.Withdrawal{
-				TxHash:      iter.Event.Raw.TxHash,
-				FromAddress: iter.Event.From,
-				ToAddress:   iter.Event.To,
-				Amount:      iter.Event.Amount,
-				Data:        iter.Event.ExtraData,
-				LogIndex:    iter.Event.Raw.Index,
-			})
-	}
-	if err := iter.Error(); err != nil {
-		return nil, err
-	}
 
-	return withdrawalsByBlockHash, nil
+	return depositsByBlockhash, iter.Error()
 }
 
 func (e *EthBridge) String() string {

indexer/services/l1/bridge/filter.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"time"
 
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 )
 
@@ -12,61 +12,13 @@ import (
 // calls.
 var clientRetryInterval = 5 * time.Second
 
-// FilterETHDepositInitiatedWithRetry retries the given func until it succeeds,
+// FilterStateBatchAppendedWithRetry retries the given func until it succeeds,
 // waiting for clientRetryInterval duration after every call.
-func FilterETHDepositInitiatedWithRetry(ctx context.Context, filterer *bindings.L1StandardBridgeFilterer, opts *bind.FilterOpts) (*bindings.L1StandardBridgeETHDepositInitiatedIterator, error) {
+func FilterStateBatchAppendedWithRetry(ctx context.Context, filterer *scc.StateCommitmentChainFilterer, opts *bind.FilterOpts) (*scc.StateCommitmentChainStateBatchAppendedIterator, error) {
 	for {
 		ctxt, cancel := context.WithTimeout(ctx, DefaultConnectionTimeout)
 		opts.Context = ctxt
-		res, err := filterer.FilterETHDepositInitiated(opts, nil, nil)
-		cancel()
-		if err == nil {
-			return res, nil
-		}
-		logger.Error("Error fetching filter", "err", err)
-		time.Sleep(clientRetryInterval)
-	}
-}
-
-// FilterERC20DepositInitiatedWithRetry retries the given func until it succeeds,
-// waiting for clientRetryInterval duration after every call.
-func FilterERC20DepositInitiatedWithRetry(ctx context.Context, filterer *bindings.L1StandardBridgeFilterer, opts *bind.FilterOpts) (*bindings.L1StandardBridgeERC20DepositInitiatedIterator, error) {
-	for {
-		ctxt, cancel := context.WithTimeout(ctx, DefaultConnectionTimeout)
-		opts.Context = ctxt
-		res, err := filterer.FilterERC20DepositInitiated(opts, nil, nil, nil)
-		cancel()
-		if err == nil {
-			return res, nil
-		}
-		logger.Error("Error fetching filter", "err", err)
-		time.Sleep(clientRetryInterval)
-	}
-}
-
-// FilterETHWithdrawalFinalizedWithRetry retries the given func until it succeeds,
-// waiting for clientRetryInterval duration after every call.
-func FilterETHWithdrawalFinalizedWithRetry(ctx context.Context, filterer *bindings.L1StandardBridgeFilterer, opts *bind.FilterOpts) (*bindings.L1StandardBridgeETHWithdrawalFinalizedIterator, error) {
-	for {
-		ctxt, cancel := context.WithTimeout(ctx, DefaultConnectionTimeout)
-		opts.Context = ctxt
-		res, err := filterer.FilterETHWithdrawalFinalized(opts, nil, nil)
-		cancel()
-		if err == nil {
-			return res, nil
-		}
-		logger.Error("Error fetching filter", "err", err)
-		time.Sleep(clientRetryInterval)
-	}
-}
-
-// FilterERC20WithdrawalFinalizedWithRetry retries the given func until it succeeds,
-// waiting for clientRetryInterval duration after every call.
-func FilterERC20WithdrawalFinalizedWithRetry(ctx context.Context, filterer *bindings.L1StandardBridgeFilterer, opts *bind.FilterOpts) (*bindings.L1StandardBridgeERC20WithdrawalFinalizedIterator, error) {
-	for {
-		ctxt, cancel := context.WithTimeout(ctx, DefaultConnectionTimeout)
-		opts.Context = ctxt
-		res, err := filterer.FilterERC20WithdrawalFinalized(opts, nil, nil, nil)
+		res, err := filterer.FilterStateBatchAppended(opts, nil)
 		cancel()
 		if err == nil {
 			return res, nil

indexer/services/l1/bridge/portal.go

+package bridge
+
+import (
+	"context"
+
+	"github.com/ethereum-optimism/optimism/indexer/db"
+	"github.com/ethereum-optimism/optimism/indexer/services"
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-service/backoff"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type Portal struct {
+	address  common.Address
+	contract *bindings.OptimismPortal
+}
+
+func NewPortal(addrs services.AddressManager) *Portal {
+	address, contract := addrs.OptimismPortal()
+
+	return &Portal{
+		address:  address,
+		contract: contract,
+	}
+}
+
+func (p *Portal) Address() common.Address {
+	return p.address
+}
+
+func (p *Portal) GetFinalizedWithdrawalsByBlockRange(ctx context.Context, start, end uint64) (FinalizedWithdrawalsMap, error) {
+	wdsByBlockHash := make(FinalizedWithdrawalsMap)
+	opts := &bind.FilterOpts{
+		Context: ctx,
+		Start:   start,
+		End:     &end,
+	}
+
+	var iter *bindings.OptimismPortalWithdrawalFinalizedIterator
+	err := backoff.Do(3, backoff.Exponential(), func() error {
+		var err error
+		iter, err = p.contract.FilterWithdrawalFinalized(opts, nil)
+		return err
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	defer iter.Close()
+	for iter.Next() {
+		wdsByBlockHash[iter.Event.Raw.BlockHash] = append(
+			wdsByBlockHash[iter.Event.Raw.BlockHash], db.FinalizedWithdrawal{
+				TxHash:         iter.Event.Raw.TxHash,
+				WithdrawalHash: iter.Event.WithdrawalHash,
+				Success:        iter.Event.Success,
+				LogIndex:       iter.Event.Raw.Index,
+			},
+		)
+	}
+
+	return wdsByBlockHash, iter.Error()
+}

indexer/services/l1/bridge/standard_bridge.go

@@ -5,33 +5,40 @@ import (
 
 	"github.com/ethereum-optimism/optimism/indexer/db"
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-service/backoff"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
 
 type StandardBridge struct {
 	name     string
-	ctx      context.Context
 	address  common.Address
-	client   bind.ContractFilterer
-	filterer *bindings.L1StandardBridgeFilterer
+	contract *bindings.L1StandardBridge
 }
 
 func (s *StandardBridge) Address() common.Address {
 	return s.address
 }
 
-func (s *StandardBridge) GetDepositsByBlockRange(start, end uint64) (DepositsMap, error) {
+func (s *StandardBridge) GetDepositsByBlockRange(ctx context.Context, start, end uint64) (DepositsMap, error) {
 	depositsByBlockhash := make(DepositsMap)
+	opts := &bind.FilterOpts{
+		Context: ctx,
+		Start:   start,
+		End:     &end,
+	}
 
-	iter, err := FilterERC20DepositInitiatedWithRetry(s.ctx, s.filterer, &bind.FilterOpts{
-		Start: start,
-		End:   &end,
+	var iter *bindings.L1StandardBridgeERC20DepositInitiatedIterator
+	err := backoff.Do(3, backoff.Exponential(), func() error {
+		var err error
+		iter, err = s.contract.FilterERC20DepositInitiated(opts, nil, nil, nil)
+		return err
 	})
 	if err != nil {
-		logger.Error("Error fetching filter", "err", err)
+		return nil, err
 	}
 
+	defer iter.Close()
 	for iter.Next() {
 		depositsByBlockhash[iter.Event.Raw.BlockHash] = append(
 			depositsByBlockhash[iter.Event.Raw.BlockHash], db.Deposit{
@@ -45,43 +52,8 @@ func (s *StandardBridge) GetDepositsByBlockRange(start, end uint64) (DepositsMap
 				LogIndex:    iter.Event.Raw.Index,
 			})
 	}
-	if err := iter.Error(); err != nil {
-		return nil, err
-	}
-
-	return depositsByBlockhash, nil
-}
-
-func (s *StandardBridge) GetWithdrawalsByBlockRange(start, end uint64) (WithdrawalsMap, error) {
-	withdrawalsByBlockHash := make(WithdrawalsMap)
-
-	iter, err := FilterERC20WithdrawalFinalizedWithRetry(s.ctx, s.filterer, &bind.FilterOpts{
-		Start: start,
-		End:   &end,
-	})
-
-	if err != nil {
-		logger.Error("Error fetching filter", "err", err)
-	}
-
-	for iter.Next() {
-		withdrawalsByBlockHash[iter.Event.Raw.BlockHash] = append(
-			withdrawalsByBlockHash[iter.Event.Raw.BlockHash], db.Withdrawal{
-				TxHash:      iter.Event.Raw.TxHash,
-				L1Token:     iter.Event.L1Token,
-				L2Token:     iter.Event.L2Token,
-				FromAddress: iter.Event.From,
-				ToAddress:   iter.Event.To,
-				Amount:      iter.Event.Amount,
-				Data:        iter.Event.ExtraData,
-				LogIndex:    iter.Event.Raw.Index,
-			})
-	}
-	if err := iter.Error(); err != nil {
-		return nil, err
-	}
 
-	return withdrawalsByBlockHash, nil
+	return depositsByBlockhash, iter.Error()
 }
 
 func (s *StandardBridge) String() string {

indexer/services/l1/confirmed_headers.go

@@ -17,9 +17,8 @@ import (
 )
 
 const (
-	DefaultConnectionTimeout        = 30 * time.Second
-	DefaultConfDepth         uint64 = 20
-	DefaultMaxBatchSize             = 100
+	DefaultConnectionTimeout = 30 * time.Second
+	DefaultMaxBatchSize      = 100
 )
 
 type NewHeader struct {

indexer/services/l1/query.go

 package l1
 
 import (
-	"github.com/ethereum/go-ethereum/ethclient"
+	"context"
 
+	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
 	"github.com/ethereum-optimism/optimism/indexer/db"
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/indexer/services/l1/bridge"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
 
-func QueryERC20(address common.Address, client *ethclient.Client) (*db.Token, error) {
-	contract, err := bindings.NewERC20(address, client)
-	if err != nil {
-		return nil, err
-	}
-
-	name, err := contract.Name(&bind.CallOpts{})
-	if err != nil {
-		return nil, err
-	}
+func QueryStateBatches(filterer *scc.StateCommitmentChainFilterer, startHeight, endHeight uint64, ctx context.Context) (map[common.Hash][]db.StateBatch, error) {
+	batches := make(map[common.Hash][]db.StateBatch)
 
-	symbol, err := contract.Symbol(&bind.CallOpts{})
+	iter, err := bridge.FilterStateBatchAppendedWithRetry(ctx, filterer, &bind.FilterOpts{
+		Start: startHeight,
+		End:   &endHeight,
+	})
 	if err != nil {
 		return nil, err
 	}
 
-	decimals, err := contract.Decimals(&bind.CallOpts{})
-	if err != nil {
-		return nil, err
+	defer iter.Close()
+	for iter.Next() {
+		batches[iter.Event.Raw.BlockHash] = append(
+			batches[iter.Event.Raw.BlockHash], db.StateBatch{
+				Index:     iter.Event.BatchIndex,
+				Root:      iter.Event.BatchRoot,
+				Size:      iter.Event.BatchSize,
+				PrevTotal: iter.Event.PrevTotalElements,
+				ExtraData: iter.Event.ExtraData,
+				BlockHash: iter.Event.Raw.BlockHash,
+			})
 	}
-
-	return &db.Token{
-		Name:     name,
-		Symbol:   symbol,
-		Decimals: decimals,
-	}, nil
+	return batches, iter.Error()
 }

indexer/services/l1/service.go

@@ -11,7 +11,10 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
 	"github.com/ethereum-optimism/optimism/indexer/metrics"
+	"github.com/ethereum-optimism/optimism/indexer/services"
+	"github.com/ethereum-optimism/optimism/indexer/services/query"
 	"github.com/prometheus/client_golang/prometheus"
 
 	"github.com/ethereum-optimism/optimism/indexer/server"
@@ -36,28 +39,8 @@ var errNoChainID = errors.New("no chain id provided")
 
 var errNoNewBlocks = errors.New("no new blocks")
 
-// clientRetryInterval is the interval to wait between retrying client API
-// calls.
-var clientRetryInterval = 5 * time.Second
-
 var ZeroAddress common.Address
 
-// HeaderByNumberWithRetry retries the given func until it succeeds, waiting
-// for clientRetryInterval duration after every call.
-func HeaderByNumberWithRetry(ctx context.Context,
-	client *ethclient.Client) (*types.Header, error) {
-	for {
-		res, err := client.HeaderByNumber(ctx, nil)
-		switch err {
-		case nil:
-			return res, err
-		default:
-			log.Error("Error fetching header", "err", err)
-		}
-		time.Sleep(clientRetryInterval)
-	}
-}
-
 // Driver is an interface for indexing deposits from l1.
 type Driver interface {
 	// Name is an identifier used to prefix logs for a particular service.
@@ -70,11 +53,12 @@ type ServiceConfig struct {
 	L1Client           *ethclient.Client
 	RawL1Client        *rpc.Client
 	ChainID            *big.Int
+	AddressManager     services.AddressManager
 	ConfDepth          uint64
 	MaxHeaderBatchSize uint64
 	StartBlockNumber   uint64
-	StartBlockHash     string
 	DB                 *db.Database
+	Bedrock            bool
 }
 
 type Service struct {
@@ -83,11 +67,14 @@ type Service struct {
 	cancel func()
 
 	bridges        map[string]bridge.Bridge
+	portal         *bridge.Portal
+	batchScanner   *scc.StateCommitmentChainFilterer
 	latestHeader   uint64
 	headerSelector *ConfirmedHeaderSelector
 
 	metrics    *metrics.Metrics
 	tokenCache map[common.Address]*db.Token
+	isBedrock  bool
 	wg         sync.WaitGroup
 }
 
@@ -113,11 +100,24 @@ func NewService(cfg ServiceConfig) (*Service, error) {
 		return nil, fmt.Errorf("chain ID configured with %d but got %d", cfg.ChainID, chainID)
 	}
 
-	bridges, err := bridge.BridgesByChainID(cfg.ChainID, cfg.L1Client, ctx)
+	bridges, err := bridge.BridgesByChainID(cfg.ChainID, cfg.L1Client, cfg.AddressManager)
 	if err != nil {
 		cancel()
 		return nil, err
 	}
+
+	var portal *bridge.Portal
+	var batchScanner *scc.StateCommitmentChainFilterer
+	if cfg.Bedrock {
+		portal = bridge.NewPortal(cfg.AddressManager)
+	} else {
+		batchScanner, err = bridge.StateCommitmentChainScanner(cfg.L1Client, cfg.AddressManager)
+		if err != nil {
+			cancel()
+			return nil, err
+		}
+	}
+
 	logger.Info("Scanning bridges for deposits", "bridges", bridges)
 
 	confirmedHeaderSelector, err := NewConfirmedHeaderSelector(HeaderSelectorConfig{
@@ -130,22 +130,29 @@ func NewService(cfg ServiceConfig) (*Service, error) {
 		return nil, err
 	}
 
-	return &Service{
+	service := &Service{
 		cfg:            cfg,
 		ctx:            ctx,
 		cancel:         cancel,
+		portal:         portal,
 		bridges:        bridges,
+		batchScanner:   batchScanner,
 		headerSelector: confirmedHeaderSelector,
 		metrics:        cfg.Metrics,
 		tokenCache: map[common.Address]*db.Token{
 			ZeroAddress: db.ETHL1Token,
 		},
-	}, nil
+		isBedrock: cfg.Bedrock,
+	}
+	service.wg.Add(1)
+	return service, nil
 }
 
-func (s *Service) Loop(ctx context.Context) {
+func (s *Service) loop() {
+	defer s.wg.Done()
+
 	for {
-		err := s.catchUp(ctx)
+		err := s.catchUp()
 		if err == nil {
 			break
 		}
@@ -159,10 +166,18 @@ func (s *Service) Loop(ctx context.Context) {
 	}
 
 	newHeads := make(chan *types.Header, 1000)
-	go s.subscribeNewHeads(ctx, newHeads)
+	tick := time.NewTicker(5 * time.Second)
+	defer tick.Stop()
 
 	for {
 		select {
+		case <-tick.C:
+			header, err := query.HeaderByNumberWithRetry(s.ctx, s.cfg.L1Client)
+			if err != nil {
+				logger.Error("error fetching header by number", "err", err)
+				continue
+			}
+			newHeads <- header
 		case header := <-newHeads:
 			if header == nil {
 				break
@@ -180,6 +195,7 @@ func (s *Service) Loop(ctx context.Context) {
 				}
 			}
 		case <-s.ctx.Done():
+			logger.Info("service stopped")
 			return
 		}
 	}
@@ -188,7 +204,6 @@ func (s *Service) Loop(ctx context.Context) {
 func (s *Service) Update(newHeader *types.Header) error {
 	var lowest = db.BlockLocator{
 		Number: s.cfg.StartBlockNumber,
-		Hash:   common.HexToHash(s.cfg.StartBlockHash),
 	}
 	highestConfirmed, err := s.cfg.DB.GetHighestL1Block()
 	if err != nil {
@@ -213,7 +228,7 @@ func (s *Service) Update(newHeader *types.Header) error {
 		return nil
 	}
 
-	if lowest.Hash != headers[0].ParentHash {
+	if lowest.Number > 0 && lowest.Hash != headers[0].ParentHash {
 		logger.Error("Parent hash does not connect to ",
 			"block", headers[0].Number.Uint64(), "hash", headers[0].Hash,
 			"lowest_block", lowest.Number, "hash", lowest.Hash)
@@ -223,7 +238,6 @@ func (s *Service) Update(newHeader *types.Header) error {
 	startHeight := headers[0].Number.Uint64()
 	endHeight := headers[len(headers)-1].Number.Uint64()
 	depositsByBlockHash := make(map[common.Hash][]db.Deposit)
-	withdrawalsByBlockHash := make(map[common.Hash][]db.Withdrawal)
 
 	start := prometheus.NewTimer(s.metrics.UpdateDuration.WithLabelValues("l1"))
 	defer func() {
@@ -232,27 +246,27 @@ func (s *Service) Update(newHeader *types.Header) error {
 	}()
 
 	bridgeDepositsCh := make(chan bridge.DepositsMap, len(s.bridges))
-	bridgeWdsCh := make(chan bridge.WithdrawalsMap, len(s.bridges))
-	errCh := make(chan error, len(s.bridges))
+	finalizedWithdrawalsCh := make(chan bridge.FinalizedWithdrawalsMap, 1)
+	errCh := make(chan error, len(s.bridges)+1)
 
 	for _, bridgeImpl := range s.bridges {
 		go func(b bridge.Bridge) {
-			deposits, err := b.GetDepositsByBlockRange(startHeight, endHeight)
+			deposits, err := b.GetDepositsByBlockRange(s.ctx, startHeight, endHeight)
 			if err != nil {
 				errCh <- err
 				return
 			}
 			bridgeDepositsCh <- deposits
 		}(bridgeImpl)
-		go func(b bridge.Bridge) {
-			withdrawals, err := b.GetWithdrawalsByBlockRange(startHeight, endHeight)
-			if err != nil {
-				errCh <- err
-				return
-			}
-			bridgeWdsCh <- withdrawals
-		}(bridgeImpl)
 	}
+	go func() {
+		finalizedWithdrawals, err := s.portal.GetFinalizedWithdrawalsByBlockRange(s.ctx, startHeight, endHeight)
+		if err != nil {
+			errCh <- err
+			return
+		}
+		finalizedWithdrawalsCh <- finalizedWithdrawals
+	}()
 
 	var receives int
 	for {
@@ -260,49 +274,54 @@ func (s *Service) Update(newHeader *types.Header) error {
 		case bridgeDeposits := <-bridgeDepositsCh:
 			for blockHash, deposits := range bridgeDeposits {
 				for _, deposit := range deposits {
-					if err := s.cacheToken(deposit.L1Token); err != nil {
+					if err := s.cacheToken(deposit); err != nil {
 						logger.Warn("error caching token", "err", err)
 					}
 				}
 
 				depositsByBlockHash[blockHash] = append(depositsByBlockHash[blockHash], deposits...)
 			}
-		case bridgeWithdrawals := <-bridgeWdsCh:
-			for blockHash, withdrawals := range bridgeWithdrawals {
-				for _, withdrawal := range withdrawals {
-					if err := s.cacheToken(withdrawal.L1Token); err != nil {
-						logger.Warn("error caching token", "err", err)
-					}
-				}
-
-				withdrawalsByBlockHash[blockHash] = append(withdrawalsByBlockHash[blockHash], withdrawals...)
-			}
 		case err := <-errCh:
 			return err
 		}
 
 		receives++
-		if receives == 2*len(s.bridges) {
+		if receives == len(s.bridges) {
 			break
 		}
 	}
 
+	finalizedWithdrawalsByBlockHash := <-finalizedWithdrawalsCh
+
+	var stateBatches map[common.Hash][]db.StateBatch
+	if !s.isBedrock {
+		stateBatches, err = QueryStateBatches(s.batchScanner, startHeight, endHeight, s.ctx)
+		if err != nil {
+			logger.Error("Error querying state batches", "err", err)
+			return err
+		}
+	}
+
 	for i, header := range headers {
 		blockHash := header.Hash
 		number := header.Number.Uint64()
 		deposits := depositsByBlockHash[blockHash]
-		withdrawals := withdrawalsByBlockHash[blockHash]
+		batches := stateBatches[blockHash]
+		finalizedWds := finalizedWithdrawalsByBlockHash[blockHash]
 
-		if len(deposits) == 0 && len(withdrawals) == 0 && i != len(headers)-1 {
+		// Always record block data in the last block
+		// in the list of headers
+		if len(deposits) == 0 && len(batches) == 0 && len(finalizedWds) == 0 && i != len(headers)-1 {
 			continue
 		}
 
 		block := &db.IndexedL1Block{
-			Hash:       blockHash,
-			ParentHash: header.ParentHash,
-			Number:     number,
-			Timestamp:  header.Time,
-			Deposits:   deposits,
+			Hash:                 blockHash,
+			ParentHash:           header.ParentHash,
+			Number:               number,
+			Timestamp:            header.Time,
+			Deposits:             deposits,
+			FinalizedWithdrawals: finalizedWds,
 		}
 
 		err := s.cfg.DB.AddIndexedL1Block(block)
@@ -310,24 +329,35 @@ func (s *Service) Update(newHeader *types.Header) error {
 			logger.Error(
 				"Unable to import ",
 				"block", number,
-				"hash", blockHash,
-				"err", err,
+				"hash", blockHash, "err", err,
+				"block", block,
+			)
+			return err
+		}
+
+		err = s.cfg.DB.AddStateBatch(batches)
+		if err != nil {
+			logger.Error(
+				"Unable to import state append batch",
+				"block", number,
+				"hash", blockHash, "err", err,
 				"block", block,
 			)
 			return err
 		}
+		s.metrics.RecordStateBatches(len(batches))
 
 		logger.Debug("Imported ",
 			"block", number, "hash", blockHash, "deposits", len(block.Deposits))
 		for _, deposit := range block.Deposits {
-			token := s.tokenCache[deposit.L2Token]
+			token := s.tokenCache[deposit.L1Token]
 			logger.Info(
-				"indexed deposit ",
+				"indexed deposit",
 				"tx_hash", deposit.TxHash,
 				"symbol", token.Symbol,
 				"amount", deposit.Amount,
 			)
-			s.metrics.RecordDeposit(deposit.L2Token)
+			s.metrics.RecordDeposit(deposit.L1Token)
 		}
 	}
 
@@ -382,8 +412,8 @@ func (s *Service) GetDeposits(w http.ResponseWriter, r *http.Request) {
 	}
 
 	page := db.PaginationParam{
-		Limit:  uint64(limit),
-		Offset: uint64(offset),
+		Limit:  limit,
+		Offset: offset,
 	}
 
 	deposits, err := s.cfg.DB.GetDepositsByAddress(common.HexToAddress(vars["address"]), page)
@@ -395,25 +425,8 @@ func (s *Service) GetDeposits(w http.ResponseWriter, r *http.Request) {
 	server.RespondWithJSON(w, http.StatusOK, deposits)
 }
 
-func (s *Service) subscribeNewHeads(ctx context.Context, heads chan *types.Header) {
-	tick := time.NewTicker(5 * time.Second)
-
-	for {
-		select {
-		case <-tick.C:
-			header, err := HeaderByNumberWithRetry(ctx, s.cfg.L1Client)
-			if err != nil {
-				logger.Error("error fetching header by number", "err", err)
-			}
-			heads <- header
-		case <-ctx.Done():
-			return
-		}
-	}
-}
-
-func (s *Service) catchUp(ctx context.Context) error {
-	realHead, err := HeaderByNumberWithRetry(ctx, s.cfg.L1Client)
+func (s *Service) catchUp() error {
+	realHead, err := query.HeaderByNumberWithRetry(s.ctx, s.cfg.L1Client)
 	if err != nil {
 		return err
 	}
@@ -437,8 +450,8 @@ func (s *Service) catchUp(ctx context.Context) error {
 
 	for realHeadNum-s.cfg.ConfDepth > currHeadNum+s.cfg.MaxHeaderBatchSize {
 		select {
-		case <-ctx.Done():
-			return context.Canceled
+		case <-s.ctx.Done():
+			return s.ctx.Err()
 		default:
 			if err := s.Update(realHead); err != nil && err != errNoNewBlocks {
 				return err
@@ -456,33 +469,33 @@ func (s *Service) catchUp(ctx context.Context) error {
 	return nil
 }
 
-func (s *Service) cacheToken(address common.Address) error {
-	if s.tokenCache[address] != nil {
+func (s *Service) cacheToken(deposit db.Deposit) error {
+	if s.tokenCache[deposit.L1Token] != nil {
 		return nil
 	}
 
-	token, err := s.cfg.DB.GetL1TokenByAddress(address.String())
+	token, err := s.cfg.DB.GetL1TokenByAddress(deposit.L1Token.String())
 	if err != nil {
 		return err
 	}
 	if token != nil {
 		s.metrics.IncL1CachedTokensCount()
-		s.tokenCache[address] = token
+		s.tokenCache[deposit.L1Token] = token
 		return nil
 	}
 
-	token, err = QueryERC20(address, s.cfg.L1Client)
+	token, err = query.NewERC20(deposit.L1Token, s.cfg.L1Client)
 	if err != nil {
 		logger.Error("Error querying ERC20 token details",
-			"l1_token", address.String(), "err", err)
+			"l1_token", deposit.L1Token.String(), "err", err)
 		token = &db.Token{
-			Address: address.String(),
+			Address: deposit.L1Token.String(),
 		}
 	}
-	if err := s.cfg.DB.AddL1Token(address.String(), token); err != nil {
+	if err := s.cfg.DB.AddL1Token(deposit.L1Token.String(), token); err != nil {
 		return err
 	}
-	s.tokenCache[address] = token
+	s.tokenCache[deposit.L1Token] = token
 	s.metrics.IncL1CachedTokensCount()
 	return nil
 }
@@ -491,16 +504,11 @@ func (s *Service) Start() error {
 	if s.cfg.ChainID == nil {
 		return errNoChainID
 	}
-	s.wg.Add(1)
-	go s.Loop(s.ctx)
+	go s.loop()
 	return nil
 }
 
 func (s *Service) Stop() {
 	s.cancel()
 	s.wg.Wait()
-	err := s.cfg.DB.Close()
-	if err != nil {
-		logger.Error("Error closing db", "err", err)
-	}
 }

indexer/services/l2/bridge/bridge.go

@@ -7,75 +7,76 @@ import (
 
 	"github.com/ethereum-optimism/optimism/indexer/db"
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
+	"github.com/ethereum/go-ethereum/ethclient"
 
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
 
-type DepositsMap map[common.Hash][]db.Deposit // Finalizations
 type WithdrawalsMap map[common.Hash][]db.Withdrawal
 
 type Bridge interface {
 	Address() common.Address
-	GetDepositsByBlockRange(uint64, uint64) (DepositsMap, error)
-	GetWithdrawalsByBlockRange(uint64, uint64) (WithdrawalsMap, error)
+	GetWithdrawalsByBlockRange(context.Context, uint64, uint64) (WithdrawalsMap, error)
 	String() string
 }
 
 type implConfig struct {
 	name string
 	impl string
-	addr string
+	addr common.Address
 }
 
-var defaultBridgeCfgs = map[uint64][]*implConfig{
-	// Devnet
-	901: {
-		{"Standard", "StandardBridge", L2StandardBridgeAddr},
-	},
-	// Goerli Alpha Testnet
-	28528: {
-		{"Standard", "StandardBridge", L2StandardBridgeAddr},
-	},
+var defaultBridgeCfgs = []*implConfig{
+	{"Standard", "StandardBridge", predeploys.L2StandardBridgeAddr},
 }
 
 var customBridgeCfgs = map[uint64][]*implConfig{
 	// Mainnet
 	10: {
-		{"BitBTC", StandardBridgeImpl, "0x158F513096923fF2d3aab2BcF4478536de6725e2"},
+		{"BitBTC", StandardBridgeImpl, common.HexToAddress("0x158F513096923fF2d3aab2BcF4478536de6725e2")},
 		//{"DAI", "DAIBridge", "0x467194771dAe2967Aef3ECbEDD3Bf9a310C76C65"},
+		{"wstETH", StandardBridgeImpl, common.HexToAddress("0x8E01013243a96601a86eb3153F0d9Fa4fbFb6957")},
 	},
 	// Kovan
 	69: {
-		{"BitBTC", StandardBridgeImpl, "0x0CFb46528a7002a7D8877a5F7a69b9AaF1A9058e"},
-		{"USX", StandardBridgeImpl, "0xB4d37826b14Cd3CB7257A2A5094507d701fe715f"},
+		{"BitBTC", StandardBridgeImpl, common.HexToAddress("0x0CFb46528a7002a7D8877a5F7a69b9AaF1A9058e")},
+		{"USX", StandardBridgeImpl, common.HexToAddress("0xB4d37826b14Cd3CB7257A2A5094507d701fe715f")},
+		{"wstETH", StandardBridgeImpl, common.HexToAddress("0x2E34e7d705AfaC3C4665b6feF31Aa394A1c81c92")},
 		//{"DAI", "	DAIBridge", "0x467194771dAe2967Aef3ECbEDD3Bf9a310C76C65"},
 	},
 }
 
-func BridgesByChainID(chainID *big.Int, client bind.ContractFilterer, ctx context.Context) (map[string]Bridge, error) {
+func BridgesByChainID(chainID *big.Int, client *ethclient.Client, isBedrock bool) (map[string]Bridge, error) {
 	allCfgs := make([]*implConfig, 0)
-	allCfgs = append(allCfgs, defaultBridgeCfgs[chainID.Uint64()]...)
+	allCfgs = append(allCfgs, defaultBridgeCfgs...)
 	allCfgs = append(allCfgs, customBridgeCfgs[chainID.Uint64()]...)
 
+	var l2L1MP *bindings.L2ToL1MessagePasser
+	var err error
+	if isBedrock {
+		l2L1MP, err = bindings.NewL2ToL1MessagePasser(predeploys.L2ToL1MessagePasserAddr, client)
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	bridges := make(map[string]Bridge)
 	for _, bridge := range allCfgs {
 		switch bridge.impl {
 		case "StandardBridge":
-			l2StandardBridgeAddress := common.HexToAddress(bridge.addr)
-			l2StandardBridgeFilter, err := bindings.NewL2StandardBridgeFilterer(l2StandardBridgeAddress, client)
+			l2SB, err := bindings.NewL2StandardBridge(bridge.addr, client)
 			if err != nil {
 				return nil, err
 			}
-
-			standardBridge := &StandardBridge{
-				name:     bridge.name,
-				ctx:      ctx,
-				address:  l2StandardBridgeAddress,
-				client:   client,
-				filterer: l2StandardBridgeFilter,
+			bridges[bridge.name] = &StandardBridge{
+				name:      bridge.name,
+				address:   bridge.addr,
+				client:    client,
+				l2SB:      l2SB,
+				l2L1MP:    l2L1MP,
+				isBedrock: isBedrock,
 			}
-			bridges[bridge.name] = standardBridge
 		default:
 			return nil, errors.New("unsupported bridge")
 		}

indexer/services/l2/bridge/filter.go

-package bridge
-
-import (
-	"context"
-	"time"
-
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-)
-
-// clientRetryInterval is the interval to wait between retrying client API
-// calls.
-var clientRetryInterval = 5 * time.Second
-
-// FilterWithdrawalInitiatedWithRetry retries the given func until it succeeds,
-// waiting for clientRetryInterval duration after every call.
-func FilterWithdrawalInitiatedWithRetry(ctx context.Context, filterer *bindings.L2StandardBridgeFilterer, opts *bind.FilterOpts) (*bindings.L2StandardBridgeWithdrawalInitiatedIterator, error) {
-	for {
-		ctxt, cancel := context.WithTimeout(ctx, DefaultConnectionTimeout)
-		opts.Context = ctxt
-		res, err := filterer.FilterWithdrawalInitiated(opts, nil, nil, nil)
-		cancel()
-		if err == nil {
-			return res, nil
-		}
-		logger.Error("Error fetching filter", "err", err)
-		time.Sleep(clientRetryInterval)
-	}
-}
-
-// FilterDepositFinalizedWithRetry retries the given func until it succeeds,
-// waiting for clientRetryInterval duration after every call.
-func FilterDepositFinalizedWithRetry(ctx context.Context, filterer *bindings.L2StandardBridgeFilterer, opts *bind.FilterOpts) (*bindings.L2StandardBridgeDepositFinalizedIterator, error) {
-	for {
-		ctxt, cancel := context.WithTimeout(ctx, DefaultConnectionTimeout)
-		opts.Context = ctxt
-		res, err := filterer.FilterDepositFinalized(opts, nil, nil, nil)
-		cancel()
-		if err == nil {
-			return res, nil
-		}
-		logger.Error("Error fetching filter", "err", err)
-		time.Sleep(clientRetryInterval)
-	}
-}

indexer/services/l2/bridge/standard_bridge.go

@@ -5,83 +5,112 @@ import (
 
 	"github.com/ethereum-optimism/optimism/indexer/db"
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-node/withdrawals"
+	"github.com/ethereum-optimism/optimism/op-service/backoff"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
 
 type StandardBridge struct {
-	name     string
-	ctx      context.Context
-	address  common.Address
-	client   bind.ContractFilterer
-	filterer *bindings.L2StandardBridgeFilterer
+	name      string
+	address   common.Address
+	client    *ethclient.Client
+	l2SB      *bindings.L2StandardBridge
+	l2L1MP    *bindings.L2ToL1MessagePasser
+	isBedrock bool
 }
 
 func (s *StandardBridge) Address() common.Address {
 	return s.address
 }
 
-func (s *StandardBridge) GetDepositsByBlockRange(start, end uint64) (DepositsMap, error) {
-	depositsByBlockhash := make(DepositsMap)
+func (s *StandardBridge) GetWithdrawalsByBlockRange(ctx context.Context, start, end uint64) (WithdrawalsMap, error) {
+	withdrawalsByBlockhash := make(map[common.Hash][]db.Withdrawal)
+	opts := &bind.FilterOpts{
+		Context: ctx,
+		Start:   start,
+		End:     &end,
+	}
 
-	iter, err := FilterDepositFinalizedWithRetry(s.ctx, s.filterer, &bind.FilterOpts{
-		Start: start,
-		End:   &end,
+	var iter *bindings.L2StandardBridgeWithdrawalInitiatedIterator
+	err := backoff.Do(3, backoff.Exponential(), func() error {
+		var err error
+		iter, err = s.l2SB.FilterWithdrawalInitiated(opts, nil, nil, nil)
+		return err
 	})
 	if err != nil {
-		logger.Error("Error fetching filter", "err", err)
+		return nil, err
 	}
 
+	receipts := make(map[common.Hash]*types.Receipt)
+	defer iter.Close()
 	for iter.Next() {
-		depositsByBlockhash[iter.Event.Raw.BlockHash] = append(
-			depositsByBlockhash[iter.Event.Raw.BlockHash], db.Deposit{
-				TxHash:      iter.Event.Raw.TxHash,
-				L1Token:     iter.Event.L1Token,
-				L2Token:     iter.Event.L2Token,
-				FromAddress: iter.Event.From,
-				ToAddress:   iter.Event.To,
-				Amount:      iter.Event.Amount,
-				Data:        iter.Event.ExtraData,
-				LogIndex:    iter.Event.Raw.Index,
-			})
-	}
-	if err := iter.Error(); err != nil {
-		return nil, err
-	}
+		ev := iter.Event
+		if s.isBedrock {
+			receipt := receipts[ev.Raw.TxHash]
+			if receipt == nil {
+				receipt, err = s.client.TransactionReceipt(ctx, ev.Raw.TxHash)
+				if err != nil {
+					return nil, err
+				}
+				receipts[ev.Raw.TxHash] = receipt
+			}
 
-	return depositsByBlockhash, nil
-}
+			var withdrawalInitiated *bindings.L2ToL1MessagePasserMessagePassed
+			for _, eLog := range receipt.Logs {
+				if len(eLog.Topics) == 0 || eLog.Topics[0] != withdrawals.MessagePassedTopic {
+					continue
+				}
 
-func (s *StandardBridge) GetWithdrawalsByBlockRange(start, end uint64) (WithdrawalsMap, error) {
-	withdrawalsByBlockhash := make(map[common.Hash][]db.Withdrawal)
+				if withdrawalInitiated != nil {
+					logger.Warn("detected multiple withdrawal initiated events! ignoring", "tx_hash", ev.Raw.TxHash)
+					continue
+				}
 
-	iter, err := FilterWithdrawalInitiatedWithRetry(s.ctx, s.filterer, &bind.FilterOpts{
-		Start: start,
-		End:   &end,
-	})
-	if err != nil {
-		logger.Error("Error fetching filter", "err", err)
-	}
+				withdrawalInitiated, err = s.l2L1MP.ParseMessagePassed(*eLog)
+				if err != nil {
+					return nil, err
+				}
+			}
 
-	for iter.Next() {
-		withdrawalsByBlockhash[iter.Event.Raw.BlockHash] = append(
-			withdrawalsByBlockhash[iter.Event.Raw.BlockHash], db.Withdrawal{
-				TxHash:      iter.Event.Raw.TxHash,
-				L1Token:     iter.Event.L1Token,
-				L2Token:     iter.Event.L2Token,
-				FromAddress: iter.Event.From,
-				ToAddress:   iter.Event.To,
-				Amount:      iter.Event.Amount,
-				Data:        iter.Event.ExtraData,
-				LogIndex:    iter.Event.Raw.Index,
-			})
-	}
-	if err := iter.Error(); err != nil {
-		return nil, err
+			hash, err := withdrawals.WithdrawalHash(withdrawalInitiated)
+			if err != nil {
+				return nil, err
+			}
+
+			withdrawalsByBlockhash[ev.Raw.BlockHash] = append(
+				withdrawalsByBlockhash[ev.Raw.BlockHash], db.Withdrawal{
+					TxHash:      ev.Raw.TxHash,
+					L1Token:     ev.L1Token,
+					L2Token:     ev.L2Token,
+					FromAddress: ev.From,
+					ToAddress:   ev.To,
+					Amount:      ev.Amount,
+					Data:        ev.ExtraData,
+					LogIndex:    ev.Raw.Index,
+					BedrockHash: &hash,
+				},
+			)
+		} else {
+			withdrawalsByBlockhash[ev.Raw.BlockHash] = append(
+				withdrawalsByBlockhash[ev.Raw.BlockHash], db.Withdrawal{
+					TxHash:      ev.Raw.TxHash,
+					L1Token:     ev.L1Token,
+					L2Token:     ev.L2Token,
+					FromAddress: ev.From,
+					ToAddress:   ev.To,
+					Amount:      ev.Amount,
+					Data:        ev.ExtraData,
+					LogIndex:    ev.Raw.Index,
+				},
+			)
+		}
 	}
 
-	return withdrawalsByBlockhash, nil
+	return withdrawalsByBlockhash, iter.Error()
 }
 
 func (s *StandardBridge) String() string {

indexer/services/l2/confirmed_headers.go

@@ -147,8 +147,7 @@ func (f *ConfirmedHeaderSelector) NewHead(
 	return headers, nil
 }
 
-func NewConfirmedHeaderSelector(cfg HeaderSelectorConfig) (*ConfirmedHeaderSelector,
-	error) {
+func NewConfirmedHeaderSelector(cfg HeaderSelectorConfig) (*ConfirmedHeaderSelector, error) {
 	if cfg.ConfDepth == 0 {
 		return nil, errors.New("ConfDepth must be greater than zero")
 	}

indexer/services/l2/service.go

@@ -12,6 +12,8 @@ import (
 
 	"github.com/ethereum-optimism/optimism/indexer/metrics"
 	"github.com/ethereum-optimism/optimism/indexer/server"
+	"github.com/ethereum-optimism/optimism/indexer/services/query"
+	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	"github.com/prometheus/client_golang/prometheus"
 
 	"github.com/ethereum-optimism/optimism/indexer/db"
@@ -38,37 +40,18 @@ var errWrongChainID = errors.New("wrong chain id provided")
 
 var errNoNewBlocks = errors.New("no new blocks")
 
-// clientRetryInterval is the interval to wait between retrying client API
-// calls.
-var clientRetryInterval = 5 * time.Second
-
-// HeaderByNumberWithRetry retries the given func until it succeeds, waiting
-// for clientRetryInterval duration after every call.
-func HeaderByNumberWithRetry(ctx context.Context,
-	client *ethclient.Client) (*types.Header, error) {
-	for {
-		res, err := client.HeaderByNumber(ctx, nil)
-		switch err {
-		case nil:
-			return res, err
-		default:
-			log.Error("Error fetching header", "err", err)
-		}
-		time.Sleep(clientRetryInterval)
-	}
-}
-
 type ServiceConfig struct {
-	Context            context.Context
-	Metrics            *metrics.Metrics
-	L2RPC              *rpc.Client
-	L2Client           *ethclient.Client
-	ChainID            *big.Int
+	Context  context.Context
+	Metrics  *metrics.Metrics
+	L2RPC    *rpc.Client
+	L2Client *ethclient.Client
+	ChainID  *big.Int
+
 	ConfDepth          uint64
 	MaxHeaderBatchSize uint64
 	StartBlockNumber   uint64
-	StartBlockHash     string
 	DB                 *db.Database
+	Bedrock            bool
 }
 
 type Service struct {
@@ -113,7 +96,7 @@ func NewService(cfg ServiceConfig) (*Service, error) {
 		cfg.ChainID = chainID
 	}
 
-	bridges, err := bridge.BridgesByChainID(cfg.ChainID, cfg.L2Client, ctx)
+	bridges, err := bridge.BridgesByChainID(cfg.ChainID, cfg.L2Client, cfg.Bedrock)
 	if err != nil {
 		cancel()
 		return nil, err
@@ -131,7 +114,7 @@ func NewService(cfg ServiceConfig) (*Service, error) {
 		return nil, err
 	}
 
-	return &Service{
+	service := &Service{
 		cfg:            cfg,
 		ctx:            ctx,
 		cancel:         cancel,
@@ -139,14 +122,18 @@ func NewService(cfg ServiceConfig) (*Service, error) {
 		headerSelector: confirmedHeaderSelector,
 		metrics:        cfg.Metrics,
 		tokenCache: map[common.Address]*db.Token{
-			db.ETHL2Address: db.ETHL1Token,
+			predeploys.LegacyERC20ETHAddr: db.ETHL1Token,
 		},
-	}, nil
+	}
+	service.wg.Add(1)
+	return service, nil
 }
 
-func (s *Service) Loop(ctx context.Context) {
+func (s *Service) loop() {
+	defer s.wg.Done()
+
 	for {
-		err := s.catchUp(ctx)
+		err := s.catchUp()
 		if err == nil {
 			break
 		}
@@ -160,10 +147,18 @@ func (s *Service) Loop(ctx context.Context) {
 	}
 
 	newHeads := make(chan *types.Header, 1000)
-	go s.subscribeNewHeads(ctx, newHeads)
+	tick := time.NewTicker(5 * time.Second)
+	defer tick.Stop()
 
 	for {
 		select {
+		case <-tick.C:
+			header, err := query.HeaderByNumberWithRetry(s.ctx, s.cfg.L2Client)
+			if err != nil {
+				logger.Error("error fetching header by number", "err", err)
+				continue
+			}
+			newHeads <- header
 		case header := <-newHeads:
 			logger.Info("Received new header", "header", header.Hash)
 			for {
@@ -176,6 +171,7 @@ func (s *Service) Loop(ctx context.Context) {
 				}
 			}
 		case <-s.ctx.Done():
+			logger.Info("service stopped")
 			return
 		}
 	}
@@ -184,7 +180,6 @@ func (s *Service) Loop(ctx context.Context) {
 func (s *Service) Update(newHeader *types.Header) error {
 	var lowest = db.BlockLocator{
 		Number: s.cfg.StartBlockNumber,
-		Hash:   common.HexToHash(s.cfg.StartBlockHash),
 	}
 	highestConfirmed, err := s.cfg.DB.GetHighestL2Block()
 	if err != nil {
@@ -209,7 +204,7 @@ func (s *Service) Update(newHeader *types.Header) error {
 		return nil
 	}
 
-	if lowest.Hash != headers[0].ParentHash {
+	if lowest.Number > 0 && lowest.Hash != headers[0].ParentHash {
 		logger.Error("Parent hash does not connect to ",
 			"block", headers[0].Number.Uint64(), "hash", headers[0].Hash(),
 			"lowest_block", lowest.Number, "hash", lowest.Hash)
@@ -218,7 +213,6 @@ func (s *Service) Update(newHeader *types.Header) error {
 
 	startHeight := headers[0].Number.Uint64()
 	endHeight := headers[len(headers)-1].Number.Uint64()
-	depositsByBlockHash := make(map[common.Hash][]db.Deposit)
 	withdrawalsByBlockHash := make(map[common.Hash][]db.Withdrawal)
 
 	start := prometheus.NewTimer(s.metrics.UpdateDuration.WithLabelValues("l2"))
@@ -227,21 +221,12 @@ func (s *Service) Update(newHeader *types.Header) error {
 		logger.Info("updated index", "start_height", startHeight, "end_height", endHeight, "duration", dur)
 	}()
 
-	bridgeDepositsCh := make(chan bridge.DepositsMap, len(s.bridges))
 	bridgeWdsCh := make(chan bridge.WithdrawalsMap)
 	errCh := make(chan error, len(s.bridges))
 
 	for _, bridgeImpl := range s.bridges {
 		go func(b bridge.Bridge) {
-			deposits, err := b.GetDepositsByBlockRange(startHeight, endHeight)
-			if err != nil {
-				errCh <- err
-				return
-			}
-			bridgeDepositsCh <- deposits
-		}(bridgeImpl)
-		go func(b bridge.Bridge) {
-			wds, err := b.GetWithdrawalsByBlockRange(startHeight, endHeight)
+			wds, err := b.GetWithdrawalsByBlockRange(s.ctx, startHeight, endHeight)
 			if err != nil {
 				errCh <- err
 				return
@@ -256,29 +241,19 @@ func (s *Service) Update(newHeader *types.Header) error {
 		case bridgeWds := <-bridgeWdsCh:
 			for blockHash, withdrawals := range bridgeWds {
 				for _, wd := range withdrawals {
-					if err := s.cacheToken(wd.L2Token); err != nil {
+					if err := s.cacheToken(wd); err != nil {
 						logger.Warn("error caching token", "err", err)
 					}
 				}
 
 				withdrawalsByBlockHash[blockHash] = append(withdrawalsByBlockHash[blockHash], withdrawals...)
 			}
-		case bridgeDeposits := <-bridgeDepositsCh:
-			for blockHash, deposits := range bridgeDeposits {
-				for _, deposit := range deposits {
-					if err := s.cacheToken(deposit.L2Token); err != nil {
-						logger.Warn("error caching token", "err", err)
-					}
-				}
-
-				depositsByBlockHash[blockHash] = append(depositsByBlockHash[blockHash], deposits...)
-			}
 		case err := <-errCh:
 			return err
 		}
 
 		receives++
-		if receives == 2*len(s.bridges) {
+		if receives == len(s.bridges) {
 			break
 		}
 	}
@@ -356,8 +331,21 @@ func (s *Service) GetIndexerStatus(w http.ResponseWriter, r *http.Request) {
 	server.RespondWithJSON(w, http.StatusOK, status)
 }
 
-func (s *Service) GetWithdrawalStatus(w http.ResponseWriter, r *http.Request) {
-	// Temporary stub until rest of indexer is landed
+func (s *Service) GetWithdrawalBatch(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	hash := vars["hash"]
+	if hash == "" {
+		server.RespondWithError(w, http.StatusBadRequest, "must specify a hash")
+		return
+	}
+
+	batch, err := s.cfg.DB.GetWithdrawalBatch(common.HexToHash(vars["hash"]))
+	if err != nil {
+		server.RespondWithError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	server.RespondWithJSON(w, http.StatusOK, batch)
 }
 
 func (s *Service) GetWithdrawals(w http.ResponseWriter, r *http.Request) {
@@ -380,12 +368,14 @@ func (s *Service) GetWithdrawals(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	finalizationState := db.ParseFinalizationState(r.URL.Query().Get("finalized"))
+
 	page := db.PaginationParam{
-		Limit:  uint64(limit),
-		Offset: uint64(offset),
+		Limit:  limit,
+		Offset: offset,
 	}
 
-	withdrawals, err := s.cfg.DB.GetWithdrawalsByAddress(common.HexToAddress(vars["address"]), page)
+	withdrawals, err := s.cfg.DB.GetWithdrawalsByAddress(common.HexToAddress(vars["address"]), page, finalizationState)
 	if err != nil {
 		server.RespondWithError(w, http.StatusInternalServerError, err.Error())
 		return
@@ -394,25 +384,8 @@ func (s *Service) GetWithdrawals(w http.ResponseWriter, r *http.Request) {
 	server.RespondWithJSON(w, http.StatusOK, withdrawals)
 }
 
-func (s *Service) subscribeNewHeads(ctx context.Context, heads chan *types.Header) {
-	tick := time.NewTicker(5 * time.Second)
-
-	for {
-		select {
-		case <-tick.C:
-			header, err := HeaderByNumberWithRetry(ctx, s.cfg.L2Client)
-			if err != nil {
-				logger.Error("error fetching header by number", "err", err)
-			}
-			heads <- header
-		case <-ctx.Done():
-			return
-		}
-	}
-}
-
-func (s *Service) catchUp(ctx context.Context) error {
-	realHead, err := HeaderByNumberWithRetry(ctx, s.cfg.L2Client)
+func (s *Service) catchUp() error {
+	realHead, err := query.HeaderByNumberWithRetry(s.ctx, s.cfg.L2Client)
 	if err != nil {
 		return err
 	}
@@ -436,8 +409,8 @@ func (s *Service) catchUp(ctx context.Context) error {
 
 	for realHeadNum-s.cfg.ConfDepth > currHeadNum+s.cfg.MaxHeaderBatchSize {
 		select {
-		case <-ctx.Done():
-			return context.Canceled
+		case <-s.ctx.Done():
+			return s.ctx.Err()
 		default:
 			if err := s.Update(realHead); err != nil && err != errNoNewBlocks {
 				return err
@@ -455,32 +428,32 @@ func (s *Service) catchUp(ctx context.Context) error {
 	return nil
 }
 
-func (s *Service) cacheToken(address common.Address) error {
-	if s.tokenCache[address] != nil {
+func (s *Service) cacheToken(withdrawal db.Withdrawal) error {
+	if s.tokenCache[withdrawal.L2Token] != nil {
 		return nil
 	}
 
-	token, err := s.cfg.DB.GetL2TokenByAddress(address.String())
+	token, err := s.cfg.DB.GetL2TokenByAddress(withdrawal.L2Token.String())
 	if err != nil {
 		return err
 	}
 	if token != nil {
 		s.metrics.IncL2CachedTokensCount()
-		s.tokenCache[address] = token
+		s.tokenCache[withdrawal.L2Token] = token
 		return nil
 	}
-	token, err = QueryERC20(address, s.cfg.L2Client)
+	token, err = query.NewERC20(withdrawal.L2Token, s.cfg.L2Client)
 	if err != nil {
 		logger.Error("Error querying ERC20 token details",
-			"l2_token", address.String(), "err", err)
+			"l2_token", withdrawal.L2Token.String(), "err", err)
 		token = &db.Token{
-			Address: address.String(),
+			Address: withdrawal.L2Token.String(),
 		}
 	}
-	if err := s.cfg.DB.AddL2Token(address.String(), token); err != nil {
+	if err := s.cfg.DB.AddL2Token(withdrawal.L2Token.String(), token); err != nil {
 		return err
 	}
-	s.tokenCache[address] = token
+	s.tokenCache[withdrawal.L2Token] = token
 	s.metrics.IncL2CachedTokensCount()
 	return nil
 }
@@ -489,16 +462,11 @@ func (s *Service) Start() error {
 	if s.cfg.ChainID == nil {
 		return errNoChainID
 	}
-	s.wg.Add(1)
-	go s.Loop(s.ctx)
+	go s.loop()
 	return nil
 }
 
 func (s *Service) Stop() {
 	s.cancel()
 	s.wg.Wait()
-	err := s.cfg.DB.Close()
-	if err != nil {
-		logger.Error("Error closing db", "err", err)
-	}
 }

indexer/services/l2/query.go → indexer/services/query/erc20.go

-package l2
+package query
 
 import (
 	"github.com/ethereum-optimism/optimism/indexer/db"
-
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 )
 
-func QueryERC20(address common.Address, client *ethclient.Client) (*db.Token, error) {
+func NewERC20(address common.Address, client *ethclient.Client) (*db.Token, error) {
 	contract, err := bindings.NewERC20(address, client)
 	if err != nil {
 		return nil, err

indexer/services/query/headers.go

+package query
+
+import (
+	"context"
+
+	"github.com/ethereum-optimism/optimism/op-service/backoff"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+)
+
+// HeaderByNumberWithRetry retries getting headers.
+func HeaderByNumberWithRetry(ctx context.Context, client *ethclient.Client) (*types.Header, error) {
+	var res *types.Header
+	err := backoff.DoCtx(ctx, 3, backoff.Exponential(), func() error {
+		var err error
+		res, err = client.HeaderByNumber(ctx, nil)
+		return err
+	})
+	return res, err
+}

integration-tests/CHANGELOG.md

 # @eth-optimism/integration-tests
 
+## 0.5.21
+
+### Patch Changes
+
+- a3242d4f: Fix erc721 factory to match erc21 factory
+
 ## 0.5.20
 
 ### Patch Changes

integration-tests/package.json

 {
   "private": true,
   "name": "@eth-optimism/integration-tests",
-  "version": "0.5.20",
+  "version": "0.5.21",
   "description": "[Optimism] Integration tests",
   "scripts": {
     "lint": "yarn lint:fix && yarn lint:check",
@@ -30,9 +30,9 @@
   "devDependencies": {
     "@babel/eslint-parser": "^7.5.4",
     "@eth-optimism/contracts": "^0.5.37",
-    "@eth-optimism/contracts-periphery": "^1.0.1",
+    "@eth-optimism/contracts-periphery": "^1.0.2",
     "@eth-optimism/core-utils": "0.10.1",
-    "@eth-optimism/sdk": "1.6.6",
+    "@eth-optimism/sdk": "1.6.7",
     "@ethersproject/abstract-provider": "^5.7.0",
     "@ethersproject/providers": "^5.7.0",
     "@ethersproject/transactions": "^5.7.0",

l2geth/CHANGELOG.md

 # Changelog
 
+## 0.5.25
+
+### Patch Changes
+
+- 89f1abfa: add --rpc.evmtimeout flag to configure timeout for eth_call
+
 ## 0.5.24
 
 ### Patch Changes

l2geth/package.json

 {
   "name": "@eth-optimism/l2geth",
-  "version": "0.5.24",
+  "version": "0.5.25",
   "private": true,
   "devDependencies": {}
 }

op-batcher/batch_submitter.go

@@ -16,18 +16,16 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/ethereum-optimism/optimism/op-batcher/sequencer"
+	"github.com/ethereum-optimism/optimism/op-node/client"
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
 	"github.com/ethereum-optimism/optimism/op-node/sources"
+	"github.com/ethereum-optimism/optimism/op-proposer/txmgr"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
 	oprpc "github.com/ethereum-optimism/optimism/op-service/rpc"
-	hdwallet "github.com/miguelmota/go-ethereum-hdwallet"
-	"github.com/urfave/cli"
-
-	"github.com/ethereum-optimism/optimism/op-batcher/sequencer"
-	"github.com/ethereum-optimism/optimism/op-node/eth"
-	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
-	"github.com/ethereum-optimism/optimism/op-proposer/txmgr"
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
@@ -36,6 +34,8 @@ import (
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rpc"
+	hdwallet "github.com/miguelmota/go-ethereum-hdwallet"
+	"github.com/urfave/cli"
 )
 
 const (
@@ -94,6 +94,7 @@ func Main(version string) func(cliCtx *cli.Context) error {
 					l.Error("error starting metrics server", err)
 				}
 			}()
+			opmetrics.LaunchBalanceMetrics(ctx, l, registry, "", batchSubmitter.cfg.L1Client, batchSubmitter.addr)
 		}
 
 		rpcCfg := cfg.RPCConfig
@@ -125,6 +126,7 @@ func Main(version string) func(cliCtx *cli.Context) error {
 // batches to L1 for availability.
 type BatchSubmitter struct {
 	txMgr txmgr.TxManager
+	addr  common.Address
 	cfg   sequencer.Config
 	wg    sync.WaitGroup
 	done  chan struct{}
@@ -244,6 +246,7 @@ func NewBatchSubmitter(cfg Config, l log.Logger) (*BatchSubmitter, error) {
 
 	return &BatchSubmitter{
 		cfg:   batcherCfg,
+		addr:  addr,
 		txMgr: txmgr.NewSimpleTxManager("batcher", txManagerConfig, l1Client),
 		done:  make(chan struct{}),
 		log:   l,
@@ -495,12 +498,12 @@ func dialRollupClientWithTimeout(ctx context.Context, url string) (*sources.Roll
 	ctxt, cancel := context.WithTimeout(ctx, defaultDialTimeout)
 	defer cancel()
 
-	client, err := rpc.DialContext(ctxt, url)
+	rpcCl, err := rpc.DialContext(ctxt, url)
 	if err != nil {
 		return nil, err
 	}
 
-	return sources.NewRollupClient(client), nil
+	return sources.NewRollupClient(client.NewBaseRPCClient(rpcCl)), nil
 }
 
 // parseAddress parses an ETH address from a hex string. This method will fail if

op-bindings/bindings/deployerwhitelist_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const DeployerWhitelistStorageLayoutJSON = "{\"storage\":[{\"astId\":2853,\"contract\":\"contracts/legacy/DeployerWhitelist.sol:DeployerWhitelist\",\"label\":\"owner\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":2858,\"contract\":\"contracts/legacy/DeployerWhitelist.sol:DeployerWhitelist\",\"label\":\"whitelist\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_mapping(t_address,t_bool)\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_mapping(t_address,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_bool\"}}}"
+const DeployerWhitelistStorageLayoutJSON = "{\"storage\":[{\"astId\":2850,\"contract\":\"contracts/legacy/DeployerWhitelist.sol:DeployerWhitelist\",\"label\":\"owner\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":2855,\"contract\":\"contracts/legacy/DeployerWhitelist.sol:DeployerWhitelist\",\"label\":\"whitelist\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_mapping(t_address,t_bool)\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_mapping(t_address,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_bool\"}}}"
 
 var DeployerWhitelistStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/gaspriceoracle_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const GasPriceOracleStorageLayoutJSON = "{\"storage\":[{\"astId\":27829,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":1754,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"spacer_1_0_32\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_uint256\"},{\"astId\":1757,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"spacer_2_0_32\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_uint256\"},{\"astId\":1760,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"overhead\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_uint256\"},{\"astId\":1763,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"scalar\",\"offset\":0,\"slot\":\"4\",\"type\":\"t_uint256\"},{\"astId\":1766,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"decimals\",\"offset\":0,\"slot\":\"5\",\"type\":\"t_uint256\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
+const GasPriceOracleStorageLayoutJSON = "{\"storage\":[{\"astId\":27823,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":1751,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"spacer_1_0_32\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_uint256\"},{\"astId\":1754,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"spacer_2_0_32\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_uint256\"},{\"astId\":1757,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"overhead\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_uint256\"},{\"astId\":1760,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"scalar\",\"offset\":0,\"slot\":\"4\",\"type\":\"t_uint256\"},{\"astId\":1763,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"decimals\",\"offset\":0,\"slot\":\"5\",\"type\":\"t_uint256\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
 
 var GasPriceOracleStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/governancetoken_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const GovernanceTokenStorageLayoutJSON = "{\"storage\":[{\"astId\":28179,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_balances\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_address,t_uint256)\"},{\"astId\":28185,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_allowances\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_mapping(t_address,t_mapping(t_address,t_uint256))\"},{\"astId\":28187,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_totalSupply\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_uint256\"},{\"astId\":28189,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_name\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_string_storage\"},{\"astId\":28191,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_symbol\",\"offset\":0,\"slot\":\"4\",\"type\":\"t_string_storage\"},{\"astId\":29556,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_nonces\",\"offset\":0,\"slot\":\"5\",\"type\":\"t_mapping(t_address,t_struct(Counter)30345_storage)\"},{\"astId\":29564,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_PERMIT_TYPEHASH_DEPRECATED_SLOT\",\"offset\":0,\"slot\":\"6\",\"type\":\"t_bytes32\"},{\"astId\":28897,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_delegates\",\"offset\":0,\"slot\":\"7\",\"type\":\"t_mapping(t_address,t_address)\"},{\"astId\":28903,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_checkpoints\",\"offset\":0,\"slot\":\"8\",\"type\":\"t_mapping(t_address,t_array(t_struct(Checkpoint)28888_storage)dyn_storage)\"},{\"astId\":28907,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_totalSupplyCheckpoints\",\"offset\":0,\"slot\":\"9\",\"type\":\"t_array(t_struct(Checkpoint)28888_storage)dyn_storage\"},{\"astId\":27829,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"10\",\"type\":\"t_address\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_struct(Checkpoint)28888_storage)dyn_storage\":{\"encoding\":\"dynamic_array\",\"label\":\"struct ERC20Votes.Checkpoint[]\",\"numberOfBytes\":\"32\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_address,t_address)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e address)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_address\"},\"t_mapping(t_address,t_array(t_struct(Checkpoint)28888_storage)dyn_storage)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e struct ERC20Votes.Checkpoint[])\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_array(t_struct(Checkpoint)28888_storage)dyn_storage\"},\"t_mapping(t_address,t_mapping(t_address,t_uint256))\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e mapping(address =\u003e uint256))\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_mapping(t_address,t_uint256)\"},\"t_mapping(t_address,t_struct(Counter)30345_storage)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e struct Counters.Counter)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_struct(Counter)30345_storage\"},\"t_mapping(t_address,t_uint256)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e uint256)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_uint256\"},\"t_string_storage\":{\"encoding\":\"bytes\",\"label\":\"string\",\"numberOfBytes\":\"32\"},\"t_struct(Checkpoint)28888_storage\":{\"encoding\":\"inplace\",\"label\":\"struct ERC20Votes.Checkpoint\",\"numberOfBytes\":\"32\"},\"t_struct(Counter)30345_storage\":{\"encoding\":\"inplace\",\"label\":\"struct Counters.Counter\",\"numberOfBytes\":\"32\"},\"t_uint224\":{\"encoding\":\"inplace\",\"label\":\"uint224\",\"numberOfBytes\":\"28\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint32\":{\"encoding\":\"inplace\",\"label\":\"uint32\",\"numberOfBytes\":\"4\"}}}"
+const GovernanceTokenStorageLayoutJSON = "{\"storage\":[{\"astId\":28173,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_balances\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_address,t_uint256)\"},{\"astId\":28179,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_allowances\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_mapping(t_address,t_mapping(t_address,t_uint256))\"},{\"astId\":28181,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_totalSupply\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_uint256\"},{\"astId\":28183,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_name\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_string_storage\"},{\"astId\":28185,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_symbol\",\"offset\":0,\"slot\":\"4\",\"type\":\"t_string_storage\"},{\"astId\":29550,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_nonces\",\"offset\":0,\"slot\":\"5\",\"type\":\"t_mapping(t_address,t_struct(Counter)30339_storage)\"},{\"astId\":29558,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_PERMIT_TYPEHASH_DEPRECATED_SLOT\",\"offset\":0,\"slot\":\"6\",\"type\":\"t_bytes32\"},{\"astId\":28891,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_delegates\",\"offset\":0,\"slot\":\"7\",\"type\":\"t_mapping(t_address,t_address)\"},{\"astId\":28897,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_checkpoints\",\"offset\":0,\"slot\":\"8\",\"type\":\"t_mapping(t_address,t_array(t_struct(Checkpoint)28882_storage)dyn_storage)\"},{\"astId\":28901,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_totalSupplyCheckpoints\",\"offset\":0,\"slot\":\"9\",\"type\":\"t_array(t_struct(Checkpoint)28882_storage)dyn_storage\"},{\"astId\":27823,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"10\",\"type\":\"t_address\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_struct(Checkpoint)28882_storage)dyn_storage\":{\"encoding\":\"dynamic_array\",\"label\":\"struct ERC20Votes.Checkpoint[]\",\"numberOfBytes\":\"32\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_address,t_address)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e address)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_address\"},\"t_mapping(t_address,t_array(t_struct(Checkpoint)28882_storage)dyn_storage)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e struct ERC20Votes.Checkpoint[])\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_array(t_struct(Checkpoint)28882_storage)dyn_storage\"},\"t_mapping(t_address,t_mapping(t_address,t_uint256))\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e mapping(address =\u003e uint256))\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_mapping(t_address,t_uint256)\"},\"t_mapping(t_address,t_struct(Counter)30339_storage)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e struct Counters.Counter)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_struct(Counter)30339_storage\"},\"t_mapping(t_address,t_uint256)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e uint256)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_uint256\"},\"t_string_storage\":{\"encoding\":\"bytes\",\"label\":\"string\",\"numberOfBytes\":\"32\"},\"t_struct(Checkpoint)28882_storage\":{\"encoding\":\"inplace\",\"label\":\"struct ERC20Votes.Checkpoint\",\"numberOfBytes\":\"32\"},\"t_struct(Counter)30339_storage\":{\"encoding\":\"inplace\",\"label\":\"struct Counters.Counter\",\"numberOfBytes\":\"32\"},\"t_uint224\":{\"encoding\":\"inplace\",\"label\":\"uint224\",\"numberOfBytes\":\"28\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint32\":{\"encoding\":\"inplace\",\"label\":\"uint32\",\"numberOfBytes\":\"4\"}}}"
 
 var GovernanceTokenStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/l1block_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const L1BlockStorageLayoutJSON = "{\"storage\":[{\"astId\":2101,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"number\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_uint64\"},{\"astId\":2104,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"timestamp\",\"offset\":8,\"slot\":\"0\",\"type\":\"t_uint64\"},{\"astId\":2107,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"basefee\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_uint256\"},{\"astId\":2110,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"hash\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_bytes32\"},{\"astId\":2113,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"sequenceNumber\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_uint64\"}],\"types\":{\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint64\":{\"encoding\":\"inplace\",\"label\":\"uint64\",\"numberOfBytes\":\"8\"}}}"
+const L1BlockStorageLayoutJSON = "{\"storage\":[{\"astId\":2098,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"number\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_uint64\"},{\"astId\":2101,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"timestamp\",\"offset\":8,\"slot\":\"0\",\"type\":\"t_uint64\"},{\"astId\":2104,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"basefee\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_uint256\"},{\"astId\":2107,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"hash\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_bytes32\"},{\"astId\":2110,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"sequenceNumber\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_uint64\"}],\"types\":{\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint64\":{\"encoding\":\"inplace\",\"label\":\"uint64\",\"numberOfBytes\":\"8\"}}}"
 
 var L1BlockStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/l1crossdomainmessenger_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const L1CrossDomainMessengerStorageLayoutJSON = "{\"storage\":[{\"astId\":24817,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"spacer_0_0_20\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":27206,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_initialized\",\"offset\":20,\"slot\":\"0\",\"type\":\"t_uint8\"},{\"astId\":27209,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_initializing\",\"offset\":21,\"slot\":\"0\",\"type\":\"t_bool\"},{\"astId\":27820,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_array(t_uint256)50_storage\"},{\"astId\":27078,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"51\",\"type\":\"t_address\"},{\"astId\":27198,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"52\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":27371,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_paused\",\"offset\":0,\"slot\":\"101\",\"type\":\"t_bool\"},{\"astId\":27476,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"102\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":27491,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_status\",\"offset\":0,\"slot\":\"151\",\"type\":\"t_uint256\"},{\"astId\":27535,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"152\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":24869,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"spacer_201_0_32\",\"offset\":0,\"slot\":\"201\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24874,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"spacer_202_0_32\",\"offset\":0,\"slot\":\"202\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24879,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"successfulMessages\",\"offset\":0,\"slot\":\"203\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24882,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"xDomainMsgSender\",\"offset\":0,\"slot\":\"204\",\"type\":\"t_address\"},{\"astId\":24885,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"msgNonce\",\"offset\":0,\"slot\":\"205\",\"type\":\"t_uint240\"},{\"astId\":24890,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"receivedMessages\",\"offset\":0,\"slot\":\"206\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24895,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"207\",\"type\":\"t_array(t_uint256)42_storage\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)42_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[42]\",\"numberOfBytes\":\"1344\"},\"t_array(t_uint256)49_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[49]\",\"numberOfBytes\":\"1568\"},\"t_array(t_uint256)50_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[50]\",\"numberOfBytes\":\"1600\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"},\"t_uint240\":{\"encoding\":\"inplace\",\"label\":\"uint240\",\"numberOfBytes\":\"30\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint8\":{\"encoding\":\"inplace\",\"label\":\"uint8\",\"numberOfBytes\":\"1\"}}}"
+const L1CrossDomainMessengerStorageLayoutJSON = "{\"storage\":[{\"astId\":24811,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"spacer_0_0_20\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":27200,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_initialized\",\"offset\":20,\"slot\":\"0\",\"type\":\"t_uint8\"},{\"astId\":27203,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_initializing\",\"offset\":21,\"slot\":\"0\",\"type\":\"t_bool\"},{\"astId\":27814,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_array(t_uint256)50_storage\"},{\"astId\":27072,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"51\",\"type\":\"t_address\"},{\"astId\":27192,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"52\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":27365,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_paused\",\"offset\":0,\"slot\":\"101\",\"type\":\"t_bool\"},{\"astId\":27470,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"102\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":27485,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_status\",\"offset\":0,\"slot\":\"151\",\"type\":\"t_uint256\"},{\"astId\":27529,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"152\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":24863,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"spacer_201_0_32\",\"offset\":0,\"slot\":\"201\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24868,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"spacer_202_0_32\",\"offset\":0,\"slot\":\"202\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24873,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"successfulMessages\",\"offset\":0,\"slot\":\"203\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24876,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"xDomainMsgSender\",\"offset\":0,\"slot\":\"204\",\"type\":\"t_address\"},{\"astId\":24879,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"msgNonce\",\"offset\":0,\"slot\":\"205\",\"type\":\"t_uint240\"},{\"astId\":24884,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"receivedMessages\",\"offset\":0,\"slot\":\"206\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24889,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"207\",\"type\":\"t_array(t_uint256)42_storage\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)42_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[42]\",\"numberOfBytes\":\"1344\"},\"t_array(t_uint256)49_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[49]\",\"numberOfBytes\":\"1568\"},\"t_array(t_uint256)50_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[50]\",\"numberOfBytes\":\"1600\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"},\"t_uint240\":{\"encoding\":\"inplace\",\"label\":\"uint240\",\"numberOfBytes\":\"30\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint8\":{\"encoding\":\"inplace\",\"label\":\"uint8\",\"numberOfBytes\":\"1\"}}}"
 
 var L1CrossDomainMessengerStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/l2crossdomainmessenger_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const L2CrossDomainMessengerStorageLayoutJSON = "{\"storage\":[{\"astId\":24817,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"spacer_0_0_20\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":27206,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_initialized\",\"offset\":20,\"slot\":\"0\",\"type\":\"t_uint8\"},{\"astId\":27209,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_initializing\",\"offset\":21,\"slot\":\"0\",\"type\":\"t_bool\"},{\"astId\":27820,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_array(t_uint256)50_storage\"},{\"astId\":27078,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"51\",\"type\":\"t_address\"},{\"astId\":27198,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"52\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":27371,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_paused\",\"offset\":0,\"slot\":\"101\",\"type\":\"t_bool\"},{\"astId\":27476,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"102\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":27491,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_status\",\"offset\":0,\"slot\":\"151\",\"type\":\"t_uint256\"},{\"astId\":27535,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"152\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":24869,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"spacer_201_0_32\",\"offset\":0,\"slot\":\"201\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24874,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"spacer_202_0_32\",\"offset\":0,\"slot\":\"202\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24879,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"successfulMessages\",\"offset\":0,\"slot\":\"203\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24882,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"xDomainMsgSender\",\"offset\":0,\"slot\":\"204\",\"type\":\"t_address\"},{\"astId\":24885,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"msgNonce\",\"offset\":0,\"slot\":\"205\",\"type\":\"t_uint240\"},{\"astId\":24890,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"receivedMessages\",\"offset\":0,\"slot\":\"206\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24895,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"207\",\"type\":\"t_array(t_uint256)42_storage\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)42_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[42]\",\"numberOfBytes\":\"1344\"},\"t_array(t_uint256)49_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[49]\",\"numberOfBytes\":\"1568\"},\"t_array(t_uint256)50_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[50]\",\"numberOfBytes\":\"1600\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"},\"t_uint240\":{\"encoding\":\"inplace\",\"label\":\"uint240\",\"numberOfBytes\":\"30\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint8\":{\"encoding\":\"inplace\",\"label\":\"uint8\",\"numberOfBytes\":\"1\"}}}"
+const L2CrossDomainMessengerStorageLayoutJSON = "{\"storage\":[{\"astId\":24811,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"spacer_0_0_20\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":27200,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_initialized\",\"offset\":20,\"slot\":\"0\",\"type\":\"t_uint8\"},{\"astId\":27203,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_initializing\",\"offset\":21,\"slot\":\"0\",\"type\":\"t_bool\"},{\"astId\":27814,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_array(t_uint256)50_storage\"},{\"astId\":27072,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"51\",\"type\":\"t_address\"},{\"astId\":27192,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"52\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":27365,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_paused\",\"offset\":0,\"slot\":\"101\",\"type\":\"t_bool\"},{\"astId\":27470,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"102\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":27485,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_status\",\"offset\":0,\"slot\":\"151\",\"type\":\"t_uint256\"},{\"astId\":27529,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"152\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":24863,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"spacer_201_0_32\",\"offset\":0,\"slot\":\"201\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24868,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"spacer_202_0_32\",\"offset\":0,\"slot\":\"202\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24873,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"successfulMessages\",\"offset\":0,\"slot\":\"203\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24876,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"xDomainMsgSender\",\"offset\":0,\"slot\":\"204\",\"type\":\"t_address\"},{\"astId\":24879,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"msgNonce\",\"offset\":0,\"slot\":\"205\",\"type\":\"t_uint240\"},{\"astId\":24884,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"receivedMessages\",\"offset\":0,\"slot\":\"206\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24889,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"207\",\"type\":\"t_array(t_uint256)42_storage\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)42_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[42]\",\"numberOfBytes\":\"1344\"},\"t_array(t_uint256)49_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[49]\",\"numberOfBytes\":\"1568\"},\"t_array(t_uint256)50_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[50]\",\"numberOfBytes\":\"1600\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"},\"t_uint240\":{\"encoding\":\"inplace\",\"label\":\"uint240\",\"numberOfBytes\":\"30\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint8\":{\"encoding\":\"inplace\",\"label\":\"uint8\",\"numberOfBytes\":\"1\"}}}"
 
 var L2CrossDomainMessengerStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/l2outputoracle.go

@@ -36,8 +36,8 @@ type TypesOutputProposal struct {
 
 // L2OutputOracleMetaData contains all meta data concerning the L2OutputOracle contract.
 var L2OutputOracleMetaData = &bind.MetaData{
-	ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_submissionInterval\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"_genesisL2Output\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"_historicalTotalBlocks\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_startingBlockNumber\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_startingTimestamp\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_l2BlockTime\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"_proposer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"outputRoot\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"l1Timestamp\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"l2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"OutputDeleted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"outputRoot\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"l1Timestamp\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"l2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"OutputProposed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousProposer\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newProposer\",\"type\":\"address\"}],\"name\":\"ProposerChanged\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"HISTORICAL_TOTAL_BLOCKS\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"L2_BLOCK_TIME\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"STARTING_BLOCK_NUMBER\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"STARTING_TIMESTAMP\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SUBMISSION_INTERVAL\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newProposer\",\"type\":\"address\"}],\"name\":\"changeProposer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_l2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"computeL2Timestamp\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"outputRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"internalType\":\"structTypes.OutputProposal\",\"name\":\"_proposal\",\"type\":\"tuple\"}],\"name\":\"deleteL2Output\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_l2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"getL2Output\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"outputRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"internalType\":\"structTypes.OutputProposal\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_genesisL2Output\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"_startingBlockNumber\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"_proposer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"latestBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nextBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_outputRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"_l2BlockNumber\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"_l1Blockhash\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"_l1BlockNumber\",\"type\":\"uint256\"}],\"name\":\"proposeL2Output\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proposer\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"version\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
-	Bin: "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",
+	ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_submissionInterval\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"_genesisL2Output\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"_historicalTotalBlocks\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_startingBlockNumber\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_startingTimestamp\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_l2BlockTime\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"_proposer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"outputRoot\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"l1Timestamp\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"l2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"OutputDeleted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"outputRoot\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"l1Timestamp\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"l2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"OutputProposed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousProposer\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newProposer\",\"type\":\"address\"}],\"name\":\"ProposerChanged\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"HISTORICAL_TOTAL_BLOCKS\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"L2_BLOCK_TIME\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"STARTING_BLOCK_NUMBER\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"STARTING_TIMESTAMP\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SUBMISSION_INTERVAL\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newProposer\",\"type\":\"address\"}],\"name\":\"changeProposer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_l2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"computeL2Timestamp\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"outputRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"internalType\":\"structTypes.OutputProposal\",\"name\":\"_proposal\",\"type\":\"tuple\"}],\"name\":\"deleteL2Output\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_l2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"getL2Output\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"outputRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"internalType\":\"structTypes.OutputProposal\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_genesisL2Output\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"_proposer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"latestBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nextBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_outputRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"_l2BlockNumber\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"_l1Blockhash\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"_l1BlockNumber\",\"type\":\"uint256\"}],\"name\":\"proposeL2Output\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proposer\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"version\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+	Bin: "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",
 }
 
 // L2OutputOracleABI is the input ABI used to generate the binding from.
@@ -621,25 +621,25 @@ func (_L2OutputOracle *L2OutputOracleTransactorSession) DeleteL2Output(_proposal
 	return _L2OutputOracle.Contract.DeleteL2Output(&_L2OutputOracle.TransactOpts, _proposal)
 }
 
-// Initialize is a paid mutator transaction binding the contract method 0xd20b1a51.
+// Initialize is a paid mutator transaction binding the contract method 0x88b117b3.
 //
-// Solidity: function initialize(bytes32 _genesisL2Output, uint256 _startingBlockNumber, address _proposer, address _owner) returns()
-func (_L2OutputOracle *L2OutputOracleTransactor) Initialize(opts *bind.TransactOpts, _genesisL2Output [32]byte, _startingBlockNumber *big.Int, _proposer common.Address, _owner common.Address) (*types.Transaction, error) {
-	return _L2OutputOracle.contract.Transact(opts, "initialize", _genesisL2Output, _startingBlockNumber, _proposer, _owner)
+// Solidity: function initialize(bytes32 _genesisL2Output, address _proposer, address _owner) returns()
+func (_L2OutputOracle *L2OutputOracleTransactor) Initialize(opts *bind.TransactOpts, _genesisL2Output [32]byte, _proposer common.Address, _owner common.Address) (*types.Transaction, error) {
+	return _L2OutputOracle.contract.Transact(opts, "initialize", _genesisL2Output, _proposer, _owner)
 }
 
-// Initialize is a paid mutator transaction binding the contract method 0xd20b1a51.
+// Initialize is a paid mutator transaction binding the contract method 0x88b117b3.
 //
-// Solidity: function initialize(bytes32 _genesisL2Output, uint256 _startingBlockNumber, address _proposer, address _owner) returns()
-func (_L2OutputOracle *L2OutputOracleSession) Initialize(_genesisL2Output [32]byte, _startingBlockNumber *big.Int, _proposer common.Address, _owner common.Address) (*types.Transaction, error) {
-	return _L2OutputOracle.Contract.Initialize(&_L2OutputOracle.TransactOpts, _genesisL2Output, _startingBlockNumber, _proposer, _owner)
+// Solidity: function initialize(bytes32 _genesisL2Output, address _proposer, address _owner) returns()
+func (_L2OutputOracle *L2OutputOracleSession) Initialize(_genesisL2Output [32]byte, _proposer common.Address, _owner common.Address) (*types.Transaction, error) {
+	return _L2OutputOracle.Contract.Initialize(&_L2OutputOracle.TransactOpts, _genesisL2Output, _proposer, _owner)
 }
 
-// Initialize is a paid mutator transaction binding the contract method 0xd20b1a51.
+// Initialize is a paid mutator transaction binding the contract method 0x88b117b3.
 //
-// Solidity: function initialize(bytes32 _genesisL2Output, uint256 _startingBlockNumber, address _proposer, address _owner) returns()
-func (_L2OutputOracle *L2OutputOracleTransactorSession) Initialize(_genesisL2Output [32]byte, _startingBlockNumber *big.Int, _proposer common.Address, _owner common.Address) (*types.Transaction, error) {
-	return _L2OutputOracle.Contract.Initialize(&_L2OutputOracle.TransactOpts, _genesisL2Output, _startingBlockNumber, _proposer, _owner)
+// Solidity: function initialize(bytes32 _genesisL2Output, address _proposer, address _owner) returns()
+func (_L2OutputOracle *L2OutputOracleTransactorSession) Initialize(_genesisL2Output [32]byte, _proposer common.Address, _owner common.Address) (*types.Transaction, error) {
+	return _L2OutputOracle.Contract.Initialize(&_L2OutputOracle.TransactOpts, _genesisL2Output, _proposer, _owner)
 }
 
 // ProposeL2Output is a paid mutator transaction binding the contract method 0x9aaab648.

op-bindings/bindings/l2standardbridge_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const L2StandardBridgeStorageLayoutJSON = "{\"storage\":[{\"astId\":26379,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"spacer_0_0_20\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":26382,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"spacer_1_0_20\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_address\"},{\"astId\":26389,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"deposits\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_mapping(t_address,t_mapping(t_address,t_uint256))\"},{\"astId\":26394,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_array(t_uint256)47_storage\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)47_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[47]\",\"numberOfBytes\":\"1504\"},\"t_mapping(t_address,t_mapping(t_address,t_uint256))\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e mapping(address =\u003e uint256))\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_mapping(t_address,t_uint256)\"},\"t_mapping(t_address,t_uint256)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e uint256)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_uint256\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
+const L2StandardBridgeStorageLayoutJSON = "{\"storage\":[{\"astId\":26373,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"spacer_0_0_20\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":26376,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"spacer_1_0_20\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_address\"},{\"astId\":26383,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"deposits\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_mapping(t_address,t_mapping(t_address,t_uint256))\"},{\"astId\":26388,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_array(t_uint256)47_storage\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)47_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[47]\",\"numberOfBytes\":\"1504\"},\"t_mapping(t_address,t_mapping(t_address,t_uint256))\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e mapping(address =\u003e uint256))\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_mapping(t_address,t_uint256)\"},\"t_mapping(t_address,t_uint256)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e uint256)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_uint256\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
 
 var L2StandardBridgeStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/l2tol1messagepasser_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const L2ToL1MessagePasserStorageLayoutJSON = "{\"storage\":[{\"astId\":2546,\"contract\":\"contracts/L2/L2ToL1MessagePasser.sol:L2ToL1MessagePasser\",\"label\":\"sentMessages\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":2549,\"contract\":\"contracts/L2/L2ToL1MessagePasser.sol:L2ToL1MessagePasser\",\"label\":\"nonce\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_uint256\"}],\"types\":{\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
+const L2ToL1MessagePasserStorageLayoutJSON = "{\"storage\":[{\"astId\":2543,\"contract\":\"contracts/L2/L2ToL1MessagePasser.sol:L2ToL1MessagePasser\",\"label\":\"sentMessages\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":2546,\"contract\":\"contracts/L2/L2ToL1MessagePasser.sol:L2ToL1MessagePasser\",\"label\":\"nonce\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_uint256\"}],\"types\":{\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
 
 var L2ToL1MessagePasserStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/legacyerc20eth_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const LegacyERC20ETHStorageLayoutJSON = "{\"storage\":[{\"astId\":28179,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_balances\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_address,t_uint256)\"},{\"astId\":28185,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_allowances\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_mapping(t_address,t_mapping(t_address,t_uint256))\"},{\"astId\":28187,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_totalSupply\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_uint256\"},{\"astId\":28189,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_name\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_string_storage\"},{\"astId\":28191,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_symbol\",\"offset\":0,\"slot\":\"4\",\"type\":\"t_string_storage\"},{\"astId\":25292,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"remoteToken\",\"offset\":0,\"slot\":\"5\",\"type\":\"t_address\"},{\"astId\":25295,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"bridge\",\"offset\":0,\"slot\":\"6\",\"type\":\"t_address\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_mapping(t_address,t_mapping(t_address,t_uint256))\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e mapping(address =\u003e uint256))\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_mapping(t_address,t_uint256)\"},\"t_mapping(t_address,t_uint256)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e uint256)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_uint256\"},\"t_string_storage\":{\"encoding\":\"bytes\",\"label\":\"string\",\"numberOfBytes\":\"32\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
+const LegacyERC20ETHStorageLayoutJSON = "{\"storage\":[{\"astId\":28173,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_balances\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_address,t_uint256)\"},{\"astId\":28179,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_allowances\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_mapping(t_address,t_mapping(t_address,t_uint256))\"},{\"astId\":28181,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_totalSupply\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_uint256\"},{\"astId\":28183,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_name\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_string_storage\"},{\"astId\":28185,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_symbol\",\"offset\":0,\"slot\":\"4\",\"type\":\"t_string_storage\"},{\"astId\":25286,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"remoteToken\",\"offset\":0,\"slot\":\"5\",\"type\":\"t_address\"},{\"astId\":25289,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"bridge\",\"offset\":0,\"slot\":\"6\",\"type\":\"t_address\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_mapping(t_address,t_mapping(t_address,t_uint256))\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e mapping(address =\u003e uint256))\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_mapping(t_address,t_uint256)\"},\"t_mapping(t_address,t_uint256)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e uint256)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_uint256\"},\"t_string_storage\":{\"encoding\":\"bytes\",\"label\":\"string\",\"numberOfBytes\":\"32\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
 
 var LegacyERC20ETHStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/legacymessagepasser_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const LegacyMessagePasserStorageLayoutJSON = "{\"storage\":[{\"astId\":3496,\"contract\":\"contracts/legacy/LegacyMessagePasser.sol:LegacyMessagePasser\",\"label\":\"sentMessages\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_bytes32,t_bool)\"}],\"types\":{\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"}}}"
+const LegacyMessagePasserStorageLayoutJSON = "{\"storage\":[{\"astId\":3493,\"contract\":\"contracts/legacy/LegacyMessagePasser.sol:LegacyMessagePasser\",\"label\":\"sentMessages\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_bytes32,t_bool)\"}],\"types\":{\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"}}}"
 
 var LegacyMessagePasserStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/optimismportal_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const OptimismPortalStorageLayoutJSON = "{\"storage\":[{\"astId\":28019,\"contract\":\"contracts/L1/OptimismPortal.sol:OptimismPortal\",\"label\":\"_initialized\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_uint8\"},{\"astId\":28022,\"contract\":\"contracts/L1/OptimismPortal.sol:OptimismPortal\",\"label\":\"_initializing\",\"offset\":1,\"slot\":\"0\",\"type\":\"t_bool\"},{\"astId\":1404,\"contract\":\"contracts/L1/OptimismPortal.sol:OptimismPortal\",\"label\":\"params\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_struct(ResourceParams)1374_storage\"},{\"astId\":1409,\"contract\":\"contracts/L1/OptimismPortal.sol:OptimismPortal\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_array(t_uint256)48_storage\"},{\"astId\":982,\"contract\":\"contracts/L1/OptimismPortal.sol:OptimismPortal\",\"label\":\"l2Sender\",\"offset\":0,\"slot\":\"50\",\"type\":\"t_address\"},{\"astId\":995,\"contract\":\"contracts/L1/OptimismPortal.sol:OptimismPortal\",\"label\":\"finalizedWithdrawals\",\"offset\":0,\"slot\":\"51\",\"type\":\"t_mapping(t_bytes32,t_bool)\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)48_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[48]\",\"numberOfBytes\":\"1536\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"},\"t_struct(ResourceParams)1374_storage\":{\"encoding\":\"inplace\",\"label\":\"struct ResourceMetering.ResourceParams\",\"numberOfBytes\":\"32\"},\"t_uint128\":{\"encoding\":\"inplace\",\"label\":\"uint128\",\"numberOfBytes\":\"16\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint64\":{\"encoding\":\"inplace\",\"label\":\"uint64\",\"numberOfBytes\":\"8\"},\"t_uint8\":{\"encoding\":\"inplace\",\"label\":\"uint8\",\"numberOfBytes\":\"1\"}}}"
+const OptimismPortalStorageLayoutJSON = "{\"storage\":[{\"astId\":28013,\"contract\":\"contracts/L1/OptimismPortal.sol:OptimismPortal\",\"label\":\"_initialized\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_uint8\"},{\"astId\":28016,\"contract\":\"contracts/L1/OptimismPortal.sol:OptimismPortal\",\"label\":\"_initializing\",\"offset\":1,\"slot\":\"0\",\"type\":\"t_bool\"},{\"astId\":1401,\"contract\":\"contracts/L1/OptimismPortal.sol:OptimismPortal\",\"label\":\"params\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_struct(ResourceParams)1371_storage\"},{\"astId\":1406,\"contract\":\"contracts/L1/OptimismPortal.sol:OptimismPortal\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_array(t_uint256)48_storage\"},{\"astId\":979,\"contract\":\"contracts/L1/OptimismPortal.sol:OptimismPortal\",\"label\":\"l2Sender\",\"offset\":0,\"slot\":\"50\",\"type\":\"t_address\"},{\"astId\":992,\"contract\":\"contracts/L1/OptimismPortal.sol:OptimismPortal\",\"label\":\"finalizedWithdrawals\",\"offset\":0,\"slot\":\"51\",\"type\":\"t_mapping(t_bytes32,t_bool)\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)48_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[48]\",\"numberOfBytes\":\"1536\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"},\"t_struct(ResourceParams)1371_storage\":{\"encoding\":\"inplace\",\"label\":\"struct ResourceMetering.ResourceParams\",\"numberOfBytes\":\"32\"},\"t_uint128\":{\"encoding\":\"inplace\",\"label\":\"uint128\",\"numberOfBytes\":\"16\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint64\":{\"encoding\":\"inplace\",\"label\":\"uint64\",\"numberOfBytes\":\"8\"},\"t_uint8\":{\"encoding\":\"inplace\",\"label\":\"uint8\",\"numberOfBytes\":\"1\"}}}"
 
 var OptimismPortalStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/sequencerfeevault_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const SequencerFeeVaultStorageLayoutJSON = "{\"storage\":[{\"astId\":2694,\"contract\":\"contracts/L2/SequencerFeeVault.sol:SequencerFeeVault\",\"label\":\"l1FeeWallet\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"}}}"
+const SequencerFeeVaultStorageLayoutJSON = "{\"storage\":[{\"astId\":2691,\"contract\":\"contracts/L2/SequencerFeeVault.sol:SequencerFeeVault\",\"label\":\"l1FeeWallet\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"}}}"
 
 var SequencerFeeVaultStorageLayout = new(solc.StorageLayout)
 

op-chain-ops/genesis/layer_one.go

@@ -73,7 +73,6 @@ func BuildL1DeveloperGenesis(config *DeployConfig) (*core.Genesis, error) {
 	data, err := l2ooABI.Pack(
 		"initialize",
 		config.L2OutputOracleGenesisL2Output,
-		big.NewInt(0),
 		config.L2OutputOracleProposer,
 		config.L2OutputOracleOwner,
 	)

op-e2e/actions/l1_replica.go

@@ -4,6 +4,10 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/ethereum-optimism/optimism/op-node/client"
+	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum-optimism/optimism/op-node/sources"
+	"github.com/ethereum-optimism/optimism/op-node/testutils"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/eth"
@@ -15,9 +19,6 @@ import (
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/stretchr/testify/require"
-
-	"github.com/ethereum-optimism/optimism/op-node/client"
-	"github.com/ethereum-optimism/optimism/op-node/testutils"
 )
 
 // L1CanonSrc is used to sync L1 from another node.
@@ -170,6 +171,12 @@ func (s *L1Replica) RPCClient() client.RPC {
 	}
 }
 
+func (s *L1Replica) L1Client(t Testing, cfg *rollup.Config) *sources.L1Client {
+	l1F, err := sources.NewL1Client(s.RPCClient(), s.log, nil, sources.L1ClientDefaultConfig(cfg, false))
+	require.NoError(t, err)
+	return l1F
+}
+
 // ActL1FinalizeNext finalizes the next block, which must be marked as safe before doing so (see ActL1SafeNext).
 func (s *L1Replica) ActL1FinalizeNext(t Testing) {
 	safe := s.l1Chain.CurrentSafeBlock()

op-e2e/actions/l2_engine.go

@@ -4,6 +4,8 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/stretchr/testify/require"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/beacon"
@@ -21,6 +23,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/client"
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum-optimism/optimism/op-node/sources"
 	"github.com/ethereum-optimism/optimism/op-node/testutils"
 )
 
@@ -130,6 +133,12 @@ func (e *L2Engine) RPCClient() client.RPC {
 	}
 }
 
+func (e *L2Engine) EngineClient(t Testing, cfg *rollup.Config) *sources.EngineClient {
+	l2Cl, err := sources.NewEngineClient(e.RPCClient(), e.log, nil, sources.EngineClientDefaultConfig(cfg))
+	require.NoError(t, err)
+	return l2Cl
+}
+
 // ActL2RPCFail makes the next L2 RPC request fail
 func (e *L2Engine) ActL2RPCFail(t Testing) {
 	if e.failL2RPC != nil { // already set to fail?

op-e2e/actions/l2_sequencer.go

@@ -22,7 +22,7 @@ type L2Sequencer struct {
 	failL2GossipUnsafeBlock error // mock error
 }
 
-func NewL2Sequencer(log log.Logger, l1 derive.L1Fetcher, eng derive.Engine, cfg *rollup.Config, seqConfDepth uint64) *L2Sequencer {
+func NewL2Sequencer(log log.Logger, l1 derive.L1Fetcher, eng L2API, cfg *rollup.Config, seqConfDepth uint64) *L2Sequencer {
 	ver := NewL2Verifier(log, l1, eng, cfg)
 	return &L2Sequencer{
 		L2Verifier:              *ver,

op-e2e/actions/l2_verifier.go

 package actions
 
 import (
+	"context"
 	"errors"
 	"io"
 
-	"github.com/ethereum-optimism/optimism/op-node/rollup/driver"
-	"github.com/stretchr/testify/require"
-
-	"github.com/ethereum/go-ethereum/log"
-
+	"github.com/ethereum-optimism/optimism/op-node/client"
 	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum-optimism/optimism/op-node/node"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/driver"
+	"github.com/ethereum-optimism/optimism/op-node/sources"
 	"github.com/ethereum-optimism/optimism/op-node/testutils"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+	gnode "github.com/ethereum/go-ethereum/node"
+	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/stretchr/testify/require"
 )
 
 // L2Verifier is an actor that functions like a rollup node,
@@ -32,13 +37,25 @@ type L2Verifier struct {
 	l2Building     bool
 
 	rollupCfg *rollup.Config
+
+	rpc *rpc.Server
+
+	failRPC error // mock error
+}
+
+type L2API interface {
+	derive.Engine
+	InfoByRpcNumber(ctx context.Context, num rpc.BlockNumber) (eth.BlockInfo, error)
+	// GetProof returns a proof of the account, it may return a nil result without error if the address was not found.
+	GetProof(ctx context.Context, address common.Address, blockTag string) (*eth.AccountResult, error)
 }
 
-func NewL2Verifier(log log.Logger, l1 derive.L1Fetcher, eng derive.Engine, cfg *rollup.Config) *L2Verifier {
+func NewL2Verifier(log log.Logger, l1 derive.L1Fetcher, eng L2API, cfg *rollup.Config) *L2Verifier {
 	metrics := &testutils.TestDerivationMetrics{}
 	pipeline := derive.NewDerivationPipeline(log, cfg, l1, eng, metrics)
 	pipeline.Reset()
-	return &L2Verifier{
+
+	rollupNode := &L2Verifier{
 		log:            log,
 		eng:            eng,
 		derivation:     pipeline,
@@ -47,7 +64,44 @@ func NewL2Verifier(log log.Logger, l1 derive.L1Fetcher, eng derive.Engine, cfg *
 		l2PipelineIdle: true,
 		l2Building:     false,
 		rollupCfg:      cfg,
+		rpc:            rpc.NewServer(),
+	}
+
+	// setup RPC server for rollup node, hooked to the actor as backend
+	m := &testutils.TestRPCMetrics{}
+	backend := &l2VerifierBackend{verifier: rollupNode}
+	apis := []rpc.API{
+		{
+			Namespace:     "optimism",
+			Service:       node.NewNodeAPI(cfg, eng, backend, log, m),
+			Public:        true,
+			Authenticated: false,
+		},
+		{
+			Namespace:     "admin",
+			Version:       "",
+			Service:       node.NewAdminAPI(backend, m),
+			Public:        true, // TODO: this field is deprecated. Do we even need this anymore?
+			Authenticated: false,
+		},
+	}
+	if err := gnode.RegisterApis(apis, nil, rollupNode.rpc); err != nil {
+		panic(err)
 	}
+	return rollupNode
+}
+
+type l2VerifierBackend struct {
+	verifier *L2Verifier
+}
+
+func (s *l2VerifierBackend) SyncStatus(ctx context.Context) (*eth.SyncStatus, error) {
+	return s.verifier.SyncStatus(), nil
+}
+
+func (s *l2VerifierBackend) ResetDerivationPipeline(ctx context.Context) error {
+	s.verifier.derivation.Reset()
+	return nil
 }
 
 func (s *L2Verifier) SyncStatus() *eth.SyncStatus {
@@ -62,6 +116,31 @@ func (s *L2Verifier) SyncStatus() *eth.SyncStatus {
 	}
 }
 
+func (s *L2Verifier) RollupClient() *sources.RollupClient {
+	return sources.NewRollupClient(s.RPCClient())
+}
+
+func (s *L2Verifier) RPCClient() client.RPC {
+	cl := rpc.DialInProc(s.rpc)
+	return testutils.RPCErrFaker{
+		RPC: client.NewBaseRPCClient(cl),
+		ErrFn: func() error {
+			err := s.failRPC
+			s.failRPC = nil // reset back, only error once.
+			return err
+		},
+	}
+}
+
+// ActRPCFail makes the next L2 RPC request fail
+func (s *L2Verifier) ActRPCFail(t Testing) {
+	if s.failRPC != nil { // already set to fail?
+		t.InvalidAction("already set a mock rpc error")
+		return
+	}
+	s.failRPC = errors.New("mock RPC error")
+}
+
 func (s *L2Verifier) ActL1HeadSignal(t Testing) {
 	head, err := s.l1.L1BlockRefByLabel(t.Ctx(), eth.Unsafe)
 	require.NoError(t, err)

op-e2e/actions/l2_verifier_test.go

@@ -3,27 +3,26 @@ package actions
 import (
 	"testing"
 
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/stretchr/testify/require"
-
-	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
-	"github.com/ethereum-optimism/optimism/op-node/sources"
-	"github.com/ethereum-optimism/optimism/op-node/testlog"
 )
 
-func setupVerifierTest(t Testing, sd *e2eutils.SetupData, log log.Logger) (*L1Miner, *L2Engine, *L2Verifier) {
+func setupVerifier(t Testing, sd *e2eutils.SetupData, log log.Logger, l1F derive.L1Fetcher) (*L2Engine, *L2Verifier) {
 	jwtPath := e2eutils.WriteDefaultJWT(t)
-
-	miner := NewL1Miner(log, sd.L1Cfg)
-
-	l1F, err := sources.NewL1Client(miner.RPCClient(), log, nil, sources.L1ClientDefaultConfig(sd.RollupCfg, false))
-	require.NoError(t, err)
 	engine := NewL2Engine(log, sd.L2Cfg, sd.RollupCfg.Genesis.L1, jwtPath)
-	l2Cl, err := sources.NewEngineClient(engine.RPCClient(), log, nil, sources.EngineClientDefaultConfig(sd.RollupCfg))
-	require.NoError(t, err)
+	engCl := engine.EngineClient(t, sd.RollupCfg)
+	verifier := NewL2Verifier(log, l1F, engCl, sd.RollupCfg)
+	return engine, verifier
+}
 
-	verifier := NewL2Verifier(log, l1F, l2Cl, sd.RollupCfg)
+func setupVerifierOnlyTest(t Testing, sd *e2eutils.SetupData, log log.Logger) (*L1Miner, *L2Engine, *L2Verifier) {
+	miner := NewL1Miner(log, sd.L1Cfg)
+	l1Cl := miner.L1Client(t, sd.RollupCfg)
+	engine, verifier := setupVerifier(t, sd, log, l1Cl)
 	return miner, engine, verifier
 }
 
@@ -37,7 +36,7 @@ func TestL2Verifier_SequenceWindow(gt *testing.T) {
 	dp := e2eutils.MakeDeployParams(t, p)
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlDebug)
-	miner, engine, verifier := setupVerifierTest(t, sd, log)
+	miner, engine, verifier := setupVerifierOnlyTest(t, sd, log)
 	miner.ActL1SetFeeRecipient(common.Address{'A'})
 
 	// Make two sequence windows worth of empty L1 blocks. After we pass the first sequence window, the L2 chain should get blocks

op-e2e/system_test.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
+	"github.com/ethereum-optimism/optimism/op-node/client"
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
 	"github.com/ethereum-optimism/optimism/op-node/sources"
@@ -57,7 +58,7 @@ func TestL2OutputSubmitter(t *testing.T) {
 
 	rollupRPCClient, err := rpc.DialContext(context.Background(), sys.RollupNodes["sequencer"].HTTPEndpoint())
 	require.Nil(t, err)
-	rollupClient := sources.NewRollupClient(rollupRPCClient)
+	rollupClient := sources.NewRollupClient(client.NewBaseRPCClient(rollupRPCClient))
 
 	//  OutputOracle is already deployed
 	l2OutputOracle, err := bindings.NewL2OutputOracleCaller(predeploys.DevL2OutputOracleAddr, l1Client)
@@ -212,7 +213,7 @@ func TestSystemE2E(t *testing.T) {
 
 	rollupRPCClient, err := rpc.DialContext(context.Background(), sys.RollupNodes["sequencer"].HTTPEndpoint())
 	require.Nil(t, err)
-	rollupClient := sources.NewRollupClient(rollupRPCClient)
+	rollupClient := sources.NewRollupClient(client.NewBaseRPCClient(rollupRPCClient))
 	// basic check that sync status works
 	seqStatus, err := rollupClient.SyncStatus(context.Background())
 	require.Nil(t, err)

op-node/node/api.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	"github.com/ethereum-optimism/optimism/op-node/eth"
-	"github.com/ethereum-optimism/optimism/op-node/metrics"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum-optimism/optimism/op-node/version"
 	"github.com/ethereum/go-ethereum"
@@ -26,12 +25,17 @@ type driverClient interface {
 	ResetDerivationPipeline(context.Context) error
 }
 
+type rpcMetrics interface {
+	// RecordRPCServerRequest returns a function that records the duration of serving the given RPC method
+	RecordRPCServerRequest(method string) func()
+}
+
 type adminAPI struct {
 	dr driverClient
-	m  *metrics.Metrics
+	m  rpcMetrics
 }
 
-func newAdminAPI(dr driverClient, m *metrics.Metrics) *adminAPI {
+func NewAdminAPI(dr driverClient, m rpcMetrics) *adminAPI {
 	return &adminAPI{
 		dr: dr,
 		m:  m,
@@ -49,10 +53,10 @@ type nodeAPI struct {
 	client l2EthClient
 	dr     driverClient
 	log    log.Logger
-	m      *metrics.Metrics
+	m      rpcMetrics
 }
 
-func newNodeAPI(config *rollup.Config, l2Client l2EthClient, dr driverClient, log log.Logger, m *metrics.Metrics) *nodeAPI {
+func NewNodeAPI(config *rollup.Config, l2Client l2EthClient, dr driverClient, log log.Logger, m rpcMetrics) *nodeAPI {
 	return &nodeAPI{
 		config: config,
 		client: l2Client,

op-node/node/log.go

@@ -44,7 +44,7 @@ func (cfg *LogConfig) Check() error {
 func (cfg *LogConfig) NewLogger() log.Logger {
 	handler := log.StreamHandler(os.Stdout, format(cfg.Format, cfg.Color))
 	handler = log.SyncHandler(handler)
-	log.LvlFilterHandler(level(cfg.Level), handler)
+	handler = log.LvlFilterHandler(level(cfg.Level), handler)
 	logger := log.New()
 	logger.SetHandler(handler)
 	return logger

op-node/node/node.go

@@ -171,7 +171,7 @@ func (n *OpNode) initRPCServer(ctx context.Context, cfg *Config) error {
 		n.server.EnableP2P(p2p.NewP2PAPIBackend(n.p2pNode, n.log, n.metrics))
 	}
 	if cfg.RPC.EnableAdmin {
-		n.server.EnableAdminAPI(newAdminAPI(n.l2Driver, n.metrics))
+		n.server.EnableAdminAPI(NewAdminAPI(n.l2Driver, n.metrics))
 	}
 	n.log.Info("Starting JSON-RPC server")
 	if err := n.server.Start(); err != nil {

op-node/node/server.go

@@ -29,7 +29,7 @@ type rpcServer struct {
 }
 
 func newRPCServer(ctx context.Context, rpcCfg *RPCConfig, rollupCfg *rollup.Config, l2Client l2EthClient, dr driverClient, log log.Logger, appVersion string, m *metrics.Metrics) (*rpcServer, error) {
-	api := newNodeAPI(rollupCfg, l2Client, dr, log.New("rpc", "node"), m)
+	api := NewNodeAPI(rollupCfg, l2Client, dr, log.New("rpc", "node"), m)
 	// TODO: extend RPC config with options for WS, IPC and HTTP RPC connections
 	endpoint := net.JoinHostPort(rpcCfg.ListenAddr, strconv.Itoa(rpcCfg.ListenPort))
 	r := &rpcServer{

op-node/rollup/derive/attributes_test.go

@@ -114,12 +114,13 @@ func TestPreparePayloadAttributes(t *testing.T) {
 		l1Info.InfoParentHash = l2Parent.L1Origin.Hash
 		l1Info.InfoNum = l2Parent.L1Origin.Number + 1
 
-		receipts, depositTxs := makeReceipts(rng, l1Info.InfoHash, cfg.DepositContractAddress, []receiptData{
+		receipts, depositTxs, err := makeReceipts(rng, l1Info.InfoHash, cfg.DepositContractAddress, []receiptData{
 			{goodReceipt: true, DepositLogs: []bool{true, false}},
 			{goodReceipt: true, DepositLogs: []bool{true}},
 			{goodReceipt: false, DepositLogs: []bool{true}},
 			{goodReceipt: false, DepositLogs: []bool{false}},
 		})
+		require.NoError(t, err)
 		usedDepositTxs, err := encodeDeposits(depositTxs)
 		require.NoError(t, err)
 

op-node/rollup/derive/batch_queue.go

@@ -148,7 +148,7 @@ func (bq *BatchQueue) deriveNextBatch(ctx context.Context, outOfData bool, l2Saf
 	epoch := bq.l1Blocks[0]
 
 	if l2SafeHead.L1Origin != epoch.ID() {
-		return nil, NewResetError(fmt.Errorf("buffered L1 chain epoch %s in batch queue does not match safe head %s", epoch, l2SafeHead))
+		return nil, NewResetError(fmt.Errorf("buffered L1 chain epoch %s in batch queue does not match safe head origin %s", epoch, l2SafeHead.L1Origin))
 	}
 
 	// Find the first-seen batch that matches all validity conditions.

op-node/rollup/derive/deposit_log.go

@@ -140,7 +140,7 @@ func unmarshalDepositVersion0(dep *types.DepositTx, to common.Address, opaqueDat
 
 // MarshalDepositLogEvent returns an EVM log entry that encodes a TransactionDeposited event from the deposit contract.
 // This is the reverse of the deposit transaction derivation.
-func MarshalDepositLogEvent(depositContractAddr common.Address, deposit *types.DepositTx) *types.Log {
+func MarshalDepositLogEvent(depositContractAddr common.Address, deposit *types.DepositTx) (*types.Log, error) {
 	toBytes := common.Hash{}
 	if deposit.To != nil {
 		toBytes = deposit.To.Hash()
@@ -157,7 +157,10 @@ func MarshalDepositLogEvent(depositContractAddr common.Address, deposit *types.D
 	// opaqueData slice content offset: value will always be 0x20.
 	binary.BigEndian.PutUint64(data[32-8:32], 32)
 
-	opaqueData := marshalDepositVersion0(deposit)
+	opaqueData, err := marshalDepositVersion0(deposit)
+	if err != nil {
+		return &types.Log{}, err
+	}
 
 	// opaqueData slice length
 	binary.BigEndian.PutUint64(data[64-8:64], uint64(len(opaqueData)))
@@ -182,20 +185,26 @@ func MarshalDepositLogEvent(depositContractAddr common.Address, deposit *types.D
 		TxIndex:     0,
 		BlockHash:   common.Hash{},
 		Index:       0,
-	}
+	}, nil
 }
 
-func marshalDepositVersion0(deposit *types.DepositTx) (opaqueData []byte) {
-	opaqueData = make([]byte, 32+32+8+1, 32+32+8+1+len(deposit.Data))
+func marshalDepositVersion0(deposit *types.DepositTx) ([]byte, error) {
+	opaqueData := make([]byte, 32+32+8+1, 32+32+8+1+len(deposit.Data))
 	offset := 0
 
 	// uint256 mint
 	if deposit.Mint != nil {
+		if deposit.Mint.BitLen() > 256 {
+			return nil, fmt.Errorf("mint value exceeds 256 bits: %d", deposit.Mint)
+		}
 		deposit.Mint.FillBytes(opaqueData[offset : offset+32])
 	}
 	offset += 32
 
 	// uint256 value
+	if deposit.Value.BitLen() > 256 {
+		return nil, fmt.Errorf("value value exceeds 256 bits: %d", deposit.Value)
+	}
 	deposit.Value.FillBytes(opaqueData[offset : offset+32])
 	offset += 32
 
@@ -211,5 +220,5 @@ func marshalDepositVersion0(deposit *types.DepositTx) (opaqueData []byte) {
 	// Deposit data then fills the remaining event data
 	opaqueData = append(opaqueData, deposit.Data...)
 
-	return opaqueData
+	return opaqueData, nil
 }

op-node/rollup/derive/deposit_log_test.go

@@ -23,7 +23,10 @@ func TestUnmarshalLogEvent(t *testing.T) {
 				LogIndex:    uint64(rng.Intn(10000)),
 			}
 			depInput := testutils.GenerateDeposit(source.SourceHash(), rng)
-			log := MarshalDepositLogEvent(MockDepositContractAddr, depInput)
+			log, err := MarshalDepositLogEvent(MockDepositContractAddr, depInput)
+			if err != nil {
+				t.Fatal(err)
+			}
 
 			log.TxIndex = uint(rng.Intn(10000))
 			log.Index = uint(source.LogIndex)
@@ -47,8 +50,10 @@ type receiptData struct {
 	DepositLogs []bool
 }
 
-func makeReceipts(rng *rand.Rand, blockHash common.Hash, depositContractAddr common.Address, testReceipts []receiptData) (receipts []*types.Receipt, expectedDeposits []*types.DepositTx) {
+func makeReceipts(rng *rand.Rand, blockHash common.Hash, depositContractAddr common.Address, testReceipts []receiptData) ([]*types.Receipt, []*types.DepositTx, error) {
 	logIndex := uint(0)
+	receipts := []*types.Receipt{}
+	expectedDeposits := []*types.DepositTx{}
 	for txIndex, rData := range testReceipts {
 		var logs []*types.Log
 		status := types.ReceiptStatusSuccessful
@@ -57,13 +62,17 @@ func makeReceipts(rng *rand.Rand, blockHash common.Hash, depositContractAddr com
 		}
 		for _, isDeposit := range rData.DepositLogs {
 			var ev *types.Log
+			var err error
 			if isDeposit {
 				source := UserDepositSource{L1BlockHash: blockHash, LogIndex: uint64(logIndex)}
 				dep := testutils.GenerateDeposit(source.SourceHash(), rng)
 				if status == types.ReceiptStatusSuccessful {
 					expectedDeposits = append(expectedDeposits, dep)
 				}
-				ev = MarshalDepositLogEvent(depositContractAddr, dep)
+				ev, err = MarshalDepositLogEvent(depositContractAddr, dep)
+				if err != nil {
+					return []*types.Receipt{}, []*types.DepositTx{}, err
+				}
 			} else {
 				ev = testutils.GenerateLog(testutils.RandomAddress(rng), nil, nil)
 			}
@@ -82,7 +91,7 @@ func makeReceipts(rng *rand.Rand, blockHash common.Hash, depositContractAddr com
 			TransactionIndex: uint(txIndex),
 		})
 	}
-	return
+	return receipts, expectedDeposits, nil
 }
 
 type DeriveUserDepositsTestCase struct {
@@ -108,7 +117,10 @@ func TestDeriveUserDeposits(t *testing.T) {
 		t.Run(testCase.name, func(t *testing.T) {
 			rng := rand.New(rand.NewSource(1234 + int64(i)))
 			blockHash := testutils.RandomHash(rng)
-			receipts, expectedDeposits := makeReceipts(rng, blockHash, MockDepositContractAddr, testCase.receipts)
+			receipts, expectedDeposits, err := makeReceipts(rng, blockHash, MockDepositContractAddr, testCase.receipts)
+			if err != nil {
+				t.Fatal(err)
+			}
 			got, err := UserDeposits(receipts, MockDepositContractAddr)
 			require.NoError(t, err)
 			require.Equal(t, len(got), len(expectedDeposits))

op-node/rollup/derive/l1_block_info.go

@@ -40,6 +40,10 @@ func (info *L1BlockInfo) MarshalBinary() ([]byte, error) {
 	offset += 32
 	binary.BigEndian.PutUint64(data[offset+24:offset+32], info.Time)
 	offset += 32
+	// Ensure that the baseFee is not too large.
+	if info.BaseFee.BitLen() > 256 {
+		return nil, fmt.Errorf("base fee exceeds 256 bits: %d", info.BaseFee)
+	}
 	info.BaseFee.FillBytes(data[offset : offset+32])
 	offset += 32
 	copy(data[offset:offset+32], info.BlockHash.Bytes())

op-node/sources/rollupclient.go

@@ -4,17 +4,17 @@ import (
 	"context"
 	"math/big"
 
+	"github.com/ethereum-optimism/optimism/op-node/client"
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/rpc"
 )
 
 type RollupClient struct {
-	rpc *rpc.Client
+	rpc client.RPC
 }
 
-func NewRollupClient(rpc *rpc.Client) *RollupClient {
+func NewRollupClient(rpc client.RPC) *RollupClient {
 	return &RollupClient{rpc}
 }
 

op-node/testutils/metrics.go

@@ -34,3 +34,9 @@ func (t *TestDerivationMetrics) RecordUnsafePayloadsBuffer(length uint64, memSiz
 		t.FnRecordUnsafePayloads(length, memSize, next)
 	}
 }
+
+type TestRPCMetrics struct{}
+
+func (n *TestRPCMetrics) RecordRPCServerRequest(method string) func() {
+	return func() {}
+}

op-proposer/l2_output_submitter.go

@@ -12,9 +12,7 @@ import (
 	"syscall"
 	"time"
 
-	hdwallet "github.com/miguelmota/go-ethereum-hdwallet"
-	"github.com/urfave/cli"
-
+	"github.com/ethereum-optimism/optimism/op-node/client"
 	"github.com/ethereum-optimism/optimism/op-node/sources"
 	"github.com/ethereum-optimism/optimism/op-proposer/drivers/l2output"
 	"github.com/ethereum-optimism/optimism/op-proposer/txmgr"
@@ -28,6 +26,8 @@ import (
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rpc"
+	hdwallet "github.com/miguelmota/go-ethereum-hdwallet"
+	"github.com/urfave/cli"
 )
 
 const (
@@ -86,6 +86,8 @@ func Main(version string) func(ctx *cli.Context) error {
 					l.Error("error starting metrics server", err)
 				}
 			}()
+			addr := l2OutputSubmitter.l2OutputService.cfg.Driver.WalletAddr()
+			opmetrics.LaunchBalanceMetrics(ctx, l, registry, "", l2OutputSubmitter.l2OutputService.cfg.L1Client, addr)
 		}
 
 		rpcCfg := cfg.RPCConfig
@@ -250,12 +252,12 @@ func dialRollupClientWithTimeout(ctx context.Context, url string) (*sources.Roll
 	ctxt, cancel := context.WithTimeout(ctx, defaultDialTimeout)
 	defer cancel()
 
-	client, err := rpc.DialContext(ctxt, url)
+	rpcCl, err := rpc.DialContext(ctxt, url)
 	if err != nil {
 		return nil, err
 	}
 
-	return sources.NewRollupClient(client), nil
+	return sources.NewRollupClient(client.NewBaseRPCClient(rpcCl)), nil
 }
 
 // parseAddress parses an ETH address from a hex string. This method will fail if

op-proposer/rollupclient/rollupclient.go

-package rollupclient
-
-import (
-	"github.com/ethereum-optimism/optimism/op-node/sources"
-	"github.com/ethereum/go-ethereum/rpc"
-)
-
-// Deprecated: use sources.RollupClient instead
-type RollupClient = sources.RollupClient
-
-// Deprecated: use sources.NewRollupClient instead
-func NewRollupClient(rpc *rpc.Client) *sources.RollupClient {
-	return sources.NewRollupClient(rpc)
-}

op-service/go.sum

@@ -102,6 +102,7 @@ github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:Htrtb
 github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
 github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
 github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
+github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
 github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
 github.com/envoyproxy/go-control-plane v0.6.9/go.mod h1:SBwIajubJHhxtWwsL9s8ss4safvEdbitLhGGK48rN6g=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
@@ -119,6 +120,7 @@ github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMo
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 github.com/fsnotify/fsnotify v1.5.4 h1:jRbGcIw6P2Meqdwuo0H1p6JVLbL5DHKAKlYndzMwVZI=
 github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU=
+github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
@@ -205,6 +207,7 @@ github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hf
 github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.2.0 h1:qJYtXnJRWmpe7m/3XlyhrsLrEURqHRM2kxzoxXqyUDs=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
 github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
@@ -241,6 +244,8 @@ github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO
 github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=
 github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I=
 github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
+github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao=
+github.com/holiman/uint256 v1.2.0 h1:gpSYcPLWGv4sG43I2mVLiDZCNDh/EpGjSk8tmtxitHM=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg=
 github.com/huin/goupnp v1.0.3 h1:N8No57ls+MnjlB+JPiCVSOyy/ot7MJTqlo7rn+NYSqQ=
@@ -406,6 +411,7 @@ github.com/prometheus/tsdb v0.10.0/go.mod h1:oi49uRhEe9dPUTlS3JRZOwJuVi6tmh10QSg
 github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
 github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rjeczalik/notify v0.9.1 h1:CLCKso/QK1snAlnhNR/CNvNiFU2saUtjV0bx3EwNeCE=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -432,6 +438,7 @@ github.com/sony/gobreaker v0.4.1/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJ
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
 github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4 h1:Gb2Tyox57NRNuZ2d3rmvB3pcmbu7O1RS3m8WRx7ilrg=
 github.com/streadway/amqp v0.0.0-20190404075320-75d898a42a94/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
 github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
 github.com/streadway/handy v0.0.0-20190108123426-d5acb3125c2a/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI=
@@ -454,6 +461,7 @@ github.com/tklauser/go-sysconf v0.3.10/go.mod h1:C8XykCvCb+Gn0oNCWPIlcb0RuglQTYa
 github.com/tklauser/numcpus v0.4.0 h1:E53Dm1HjH1/R2/aoCtXtPgzmElmn51aOkhCFSuZq//o=
 github.com/tklauser/numcpus v0.4.0/go.mod h1:1+UI3pD8NW14VMwdgJNJ1ESk2UnwhAnz5hMwiKKqXCQ=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
+github.com/tyler-smith/go-bip39 v1.0.1-0.20181017060643-dbb3b84ba2ef h1:wHSqTBrZW24CsNJDfeh9Ex6Pm0Rcpc7qrgKBiL44vF4=
 github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
 github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
 github.com/urfave/cli v1.22.9 h1:cv3/KhXGBGjEXLC4bH0sLuJ9BewaAbpk5oyMOveu4pw=
@@ -661,6 +669,7 @@ golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxb
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba h1:O8mE0/t419eoIwhTFpKVkHiTs/Igowgfkj25AcZrtiE=
 golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

op-service/metrics/balance.go

+package metrics
+
+import (
+	"context"
+	"math/big"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+)
+
+// weiToEther divides the wei value by 10^18 to get a number in ether as a float64
+func weiToEther(wei *big.Int) float64 {
+	num := new(big.Rat).SetInt(wei)
+	denom := big.NewRat(params.Ether, 1)
+	num = num.Quo(num, denom)
+	f, _ := num.Float64()
+	return f
+}
+
+// LaunchBalanceMetrics fires off a go rountine that queries the balance of the supplied account & periodically records it
+// to the balance metric of the namespace. The balance of the account is recorded in Ether (not Wei).
+// Cancel the supplied context to shut down the go routine
+func LaunchBalanceMetrics(ctx context.Context, log log.Logger, r *prometheus.Registry, ns string, client *ethclient.Client, account common.Address) {
+	go func() {
+		balanceGuage := promauto.With(r).NewGauge(prometheus.GaugeOpts{
+			Namespace: ns,
+			Name:      "balance",
+			Help:      "balance (in ether) of account " + account.String(),
+		})
+
+		ticker := time.NewTicker(10 * time.Second)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ticker.C:
+				ctx, cancel := context.WithTimeout(ctx, 1*time.Minute)
+				bigBal, err := client.BalanceAt(ctx, account, nil)
+				if err != nil {
+					log.Warn("failed to get balance of account", "err", err, "address", account)
+					cancel()
+					continue
+				}
+				bal := weiToEther(bigBal)
+				balanceGuage.Set(bal)
+				cancel()
+			case <-ctx.Done():
+				log.Info("balance metrics shutting down")
+				return
+			}
+		}
+
+	}()
+}

op-service/metrics/balance_test.go

+package metrics
+
+import (
+	"math/big"
+	"testing"
+)
+
+type weiToEthTestCase struct {
+	input  *big.Int
+	output float64
+}
+
+func TestWeiToEther(t *testing.T) {
+	tests := []weiToEthTestCase{
+		{
+			input:  big.NewInt(1_000_000_000_000_000_000),
+			output: 1.0,
+		},
+		{
+			input:  big.NewInt(3_000_000_000_000_000_000),
+			output: 3.0,
+		},
+		{
+			input:  big.NewInt(3_456_789_000_000_000_000),
+			output: 3.456789,
+		},
+		{
+			input:  new(big.Int).Mul(big.NewInt(1_000_000), big.NewInt(1_000_000_000_000_000_000)),
+			output: 1_000_000,
+		},
+	}
+
+	for i, tc := range tests {
+		out := weiToEther(tc.input)
+		if out != tc.output {
+			t.Fatalf("test %v: expected %v but got %v", i, tc.output, out)
+		}
+	}
+
+}

ops-bedrock/docker-compose.yml

@@ -86,6 +86,7 @@ services:
       dockerfile: ./op-proposer/Dockerfile
     ports:
       - "6062:6060"
+      - "7302:7300"
     environment:
       OP_PROPOSER_L1_ETH_RPC: http://l1:8545
       OP_PROPOSER_L2_ETH_RPC: http://l2:8545
@@ -99,6 +100,7 @@ services:
       OP_PROPOSER_LOG_TERMINAL: "true"
       OP_PROPOSER_L2OO_ADDRESS: "${L2OO_ADDRESS}"
       OP_PROPOSER_PPROF_ENABLED: "true"
+      OP_PROPOSER_METRICS_ENABLED: "true"
 
   op-batcher:
     depends_on:
@@ -110,6 +112,7 @@ services:
       dockerfile: ./op-batcher/Dockerfile
     ports:
       - "6061:6060"
+      - "7301:7300"
     environment:
       OP_BATCHER_L1_ETH_RPC: http://l1:8545
       OP_BATCHER_L2_ETH_RPC: http://l2:8545
@@ -127,6 +130,7 @@ services:
       OP_BATCHER_SEQUENCER_BATCH_INBOX_ADDRESS: "${SEQUENCER_BATCH_INBOX_ADDRESS}"
       OP_BATCHER_LOG_TERMINAL: "true"
       OP_BATCHER_PPROF_ENABLED: "true"
+      OP_BATCHER_METRICS_ENABLED: "true"
 
   stateviz:
     build:

ops/docker/ci-builder/CHANGELOG.md

 # @eth-optimism/ci-builder
 
+## 0.3.3
+
+### Patch Changes
+
+- 3f485627: Pin slither version to 0.9.0
+
 ## 0.3.2
 
 ### Patch Changes

ops/docker/ci-builder/package.json

 {
   "name": "@eth-optimism/ci-builder",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "scripts": {},
   "license": "MIT",
   "dependencies": {}

packages/actor-tests/CHANGELOG.md

 # @eth-optimism/actor-tests
 
+## 0.0.9
+
+### Patch Changes
+
+- Updated dependencies [35a7bb5e]
+- Updated dependencies [b40913b1]
+- Updated dependencies [a5e715c3]
+- Updated dependencies [d18b8aa3]
+  - @eth-optimism/contracts-bedrock@0.8.1
+  - @eth-optimism/sdk@1.6.7
+
 ## 0.0.8
 
 ### Patch Changes

packages/actor-tests/package.json

 {
   "name": "@eth-optimism/actor-tests",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "A library and suite of tests to stress test Optimism Bedrock.",
   "license": "MIT",
   "author": "",
@@ -18,9 +18,9 @@
     "test:coverage": "yarn test"
   },
   "dependencies": {
-    "@eth-optimism/contracts-bedrock": "0.8.0",
+    "@eth-optimism/contracts-bedrock": "0.8.1",
     "@eth-optimism/core-utils": "^0.10.1",
-    "@eth-optimism/sdk": "^1.6.6",
+    "@eth-optimism/sdk": "^1.6.7",
     "@types/chai": "^4.2.18",
     "@types/chai-as-promised": "^7.1.4",
     "async-mutex": "^0.3.2",

packages/contracts-bedrock/.gas-snapshot

@@ -6,7 +6,7 @@ GasBenchMark_L1StandardBridge_Deposit:test_depositERC20_benchmark_1() (gas: 1122
 GasBenchMark_L1StandardBridge_Deposit:test_depositETH_benchmark_0() (gas: 348094)
 GasBenchMark_L1StandardBridge_Deposit:test_depositETH_benchmark_1() (gas: 112225)
 GasBenchMark_L1StandardBridge_Finalize:test_finalizeETHWithdrawal_benchmark() (gas: 40569)
-GasBenchMark_L2OutputOracle:test_proposeL2Output_benchmark() (gas: 68671)
+GasBenchMark_L2OutputOracle:test_proposeL2Output_benchmark() (gas: 68693)
 GasBenchMark_OptimismPortal:test_depositTransaction_benchmark() (gas: 74964)
 GasBenchMark_OptimismPortal:test_depositTransaction_benchmark_1() (gas: 35777)
 CrossDomainMessenger_Test:testFuzz_baseGas(uint32) (runs: 256, μ: 20263, ~: 20263)
@@ -97,29 +97,29 @@ L2CrossDomainMessenger_Test:test_L2MessengerSendMessage() (gas: 120648)
 L2CrossDomainMessenger_Test:test_L2MessengerTwiceSendMessage() (gas: 136338)
 L2CrossDomainMessenger_Test:test_L2MessengerXDomainSenderReverts() (gas: 10576)
 L2CrossDomainMessenger_Test:test_L2MessengerxDomainMessageSenderResets() (gas: 50459)
-L2OutputOracleTest:testCannot_ProposeWithUnmatchedBlockhash() (gas: 26829)
-L2OutputOracleTest:testCannot_constructWithBadTimestamp() (gas: 52842)
-L2OutputOracleTest:testCannot_deleteL2Output_ifNotOwner() (gas: 25123)
-L2OutputOracleTest:testCannot_deleteL2Output_withWrongRoot() (gas: 91467)
-L2OutputOracleTest:testCannot_deleteL2Output_withWrongTime() (gas: 87450)
-L2OutputOracleTest:testCannot_proposeEmptyOutput() (gas: 24150)
-L2OutputOracleTest:testCannot_proposeFutureTimetamp() (gas: 26074)
-L2OutputOracleTest:testCannot_proposeL2OutputIfNotProposer() (gas: 23564)
-L2OutputOracleTest:testCannot_proposeOnWrongFork() (gas: 26381)
-L2OutputOracleTest:testCannot_proposeUnexpectedBlockNumber() (gas: 26005)
-L2OutputOracleTest:test_changeProposer() (gas: 56127)
-L2OutputOracleTest:test_computeL2Timestamp() (gas: 30284)
-L2OutputOracleTest:test_constructor() (gas: 49046)
-L2OutputOracleTest:test_deleteOutput() (gas: 77260)
-L2OutputOracleTest:test_getL2Output() (gas: 88523)
-L2OutputOracleTest:test_latestBlockNumber() (gas: 76242)
+L2OutputOracleTest:testCannot_ProposeWithUnmatchedBlockhash() (gas: 26828)
+L2OutputOracleTest:testCannot_constructWithBadTimestamp() (gas: 52850)
+L2OutputOracleTest:testCannot_deleteL2Output_ifNotOwner() (gas: 25145)
+L2OutputOracleTest:testCannot_deleteL2Output_withWrongRoot() (gas: 91488)
+L2OutputOracleTest:testCannot_deleteL2Output_withWrongTime() (gas: 87471)
+L2OutputOracleTest:testCannot_proposeEmptyOutput() (gas: 24149)
+L2OutputOracleTest:testCannot_proposeFutureTimetamp() (gas: 26073)
+L2OutputOracleTest:testCannot_proposeL2OutputIfNotProposer() (gas: 23563)
+L2OutputOracleTest:testCannot_proposeOnWrongFork() (gas: 26380)
+L2OutputOracleTest:testCannot_proposeUnexpectedBlockNumber() (gas: 26004)
+L2OutputOracleTest:test_changeProposer() (gas: 56149)
+L2OutputOracleTest:test_computeL2Timestamp() (gas: 30192)
+L2OutputOracleTest:test_constructor() (gas: 49090)
+L2OutputOracleTest:test_deleteOutput() (gas: 77312)
+L2OutputOracleTest:test_getL2Output() (gas: 88610)
+L2OutputOracleTest:test_latestBlockNumber() (gas: 76241)
 L2OutputOracleTest:test_nextBlockNumber() (gas: 15254)
-L2OutputOracleTest:test_proposeWithBlockhashAndHeight() (gas: 75046)
-L2OutputOracleTest:test_proposingAnotherOutput() (gas: 76903)
-L2OutputOracleTest:test_updateOwner() (gas: 46095)
-L2OutputOracleUpgradeable_Test:test_cannotInitImpl() (gas: 19555)
-L2OutputOracleUpgradeable_Test:test_cannotInitProxy() (gas: 24554)
-L2OutputOracleUpgradeable_Test:test_initValuesOnProxy() (gas: 39086)
+L2OutputOracleTest:test_proposeWithBlockhashAndHeight() (gas: 75045)
+L2OutputOracleTest:test_proposingAnotherOutput() (gas: 76902)
+L2OutputOracleTest:test_updateOwner() (gas: 46161)
+L2OutputOracleUpgradeable_Test:test_cannotInitImpl() (gas: 17381)
+L2OutputOracleUpgradeable_Test:test_cannotInitProxy() (gas: 22377)
+L2OutputOracleUpgradeable_Test:test_initValuesOnProxy() (gas: 39108)
 L2OutputOracleUpgradeable_Test:test_upgrading() (gas: 180632)
 L2StandardBridge_Test:test_cannotWithdrawEthWithoutSendingIt() (gas: 21816)
 L2StandardBridge_Test:test_finalizeBridgeETH_incorrectValueReverts() (gas: 23835)
@@ -162,16 +162,16 @@ OptimismPortalUpgradeable_Test:test_cannotInitImpl() (gas: 10813)
 OptimismPortalUpgradeable_Test:test_cannotInitProxy() (gas: 15789)
 OptimismPortalUpgradeable_Test:test_initValuesOnProxy() (gas: 15967)
 OptimismPortalUpgradeable_Test:test_upgrading() (gas: 180632)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_differential(address,address,uint256,uint256,bytes) (runs: 256, μ: 258471, ~: 259036)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_differential(address,address,uint256,uint256,bytes) (runs: 256, μ: 258442, ~: 259036)
 OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_revertsOnInsufficientGas() (gas: 158312)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_revertsOnInvalidOutputRootProof() (gas: 81265)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_revertsOnInvalidOutputRootProof() (gas: 81287)
 OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_revertsOnRecentWithdrawal() (gas: 50525)
 OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_revertsOnReentrancy() (gas: 202902)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_revertsOnReplay() (gas: 278777)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_revertsOnReplay() (gas: 278821)
 OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_revertsOnSelfCall() (gas: 50563)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_revertsOninvalidWithdrawalProof() (gas: 148586)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_succeeds() (gas: 186825)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_targetFails() (gas: 289474)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_revertsOninvalidWithdrawalProof() (gas: 148608)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_succeeds() (gas: 186847)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_targetFails() (gas: 289496)
 OptimismPortal_Test:test_OptimismPortalConstructor() (gas: 17341)
 OptimismPortal_Test:test_OptimismPortalContractCreationReverts() (gas: 14199)
 OptimismPortal_Test:test_OptimismPortalReceiveEth() (gas: 127534)
@@ -183,7 +183,7 @@ OptimismPortal_Test:test_depositTransaction_withEthValueAndContractContractCreat
 OptimismPortal_Test:test_depositTransaction_withEthValueAndEOAContractCreation() (gas: 75881)
 OptimismPortal_Test:test_depositTransaction_withEthValueFromContract() (gas: 83333)
 OptimismPortal_Test:test_depositTransaction_withEthValueFromEOA() (gas: 83993)
-OptimismPortal_Test:test_isBlockFinalized() (gas: 113744)
+OptimismPortal_Test:test_isBlockFinalized() (gas: 113897)
 OptimismPortal_Test:test_simple_isBlockFinalized() (gas: 24130)
 Proxy_Test:test_clashingFunctionSignatures() (gas: 101427)
 Proxy_Test:test_implementationKey() (gas: 20942)

packages/contracts-bedrock/CHANGELOG.md

 # @eth-optimism/contracts-bedrock
 
+## 0.8.1
+
+### Patch Changes
+
+- 35a7bb5e: Use uint64 for arithmetic in XDM's baseGas
+- a5e715c3: Rename the event emitted in the L2ToL1MessagePasser
+- d18b8aa3: Removes an unnecessary initializer parameter in the L200
+
 ## 0.8.0
 
 ### Minor Changes

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

@@ -138,7 +138,27 @@ contract L2OutputOracle is OwnableUpgradeable, Semver {
         STARTING_TIMESTAMP = _startingTimestamp;
         L2_BLOCK_TIME = _l2BlockTime;
 
-        initialize(_genesisL2Output, _startingBlockNumber, _proposer, _owner);
+        initialize(_genesisL2Output, _proposer, _owner);
+    }
+
+    /**
+     * @notice Initializer.
+     *
+     * @param _genesisL2Output     The initial L2 output of the L2 chain.
+     * @param _proposer            The address of the proposer.
+     * @param _owner               The address of the owner.
+     */
+    function initialize(
+        bytes32 _genesisL2Output,
+        address _proposer,
+        address _owner
+    ) public initializer {
+        require(_proposer != _owner, "L2OutputOracle: proposer cannot be the same as the owner");
+        l2Outputs[STARTING_BLOCK_NUMBER] = Types.OutputProposal(_genesisL2Output, block.timestamp);
+        latestBlockNumber = STARTING_BLOCK_NUMBER;
+        __Ownable_init();
+        changeProposer(_proposer);
+        _transferOwnership(_owner);
     }
 
     /**
@@ -257,28 +277,6 @@ contract L2OutputOracle is OwnableUpgradeable, Semver {
         return output;
     }
 
-    /**
-     * @notice Initializer.
-     *
-     * @param _genesisL2Output     The initial L2 output of the L2 chain.
-     * @param _startingBlockNumber The timestamp to start L2 block at.
-     * @param _proposer            The address of the proposer.
-     * @param _owner               The address of the owner.
-     */
-    function initialize(
-        bytes32 _genesisL2Output,
-        uint256 _startingBlockNumber,
-        address _proposer,
-        address _owner
-    ) public initializer {
-        require(_proposer != _owner, "L2OutputOracle: proposer cannot be the same as the owner");
-        l2Outputs[_startingBlockNumber] = Types.OutputProposal(_genesisL2Output, block.timestamp);
-        latestBlockNumber = _startingBlockNumber;
-        __Ownable_init();
-        changeProposer(_proposer);
-        _transferOwnership(_owner);
-    }
-
     /**
      * @notice Overrides the standard implementation of transferOwnership
      *         to add the requirement that the owner and proposer are distinct.

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

@@ -130,12 +130,13 @@ contract L2OutputOracle_Initializer is CommonTest {
         vm.prank(multisig);
         proxy.upgradeToAndCall(
             address(oracleImpl),
-            abi.encodeWithSelector(
-                L2OutputOracle.initialize.selector,
-                genesisL2Output,
-                startingBlockNumber,
-                proposer,
-                owner
+            abi.encodeCall(
+                L2OutputOracle.initialize,
+                (
+                    genesisL2Output,
+                    proposer,
+                    owner
+                )
             )
         );
         oracle = L2OutputOracle(address(proxy));

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

@@ -384,7 +384,6 @@ contract L2OutputOracleUpgradeable_Test is L2OutputOracle_Initializer {
         vm.expectRevert("Initializable: contract is already initialized");
         L2OutputOracle(payable(proxy)).initialize(
             genesisL2Output,
-            startingBlockNumber,
             proposer,
             owner
         );
@@ -394,7 +393,6 @@ contract L2OutputOracleUpgradeable_Test is L2OutputOracle_Initializer {
         vm.expectRevert("Initializable: contract is already initialized");
         L2OutputOracle(oracleImpl).initialize(
             genesisL2Output,
-            startingBlockNumber,
             proposer,
             owner
         );

packages/contracts-bedrock/deploy/001-InitImplementations.deploy.ts

@@ -10,7 +10,6 @@ const upgradeABIs = {
     'initialize(bytes32,uint256,address,address)',
     [
       deployConfig.l2OutputOracleGenesisL2Output,
-      deployConfig.l2OutputOracleStartingBlockNumber,
       deployConfig.l2OutputOracleProposer,
       deployConfig.l2OutputOracleOwner,
     ],

packages/contracts-bedrock/package.json

 {
   "name": "@eth-optimism/contracts-bedrock",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Contracts for Optimism Specs",
   "main": "dist/index",
   "types": "dist/index",

packages/contracts-governance/deploy-config/optimism-goerli.json

+{
+    "upgrader": "0xC30276833798867C1dBC5c468bf51cA900b44E4c"
+}

packages/contracts-governance/deploy-config/optimism-mainnet.json

+{
+    "upgrader": "0x2A82Ae142b2e62Cb7D10b55E323ACB1Cab663a26"
+}

packages/contracts-governance/deploy/000-mint-manager-impl.ts

+import { DeployFunction } from 'hardhat-deploy/dist/types'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import 'hardhat-deploy'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+import { sleep } from '@eth-optimism/core-utils'
+
+// $ cast call --rpc-url https://mainnet.optimism.io 0x4200000000000000000000000000000000000042 'owner()(address)'
+// 0x724604DB3C8D86c906A27B610703fD0296Eb26D5
+// $ cast call --rpc-url https://mainnet.optimism.io 0x724604DB3C8D86c906A27B610703fD0296Eb26D5 'owner()(address)'
+// 0x2A82Ae142b2e62Cb7D10b55E323ACB1Cab663a26
+//
+// $ cast call --rpc-url https://goerli.optimism.io 0x4200000000000000000000000000000000000042 'owner()(address)'
+// 0xB2DcB2Df7732030eD99241E5F9aEBB3Fb53eFCb6
+// $ cast call --rpc-url https://goerli.optimism.io 0xB2DcB2Df7732030eD99241E5F9aEBB3Fb53eFCb6  'owner()(address)'
+// 0xC30276833798867C1dBC5c468bf51cA900b44E4c
+
+// Deployment steps:
+//  1 - Deploy new MintManager implementation
+//  2 - Multisig transaction calls `upgrade()` on the old MintManager
+const deployFn: DeployFunction = async (hre: HardhatRuntimeEnvironment) => {
+  const { deploy } = hre.deployments
+  const { deployer } = await hre.getNamedAccounts()
+
+  const upgrader = hre.deployConfig.upgrader
+  const governanceToken = '0x4200000000000000000000000000000000000042'
+
+  if (upgrader === '' || upgrader === hre.ethers.constants.AddressZero) {
+    throw new Error('upgrader not set in deploy-config')
+  }
+
+  // There is no artifact for the originally deployed MintManager
+  let oldImpl: string
+  if (hre.network.name === 'optimism-mainnet') {
+    oldImpl = '0x724604DB3C8D86c906A27B610703fD0296Eb26D5'
+  } else if (hre.network.name === 'optimism-goerli') {
+    oldImpl = '0xB2DcB2Df7732030eD99241E5F9aEBB3Fb53eFCb6'
+  } else {
+    throw new Error(`unknown network ${hre.network.name}`)
+  }
+
+  await deploy('MintManager', {
+    from: deployer,
+    args: [upgrader, governanceToken],
+    log: true,
+    waitConfirmations: 1,
+  })
+
+  const GovernanceToken = await hre.ethers.getContractAt(
+    'GovernanceToken',
+    '0x4200000000000000000000000000000000000042'
+  )
+
+  const Old__MintManager = await hre.ethers.getContractAt(
+    'MintManager',
+    oldImpl
+  )
+  const oldOwner = await Old__MintManager.owner()
+
+  const getAddress = hre.ethers.utils.getAddress
+
+  const Deployment__MintManager = await hre.deployments.get('MintManager')
+  const newImpl = Deployment__MintManager.address
+
+  console.log()
+  console.log('Action is required to complete this deployment')
+  console.log(
+    'Ownership of the GovernanceToken should be migrated to the newly deployed MintManager'
+  )
+  console.log(`MintManager.owner() -> ${oldOwner}`)
+  console.log(`Call MintManager(${oldImpl}).upgrade(${newImpl})`)
+  console.log()
+
+  while (true) {
+    const owner = await GovernanceToken.owner()
+    if (getAddress(owner) === getAddress(oldImpl)) {
+      console.log(`GovernanceToken.owner() is still old implementation`)
+    } else if (getAddress(owner) === getAddress(newImpl)) {
+      console.log(`GovernanceToken.owner() upgraded to new implementation!`)
+      break
+    } else {
+      throw new Error(
+        `GovernanceToken.owner() upgraded to unknown address ${owner}`
+      )
+    }
+    await sleep(5000)
+  }
+}
+
+deployFn.tags = ['MintManager']
+
+export default deployFn

packages/contracts-governance/deployments/optimism-goerli/.chainId

+420
\ No newline at end of file

packages/contracts-governance/deployments/optimism-goerli/solcInputs/b1df373a9ed51b3903b61f56faa9a78f.json

+{
+  "language": "Solidity",
+  "sources": {
+    "contracts/GovernanceToken.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.12;\n\nimport \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol\";\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\n\n/**\n * @dev The Optimism token used in governance and supporting voting and delegation.\n * Implements EIP 2612 allowing signed approvals.\n * Contract is \"owned\" by a `MintManager` instance with permission to the `mint` function only,\n * for the purposes of enforcing the token inflation schedule.\n */\ncontract GovernanceToken is ERC20Burnable, ERC20Votes, Ownable {\n    /**\n     * @dev Constructor.\n     */\n    constructor() ERC20(\"Optimism\", \"OP\") ERC20Permit(\"Optimism\") {}\n\n    function mint(address _account, uint256 _amount) public onlyOwner {\n        _mint(_account, _amount);\n    }\n\n    // The following functions are overrides required by Solidity.\n    function _afterTokenTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal override(ERC20, ERC20Votes) {\n        super._afterTokenTransfer(from, to, amount);\n    }\n\n    function _mint(address to, uint256 amount) internal override(ERC20, ERC20Votes) {\n        super._mint(to, amount);\n    }\n\n    function _burn(address account, uint256 amount) internal override(ERC20, ERC20Votes) {\n        super._burn(account, amount);\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC20/ERC20.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20.sol\";\nimport \"./extensions/IERC20Metadata.sol\";\nimport \"../../utils/Context.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n    mapping(address => uint256) private _balances;\n\n    mapping(address => mapping(address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * The default value of {decimals} is 18. To select a different value for\n     * {decimals} you should overload it.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual override returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual override returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the value {ERC20} uses, unless this function is\n     * overridden;\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual override returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(address to, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(\n        address from,\n        address to,\n        uint256 amount\n    ) public virtual override returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, amount);\n        _transfer(from, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, _allowances[owner][spender] + addedValue);\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        uint256 currentAllowance = _allowances[owner][spender];\n        require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n        unchecked {\n            _approve(owner, spender, currentAllowance - subtractedValue);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Moves `amount` of tokens from `sender` to `recipient`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     */\n    function _transfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal virtual {\n        require(from != address(0), \"ERC20: transfer from the zero address\");\n        require(to != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(from, to, amount);\n\n        uint256 fromBalance = _balances[from];\n        require(fromBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n        unchecked {\n            _balances[from] = fromBalance - amount;\n        }\n        _balances[to] += amount;\n\n        emit Transfer(from, to, amount);\n\n        _afterTokenTransfer(from, to, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        _balances[account] += amount;\n        emit Transfer(address(0), account, amount);\n\n        _afterTokenTransfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        uint256 accountBalance = _balances[account];\n        require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n        unchecked {\n            _balances[account] = accountBalance - amount;\n        }\n        _totalSupply -= amount;\n\n        emit Transfer(account, address(0), amount);\n\n        _afterTokenTransfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(\n        address owner,\n        address spender,\n        uint256 amount\n    ) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Spend `amount` form the allowance of `owner` toward `spender`.\n     *\n     * Does not update the allowance amount in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Might emit an {Approval} event.\n     */\n    function _spendAllowance(\n        address owner,\n        address spender,\n        uint256 amount\n    ) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance != type(uint256).max) {\n            require(currentAllowance >= amount, \"ERC20: insufficient allowance\");\n            unchecked {\n                _approve(owner, spender, currentAllowance - amount);\n            }\n        }\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * has been transferred to `to`.\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal virtual {}\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../ERC20.sol\";\nimport \"../../../utils/Context.sol\";\n\n/**\n * @dev Extension of {ERC20} that allows token holders to destroy both their own\n * tokens and those that they have an allowance for, in a way that can be\n * recognized off-chain (via event analysis).\n */\nabstract contract ERC20Burnable is Context, ERC20 {\n    /**\n     * @dev Destroys `amount` tokens from the caller.\n     *\n     * See {ERC20-_burn}.\n     */\n    function burn(uint256 amount) public virtual {\n        _burn(_msgSender(), amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, deducting from the caller's\n     * allowance.\n     *\n     * See {ERC20-_burn} and {ERC20-allowance}.\n     *\n     * Requirements:\n     *\n     * - the caller must have allowance for ``accounts``'s tokens of at least\n     * `amount`.\n     */\n    function burnFrom(address account, uint256 amount) public virtual {\n        _spendAllowance(account, _msgSender(), amount);\n        _burn(account, amount);\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Votes.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./draft-ERC20Permit.sol\";\nimport \"../../../utils/math/Math.sol\";\nimport \"../../../governance/utils/IVotes.sol\";\nimport \"../../../utils/math/SafeCast.sol\";\nimport \"../../../utils/cryptography/ECDSA.sol\";\n\n/**\n * @dev Extension of ERC20 to support Compound-like voting and delegation. This version is more generic than Compound's,\n * and supports token supply up to 2^224^ - 1, while COMP is limited to 2^96^ - 1.\n *\n * NOTE: If exact COMP compatibility is required, use the {ERC20VotesComp} variant of this module.\n *\n * This extension keeps a history (checkpoints) of each account's vote power. Vote power can be delegated either\n * by calling the {delegate} function directly, or by providing a signature to be used with {delegateBySig}. Voting\n * power can be queried through the public accessors {getVotes} and {getPastVotes}.\n *\n * By default, token balance does not account for voting power. This makes transfers cheaper. The downside is that it\n * requires users to delegate to themselves in order to activate checkpoints and have their voting power tracked.\n *\n * _Available since v4.2._\n */\nabstract contract ERC20Votes is IVotes, ERC20Permit {\n    struct Checkpoint {\n        uint32 fromBlock;\n        uint224 votes;\n    }\n\n    bytes32 private constant _DELEGATION_TYPEHASH =\n        keccak256(\"Delegation(address delegatee,uint256 nonce,uint256 expiry)\");\n\n    mapping(address => address) private _delegates;\n    mapping(address => Checkpoint[]) private _checkpoints;\n    Checkpoint[] private _totalSupplyCheckpoints;\n\n    /**\n     * @dev Get the `pos`-th checkpoint for `account`.\n     */\n    function checkpoints(address account, uint32 pos) public view virtual returns (Checkpoint memory) {\n        return _checkpoints[account][pos];\n    }\n\n    /**\n     * @dev Get number of checkpoints for `account`.\n     */\n    function numCheckpoints(address account) public view virtual returns (uint32) {\n        return SafeCast.toUint32(_checkpoints[account].length);\n    }\n\n    /**\n     * @dev Get the address `account` is currently delegating to.\n     */\n    function delegates(address account) public view virtual override returns (address) {\n        return _delegates[account];\n    }\n\n    /**\n     * @dev Gets the current votes balance for `account`\n     */\n    function getVotes(address account) public view virtual override returns (uint256) {\n        uint256 pos = _checkpoints[account].length;\n        return pos == 0 ? 0 : _checkpoints[account][pos - 1].votes;\n    }\n\n    /**\n     * @dev Retrieve the number of votes for `account` at the end of `blockNumber`.\n     *\n     * Requirements:\n     *\n     * - `blockNumber` must have been already mined\n     */\n    function getPastVotes(address account, uint256 blockNumber) public view virtual override returns (uint256) {\n        require(blockNumber < block.number, \"ERC20Votes: block not yet mined\");\n        return _checkpointsLookup(_checkpoints[account], blockNumber);\n    }\n\n    /**\n     * @dev Retrieve the `totalSupply` at the end of `blockNumber`. Note, this value is the sum of all balances.\n     * It is but NOT the sum of all the delegated votes!\n     *\n     * Requirements:\n     *\n     * - `blockNumber` must have been already mined\n     */\n    function getPastTotalSupply(uint256 blockNumber) public view virtual override returns (uint256) {\n        require(blockNumber < block.number, \"ERC20Votes: block not yet mined\");\n        return _checkpointsLookup(_totalSupplyCheckpoints, blockNumber);\n    }\n\n    /**\n     * @dev Lookup a value in a list of (sorted) checkpoints.\n     */\n    function _checkpointsLookup(Checkpoint[] storage ckpts, uint256 blockNumber) private view returns (uint256) {\n        // We run a binary search to look for the earliest checkpoint taken after `blockNumber`.\n        //\n        // During the loop, the index of the wanted checkpoint remains in the range [low-1, high).\n        // With each iteration, either `low` or `high` is moved towards the middle of the range to maintain the invariant.\n        // - If the middle checkpoint is after `blockNumber`, we look in [low, mid)\n        // - If the middle checkpoint is before or equal to `blockNumber`, we look in [mid+1, high)\n        // Once we reach a single value (when low == high), we've found the right checkpoint at the index high-1, if not\n        // out of bounds (in which case we're looking too far in the past and the result is 0).\n        // Note that if the latest checkpoint available is exactly for `blockNumber`, we end up with an index that is\n        // past the end of the array, so we technically don't find a checkpoint after `blockNumber`, but it works out\n        // the same.\n        uint256 high = ckpts.length;\n        uint256 low = 0;\n        while (low < high) {\n            uint256 mid = Math.average(low, high);\n            if (ckpts[mid].fromBlock > blockNumber) {\n                high = mid;\n            } else {\n                low = mid + 1;\n            }\n        }\n\n        return high == 0 ? 0 : ckpts[high - 1].votes;\n    }\n\n    /**\n     * @dev Delegate votes from the sender to `delegatee`.\n     */\n    function delegate(address delegatee) public virtual override {\n        _delegate(_msgSender(), delegatee);\n    }\n\n    /**\n     * @dev Delegates votes from signer to `delegatee`\n     */\n    function delegateBySig(\n        address delegatee,\n        uint256 nonce,\n        uint256 expiry,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual override {\n        require(block.timestamp <= expiry, \"ERC20Votes: signature expired\");\n        address signer = ECDSA.recover(\n            _hashTypedDataV4(keccak256(abi.encode(_DELEGATION_TYPEHASH, delegatee, nonce, expiry))),\n            v,\n            r,\n            s\n        );\n        require(nonce == _useNonce(signer), \"ERC20Votes: invalid nonce\");\n        _delegate(signer, delegatee);\n    }\n\n    /**\n     * @dev Maximum token supply. Defaults to `type(uint224).max` (2^224^ - 1).\n     */\n    function _maxSupply() internal view virtual returns (uint224) {\n        return type(uint224).max;\n    }\n\n    /**\n     * @dev Snapshots the totalSupply after it has been increased.\n     */\n    function _mint(address account, uint256 amount) internal virtual override {\n        super._mint(account, amount);\n        require(totalSupply() <= _maxSupply(), \"ERC20Votes: total supply risks overflowing votes\");\n\n        _writeCheckpoint(_totalSupplyCheckpoints, _add, amount);\n    }\n\n    /**\n     * @dev Snapshots the totalSupply after it has been decreased.\n     */\n    function _burn(address account, uint256 amount) internal virtual override {\n        super._burn(account, amount);\n\n        _writeCheckpoint(_totalSupplyCheckpoints, _subtract, amount);\n    }\n\n    /**\n     * @dev Move voting power when tokens are transferred.\n     *\n     * Emits a {DelegateVotesChanged} event.\n     */\n    function _afterTokenTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal virtual override {\n        super._afterTokenTransfer(from, to, amount);\n\n        _moveVotingPower(delegates(from), delegates(to), amount);\n    }\n\n    /**\n     * @dev Change delegation for `delegator` to `delegatee`.\n     *\n     * Emits events {DelegateChanged} and {DelegateVotesChanged}.\n     */\n    function _delegate(address delegator, address delegatee) internal virtual {\n        address currentDelegate = delegates(delegator);\n        uint256 delegatorBalance = balanceOf(delegator);\n        _delegates[delegator] = delegatee;\n\n        emit DelegateChanged(delegator, currentDelegate, delegatee);\n\n        _moveVotingPower(currentDelegate, delegatee, delegatorBalance);\n    }\n\n    function _moveVotingPower(\n        address src,\n        address dst,\n        uint256 amount\n    ) private {\n        if (src != dst && amount > 0) {\n            if (src != address(0)) {\n                (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[src], _subtract, amount);\n                emit DelegateVotesChanged(src, oldWeight, newWeight);\n            }\n\n            if (dst != address(0)) {\n                (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[dst], _add, amount);\n                emit DelegateVotesChanged(dst, oldWeight, newWeight);\n            }\n        }\n    }\n\n    function _writeCheckpoint(\n        Checkpoint[] storage ckpts,\n        function(uint256, uint256) view returns (uint256) op,\n        uint256 delta\n    ) private returns (uint256 oldWeight, uint256 newWeight) {\n        uint256 pos = ckpts.length;\n        oldWeight = pos == 0 ? 0 : ckpts[pos - 1].votes;\n        newWeight = op(oldWeight, delta);\n\n        if (pos > 0 && ckpts[pos - 1].fromBlock == block.number) {\n            ckpts[pos - 1].votes = SafeCast.toUint224(newWeight);\n        } else {\n            ckpts.push(Checkpoint({fromBlock: SafeCast.toUint32(block.number), votes: SafeCast.toUint224(newWeight)}));\n        }\n    }\n\n    function _add(uint256 a, uint256 b) private pure returns (uint256) {\n        return a + b;\n    }\n\n    function _subtract(uint256 a, uint256 b) private pure returns (uint256) {\n        return a - b;\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/access/Ownable.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n        _;\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC20/IERC20.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(\n        address from,\n        address to,\n        uint256 amount\n    ) external returns (bool);\n\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"
+    },
+    "@openzeppelin/contracts/utils/Context.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-ERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./draft-IERC20Permit.sol\";\nimport \"../ERC20.sol\";\nimport \"../../../utils/cryptography/draft-EIP712.sol\";\nimport \"../../../utils/cryptography/ECDSA.sol\";\nimport \"../../../utils/Counters.sol\";\n\n/**\n * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * _Available since v3.4._\n */\nabstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {\n    using Counters for Counters.Counter;\n\n    mapping(address => Counters.Counter) private _nonces;\n\n    // solhint-disable-next-line var-name-mixedcase\n    bytes32 private immutable _PERMIT_TYPEHASH =\n        keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\");\n\n    /**\n     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `\"1\"`.\n     *\n     * It's a good idea to use the same `name` that is defined as the ERC20 token name.\n     */\n    constructor(string memory name) EIP712(name, \"1\") {}\n\n    /**\n     * @dev See {IERC20Permit-permit}.\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual override {\n        require(block.timestamp <= deadline, \"ERC20Permit: expired deadline\");\n\n        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));\n\n        bytes32 hash = _hashTypedDataV4(structHash);\n\n        address signer = ECDSA.recover(hash, v, r, s);\n        require(signer == owner, \"ERC20Permit: invalid signature\");\n\n        _approve(owner, spender, value);\n    }\n\n    /**\n     * @dev See {IERC20Permit-nonces}.\n     */\n    function nonces(address owner) public view virtual override returns (uint256) {\n        return _nonces[owner].current();\n    }\n\n    /**\n     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view override returns (bytes32) {\n        return _domainSeparatorV4();\n    }\n\n    /**\n     * @dev \"Consume a nonce\": return the current value and increment.\n     *\n     * _Available since v4.1._\n     */\n    function _useNonce(address owner) internal virtual returns (uint256 current) {\n        Counters.Counter storage nonce = _nonces[owner];\n        current = nonce.current();\n        nonce.increment();\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/utils/math/Math.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a >= b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a / b + (a % b == 0 ? 0 : 1);\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/governance/utils/IVotes.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (governance/utils/IVotes.sol)\npragma solidity ^0.8.0;\n\n/**\n * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts.\n *\n * _Available since v4.5._\n */\ninterface IVotes {\n    /**\n     * @dev Emitted when an account changes their delegate.\n     */\n    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);\n\n    /**\n     * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of votes.\n     */\n    event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);\n\n    /**\n     * @dev Returns the current amount of votes that `account` has.\n     */\n    function getVotes(address account) external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of votes that `account` had at the end of a past block (`blockNumber`).\n     */\n    function getPastVotes(address account, uint256 blockNumber) external view returns (uint256);\n\n    /**\n     * @dev Returns the total supply of votes available at the end of a past block (`blockNumber`).\n     *\n     * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes.\n     * Votes that have not been delegated are still part of total supply, even though they would not participate in a\n     * vote.\n     */\n    function getPastTotalSupply(uint256 blockNumber) external view returns (uint256);\n\n    /**\n     * @dev Returns the delegate that `account` has chosen.\n     */\n    function delegates(address account) external view returns (address);\n\n    /**\n     * @dev Delegates votes from the sender to `delegatee`.\n     */\n    function delegate(address delegatee) external;\n\n    /**\n     * @dev Delegates votes from signer to `delegatee`.\n     */\n    function delegateBySig(\n        address delegatee,\n        uint256 nonce,\n        uint256 expiry,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n}\n"
+    },
+    "@openzeppelin/contracts/utils/math/SafeCast.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/math/SafeCast.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n *\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\n * all math on `uint256` and `int256` and then downcasting.\n */\nlibrary SafeCast {\n    /**\n     * @dev Returns the downcasted uint224 from uint256, reverting on\n     * overflow (when the input is greater than largest uint224).\n     *\n     * Counterpart to Solidity's `uint224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toUint224(uint256 value) internal pure returns (uint224) {\n        require(value <= type(uint224).max, \"SafeCast: value doesn't fit in 224 bits\");\n        return uint224(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint128 from uint256, reverting on\n     * overflow (when the input is greater than largest uint128).\n     *\n     * Counterpart to Solidity's `uint128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toUint128(uint256 value) internal pure returns (uint128) {\n        require(value <= type(uint128).max, \"SafeCast: value doesn't fit in 128 bits\");\n        return uint128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint96 from uint256, reverting on\n     * overflow (when the input is greater than largest uint96).\n     *\n     * Counterpart to Solidity's `uint96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toUint96(uint256 value) internal pure returns (uint96) {\n        require(value <= type(uint96).max, \"SafeCast: value doesn't fit in 96 bits\");\n        return uint96(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint64 from uint256, reverting on\n     * overflow (when the input is greater than largest uint64).\n     *\n     * Counterpart to Solidity's `uint64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toUint64(uint256 value) internal pure returns (uint64) {\n        require(value <= type(uint64).max, \"SafeCast: value doesn't fit in 64 bits\");\n        return uint64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint32 from uint256, reverting on\n     * overflow (when the input is greater than largest uint32).\n     *\n     * Counterpart to Solidity's `uint32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toUint32(uint256 value) internal pure returns (uint32) {\n        require(value <= type(uint32).max, \"SafeCast: value doesn't fit in 32 bits\");\n        return uint32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint16 from uint256, reverting on\n     * overflow (when the input is greater than largest uint16).\n     *\n     * Counterpart to Solidity's `uint16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toUint16(uint256 value) internal pure returns (uint16) {\n        require(value <= type(uint16).max, \"SafeCast: value doesn't fit in 16 bits\");\n        return uint16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint8 from uint256, reverting on\n     * overflow (when the input is greater than largest uint8).\n     *\n     * Counterpart to Solidity's `uint8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits.\n     */\n    function toUint8(uint256 value) internal pure returns (uint8) {\n        require(value <= type(uint8).max, \"SafeCast: value doesn't fit in 8 bits\");\n        return uint8(value);\n    }\n\n    /**\n     * @dev Converts a signed int256 into an unsigned uint256.\n     *\n     * Requirements:\n     *\n     * - input must be greater than or equal to 0.\n     */\n    function toUint256(int256 value) internal pure returns (uint256) {\n        require(value >= 0, \"SafeCast: value must be positive\");\n        return uint256(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int128 from int256, reverting on\n     * overflow (when the input is less than smallest int128 or\n     * greater than largest int128).\n     *\n     * Counterpart to Solidity's `int128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt128(int256 value) internal pure returns (int128) {\n        require(value >= type(int128).min && value <= type(int128).max, \"SafeCast: value doesn't fit in 128 bits\");\n        return int128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int64 from int256, reverting on\n     * overflow (when the input is less than smallest int64 or\n     * greater than largest int64).\n     *\n     * Counterpart to Solidity's `int64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt64(int256 value) internal pure returns (int64) {\n        require(value >= type(int64).min && value <= type(int64).max, \"SafeCast: value doesn't fit in 64 bits\");\n        return int64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int32 from int256, reverting on\n     * overflow (when the input is less than smallest int32 or\n     * greater than largest int32).\n     *\n     * Counterpart to Solidity's `int32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt32(int256 value) internal pure returns (int32) {\n        require(value >= type(int32).min && value <= type(int32).max, \"SafeCast: value doesn't fit in 32 bits\");\n        return int32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int16 from int256, reverting on\n     * overflow (when the input is less than smallest int16 or\n     * greater than largest int16).\n     *\n     * Counterpart to Solidity's `int16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt16(int256 value) internal pure returns (int16) {\n        require(value >= type(int16).min && value <= type(int16).max, \"SafeCast: value doesn't fit in 16 bits\");\n        return int16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int8 from int256, reverting on\n     * overflow (when the input is less than smallest int8 or\n     * greater than largest int8).\n     *\n     * Counterpart to Solidity's `int8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits.\n     *\n     * _Available since v3.1._\n     */\n    function toInt8(int256 value) internal pure returns (int8) {\n        require(value >= type(int8).min && value <= type(int8).max, \"SafeCast: value doesn't fit in 8 bits\");\n        return int8(value);\n    }\n\n    /**\n     * @dev Converts an unsigned uint256 into a signed int256.\n     *\n     * Requirements:\n     *\n     * - input must be less than or equal to maxInt256.\n     */\n    function toInt256(uint256 value) internal pure returns (int256) {\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\n        require(value <= uint256(type(int256).max), \"SafeCast: value doesn't fit in an int256\");\n        return int256(value);\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/utils/cryptography/ECDSA.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/ECDSA.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../Strings.sol\";\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n    enum RecoverError {\n        NoError,\n        InvalidSignature,\n        InvalidSignatureLength,\n        InvalidSignatureS,\n        InvalidSignatureV\n    }\n\n    function _throwError(RecoverError error) private pure {\n        if (error == RecoverError.NoError) {\n            return; // no error: do nothing\n        } else if (error == RecoverError.InvalidSignature) {\n            revert(\"ECDSA: invalid signature\");\n        } else if (error == RecoverError.InvalidSignatureLength) {\n            revert(\"ECDSA: invalid signature length\");\n        } else if (error == RecoverError.InvalidSignatureS) {\n            revert(\"ECDSA: invalid signature 's' value\");\n        } else if (error == RecoverError.InvalidSignatureV) {\n            revert(\"ECDSA: invalid signature 'v' value\");\n        }\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature` or error string. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {toEthSignedMessageHash} on it.\n     *\n     * Documentation for signature generation:\n     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n     *\n     * _Available since v4.3._\n     */\n    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {\n        // Check the signature length\n        // - case 65: r,s,v signature (standard)\n        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._\n        if (signature.length == 65) {\n            bytes32 r;\n            bytes32 s;\n            uint8 v;\n            // ecrecover takes the signature parameters, and the only way to get them\n            // currently is to use assembly.\n            assembly {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            return tryRecover(hash, v, r, s);\n        } else if (signature.length == 64) {\n            bytes32 r;\n            bytes32 vs;\n            // ecrecover takes the signature parameters, and the only way to get them\n            // currently is to use assembly.\n            assembly {\n                r := mload(add(signature, 0x20))\n                vs := mload(add(signature, 0x40))\n            }\n            return tryRecover(hash, r, vs);\n        } else {\n            return (address(0), RecoverError.InvalidSignatureLength);\n        }\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature`. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {toEthSignedMessageHash} on it.\n     */\n    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n        (address recovered, RecoverError error) = tryRecover(hash, signature);\n        _throwError(error);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\n     *\n     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\n     *\n     * _Available since v4.3._\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes32 r,\n        bytes32 vs\n    ) internal pure returns (address, RecoverError) {\n        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\n        uint8 v = uint8((uint256(vs) >> 255) + 27);\n        return tryRecover(hash, v, r, s);\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\n     *\n     * _Available since v4.2._\n     */\n    function recover(\n        bytes32 hash,\n        bytes32 r,\n        bytes32 vs\n    ) internal pure returns (address) {\n        (address recovered, RecoverError error) = tryRecover(hash, r, vs);\n        _throwError(error);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     *\n     * _Available since v4.3._\n     */\n    function tryRecover(\n        bytes32 hash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address, RecoverError) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n            return (address(0), RecoverError.InvalidSignatureS);\n        }\n        if (v != 27 && v != 28) {\n            return (address(0), RecoverError.InvalidSignatureV);\n        }\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(hash, v, r, s);\n        if (signer == address(0)) {\n            return (address(0), RecoverError.InvalidSignature);\n        }\n\n        return (signer, RecoverError.NoError);\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function recover(\n        bytes32 hash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address) {\n        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\n        _throwError(error);\n        return recovered;\n    }\n\n    /**\n     * @dev Returns an Ethereum Signed Message, created from a `hash`. This\n     * produces hash corresponding to the one signed with the\n     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\n     * JSON-RPC method as part of EIP-191.\n     *\n     * See {recover}.\n     */\n    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\n        // 32 is the length in bytes of hash,\n        // enforced by the type signature above\n        return keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n32\", hash));\n    }\n\n    /**\n     * @dev Returns an Ethereum Signed Message, created from `s`. This\n     * produces hash corresponding to the one signed with the\n     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\n     * JSON-RPC method as part of EIP-191.\n     *\n     * See {recover}.\n     */\n    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {\n        return keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n\", Strings.toString(s.length), s));\n    }\n\n    /**\n     * @dev Returns an Ethereum Signed Typed Data, created from a\n     * `domainSeparator` and a `structHash`. This produces hash corresponding\n     * to the one signed with the\n     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\n     * JSON-RPC method as part of EIP-712.\n     *\n     * See {recover}.\n     */\n    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\n        return keccak256(abi.encodePacked(\"\\x19\\x01\", domainSeparator, structHash));\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\ninterface IERC20Permit {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n     * given ``owner``'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"
+    },
+    "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/cryptography/draft-EIP712.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./ECDSA.sol\";\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.\n *\n * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,\n * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding\n * they need in their contracts using a combination of `abi.encode` and `keccak256`.\n *\n * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding\n * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA\n * ({_hashTypedDataV4}).\n *\n * The implementation of the domain separator was designed to be as efficient as possible while still properly updating\n * the chain id to protect against replay attacks on an eventual fork of the chain.\n *\n * NOTE: This contract implements the version of the encoding known as \"v4\", as implemented by the JSON RPC method\n * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].\n *\n * _Available since v3.4._\n */\nabstract contract EIP712 {\n    /* solhint-disable var-name-mixedcase */\n    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to\n    // invalidate the cached domain separator if the chain id changes.\n    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;\n    uint256 private immutable _CACHED_CHAIN_ID;\n    address private immutable _CACHED_THIS;\n\n    bytes32 private immutable _HASHED_NAME;\n    bytes32 private immutable _HASHED_VERSION;\n    bytes32 private immutable _TYPE_HASH;\n\n    /* solhint-enable var-name-mixedcase */\n\n    /**\n     * @dev Initializes the domain separator and parameter caches.\n     *\n     * The meaning of `name` and `version` is specified in\n     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:\n     *\n     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.\n     * - `version`: the current major version of the signing domain.\n     *\n     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart\n     * contract upgrade].\n     */\n    constructor(string memory name, string memory version) {\n        bytes32 hashedName = keccak256(bytes(name));\n        bytes32 hashedVersion = keccak256(bytes(version));\n        bytes32 typeHash = keccak256(\n            \"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"\n        );\n        _HASHED_NAME = hashedName;\n        _HASHED_VERSION = hashedVersion;\n        _CACHED_CHAIN_ID = block.chainid;\n        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);\n        _CACHED_THIS = address(this);\n        _TYPE_HASH = typeHash;\n    }\n\n    /**\n     * @dev Returns the domain separator for the current chain.\n     */\n    function _domainSeparatorV4() internal view returns (bytes32) {\n        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {\n            return _CACHED_DOMAIN_SEPARATOR;\n        } else {\n            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);\n        }\n    }\n\n    function _buildDomainSeparator(\n        bytes32 typeHash,\n        bytes32 nameHash,\n        bytes32 versionHash\n    ) private view returns (bytes32) {\n        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));\n    }\n\n    /**\n     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this\n     * function returns the hash of the fully encoded EIP712 message for this domain.\n     *\n     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:\n     *\n     * ```solidity\n     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(\n     *     keccak256(\"Mail(address to,string contents)\"),\n     *     mailTo,\n     *     keccak256(bytes(mailContents))\n     * )));\n     * address signer = ECDSA.recover(digest, signature);\n     * ```\n     */\n    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\n        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/utils/Counters.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @title Counters\n * @author Matt Condon (@shrugs)\n * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\n *\n * Include with `using Counters for Counters.Counter;`\n */\nlibrary Counters {\n    struct Counter {\n        // This variable should never be directly accessed by users of the library: interactions must be restricted to\n        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\n        // this feature: see https://github.com/ethereum/solidity/issues/4637\n        uint256 _value; // default: 0\n    }\n\n    function current(Counter storage counter) internal view returns (uint256) {\n        return counter._value;\n    }\n\n    function increment(Counter storage counter) internal {\n        unchecked {\n            counter._value += 1;\n        }\n    }\n\n    function decrement(Counter storage counter) internal {\n        uint256 value = counter._value;\n        require(value > 0, \"Counter: decrement overflow\");\n        unchecked {\n            counter._value = value - 1;\n        }\n    }\n\n    function reset(Counter storage counter) internal {\n        counter._value = 0;\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/utils/Strings.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    bytes16 private constant _HEX_SYMBOLS = \"0123456789abcdef\";\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        // Inspired by OraclizeAPI's implementation - MIT licence\n        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\n\n        if (value == 0) {\n            return \"0\";\n        }\n        uint256 temp = value;\n        uint256 digits;\n        while (temp != 0) {\n            digits++;\n            temp /= 10;\n        }\n        bytes memory buffer = new bytes(digits);\n        while (value != 0) {\n            digits -= 1;\n            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\n            value /= 10;\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        if (value == 0) {\n            return \"0x00\";\n        }\n        uint256 temp = value;\n        uint256 length = 0;\n        while (temp != 0) {\n            length++;\n            temp >>= 8;\n        }\n        return toHexString(value, length);\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = _HEX_SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n}\n"
+    },
+    "contracts/MintManager.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.12;\n\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"./GovernanceToken.sol\";\n\n/**\n * @title  MintManager\n * @notice Set as `owner` of the OP token and responsible for the token inflation schedule.\n *         Contract acts as the token \"mint manager\" with permission to the `mint` function only.\n *         Currently permitted to mint once per year of up to 2% of the total token supply.\n *         Upgradable to allow changes in the inflation schedule.\n */\ncontract MintManager is Ownable {\n    /**\n     * @notice The GovernanceToken that the MintManager can mint tokens\n     */\n    GovernanceToken public immutable governanceToken;\n\n    /**\n     * @notice The amount of tokens that can be minted per year. The value is a fixed\n     *          point number with 4 decimals.\n     */\n    uint256 public constant MINT_CAP = 20; // 2%\n\n    /**\n     * @notice The number of decimals for the MINT_CAP.\n     */\n    uint256 public constant DENOMINATOR = 1000;\n\n    /**\n     * @notice The amount of time that must pass before the MINT_CAP number of tokens can\n     *         be minted again.\n     */\n    uint256 public constant MINT_PERIOD = 365 days;\n\n    /**\n     * @notice Tracks the time of last mint\n     */\n    uint256 public mintPermittedAfter;\n\n    /**\n     * @param _upgrader        The owner of this contract\n     * @param _governanceToken The governance token this contract can mint\n     *                         tokens of\n     */\n    constructor(address _upgrader, address _governanceToken) {\n        transferOwnership(_upgrader);\n        governanceToken = GovernanceToken(_governanceToken);\n    }\n\n    /**\n     * @notice Only the token owner is allowed to mint a certain amount of OP per year.\n     *\n     * @param _account Address to mint new tokens to.\n     * @param _amount  Amount of tokens to be minted.\n     */\n    function mint(address _account, uint256 _amount) public onlyOwner {\n        if (mintPermittedAfter > 0) {\n            require(mintPermittedAfter <= block.timestamp, \"OP: minting not permitted yet\");\n\n            require(\n                _amount <= (governanceToken.totalSupply() * MINT_CAP) / DENOMINATOR,\n                \"OP: mint amount exceeds cap\"\n            );\n        }\n\n        mintPermittedAfter = block.timestamp + MINT_PERIOD;\n\n        governanceToken.mint(_account, _amount);\n    }\n\n    /**\n     * @notice Upgrade the owner of the governance token to a new MintManager.\n     *\n     * @param _newMintManager The MintManager to upgrade to\n     */\n    function upgrade(address _newMintManager) public onlyOwner {\n        require(_newMintManager != address(0), \"OP: Mint manager cannot be empty\");\n\n        governanceToken.transferOwnership(_newMintManager);\n    }\n}\n"
+    },
+    "contracts/test/TestERC20.sol": {
+      "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity =0.8.12;\n\nimport \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\ncontract TestERC20 is ERC20 {\n    constructor(\n        string memory name_,\n        string memory symbol_,\n        uint256 amountToMint\n    ) ERC20(name_, symbol_) {\n        setBalance(msg.sender, amountToMint);\n    }\n\n    // sets the balance of the address\n    // this mints/burns the amount depending on the current balance\n    function setBalance(address to, uint256 amount) public {\n        uint256 old = balanceOf(to);\n        if (old < amount) {\n            _mint(to, amount - old);\n        } else if (old > amount) {\n            _burn(to, old - amount);\n        }\n    }\n}\n"
+    },
+    "contracts/MerkleDistributor.sol": {
+      "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity =0.8.12;\n\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\";\nimport \"./interfaces/IMerkleDistributor.sol\";\n\ncontract MerkleDistributor is IMerkleDistributor {\n    address public immutable override token;\n    bytes32 public immutable override merkleRoot;\n\n    uint256 public constant ONE_YEAR_IN_SECONDS = 31_536_000;\n    uint256 public immutable activationTimestamp;\n    address public immutable airdropTreasury;\n    bool public isActive;\n\n    // This is a packed array of booleans.\n    mapping(uint256 => uint256) private claimedBitMap;\n\n    event Finalised(address indexed calledBy, uint256 timestamp, uint256 unclaimedAmount);\n\n    constructor(\n        address token_,\n        bytes32 merkleRoot_,\n        address _treasury\n    ) {\n        token = token_;\n        merkleRoot = merkleRoot_;\n\n        activationTimestamp = block.timestamp;\n        isActive = true;\n        airdropTreasury = _treasury;\n    }\n\n    function isClaimed(uint256 index) public view override returns (bool) {\n        uint256 claimedWordIndex = index / 256;\n        uint256 claimedBitIndex = index % 256;\n        uint256 claimedWord = claimedBitMap[claimedWordIndex];\n        uint256 mask = (1 << claimedBitIndex);\n        return claimedWord & mask == mask;\n    }\n\n    function _setClaimed(uint256 index) private {\n        uint256 claimedWordIndex = index / 256;\n        uint256 claimedBitIndex = index % 256;\n        claimedBitMap[claimedWordIndex] = claimedBitMap[claimedWordIndex] | (1 << claimedBitIndex);\n    }\n\n    function claim(\n        uint256 index,\n        address account,\n        uint256 amount,\n        bytes32[] calldata merkleProof\n    ) external override {\n        require(!isClaimed(index), \"MerkleDistributor: Drop already claimed.\");\n\n        // Verify the merkle proof.\n        bytes32 node = keccak256(abi.encodePacked(index, account, amount));\n        require(\n            MerkleProof.verify(merkleProof, merkleRoot, node),\n            \"MerkleDistributor: Invalid proof.\"\n        );\n\n        // Mark it claimed and send the token.\n        _setClaimed(index);\n        require(IERC20(token).transfer(account, amount), \"MerkleDistributor: Transfer failed.\");\n\n        emit Claimed(index, account, amount);\n    }\n\n    /**\n     * @dev Finalises the airdrop and sweeps unclaimed tokens into the Optimism multisig\n     */\n    function clawBack() external {\n        // Airdrop can only be finalised once\n        require(isActive, \"Airdrop: Already finalised\");\n        // Airdrop will remain open for one year\n        require(\n            block.timestamp >= activationTimestamp + ONE_YEAR_IN_SECONDS,\n            \"Airdrop: Drop should remain open for one year\"\n        );\n        // Deactivate airdrop\n        isActive = false;\n\n        // Sweep unclaimed tokens\n        uint256 amount = IERC20(token).balanceOf(address(this));\n        require(\n            IERC20(token).transfer(airdropTreasury, amount),\n            \"Airdrop: Finalise transfer failed\"\n        );\n\n        emit Finalised(msg.sender, block.timestamp, amount);\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/MerkleProof.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev These functions deal with verification of Merkle Trees proofs.\n *\n * The proofs can be generated using the JavaScript library\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\n *\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\n */\nlibrary MerkleProof {\n    /**\n     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\n     * defined by `root`. For this, a `proof` must be provided, containing\n     * sibling hashes on the branch from the leaf to the root of the tree. Each\n     * pair of leaves and each pair of pre-images are assumed to be sorted.\n     */\n    function verify(\n        bytes32[] memory proof,\n        bytes32 root,\n        bytes32 leaf\n    ) internal pure returns (bool) {\n        return processProof(proof, leaf) == root;\n    }\n\n    /**\n     * @dev Returns the rebuilt hash obtained by traversing a Merklee tree up\n     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\n     * hash matches the root of the tree. When processing the proof, the pairs\n     * of leafs & pre-images are assumed to be sorted.\n     *\n     * _Available since v4.4._\n     */\n    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {\n        bytes32 computedHash = leaf;\n        for (uint256 i = 0; i < proof.length; i++) {\n            bytes32 proofElement = proof[i];\n            if (computedHash <= proofElement) {\n                // Hash(current computed hash + current element of the proof)\n                computedHash = _efficientHash(computedHash, proofElement);\n            } else {\n                // Hash(current element of the proof + current computed hash)\n                computedHash = _efficientHash(proofElement, computedHash);\n            }\n        }\n        return computedHash;\n    }\n\n    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {\n        assembly {\n            mstore(0x00, a)\n            mstore(0x20, b)\n            value := keccak256(0x00, 0x40)\n        }\n    }\n}\n"
+    },
+    "contracts/interfaces/IMerkleDistributor.sol": {
+      "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.12;\n\n// Allows anyone to claim a token if they exist in a merkle root.\ninterface IMerkleDistributor {\n    // Returns the address of the token distributed by this contract.\n    function token() external view returns (address);\n\n    // Returns the merkle root of the merkle tree containing account balances available to claim.\n    function merkleRoot() external view returns (bytes32);\n\n    // Returns true if the index has been marked claimed.\n    function isClaimed(uint256 index) external view returns (bool);\n\n    // Claim the given amount of the token to the given address. Reverts if the inputs are invalid.\n    function claim(\n        uint256 index,\n        address account,\n        uint256 amount,\n        bytes32[] calldata merkleProof\n    ) external;\n\n    // This event is triggered whenever a call to #claim succeeds.\n    event Claimed(uint256 index, address account, uint256 amount);\n}\n"
+    }
+  },
+  "settings": {
+    "outputSelection": {
+      "*": {
+        "*": [
+          "metadata",
+          "storageLayout",
+          "abi",
+          "evm.bytecode",
+          "evm.deployedBytecode",
+          "evm.methodIdentifiers",
+          "devdoc",
+          "userdoc",
+          "evm.gasEstimates"
+        ],
+        "": [
+          "ast"
+        ]
+      }
+    },
+    "optimizer": {
+      "enabled": false,
+      "runs": 200
+    },
+    "metadata": {
+      "useLiteralContent": true
+    }
+  }
+}
\ No newline at end of file

packages/contracts-governance/deployments/optimism-mainnet/.chainId

+10
\ No newline at end of file

packages/contracts-governance/deployments/optimism-mainnet/solcInputs/b1df373a9ed51b3903b61f56faa9a78f.json

+{
+  "language": "Solidity",
+  "sources": {
+    "contracts/GovernanceToken.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.12;\n\nimport \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol\";\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\n\n/**\n * @dev The Optimism token used in governance and supporting voting and delegation.\n * Implements EIP 2612 allowing signed approvals.\n * Contract is \"owned\" by a `MintManager` instance with permission to the `mint` function only,\n * for the purposes of enforcing the token inflation schedule.\n */\ncontract GovernanceToken is ERC20Burnable, ERC20Votes, Ownable {\n    /**\n     * @dev Constructor.\n     */\n    constructor() ERC20(\"Optimism\", \"OP\") ERC20Permit(\"Optimism\") {}\n\n    function mint(address _account, uint256 _amount) public onlyOwner {\n        _mint(_account, _amount);\n    }\n\n    // The following functions are overrides required by Solidity.\n    function _afterTokenTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal override(ERC20, ERC20Votes) {\n        super._afterTokenTransfer(from, to, amount);\n    }\n\n    function _mint(address to, uint256 amount) internal override(ERC20, ERC20Votes) {\n        super._mint(to, amount);\n    }\n\n    function _burn(address account, uint256 amount) internal override(ERC20, ERC20Votes) {\n        super._burn(account, amount);\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC20/ERC20.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20.sol\";\nimport \"./extensions/IERC20Metadata.sol\";\nimport \"../../utils/Context.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n    mapping(address => uint256) private _balances;\n\n    mapping(address => mapping(address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * The default value of {decimals} is 18. To select a different value for\n     * {decimals} you should overload it.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual override returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual override returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the value {ERC20} uses, unless this function is\n     * overridden;\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual override returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(address to, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(\n        address from,\n        address to,\n        uint256 amount\n    ) public virtual override returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, amount);\n        _transfer(from, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, _allowances[owner][spender] + addedValue);\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        uint256 currentAllowance = _allowances[owner][spender];\n        require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n        unchecked {\n            _approve(owner, spender, currentAllowance - subtractedValue);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Moves `amount` of tokens from `sender` to `recipient`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     */\n    function _transfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal virtual {\n        require(from != address(0), \"ERC20: transfer from the zero address\");\n        require(to != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(from, to, amount);\n\n        uint256 fromBalance = _balances[from];\n        require(fromBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n        unchecked {\n            _balances[from] = fromBalance - amount;\n        }\n        _balances[to] += amount;\n\n        emit Transfer(from, to, amount);\n\n        _afterTokenTransfer(from, to, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        _balances[account] += amount;\n        emit Transfer(address(0), account, amount);\n\n        _afterTokenTransfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        uint256 accountBalance = _balances[account];\n        require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n        unchecked {\n            _balances[account] = accountBalance - amount;\n        }\n        _totalSupply -= amount;\n\n        emit Transfer(account, address(0), amount);\n\n        _afterTokenTransfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(\n        address owner,\n        address spender,\n        uint256 amount\n    ) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Spend `amount` form the allowance of `owner` toward `spender`.\n     *\n     * Does not update the allowance amount in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Might emit an {Approval} event.\n     */\n    function _spendAllowance(\n        address owner,\n        address spender,\n        uint256 amount\n    ) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance != type(uint256).max) {\n            require(currentAllowance >= amount, \"ERC20: insufficient allowance\");\n            unchecked {\n                _approve(owner, spender, currentAllowance - amount);\n            }\n        }\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * has been transferred to `to`.\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal virtual {}\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../ERC20.sol\";\nimport \"../../../utils/Context.sol\";\n\n/**\n * @dev Extension of {ERC20} that allows token holders to destroy both their own\n * tokens and those that they have an allowance for, in a way that can be\n * recognized off-chain (via event analysis).\n */\nabstract contract ERC20Burnable is Context, ERC20 {\n    /**\n     * @dev Destroys `amount` tokens from the caller.\n     *\n     * See {ERC20-_burn}.\n     */\n    function burn(uint256 amount) public virtual {\n        _burn(_msgSender(), amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, deducting from the caller's\n     * allowance.\n     *\n     * See {ERC20-_burn} and {ERC20-allowance}.\n     *\n     * Requirements:\n     *\n     * - the caller must have allowance for ``accounts``'s tokens of at least\n     * `amount`.\n     */\n    function burnFrom(address account, uint256 amount) public virtual {\n        _spendAllowance(account, _msgSender(), amount);\n        _burn(account, amount);\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Votes.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./draft-ERC20Permit.sol\";\nimport \"../../../utils/math/Math.sol\";\nimport \"../../../governance/utils/IVotes.sol\";\nimport \"../../../utils/math/SafeCast.sol\";\nimport \"../../../utils/cryptography/ECDSA.sol\";\n\n/**\n * @dev Extension of ERC20 to support Compound-like voting and delegation. This version is more generic than Compound's,\n * and supports token supply up to 2^224^ - 1, while COMP is limited to 2^96^ - 1.\n *\n * NOTE: If exact COMP compatibility is required, use the {ERC20VotesComp} variant of this module.\n *\n * This extension keeps a history (checkpoints) of each account's vote power. Vote power can be delegated either\n * by calling the {delegate} function directly, or by providing a signature to be used with {delegateBySig}. Voting\n * power can be queried through the public accessors {getVotes} and {getPastVotes}.\n *\n * By default, token balance does not account for voting power. This makes transfers cheaper. The downside is that it\n * requires users to delegate to themselves in order to activate checkpoints and have their voting power tracked.\n *\n * _Available since v4.2._\n */\nabstract contract ERC20Votes is IVotes, ERC20Permit {\n    struct Checkpoint {\n        uint32 fromBlock;\n        uint224 votes;\n    }\n\n    bytes32 private constant _DELEGATION_TYPEHASH =\n        keccak256(\"Delegation(address delegatee,uint256 nonce,uint256 expiry)\");\n\n    mapping(address => address) private _delegates;\n    mapping(address => Checkpoint[]) private _checkpoints;\n    Checkpoint[] private _totalSupplyCheckpoints;\n\n    /**\n     * @dev Get the `pos`-th checkpoint for `account`.\n     */\n    function checkpoints(address account, uint32 pos) public view virtual returns (Checkpoint memory) {\n        return _checkpoints[account][pos];\n    }\n\n    /**\n     * @dev Get number of checkpoints for `account`.\n     */\n    function numCheckpoints(address account) public view virtual returns (uint32) {\n        return SafeCast.toUint32(_checkpoints[account].length);\n    }\n\n    /**\n     * @dev Get the address `account` is currently delegating to.\n     */\n    function delegates(address account) public view virtual override returns (address) {\n        return _delegates[account];\n    }\n\n    /**\n     * @dev Gets the current votes balance for `account`\n     */\n    function getVotes(address account) public view virtual override returns (uint256) {\n        uint256 pos = _checkpoints[account].length;\n        return pos == 0 ? 0 : _checkpoints[account][pos - 1].votes;\n    }\n\n    /**\n     * @dev Retrieve the number of votes for `account` at the end of `blockNumber`.\n     *\n     * Requirements:\n     *\n     * - `blockNumber` must have been already mined\n     */\n    function getPastVotes(address account, uint256 blockNumber) public view virtual override returns (uint256) {\n        require(blockNumber < block.number, \"ERC20Votes: block not yet mined\");\n        return _checkpointsLookup(_checkpoints[account], blockNumber);\n    }\n\n    /**\n     * @dev Retrieve the `totalSupply` at the end of `blockNumber`. Note, this value is the sum of all balances.\n     * It is but NOT the sum of all the delegated votes!\n     *\n     * Requirements:\n     *\n     * - `blockNumber` must have been already mined\n     */\n    function getPastTotalSupply(uint256 blockNumber) public view virtual override returns (uint256) {\n        require(blockNumber < block.number, \"ERC20Votes: block not yet mined\");\n        return _checkpointsLookup(_totalSupplyCheckpoints, blockNumber);\n    }\n\n    /**\n     * @dev Lookup a value in a list of (sorted) checkpoints.\n     */\n    function _checkpointsLookup(Checkpoint[] storage ckpts, uint256 blockNumber) private view returns (uint256) {\n        // We run a binary search to look for the earliest checkpoint taken after `blockNumber`.\n        //\n        // During the loop, the index of the wanted checkpoint remains in the range [low-1, high).\n        // With each iteration, either `low` or `high` is moved towards the middle of the range to maintain the invariant.\n        // - If the middle checkpoint is after `blockNumber`, we look in [low, mid)\n        // - If the middle checkpoint is before or equal to `blockNumber`, we look in [mid+1, high)\n        // Once we reach a single value (when low == high), we've found the right checkpoint at the index high-1, if not\n        // out of bounds (in which case we're looking too far in the past and the result is 0).\n        // Note that if the latest checkpoint available is exactly for `blockNumber`, we end up with an index that is\n        // past the end of the array, so we technically don't find a checkpoint after `blockNumber`, but it works out\n        // the same.\n        uint256 high = ckpts.length;\n        uint256 low = 0;\n        while (low < high) {\n            uint256 mid = Math.average(low, high);\n            if (ckpts[mid].fromBlock > blockNumber) {\n                high = mid;\n            } else {\n                low = mid + 1;\n            }\n        }\n\n        return high == 0 ? 0 : ckpts[high - 1].votes;\n    }\n\n    /**\n     * @dev Delegate votes from the sender to `delegatee`.\n     */\n    function delegate(address delegatee) public virtual override {\n        _delegate(_msgSender(), delegatee);\n    }\n\n    /**\n     * @dev Delegates votes from signer to `delegatee`\n     */\n    function delegateBySig(\n        address delegatee,\n        uint256 nonce,\n        uint256 expiry,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual override {\n        require(block.timestamp <= expiry, \"ERC20Votes: signature expired\");\n        address signer = ECDSA.recover(\n            _hashTypedDataV4(keccak256(abi.encode(_DELEGATION_TYPEHASH, delegatee, nonce, expiry))),\n            v,\n            r,\n            s\n        );\n        require(nonce == _useNonce(signer), \"ERC20Votes: invalid nonce\");\n        _delegate(signer, delegatee);\n    }\n\n    /**\n     * @dev Maximum token supply. Defaults to `type(uint224).max` (2^224^ - 1).\n     */\n    function _maxSupply() internal view virtual returns (uint224) {\n        return type(uint224).max;\n    }\n\n    /**\n     * @dev Snapshots the totalSupply after it has been increased.\n     */\n    function _mint(address account, uint256 amount) internal virtual override {\n        super._mint(account, amount);\n        require(totalSupply() <= _maxSupply(), \"ERC20Votes: total supply risks overflowing votes\");\n\n        _writeCheckpoint(_totalSupplyCheckpoints, _add, amount);\n    }\n\n    /**\n     * @dev Snapshots the totalSupply after it has been decreased.\n     */\n    function _burn(address account, uint256 amount) internal virtual override {\n        super._burn(account, amount);\n\n        _writeCheckpoint(_totalSupplyCheckpoints, _subtract, amount);\n    }\n\n    /**\n     * @dev Move voting power when tokens are transferred.\n     *\n     * Emits a {DelegateVotesChanged} event.\n     */\n    function _afterTokenTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal virtual override {\n        super._afterTokenTransfer(from, to, amount);\n\n        _moveVotingPower(delegates(from), delegates(to), amount);\n    }\n\n    /**\n     * @dev Change delegation for `delegator` to `delegatee`.\n     *\n     * Emits events {DelegateChanged} and {DelegateVotesChanged}.\n     */\n    function _delegate(address delegator, address delegatee) internal virtual {\n        address currentDelegate = delegates(delegator);\n        uint256 delegatorBalance = balanceOf(delegator);\n        _delegates[delegator] = delegatee;\n\n        emit DelegateChanged(delegator, currentDelegate, delegatee);\n\n        _moveVotingPower(currentDelegate, delegatee, delegatorBalance);\n    }\n\n    function _moveVotingPower(\n        address src,\n        address dst,\n        uint256 amount\n    ) private {\n        if (src != dst && amount > 0) {\n            if (src != address(0)) {\n                (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[src], _subtract, amount);\n                emit DelegateVotesChanged(src, oldWeight, newWeight);\n            }\n\n            if (dst != address(0)) {\n                (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[dst], _add, amount);\n                emit DelegateVotesChanged(dst, oldWeight, newWeight);\n            }\n        }\n    }\n\n    function _writeCheckpoint(\n        Checkpoint[] storage ckpts,\n        function(uint256, uint256) view returns (uint256) op,\n        uint256 delta\n    ) private returns (uint256 oldWeight, uint256 newWeight) {\n        uint256 pos = ckpts.length;\n        oldWeight = pos == 0 ? 0 : ckpts[pos - 1].votes;\n        newWeight = op(oldWeight, delta);\n\n        if (pos > 0 && ckpts[pos - 1].fromBlock == block.number) {\n            ckpts[pos - 1].votes = SafeCast.toUint224(newWeight);\n        } else {\n            ckpts.push(Checkpoint({fromBlock: SafeCast.toUint32(block.number), votes: SafeCast.toUint224(newWeight)}));\n        }\n    }\n\n    function _add(uint256 a, uint256 b) private pure returns (uint256) {\n        return a + b;\n    }\n\n    function _subtract(uint256 a, uint256 b) private pure returns (uint256) {\n        return a - b;\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/access/Ownable.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n        _;\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC20/IERC20.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(\n        address from,\n        address to,\n        uint256 amount\n    ) external returns (bool);\n\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"
+    },
+    "@openzeppelin/contracts/utils/Context.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-ERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./draft-IERC20Permit.sol\";\nimport \"../ERC20.sol\";\nimport \"../../../utils/cryptography/draft-EIP712.sol\";\nimport \"../../../utils/cryptography/ECDSA.sol\";\nimport \"../../../utils/Counters.sol\";\n\n/**\n * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * _Available since v3.4._\n */\nabstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {\n    using Counters for Counters.Counter;\n\n    mapping(address => Counters.Counter) private _nonces;\n\n    // solhint-disable-next-line var-name-mixedcase\n    bytes32 private immutable _PERMIT_TYPEHASH =\n        keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\");\n\n    /**\n     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `\"1\"`.\n     *\n     * It's a good idea to use the same `name` that is defined as the ERC20 token name.\n     */\n    constructor(string memory name) EIP712(name, \"1\") {}\n\n    /**\n     * @dev See {IERC20Permit-permit}.\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual override {\n        require(block.timestamp <= deadline, \"ERC20Permit: expired deadline\");\n\n        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));\n\n        bytes32 hash = _hashTypedDataV4(structHash);\n\n        address signer = ECDSA.recover(hash, v, r, s);\n        require(signer == owner, \"ERC20Permit: invalid signature\");\n\n        _approve(owner, spender, value);\n    }\n\n    /**\n     * @dev See {IERC20Permit-nonces}.\n     */\n    function nonces(address owner) public view virtual override returns (uint256) {\n        return _nonces[owner].current();\n    }\n\n    /**\n     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view override returns (bytes32) {\n        return _domainSeparatorV4();\n    }\n\n    /**\n     * @dev \"Consume a nonce\": return the current value and increment.\n     *\n     * _Available since v4.1._\n     */\n    function _useNonce(address owner) internal virtual returns (uint256 current) {\n        Counters.Counter storage nonce = _nonces[owner];\n        current = nonce.current();\n        nonce.increment();\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/utils/math/Math.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a >= b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a / b + (a % b == 0 ? 0 : 1);\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/governance/utils/IVotes.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (governance/utils/IVotes.sol)\npragma solidity ^0.8.0;\n\n/**\n * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts.\n *\n * _Available since v4.5._\n */\ninterface IVotes {\n    /**\n     * @dev Emitted when an account changes their delegate.\n     */\n    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);\n\n    /**\n     * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of votes.\n     */\n    event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);\n\n    /**\n     * @dev Returns the current amount of votes that `account` has.\n     */\n    function getVotes(address account) external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of votes that `account` had at the end of a past block (`blockNumber`).\n     */\n    function getPastVotes(address account, uint256 blockNumber) external view returns (uint256);\n\n    /**\n     * @dev Returns the total supply of votes available at the end of a past block (`blockNumber`).\n     *\n     * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes.\n     * Votes that have not been delegated are still part of total supply, even though they would not participate in a\n     * vote.\n     */\n    function getPastTotalSupply(uint256 blockNumber) external view returns (uint256);\n\n    /**\n     * @dev Returns the delegate that `account` has chosen.\n     */\n    function delegates(address account) external view returns (address);\n\n    /**\n     * @dev Delegates votes from the sender to `delegatee`.\n     */\n    function delegate(address delegatee) external;\n\n    /**\n     * @dev Delegates votes from signer to `delegatee`.\n     */\n    function delegateBySig(\n        address delegatee,\n        uint256 nonce,\n        uint256 expiry,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n}\n"
+    },
+    "@openzeppelin/contracts/utils/math/SafeCast.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/math/SafeCast.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n *\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\n * all math on `uint256` and `int256` and then downcasting.\n */\nlibrary SafeCast {\n    /**\n     * @dev Returns the downcasted uint224 from uint256, reverting on\n     * overflow (when the input is greater than largest uint224).\n     *\n     * Counterpart to Solidity's `uint224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toUint224(uint256 value) internal pure returns (uint224) {\n        require(value <= type(uint224).max, \"SafeCast: value doesn't fit in 224 bits\");\n        return uint224(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint128 from uint256, reverting on\n     * overflow (when the input is greater than largest uint128).\n     *\n     * Counterpart to Solidity's `uint128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toUint128(uint256 value) internal pure returns (uint128) {\n        require(value <= type(uint128).max, \"SafeCast: value doesn't fit in 128 bits\");\n        return uint128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint96 from uint256, reverting on\n     * overflow (when the input is greater than largest uint96).\n     *\n     * Counterpart to Solidity's `uint96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toUint96(uint256 value) internal pure returns (uint96) {\n        require(value <= type(uint96).max, \"SafeCast: value doesn't fit in 96 bits\");\n        return uint96(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint64 from uint256, reverting on\n     * overflow (when the input is greater than largest uint64).\n     *\n     * Counterpart to Solidity's `uint64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toUint64(uint256 value) internal pure returns (uint64) {\n        require(value <= type(uint64).max, \"SafeCast: value doesn't fit in 64 bits\");\n        return uint64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint32 from uint256, reverting on\n     * overflow (when the input is greater than largest uint32).\n     *\n     * Counterpart to Solidity's `uint32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toUint32(uint256 value) internal pure returns (uint32) {\n        require(value <= type(uint32).max, \"SafeCast: value doesn't fit in 32 bits\");\n        return uint32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint16 from uint256, reverting on\n     * overflow (when the input is greater than largest uint16).\n     *\n     * Counterpart to Solidity's `uint16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toUint16(uint256 value) internal pure returns (uint16) {\n        require(value <= type(uint16).max, \"SafeCast: value doesn't fit in 16 bits\");\n        return uint16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint8 from uint256, reverting on\n     * overflow (when the input is greater than largest uint8).\n     *\n     * Counterpart to Solidity's `uint8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits.\n     */\n    function toUint8(uint256 value) internal pure returns (uint8) {\n        require(value <= type(uint8).max, \"SafeCast: value doesn't fit in 8 bits\");\n        return uint8(value);\n    }\n\n    /**\n     * @dev Converts a signed int256 into an unsigned uint256.\n     *\n     * Requirements:\n     *\n     * - input must be greater than or equal to 0.\n     */\n    function toUint256(int256 value) internal pure returns (uint256) {\n        require(value >= 0, \"SafeCast: value must be positive\");\n        return uint256(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int128 from int256, reverting on\n     * overflow (when the input is less than smallest int128 or\n     * greater than largest int128).\n     *\n     * Counterpart to Solidity's `int128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt128(int256 value) internal pure returns (int128) {\n        require(value >= type(int128).min && value <= type(int128).max, \"SafeCast: value doesn't fit in 128 bits\");\n        return int128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int64 from int256, reverting on\n     * overflow (when the input is less than smallest int64 or\n     * greater than largest int64).\n     *\n     * Counterpart to Solidity's `int64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt64(int256 value) internal pure returns (int64) {\n        require(value >= type(int64).min && value <= type(int64).max, \"SafeCast: value doesn't fit in 64 bits\");\n        return int64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int32 from int256, reverting on\n     * overflow (when the input is less than smallest int32 or\n     * greater than largest int32).\n     *\n     * Counterpart to Solidity's `int32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt32(int256 value) internal pure returns (int32) {\n        require(value >= type(int32).min && value <= type(int32).max, \"SafeCast: value doesn't fit in 32 bits\");\n        return int32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int16 from int256, reverting on\n     * overflow (when the input is less than smallest int16 or\n     * greater than largest int16).\n     *\n     * Counterpart to Solidity's `int16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt16(int256 value) internal pure returns (int16) {\n        require(value >= type(int16).min && value <= type(int16).max, \"SafeCast: value doesn't fit in 16 bits\");\n        return int16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int8 from int256, reverting on\n     * overflow (when the input is less than smallest int8 or\n     * greater than largest int8).\n     *\n     * Counterpart to Solidity's `int8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits.\n     *\n     * _Available since v3.1._\n     */\n    function toInt8(int256 value) internal pure returns (int8) {\n        require(value >= type(int8).min && value <= type(int8).max, \"SafeCast: value doesn't fit in 8 bits\");\n        return int8(value);\n    }\n\n    /**\n     * @dev Converts an unsigned uint256 into a signed int256.\n     *\n     * Requirements:\n     *\n     * - input must be less than or equal to maxInt256.\n     */\n    function toInt256(uint256 value) internal pure returns (int256) {\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\n        require(value <= uint256(type(int256).max), \"SafeCast: value doesn't fit in an int256\");\n        return int256(value);\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/utils/cryptography/ECDSA.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/ECDSA.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../Strings.sol\";\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n    enum RecoverError {\n        NoError,\n        InvalidSignature,\n        InvalidSignatureLength,\n        InvalidSignatureS,\n        InvalidSignatureV\n    }\n\n    function _throwError(RecoverError error) private pure {\n        if (error == RecoverError.NoError) {\n            return; // no error: do nothing\n        } else if (error == RecoverError.InvalidSignature) {\n            revert(\"ECDSA: invalid signature\");\n        } else if (error == RecoverError.InvalidSignatureLength) {\n            revert(\"ECDSA: invalid signature length\");\n        } else if (error == RecoverError.InvalidSignatureS) {\n            revert(\"ECDSA: invalid signature 's' value\");\n        } else if (error == RecoverError.InvalidSignatureV) {\n            revert(\"ECDSA: invalid signature 'v' value\");\n        }\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature` or error string. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {toEthSignedMessageHash} on it.\n     *\n     * Documentation for signature generation:\n     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n     *\n     * _Available since v4.3._\n     */\n    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {\n        // Check the signature length\n        // - case 65: r,s,v signature (standard)\n        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._\n        if (signature.length == 65) {\n            bytes32 r;\n            bytes32 s;\n            uint8 v;\n            // ecrecover takes the signature parameters, and the only way to get them\n            // currently is to use assembly.\n            assembly {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            return tryRecover(hash, v, r, s);\n        } else if (signature.length == 64) {\n            bytes32 r;\n            bytes32 vs;\n            // ecrecover takes the signature parameters, and the only way to get them\n            // currently is to use assembly.\n            assembly {\n                r := mload(add(signature, 0x20))\n                vs := mload(add(signature, 0x40))\n            }\n            return tryRecover(hash, r, vs);\n        } else {\n            return (address(0), RecoverError.InvalidSignatureLength);\n        }\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature`. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {toEthSignedMessageHash} on it.\n     */\n    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n        (address recovered, RecoverError error) = tryRecover(hash, signature);\n        _throwError(error);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\n     *\n     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\n     *\n     * _Available since v4.3._\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes32 r,\n        bytes32 vs\n    ) internal pure returns (address, RecoverError) {\n        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\n        uint8 v = uint8((uint256(vs) >> 255) + 27);\n        return tryRecover(hash, v, r, s);\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\n     *\n     * _Available since v4.2._\n     */\n    function recover(\n        bytes32 hash,\n        bytes32 r,\n        bytes32 vs\n    ) internal pure returns (address) {\n        (address recovered, RecoverError error) = tryRecover(hash, r, vs);\n        _throwError(error);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     *\n     * _Available since v4.3._\n     */\n    function tryRecover(\n        bytes32 hash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address, RecoverError) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n            return (address(0), RecoverError.InvalidSignatureS);\n        }\n        if (v != 27 && v != 28) {\n            return (address(0), RecoverError.InvalidSignatureV);\n        }\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(hash, v, r, s);\n        if (signer == address(0)) {\n            return (address(0), RecoverError.InvalidSignature);\n        }\n\n        return (signer, RecoverError.NoError);\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function recover(\n        bytes32 hash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address) {\n        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\n        _throwError(error);\n        return recovered;\n    }\n\n    /**\n     * @dev Returns an Ethereum Signed Message, created from a `hash`. This\n     * produces hash corresponding to the one signed with the\n     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\n     * JSON-RPC method as part of EIP-191.\n     *\n     * See {recover}.\n     */\n    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\n        // 32 is the length in bytes of hash,\n        // enforced by the type signature above\n        return keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n32\", hash));\n    }\n\n    /**\n     * @dev Returns an Ethereum Signed Message, created from `s`. This\n     * produces hash corresponding to the one signed with the\n     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\n     * JSON-RPC method as part of EIP-191.\n     *\n     * See {recover}.\n     */\n    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {\n        return keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n\", Strings.toString(s.length), s));\n    }\n\n    /**\n     * @dev Returns an Ethereum Signed Typed Data, created from a\n     * `domainSeparator` and a `structHash`. This produces hash corresponding\n     * to the one signed with the\n     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\n     * JSON-RPC method as part of EIP-712.\n     *\n     * See {recover}.\n     */\n    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\n        return keccak256(abi.encodePacked(\"\\x19\\x01\", domainSeparator, structHash));\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\ninterface IERC20Permit {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n     * given ``owner``'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"
+    },
+    "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/cryptography/draft-EIP712.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./ECDSA.sol\";\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.\n *\n * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,\n * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding\n * they need in their contracts using a combination of `abi.encode` and `keccak256`.\n *\n * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding\n * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA\n * ({_hashTypedDataV4}).\n *\n * The implementation of the domain separator was designed to be as efficient as possible while still properly updating\n * the chain id to protect against replay attacks on an eventual fork of the chain.\n *\n * NOTE: This contract implements the version of the encoding known as \"v4\", as implemented by the JSON RPC method\n * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].\n *\n * _Available since v3.4._\n */\nabstract contract EIP712 {\n    /* solhint-disable var-name-mixedcase */\n    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to\n    // invalidate the cached domain separator if the chain id changes.\n    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;\n    uint256 private immutable _CACHED_CHAIN_ID;\n    address private immutable _CACHED_THIS;\n\n    bytes32 private immutable _HASHED_NAME;\n    bytes32 private immutable _HASHED_VERSION;\n    bytes32 private immutable _TYPE_HASH;\n\n    /* solhint-enable var-name-mixedcase */\n\n    /**\n     * @dev Initializes the domain separator and parameter caches.\n     *\n     * The meaning of `name` and `version` is specified in\n     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:\n     *\n     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.\n     * - `version`: the current major version of the signing domain.\n     *\n     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart\n     * contract upgrade].\n     */\n    constructor(string memory name, string memory version) {\n        bytes32 hashedName = keccak256(bytes(name));\n        bytes32 hashedVersion = keccak256(bytes(version));\n        bytes32 typeHash = keccak256(\n            \"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"\n        );\n        _HASHED_NAME = hashedName;\n        _HASHED_VERSION = hashedVersion;\n        _CACHED_CHAIN_ID = block.chainid;\n        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);\n        _CACHED_THIS = address(this);\n        _TYPE_HASH = typeHash;\n    }\n\n    /**\n     * @dev Returns the domain separator for the current chain.\n     */\n    function _domainSeparatorV4() internal view returns (bytes32) {\n        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {\n            return _CACHED_DOMAIN_SEPARATOR;\n        } else {\n            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);\n        }\n    }\n\n    function _buildDomainSeparator(\n        bytes32 typeHash,\n        bytes32 nameHash,\n        bytes32 versionHash\n    ) private view returns (bytes32) {\n        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));\n    }\n\n    /**\n     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this\n     * function returns the hash of the fully encoded EIP712 message for this domain.\n     *\n     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:\n     *\n     * ```solidity\n     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(\n     *     keccak256(\"Mail(address to,string contents)\"),\n     *     mailTo,\n     *     keccak256(bytes(mailContents))\n     * )));\n     * address signer = ECDSA.recover(digest, signature);\n     * ```\n     */\n    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\n        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/utils/Counters.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @title Counters\n * @author Matt Condon (@shrugs)\n * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\n *\n * Include with `using Counters for Counters.Counter;`\n */\nlibrary Counters {\n    struct Counter {\n        // This variable should never be directly accessed by users of the library: interactions must be restricted to\n        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\n        // this feature: see https://github.com/ethereum/solidity/issues/4637\n        uint256 _value; // default: 0\n    }\n\n    function current(Counter storage counter) internal view returns (uint256) {\n        return counter._value;\n    }\n\n    function increment(Counter storage counter) internal {\n        unchecked {\n            counter._value += 1;\n        }\n    }\n\n    function decrement(Counter storage counter) internal {\n        uint256 value = counter._value;\n        require(value > 0, \"Counter: decrement overflow\");\n        unchecked {\n            counter._value = value - 1;\n        }\n    }\n\n    function reset(Counter storage counter) internal {\n        counter._value = 0;\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/utils/Strings.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    bytes16 private constant _HEX_SYMBOLS = \"0123456789abcdef\";\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        // Inspired by OraclizeAPI's implementation - MIT licence\n        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\n\n        if (value == 0) {\n            return \"0\";\n        }\n        uint256 temp = value;\n        uint256 digits;\n        while (temp != 0) {\n            digits++;\n            temp /= 10;\n        }\n        bytes memory buffer = new bytes(digits);\n        while (value != 0) {\n            digits -= 1;\n            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\n            value /= 10;\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        if (value == 0) {\n            return \"0x00\";\n        }\n        uint256 temp = value;\n        uint256 length = 0;\n        while (temp != 0) {\n            length++;\n            temp >>= 8;\n        }\n        return toHexString(value, length);\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = _HEX_SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n}\n"
+    },
+    "contracts/MintManager.sol": {
+      "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.12;\n\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"./GovernanceToken.sol\";\n\n/**\n * @title  MintManager\n * @notice Set as `owner` of the OP token and responsible for the token inflation schedule.\n *         Contract acts as the token \"mint manager\" with permission to the `mint` function only.\n *         Currently permitted to mint once per year of up to 2% of the total token supply.\n *         Upgradable to allow changes in the inflation schedule.\n */\ncontract MintManager is Ownable {\n    /**\n     * @notice The GovernanceToken that the MintManager can mint tokens\n     */\n    GovernanceToken public immutable governanceToken;\n\n    /**\n     * @notice The amount of tokens that can be minted per year. The value is a fixed\n     *          point number with 4 decimals.\n     */\n    uint256 public constant MINT_CAP = 20; // 2%\n\n    /**\n     * @notice The number of decimals for the MINT_CAP.\n     */\n    uint256 public constant DENOMINATOR = 1000;\n\n    /**\n     * @notice The amount of time that must pass before the MINT_CAP number of tokens can\n     *         be minted again.\n     */\n    uint256 public constant MINT_PERIOD = 365 days;\n\n    /**\n     * @notice Tracks the time of last mint\n     */\n    uint256 public mintPermittedAfter;\n\n    /**\n     * @param _upgrader        The owner of this contract\n     * @param _governanceToken The governance token this contract can mint\n     *                         tokens of\n     */\n    constructor(address _upgrader, address _governanceToken) {\n        transferOwnership(_upgrader);\n        governanceToken = GovernanceToken(_governanceToken);\n    }\n\n    /**\n     * @notice Only the token owner is allowed to mint a certain amount of OP per year.\n     *\n     * @param _account Address to mint new tokens to.\n     * @param _amount  Amount of tokens to be minted.\n     */\n    function mint(address _account, uint256 _amount) public onlyOwner {\n        if (mintPermittedAfter > 0) {\n            require(mintPermittedAfter <= block.timestamp, \"OP: minting not permitted yet\");\n\n            require(\n                _amount <= (governanceToken.totalSupply() * MINT_CAP) / DENOMINATOR,\n                \"OP: mint amount exceeds cap\"\n            );\n        }\n\n        mintPermittedAfter = block.timestamp + MINT_PERIOD;\n\n        governanceToken.mint(_account, _amount);\n    }\n\n    /**\n     * @notice Upgrade the owner of the governance token to a new MintManager.\n     *\n     * @param _newMintManager The MintManager to upgrade to\n     */\n    function upgrade(address _newMintManager) public onlyOwner {\n        require(_newMintManager != address(0), \"OP: Mint manager cannot be empty\");\n\n        governanceToken.transferOwnership(_newMintManager);\n    }\n}\n"
+    },
+    "contracts/test/TestERC20.sol": {
+      "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity =0.8.12;\n\nimport \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\ncontract TestERC20 is ERC20 {\n    constructor(\n        string memory name_,\n        string memory symbol_,\n        uint256 amountToMint\n    ) ERC20(name_, symbol_) {\n        setBalance(msg.sender, amountToMint);\n    }\n\n    // sets the balance of the address\n    // this mints/burns the amount depending on the current balance\n    function setBalance(address to, uint256 amount) public {\n        uint256 old = balanceOf(to);\n        if (old < amount) {\n            _mint(to, amount - old);\n        } else if (old > amount) {\n            _burn(to, old - amount);\n        }\n    }\n}\n"
+    },
+    "contracts/MerkleDistributor.sol": {
+      "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity =0.8.12;\n\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\";\nimport \"./interfaces/IMerkleDistributor.sol\";\n\ncontract MerkleDistributor is IMerkleDistributor {\n    address public immutable override token;\n    bytes32 public immutable override merkleRoot;\n\n    uint256 public constant ONE_YEAR_IN_SECONDS = 31_536_000;\n    uint256 public immutable activationTimestamp;\n    address public immutable airdropTreasury;\n    bool public isActive;\n\n    // This is a packed array of booleans.\n    mapping(uint256 => uint256) private claimedBitMap;\n\n    event Finalised(address indexed calledBy, uint256 timestamp, uint256 unclaimedAmount);\n\n    constructor(\n        address token_,\n        bytes32 merkleRoot_,\n        address _treasury\n    ) {\n        token = token_;\n        merkleRoot = merkleRoot_;\n\n        activationTimestamp = block.timestamp;\n        isActive = true;\n        airdropTreasury = _treasury;\n    }\n\n    function isClaimed(uint256 index) public view override returns (bool) {\n        uint256 claimedWordIndex = index / 256;\n        uint256 claimedBitIndex = index % 256;\n        uint256 claimedWord = claimedBitMap[claimedWordIndex];\n        uint256 mask = (1 << claimedBitIndex);\n        return claimedWord & mask == mask;\n    }\n\n    function _setClaimed(uint256 index) private {\n        uint256 claimedWordIndex = index / 256;\n        uint256 claimedBitIndex = index % 256;\n        claimedBitMap[claimedWordIndex] = claimedBitMap[claimedWordIndex] | (1 << claimedBitIndex);\n    }\n\n    function claim(\n        uint256 index,\n        address account,\n        uint256 amount,\n        bytes32[] calldata merkleProof\n    ) external override {\n        require(!isClaimed(index), \"MerkleDistributor: Drop already claimed.\");\n\n        // Verify the merkle proof.\n        bytes32 node = keccak256(abi.encodePacked(index, account, amount));\n        require(\n            MerkleProof.verify(merkleProof, merkleRoot, node),\n            \"MerkleDistributor: Invalid proof.\"\n        );\n\n        // Mark it claimed and send the token.\n        _setClaimed(index);\n        require(IERC20(token).transfer(account, amount), \"MerkleDistributor: Transfer failed.\");\n\n        emit Claimed(index, account, amount);\n    }\n\n    /**\n     * @dev Finalises the airdrop and sweeps unclaimed tokens into the Optimism multisig\n     */\n    function clawBack() external {\n        // Airdrop can only be finalised once\n        require(isActive, \"Airdrop: Already finalised\");\n        // Airdrop will remain open for one year\n        require(\n            block.timestamp >= activationTimestamp + ONE_YEAR_IN_SECONDS,\n            \"Airdrop: Drop should remain open for one year\"\n        );\n        // Deactivate airdrop\n        isActive = false;\n\n        // Sweep unclaimed tokens\n        uint256 amount = IERC20(token).balanceOf(address(this));\n        require(\n            IERC20(token).transfer(airdropTreasury, amount),\n            \"Airdrop: Finalise transfer failed\"\n        );\n\n        emit Finalised(msg.sender, block.timestamp, amount);\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/MerkleProof.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev These functions deal with verification of Merkle Trees proofs.\n *\n * The proofs can be generated using the JavaScript library\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\n *\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\n */\nlibrary MerkleProof {\n    /**\n     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\n     * defined by `root`. For this, a `proof` must be provided, containing\n     * sibling hashes on the branch from the leaf to the root of the tree. Each\n     * pair of leaves and each pair of pre-images are assumed to be sorted.\n     */\n    function verify(\n        bytes32[] memory proof,\n        bytes32 root,\n        bytes32 leaf\n    ) internal pure returns (bool) {\n        return processProof(proof, leaf) == root;\n    }\n\n    /**\n     * @dev Returns the rebuilt hash obtained by traversing a Merklee tree up\n     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\n     * hash matches the root of the tree. When processing the proof, the pairs\n     * of leafs & pre-images are assumed to be sorted.\n     *\n     * _Available since v4.4._\n     */\n    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {\n        bytes32 computedHash = leaf;\n        for (uint256 i = 0; i < proof.length; i++) {\n            bytes32 proofElement = proof[i];\n            if (computedHash <= proofElement) {\n                // Hash(current computed hash + current element of the proof)\n                computedHash = _efficientHash(computedHash, proofElement);\n            } else {\n                // Hash(current element of the proof + current computed hash)\n                computedHash = _efficientHash(proofElement, computedHash);\n            }\n        }\n        return computedHash;\n    }\n\n    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {\n        assembly {\n            mstore(0x00, a)\n            mstore(0x20, b)\n            value := keccak256(0x00, 0x40)\n        }\n    }\n}\n"
+    },
+    "contracts/interfaces/IMerkleDistributor.sol": {
+      "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.12;\n\n// Allows anyone to claim a token if they exist in a merkle root.\ninterface IMerkleDistributor {\n    // Returns the address of the token distributed by this contract.\n    function token() external view returns (address);\n\n    // Returns the merkle root of the merkle tree containing account balances available to claim.\n    function merkleRoot() external view returns (bytes32);\n\n    // Returns true if the index has been marked claimed.\n    function isClaimed(uint256 index) external view returns (bool);\n\n    // Claim the given amount of the token to the given address. Reverts if the inputs are invalid.\n    function claim(\n        uint256 index,\n        address account,\n        uint256 amount,\n        bytes32[] calldata merkleProof\n    ) external;\n\n    // This event is triggered whenever a call to #claim succeeds.\n    event Claimed(uint256 index, address account, uint256 amount);\n}\n"
+    }
+  },
+  "settings": {
+    "outputSelection": {
+      "*": {
+        "*": [
+          "metadata",
+          "storageLayout",
+          "abi",
+          "evm.bytecode",
+          "evm.deployedBytecode",
+          "evm.methodIdentifiers",
+          "devdoc",
+          "userdoc",
+          "evm.gasEstimates"
+        ],
+        "": [
+          "ast"
+        ]
+      }
+    },
+    "optimizer": {
+      "enabled": false,
+      "runs": 200
+    },
+    "metadata": {
+      "useLiteralContent": true
+    }
+  }
+}
\ No newline at end of file

packages/contracts-governance/hardhat.config.ts

 import dotenv from 'dotenv'
 import { HardhatUserConfig } from 'hardhat/config'
+import { getenv } from '@eth-optimism/core-utils'
 import '@nomiclabs/hardhat-ethers'
 import '@nomiclabs/hardhat-etherscan'
 import '@nomiclabs/hardhat-waffle'
 import 'hardhat-gas-reporter'
 import 'solidity-coverage'
+import '@eth-optimism/hardhat-deploy-config'
+import 'hardhat-deploy'
 
 import './scripts/deploy-token'
 import './scripts/multi-send'
@@ -60,6 +63,14 @@ const config: HardhatUserConfig = {
       url: 'http://localhost:8545',
     },
   },
+  paths: {
+    deployConfig: 'deploy-config',
+  },
+  deployConfigSpec: {
+    upgrader: {
+      type: 'address',
+    },
+  },
   gasReporter: {
     enabled: process.env.REPORT_GAS !== undefined,
     currency: 'USD',
@@ -67,6 +78,14 @@ const config: HardhatUserConfig = {
   etherscan: {
     apiKey: process.env.ETHERSCAN_API_KEY,
   },
+  namedAccounts: {
+    deployer: {
+      default: getenv('LEDGER_ADDRESS')
+        ? `ledger://${getenv('LEDGER_ADDRESS')}`
+        : 0,
+      hardhat: 0,
+    },
+  },
 }
 
 export default config

packages/contracts-governance/package.json

@@ -30,6 +30,7 @@
   "dependencies": {
     "@eth-optimism/core-utils": "^0.10.1",
     "@eth-optimism/sdk": "^1.6.4",
+    "@eth-optimism/hardhat-deploy-config": "^0.2.3",
     "@ethersproject/hardware-wallets": "^5.7.0",
     "@nomiclabs/hardhat-ethers": "^2.0.2",
     "@nomiclabs/hardhat-etherscan": "^3.0.1",
@@ -50,6 +51,7 @@
     "eslint": "^8.9.0",
     "ethereum-waffle": "^3.4.0",
     "hardhat-gas-reporter": "^1.0.7",
+    "hardhat-deploy": "^0.11.4",
     "prettier": "^2.3.1",
     "prettier-plugin-solidity": "^1.0.0-beta.18",
     "solhint": "^3.3.6",

packages/contracts-periphery/CHANGELOG.md

 # @eth-optimism/contracts-periphery
 
+## 1.0.2
+
+### Patch Changes
+
+- e81a6ff5: Goerli nft bridge deployment
+- a3242d4f: Fix erc721 factory to match erc21 factory
+- ffa5297e: mainnet nft bridge deployments
+
 ## 1.0.1
 
 ### Patch Changes

packages/contracts-periphery/package.json

 {
   "name": "@eth-optimism/contracts-periphery",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "[Optimism] External (out-of-protocol) L1 and L2 smart contracts for Optimism",
   "main": "dist/index",
   "types": "dist/index",
@@ -55,7 +55,7 @@
   "devDependencies": {
     "@defi-wonderland/smock": "^2.0.7",
     "@eth-optimism/contracts": "^0.5.37",
-    "@eth-optimism/contracts-bedrock": "^0.8.0",
+    "@eth-optimism/contracts-bedrock": "^0.8.1",
     "@eth-optimism/core-utils": "^0.10.1",
     "@eth-optimism/hardhat-deploy-config": "^0.2.4",
     "@ethersproject/hardware-wallets": "^5.7.0",

packages/drippie-mon/CHANGELOG.md

 # @eth-optimism/drippie-mon
 
+## 0.3.18
+
+### Patch Changes
+
+- Updated dependencies [b40913b1]
+- Updated dependencies [a5e715c3]
+- Updated dependencies [e81a6ff5]
+- Updated dependencies [a3242d4f]
+- Updated dependencies [ffa5297e]
+  - @eth-optimism/sdk@1.6.7
+  - @eth-optimism/contracts-periphery@1.0.2
+
 ## 0.3.17
 
 ### Patch Changes

packages/drippie-mon/package.json

 {
   "private": true,
   "name": "@eth-optimism/drippie-mon",
-  "version": "0.3.17",
+  "version": "0.3.18",
   "description": "[Optimism] Service for monitoring Drippie instances",
   "main": "dist/index",
   "types": "dist/index",
@@ -33,9 +33,9 @@
   },
   "dependencies": {
     "@eth-optimism/common-ts": "0.6.6",
-    "@eth-optimism/contracts-periphery": "1.0.1",
+    "@eth-optimism/contracts-periphery": "1.0.2",
     "@eth-optimism/core-utils": "0.10.1",
-    "@eth-optimism/sdk": "1.6.6",
+    "@eth-optimism/sdk": "1.6.7",
     "ethers": "^5.7.0"
   },
   "devDependencies": {

packages/integration-tests-bedrock/package.json

@@ -29,7 +29,7 @@
   "devDependencies": {
     "@eth-optimism/contracts": "0.5.37",
     "@eth-optimism/core-utils": "0.10.1",
-    "@eth-optimism/sdk": "1.6.6",
+    "@eth-optimism/sdk": "1.6.7",
     "@ethersproject/abstract-provider": "^5.7.0",
     "chai-as-promised": "^7.1.1",
     "chai": "^4.3.4",

packages/message-relayer/CHANGELOG.md

 # @eth-optimism/message-relayer
 
+## 0.5.17
+
+### Patch Changes
+
+- Updated dependencies [b40913b1]
+- Updated dependencies [a5e715c3]
+  - @eth-optimism/sdk@1.6.7
+
 ## 0.5.16
 
 ### Patch Changes

packages/message-relayer/package.json

 {
   "private": true,
   "name": "@eth-optimism/message-relayer",
-  "version": "0.5.16",
+  "version": "0.5.17",
   "description": "[Optimism] Service for automatically relaying L2 to L1 transactions",
   "main": "dist/index",
   "types": "dist/index",
@@ -33,7 +33,7 @@
   "dependencies": {
     "@eth-optimism/common-ts": "0.6.6",
     "@eth-optimism/core-utils": "0.10.1",
-    "@eth-optimism/sdk": "1.6.6",
+    "@eth-optimism/sdk": "1.6.7",
     "ethers": "^5.7.0"
   },
   "devDependencies": {

packages/sdk/CHANGELOG.md

 # @eth-optimism/sdk
 
+## 1.6.7
+
+### Patch Changes
+
+- b40913b1: Adds contract addresses for the Bedrock Alpha testnet
+- a5e715c3: Rename the event emitted in the L2ToL1MessagePasser
+- Updated dependencies [35a7bb5e]
+- Updated dependencies [a5e715c3]
+- Updated dependencies [d18b8aa3]
+  - @eth-optimism/contracts-bedrock@0.8.1
+
 ## 1.6.6
 
 ### Patch Changes

packages/sdk/package.json

 {
   "name": "@eth-optimism/sdk",
-  "version": "1.6.6",
+  "version": "1.6.7",
   "description": "[Optimism] Tools for working with Optimism",
   "main": "dist/index",
   "types": "dist/index",
@@ -50,7 +50,7 @@
   "dependencies": {
     "@eth-optimism/contracts": "0.5.37",
     "@eth-optimism/core-utils": "0.10.1",
-    "@eth-optimism/contracts-bedrock": "0.8.0",
+    "@eth-optimism/contracts-bedrock": "0.8.1",
     "lodash": "^4.17.21",
     "merkletreejs": "^0.2.27",
     "rlp": "^2.2.7"

proxyd/CHANGELOG.md

 # @eth-optimism/proxyd
 
+## 3.11.0
+
+### Minor Changes
+
+- b3c5eeec: Fixed JSON-RPC 2.0 specification compliance by adding the optional data field on an RPCError
+- 01ae6625: Adds new Redis rate limiter
+
 ## 3.10.2
 
 ### Patch Changes

proxyd/rate_limiter.go → proxyd/backend_rate_limiter.go

@@ -57,22 +57,14 @@ type RedisBackendRateLimiter struct {
 	tkMtx     sync.Mutex
 }
 
-func NewRedisRateLimiter(url string) (BackendRateLimiter, error) {
-	opts, err := redis.ParseURL(url)
-	if err != nil {
-		return nil, err
-	}
-	rdb := redis.NewClient(opts)
-	if err := rdb.Ping(context.Background()).Err(); err != nil {
-		return nil, wrapErr(err, "error connecting to redis")
-	}
+func NewRedisRateLimiter(rdb *redis.Client) BackendRateLimiter {
 	out := &RedisBackendRateLimiter{
 		rdb:       rdb,
 		randID:    randStr(20),
 		touchKeys: make(map[string]time.Duration),
 	}
 	go out.touch()
-	return out, nil
+	return out
 }
 
 func (r *RedisBackendRateLimiter) IsBackendOnline(name string) (bool, error) {

proxyd/cache.go

@@ -46,16 +46,8 @@ type redisCache struct {
 	rdb *redis.Client
 }
 
-func newRedisCache(url string) (*redisCache, error) {
-	opts, err := redis.ParseURL(url)
-	if err != nil {
-		return nil, err
-	}
-	rdb := redis.NewClient(opts)
-	if err := rdb.Ping(context.Background()).Err(); err != nil {
-		return nil, wrapErr(err, "error connecting to redis")
-	}
-	return &redisCache{rdb}, nil
+func newRedisCache(rdb *redis.Client) *redisCache {
+	return &redisCache{rdb}
 }
 
 func (c *redisCache) Get(ctx context.Context, key string) (string, error) {

proxyd/config.go

@@ -41,7 +41,9 @@ type MetricsConfig struct {
 }
 
 type RateLimitConfig struct {
-	RatePerSecond    int                                 `toml:"rate_per_second"`
+	UseRedis         bool                                `toml:"use_redis"`
+	BaseRate         int                                 `toml:"base_rate"`
+	BaseInterval     TOMLDuration                        `toml:"base_interval"`
 	ExemptOrigins    []string                            `toml:"exempt_origins"`
 	ExemptUserAgents []string                            `toml:"exempt_user_agents"`
 	ErrorMessage     string                              `toml:"error_message"`

proxyd/frontend_rate_limiter.go

+package proxyd
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/go-redis/redis/v8"
+)
+
+type FrontendRateLimiter interface {
+	// Take consumes a key, and a maximum number of requests
+	// per time interval. It returns a boolean denoting if
+	// the limit could be taken, or an error if a failure
+	// occurred in the backing rate limit implementation.
+	//
+	// No error will be returned if the limit could not be taken
+	// as a result of the requestor being over the limit.
+	Take(ctx context.Context, key string) (bool, error)
+}
+
+// limitedKeys is a wrapper around a map that stores a truncated
+// timestamp and a mutex. The map is used to keep track of rate
+// limit keys, and their used limits.
+type limitedKeys struct {
+	truncTS int64
+	keys    map[string]int
+	mtx     sync.Mutex
+}
+
+func newLimitedKeys(t int64) *limitedKeys {
+	return &limitedKeys{
+		truncTS: t,
+		keys:    make(map[string]int),
+	}
+}
+
+func (l *limitedKeys) Take(key string, max int) bool {
+	l.mtx.Lock()
+	defer l.mtx.Unlock()
+	val, ok := l.keys[key]
+	if !ok {
+		l.keys[key] = 0
+		val = 0
+	}
+	l.keys[key] = val + 1
+	return val < max
+}
+
+// MemoryFrontendRateLimiter is a rate limiter that stores
+// all rate limiting information in local memory. It works
+// by storing a limitedKeys struct that references the
+// truncated timestamp at which the struct was created. If
+// the current truncated timestamp doesn't match what's
+// referenced, the limit is reset. Otherwise, values in
+// a map are incremented to represent the limit.
+type MemoryFrontendRateLimiter struct {
+	currGeneration *limitedKeys
+	dur            time.Duration
+	max            int
+	mtx            sync.Mutex
+}
+
+func NewMemoryFrontendRateLimit(dur time.Duration, max int) FrontendRateLimiter {
+	return &MemoryFrontendRateLimiter{
+		dur: dur,
+		max: max,
+	}
+}
+
+func (m *MemoryFrontendRateLimiter) Take(ctx context.Context, key string) (bool, error) {
+	m.mtx.Lock()
+	// Create truncated timestamp
+	truncTS := truncateNow(m.dur)
+
+	// If there is no current rate limit map or the rate limit map reference
+	// a different timestamp, reset limits.
+	if m.currGeneration == nil || m.currGeneration.truncTS != truncTS {
+		m.currGeneration = newLimitedKeys(truncTS)
+	}
+
+	// Pull out the limiter so we can unlock before incrementing the limit.
+	limiter := m.currGeneration
+
+	m.mtx.Unlock()
+
+	return limiter.Take(key, m.max), nil
+}
+
+// RedisFrontendRateLimiter is a rate limiter that stores data in Redis.
+// It uses the basic rate limiter pattern described on the Redis best
+// practices website: https://redis.com/redis-best-practices/basic-rate-limiting/.
+type RedisFrontendRateLimiter struct {
+	r      *redis.Client
+	dur    time.Duration
+	max    int
+	prefix string
+}
+
+func NewRedisFrontendRateLimiter(r *redis.Client, dur time.Duration, max int, prefix string) FrontendRateLimiter {
+	return &RedisFrontendRateLimiter{
+		r:      r,
+		dur:    dur,
+		max:    max,
+		prefix: prefix,
+	}
+}
+
+func (r *RedisFrontendRateLimiter) Take(ctx context.Context, key string) (bool, error) {
+	var incr *redis.IntCmd
+	truncTS := truncateNow(r.dur)
+	fullKey := fmt.Sprintf("rate_limit:%s:%s:%d", r.prefix, key, truncTS)
+	_, err := r.r.Pipelined(ctx, func(pipe redis.Pipeliner) error {
+		incr = pipe.Incr(ctx, fullKey)
+		pipe.PExpire(ctx, fullKey, r.dur-time.Millisecond)
+		return nil
+	})
+	if err != nil {
+		frontendRateLimitTakeErrors.Inc()
+		return false, err
+	}
+
+	return incr.Val()-1 < int64(r.max), nil
+}
+
+type noopFrontendRateLimiter struct{}
+
+var NoopFrontendRateLimiter = &noopFrontendRateLimiter{}
+
+func (n *noopFrontendRateLimiter) Take(ctx context.Context, key string) (bool, error) {
+	return true, nil
+}
+
+// truncateNow truncates the current timestamp
+// to the specified duration.
+func truncateNow(dur time.Duration) int64 {
+	return time.Now().Truncate(dur).Unix()
+}

proxyd/frontend_rate_limiter_test.go

+package proxyd
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/alicebob/miniredis"
+	"github.com/go-redis/redis/v8"
+	"github.com/stretchr/testify/require"
+)
+
+func TestFrontendRateLimiter(t *testing.T) {
+	redisServer, err := miniredis.Run()
+	require.NoError(t, err)
+	defer redisServer.Close()
+
+	redisClient := redis.NewClient(&redis.Options{
+		Addr: fmt.Sprintf("127.0.0.1:%s", redisServer.Port()),
+	})
+
+	max := 2
+	lims := []struct {
+		name string
+		frl  FrontendRateLimiter
+	}{
+		{"memory", NewMemoryFrontendRateLimit(2*time.Second, max)},
+		{"redis", NewRedisFrontendRateLimiter(redisClient, 2*time.Second, max, "")},
+	}
+
+	for _, cfg := range lims {
+		frl := cfg.frl
+		ctx := context.Background()
+		t.Run(cfg.name, func(t *testing.T) {
+			for i := 0; i < 4; i++ {
+				ok, err := frl.Take(ctx, "foo")
+				require.NoError(t, err)
+				require.Equal(t, i < max, ok)
+				ok, err = frl.Take(ctx, "bar")
+				require.NoError(t, err)
+				require.Equal(t, i < max, ok)
+			}
+			time.Sleep(2 * time.Second)
+			for i := 0; i < 4; i++ {
+				ok, _ := frl.Take(ctx, "foo")
+				require.Equal(t, i < max, ok)
+				ok, _ = frl.Take(ctx, "bar")
+				require.Equal(t, i < max, ok)
+			}
+		})
+	}
+}

proxyd/integration_tests/failover_test.go

@@ -261,6 +261,8 @@ func TestInfuraFailoverOnUnexpectedResponse(t *testing.T) {
 	config.BackendOptions.MaxRetries = 2
 	// Setup redis to detect offline backends
 	config.Redis.URL = fmt.Sprintf("redis://127.0.0.1:%s", redis.Port())
+	redisClient, err := proxyd.NewRedisClient(config.Redis.URL)
+	require.NoError(t, err)
 
 	goodBackend := NewMockBackend(BatchedResponseHandler(200, goodResponse, goodResponse))
 	defer goodBackend.Close()
@@ -285,7 +287,7 @@ func TestInfuraFailoverOnUnexpectedResponse(t *testing.T) {
 	require.Equal(t, 1, len(badBackend.Requests()))
 	require.Equal(t, 1, len(goodBackend.Requests()))
 
-	rr, err := proxyd.NewRedisRateLimiter(config.Redis.URL)
+	rr := proxyd.NewRedisRateLimiter(redisClient)
 	require.NoError(t, err)
 	online, err := rr.IsBackendOnline("bad")
 	require.NoError(t, err)

proxyd/integration_tests/testdata/frontend_rate_limit.toml

@@ -18,7 +18,8 @@ eth_chainId = "main"
 eth_foobar = "main"
 
 [rate_limit]
-rate_per_second = 2
+base_rate = 2
+base_interval = "1s"
 exempt_origins = ["exempt_origin"]
 exempt_user_agents = ["exempt_agent"]
 error_message = "over rate limit with special message"

proxyd/metrics.go

@@ -236,6 +236,12 @@ var (
 			100,
 		},
 	})
+
+	frontendRateLimitTakeErrors = promauto.NewCounter(prometheus.CounterOpts{
+		Namespace: MetricsNamespace,
+		Name:      "rate_limit_take_errors",
+		Help:      "Count of errors taking frontend rate limits",
+	})
 )
 
 func RecordRedisError(source string) {

proxyd/package.json

 {
   "name": "@eth-optimism/proxyd",
-  "version": "3.10.2",
+  "version": "3.11.0",
   "private": true,
   "dependencies": {}
 }

proxyd/proxyd.go

@@ -13,6 +13,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/go-redis/redis/v8"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"golang.org/x/sync/semaphore"
 )
@@ -34,25 +35,29 @@ func Start(config *Config) (func(), error) {
 		}
 	}
 
-	var redisURL string
+	var redisClient *redis.Client
 	if config.Redis.URL != "" {
 		rURL, err := ReadFromEnvOrConfig(config.Redis.URL)
 		if err != nil {
 			return nil, err
 		}
-		redisURL = rURL
+		redisClient, err = NewRedisClient(rURL)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if redisClient == nil && config.RateLimit.UseRedis {
+		return nil, errors.New("must specify a Redis URL if UseRedis is true in rate limit config")
 	}
 
 	var lim BackendRateLimiter
 	var err error
-	if redisURL == "" {
+	if redisClient == nil {
 		log.Warn("redis is not configured, using local rate limiter")
 		lim = NewLocalBackendRateLimiter()
 	} else {
-		lim, err = NewRedisRateLimiter(redisURL)
-		if err != nil {
-			return nil, err
-		}
+		lim = NewRedisRateLimiter(redisClient)
 	}
 
 	// While modifying shared globals is a bad practice, the alternative
@@ -206,13 +211,11 @@ func Start(config *Config) (func(), error) {
 			return nil, err
 		}
 
-		if redisURL != "" {
-			if cache, err = newRedisCache(redisURL); err != nil {
-				return nil, err
-			}
-		} else {
+		if redisClient == nil {
 			log.Warn("redis is not configured, using in-memory cache")
 			cache = newMemoryCache()
+		} else {
+			cache = newRedisCache(redisClient)
 		}
 		// Ideally, the BlocKSyncRPCURL should be the sequencer or a HA replica that's not far behind
 		ethClient, err := ethclient.Dial(blockSyncRPCURL)
@@ -240,6 +243,7 @@ func Start(config *Config) (func(), error) {
 		config.Server.EnableRequestLog,
 		config.Server.MaxRequestBodyLogLen,
 		config.BatchConfig.MaxSize,
+		redisClient,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("error creating server: %w", err)

proxyd/redis.go

+package proxyd
+
+import (
+	"context"
+	"time"
+
+	"github.com/go-redis/redis/v8"
+)
+
+func NewRedisClient(url string) (*redis.Client, error) {
+	opts, err := redis.ParseURL(url)
+	if err != nil {
+		return nil, err
+	}
+	client := redis.NewClient(opts)
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err := client.Ping(ctx).Err(); err != nil {
+		return nil, wrapErr(err, "error connecting to redis")
+	}
+	return client, nil
+}

proxyd/rpc.go

@@ -57,6 +57,7 @@ func (r *RPCRes) MarshalJSON() ([]byte, error) {
 type RPCErr struct {
 	Code          int    `json:"code"`
 	Message       string `json:"message"`
+	Data          string `json:"data,omitempty"`
 	HTTPErrorCode int    `json:"-"`
 }
 

proxyd/rpc_test.go

@@ -45,7 +45,7 @@ func TestRPCResJSON(t *testing.T) {
 			`{"jsonrpc":"2.0","result":null,"id":123}`,
 		},
 		{
-			"error result",
+			"error result without data",
 			&RPCRes{
 				JSONRPC: JSONRPCVersion,
 				Error: &RPCErr{
@@ -56,6 +56,19 @@ func TestRPCResJSON(t *testing.T) {
 			},
 			`{"jsonrpc":"2.0","error":{"code":1234,"message":"test err"},"id":123}`,
 		},
+		{
+			"error result with data",
+			&RPCRes{
+				JSONRPC: JSONRPCVersion,
+				Error: &RPCErr{
+					Code:    1234,
+					Message: "test err",
+					Data:    "revert",
+				},
+				ID: []byte("123"),
+			},
+			`{"jsonrpc":"2.0","error":{"code":1234,"message":"test err","data":"revert"},"id":123}`,
+		},
 		{
 			"string ID",
 			&RPCRes{

proxyd/server.go

@@ -13,11 +13,8 @@ import (
 	"sync"
 	"time"
 
-	"github.com/sethvargo/go-limiter"
-	"github.com/sethvargo/go-limiter/memorystore"
-	"github.com/sethvargo/go-limiter/noopstore"
-
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/go-redis/redis/v8"
 	"github.com/gorilla/mux"
 	"github.com/gorilla/websocket"
 	"github.com/prometheus/client_golang/prometheus"
@@ -50,9 +47,8 @@ type Server struct {
 	maxUpstreamBatchSize int
 	maxBatchSize         int
 	upgrader             *websocket.Upgrader
-	mainLim              limiter.Store
-	overrideLims         map[string]limiter.Store
-	limConfig            RateLimitConfig
+	mainLim              FrontendRateLimiter
+	overrideLims         map[string]FrontendRateLimiter
 	limExemptOrigins     map[string]bool
 	limExemptUserAgents  map[string]bool
 	rpcServer            *http.Server
@@ -77,6 +73,7 @@ func NewServer(
 	enableRequestLog bool,
 	maxRequestBodyLogLen int,
 	maxBatchSize int,
+	redisClient *redis.Client,
 ) (*Server, error) {
 	if cache == nil {
 		cache = &NoopRPCCache{}
@@ -98,19 +95,19 @@ func NewServer(
 		maxBatchSize = MaxBatchRPCCallsHardLimit
 	}
 
-	var mainLim limiter.Store
-	limExemptOrigins := make(map[string]bool)
-	limExemptUserAgents := make(map[string]bool)
-	if rateLimitConfig.RatePerSecond > 0 {
-		var err error
-		mainLim, err = memorystore.New(&memorystore.Config{
-			Tokens:   uint64(rateLimitConfig.RatePerSecond),
-			Interval: time.Second,
-		})
-		if err != nil {
-			return nil, err
+	limiterFactory := func(dur time.Duration, max int, prefix string) FrontendRateLimiter {
+		if rateLimitConfig.UseRedis {
+			return NewRedisFrontendRateLimiter(redisClient, dur, max, prefix)
 		}
 
+		return NewMemoryFrontendRateLimit(dur, max)
+	}
+
+	var mainLim FrontendRateLimiter
+	limExemptOrigins := make(map[string]bool)
+	limExemptUserAgents := make(map[string]bool)
+	if rateLimitConfig.BaseRate > 0 {
+		mainLim = limiterFactory(time.Duration(rateLimitConfig.BaseInterval), rateLimitConfig.BaseRate, "main")
 		for _, origin := range rateLimitConfig.ExemptOrigins {
 			limExemptOrigins[strings.ToLower(origin)] = true
 		}
@@ -118,16 +115,13 @@ func NewServer(
 			limExemptUserAgents[strings.ToLower(agent)] = true
 		}
 	} else {
-		mainLim, _ = noopstore.New()
+		mainLim = NoopFrontendRateLimiter
 	}
 
-	overrideLims := make(map[string]limiter.Store)
+	overrideLims := make(map[string]FrontendRateLimiter)
 	for method, override := range rateLimitConfig.MethodOverrides {
 		var err error
-		overrideLims[method], err = memorystore.New(&memorystore.Config{
-			Tokens:   uint64(override.Limit),
-			Interval: time.Duration(override.Interval),
-		})
+		overrideLims[method] = limiterFactory(time.Duration(override.Interval), override.Limit, method)
 		if err != nil {
 			return nil, err
 		}
@@ -151,7 +145,6 @@ func NewServer(
 		},
 		mainLim:             mainLim,
 		overrideLims:        overrideLims,
-		limConfig:           rateLimitConfig,
 		limExemptOrigins:    limExemptOrigins,
 		limExemptUserAgents: limExemptUserAgents,
 	}, nil
@@ -235,7 +228,7 @@ func (s *Server) HandleRPC(w http.ResponseWriter, r *http.Request) {
 			return false
 		}
 
-		var lim limiter.Store
+		var lim FrontendRateLimiter
 		if method == "" {
 			lim = s.mainLim
 		} else {
@@ -246,7 +239,11 @@ func (s *Server) HandleRPC(w http.ResponseWriter, r *http.Request) {
 			return false
 		}
 
-		_, _, _, ok, _ := lim.Take(ctx, xff)
+		ok, err := lim.Take(ctx, xff)
+		if err != nil {
+			log.Warn("error taking rate limit", "err", err)
+			return true
+		}
 		return !ok
 	}