feat(docs/op-stack): Add op-proposer

In addition:
- Change `op-geth` to run in archive mode
- Usability improvements

docs/op-stack/src/docs/build/explorer.md

@@ -11,7 +11,8 @@ One easy way to do this is to use [Blockscout](https://www.blockscout.com/).
 ### Archive mode
 
 Blockscout expects to interact with an Ethereum execution client in [archive mode](https://www.alchemy.com/overviews/archive-nodes#archive-nodes).
-To create such a node, follow the [directions to add a node](./getting-started.md#adding-nodes), but in the command you use to start `op-geth` replace:
+If your `op-geth` is running in full mode, you can create a separate archive node.
+To do so, follow the [directions to add a node](./getting-started.md#adding-nodes), but in the command you use to start `op-geth` replace:
 
 ```sh
 	--gcmode=full \

docs/op-stack/src/docs/build/getting-started.md

@@ -304,13 +304,32 @@ We’re almost ready to run our chain! Now we just need to run a few commands to
 
 Everything is now initialized and ready to go!
 
-## Run op-geth
 
-Whew! We made it. It’s time to run `op-geth` and get our system started.
+## Run the node software
 
-Run `op-geth` with the following command. Make sure to replace `<SEQUENCER>` with the address of the `Sequencer` account you generated earlier.
+There are four components that need to run for a rollup.
+The first two, `op-geth` and `op-node`, have to run on every node.
+The other two, `op-batcher` and `op-proposer`, run only in one place, the sequencer that accepts transactions.
+
+Set these environment variables for the configuration
+
+| Variable       | Value |
+| -------------- | - 
+| `SEQ_ADDR`     | Address of the `Sequencer` account
+| `SEQ_KEY`      | Private key of the `Sequencer` account
+| `BATCHER_KEY`  | Private key of the `Batcher` accounts, which should have at least 1 ETH
+| `PROPOSER_KEY` | Private key of the `Proposer` account
+| `GOERLI_RPC`   | URL for the L1 (such as Goerli) you're using
+| `RPC_KIND`     | The type of L1 server to which you connect, which can optimize requests. Available options are `alchemy`, `quicknode`, `parity`, `nethermind`, `debug_geth`, `erigon`, `basic`, and `any`
+| `L2OO_ADDR`    | The address of the `L2OutputOracleProxy`, available at `~/optimism/packages/contracts-bedrock/deployments/getting-started/L2OutputOracleProxy.json
+
+### `op-geth`
+
+Run `op-geth` with the following commands.
 
 ```bash
+cd ~/op-geth
+
 ./build/bin/geth \
 	--datadir ./datadir \
 	--http \
@@ -324,7 +343,7 @@ Run `op-geth` with the following command. Make sure to replace `<SEQUENCER>` wit
 	--ws.origins="*" \
 	--ws.api=debug,eth,txpool,net,engine \
 	--syncmode=full \
-	--gcmode=full \
+	--gcmode=archive \
 	--nodiscover \
 	--maxpeers=0 \
 	--networkid=42069 \
@@ -336,13 +355,25 @@ Run `op-geth` with the following command. Make sure to replace `<SEQUENCER>` wit
 	--password=./datadir/password \
 	--allow-insecure-unlock \
 	--mine \
-	--miner.etherbase=<SEQUENCER> \
-	--unlock=<SEQUENCER>
+	--miner.etherbase=$SEQ_ADDR \
+	--unlock=$SEQ_ADDR
 ```
 
 And `op-geth` should be running! You should see some output, but you won’t see any blocks being created yet because `op-geth` is driven by the `op-node`. We’ll need to get that running next.
 
-### Reinitializing op-geth
+::: tip Why archive mode?
+
+Archive mode takes more disk storage than full mode.
+However, using it is important for two reasons:
+
+- The `op-proposer` requires access to the full state.
+  If at some point `op-proposer` needs to look beyond 256 blocks in the past (8.5 minutes in the default configuration), for example because it was down for that long, we need archive mode.
+
+- The [explorer](./explorer.md) requires archive mode.
+
+:::
+
+#### Reinitializing op-geth
 
 There are several situations are indicate database corruption and require you to reset the `op-geth` component:
 
@@ -374,13 +405,13 @@ This is the reinitialization procedure:
 1. Start `op-node`
 
 
-## Run op-node
+### `op-node`
 
 Once we’ve got `op-geth` running we’ll need to run `op-node`. Like Ethereum, the OP Stack has a consensus client (the `op-node`) and an execution client (`op-geth`). The consensus client drives the execution client over the Engine API.
 
-Head over to the `op-node` package and start the `op-node` using the following command. Replace `<SEQUENCERKEY>` with the private key for the `Sequencer` account, replace `<RPC>` with the URL for your L1 node, and replace `<RPCKIND>` with the kind of RPC you’re connected to. Although the `l1.rpckind` argument is optional, setting it will help the `op-node` optimize requests and reduce the overall load on your endpoint. Available options for the `l1.rpckind` argument are `"alchemy"`, `"quicknode"`, `"quicknode"`, `"parity"`, `"nethermind"`, `"debug_geth"`, `"erigon"`, `"basic"`, and `"any"`.
-
 ```bash
+cd ~/optimism/op-node
+
 ./bin/op-node \
 	--l2=http://localhost:8551 \
 	--l2.jwt-secret=./jwt.txt \
@@ -392,9 +423,9 @@ Head over to the `op-node` package and start the `op-node` using the following c
 	--rpc.port=8547 \
 	--p2p.disable \
 	--rpc.enable-admin \
-	--p2p.sequencer.key=<SEQUENCERKEY> \
-	--l1=<RPC> \
-	--l1.rpckind=<RPCKIND>
+	--p2p.sequencer.key=$SEQ_KEY \
+	--l1=$GOERLI_RPC \
+	--l1.rpckind=$RPC_KIND
 ```
 
 Once you run this command, you should start seeing the `op-node` begin to process all of the L1 information after the starting block number that you picked earlier. Once the `op-node` has enough information, it’ll begin sending Engine API payloads to `op-geth`. At that point, you’ll start to see blocks being created inside of `op-geth`. We’re live!
@@ -420,22 +451,17 @@ Once you have multiple nodes, it makes sense to use these command line parameter
 
 
 
-## Run op-batcher
+### `op-batcher`
 
-The final component necessary to put all the pieces together is the `op-batcher`. The `op-batcher` takes transactions from the Sequencer and publishes those transactions to L1. Once transactions are on L1, they’re officially part of the Rollup. Without the `op-batcher`, transactions sent to the Sequencer would never make it to L1 and wouldn’t become part of the canonical chain. The `op-batcher` is critical!
+The `op-batcher` takes transactions from the Sequencer and publishes those transactions to L1. Once transactions are on L1, they’re officially part of the Rollup. Without the `op-batcher`, transactions sent to the Sequencer would never make it to L1 and wouldn’t become part of the canonical chain. The `op-batcher` is critical!
 
-1. Head over to the `op-batcher` package inside the Optimism Monorepo:
+It is best to give the `Batcher` at least 1 Goerli ETH to ensure that it can continue operating without running out of ETH for gas.
 
-    ```bash
-    cd ~/optimism/op-batcher
-    ```
 
-1. And run the `op-batcher` using the following command. 
-   Replace `<RPC>` with your L1 node URL and replace `<BATCHERKEY>` with the private key for the `Batcher` account that you created and funded earlier. 
-   It’s best to give the `Batcher` at least 1 Goerli ETH to ensure that it can continue operating without running out of ETH for gas.
+```bash
+cd ~/optimism/op-batcher
 
-    ```bash
-    ./bin/op-batcher \
+./bin/op-batcher \
     --l2-eth-rpc=http://localhost:8545 \
     --rollup-rpc=http://localhost:8547 \
     --poll-interval=1s \
@@ -447,10 +473,9 @@ The final component necessary to put all the pieces together is the `op-batcher`
     --rpc.port=8548 \
     --rpc.enable-admin \
     --max-channel-duration=1 \
-        --target-l1-tx-size-bytes=2048 \
-        --l1-eth-rpc=<RPC> \
-        --private-key=<BATCHERKEY>
-    ```
+    --l1-eth-rpc=$GOERLI_RPC \
+    --private-key=$BATCHER_KEY
+```
 
    ::: tip Controlling batcher costs
 
@@ -460,6 +485,32 @@ The final component necessary to put all the pieces together is the `op-batcher`
 
    :::
 
+### `op-proposer`
+
+Now start `op-proposer`, which proposes new state roots.
+
+1. Head over to the `op-proposer` package inside the Optimism Monorepo:
+
+    ```bash
+    cd ~/optimism/op-proposer
+    ```
+
+1. And run the `op-proposer` using the following command, using these parameters: 
+
+
+
+    ```bash
+    ./bin/op-proposer \
+        --poll-interval 12s \
+        --rpc.port 8560 \
+        --rollup-rpc http://localhost:8547 \
+        --l2oo-address $L2OO_ADDR \
+        --private-key $PROPOSER_KEY
+        --l1-eth-rpc $GOERLI_RPC \        
+    ```
+
+
+
 
 ## Get some ETH on your Rollup