updats to docs

Author: tac0turtle

guides/rollkit-monitoring.md

@@ -44,8 +44,8 @@ After successfully starting a light node, it's time to start posting the batches
 
 ## 🏗️ Prerequisites {#prerequisites}
 
-* `rollkit` CLI installed from the [quick start](/tutorials/quick-start) tutorial.
- 
+- `rollkit` CLI installed from the [quick start](/tutorials/quick-start) tutorial.
+
 ## 🛠️ Configuring flags for DA
 
 Now that we are posting to the Celestia DA instead of the local DA, the `rollkit start` command requires three DA configuration flags:
@@ -143,6 +143,7 @@ Now, the rollup is running and posting blocks (aggregated in batches) to Celesti
 For example, [here on Celenium for Arabica](https://arabica.celenium.io/).
 
 Other explorers:
+
 - [Arabica testnet](https://docs.celestia.org/nodes/arabica-testnet#explorers)
 - [Mocha testnet](https://docs.celestia.org/nodes/mocha-testnet#explorers)
 - [Mainnet Beta](https://docs.celestia.org/nodes/mainnet#explorers)

guides/use-rollkit-cli.md

@@ -7,7 +7,7 @@ import constants from '../../.vitepress/constants/constants.js'
 
 ## Introduction {#introduction}
 
-This tutorial serves as a comprehensive guide for using the [local-da](https://github.com/rollkit/local-da) with your chain. 
+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](/tutorials/quick-start) or [build a chain](/tutorials/wordle) tutorial, which covers installing the rollkit CLI, building your chain, and running your chain.
 
@@ -23,7 +23,7 @@ This script will build and run the node, which will then listen on port `7980`.
 
 ## Configuring your rollup to connect to the local DA network
 
-To connect your rollup to the local DA network, you need to pass the `--rollkit.da_address` flag with the local DA node address.
+To connect your rollup to the local DA network, you need to pass the `--rollkit.da.address` flag with the local DA node address.
 
 ## Run your rollup
 
@@ -32,11 +32,11 @@ Start your rollup node with the following command, ensuring to include the DA ad
 ::: code-group
 
 ```sh [Quick Start]
-rollkit start --rollkit.da_address http://localhost:7980
+{BINARY} start --rollkit.da_address http://localhost:7980
 ```
 
 ```sh [Wordle Chain]
-rollkit start \
+{BINARY} start \
     --rollkit.aggregator \
     --rollkit.da_address http://localhost:7980 \
     --rollkit.sequencer_rollup_id wordle
@@ -47,9 +47,11 @@ rollkit start \
 You should see the following log message indicating that your rollup is connected to the local DA network:
 
 ```shell
-I[2024-11-15|14:54:19.842] DA server is already running                 module=main address=http://localhost:7980
+11:07AM INF NewLocalDA: initialized LocalDA module=local-da
+11:07AM INF Listening on host=localhost maxBlobSize=1974272 module=da port=7980
+11:07AM INF server started listening on=localhost:7980 module=da
 ```
 
 ## Summary
 
-By following these steps, you will set up a local DA network node and configure your rollup to post data to it. This setup is useful for testing and development in a controlled environment.
+By following these steps, you will set up a local DA network node and configure your rollup to post data to it. This setup is useful for testing and development in a controlled environment. You can find more information on running the local-da binary [here](https://github.com/rollkit/rollkit/blob/main/da/cmd/local-da/README.md)

tutorials/da/celestia-da.md

@@ -10,24 +10,54 @@ Now that you have the foundations of running and building a rollup with Rollkit,
 
 The first choice you need to make is which data availability (DA) layer to use. The DA layer is a critical component of a blockchain, as it provides the data availability and finality guarantees that your chain needs to operate securely.
 
-Rollkit uses the [go-da interface](https://github.com/rollkit/go-da) to communicate to DA layers. Any DA layer that implements this interface can be used with Rollkit.
+Rollkit uses the [core da interface](https://github.com/rollkit/rollkit/blob/main/core/da/da.go#L11) to communicate to DA layers. Any DA layer that implements this interface can be used with Rollkit.
 
-## Go DA {#go-da}
+## DA {#go-da}
 
-The [go-da interface](https://github.com/rollkit/go-da) defines the core functions required to interact with a DA layer. Probably the two most important functions being `Get` and `Submit`.
+The [DA interface](https://github.com/rollkit/rollkit/blob/main/core/da/da.go#L11) defines the core functions required to interact with a DA layer. Probably the two most important functions being `Get` and `Submit`.
 
 ```go
 // DA defines very generic interface for interaction with Data Availability layers.
 type DA interface {
+ // MaxBlobSize returns the max blob size
+ MaxBlobSize(ctx context.Context) (uint64, error)
+
  // Get returns Blob for each given ID, or an error.
- Get(ctx context.Context, ids []ID, namespace Namespace) ([]Blob, error)
+ //
+ // Error should be returned if ID is not formatted properly, there is no Blob for given ID or any other client-level
+ // error occurred (dropped connection, timeout, etc).
+ Get(ctx context.Context, ids []ID, namespace []byte) ([]Blob, error)
+
+ // GetIDs returns IDs of all Blobs located in DA at given height.
+ GetIDs(ctx context.Context, height uint64, namespace []byte) (*GetIDsResult, error)
+
+ // GetProofs returns inclusion Proofs for Blobs specified by their IDs.
+ GetProofs(ctx context.Context, ids []ID, namespace []byte) ([]Proof, error)
+
+ // Commit creates a Commitment for each given Blob.
+ Commit(ctx context.Context, blobs []Blob, namespace []byte) ([]Commitment, error)
 
  // Submit submits the Blobs to Data Availability layer.
- Submit(ctx context.Context, blobs []Blob, gasPrice float64, namespace Namespace) ([]ID, error)
+ //
+ // This method is synchronous. Upon successful submission to Data Availability layer, it returns the IDs identifying blobs
+ // in DA.
+ Submit(ctx context.Context, blobs []Blob, gasPrice float64, namespace []byte) ([]ID, error)
+
+ // SubmitWithOptions submits the Blobs to Data Availability layer with additional options.
+ SubmitWithOptions(ctx context.Context, blobs []Blob, gasPrice float64, namespace []byte, options []byte) ([]ID, error)
+
+ // Validate validates Commitments against the corresponding Proofs. This should be possible without retrieving the Blobs.
+ Validate(ctx context.Context, ids []ID, proofs []Proof, namespace []byte) ([]bool, error)
+
+ // GasPrice returns the gas price for the DA layer.
+ GasPrice(ctx context.Context) (float64, error)
+
+ // GasMultiplier returns the gas multiplier for the DA layer.
+ GasMultiplier(ctx context.Context) (float64, error)
 }
 ```
 
-DA layers can integrate the `go-da` interface directly into their node like [Celestia](celestia-da), or they can define a middleware service like [Avail](avail-da).
+DA layers can integrate the `da` interface directly into their node like [Celestia](celestia-da).
 
 ## Mock DA {#mock-da}
 

tutorials/da/local-da.md

@@ -30,13 +30,14 @@ this tutorial.
 
 ## 💻 CosmWasm dependency {#dependencies}
 
-As with the [GM Rollup](https://rollkit.dev/tutorials/gm-world), we use [kurtosis](https://docs.kurtosis.com/) to help with managing all the services we need to run. You can [install kurtosis here](https://docs.kurtosis.com/install). 
+As with the [GM Rollup](https://rollkit.dev/tutorials/gm-world), we use [kurtosis](https://docs.kurtosis.com/) to help with managing all the services we need to run. You can [install kurtosis here](https://docs.kurtosis.com/install).
 
 Once installed, you can verify the installation by running:
 
 ```bash
 kurtosis version
 ```
+
 ```bash
 CLI Version:   0.90.1
 
@@ -104,6 +105,7 @@ Kurtosis has successfully launched the CosmWasm rollup and the local DA network.
 ```bash
 docker ps
 ```
+
 ```bash
 CONTAINER ID   IMAGE                              COMMAND                  CREATED              STATUS              PORTS                                                                              NAMES
 5bfeda0a871f   ghcr.io/rollkit/cosmwasm:v0.1.0    "/bin/sh -c 'wasmd s…"   About a minute ago   Up About a minute   0.0.0.0:9290->9290/tcp, 0.0.0.0:36656-36657->36656-36657/tcp                       wasm--c71b0308616d40ad919ad24c3d14f35b
@@ -119,7 +121,7 @@ We can see the CosmWasm rollup running in container `wasm--c71b0308616d40ad919ad
 
 Let's hold on to the container name for the CosmWasm rollup, as we will need it later.
 
-```bash 
+```bash
 CW=$(docker ps --format '{{.Names}}' | grep wasm)
 echo $CW
 ```
@@ -129,6 +131,7 @@ You can verify the rollup is running by checking the logs:
 ```bash
 docker logs $CW
 ```
+
 ```bash
 ...
 3:55PM INF Creating and publishing block height=137 module=BlockManager
@@ -157,7 +160,7 @@ docker pull ghcr.io/rollkit/contract:v0.2.0
 
 Then run the container:
 
-```bash 
+```bash
 docker run --rm -d --name cw ghcr.io/rollkit/contract:v0.2.0
 ```
 
@@ -208,7 +211,7 @@ docker exec -it $CW sh
 
 In order to deploy a contract, you can use the command line as described below.
 For a better experience and to use Rust code instead of the command line to
-deploy/script and test your contracts, you can use [cw-orchestrator](/guides/cw-orch.md). 
+deploy/script and test your contracts, you can use [cw-orchestrator](/guides/cw-orch.md).
 
 <!-- markdownlint-disable MD013 -->
 ```bash
@@ -230,7 +233,7 @@ the variables in the command with the variables in the `init.sh` script.
 In the previous steps, we have stored out contract's tx hash in an
 environment variable for later use.
 
-The following guide will show you how to deploy and interact with a contract using CLI. 
+The following guide will show you how to deploy and interact with a contract using CLI.
 For scripting using Rust, you can use [cw-orchestrator](/guides/cw-orch.md).
 
 ### 🔎 Contract querying {#contract-querying}