Skip to content

Op deployer updates #1020

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 11 commits into from
Oct 29, 2024
Merged

Op deployer updates #1020

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
9919df7
adding todos for op-deployer docs
sbvegan Oct 21, 2024
cc6f732
adding a todo
sbvegan Oct 21, 2024
694af66
Merge branch 'main' into op-deployer-updates
sbvegan Oct 25, 2024
35769eb
updating deployer docs
sbvegan Oct 27, 2024
e5e774f
fixing linter
sbvegan Oct 27, 2024
365ac3c
Small cleanups and describe bootstrapping
mslipper Oct 28, 2024
455433f
adding tess's suggestions
sbvegan Oct 28, 2024
9f5ac79
Merge branch 'main' into op-deployer-updates
sbvegan Oct 28, 2024
076632c
Apply suggestions from code review
sbvegan Oct 28, 2024
877e8c4
addressing superchain-registry callout
sbvegan Oct 28, 2024
1bbc4b4
Apply suggestions from code review
sbvegan Oct 28, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
147 changes: 96 additions & 51 deletions pages/builders/chain-operators/tools/op-deployer.mdx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,21 +2,23 @@
title: Deployer
lang: en-US
tags: ["op-deployer","eng-platforms"]
description: Learn how op-deployer can simplify deployment of the OP Stack.
description: Learn how op-deployer can simplify deploying a standard OP Stack Chain.
---

import {Callout, Steps} from 'nextra/components'

# Deployer

