Merge branch 'develop' into 08-15-chore_indexer_Remove_logger_config_from_config

indexer/cli/cli.go

@@ -93,7 +93,7 @@ func (c *Cli) Run(args []string) error {
 
 func NewCli(GitVersion string, GitCommit string, GitDate string) *Cli {
 	flags := []cli.Flag{ConfigFlag}
-	flags = append(flags, log.CLIFlags("indexer")...)
+	flags = append(flags, log.CLIFlags("INDEXER")...)
 	app := &cli.App{
 		Version:     fmt.Sprintf("%s-%s", GitVersion, params.VersionWithCommit(GitCommit, GitDate)),
 		Description: "An indexer of all optimism events with a serving api layer",

op-e2e/e2eutils/disputegame/helper.go

@@ -11,7 +11,9 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/deployer"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/genesis"
+	"github.com/ethereum-optimism/optimism/op-challenger/config"
 	"github.com/ethereum-optimism/optimism/op-challenger/fault/alphabet"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/challenger"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/wait"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
@@ -52,6 +54,7 @@ type FactoryHelper struct {
 	require     *require.Assertions
 	client      *ethclient.Client
 	opts        *bind.TransactOpts
+	factoryAddr common.Address
 	factory     *bindings.DisputeGameFactory
 	blockOracle *bindings.BlockOracle
 	l2oo        *bindings.L2OutputOracleCaller
@@ -65,7 +68,8 @@ func NewFactoryHelper(t *testing.T, ctx context.Context, deployments *genesis.L1
 	require.NoError(err)
 
 	require.NotNil(deployments, "No deployments")
-	factory, err := bindings.NewDisputeGameFactory(deployments.DisputeGameFactoryProxy, client)
+	factoryAddr := deployments.DisputeGameFactoryProxy
+	factory, err := bindings.NewDisputeGameFactory(factoryAddr, client)
 	require.NoError(err)
 	blockOracle, err := bindings.NewBlockOracle(deployments.BlockOracle, client)
 	require.NoError(err)
@@ -78,6 +82,7 @@ func NewFactoryHelper(t *testing.T, ctx context.Context, deployments *genesis.L1
 		client:      client,
 		opts:        opts,
 		factory:     factory,
+		factoryAddr: factoryAddr,
 		blockOracle: blockOracle,
 		l2oo:        l2oo,
 	}
@@ -150,6 +155,21 @@ func (h *FactoryHelper) StartCannonGame(ctx context.Context, rootClaim common.Ha
 		},
 	}
 }
+func (h *FactoryHelper) StartChallenger(ctx context.Context, l1Endpoint string, name string, options ...challenger.Option) *challenger.Helper {
+	opts := []challenger.Option{
+		func(c *config.Config) {
+			// Uncomment when challenger actually supports setting the game factory address
+			//c.FactoryAddress = h.factoryAddr
+			c.TraceType = config.TraceTypeAlphabet
+		},
+	}
+	opts = append(opts, options...)
+	c := challenger.NewChallenger(h.t, ctx, l1Endpoint, name, opts...)
+	h.t.Cleanup(func() {
+		_ = c.Close()
+	})
+	return c
+}
 
 // waitForProposals waits until there are at least two proposals in the output oracle
 // This is the minimum required for creating a game.

op-e2e/faultproof_test.go

@@ -13,6 +13,37 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func TestCannonMultipleGames(t *testing.T) {
+	t.Skip("Challenger doesn't yet support multiple games")
+	InitParallel(t)
+
+	ctx := context.Background()
+	sys, l1Client := startFaultDisputeSystem(t)
+	t.Cleanup(sys.Close)
+
+	gameFactory := disputegame.NewFactoryHelper(t, ctx, sys.cfg.L1Deployments, l1Client)
+	// Start a challenger with the correct alphabet trace
+	gameFactory.StartChallenger(ctx, sys.NodeEndpoint("l1"), "TowerDefense", func(c *config.Config) {
+		c.AgreeWithProposedOutput = true
+		c.AlphabetTrace = "abcdefg"
+		c.TxMgrConfig.PrivateKey = e2eutils.EncodePrivKeyToString(sys.cfg.Secrets.Alice)
+	})
+
+	game1 := gameFactory.StartAlphabetGame(ctx, "abcxyz")
+	// Wait for the challenger to respond to the first game
+	game1.WaitForClaimCount(ctx, 2)
+
+	game2 := gameFactory.StartAlphabetGame(ctx, "zyxabc")
+	// Wait for the challenger to respond to the second game
+	game2.WaitForClaimCount(ctx, 2)
+
+	// Challenger should respond to new claims
+	game2.Attack(ctx, 1, common.Hash{0xaa})
+	game2.WaitForClaimCount(ctx, 4)
+	game1.Defend(ctx, 1, common.Hash{0xaa})
+	game1.WaitForClaimCount(ctx, 4)
+}
+
 func TestResolveDisputeGame(t *testing.T) {
 	InitParallel(t)
 

op-service/backoff/operation.go

@@ -17,6 +17,10 @@ func (e *ErrFailedPermanently) Error() string {
 	return fmt.Sprintf("operation failed permanently after %d attempts: %v", e.attempts, e.LastErr)
 }
 
+func (e *ErrFailedPermanently) Unwrap() error {
+	return e.LastErr
+}
+
 type pair[T, U any] struct {
 	a T
 	b U
@@ -35,37 +39,27 @@ func Do2[T, U any](ctx context.Context, maxAttempts int, strategy Strategy, op f
 // with delays in between each retry according to the provided
 // Strategy.
 func Do[T any](ctx context.Context, maxAttempts int, strategy Strategy, op func() (T, error)) (T, error) {
-	var empty T
+	var empty, ret T
+	var err error
 	if maxAttempts < 1 {
 		return empty, fmt.Errorf("need at least 1 attempt to run op, but have %d max attempts", maxAttempts)
 	}
-	var attempt int
 
-	reattemptCh := make(chan struct{}, 1)
-	doReattempt := func() {
-		reattemptCh <- struct{}{}
-	}
-	doReattempt()
-
-	for {
-		select {
-		case <-ctx.Done():
+	for i := 0; i < maxAttempts; i++ {
+		if ctx.Err() != nil {
 			return empty, ctx.Err()
-		case <-reattemptCh:
-			attempt++
-			ret, err := op()
-			if err == nil {
-				return ret, nil
-			}
-
-			if attempt == maxAttempts {
-				return empty, &ErrFailedPermanently{
-					attempts: maxAttempts,
-					LastErr:  err,
-				}
-			}
-			time.AfterFunc(strategy.Duration(attempt-1), doReattempt)
 		}
-
+		ret, err = op()
+		if err == nil {
+			return ret, nil
+		}
+		// Don't sleep when we are about to exit the loop & return ErrFailedPermanently
+		if i != maxAttempts-1 {
+			time.Sleep(strategy.Duration(i))
+		}
+	}
+	return empty, &ErrFailedPermanently{
+		attempts: maxAttempts,
+		LastErr:  err,
 	}
 }

op-service/txmgr/queue_test.go

@@ -159,7 +159,7 @@ func TestSend(t *testing.T) {
 				{sendErr: true},
 				{},
 			},
-			nonces: []uint64{0, 1, 1},
+			nonces: []uint64{0, 1},
 			total:  3 * time.Second,
 		},
 	}

op-service/txmgr/txmgr.go

@@ -17,6 +17,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
 
+	"github.com/ethereum-optimism/optimism/op-service/backoff"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr/metrics"
 )
 
@@ -175,7 +176,13 @@ func (m *SimpleTxManager) send(ctx context.Context, candidate TxCandidate) (*typ
 		ctx, cancel = context.WithTimeout(ctx, m.cfg.TxSendTimeout)
 		defer cancel()
 	}
-	tx, err := m.craftTx(ctx, candidate)
+	tx, err := backoff.Do(ctx, 30, backoff.Fixed(2*time.Second), func() (*types.Transaction, error) {
+		tx, err := m.craftTx(ctx, candidate)
+		if err != nil {
+			m.l.Warn("Failed to create a transaction, will retry", "err", err)
+		}
+		return tx, err
+	})
 	if err != nil {
 		return nil, fmt.Errorf("failed to create the tx: %w", err)
 	}

packages/contracts-bedrock/CONTRIBUTING.md

+# Contributing to CONTRIBUTING.md
+
+First off, thanks for taking the time to contribute!
+
+We welcome and appreciate all kinds of contributions. We ask that before contributing you please review the procedures for each type of contribution available in the [Table of Contents](#table-of-contents). This will streamline the process for both maintainers and contributors. To find ways to contribute, view the [I Want To Contribute](#i-want-to-contribute) section below. Larger contributions should [open an issue](https://github.com/ethereum-optimism/optimism/issues/new) before implementation to ensure changes don't go to waste.
+
+We're excited to work with you and your contributions to scaling Ethereum!
+
+## Table of Contents
+
+- [I Have a Question](#i-have-a-question)
+- [I Want To Contribute](#i-want-to-contribute)
+- [Reporting Bugs](#reporting-bugs)
+- [Suggesting Enhancements](#suggesting-enhancements)
+- [Your First Code Contribution](#your-first-code-contribution)
+- [Improving The Documentation](#improving-the-documentation)
+- [Deploying on Devnet](#deploying-on-devnet)
+- [Tools](#tools)
+
+## I Have a Question
+
+> **Note**
+> Before making an issue, please read the documentation and search the issues to see if your question has already been answered.
+
+If you have any questions about the smart contracts, please feel free to ask them in the Optimism discord developer channels or create a new detailed issue.
+
+## I Want To Contribute
+
+### Reporting Bugs
+
+**Any and all bug reports on production smart contract code should be submitted privately to the Optimism team so that we can mitigate the issue before it is exploited. Please see our security policy document [here](https://github.com/ethereum-optimism/.github/blob/master/SECURITY.md).**
+
+### Suggesting Enhancements
+
+#### Before Submitting an Enhancement
+
+- Read the documentation and the smart contracts themselves to see if the feature already exists.
+- Perform a search in the issues to see if the enhancement has already been suggested. If it has, add a comment to the existing issue instead of opening a new one.
+
+#### How Do I Submit a Good Enhancement Suggestion?
+
+Enhancement suggestions are tracked as [GitHub issues](/issues).
+
+- Use a **clear and descriptive title** for the issue to identify the suggestion.
+- Provide a **step-by-step** description of the suggested enhancement in as many details as possible.
+- Describe the **current** behavior and why the **intended** behavior you expected to see differs. At this point you can also tell which alternatives do not work for you.
+- Explain why this enhancement would be useful in Optimism's smart contracts. You may also want to point out the other projects that solved it better and which could serve as inspiration.
+
+### Your First Code Contribution
+
+The best place to begin contributing is by looking through the issues with the `good first issue` label. These are issues that are relatively easy to implement and are a great way to get familiar with the codebase.
+
+Optimism's smart contracts are written in Solidity and we use [foundry](https://github.com/foundry-rs/foundry) as our development framework. To get started, you'll need to install several dependencies:
+1. [pnpm](https://pnpm.io)
+  1. Make sure to `pnpm install`
+1. [foundry](https://getfoundry.sh)
+  1. Foundry is built with [rust](https://www.rust-lang.org/tools/install), and this project uses a pinned version of foundry. Install the rust toolchain with `rustup`.
+  1. Make sure to install the version of foundry used by `ci-builder`, defined in the `.foundryrc` file in the root of this repo. Once you have `foundryup` installed, there is a helper to do this: `pnpm install:foundry`
+1. [golang](https://golang.org/doc/install)
+1. [python](https://www.python.org/downloads/)
+
+Our [Style Guide](STYLE_GUIDE.md) contains information about the project structure, syntax preferences, naming conventions, and more. Please take a look at it before submitting a PR, and let us know if you spot inconcistencies!
+
+Once you've read the styleguide and are ready to work on your PR, there are a plethora of useful `pnpm` scripts to know about that will help you with development:
+1. `pnpm build` Builds the smart contracts.
+1. `pnpm test` Runs the full `forge` test suite.
+1  `pnpm gas-snapshot` Generates the gas snapshot for the smart contracts.
+1. `pnpm semver-lock` Generates the semver lockfile.
+1. `pnpm storage-snapshot` Generates the storage lockfile.
+1. `pnpm autogen:invariant-docs` Generates the invariant test documentation.
+1. `pnpm clean` Removes all build artifacts for `forge` and `go` compilations.
+1. `pnpm validate-spacers` Validates the positions of the storage slot spacers.
+1. `pnpm validate-deploy-configs` Validates the deployment configurations in `deploy-config`
+1. `pnpm slither` Runs the slither static analysis tool on the smart contracts.
+1. `pnpm lint` Runs the linter on the smart contracts and scripts.
+1. `pnpm pre-pr` Runs most checks, generators, and linters prior to a PR. For most PRs, this is sufficient to pass CI if everything is in order.
+1. `pnpm pre-pr:full` Runs all checks, generators, and linters prior to a PR.
+
+### Improving The Documentation
+
+Documentation improvements are more than welcome! If you see a typo or feel that a code comment describes something poorly or incorrectly, please submit a PR with a fix.
+
+### Deploying on Devnet
+
+To deploy the smart contracts on a local devnet, run `make devnet-up` in the monorepo root. For more information on the local devnet, see [devnet.md](../../specs/meta/devnet.md).
+
+### Tools
+
+#### Layout Locking
+
+We use a system called "layout locking" as a safety mechanism to prevent certain contract variables from being moved to different storage slots accidentally.
+To lock a contract variable, add it to the `layout-lock.json` file which has the following format:
+
+```json
+{
+  "MyContractName": {
+    "myVariableName": {
+      "slot": 1,
+      "offset": 0,
+      "length": 32
+    }
+  }
+}
+```
+
+With the above config, the `validate-spacers` script will check that we have a contract called `MyContractName`, that the contract has a variable named `myVariableName`, and that the variable is in the correct position as defined in the lock file.
+You should add things to the `layout-lock.json` file when you want those variables to **never** change.
+Layout locking should be used in combination with diffing the `.storage-layout` file in CI.
+
+#### Gas Snapshots
+
+We use forge's `gas-snapshot` subcommand to produce a gas snapshot for most tests within our suite. CI will check that the gas snapshot has been updated properly when it runs, so make sure to run `pnpm gas-snapshot`!
+
+#### Semver Locking
+
+Many of our smart contracts are semantically versioned. To make sure that changes are not made to a contract without deliberately bumping its version, we commit to the source code and the creation bytecode of its dependencies in a lockfile. Consult the [Style Guide](./STYLE_GUIDE.md#Versioning) for more information about how our contracts are versioned.
+
+#### Storage Snapshots
+
+Due to the many proxied contracts in Optimism's protocol, we automate tracking the diff to storage layouts of the contracts in the project. This is to ensure that we don't break a proxy by upgrading its implementation to a contract with a different storage layout. To generate the storage lockfile, run `pnpm storage-snapshot`.

packages/contracts-bedrock/README.md

@@ -50,78 +50,29 @@ We export contract ABIs, contract source code, and contract deployment informati
 npm install @eth-optimism/contracts-bedrock
 ```
 
-## Development
+## Contributing
 
-### Dependencies
+For all information about working on and contributing to Optimism's smart contracts, please see [CONTRIBUTING.md](./CONTRIBUTING.md)
 
-We work on this repository with a combination of [Hardhat](https://hardhat.org) and [Foundry](https://getfoundry.sh/).
-
-1. Install node modules with pnpm (v8) and Node.js (16+):
-
-```shell
-pnpm install
-```
-
-2. Install the correct version of foundry (defined in the .foundryrc file in the root of this repo.
-
-```shell
-pnpm install:foundry
-```
-
-### Build
-
-```shell
-pnpm build
-```
-
-### Tests
-
-```shell
-pnpm test
-```
-
-### Deployment
+## Deployment
 
 The smart contracts are deployed using `foundry` with a `hardhat-deploy` compatibility layer. When the contracts are deployed,
 they will write a temp file to disk that can then be formatted into a `hardhat-deploy` style artifact by calling another script.
 
-#### Configuration
+### Configuration
 
 Create or modify a file `<network-name>.json` inside of the [`deploy-config`](./deploy-config/) folder.
 By default, the network name will be selected automatically based on the chainid. Alternatively, the `DEPLOYMENT_CONTEXT` env var can be used to override the network name.
 The spec for the deploy config is defined by the `deployConfigSpec` located inside of the [`hardhat.config.ts`](./hardhat.config.ts).
 
-#### Execution
+### Execution
 
 1. Set the env vars `ETH_RPC_URL`, `PRIVATE_KEY` and `ETHERSCAN_API_KEY` if contract verification is desired
 1. Deploy the contracts with `forge script -vvv scripts/Deploy.s.sol:Deploy --rpc-url $ETH_RPC_URL --broadcast --private-key $PRIVATE_KEY`
    Pass the `--verify` flag to verify the deployments automatically with Etherscan.
 1. Generate the hardhat deploy artifacts with `forge script -vvv scripts/Deploy.s.sol:Deploy --sig 'sync()' --rpc-url $ETH_RPC_URL --broadcast --private-key $PRIVATE_KEY`
 
-#### Deploying a single contract
+### Deploying a single contract
 
 All of the functions for deploying a single contract are `public` meaning that the `--sig` argument to `forge script` can be used to
 target the deployment of a single contract.
-
-## Tools
-
-### Layout Locking
-
-We use a system called "layout locking" as a safety mechanism to prevent certain contract variables from being moved to different storage slots accidentally.
-To lock a contract variable, add it to the `layout-lock.json` file which has the following format:
-
-```json
-{
-  "MyContractName": {
-    "myVariableName": {
-      "slot": 1,
-      "offset": 0,
-      "length": 32
-    }
-  }
-}
-```
-
-With the above config, the `validate-spacers` hardhat task will check that we have a contract called `MyContractName`, that the contract has a variable named `myVariableName`, and that the variable is in the correct position as defined in the lock file.
-You should add things to the `layout-lock.json` file when you want those variables to **never** change.
-Layout locking should be used in combination with diffing the `.storage-layout` file in CI.

packages/contracts-bedrock/deploy-config/goerli.json

@@ -5,6 +5,7 @@
   "l1ChainID": 5,
   "l2ChainID": 420,
   "l2BlockTime": 2,
+  "l1BlockTime": 12,
   "maxSequencerDrift": 600,
   "sequencerWindowSize": 3600,
   "channelTimeout": 300,
@@ -36,5 +37,6 @@
   "l2GenesisBlockGasLimit": "0x17D7840",
   "l2GenesisBlockBaseFeePerGas": "0x3b9aca00",
   "eip1559Denominator": 50,
-  "eip1559Elasticity": 10
+  "eip1559Elasticity": 10,
+  "systemConfigStartBlock": 8300214
 }

packages/contracts-bedrock/package.json

@@ -29,6 +29,8 @@
     "slither:triage": "TRIAGE_MODE=1 ./scripts/slither.sh",
     "clean": "rm -rf ./artifacts ./forge-artifacts ./cache ./tsconfig.tsbuildinfo ./tsconfig.build.tsbuildinfo ./test-case-generator/fuzz ./scripts/differential-testing/differential-testing",
     "preinstall": "npx only-allow pnpm",
+    "pre-pr": "pnpm clean && pnpm gas-snapshot && pnpm storage-snapshot && pnpm semver-lock && pnpm autogen:invariant-docs && pnpm lint && (cd ../../op-bindings && make)",
+    "pre-pr:full": "pnpm test && pnpm slither && pnpm validate-deploy-configs && pnpm validate-spacers && pnpm pre-pr",
     "lint:ts:check": "eslint . --max-warnings=0",
     "lint:forge-tests:check": "tsx scripts/forge-test-names.ts",
     "lint:contracts:check": "pnpm lint:fix && git diff --exit-code",