Change ChainDescriptions into blobs

Author: bart-linera

CLI.md

@@ -717,12 +717,12 @@ Create an unassigned key pair
 
 Link an owner with a key pair in the wallet to a chain that was created for that owner
 
-**Usage:** `linera assign --owner <OWNER> --message-id <MESSAGE_ID>`
+**Usage:** `linera assign --owner <OWNER> --chain-id <CHAIN_ID>`
 
 ###### **Options:**
 
 * `--owner <OWNER>` — The owner to assign
-* `--message-id <MESSAGE_ID>` — The ID of the message that created the chain. (This uniquely describes the chain and where it was created.)
+* `--chain-id <CHAIN_ID>` — The ID of the chain
 
 
 

examples/Cargo.toml

@@ -2,15 +2,15 @@
 resolver = "2"
 members = [
     "amm",
-    "counter",
     "call-evm-counter",
+    "counter",
     "counter-no-graphql",
     "crowd-funding",
     "ethereum-tracker",
     "fungible",
     "gen-nft",
-    "how-to/perform-http-requests",
     "hex-game",
+    "how-to/perform-http-requests",
     "llm",
     "matching-engine",
     "meta-counter",

examples/hex-game/src/contract.rs

@@ -155,17 +155,14 @@ impl HexContract {
         );
         let app_id = self.runtime.application_id();
         let permissions = ApplicationPermissions::new_single(app_id.forget_abi());
-        let (message_id, chain_id) = self.runtime.open_chain(ownership, permissions, fee_budget);
+        let chain_id = self.runtime.open_chain(ownership, permissions, fee_budget);
         for owner in &players {
             self.state
                 .game_chains
                 .get_mut_or_default(owner)
                 .await
                 .unwrap()
-                .insert(GameChain {
-                    message_id,
-                    chain_id,
-                });
+                .insert(GameChain { chain_id });
         }
         self.runtime.send_message(
             chain_id,

examples/hex-game/src/state.rs

@@ -14,8 +14,6 @@ use serde::{Deserialize, Serialize};
 /// The IDs of a temporary chain for a single game of Hex.
 #[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize, SimpleObject)]
 pub struct GameChain {
-    /// The ID of the `OpenChain` message that created the chain.
-    pub message_id: MessageId,
     /// The ID of the temporary game chain itself.
     pub chain_id: ChainId,
 }

examples/rfq/src/contract.rs

@@ -334,7 +334,7 @@ impl RfqContract {
         );
         let app_id = self.runtime.application_id();
         let permissions = ApplicationPermissions::new_single(app_id.forget_abi());
-        let (_, temp_chain_id) = self.runtime.open_chain(ownership, permissions, fee_budget);
+        let temp_chain_id = self.runtime.open_chain(ownership, permissions, fee_budget);
 
         // transfer tokens to the new chain
         let transfer = fungible::Operation::Transfer {

linera-base/src/data_types.rs

@@ -9,6 +9,7 @@ use std::ops;
 #[cfg(with_metrics)]
 use std::sync::LazyLock;
 use std::{
+    collections::BTreeMap,
     fmt::{self, Display},
     fs,
     hash::Hash,
@@ -31,13 +32,14 @@ use crate::prometheus_util::{
     exponential_bucket_latencies, register_histogram_vec, MeasureLatency,
 };
 use crate::{
-    crypto::{BcsHashable, CryptoHash},
+    crypto::{BcsHashable, CryptoError, CryptoHash},
     doc_scalar, hex_debug, http,
     identifiers::{
         ApplicationId, BlobId, BlobType, ChainId, Destination, EventId, GenericApplicationId,
         ModuleId, StreamId,
     },
     limited_writer::{LimitedWriter, LimitedWriterError},
+    ownership::ChainOwnership,
     time::{Duration, SystemTime},
     vm::VmRuntime,
 };
@@ -707,12 +709,179 @@ impl Amount {
     }
 }
 
+/// What created a chain.
+#[derive(Eq, PartialEq, Ord, PartialOrd, Copy, Clone, Hash, Debug, Serialize, Deserialize)]
+pub enum ChainOrigin {
+    /// The chain was created by the genesis configuration.
+    Root(u32),
+    /// The chain was created by a call from another chain.
+    Child {
+        /// The parent of this chain.
+        parent: ChainId,
+        /// The block height in the parent at which this chain was created.
+        block_height: BlockHeight,
+        /// The index of this chain among chains created at the same block height in the parent
+        /// chain.
+        chain_index: u32,
+    },
+}
+
+impl ChainOrigin {
+    /// Whether the chain was created by another chain.
+    pub fn is_child(&self) -> bool {
+        matches!(self, ChainOrigin::Child { .. })
+    }
+}
+
+/// A number identifying the configuration of the chain (aka the committee).
+#[derive(Eq, PartialEq, Ord, PartialOrd, Copy, Clone, Hash, Default, Debug)]
+pub struct Epoch(pub u32);
+
+impl Epoch {
+    /// The zero epoch.
+    pub const ZERO: Epoch = Epoch(0);
+}
+
+impl Serialize for Epoch {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer,
+    {
+        if serializer.is_human_readable() {
+            serializer.serialize_str(&self.0.to_string())
+        } else {
+            serializer.serialize_newtype_struct("Epoch", &self.0)
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for Epoch {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        if deserializer.is_human_readable() {
+            let s = String::deserialize(deserializer)?;
+            Ok(Epoch(u32::from_str(&s).map_err(serde::de::Error::custom)?))
+        } else {
+            #[derive(Deserialize)]
+            #[serde(rename = "Epoch")]
+            struct EpochDerived(u32);
+
+            let value = EpochDerived::deserialize(deserializer)?;
+            Ok(Self(value.0))
+        }
+    }
+}
+
+impl std::fmt::Display for Epoch {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl std::str::FromStr for Epoch {
+    type Err = CryptoError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Epoch(s.parse()?))
+    }
+}
+
+impl From<u32> for Epoch {
+    fn from(value: u32) -> Self {
+        Epoch(value)
+    }
+}
+
+impl Epoch {
+    /// Tries to return an epoch with a number increased by one. Returns an error if an overflow
+    /// happens.
+    #[inline]
+    pub fn try_add_one(self) -> Result<Self, ArithmeticError> {
+        let val = self.0.checked_add(1).ok_or(ArithmeticError::Overflow)?;
+        Ok(Self(val))
+    }
+
+    /// Tries to add one to this epoch's number. Returns an error if an overflow happens.
+    #[inline]
+    pub fn try_add_assign_one(&mut self) -> Result<(), ArithmeticError> {
+        self.0 = self.0.checked_add(1).ok_or(ArithmeticError::Overflow)?;
+        Ok(())
+    }
+}
+
+/// The configuration for a new chain.
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Serialize, Deserialize)]
+pub struct OpenChainConfig {
+    /// The ownership configuration of the new chain.
+    pub ownership: ChainOwnership,
+    /// The ID of the admin chain.
+    pub admin_id: Option<ChainId>,
+    /// The epoch in which the chain is created.
+    pub epoch: Epoch,
+    /// Blob IDs of the committees corresponding to epochs.
+    pub committees: BTreeMap<Epoch, Vec<u8>>,
+    /// The initial chain balance.
+    pub balance: Amount,
+    /// The initial application permissions.
+    pub application_permissions: ApplicationPermissions,
+}
+
+/// How to create a chain.
+#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Hash, Debug, Serialize, Deserialize)]
+pub struct ChainDescription {
+    origin: ChainOrigin,
+    timestamp: Timestamp,
+    config: OpenChainConfig,
+}
+
+impl ChainDescription {
+    /// Creates a new [`ChainDescription`].
+    pub fn new(origin: ChainOrigin, config: OpenChainConfig, timestamp: Timestamp) -> Self {
+        Self {
+            origin,
+            config,
+            timestamp,
+        }
+    }
+
+    /// Returns the [`ChainId`] based on this [`ChainDescription`].
+    pub fn id(&self) -> ChainId {
+        ChainId::from(self)
+    }
+
+    /// Returns the [`ChainOrigin`] describing who created this chain.
+    pub fn origin(&self) -> ChainOrigin {
+        self.origin
+    }
+
+    /// Returns a reference to the [`OpenChainConfig`] of the chain.
+    pub fn config(&self) -> &OpenChainConfig {
+        &self.config
+    }
+
+    /// Returns the timestamp of when the chain was created.
+    pub fn timestamp(&self) -> Timestamp {
+        self.timestamp
+    }
+
+    /// Whether the chain was created by another chain.
+    pub fn is_child(&self) -> bool {
+        self.origin.is_child()
+    }
+}
+
+impl BcsHashable<'_> for ChainDescription {}
+
 /// Permissions for applications on a chain.
 #[derive(
     Default,
     Debug,
     PartialEq,
     Eq,
+    PartialOrd,
+    Ord,
     Hash,
     Clone,
     Serialize,
@@ -1060,6 +1229,13 @@ impl BlobContent {
         BlobContent::new(BlobType::Committee, committee)
     }
 
+    /// Creates a new chain description [`BlobContent`] from a [`ChainDescription`].
+    pub fn new_chain_description(chain_description: &ChainDescription) -> Self {
+        let bytes = bcs::to_bytes(&chain_description)
+            .expect("Serializing a ChainDescription should not fail!");
+        BlobContent::new(BlobType::ChainDescription, bytes)
+    }
+
     /// Gets a reference to the blob's bytes.
     pub fn bytes(&self) -> &[u8] {
         &self.bytes
@@ -1121,7 +1297,7 @@ impl Blob {
         Blob::new(BlobContent::new_data(bytes))
     }
 
-    /// Creates a new contract bytecode [`BlobContent`] from the provided bytes.
+    /// Creates a new contract bytecode [`Blob`] from the provided bytes.
     pub fn new_contract_bytecode(compressed_bytecode: CompressedBytecode) -> Self {
         Blob::new(BlobContent::new_contract_bytecode(compressed_bytecode))
     }
@@ -1131,19 +1307,28 @@ impl Blob {
         Blob::new(BlobContent::new_evm_bytecode(compressed_bytecode))
     }
 
-    /// Creates a new service bytecode [`BlobContent`] from the provided bytes.
+    /// Creates a new service bytecode [`Blob`] from the provided bytes.
     pub fn new_service_bytecode(compressed_bytecode: CompressedBytecode) -> Self {
         Blob::new(BlobContent::new_service_bytecode(compressed_bytecode))
     }
 
-    /// Creates a new application description [`BlobContent`] from the provided
-    /// description.
+    /// Creates a new application description [`Blob`] from the provided description.
     pub fn new_application_description(application_description: &ApplicationDescription) -> Self {
         Blob::new(BlobContent::new_application_description(
             application_description,
         ))
     }
 
+    /// Creates a new committee [`Blob`] from the provided bytes.
+    pub fn new_committee(committee: impl Into<Box<[u8]>>) -> Self {
+        Blob::new(BlobContent::new_committee(committee))
+    }
+
+    /// Creates a new chain description [`Blob`] from a [`ChainDescription`].
+    pub fn new_chain_description(chain_description: &ChainDescription) -> Self {
+        Blob::new(BlobContent::new_chain_description(chain_description))
+    }
+
     /// A content-addressed blob ID i.e. the hash of the `Blob`.
     pub fn id(&self) -> BlobId {
         BlobId {
@@ -1251,6 +1436,11 @@ doc_scalar!(
     Round,
     "A number to identify successive attempts to decide a value in a consensus protocol."
 );
+doc_scalar!(
+    Epoch,
+    "A number identifying the configuration of the chain (aka the committee)"
+);
+doc_scalar!(ChainDescription, "How to create a chain");
 doc_scalar!(OracleResponse, "A record of a single oracle response.");
 doc_scalar!(BlobContent, "A blob of binary data.");
 doc_scalar!(