fix: cleaning the docs

.vitepress/config.ts

@@ -187,15 +187,8 @@ function sidebarHome() {
           text: "About Rollkit",
           link: "/learn/about",
         },
-        {
-          text: "Technical details",
-          collapsed: true,
-          items: [
-            { text: "Rollkit stack", link: "/learn/stack" },
-            { text: "Transaction flow", link: "/learn/transaction-flow" },
-            { text: "Configuration", link: "/learn/config" },
-          ],
-        },
+        { text: "Transaction flow", link: "/learn/transaction-flow" },
+        { text: "Configuration", link: "/learn/config" },
         {
           text: "Data Availability",
           link: "/learn/data-availability",

guides/cometbft-to-rollkit.md

@@ -36,6 +36,13 @@ Run the following command to initialize Rollkit:
 ignite rollkit init
 ```
 
+:::warning
+This tutorial is being currently update to reflect the latest changes using the rollkit ignite app.
+Please check back later for the updated version.
+:::
+
+<!-- TODO: update
+
 ## Initialize Rollkit CLI Configuration {#initialize-rollkit-cli-configuration}
 
 Next, you'll need to initialize the Rollkit CLI configuration by generating the `rollkit.toml` file. This file is crucial for Rollkit to understand the structure of your rollup.
@@ -61,3 +68,5 @@ rollkit start --rollkit.aggregator <insert your flags>
 By following this guide, you've successfully converted your CometBFT app into a Rollkit app.
 
 To learn more about how to config your DA, Sequencing, and Execution, please check out those tutorial sections.
+
+-->

guides/create-genesis.md

@@ -27,38 +27,26 @@ STAKING_AMOUNT="1000000000stake"
 
 ## 2. Rebuild your chain
 
-Ensure that `rollkit.toml` is present in the root of your rollup directory (if not, follow a [Guide](/guides/gm-world.md) to set it up) and run the following command to (re)generate an entrypoint binary out of the code:
+Ensure that `.gm` folder is present at `/Users/you/.gm` (if not, follow a [Guide](/guides/gm-world.md) to set it up) and run the following command to (re)generate an entrypoint binary out of the code:
 
 ```sh
-rollkit rebuild
+make install
 ```
 
-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"
-```
-
-:::tip
-You can always recreate the `rollkit.toml` file by deleting it and re-running the following command:
+Once completed, run the following command to ensure that the `/Users/you/.gm` directory is present:
 
 ```sh
-rollkit toml init
+ignite rollkit init
 ```
 
-:::
+This (re)creates an `gmd` binary that will be used for the rest of the tutorials to run all the operations on the rollup chain.
 
 ## 3. Resetting existing genesis/chain data
 
 Reset any existing chain data:
 
 ```sh
-rollkit tendermint unsafe-reset-all
+gmd comet unsafe-reset-all
 ```
 
 Reset any existing genesis data:
@@ -73,39 +61,39 @@ rm $HOME/.$CHAIN_ID/config/genesis.json
 Initialize the validator with the chain ID you set:
 
 ```sh
-rollkit init $VALIDATOR_NAME --chain-id $CHAIN_ID
+gmd init $VALIDATOR_NAME --chain-id $CHAIN_ID
 ```
 
 ## 5. Adding a key to keyring backend
 
 Add a key to the keyring-backend:
 
 ```sh
-rollkit keys add $KEY_NAME --keyring-backend test
+gmd keys add $KEY_NAME --keyring-backend test
 ```
 
 ## 6. Adding a genesis account
 
 Add a genesis account with the specified token amount:
 
 ```sh
-rollkit genesis add-genesis-account $KEY_NAME $TOKEN_AMOUNT --keyring-backend test
+gmd genesis add-genesis-account $KEY_NAME $TOKEN_AMOUNT --keyring-backend test
 ```
 
 ## 7. Setting the staking amount in the genesis transaction
 
 Set the staking amount in the genesis transaction:
 
 ```sh
-rollkit genesis gentx $KEY_NAME $STAKING_AMOUNT --chain-id $CHAIN_ID --keyring-backend test
+gmd genesis gentx $KEY_NAME $STAKING_AMOUNT --chain-id $CHAIN_ID --keyring-backend test
 ```
 
 ## 8. Collecting genesis transactions
 
 Collect the genesis transactions:
 
 ```sh
-rollkit genesis collect-gentxs
+gmd genesis collect-gentxs
 ```
 
 ## 9. Configuring the genesis file
@@ -125,9 +113,9 @@ Finally, start the chain with your start command.
 For example, start the simple ignite chain with the following command:
 
 ```sh
-rollkit start --rollkit.aggregator --rollkit.sequencer_rollup_id $CHAIN_ID
+gmd start --rollkit.node.aggregator --chain_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 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.
+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 gm-world binary. Make sure you initialized your chain correctly, and use the `gmd` command for all operations.

guides/da/local-da.md

@@ -9,7 +9,7 @@ import constants from '../../.vitepress/constants/constants.js'
 
 This tutorial serves as a comprehensive guide for using the [local-da](https://github.com/rollkit/local-da) with your chain.
 
-Before proceeding, ensure that you have completed the [quick start](/guides/quick-start.md) or [build a chain](/guides/gm-world.md) tutorial, which covers installing the rollkit CLI, building your chain, and running your chain.
+Before proceeding, ensure that you have completed the [build a chain](/guides/gm-world.md) tutorial, which covers setting-up, building and running your chain.
 
 ## Setting Up a Local DA Network
 

guides/docker-compose.md

@@ -210,13 +210,13 @@ b9d5e80e81fb   gm-world   "gmd start --rollkit…"   27 minutes ago   Up 9 secon
 
 We can see the gm-world chain running in container `gm-world` and the local DA network running in container `local-da`.
 
-Since our chain is running in a docker container, we want to enter the docker container to interact with it via the Rollkit CLI. We can do this by running:
+Since our chain is running in a docker container, we want to enter the docker container to interact with it via the command `gmd`. We can do this by running:
 
 ```bash
 docker exec -it gm-world sh
 ```
 
-Now that you are in the docker container, you can interact with the chain using the Rollkit CLI and the example commands you used in the [gm-world tutorial](/guides/gm-world.md).
+Now that you are in the docker container, you can interact with the chain using the `gmd` command and the example you used in the [gm-world tutorial](/guides/gm-world.md).
 
 Once you are done interacting with your chain, you can exit out of your docker container with:
 
@@ -235,4 +235,4 @@ docker compose down
 
 ## 🎉 Next steps
 
-Congratulations again! You now know how to run your chain with docker compose and interact with it using the Rollkit CLI in the docker container.
+Congratulations again! You now know how to run your chain with docker compose and interact with it using the `gmd` command in the docker container.

guides/evm/single.md

@@ -18,7 +18,7 @@ Before starting, ensure you have:
 ### 1. Clone the Rollkit Repository
 
 ```bash
-git clone --depth 1 --branch v1.0.0-beta.1 https://github.com/rollkit/rollkit.git
+git clone --depth 1 --branch {{constants.rollkitLatestTag}} https://github.com/rollkit/rollkit.git
 cd rollkit
 ```
 

guides/full-node.md

@@ -6,11 +6,12 @@ This guide covers how to set up a full node to run alongside a sequencer node in
 
 ## Prerequisites
 
-Before starting, ensure you have:
+Before proceeding, ensure that you have completed the [build a chain](/guides/gm-world.md) tutorial, which covers setting-up, building and running your chain.
+
+Ensure that you have:
 
 - A local Data Availability (DA) network node running on port `7980`.
 - A Rollkit sequencer node running and posting blocks to the DA network.
-- The Rollkit CLI installed on your system.
 
 ## Setting Up Your Full Node
 
@@ -25,7 +26,7 @@ CHAIN_ID=gm
 Initialize the chain config for the full node, lets call it `FullNode` and set the chain ID to your rollup chain ID:
 
 ```bash
-{BINARY} init FullNode --chain-id=$CHAIN_ID
+gmd init FullNode --chain-id $CHAIN_ID --home $HOME/.${CHAIN_ID}_fn
 ```
 
 Copy the genesis file from the sequencer node:
@@ -39,7 +40,7 @@ cp $HOME/.$CHAIN_ID/config/genesis.json $HOME/.${CHAIN_ID}_fn/config/genesis.jso
 Identify the sequencer node's P2P address from its logs. It will look similar to:
 
 ```
-1:55PM INF listening on address=/ip4/127.0.0.1/tcp/36656/p2p/12D3KooWJbD9TQoMSSSUyfhHMmgVY3LqCjxYFz8wQ92Qa6DAqtmh
+1:55PM INF listening on address=/ip4/127.0.0.1/tcp/7676/p2p/12D3KooWJbD9TQoMSSSUyfhHMmgVY3LqCjxYFz8wQ92Qa6DAqtmh module=p2p
 ```
 
 Create an environment variable with the P2P address:
@@ -64,20 +65,21 @@ Make sure to include these flags with your start command:
 Run your full node with the following command:
 
 ```bash
-rollkit start \
+gmd start \
   --rollkit.da.address http://127.0.0.1:7980 \
-  --p2p.seeds $P2P_ID@127.0.0.1:26656 \
+  --p2p.seeds $P2P_ID@127.0.0.1:7676 \
   --minimum-gas-prices 0stake \
   --rpc.laddr tcp://127.0.0.1:46657 \
   --grpc.address 127.0.0.1:9390 \
   --p2p.laddr "0.0.0.0:46656" \
   --api.address tcp://localhost:1318 \
-  --rollkit.sequencer_rollup_id gm
+  --chain_id $CHAIN_ID \
+  --home $HOME/.${CHAIN_ID}_fn
 ```
 
 Key points about this command:
 
-- `rollkit.sequencer_rollup_id` is generally the `$CHAIN_ID`, which is `gm` in this case.
+- `chain_id` is generally the `$CHAIN_ID`, which is `gm` in this case.
 - The ports and addresses are different from the sequencer node to avoid conflicts. Not everything may be necessary for your setup.
 - We use the `P2P_ID` environment variable to set the seed node.
 

guides/gm-world.md

@@ -39,17 +39,15 @@ ignite version
 ```
 
 ```bash
-Ignite CLI version:             v28.7.0
-Ignite CLI build date:          2025-01-15T08:23:41Z
-Ignite CLI source hash:         2f83cfe6114cfc58bd6add791143fe43963c1b5c
+Ignite CLI version:             v29.2.0-dev
+Ignite CLI build date:          undefined
+Ignite CLI source hash:         undefined
 Ignite CLI config version:      v1
-Cosmos SDK version:             v0.50.11
+Cosmos SDK version:             v0.53.0
+Buf.build version:              undefined
 Your OS:                        darwin
 Your arch:                      arm64
-Your go version:                go version go1.24.2 darwin/arm64
-Your uname -a:                  Darwin Markos-MacBook-Pro.local 24.3.0 Darwin Kernel Version 24.3.0: Thu Jan  2 20:24:16 PST 2025; root:xnu-11215.81.4~3/RELEASE_ARM64_T6000 arm64
-Your cwd:                       /Users/markobaricevic/code/CoTend/rollkit1/docs
-Is on Gitpod:                   false
+Your go version:                go version go1.24.3 darwin/arm64
 ```
 
 ## Generate your App {#generate-your-app}
@@ -91,7 +89,7 @@ This will create a `~/.gm` folder with all the necessary files to run a chain.
 
 ## Initialize Your Blockchain {#initialize-your-blockchain}
 
-Before starting your blockchain, you need to initialize it with Rollkit support. Initialize the blockchain with Local DA as follows:
+Before starting your blockchain, you need to initialize it with Rollkit support. Initialize the blockchain as follows:
 
 ```bash
 ignite rollkit init
@@ -106,7 +104,7 @@ Now that we have our gm app generated and installed, we can launch our GM rollup
 First lets start the local DA network:
 
 ```bash
-curl -sSL https://rollkit.dev/install-local-da.sh | bash
+curl -sSL https://rollkit.dev/install-local-da.sh | bash -s {{constants.rollkitLatestTag}}
 ```
 
 you should see logs like:

guides/quick-start.md

@@ -36,15 +36,31 @@ rollkit git sha:  cd1970de
 To initialize a sovereign rollup node, execute the following command:
 
 ```bash
-testapp init --rollkit.node.aggregator --rollkit.signer.passphrase verysecretpass
+testapp init --rollkit.node.aggregator --rollkit.signer.passphrase secret
 ```
 
 ## 🚀 Run your sovereign rollup node
 
+Now that we have our testapp generated and installed, we can launch our rollup along with the local DA by running the following command:
+
+First lets start the local DA network:
+
+```bash
+curl -sSL https://rollkit.dev/install-local-da.sh | bash -s {{constants.rollkitLatestTag}}
+```
+
+You should see logs like:
+
+```bash
+4:58PM INF NewLocalDA: initialized LocalDA module=local-da
+4:58PM INF Listening on host=localhost maxBlobSize=1974272 module=da port=7980
+4:58PM INF server started listening on=localhost:7980 module=da
+```
+
 To start a basic sovereign rollup node, execute:
 
 ```bash
-testapp start --rollkit.signer.passphrase verysecretpass
+testapp start --rollkit.signer.passphrase secret
 ```
 
 Upon execution, the CLI will output log entries that provide insights into the node's initialization and operation: