replace more

Author: tac0turtle

guides/restart-chain.md

@@ -1,15 +1,15 @@
-# 🔄 How to restart your rollup
+# 🔄 How to restart your chain
 
-This guide will teach you how to restart your Rollkit rollup.
+This guide will teach you how to restart your Rollkit chain.
 
-## Restart rollup
+## Restart chain
 
-This section covers the case where you need to restart your rollup.
+This section covers the case where you need to restart your chain.
 
-In order to restart your rollup, you simply need to run the `<your-binary>d start [...args]`
-command for your rollup.
+In order to restart your chain, you simply need to run the `<your-binary>d start [...args]`
+command for your chain.
 
-For example, if you ran the [quick start](/guides/quick-start.md) tutorial, you started your rollup with:
+For example, if you ran the [quick start](/guides/quick-start.md) tutorial, you started your chain with:
 
 ```bash
 testapp start
@@ -24,7 +24,7 @@ I[2024-10-17|14:52:12.845] executed block                               module=B
 I[2024-10-17|14:52:12.846] indexed block events                         module=txindex height=7
 ```
 
-If you need to restart your rollup, you can run the same command again:
+If you need to restart your chain, you can run the same command again:
 
 ```bash
 testapp start
@@ -39,13 +39,13 @@ I[2024-10-17|14:52:13.845] executed block                               module=B
 I[2024-10-17|14:52:13.845] indexed block events                         module=txindex height=8
 ```
 
-It is important to include any additional flags that you used when you first started your rollup. For example, if you used the `--rollkit.da.namespace` flag, you will need to include that flag when restarting your rollup to ensure your rollup continues to publish blobs to the same namespace.
+It is important to include any additional flags that you used when you first started your chain. For example, if you used the `--rollkit.da.namespace` flag, you will need to include that flag when restarting your chain to ensure your chain continues to publish blobs to the same namespace.
 
-## Restart rollup after running out of funds
+## Restart chain after running out of funds
 
 This section covers the case that the node that
 you are using to post blocks to your DA and consensus layer runs out of funds (tokens),
