rename to ikura

Cargo.toml

@@ -11,17 +11,17 @@ debug = 0
 [workspace]
 resolver = "2"
 members = [
-    "sugondat/chain/node",
-    "sugondat/chain/pallets/*",
-    "sugondat/chain/runtimes/*",
-    "sugondat/chain/primitives",
+    "ikura/chain/node",
+    "ikura/chain/pallets/*",
+    "ikura/chain/runtimes/*",
+    "ikura/chain/primitives",
     "adapters/sovereign",
-    "sugondat/nmt",
-    "sugondat/serde-util",
-    "sugondat/shim",
-    "sugondat/shim/common/rollkit",
-    "sugondat/shim/common/sovereign",
-    "sugondat/subxt-autogen",
+    "ikura/nmt",
+    "ikura/serde-util",
+    "ikura/shim",
+    "ikura/shim/common/rollkit",
+    "ikura/shim/common/sovereign",
+    "ikura/subxt-autogen",
     "xtask"
 ]
 
@@ -168,16 +168,16 @@ bytes = { version = "1", features = ["serde"] }
 digest = "0.10.7"
 
 # Local
-sugondat-serde-util = { path = "sugondat/serde-util" }
-sugondat-nmt = { path = "sugondat/nmt", default-features = false }
-sugondat-subxt = { path = "sugondat/subxt-autogen" }
-sugondat-shim-common-sovereign = { path = "sugondat/shim/common/sovereign", default-features = false }
-sugondat-shim-common-rollkit = { path = "sugondat/shim/common/rollkit" }
-sugondat-test-runtime = { path = "sugondat/chain/runtimes/test" }
-sugondat-kusama-runtime = { path = "sugondat/chain/runtimes/sugondat-kusama" }
-sugondat-primitives = { path = "sugondat/chain/primitives", default-features = false }
-pallet-sugondat-blobs = { path = "sugondat/chain/pallets/blobs", default-features = false }
-pallet-sugondat-length-fee-adjustment = { path = "sugondat/chain/pallets/length-fee-adjustment", default-features = false }
+ikura-serde-util = { path = "ikura/serde-util" }
+ikura-nmt = { path = "ikura/nmt", default-features = false }
+ikura-subxt = { path = "ikura/subxt-autogen" }
+ikura-shim-common-sovereign = { path = "ikura/shim/common/sovereign", default-features = false }
+ikura-shim-common-rollkit = { path = "ikura/shim/common/rollkit" }
+ikura-test-runtime = { path = "ikura/chain/runtimes/test" }
+ikura-kusama-runtime = { path = "ikura/chain/runtimes/ikura-kusama" }
+ikura-primitives = { path = "ikura/chain/primitives", default-features = false }
+pallet-ikura-blobs = { path = "ikura/chain/pallets/blobs", default-features = false }
+pallet-ikura-length-fee-adjustment = { path = "ikura/chain/pallets/length-fee-adjustment", default-features = false }
 
 # xtask
 duct = { version = "0.13.7" }

README.md

@@ -7,18 +7,18 @@ Blobchains on Polkadot and Kusama
 <pre>
 <a href=".">blobs</a>: The blobs monorepo.
 ├──<a href="./adapters">adapters</a>: Adapters for various rollup development kits (RDK).
-│   ├── <a href="./adapters/rollkit">rollkit</a>: An adapter connecting Rollkit to Sugondat
-│   ├── <a href="./adapters/sovereign">sovereign</a>: An adapter connecting Sovereign to Sugondat.
-├──<a href="./demo">demo</a>: Projects showcasing integration of RDKs with Sugondat.
+│   ├── <a href="./adapters/rollkit">rollkit</a>: An adapter connecting Rollkit to Ikura
+│   ├── <a href="./adapters/sovereign">sovereign</a>: An adapter connecting Sovereign to Ikura.
+├──<a href="./demo">demo</a>: Projects showcasing integration of RDKs with Ikura.
 │   ├── <a href="./demo/rollkit">rollkit</a>: Rollkit's GM rollup.
 │   ├── <a href="./demo/sovereign">sovereign</a>: Sovereign Demo Rollup.
 |--<a href="./docs-site">docs-site</a>: Documentation site source, using Docusaurus.
