parameterize project

Switch to artifact registry

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

Address this warning: Unknown section [default] found in foundry.toml. This notation for profiles has been deprecated and may result in the profile not being registered in future versions. Please use [profile.default] instead or run .

* op-bindings: regenerate

The build was missed someplace and is now breaking ci everywhere

* ci: build monorepo with op-bindings change

Due to a new version of the openzeppelin contracts,
the docs need to be regenerated. Each time that the
contracts are built, these files are generated.
Merging this commit will make dev on alternative things
less noisy.

contracts: update docs

The `js-builder` and `go-builder` are no longer
used, they were replaced by `ci-builder`. Their
dockerfiles have already been deleted from the
repo, this now deletes their reference in the CI
docker build pipeline.

Use only 1 initializable instead of two different initializable
imports. Using contracts with the same name will break hardhat.

The two different initializable imports were:

```solidity
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
```

```solidity
import { Initializable } from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
```

This standardizes on not using `contracts-upgradeable`.

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

* contracts-bedrock: fix build

Standardize on the upgradable initializable since the contracts
are technically upgradable it is more clear. There are no real
implementation differences between the upgradable and standard
initializable implementations. `OwnableUpgradable` is `initializable`
imported from the upgradable package, and the `L2OutputOracle`
inherits from `OwnableUpgradable`. This means that the only
way to standardize on a single implementation of `Initializable`
is to use the upgradable version.

This also bumps the version of the openzeppelin contracts
dependency because they refactored the initializable implementation
and made it easier to understand.

https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/releases/tag/v4.7.0
OpenZeppelin/openzeppelin-contracts#3450

* op-bindings: regenerate

op-bindings: speed up build

ci: remove publishing of deprecated images

The `package.json` defines the files that are included
in the `npm` package, the previous glob did not match
all of the typechain artifacts.

contracts-bedrock: update hardhat forge dep

Updates the hh forge plugin to the following:

```
"@foundry-rs/hardhat-forge": "^0.1.16"
```

Includes bugfixes for when multiple imports
of contracts with the same name happens.

Adds a helper to the makefile for deleting all of the js
deps. This is useful for when checking out a new branch
and ensuring that the deps are up to date. I find
myself doing this often manually, so adding a make command
makes sense.

contracts-bedrock: update hardhat-forge plugin

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

This was being incorrectly set in the rollup json relative to the
HD path supplied to the batcher was. This resulted in L2 reorgs
on the sequencer & the inability to send L2 transactions.

Co-authored-by: Mark Tyneway <mark.tyneway@gmail.com>

contracts-bedrock: fix typechain export

Implements a simple `OpNodeProvider` that can be used
to query the op-node. It is used as part of a ci check
against the devnet. It should add some more health related
things, now it just prints of rpc responses. This will
help to debug things.

Modularize the build of `contracts-bedrock` so that
more packages can be dev deps. Make it so that the differential
testing build is different than the typescript build.

This is part of the larger sdk integration work, split out
into its own smaller PR.

Move away from using a nested api on the messenger
and instead use an imported function

contracts-bedrock: modularize build

Bedrock goerli 96f44f7

integration-tests: modularize

…ules

makefile: `clean-node-modules`

core-utils,contracts-bedrock,ci: OpNodeProvider + check

This updates the hardhat task `genesis-l2` to handle
setting the immutables in the deployed bytecode. This
is necessary because the predeploys "live" in the L2
state and are not deployed. Any immutables must be manually
placed into the bytecode by looking at the compiler output
and then finding the offsets and slicing in the values.

A high level API is exposed for setting arbitrary immutables
with the `replaceImmutables` function. This was inspired by
smock's `computeStorageSlots`.

Longer term, this code will be rewritten in go and be able to
operate on either a LevelDB database (upgrade an existing system)
or a `genesis.json` (good for starting a new network). This is
a requirement because the state surgery is large enough such that
it must bind directly to LevelDB and be in a language that is
relatively fast.

…bles

contracts-bedrock: in place handling of immutables

Fixes foundry config issue so that warnings go away during
compilation. Also cleans up warnings when running tests.

nomad-xyz/ExcessivelySafeCall@81cd99c

* ops: Use starting L1 Block for timestamp everywhere

