extract const

Signed-off-by: bkioshn <bkioshn@gmail.com>

Author: bkioshn

rust/hermes-ipfs/src/constant.rs

@@ -0,0 +1,20 @@
+//! Define constant needed for IPFS and Document Sync
+
+/// Current document synchronization protocol version.
+#[allow(dead_code)]
+pub(crate) const PROTOCOL_VERSION: u8 = 1;
+
+/// `CID` version that Doc Sync supports.
+#[allow(dead_code)]
+pub(crate) const CID_VERSION: u8 = 1;
+
+/// `CID` multihash digest size that Doc Sync supports.
+#[allow(dead_code)]
+pub(crate) const CID_DIGEST_SIZE: u8 = 32;
+
+/// Multihash SHA256.
+#[allow(dead_code)]
+pub(crate) const MULTIHASH_SHA256: u8 = 0x12;
+
+/// Codec CBOR.
+pub(crate) const CODEC_CBOR: u8 = 0x51;

rust/hermes-ipfs/src/doc_sync/envelope.rs

@@ -11,7 +11,10 @@ use catalyst_types::uuid::{self, CborContext, UuidV7};
 use ed25519_dalek::VerifyingKey;
 use minicbor::{Decode, Encode, Encoder, data::Type, encode::Write};
 
-use crate::doc_sync::{PROTOCOL_VERSION, PublicKey, Signature};
+use crate::{
+    constant::PROTOCOL_VERSION,
+    doc_sync::{PublicKey, Signature},
+};
 
 /// The unsigned portion of the message envelope.
 /// This structure corresponds to the **signature input** array:
@@ -47,7 +50,7 @@ impl EnvelopePayload {
         Ok(Self {
             peer: PublicKey(peer),
             seq: UuidV7::new(),
-            ver: PROTOCOL_VERSION,
+            ver: PROTOCOL_VERSION.into(),
             payload,
         })
     }