-|──<a href="./sugondat">sugondat</a>: Sugondat source code.
-│   ├──<a href="./sugondat/chain">sugondat-chain</a>: Implementation of the Sugondat parachain.
-│   ├──<a href="./sugondat/nmt">sugondat-nmt</a>: Namespaced Merkle Trie definitions.
-│   ├──<a href="./sugondat/serde-util">sugondat-serde-util</a>: Various utilities for serde.
-│   ├──<a href="./sugondat/shim">sugondat-shim</a>: Shim between sugondat parachain RPC and RDK adapters.
-│   ├──<a href="./sugondat/subxt-autogen">sugondat-subxt</a>: Bindings to Sugondat RPC.
+|──<a href="./ikura">ikura</a>: Ikura source code.
+│   ├──<a href="./ikura/chain">ikura-chain</a>: Implementation of the Ikura parachain.
+│   ├──<a href="./ikura/nmt">ikura-nmt</a>: Namespaced Merkle Trie definitions.
+│   ├──<a href="./ikura/serde-util">ikura-serde-util</a>: Various utilities for serde.
+│   ├──<a href="./ikura/shim">ikura-shim</a>: Shim between ikura parachain RPC and RDK adapters.
+│   ├──<a href="./ikura/subxt-autogen">ikura-subxt</a>: Bindings to Ikura RPC.
 </pre>
 
 ## Running Demos
@@ -27,26 +27,26 @@ Blobchains on Polkadot and Kusama
 
 In general you need to have the following components running:
 
-build sugondat-chain:
+build ikura-chain:
 
 ``` sh
-cd sugondat/chain
+cd ikura/chain
 cargo build --release
 ```
 
-Make sure that zombienet binary and sugondat-chain binary are in your PATH.
+Make sure that zombienet binary and ikura-chain binary are in your PATH.
 
-Now you can launch 2 polkadot validators and one sugondat-chain collator
+Now you can launch 2 polkadot validators and one ikura-chain collator
 
 ``` sh
 ./zombienet.sh
 ```
 
-Then launch the sugondat-shim with:
+Then launch the ikura-shim with:
 
 ``` sh
-cd sugondat/shim/
-cargo run -p sugondat-shim -- serve --submit-dev-alice
+cd ikura/shim/
+cargo run -p ikura-shim -- serve --submit-dev-alice
 ``````
 
 ### Sovereign Demo

adapters/rollkit/go.mod

@@ -1,4 +1,4 @@
-module sugondat
+module ikura
 
 go 1.21
 

adapters/rollkit/sugondat.go

@@ -1,22 +1,22 @@
-// Rollkit DA layer client for Sugondat.
+// Rollkit DA layer client for Ikura.
 //
 // This adapter implements the `DataAvailabilityLayerClient` and `BlockRetriever` interfaces. It
-// connects to a running sugondat-shim RPC server and uses it to submit and retrieve blocks.
+// connects to a running ikura-shim RPC server and uses it to submit and retrieve blocks.
 //
 // The intended usage is to add this module to your application and call `Register()`. This will
-// make the sugondat adapter available to Rollkit.
+// make the ikura adapter available to Rollkit.
 //
 // To start your rollkit rollup with this adapter, you will need to run your blockchain with the
 // following arguments (assuming `gmd`).
 //
 // ```
 //
 //	gmd \
-//	    --rollkit.da_layer sugondat
+//	    --rollkit.da_layer ikura
 //	    --rollkit.da_config='{"base_url":"http://localhost:10995","namespace":"0102030405060708"}'
 //
 // ```