This transitions the starting timestamp to a new flow. The L2 rollup
is anchored on a L1 block. The L2 genesis block & rollup config use
the timestamp of the L1 start block as the their time. Properly
threading this through the HH tasks is a little tricky but possible.
This is because we have two flows: creating a L1 network & placing
the rollup on that and creating a rollup on an existing L1 network
(like goerli). There is still a L1 starting time for the first flow.

This also fixes a circular dependcy that previously existed. The
starting timestamp was provided and served as the starting timestamp
for the L1 genesis & the "L2 Starting Time" in the L2 Output Oracle.
The actual L2 genesis & rollup start time were based on when the
Optimism Portal contract was deployed (after the L2 Output Oracle
contract must have been deployed). The rollup is resilient to being
started before contracts are fully deployed, so using a specific
L1 block as the start is the cleanest solution I have seen.

* Fix lint

* Update packages/contracts-bedrock/deploy-config/goerli.ts

* Add undefined checks to l1StartingBlockTag

* lint

* fix checks

Co-authored-by: Matthew Slipper <me@matthewslipper.com>
Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

* test(ctb): change gasLimit arg to uint256

* test(ctb): Set maximum diff fuzz gasLimit to 30MM

* test(ctb): Set maximum diff fuzz value to 120MM eth

* ctb: Address compiler warnings

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

* op-batcher: Enable optional pprof server

* op-proposer: Enable optional pprof server

* op-node: Eanble optional pprof server

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

It was being deployed with the implementation address
of the `L2OutputOracle` instead of the proxy. This
was preventing output commitments to actually be posted.

A hardhat task that lists off important information.
Very helpful for debugging live networks.

Usage:

```
$ npx hardhat watch --network devnetL1
```

It will print off information as the chain makes progress.

Deletes an old config option and also changes the poll
interval on the `op-proposer` to `1s` so that it submits
outputs faster. I found that the proposer will lag a lot,
especially if the commitment interval is small.

We need to carefully consider the implications of the commitment
interval and understand if it can be updated dynamically or not.

deps: update excessively-safe-call

`slither` crashes on new solidity features, one is used
in the forge tests. Not exactly sure what it is, but
this will prevent that problem by moving the tests
to a temp dir when running slither and then moving them
back.

Also adds a new `deployer` network for use with automation.