@@ -99,7 +102,7 @@ impl EnvelopePayload {
         let seq: UuidV7 = decoder.decode_with(&mut CborContext::Tagged)?;
         let ver = decoder.u64()?;
 
-        if ver != PROTOCOL_VERSION {
+        if ver != PROTOCOL_VERSION.into() {
             return Err(minicbor::decode::Error::message(format!(
                 "unsupported protocol version: {ver}"
             )));
@@ -169,7 +172,7 @@ impl<'b, C> Decode<'b, C> for EnvelopePayload {
         let seq: UuidV7 = d.decode_with(&mut CborContext::Tagged)?;
         let ver = d.u64()?;
 
-        if ver != PROTOCOL_VERSION {
+        if ver != PROTOCOL_VERSION.into() {
             return Err(minicbor::decode::Error::message(format!(
                 "unsupported protocol version: {ver}"
             )));
@@ -428,7 +431,7 @@ mod tests {
         signed
             .encode_with(payload.seq, &mut CborContext::Tagged)
             .unwrap();
-        signed.u64(PROTOCOL_VERSION + 1).unwrap();
+        signed.u64(PROTOCOL_VERSION.into() + 1).unwrap();
         <Vec<u8> as Write>::write_all(signed.writer_mut(), &payload.payload).unwrap();
         signed.encode(Signature(signature)).unwrap();
 
@@ -512,7 +515,7 @@ mod tests {
         bad_array
             .encode_with(payload.seq, &mut CborContext::Tagged)
             .unwrap();
-        bad_array.u64(PROTOCOL_VERSION).unwrap();
+        bad_array.u64(PROTOCOL_VERSION.into()).unwrap();
         // Skip payload & signature to force length error or skip signature
 
         let mut envelope = Encoder::new(Vec::new());

rust/hermes-ipfs/src/doc_sync/mod.rs

@@ -12,26 +12,13 @@ pub use envelope::{Envelope, EnvelopePayload};
 use minicbor::{Decode, Encode, Encoder, decode, encode::Write};
 pub use state_machine::{StateMachine, StateSnapshot, SyncState};
 
-/// Current document synchronization protocol version.
-const PROTOCOL_VERSION: u64 = 1;
-
-/// `CID` version that Doc Sync supports.
-const CID_VERSION: u8 = 1;
-
-/// `CID` codec that Doc Sync supports (CBOR).
-const CID_CODEC: u8 = 0x51;
-
-/// `CID` multihash code that Doc Sync supports (SHA256).
-const CID_MULTIHASH_CODE: u8 = 0x12;
-
-/// `CID` multihash digest size that Doc Sync supports.
-const CID_DIGEST_SIZE: u8 = 32;
+use crate::constant::{CID_DIGEST_SIZE, CID_VERSION, CODEC_CBOR, MULTIHASH_SHA256};
 
 /// Validates CID according to Doc Sync specification constraints.
 fn validate_cid(cid: &crate::Cid) -> bool {
     cid.version() as u8 == CID_VERSION
-        && cid.codec() == u64::from(CID_CODEC)
-        && cid.hash().code() == u64::from(CID_MULTIHASH_CODE)
+        && cid.codec() == u64::from(CODEC_CBOR)
+        && cid.hash().code() == u64::from(MULTIHASH_SHA256)
         && cid.hash().digest().len() == usize::from(CID_DIGEST_SIZE)
 }
 

rust/hermes-ipfs/src/doc_sync/payload.rs

@@ -544,13 +544,16 @@ mod tests {
     mod body {
         use minicbor::data::{Tag, Token};
 
+        use crate::constant::{CID_DIGEST_SIZE, CODEC_CBOR, MULTIHASH_SHA256, PROTOCOL_VERSION};
+
         // Generates a valid Doc Sync `CID` (according to the spec).
         const fn generate_cid(seed: u8) -> [u8; 36] {
-            const VERSION: u8 = 1;
-            const CODEC_CBOR: u8 = 0x51;
-            const CODE_SHA_256: u8 = 0x12;
-            const DIGEST_32: u8 = 0x20;
-            let prefix = [VERSION, CODEC_CBOR, CODE_SHA_256, DIGEST_32];
+            let prefix = [
+                PROTOCOL_VERSION,
+                CODEC_CBOR,
+                MULTIHASH_SHA256,
+                CID_DIGEST_SIZE,
+            ];
             let mut ret = [seed; 36];
             ret.split_at_mut(prefix.len()).0.copy_from_slice(&prefix);
             ret

rust/hermes-ipfs/src/lib.rs

@@ -2,6 +2,8 @@
 //!
 //! Provides support for storage, and `PubSub` functionality.
 
+pub(crate) mod constant;
+
 #[cfg(feature = "doc-sync")]
 pub mod doc_sync;
 
@@ -36,6 +38,8 @@ use rust_ipfs::{
     dag::ResolveError, dummy, gossipsub::IntoGossipsubTopic,
 };
 
+use crate::constant::CODEC_CBOR;
+
 #[derive(Debug, Display, From, Into)]
 /// `PubSub` Message ID.
 pub struct MessageId(pub PubsubMessageId);
@@ -177,12 +181,9 @@ impl HermesIpfs {
         &self,
         data: Vec<u8>,
     ) -> anyhow::Result<IpfsPath> {
-        /// Codec for Hermes CID.
-        const CODEC_CBOR: u64 = 0x51;
-
         let cbor_data = minicbor::to_vec(data)
             .map_err(|e| anyhow::anyhow!("Failed to encode data to CBOR: {e:?}"))?;
-        let cid = Cid::new_v1(CODEC_CBOR, Code::Sha2_256.digest(&cbor_data));
+        let cid = Cid::new_v1(CODEC_CBOR.into(), Code::Sha2_256.digest(&cbor_data));
         let block = Block::new(cid, cbor_data)
             .map_err(|e| anyhow::anyhow!("Failed to create IPFS block: {e:?}"))?;
         let ipfs_path: IpfsPath = self.node.put_block(&block).await?.into();