PublishBlob

Author: ndr-ds

CLI.md

@@ -27,6 +27,7 @@ This document contains the help content for the `linera` command-line program.
 * [`linera service`↴](#linera-service)
 * [`linera faucet`↴](#linera-faucet)
 * [`linera publish-bytecode`↴](#linera-publish-bytecode)
+* [`linera publish-blob`↴](#linera-publish-blob)
 * [`linera create-application`↴](#linera-create-application)
 * [`linera publish-and-create`↴](#linera-publish-and-create)
 * [`linera request-application`↴](#linera-request-application)
@@ -77,6 +78,7 @@ A Byzantine-fault tolerant sidechain with low-latency finality and high throughp
 * `service` — Run a GraphQL service to explore and extend the chains of the wallet
 * `faucet` — Run a GraphQL service that exposes a faucet where users can claim tokens. This gives away the chain's tokens, and is mainly intended for testing
 * `publish-bytecode` — Publish bytecode
+* `publish-blob` — Publish a blob of binary data
 * `create-application` — Create an application
 * `publish-and-create` — Create an application, and publish the required bytecode
 * `request-application` — Request an application from another chain, so it can be used on this one
@@ -553,6 +555,19 @@ Publish bytecode
 
 
 
+## `linera publish-blob`
+
+Publish a blob of binary data
+
+**Usage:** `linera publish-blob <BLOB_PATH> [PUBLISHER]`
+
+###### **Arguments:**
+
+* `<BLOB_PATH>` — Path to blob file to be published
+* `<PUBLISHER>` — An optional chain ID to publish the blob. The default chain of the wallet is used otherwise
+
+
+
 ## `linera create-application`
 
 Create an application

linera-base/src/crypto.rs

@@ -427,6 +427,11 @@ impl CryptoHash {
         CryptoHash(hasher.finalize())
     }
 
+    /// Creates a hash from its raw bytes.
+    pub fn new_from_bytes(bytes: HasherOutput) -> Self {
+        CryptoHash(bytes)
+    }
+
     /// Reads the bytes of the hash value.
     pub fn as_bytes(&self) -> &HasherOutput {
         &self.0

linera-base/src/identifiers.rs

@@ -12,6 +12,15 @@ use std::{
 use anyhow::{anyhow, Context};
 use linera_witty::{WitLoad, WitStore, WitType};
 use serde::{Deserialize, Serialize};
+#[cfg(with_testing)]
+use {
+    proptest::{
+        collection::{vec, VecStrategy},
+        prelude::Arbitrary,
+        strategy::{self, Strategy},
+    },
+    std::ops::RangeInclusive,
+};
 
 use crate::{
     bcs_scalar,
@@ -78,7 +87,7 @@ impl Account {
     }
 }
 
-impl std::fmt::Display for Account {
+impl Display for Account {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self.owner {
             Some(owner) => write!(f, "{}:{}", self.chain_id, owner),
@@ -142,20 +151,58 @@ impl ChainDescription {
 #[cfg_attr(with_testing, derive(Default))]
 pub struct ChainId(pub CryptoHash);
 
-/// A blob ID.
+/// A content addressed blob ID i.e. the hash of the Blob.
 #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Serialize, Deserialize)]
 #[cfg_attr(with_testing, derive(Default))]
 pub struct BlobId(pub CryptoHash);
 
+impl BlobId {
+    /// Creates a new `BlobId` from a `Blob`
+    pub fn new(blob: &Blob) -> Self {
+        BlobId(CryptoHash::new(blob))
+    }
+}
+
+#[cfg(with_testing)]
+impl Arbitrary for BlobId {
+    type Parameters = ();
+    type Strategy = strategy::Map<VecStrategy<RangeInclusive<u8>>, fn(Vec<u8>) -> BlobId>;
+
+    fn arbitrary_with((): Self::Parameters) -> Self::Strategy {
+        use generic_array::typenum::Unsigned;
+        type HasherOutputSize = <sha3::Sha3_256 as sha3::digest::OutputSizeUser>::OutputSize;
+
+        vec(u8::MIN..=u8::MAX, HasherOutputSize::to_usize()).prop_map(|vector| {
+            BlobId(CryptoHash::new_from_bytes(
+                generic_array::GenericArray::clone_from_slice(&vector[..]),
+            ))
+        })
+    }
+}
+
 /// A blob.
-#[derive(Serialize, Deserialize)]
+#[derive(Eq, PartialEq, Debug, Hash, Clone, Serialize, Deserialize)]
 pub struct Blob {
     #[serde(with = "serde_bytes")]
     bytes: Vec<u8>,
 }
 
 impl BcsSignable for Blob {}
 
+impl Blob {
+    /// Loads blob from a file.
+    pub async fn load_from_file(path: impl AsRef<std::path::Path>) -> std::io::Result<Self> {
+        let bytes = std::fs::read(path)?;
+        Ok(Blob { bytes })
+    }
+}
+
+impl Display for BlobId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
 /// The index of a message in a chain.
 #[derive(
     Eq,
@@ -803,6 +850,7 @@ doc_scalar!(
 doc_scalar!(AccountOwner, "An owner of an account.");
 doc_scalar!(Account, "An account");
 doc_scalar!(BlobId, "A blob id");
+doc_scalar!(Blob, "A blob");
 
 #[cfg(test)]
 mod tests {

linera-chain/src/data_types.rs

@@ -4,7 +4,7 @@
 
 use std::{
     borrow::Cow,
-    collections::{HashMap, HashSet},
+    collections::{BTreeMap, HashMap, HashSet},
 };
 
 use async_graphql::{Object, SimpleObject};
@@ -13,12 +13,13 @@ use linera_base::{
     data_types::{Amount, BlockHeight, OracleRecord, Round, Timestamp},
     doc_scalar, ensure,
     identifiers::{
-        Account, ChainId, ChannelName, Destination, GenericApplicationId, MessageId, Owner,
+        Account, Blob, BlobId, ChainId, ChannelName, Destination, GenericApplicationId, MessageId,
+        Owner,
     },
 };
 use linera_execution::{
     committee::{Committee, Epoch, ValidatorName},
-    BytecodeLocation, Message, MessageKind, Operation,
+    BytecodeLocation, Message, MessageKind, Operation, SystemOperation,
 };
 use serde::{de::Deserializer, Deserialize, Serialize};
 
@@ -78,6 +79,18 @@ impl Block {
         locations
     }
 
+    /// Return all the blob ids referred to in this block's operations.
+    pub fn blob_ids(&self) -> Vec<BlobId> {
+        let mut blob_ids = Vec::new();
+        for operation in &self.operations {
+            if let Operation::System(SystemOperation::PublishBlob { blob_id }) = operation {
+                blob_ids.push(blob_id.to_owned());
+            }
+        }
+
+        blob_ids
+    }
+
     /// Returns whether the block contains only rejected incoming messages, which
     /// makes it admissible even on closed chains.
     pub fn has_only_rejected_messages(&self) -> bool {
@@ -221,6 +234,7 @@ pub struct BlockProposal {
     pub owner: Owner,
     pub signature: Signature,
     pub hashed_certificate_values: Vec<HashedCertificateValue>,
+    pub blobs: BTreeMap<BlobId, Blob>,
     pub validated: Option<Certificate>,
 }
 
@@ -800,6 +814,7 @@ impl BlockProposal {
         content: BlockAndRound,
         secret: &KeyPair,
         hashed_certificate_values: Vec<HashedCertificateValue>,
+        blobs: BTreeMap<BlobId, Blob>,
         validated: Option<Certificate>,
     ) -> Self {
         let outcome = validated
@@ -818,6 +833,7 @@ impl BlockProposal {
             owner: secret.public().into(),
             signature,
             hashed_certificate_values,
+            blobs,
             validated,
         }
     }

linera-chain/src/manager.rs

@@ -74,7 +74,7 @@ use linera_base::{
     crypto::{KeyPair, PublicKey},
     data_types::{ArithmeticError, BlockHeight, Round, Timestamp},
     doc_scalar, ensure,
-    identifiers::{ChainId, Owner},
+    identifiers::{Blob, BlobId, ChainId, Owner},
     ownership::ChainOwnership,
 };
 use linera_execution::committee::Epoch;
@@ -134,6 +134,8 @@ pub struct ChainManager {
     pub current_round: Round,
     /// The owners that take over in fallback mode.
     pub fallback_owners: BTreeMap<Owner, (PublicKey, u64)>,
+    /// The pending blobs
+    pub pending_blobs: BTreeMap<BlobId, Blob>,
 }
 
 doc_scalar!(
@@ -202,6 +204,7 @@ impl ChainManager {
             round_timeout,
             current_round,
             fallback_owners,
+            pending_blobs: BTreeMap::new(),
         })
     }
 
@@ -518,6 +521,12 @@ impl ChainManager {
         }
     }
 
+    pub fn add_pending_blobs(&mut self, blobs: BTreeMap<BlobId, Blob>) {
+        for (blob_id, blob) in blobs {
+            self.pending_blobs.insert(blob_id, blob);
+        }
+    }
+
     /// Returns the leader who is allowed to propose a block in the given round, or `None` if every
     /// owner is allowed to propose. Exception: In `Round::Fast`, only super owners can propose.
     fn round_leader(&self, round: Round) -> Option<&Owner> {

linera-chain/src/test.rs

@@ -3,6 +3,8 @@
 
 //! Test utilities
 
+use std::collections::BTreeMap;
+
 use linera_base::{
     crypto::{CryptoHash, KeyPair},
     data_types::{Amount, BlockHeight, Round, Timestamp},
@@ -122,7 +124,7 @@ impl BlockTestExt for Block {
 
     fn into_proposal_with_round(self, key_pair: &KeyPair, round: Round) -> BlockProposal {
         let content = BlockAndRound { block: self, round };
-        BlockProposal::new(content, key_pair, vec![], None)
+        BlockProposal::new(content, key_pair, vec![], BTreeMap::new(), None)
     }
 
     fn into_justified_proposal(
@@ -132,7 +134,7 @@ impl BlockTestExt for Block {
         validated: Certificate,
     ) -> BlockProposal {
         let content = BlockAndRound { block: self, round };
-        BlockProposal::new(content, key_pair, vec![], Some(validated))
+        BlockProposal::new(content, key_pair, vec![], BTreeMap::new(), Some(validated))
     }
 }