feat: Quilt client: CLI (#2197)

* CLI support for Quilt

Author: liquid-helium

crates/walrus-core/src/encoding/errors.rs

@@ -194,6 +194,9 @@ pub enum QuiltError {
     /// Failed to decode extension.
     #[error("failed to decode extension {0}: {1}")]
     FailedToDecodeExtension(String, bcs::Error),
+    /// QuiltPatchId is invalid.
+    #[error("QuiltPatchId: {0} is invalid")]
+    QuiltPatchIdParseError(String),
     /// Other error.
     #[error("other error: {0}")]
     Other(String),

crates/walrus-core/src/encoding/quilt_encoding.rs

@@ -129,6 +129,9 @@ pub trait QuiltApi<V: QuiltVersion> {
         target_value: &str,
     ) -> Result<Vec<QuiltStoreBlob<'static>>, QuiltError>;
 
+    /// Returns all the blobs in the quilt.
+    fn get_all_blobs(&self) -> Result<Vec<QuiltStoreBlob<'static>>, QuiltError>;
+
     /// Returns the quilt index.
     fn quilt_index(&self) -> Result<&V::QuiltIndex, QuiltError>;
 
@@ -445,6 +448,13 @@ impl QuiltEnum {
         }
     }
 
+    /// Returns all the blobs in the quilt.
+    pub fn get_all_blobs(&self) -> Result<Vec<QuiltStoreBlob<'static>>, QuiltError> {
+        match self {
+            QuiltEnum::V1(quilt_v1) => quilt_v1.get_all_blobs(),
+        }
+    }
+
     /// Returns the quilt index.
     pub fn get_quilt_index(&self) -> Result<QuiltIndex, QuiltError> {
         match self {
@@ -457,7 +467,7 @@ impl QuiltEnum {
 ///
 /// A valid identifier is a string that contains only alphanumeric characters,
 /// underscores, hyphens, and periods.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
 pub struct QuiltStoreBlob<'a> {
     /// The blob data, either borrowed or owned.
     blob: Cow<'a, [u8]>,
@@ -892,6 +902,14 @@ impl QuiltApi<QuiltVersionV1> for QuiltV1 {
             .collect()
     }
 
+    fn get_all_blobs(&self) -> Result<Vec<QuiltStoreBlob<'static>>, QuiltError> {
+        self.quilt_index()?
+            .patches()
+            .iter()
+            .map(|patch| QuiltVersionV1::decode_blob(self, usize::from(patch.start_index)))
+            .collect()
+    }
+
     fn quilt_index(&self) -> Result<&QuiltIndexV1, QuiltError> {
         self.quilt_index
             .as_ref()
@@ -1453,7 +1471,7 @@ impl QuiltEncoderApi<QuiltVersionV1> for QuiltEncoderV1<'_> {
 
         let (sliver_pairs, metadata) = encoder.encode_with_metadata();
         let quilt_metadata = QuiltMetadata::V1(QuiltMetadataV1 {
-            quilt_blob_id: *metadata.blob_id(),
+            quilt_id: *metadata.blob_id(),
             metadata: metadata.metadata().clone(),
             index: QuiltIndexV1 {
                 quilt_patches: quilt.quilt_index()?.quilt_patches.clone(),
@@ -2305,7 +2323,7 @@ mod tests {
 
         let (quilt_blob, metadata_with_id) = decoder
             .decode_and_verify(
-                &quilt_metadata_v1.quilt_blob_id,
+                &quilt_metadata_v1.quilt_id,
                 sliver_pairs
                     .iter()
                     .map(|s| s.secondary.clone())

crates/walrus-core/src/lib.rs

@@ -197,6 +197,7 @@ impl Debug for BlobId {
 ///
 /// A quilt patch is a individual blob within a quilt.
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Hash)]
+#[serde(rename_all = "camelCase")]
 pub struct QuiltPatchId {
     /// The BlobId of the quilt as a Walrus blob.
     pub quilt_id: BlobId,

crates/walrus-core/src/metadata.rs

@@ -61,6 +61,7 @@ pub enum VerificationError {
 
 /// Represents a blob within a unencoded quilt.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct QuiltPatchV1 {
     /// The start sliver index of the blob.
     #[serde(skip)]
@@ -147,6 +148,7 @@ impl QuiltPatchV1 {
 
 /// A enum wrapper around the quilt index.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", rename_all_fields = "camelCase")]
 pub enum QuiltIndex {
     /// QuiltIndexV1.
     V1(QuiltIndexV1),
@@ -164,6 +166,13 @@ impl QuiltIndex {
             }
         }
     }
+
+    /// Returns the patches of the quilt index.
+    pub fn patches(&self) -> &[QuiltPatchV1] {
+        match self {
+            QuiltIndex::V1(quilt_index) => &quilt_index.quilt_patches,
+        }
+    }
 }
 
 /// QuiltPatchInternalIdV1.
@@ -249,6 +258,7 @@ impl QuiltPatchInternalIdV1 {
 /// mapped to a contiguous index range.
 // INV: The patches are sorted by their end indices.
 #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct QuiltIndexV1 {
     /// Location/identity index of the blob in the quilt.
     pub quilt_patches: Vec<QuiltPatchV1>,
@@ -311,7 +321,7 @@ impl QuiltMetadata {
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct QuiltMetadataV1 {
     /// The BlobId of the quilt blob.
-    pub quilt_blob_id: BlobId,
+    pub quilt_id: BlobId,
     /// The blob metadata of the quilt blob.
     pub metadata: BlobMetadata,
     /// The index of the quilt.
@@ -321,10 +331,7 @@ pub struct QuiltMetadataV1 {
 impl QuiltMetadataV1 {
     /// Returns the verified metadata for the quilt blob.
     pub fn get_verified_metadata(&self) -> VerifiedBlobMetadataWithId {
-        VerifiedBlobMetadataWithId::new_verified_unchecked(
-            self.quilt_blob_id,
-            self.metadata.clone(),
-        )
+        VerifiedBlobMetadataWithId::new_verified_unchecked(self.quilt_id, self.metadata.clone())
     }
 }
 

crates/walrus-sdk/src/client/client_types.rs

@@ -31,6 +31,7 @@ pub(crate) const BLOB_SPAN_LEVEL: Level = Level::DEBUG;
 
 /// Identifies a stored quilt patch.
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct StoredQuiltPatch {
     /// The identifier of the quilt patch.
     pub identifier: String,

crates/walrus-sdk/src/client/quilt_client.rs

@@ -301,6 +301,30 @@ where
                 .collect::<Result<Vec<_>, _>>(),
         }
     }
+
+    /// Retrieves all the blobs from the quilt.
+    pub async fn get_all_blobs(
+        &mut self,
+        metadata: &VerifiedBlobMetadataWithId,
+        certified_epoch: Epoch,
+    ) -> ClientResult<Vec<QuiltStoreBlob<'static>>> {
+        match &self.reader {
+            QuiltCacheReader::Uninitialized | QuiltCacheReader::Decoder(_) => {
+                let quilt = self
+                    .client
+                    .get_full_quilt(metadata, certified_epoch)
+                    .await?;
+                self.reader = QuiltCacheReader::FullQuilt(quilt);
+            }
+            QuiltCacheReader::FullQuilt(_) => {}
+        }
+
+        let quilt = match &self.reader {
+            QuiltCacheReader::FullQuilt(quilt) => quilt,
+            _ => unreachable!(),
+        };
+        quilt.get_all_blobs().map_err(ClientError::other)
+    }
 }
 
 /// Configuration for the QuiltClient.
@@ -379,7 +403,7 @@ impl<T: ReadClient> QuiltClient<'_, T> {
 
         let quilt_metadata = match quilt_index {
             QuiltIndex::V1(quilt_index) => QuiltMetadata::V1(QuiltMetadataV1 {
-                quilt_blob_id: *quilt_id,
+                quilt_id: *quilt_id,
                 metadata: metadata.metadata().clone(),
                 index: quilt_index.clone(),
             }),
@@ -632,6 +656,28 @@ impl<T: ReadClient> QuiltClient<'_, T> {
             .await
     }
 
+    /// Retrieves all the blobs from the quilt.
+    pub async fn get_all_blobs(
+        &self,
+        quilt_id: &BlobId,
+    ) -> ClientResult<Vec<QuiltStoreBlob<'static>>> {
+        let (certified_epoch, _) = self
+            .client
+            .get_blob_status_and_certified_epoch(quilt_id, None)
+            .await?;
+        let metadata = self
+            .client
+            .retrieve_metadata(certified_epoch, quilt_id)
+            .await?;
+
+        let mut quilt_reader =
+            QuiltReader::<'_, QuiltVersionV1, T>::new(self, self.config.clone(), None).await;
+        quilt_reader
+            .get_all_blobs(&metadata, certified_epoch)
+            .await
+            .map_err(ClientError::other)
+    }
+
     /// Retrieves the quilt from Walrus.
     async fn get_full_quilt(
         &self,

crates/walrus-service/src/client/cli.rs

@@ -13,7 +13,7 @@ use anyhow::{Context, Result};
 use colored::{Color, ColoredString, Colorize};
 use num_bigint::BigUint;
 use serde::{Deserialize, Serialize};
-use walrus_core::BlobId;
+use walrus_core::{BlobId, QuiltPatchId, encoding::QuiltError};
 use walrus_sdk::{
     blocklist::Blocklist,
     client::Client,
@@ -36,6 +36,11 @@ pub use args::{
     NodeSelection,
     NodeSortBy,
     PublisherArgs,
+    QuiltBlobInput,
+    QuiltPatchByIdentifier,
+    QuiltPatchByPatchId,
+    QuiltPatchByTag,
+    QuiltPatchSelector,
     SortBy,
 };
 pub use cli_output::CliOutput;
@@ -418,6 +423,11 @@ pub fn parse_blob_id(input: &str) -> Result<BlobId, BlobIdParseError> {
     })
 }
 
+/// Parses a [`QuiltPatchId`] from a string.
+pub fn parse_quilt_patch_id(input: &str) -> Result<QuiltPatchId, QuiltError> {
+    QuiltPatchId::from_str(input).map_err(|_| QuiltError::QuiltPatchIdParseError(input.to_string()))
+}
+
 /// Helper struct to parse and format blob IDs as decimal numbers.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Hash)]
 #[repr(transparent)]