op-deployer + opcm documentation

pages/builders/chain-operators/tools/_meta.json

@@ -1,5 +1,6 @@
 {
   "op-challenger": "Configure Challenger For Your Chain",
-  "op-conductor": "op-conductor",
+  "op-conductor": "Conductor",
+  "op-deployer": "Deployer",
   "explorer": "Block Explorer"
 }

pages/builders/chain-operators/tools/op-deployer.mdx

@@ -0,0 +1,126 @@
+---
+title: Deployer
+lang: en-US
+tags: ["op-deployer","eng-platforms"]
+description: Learn how op-deployer can simplify deployment of the OP Stack.
+---
+
+import {Callout, Steps} from 'nextra/components'
+
+# Deployer
+
+`op-deployer` simplifies the process of deploying the 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.
+
+## 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:
+
+<Steps>
+    ### **Clone the Monorepo**:
+
+    Run the following command to clone the monorepo:
+
+    ```bash
+    git clone https://github.com/ethereum-optimism/optimism.git
+    ```
+
+    ### **Build the Binary**:
+
+    Run the following commands to build the binary:
+
+    ```bash
+    cd op-chain-ops
+    make op-deployer
+    ```
+
+    ### (Optional) Move `op-deployer` Into `$PATH`
+
+    Run the following command to move the `op-deployer` binary into your `$PATH`. Note that the path for your system
+    may be different:
+
+    ```bash
+    sudo mv ./bin/op-deployer /usr/local/bin/op-deployer
+    ```
+</Steps>
+
+## Usage
+
+### Configuring your Chain
+
+The first step to using `op-deployer` is to create an intent file. The intent file describes how you want your chain
+to look when it is done being deployed. `op-deployer` has a utility for this. Run the following command to generate
+an example intent file for a development chain:
+
+```
+op-deployer init --l1-chain-id 11155111 --l2-chain-ids 12345 --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.
+
+Your intent file will look something like this:
+
+```toml
+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.
+
+# 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"
+```
+
+See the comments for what each field does. 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.
+
+### Applying your Intent
+
+Now that you've created your intent file, you can apply it to your chain. Run the following command to do so:
+
+```
+op-deployer apply --workdir .deployer --l1-rpc-url <rpc-url> --private-key <private key hex>
+```
+
+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
+and will use the same protocol versions address as other chains on the Superchain.
+
+### Generating Genesis Files
+
+With the contracts deployed, you can generate a genesis file for any of your L2s. Run the following command to do so:
+
+```
+./bin/op-deployer inspect genesis <l2-chain-id> --outfile genesis.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:
+
+```
+./bin/op-deployer inspect rollup <l2-chain-id> --outfile rollup.json
+```
+
+## More Information
+
+`op-deployer` uses the OP Contracts Manager (OPCM) under the hood to deploy contracts.
+
+## Next Steps
+
+*   For more details, check out the tool and documentation in the [op-deployer repository](https://github.com/ethereum-optimism/optimism/tree/develop/op-chain-ops/cmd/op-deployer).
+*   For more information on OP Contracts Manager, refer to the [OPCM documentation](/stack/experimental/opcm).

pages/stack/_meta.json

@@ -8,5 +8,10 @@
   "protocol": "Protocol",
   "transactions": "Transactions",
   "security": "Security",
-  "operators": "Operators"
+  "operators": "Operators",
+  "--- Experimental": {
+    "title": "Experimental",
+    "type": "separator"
+  },
+  "opcm": "OP Contracts Manager"
 }

pages/stack/opcm.mdx

@@ -0,0 +1,29 @@
+---
+title: OP Contracts Manager
+lang: en-US
+tags: ["opcm","eng-security"]
+description: Learn how OP Contracts Manager deploys of the OP Stack with one transaction.
+---
+
+import { Callout, Tabs, Steps } from 'nextra/components'
+
+# OP Contracts Manager
+
+The OP Contracts Manager is a contract that deploys the L1 contracts for an OP Stack chain in a single transaction. It provides a minimal set of user-configurable parameters to ensure that the resulting chain meets the standard configuration requirements.
+
+The version deployed is always a governance-approved contract release. The set of governance approved contract releases can be found on the Optimism Monorepo releases page, and is the set of releases named `op-contracts/vX.Y.Z`.
+
+## Purpose
+
+OPCM simplifies the L1 contract deployments for new OP Stack chains. It addresses three aspects of deploying the OP Stack's L1 contracts:
+
+1.  **Deploy Superchain Contracts.** Superchain contracts are shared between many OP chains, so this occurs only occasionally in production.
+2.  **Deploy Shared Implementation Contracts.** This occurs once per contracts release in production.
+3.  **Deploy OP Chain Contracts.** This occurs for every OP chain deployment in production.
+
+In a future iteration, it also is meant to handle upgrading the smart contracts.
+
+## Learn more
+
+*   Checkout the [OPCM specs](https://specs.optimism.io/experimental/op-contracts-manager.html)
+*   Checkout the [OPCM design document](https://github.com/ethereum-optimism/design-docs/blob/main/protocol/op-contracts-manager-arch.md)

words.txt

@@ -227,6 +227,8 @@ nosyncserve
 Numba
 Offchain
 offchain
+OPCM
+opcm
 Openfort
 oplabs
 opnode's
@@ -340,6 +342,7 @@ syncmode
 SYNCTARGET
 synctarget
 syscalls
+Terraform
 therealbytes
 Thirdweb
 threadcreate