-package sugondat
+package ikura
 
 import (
 	"context"
@@ -35,8 +35,8 @@ type Blob struct {
 	Data []byte `json:"data"` // base64 encoded blob data.
 }
 
-// Declaration of JSON-RPC API for sugondat-shim.
-type SugondatAPI struct {
+// Declaration of JSON-RPC API for ikura-shim.
+type IkuraAPI struct {
 	// Retrieves the blobs at the given height from the data availability layer at the given namespace.
 	// Returns the blobs.
 	Retrieve func(string, uint64) ([]*Blob, error)
@@ -47,7 +47,7 @@ type SugondatAPI struct {
 
 type RpcClient struct {
 	closer jsonrpc.ClientCloser
-	api    SugondatAPI
+	api    IkuraAPI
 }
 
 // Main adapter struct.
@@ -60,24 +60,24 @@ type DataAvailabilityLayerClient struct {
 var _ da.DataAvailabilityLayerClient = &DataAvailabilityLayerClient{}
 var _ da.BlockRetriever = &DataAvailabilityLayerClient{}
 
-// Configuration of the Sugondat adapter.
+// Configuration of the Ikura adapter.
 type Config struct {
-	BaseURL   string `json:"base_url"`  // The base URL of the sugondat-shim RPC server.
+	BaseURL   string `json:"base_url"`  // The base URL of the ikura-shim RPC server.
 	Namespace string `json:"namespace"` // HEX encoded namespace ID. Cannot be empty.
 }
 
-// Register the `sugondat` adapter with the da adapter registry. Must be called to make the adapter
-// available via `--da.layer sugondat`.
+// Register the `ikura` adapter with the da adapter registry. Must be called to make the adapter
+// available via `--da.layer ikura`.
 func Register() error {
-	return registry.Register("sugondat", func() da.DataAvailabilityLayerClient {
+	return registry.Register("ikura", func() da.DataAvailabilityLayerClient {
 		return &DataAvailabilityLayerClient{}
 	})
 }
 
 func (c *DataAvailabilityLayerClient) Init(namespaceID types.NamespaceID, config []byte, kvStore ds.Datastore, logger log.Logger) error {
 	c.logger = logger
 	if len(config) > 0 {
-		c.logger.Info("initializing Sugondat Data Availability Layer Client", "config", string(config))
+		c.logger.Info("initializing Ikura Data Availability Layer Client", "config", string(config))
 		if err := json.Unmarshal(config, &c.config); err != nil {
 			return err
 		}
@@ -89,7 +89,7 @@ func (c *DataAvailabilityLayerClient) Init(namespaceID types.NamespaceID, config
 //
 // Expected to be called before `SubmitBlocks` or `RetrieveBlocks`.
 func (c *DataAvailabilityLayerClient) Start() error {
-	c.logger.Info("starting Sugondat Data Availability Layer Client", "baseURL", c.config.BaseURL)
+	c.logger.Info("starting Ikura Data Availability Layer Client", "baseURL", c.config.BaseURL)
 	closer, err := jsonrpc.NewClient(context.Background(), c.config.BaseURL, "Rollkit", &c.rpc.api, nil)
 	if err != nil {
 		return err
@@ -100,14 +100,14 @@ func (c *DataAvailabilityLayerClient) Start() error {
 
 // Tears down the RPC client.
 func (c *DataAvailabilityLayerClient) Stop() error {
-	c.logger.Info("stopping Sugondat Data Availability Layer Client")
+	c.logger.Info("stopping Ikura Data Availability Layer Client")
 	c.rpc.closer()
 	return nil
 }
 
 // RetrieveBlocks gets a batch of blocks from DA layer.
 func (c *DataAvailabilityLayerClient) RetrieveBlocks(ctx context.Context, dataLayerHeight uint64) da.ResultRetrieveBlocks {
-	c.logger.Info("retrieving blocks from Sugondat Data Availability Layer", "dataLayerHeight", dataLayerHeight)
+	c.logger.Info("retrieving blocks from Ikura Data Availability Layer", "dataLayerHeight", dataLayerHeight)
 	blobs, err := c.rpc.api.Retrieve(c.config.Namespace, dataLayerHeight)
 	if err != nil {
 		return da.ResultRetrieveBlocks{
@@ -142,7 +142,7 @@ func (c *DataAvailabilityLayerClient) RetrieveBlocks(ctx context.Context, dataLa
 
 // SubmitBlocks submits blocks to DA layer.
 func (c *DataAvailabilityLayerClient) SubmitBlocks(ctx context.Context, blocks []*types.Block) da.ResultSubmitBlocks {
-	c.logger.Info("submitting blocks to Sugondat Data Availability Layer", "blocks", blocks)
+	c.logger.Info("submitting blocks to Ikura Data Availability Layer", "blocks", blocks)
 	blobs := make([]*Blob, len(blocks))
 	for i, block := range blocks {
 		data, err := block.MarshalBinary()
@@ -167,7 +167,7 @@ func (c *DataAvailabilityLayerClient) SubmitBlocks(ctx context.Context, blocks [
 		}
 	}
 
-	c.logger.Debug("submitted blocks to Sugondat Data Availability Layer", "dataLayerHeight", dataLayerHeight)
+	c.logger.Debug("submitted blocks to Ikura Data Availability Layer", "dataLayerHeight", dataLayerHeight)
 
 	return da.ResultSubmitBlocks{
 		BaseResult: da.BaseResult{

adapters/sovereign/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "sugondat-da-adapter"
+name = "ikura-da-adapter"
 version = "0.1.0"
 authors.workspace = true
 homepage.workspace = true
@@ -24,10 +24,10 @@ borsh = { workspace = true, features = ["bytes"] }
 bytes = { workspace = true, features = ["serde"] }
 
 sha2 = { workspace = true }
-sugondat-nmt = { workspace = true }
+ikura-nmt = { workspace = true }
 jsonrpsee = { workspace = true, optional = true, features = ["ws-client"] }
 tokio = { workspace = true, optional = true }
-sugondat-shim-common-sovereign = { workspace = true, optional = true, features = ["client"] }
+ikura-shim-common-sovereign = { workspace = true, optional = true, features = ["client"] }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 digest = { workspace = true }
@@ -36,10 +36,10 @@ digest = { workspace = true }
 default = ["native"]
 native = [
     "sov-rollup-interface/native",
-    "sugondat-nmt/serde",
-    "sugondat-nmt/native",
+    "ikura-nmt/serde",
+    "ikura-nmt/native",
     "dep:tokio",
     "dep:jsonrpsee",
-    "dep:sugondat-shim-common-sovereign",
+    "dep:ikura-shim-common-sovereign",
 ]
-verifier = ["sugondat-nmt/serde"]
+verifier = ["ikura-nmt/serde"]

adapters/sovereign/src/service.rs

@@ -1,12 +1,12 @@
 use crate::{
     spec::{ChainParams, DaLayerSpec},
     types::{self, Hash},
-    verifier::SugondatVerifier,
+    verifier::IkuraVerifier,
 };
 use async_trait::async_trait;
+use ikura_shim_common_sovereign::SovereignRPCClient;
 use sov_rollup_interface::da::DaSpec;
 use std::time::Duration;
-use sugondat_shim_common_sovereign::SovereignRPCClient;
 
 mod client;
 
@@ -24,25 +24,25 @@ fn default_rpc_timeout_seconds() -> u64 {
 #[derive(Default, Debug, Clone, PartialEq, serde::Deserialize, serde::Serialize)]
 pub struct DaServiceConfig {
     #[serde(default = "default_rpc_addr")]
-    pub sugondat_rpc: String,
+    pub ikura_rpc: String,
     #[serde(default = "default_rpc_timeout_seconds")]
     pub rpc_timeout_seconds: u64,
 }
 
-/// Implementation of the DA provider that uses sugondat.
+/// Implementation of the DA provider that uses ikura.
 #[derive(Clone)]
 pub struct DaProvider {
-    namespace: sugondat_nmt::Namespace,
+    namespace: ikura_nmt::Namespace,
     client: Client,
 }
 
 impl DaProvider {
     /// Creates new instance of the service.
     pub fn new(config: DaServiceConfig, chain_params: ChainParams) -> Self {
         let request_timeout = Duration::from_secs(config.rpc_timeout_seconds);
-        let client = Client::new(config.sugondat_rpc, request_timeout);
+        let client = Client::new(config.ikura_rpc, request_timeout);
         Self {
-            namespace: sugondat_nmt::Namespace::from_raw_bytes(chain_params.namespace_id),
+            namespace: ikura_nmt::Namespace::from_raw_bytes(chain_params.namespace_id),
             client,
         }
     }
@@ -53,13 +53,13 @@ impl sov_rollup_interface::services::da::DaService for DaProvider {
     type Spec = DaLayerSpec;
     type FilteredBlock = crate::types::Block;
     type Error = anyhow::Error;
-    type Verifier = SugondatVerifier;
+    type Verifier = IkuraVerifier;
 
     // Make an RPC call to the node to get the finalized block at the given height, if one exists.
     // If no such block exists, block until one does.
     async fn get_finalized_at(&self, height: u64) -> Result<Self::FilteredBlock, Self::Error> {
         let client = self.client.ensure_connected().await?;
-        let block: sugondat_shim_common_sovereign::Block =
+        let block: ikura_shim_common_sovereign::Block =
             client.get_block(height, self.namespace).await?;
         let header = types::Header::new(
             Hash(block.block_hash),

adapters/sovereign/src/spec.rs

@@ -8,7 +8,7 @@ use serde::{Deserialize, Serialize};
 pub struct DaLayerSpec;
 
 pub struct ChainParams {
-    pub namespace_id: [u8; sugondat_nmt::NS_ID_SIZE],
+    pub namespace_id: [u8; ikura_nmt::NS_ID_SIZE],
 }
 
 impl sov_rollup_interface::da::DaSpec for DaLayerSpec {
@@ -17,7 +17,7 @@ impl sov_rollup_interface::da::DaSpec for DaLayerSpec {
     type BlobTransaction = BlobTransaction;
     type Address = Address;
     type ValidityCondition = ChainValidityCondition;
-    type InclusionMultiProof = sugondat_nmt::NamespaceProof;
+    type InclusionMultiProof = ikura_nmt::NamespaceProof;
     type CompletenessProof = ();
     type ChainParams = ChainParams;
 }

adapters/sovereign/src/types/block.rs

@@ -8,7 +8,7 @@ use sov_rollup_interface::{da::BlockHeaderTrait, services::da::SlotData};
 pub struct Block {
     pub header: Header,
     pub transactions: Vec<BlobTransaction>,
-    pub blob_proof: sugondat_nmt::NamespaceProof,
+    pub blob_proof: ikura_nmt::NamespaceProof,
 }
 
 impl SlotData for Block {

adapters/sovereign/src/types/header.rs

@@ -1,9 +1,9 @@
 //! Definition of the header.
 
 use super::Hash;
+use ikura_nmt::TreeRoot;
 use serde::{Deserialize, Serialize};
 use sov_rollup_interface::da::{BlockHeaderTrait, Time};
-use sugondat_nmt::TreeRoot;
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
 pub struct Header {