-and you need to restart your rollup.
+and you need to restart your chain.
 
 In this example, we're using Celestia's [Mocha testnet](https://docs.celestia.org/how-to-guides/mocha-testnet/)
 and running the [quick start](/guides/quick-start.md). In this example, our Celestia DA light node
@@ -58,7 +58,7 @@ error. This error is defined by Cosmos SDK as:
 ErrTxInMempoolCache = Register(RootCodespace, 19, "tx already in mempool")
 ```
 
-In order to get around this error, and the same error on other Rollkit rollups, you will need to re-fund your Celestia account and increase the gas fee. This will override the transaction that is stuck in the mempool.
+In order to get around this error, and the same error on other Rollkit chains, you will need to re-fund your Celestia account and increase the gas fee. This will override the transaction that is stuck in the mempool.
 
 If you top up the balance of your node and don't increase the gas fee, you will still encounter the `Code: 19` error because there is a transaction (posting block to DA) that is duplicate to one that already exists. In order to get around this, you'll need to increase the gas fee and restart the chain.
 
@@ -82,20 +82,20 @@ cd $HOME && cd celestia-node
 ./cel-key list --keyring-backend test --node.type light --p2p.network <network>
 ```
 
-### 🛑 Stopping your rollup {#stopping-your-rollup}
+### 🛑 Stopping your chain {#stopping-your-chain}
 
-You can stop your rollup by using `Control + C` in your terminal where the node is running.
+You can stop your chain by using `Control + C` in your terminal where the node is running.
 
 ### ⛽ Increase the gas fee {#increase-gas-fee}
 
 To reiterate, before restarting the chain, you will need to increase the gas fee in order to avoid a `Code: 19` error. See the [How to configure gas price](/guides/config.md#da-gas-price) guide for more information.
 
-### 🔁 Restarting your rollup {#restarting-your-rollup}
+### 🔁 Restarting your chain {#restarting-your-chain}
 
-Follow the [restart rollup](#restart-rollup) section above.
+Follow the [restart chain](#restart-chain) section above.
 
 ### 🛢️ Reduce gas fee & restart again {#reduce-gas-fee-restart-again}
 
 In order to save your TIA, we also recommend stopping the chain with `Control + C`, changing the gas fee back to the default (in our case, 8000 utia) and restarting the chain:
 
-🎊 Congrats! You've successfully restarted your Rollkit rollup after running out of TIA.
+🎊 Congrats! You've successfully restarted your Rollkit chain after running out of TIA.

learn/about.md

@@ -69,23 +69,23 @@ Rollkit's goal is to make deploying a chain as easy as it is to deploy a smart c
 
 ## How can you use Rollkit?
 
-As briefly mentioned above, Rollkit could be used in many different ways. From sovereign rollups, to settlement layers, and in the future even to L3s.
+As briefly mentioned above, Rollkit could be used in many different ways. From sovereign chains, to settlement layers, and in the future even to L3s.
 
-### Rollup with any execution environment
+### Chain with any execution environment
 
-Rollkit gives developers the flexibility to use pre-existing ABCI-compatible state machines or create a custom state machine tailored to their rollup needs. Rollkit does not restrict the use of any specific virtual machine, allowing developers to experiment and bring innovative applications to life.
+Rollkit gives developers the flexibility to use pre-existing ABCI-compatible state machines or create a custom state machine tailored to their chain needs. Rollkit does not restrict the use of any specific virtual machine, allowing developers to experiment and bring innovative applications to life.
 
-### Sovereign rollup with Cosmos SDK
+### Sovereign chain with Cosmos SDK
 
-Similarly to how developers utilize the Cosmos SDK to build a sovereign layer 1 chain, the Cosmos SDK could be utilized to create a Rollkit-compatible rollup chain.
+Similarly to how developers utilize the Cosmos SDK to build a sovereign layer 1 chain, the Cosmos SDK could be utilized to create a Rollkit-compatible chain.
 Cosmos-SDK has great [documentation](https://docs.cosmos.network/main) and tooling that developers can leverage to learn.
 
-Another possibility is taking an existing layer 1 built with the Cosmos SDK and deploying it as a Rollkit rollup. This can provide a great opportunity for experimentation and growth.
+Another possibility is taking an existing layer 1 built with the Cosmos SDK and deploying it as a Rollkit chain. This can provide a great opportunity for experimentation and growth.
 
 ### Build a settlement layer
 
-[Settlement layers](https://celestia.org/learn/modular-settlement-layers/settlement-in-the-modular-stack/) are ideal for developers who want to avoid deploying sovereign rollups. They provide a platform for rollups to verify proofs and resolve disputes.
-Additionally, they act as a hub for rollups to facilitate trust-minimized token transfers and liquidity sharing between rollups that share the same settlement layer.
+[Settlement layers](https://celestia.org/learn/modular-settlement-layers/settlement-in-the-modular-stack/) are ideal for developers who want to avoid deploying sovereign chains. They provide a platform for chains to verify proofs and resolve disputes.
+Additionally, they act as a hub for chains to facilitate trust-minimized token transfers and liquidity sharing between chains that share the same settlement layer.
 Think of settlement layers as a special type of execution layer.
 
 ## When can you use Rollkit?

learn/config.md

@@ -98,7 +98,7 @@ db_path: "data"
 ### Chain ID
 
 **Description:**
-The unique identifier for your rollup chain. This ID is used to differentiate your network from others and is crucial for network communication and transaction validation.
+The unique identifier for your chain. This ID is used to differentiate your network from others and is crucial for network communication and transaction validation.
 
 **YAML:**
 Set this in your configuration file at the top level:
@@ -354,7 +354,7 @@ da:
 ### DA Namespace
 
 **Description:**
-The namespace ID used when submitting blobs (block data) to the DA layer. This helps segregate data from different rollups or applications on a shared DA layer.
+The namespace ID used when submitting blobs (block data) to the DA layer. This helps segregate data from different chains or applications on a shared DA layer.
 
 **YAML:**
 

learn/data-availability.md

@@ -1,6 +1,6 @@
 # Data Availability in Rollkit
 
-Data availability (DA) is a core of Rollkit's. Rollkit utilize's  data availability ensures that all transaction data and block information required to verify the rollup's state is accessible to anyone running a node or light client.
+Data availability (DA) is a core of Rollkit's. Rollkit utilize's  data availability ensures that all transaction data and block information required to verify the chain's state is accessible to anyone running a node or light client.
 
 Learn more about data availability:
 

learn/execution.md

@@ -1,14 +1,14 @@
 # Execution Layers in Rollkit
 
-Rollkit is designed to be modular and flexible, allowing different execution layers to be plugged in. Rollkit defines a general-purpose execution interface ([see execution.go](https://github.com/rollkit/rollkit/blob/main/core/execution/execution.go)) that enables developers to integrate any compatible application as the rollup's execution layer.
+Rollkit is designed to be modular and flexible, allowing different execution layers to be plugged in. Rollkit defines a general-purpose execution interface ([see execution.go](https://github.com/rollkit/rollkit/blob/main/core/execution/execution.go)) that enables developers to integrate any compatible application as the chain's execution layer.
 
-This means you can use a variety of Cosmos SDK or Reth compatible applications as the execution environment for your rollup: choose the execution environment that best fits your use case.
+This means you can use a variety of Cosmos SDK or Reth compatible applications as the execution environment for your chain: choose the execution environment that best fits your use case.
 
 ## Supported Execution Layers
 
 ### Cosmos SDK Execution Layer
 
-Rollkit natively supports Cosmos SDK-based applications as the execution layer for a rollup via the ABCI (Application Blockchain Interface) protocol. The Cosmos SDK provides a rich set of modules for staking, governance, IBC, and more, and is widely used in the Cosmos ecosystem. This integration allows developers to leverage the full power and flexibility of the Cosmos SDK when building their rollup applications.
+Rollkit natively supports Cosmos SDK-based applications as the execution layer for a chain via the ABCI (Application Blockchain Interface) protocol. The Cosmos SDK provides a rich set of modules for staking, governance, IBC, and more, and is widely used in the Cosmos ecosystem. This integration allows developers to leverage the full power and flexibility of the Cosmos SDK when building their chain applications.
 
 - [Cosmos SDK Documentation](https://docs.cosmos.network/)
 - [Cosmos SDK ABCI Documentation](https://docs.cosmos.network/main/build/abci/introduction)

learn/sequencing/overview.md

@@ -1,28 +1,44 @@
 # Sequencing
 
- Sequencing is the essential first step for handling your transactions. Think of it as an organizer that takes all incoming transactions, puts them in a clear order, and then groups them into batches. This process is vital for keeping everything consistent and making the rollup run. Rollkit uses a "Sequencing Interface" with key functions like submitting, retrieving, and verifying these transaction batches, ensuring smooth communication between the rollup and the sequencing mechanism, which often acts as a bridge to the underlying network.
+ Sequencing is the essential first step for handling your transactions. Think of it as an organizer that takes all incoming transactions, puts them in a clear order, and then groups them into batches. This process is vital for keeping everything consistent and making the chain run. Rollkit uses a "Sequencing Interface" with key functions like submitting, retrieving, and verifying these transaction batches, ensuring smooth communication between the chain and the sequencing mechanism, which often acts as a bridge to the underlying network.
 
 ## Sequencing Interface {#sequencing-interface}
 
 [Sequencing Interface](https://github.com/rollkit/rollkit/blob/main/core/sequencer/sequencing.go#L11) defines a sequencing interface for communicating between any sequencing network and Rollkit. The key functions of the interface are defined as shown below.
 
 ```go
-SubmitRollupTransaction(rollupId, data) returns (error)
-
-GetNextBatch(rollupId, lastBatchHash, maxBytes) returns (batch, timestamp)
-
-VerifyBatch(rollupId, batchHash) returns (status)
+// Sequencer is a generic interface for a sequencer
+type Sequencer interface {
+ // SubmitBatchTxs submits a batch of transactions from  to sequencer
+ // Id is the unique identifier for the  chain
+ // Batch is the batch of transactions to submit
+ // returns an error if any from the sequencer
+ SubmitBatchTxs(ctx context.Context, req SubmitBatchTxsRequest) (*SubmitBatchTxsResponse, error)
+
+ // GetNextBatch returns the next batch of transactions from sequencer to
+ // Id is the unique identifier for the  chain
+ // LastBatchHash is the cryptographic hash of the last batch received by the
+ // MaxBytes is the maximum number of bytes to return in the batch
+ // returns the next batch of transactions and an error if any from the sequencer
+ GetNextBatch(ctx context.Context, req GetNextBatchRequest) (*GetNextBatchResponse, error)
+
+ // VerifyBatch verifies a batch of transactions received from the sequencer
+ // Id is the unique identifier for the  chain
+ // BatchHash is the cryptographic hash of the batch to verify
+ // returns a boolean indicating if the batch is valid and an error if any from the sequencer
+ VerifyBatch(ctx context.Context, req VerifyBatchRequest) (*VerifyBatchResponse, error)
+}
 ```
 
 It mainly consists of:
 
-* `SubmitRollupTransaction` relays the rollup transactions from Rollkit rollup to the sequencing network
+* `SubmitBatchTxs` relays the chain transactions from Rollkit chain to the sequencing network
 * `GetNextBatch` returns the next batch of transactions along with a deterministic timestamp
 * `VerifyBatch` validates the sequenced batch
 
 ## Sequencing Implementations {#sequencing-implementations}
 
-An implementation of the sequencing interface mainly acts as a middleware that connects Rollkit rollup and the sequencing layer. It implements the sequencing interface functions described above.
+An implementation of the sequencing interface mainly acts as a middleware that connects Rollkit chain and the sequencing layer. It implements the sequencing interface functions described above.
 There are several implementations of the sequencer but for now only one is available in Rollkit.
 
 * [single-sequencer](/learn/sequencing/single.md) - The simplest and most widely used sequencing model, where a single node (the sequencer) is responsible for ordering transactions and producing blocks.

learn/sequencing/single.md

@@ -1,6 +1,6 @@
 # Single Sequencer
 
-A single sequencer is the simplest sequencing architecture for a Rollkit-based rollup. In this model, one node (the sequencer) is responsible for ordering transactions, producing blocks, and submitting data to the data availability (DA) layer.
+A single sequencer is the simplest sequencing architecture for a Rollkit-based chain. In this model, one node (the sequencer) is responsible for ordering transactions, producing blocks, and submitting data to the data availability (DA) layer.
 
 ## How the Single Sequencer Model Works
 
@@ -19,10 +19,10 @@ A single sequencer is the simplest sequencing architecture for a Rollkit-based r
 
 4. **Data Availability Posting:**
    - The sequencer posts the block data to the configured DA layer (e.g., Celestia).
-   - This ensures that anyone can access the data needed to reconstruct the rollup state.
+   - This ensures that anyone can access the data needed to reconstruct the chain state.
 
 5. **State Update:**
-   - The sequencer updates the rollup state based on the new block and makes the updated state available to light clients and full nodes.
+   - The sequencer updates the chain state based on the new block and makes the updated state available to light clients and full nodes.
 
 ## Transaction Flow Diagram
 

learn/specs/block-manager.md

@@ -97,7 +97,7 @@ The block manager is initialized using several parameters as defined below:
 signing key|crypto.PrivKey|used for signing blocks and data after creation
 config|config.BlockManagerConfig|block manager configurations (see config options below)
 genesis|*cmtypes.GenesisDoc|initialize the block manager with genesis state (genesis configuration defined in `config/genesis.json` file under the app directory)
-store|store.Store|local datastore for storing rollup blocks and states (default local store path is `$db_dir/rollkit` and `db_dir` specified in the `config.yaml` file under the app directory)
+store|store.Store|local datastore for storing chain blocks and states (default local store path is `$db_dir/rollkit` and `db_dir` specified in the `config.yaml` file under the app directory)
 mempool, proxyapp, eventbus|mempool.Mempool, proxy.AppConnConsensus, *cmtypes.EventBus|for initializing the executor (state transition function). mempool is also used in the manager to check for availability of transactions for lazy block production
 dalc|da.DAClient|the data availability light client used to submit and retrieve blocks to DA network
 headerStore|*goheaderstore.Store[*types.SignedHeader]|to store and retrieve block headers gossiped over the P2P network
@@ -290,7 +290,7 @@ flowchart TD
    * Makes `GetHeightPair(daHeight)` request to get both header and data
    * Handles three possible outcomes:
      * `Success`: Process retrieved header and data
-     * `NotFound`: No rollup block at this DA height (normal case)
+     * `NotFound`: No chain block at this DA height (normal case)
      * `Error`: Retry with backoff
 
 3. **Error Handling**:
@@ -316,7 +316,7 @@ The retrieval system uses persistent caches for both headers and data:
 
 For more details on DA integration, see the [Data Availability specification](./da.md).
 
-#### Out-of-Order Rollup Blocks on DA
+#### Out-of-Order Chain Blocks on DA
 
 Rollkit should support blocks arriving out-of-order on DA, like so:
 ![out-of-order blocks](./out-of-order-blocks.png)