Merge branch 'main' into fullnode-guide-updates

gupadhyaya · web-flow · commit 2a82f39eaaae · 2025-01-23T11:24:41.000+04:00
diff --git a/.vitepress/config.ts b/.vitepress/config.ts
@@ -322,8 +322,8 @@ function sidebarHome() {
           link: "/guides/use-rollkit-cli",
         },
         {
-          text: "Create genesis for your rollup",
-          link: "/guides/create-genesis",
+          text: "Use Ignite to create a Rollkit app",
+          link: "/guides/ignite-rollkit",
         },
         {
           text: "Restart your rollup",
@@ -337,17 +337,13 @@ function sidebarHome() {
           text: "Run a rollup full node",
           link: "/guides/full-node",
         },
-        {
-          text: "Run a centralized sequencer",
-          link: "/guides/centralized-sequencer",
-        },
         {
           text: "CometBFT into a Rollkit app",
           link: "/guides/cometbft-to-rollkit",
         },
         {
-          text: "Use Ignite to create a Rollkit app",
-          link: "/guides/ignite-rollkit",
+          text: "Create genesis for your rollup",
+          link: "/guides/create-genesis",
         },
         {
           text: "Configuration",
diff --git a/guides/centralized-sequencer.md b/guides/centralized-sequencer.md
diff --git a/guides/create-genesis.md b/guides/create-genesis.md
@@ -2,43 +2,71 @@
 
 This guide will walk you through the process of setting up a genesis for your rollup. Follow the steps below to initialize your rollup chain, add a genesis account, and start the chain.
 
+## 0. Pre-requisities 
+
+For this guide you need to have a chain directory where you have created and built your chain. 
+
+If you don't have a chain directory yet, you can initialize a simple ignite chain by following [this guide](./ignite-rollkit.md)
+
+:::tip
+This guide will use the simple ignite chain created in linked guide. Make sure to update any relevant variables to match your chain. 
+:::
+
 ## 1. Setting variables
 
-First, set the necessary variables for your chain, here is an example:
+First, set the necessary variables for your chain in the terminal, here is an example:
 
 ```sh
 VALIDATOR_NAME=validator1
-CHAIN_ID=rollup-chain
+CHAIN_ID=gm
 KEY_NAME=rollup-key
 CHAINFLAG="--chain-id ${CHAIN_ID}"
 TOKEN_AMOUNT="10000000000000000000000000stake"
 STAKING_AMOUNT="1000000000stake"
 ```
 
-## 2. Ensuring `rollkit.toml` is present and building entrypoint
+## 2. Rebuild your chain
 
 Ensure that `rollkit.toml` is present in the root of your rollup directory (if not, follow a [Guide](/guides/use-rollkit-cli) to set it up) and run the following command to (re)generate an entrypoint binary out of the code:
 
 ```sh
 rollkit rebuild
 ```
 
-This creates an `entrypoint` binary in the root of your rollup directory. which is used to run all the operations on the rollup chain.
+This (re)creates an `entrypoint` binary in the root of your rollup directory. which is used to run all the operations on the rollup chain.
+
+Ensure that the chain configuration directory is set correctly in the `rollkit.toml` file.
+
+For example:
+
+```sh
+[chain]
+  config_dir = "/Users/you/.gm"
+```
 
-Ensure that the chain configuration directory is set correctly in the `rollkit.toml` file, if you doubt it, you can remove the `rollkit.toml` file and run the following command to generate a new one:
+:::tip
+You can always recreate the `rollkit.toml` file by deleting it and re-running the following command:
 
 ```sh
 rollkit toml init
 ```
+:::
 
 ## 3. Resetting existing genesis/chain data
 
-Reset any existing genesis or chain data:
+Reset any existing chain data:
 
 ```sh
 rollkit tendermint unsafe-reset-all
 ```
 
+Reset any existing genesis data:
+
+```sh
+rm -rf $HOME/.$CHAIN_ID/config/gentx
+rm $HOME/.$CHAIN_ID/config/genesis.json
+```
+
 ## 4. Initializing the validator
 
 Initialize the validator with the chain ID you set:
@@ -84,29 +112,21 @@ rollkit genesis collect-gentxs
 Copy the centralized sequencer address into `genesis.json`:
 
 ```sh
-ADDRESS=$(jq -r '.address' ~/.rollup/config/priv_validator_key.json)
-PUB_KEY=$(jq -r '.pub_key' ~/.rollup/config/priv_validator_key.json)
-jq --argjson pubKey "$PUB_KEY" '.consensus["validators"]=[{"address": "'$ADDRESS'", "pub_key": $pubKey, "power": "1000", "name": "Rollkit Sequencer"}]' ~/.rollup/config/genesis.json > temp.json && mv temp.json ~/.rollup/config/genesis.json
+ADDRESS=$(jq -r '.address' ~/.$CHAIN_ID/config/priv_validator_key.json)
+PUB_KEY=$(jq -r '.pub_key' ~/.$CHAIN_ID/config/priv_validator_key.json)
+jq --argjson pubKey "$PUB_KEY" '.consensus["validators"]=[{"address": "'$ADDRESS'", "pub_key": $pubKey, "power": "1000", "name": "Rollkit Sequencer"}]' ~/.$CHAIN_ID/config/genesis.json > temp.json && mv temp.json ~/.$CHAIN_ID/config/genesis.json
 ```
 
-## 10. Creating a restart script
-
-Create a `restart-rollup.sh` file to restart the chain later, notice the `rollkit.da_address` flag which is the address of the data availability node, for other DA layers it will be a different set of flags (in case of Celestia check out the tutorial [here](/tutorials/celestia-da)):
-
-```sh
-[ -f restart-rollup.sh ] && rm restart-rollup.sh
-
-echo "rollkit start --rollkit.aggregator --rpc.laddr tcp://127.0.0.1:36657 --grpc.address 127.0.0.1:9290 --p2p.laddr \"0.0.0.0:36656\" --minimum-gas-prices=\"0.025stake\" --rollkit.da_address \"http://localhost:7980\"" >> restart-rollup.sh
-```
+## 10. Starting the chain
 
-## 11. Starting the chain
+Finally, start the chain with your start command.
 
-Finally, start the chain with the following command:
+For example, start the simple ignite chain with the following command:
 
 ```sh
-rollkit start --rollkit.aggregator --rpc.laddr tcp://127.0.0.1:36657 --grpc.address 127.0.0.1:9290 --p2p.laddr "0.0.0.0:36656" --minimum-gas-prices="0.025stake" --rollkit.da_address "http://localhost:7980"
+rollkit start --rollkit.aggregator --rollkit.sequencer_rollup_id $CHAIN_ID
 ```
 
 ## Summary
 
-By following these steps, you will set up the genesis for your rollup, initialize the validator, add a genesis account, and start the chain on a local data availability network (DA). This guide provides a basic framework for configuring and starting your rollup using the Rollkit CLI. Make sure `rollkit.toml` is present in the root of your rollup directory, and use the `rollkit` command for all operations.
+By following these steps, you will set up the genesis for your rollup, initialize the validator, add a genesis account, and started the chain. This guide provides a basic framework for configuring and starting your rollup using the Rollkit CLI. Make sure `rollkit.toml` is present in the root of your rollup directory, and use the `rollkit` command for all operations.
diff --git a/public/install.sh b/public/install.sh
@@ -1,17 +1,95 @@
 #!/bin/bash
 
-echo "Downloading Rollkit source code..."
+# Define colors for output
+RED="\033[31m"
+GREEN="\033[32m"
+YELLOW="\033[33m"
+CYAN="\033[36m"
+BOLD="\033[1m"
+RESET="\033[0m"
+
+# Function to print headers
+print_header() {
+    echo -e "${CYAN}${BOLD}--> $1${RESET}"
+}
+
+# Function to print success messages
+print_success() {
+    echo -e "${GREEN}${BOLD}$1${RESET}"
+}
+
+# Function to print warnings
+print_warning() {
+    echo -e "${YELLOW}${BOLD}$1${RESET}"
+}
+
+# Function to print errors
+print_error() {
+    echo -e "${RED}${BOLD}$1${RESET}"
+}
+
+# Function to compare versions
+compare_versions() {
+    if [ "$(printf '%s\n' "$1" "$2" | sort -V | head -n1)" = "$1" ]; then
+        if [ "$1" = "$2" ]; then
+            return 0 # Equal
+        else
+            return 1 # First is less
+        fi
+    else
+        return 2 # First is greater
+    fi
+}
+
+print_header "Downloading Rollkit source code..."
 git clone https://github.com/rollkit/rollkit.git
+echo ""
+
+cd rollkit || { print_error "Failed to find the downloaded repository."; exit 1; }
+
+print_header "Extracting Go version from go.mod..."
+go_mod_version=$(grep "^go " go.mod | cut -d' ' -f2)
 
+if [ -z "$go_mod_version" ]; then
+    print_error "Error: Could not find a Go version in go.mod."
+    exit 1
+fi
+formatted_go_version="go${go_mod_version}"
+echo -e "   Required Go version: ${BOLD}${formatted_go_version}${RESET}\n"
+
+print_header "Checking if Go is installed..."
 if ! which go > /dev/null; then
-	echo "Go is not installed. Attempting to install Go..."
-	curl -sL "https://rollkit.dev/install-go.sh" | sh -s "go1.22.2"
+    print_warning "Go is not installed. Attempting to install Go..."
+    curl -sL "https://rollkit.dev/install-go.sh" | sh -s "$formatted_go_version"
+fi
+
+installed_version=$(go version | awk '{print $3}' | sed 's/go//')
+echo -e "   Installed Go version: ${BOLD}${installed_version}${RESET}\n"
+
+print_header "Validating installed Go version..."
+compare_versions "$installed_version" "$go_mod_version"
+comparison_result=$?
+
+if [ $comparison_result -eq 1 ]; then
+    print_error "ERROR: The installed Go version ($installed_version) is less than the required version ($go_mod_version)."
+    echo "       Please upgrade your version of Go."
+    exit 1
+elif [ $comparison_result -eq 2 ]; then
+    print_warning "INFO: The installed Go version ($installed_version) is greater than the required version ($go_mod_version)."
+    echo "      If you run into issues, try downgrading your version of Go."
 fi
+echo ""
 
-cd rollkit || { echo "Failed to find the downloaded repository."; exit 1; }
-git fetch && git checkout $1
-echo "Building and installing Rollkit..."
+print_header "Fetching and checking out the specified branch or tag..."
+git fetch && git checkout "$1"
+echo ""
+
+print_header "Building and installing Rollkit..."
 make install
+print_success "Rollkit CLI installed successfully!"
+
 cd ..
-echo "Installation completed successfully."
+print_header "Cleaning up downloads..."
+rm -rf rollkit
 
+print_success "Installation completed successfully."
diff --git a/tutorials/sequencing/centralized.md b/tutorials/sequencing/centralized.md
@@ -30,6 +30,8 @@ make build
 ./build/centralized-sequencer -h
 ```
 
+You should see the following output:
+
 ```sh
 Usage:
   -host string
@@ -50,6 +52,7 @@ Usage:
     	DA namespace where the sequencer submits transactions
   -db_path string
     	path to the database
+...
 ```
 
 As shown by the help command, a centralized sequencer is configured to serve a rollup (via `rollup_id`). The DA network to persist the sequenced batches are specified using `da_address`, `da_auth_token` and `da_namespace`.
@@ -113,6 +116,24 @@ Then after a few blocks you should see this message confirming that your sequenc
 I[2024-11-15|16:04:07.698] successfully submitted Rollkit headers to DA layer module=BlockManager gasPrice=-1 daHeight=1 headerCount=14
 ```
 
+## Metrics {#metrics}
+
+The `centralized-sequencer` node reports Prometheus metrics when the `-metrics` flag is enabled.
+
+By default, metrics are exported to `http://localhost:8080/metrics`.
+
+The listening address and port can be configured with the `-metrics-address` flag.
+
+The following metrics are available:
+
+| **Name**                                  | **Type**  | **Tags**  | **Description**                                                        |
+|-------------------------------------------|-----------|-----------|------------------------------------------------------------------------|
+| sequencer_gas_price                       | Gauge     |           | Gas price of the DA transaction                                         |
+| sequencer_last_blob_size                  | Gauge     |           | Last blob size submitted to the DA                                      |
+| sequencer_transaction_status              | Gauge     |           | Transaction status of the DA transaction                                |
+| sequencer_num_pending_blocks              | Gauge     |           | Number of blocks pending DA submission                                  |
+| sequencer_included_block_height           | Gauge     |           | Block height of the last DA transaction                                 |
+
 ## Summary {#summary}
 
 By following these steps, you will have successfully set up and connected your chain to the centralized sequencer. You can now start submitting transactions to your chain.