`op-deployer` simplifies the process of deploying the OP Stack. It works similarly to [Terraform](https://www.terraform.io). Like Terraform, you define a declarative config file called an "intent," then run a
command to apply the intent to your chain. `op-deployer` will compare the state of your chain against the intent,
and make whatever changes are necessary for them to match.
`op-deployer` simplifies the process of deploying the OP Stack. It works similarly to [Terraform](https://www.terraform.io). Like Terraform, you define a declarative config file called an "intent," then run a command to apply the intent to your chain. `op-deployer` will compare the state of your chain against the intent, and make whatever changes are necessary for them to match. In its current state, it is intended to deploy new standard chains that utilize the Superchain wide contracts.

## Installation

`op-deployer` is currently under active development, and must be compiled from source. Assuming you have the Go
toolchain installed, you can install `op-deployer` by following these steps:
The recommended way to install `op-deployer` is to download the latest release from the monorepo's
[release page](https://github.com/ethereum-optimism/optimism/releases). To install a release, download the binary
for your platform then extract it somewhere on your `PATH`. The rest of this tutorial will assume that you have
installed `op-deployer` using this method.

To alternatively install from source, follow the steps below. You will need to install the Go toolchain and `just` as prerequisites.

<Steps>
### **Clone the monorepo**:
Expand All @@ -32,94 +34,137 @@ toolchain installed, you can install `op-deployer` by following these steps:
Run the following commands to build the binary:

```bash
cd op-chain-ops
make op-deployer
cd op-deployer
just build
```

### (Optional) move `op-deployer` into `$PATH`
The binary will be in the `bin` directory.
</Steps>

Run the following command to move the `op-deployer` binary into your `$PATH`. Note that the path for your system
may be different:
## Deployment usage

```bash
sudo mv ./bin/op-deployer /usr/local/bin/op-deployer
```
</Steps>
The base use case for `op-deployer` is deploying new OP Chains. This process is broken down into three steps:

## Usage
<Steps>

### Configuring your chain
### `init`: configure your chain

To get started with `op-deployer`, you need to create an intent file that outlines your desired chain configuration. You can use the built-in `op-deployer` utility to generate this file. Just run the following command to create an example intent file for a development chain:
To get started with `op-deployer`, create an intent file that defines your desired chain configuration. Use the built-in `op-deployer` utility to generate this file:

```
op-deployer init --l1-chain-id 11155111 --l2-chain-ids 12345 --workdir .deployer
./bin/op-deployer init --l1-chain-id 11155111 --l2-chain-ids <l2-chain-id> --workdir .deployer
```

This command will create a directory called `.deployer` in your current working directory containing the intent file
and an empty `state.json` file. `state.json` is populated with the results of your deployment, and never needs to
be edited directly.
This command will create a directory called `.deployer` in your current working directory containing the intent file and an empty `state.json` file. `state.json` is populated with the results of your deployment, and never needs to be edited directly.

Your intent file will need to be modified to your parameters, but it will initially look something like this:

<Callout type="warning">
Do not use the default addresses in the intent for a production chain! They are generated from the `test... junk`
mnemonic. **Any funds they hold will be stolen on a live chain.**
</Callout>

Your intent file will look something like this:

```toml
deploymentStrategy = "live" # Deploying a chain to a live network i.e. Sepolia
l1ChainID = 11155111 # The chain ID of the L1 chain you'll be deploying to
fundDevAccounts = true # Whether or not to fund dev accounts using the test... junk mnemonic on L2.
contractsRelease = "op-contracts/v1.6.0" # The version of the smart contracts to deploy.
l1ContractsLocator = "tag://op-contracts/v1.6.0" # L1 smart contracts versions
l2ContractsLocator = "tag://op-contracts/v1.7.0-beta.1+l2-contracts" # L2 smart contracts versions

# Delete this table if you are using the shared Superchain contracts on the L1
# If you are deploying your own SuperchainConfig and ProtocolVersions contracts, fill in these details
[superchainRoles]
proxyAdminOwner = "0xb9cdf788704088a4c0191d045c151fcbe2db14a4"
protocolVersionsOwner = "0x85d646ed26c3f46400ede51236d8d7528196849b"
guardian = "0x8c7e4a51acb17719d225bd17598b8a94b46c8767"

# List of L2s to deploy. op-deployer can deploy multiple L2s at once
[[chains]]
# Your chain's ID, encoded as a 32-byte hex string
id = "0x0000000000000000000000000000000000000000000000000000000000003039"
# Various ownership roles for your chain. When you use op-deployer init, these roles are generated using the
# test... junk mnemonic. You should replace these with your own addresses for production chains.
[chains.roles]
proxyAdminOwner = "0x7759a8a43aa6a7ee9434ddb597beed64180c40fd"
systemConfigOwner = "0x8e35d9523a0c4c9ac537d254079c2398c6f3b35f"
governanceTokenOwner = "0x7759a8a43aa6a7ee9434ddb597beed64180c40fd"
unsafeBlockSigner = "0xbb19dce4ce51f353a98dbab31b5fa3bc80dc7769"
batcher = "0x0e9c62712ab826e06b16b2236ce542f711eaffaf"
proposer = "0x86dfafe0689e20685f7872e0cb264868454627bc"
challenger = "0xf1658da627dd0738c555f9572f658617511c49d5"
# Your chain's ID, encoded as a 32-byte hex string
id = "0x0000000000000000000000000000000000000000000000000000000000003039"
# Update the fee receipiant contract
baseFeeVaultRecipient = "0x0000000000000000000000000000000000000000"
l1FeeVaultRecipient = "0x0000000000000000000000000000000000000000"
sequencerFeeVaultRecipient = "0x0000000000000000000000000000000000000000"
eip1559Denominator = 50
eip1559Elasticity = 6
# Various ownership roles for your chain. When you use op-deployer init, these roles are generated using the
# test... junk mnemonic. You should replace these with your own addresses for production chains.
[chains.roles]
l1ProxyAdminOwner = "0x1a66b55a4f0139c32eddf4f8c60463afc3832e76"
l2ProxyAdminOwner = "0x7759a8a43aa6a7ee9434ddb597beed64180c40fd"
systemConfigOwner = "0x8e35d9523a0c4c9ac537d254079c2398c6f3b35f"
unsafeBlockSigner = "0xbb19dce4ce51f353a98dbab31b5fa3bc80dc7769"
batcher = "0x0e9c62712ab826e06b16b2236ce542f711eaffaf"
proposer = "0x86dfafe0689e20685f7872e0cb264868454627bc"
challenger = "0xf1658da627dd0738c555f9572f658617511c49d5"

```

By default, `op-deployer` will fill in all other configuration variables with those that match the [standard configuration](https://specs.optimism.io/protocol/configurability.html). You can override these default settings by adding them to your intent file using the table below:

```toml
[globalDeployOverrides]
l2BlockTime = 1 # 1s L2blockTime is also standard, op-deployer defaults to 2s
```

See the code comments above for explanations of each field. By default, `op-deployer` will fill in all other configuration variables
with those that match our standard config. You can override these defaults by adding them to your intent file, but
that won't be covered here.
You can also do chain by chain configurations in the `chains` table.

### Applying your intent
### `apply`: deploy your chain

Now that you've created your intent file, you can apply it to your chain:
<Callout type="info">
Hardware wallets are not supported, but you can use ephemeral hot wallets since this deployer key has no privileges.
</Callout>

Now that you've created your intent file, you can apply it to your chain to deploy the L1 smart contracts:

```
op-deployer apply --workdir .deployer --l1-rpc-url <rpc-url> --private-key <private key hex>
```

Hardware wallets are not supported, but you can use ephemeral hot wallets since this deployer key has no privileges.

This command will deploy the OP Stack to L1. It will deploy all L2s specified in the intent file. Superchain
configuration will be set to the Superchain-wide defaults - i.e., your chain will be opted into the [Superchain pause](https://specs.optimism.io/protocol/superchain-configuration.html#pausability)
and will use the same [protocol versions](https://github.com/ethereum-optimism/specs/blob/main/specs/protocol/superchain-upgrades.md)
address as other chains on the Superchain.

### Generating genesis files
### `inspect`: generate genesis files and chain information

<Callout type="info">
To add your chain to the [Superchain Registry](https://github.com/ethereum-optimism/superchain-registry) you will need to provide the chain artifacts. To get these chain artifacts, you will need to write the output of these commands to new files.
</Callout>

With the contracts deployed, you can generate a genesis file for any of your L2s. Run the following command to do so:
Inspect the `state.json` file by navigating to your working directory. With the contracts deployed, generate the genesis and rollup configuration files by running the following commands:"

```
./bin/op-deployer inspect genesis <l2-chain-id> --outfile genesis.json
cd .deployer
op-deployer --workdir .deployer inspect genesis <l2-chain-id> > genesis.json
op-deployer --workdir .deployer inspect rollup <l2-chain-id> > rollup.json
```

This will write the genesis file to `genesis.json`. You can change the `--outfile` parameter to write it somewhere
else. You can run another member of the `inspect` family, `rollup`, to get the `rollup.json` file:
Now that you have your `genesis.json` and `rollup.json` you can spin up a node on your network. You can also use the following inspect subcommands to get additional data:

```
./bin/op-deployer inspect rollup <l2-chain-id> --outfile rollup.json
op-deployer --workdir .deployer inspect l1 <l2-chain-id> # outputs all L1 contract addresses for an L2 chain
op-deployer --workdir .deployer inspect deploy-config <l2-chain-id> # outputs the deploy config for an L2 chain
op-deployer --workdir .deployer inspect l2-semvers <l2-chain-id> # outputs the semvers for all L2 chains
```
</Steps>

## Bootstrap usage

You can also use `op-deployer` to deploy the contracts needed to run the `init`... `apply` flow on new chains. This process, called 'bootstrapping,' is useful when you want to use `op-deployer` with L3s, new testnets, or other custom settlement chains.

## More information
### OPCM bootstrap

`op-deployer` uses the OP Contracts Manager (OPCM) under the hood to deploy contracts.
To deploy OPCM to a new chain, run the following command:

```bash
op-deployer bootstrap opcm \
--l1-rpc-url <mainnet-rpc-url> \
--private-key <deployer-private-key> \
--artifacts-locator tag://op-contracts/v1.6.0
```

## Next steps

Expand Down
3 changes: 3 additions & 0 deletions words.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -60,6 +60,7 @@ Chugsplash
Clabby
codebases
collateralized
complie
compr
COMPUTEPENDINGBLOCK
computependingblock
Expand Down Expand Up @@ -154,6 +155,7 @@ Inator
inator
INFLUXDBV
influxdbv
initally
initcode
IPCDISABLE
ipcdisable
Expand Down Expand Up @@ -325,6 +327,7 @@ safedb
Schnorr
secp
SELFDESTRUCT
Sendrawtransactionconditional
SEPOLIA
Sepolia
sepolia
Expand Down
Loading