…ript (#3148)

* ci: Tag cloudbuild images with the commit SHA

* contracts-bedrock: Fix provider usage in L2OutputOracle deployment script

`getDefaultProvider()` returns a fallback mainnet provider, which doesn't work.

Builds on #3147.

Update to commit 64fe4ac

https://github.com/foundry-rs/foundry/tree/64fe4acc97e6d76551cea7598c201f05ecd65639
foundry-rs/foundry@64fe4ac

This update is pulled in so that the new config file format can be
adopted.

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

contracts-bedrock: fix slither

The gas snapshot check was disabled in CI because it
would cause a lot of merge conflicts. Now that there
is no rush to change the contracts, we should re-enable
the check. Also commit in the latest snapshot.

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

* add wsteth to sdk

* changeset

Co-authored-by: Will Cory <willcory@Wills-MacBook-Pro.local>

ops-bedrock: simple config fixes

contracts-bedrock: add watch task

contracts-bedrock: fix deployment

* op-node: Add p2p utils

* Update op-node/cmd/p2p/cmd.go

Co-authored-by: Joshua Gutow <jgutow@optimism.io>

* Update op-node/cmd/p2p/cmd.go

Co-authored-by: Joshua Gutow <jgutow@optimism.io>

* lint

* fix devnet

Co-authored-by: Joshua Gutow <jgutow@optimism.io>

This reverts commit f7fcf8a.

This now uses a passed in timestamp for PreparePayloadAttributes.
This is important because when generating a payload attributes from
a batch it should be using the timestamp of the batch, not the
L2 parent + block time. When we are creating payloads based on the
L2 parent time, that is easy to set there instead of pulling it into
this function.

This enabled/exacerbated a divergence bug where the timestamp of the
batch was not the timestamp that was being set inside
PreparePayloadAttributes.

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

* op-node: Add p2p utils

* Update op-node/flags/flags.go

Co-authored-by: Diederik Loerakker <proto@protolambda.com>

Co-authored-by: Diederik Loerakker <proto@protolambda.com>

Emit an additional event during `initiateWithdrawal` that includes
the withdrawal hash so that it is easy to observe changes to the
`sentMessages` mapping.

…xtension

contracts-bedrock: L2ToL1MessagePasser event extension

#3155)

* contracts-bedrock: add forge contract verification support

Add etherscan contract verification for the hh/foundry
compiler toolchain. This will eventually be upstreamed,
but is implemented here to ensure that it works thoroughly
first.

To run the task:

```
export ETHERSCAN_API_KEY=$(cat api-key.txt)
$ npx hardhat forge-verify --network goerli
```

In the future, other contract verification backends
will be added to forge and this task will be updated
to support them.

Example contract that was verified: https://goerli.etherscan.io/address/0x1234662682c85fa6fb375416d14db965eba222ba#code

An individual contract can be targeted instead of all of them
with the `--contract` flag. If hardhat deploy has configured
external deployments, forge will not be able to verify them.
It may be possible to implement that in the future.

* contracts-bedrock: modularize tasks

* core-utils: add bedrock types

* sdk: implement bedrock functionality

* tests: update for bedrock

* sdk: add hardhat deposit task

* circleci: run deposit task in ci

* tsconfig: cleanup

* contracts-bedrock: make commitment interval larger

* changeset: add

Co-authored-by: Mark Tyneway <mark.tyneway@gmail.com>

* op-node: Add channel frame serialization

This creates a struct & serialization & deserialization methods
for it. This is to replace the current serialization code which
is embedded in more complex methods.

The reading is done with a reader API instead of a bytes API because
the frame is variable length & is originally merged together with
other frames without a clean division. The writing API uses a
writer for simplicity (but is not required).

This lays the groundwork for easily switching to fixed int sizes.

* op-node: Use channel frame deserialization

This uses the new channel frame object for deserialization. Some
of the API interaction is a little weird in the channel_bank
IngestData loop, but the code is not able to be easily tested and
upgraded.

* op-node: Use channel frame in serialization

This uses the default implementation (through a struct) rather
than the custom logic. It might make sense to use a slightly
different API for serialization than deserialization given the
inputs, but splitting out the logic into it's own function is
still an improvement.

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

* op-node: Derivation metrics

Adds support for the following batch derivation metrics:

- 0/1 gauge for if the derivation is idle
- Count of total pipeline resets
- Count of total unsafe payloads received
- Count of total derivation errors
- Gauge tracking the various L1/L2 safe/unsafe heads

* review updates + more metrics

This will allow us to measure opnode throughput.

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

Co-authored-by: Will Cory <willcory@Wills-MacBook-Pro.local>
Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

* style(specs): fix toc/lint in specs, update CI

style(specs): lint/toc/link fixes

style(readme): fix bedrock contracts link

chore(specs): specs lint scripts

chore(specs): update CI jobs to use new lint scripts and unsilence links linter

style(specs): fix toc, fix quotes in markdown lint script

* yarn: update linting dependencies

* specs: add minimal batch submitter spec, fix broken links

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

Co-authored-by: Matthew Slipper <me@matthewslipper.com>

* proxyd: Unwrap single RPC batches

* Update backend.go

`no_output_timeout` wasn't being honored because the deposit command produced output on each poll. Instead, use the `timeout` command to kill the process from within the job itself regardless of output.

* op-node: Use unmetered L1 Attributes Transaction

This enables the IsSystemTransaction flag in the L1 Attributes
deposit & updates to the latest version of geth.

* specs updates

* Update specs/deposits.md

* feat: bedrock deposit transaction type update

* bedrock: update geth dependency

* fix(core-utils): bedrock deposit tx encode/decode typescript fixes

* feat(packages/contracts-bedrock): update UserDepositTransaction type and encoding to handle isSystemTransaction bool

* contracts-bedrock: update differential deposit tx solidity <> js fuzzing

* core-utils

* contracts-bedrock

* contracts-bedrock: fix test

* contracts-bedrock: fix differential tests

* contracts-bedrock: fix broken test

* contracts-bedrock: gas snapshot

Co-authored-by: protolambda <proto@protolambda.com>
Co-authored-by: Mark Tyneway <mark.tyneway@gmail.com>

* proxyd: Add frontend rate limiting

To give us more flexibiltiy with rate limiting, proxyd now supports rate limiting of client (frontend) requests in addition to upstream (backend) requests. This PR also gives us the ability to exempt certain user agents/origins from rate limiting.

* lint