Reworked CID vs content_hash handling

Author: bkontur

Cargo.lock

@@ -20,6 +20,7 @@ westend-runtime-constants = { git = "https://github.com/paritytech/polkadot-sdk.
 array-bytes = { version = "6.1" }
 bp-test-utils = { git = "https://github.com/paritytech/polkadot-sdk.git", rev = "56e4b10bbbbcefcf9e4fe879c88c68902181fc4a" }
 cfg-if = { version = "1.0" }
+cid = { version = "0.11.1", default-features = false }
 clap = { version = "4.2.5" }
 codec = { package = "parity-scale-codec", version = "3.7.5", default-features = false }
 futures = { version = "0.3.21" }

Cargo.toml

@@ -14,6 +14,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
 array-bytes = { optional = true, workspace = true }
+cid = { features = ["alloc"], workspace = true }
 codec = { workspace = true }
 log = { workspace = true, default-features = true }
 scale-info = { features = ["derive"], workspace = true }

pallets/transaction-storage/Cargo.toml

@@ -0,0 +1,150 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Utilities for working with CIDs (Content Identifiers).
+//!
+//! This module provides types and functions to compute CIDs for raw data or
+//! DAG blocks using supported hashing algorithms and codecs.
+
+use crate::LOG_TARGET;
+use cid::{multihash::Multihash, CidGeneric};
+use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen};
+use polkadot_sdk_frame::deps::sp_io;
+
+/// 32-byte hash of a stored blob of data.
+pub type ContentHash = [u8; 32];
+
+/// CIDv1 serialized bytes (codec + multihash(ContentHash)).
+pub type Cid = Vec<u8>;
+
+/// Type alias representing a CID codec (e.g., raw = 0x55, dag-pb = 0x70).
+pub type CidCodec = u64;
+
+/// Supported hashing algorithms for computing CIDs.
+#[derive(
+	Clone,
+	PartialEq,
+	Eq,
+	Encode,
+	Debug,
+	Decode,
+	DecodeWithMemTracking,
+	scale_info::TypeInfo,
+	MaxEncodedLen,
+)]
+pub enum HashingAlgorithm {
+	/// Blake2b-256 hash function.
+	Blake2b256,
+	/// SHA2-256 hash function.
+	Sha2_256,
+	/// Keccak-256 hash function.
+	Keccak256,
+}
+
+impl HashingAlgorithm {
+	/// Compute the hash of the given data using the selected algorithm.
+	pub fn hash(&self, data: &[u8]) -> ContentHash {
+		match self {
+			HashingAlgorithm::Blake2b256 => sp_io::hashing::blake2_256(data),
+			HashingAlgorithm::Sha2_256 => sp_io::hashing::sha2_256(data),
+			HashingAlgorithm::Keccak256 => sp_io::hashing::keccak_256(data),
+		}
+	}
+
+	/// Return the multihash code corresponding to this hashing algorithm.
+	///
+	/// These codes follow the [multihash table](https://github.com/multiformats/multicodec/blob/master/table.csv):
+	/// - Blake2b-256 = 0xb2 (178)
+	/// - SHA2-256 = 0x12 (18)
+	/// - Keccak-256 = 0x1b (27)
+	pub fn multihash_code(&self) -> u64 {
+		match self {
+			HashingAlgorithm::Blake2b256 => 0xb2,
+			HashingAlgorithm::Sha2_256 => 0x12,
+			HashingAlgorithm::Keccak256 => 0x1b,
+		}
+	}
+}
+
+/// Configuration for generating a CID.
+#[derive(
+	Clone,
+	PartialEq,
+	Eq,
+	Encode,
+	Debug,
+	Decode,
+	DecodeWithMemTracking,
+	scale_info::TypeInfo,
+	MaxEncodedLen,
+)]
+pub struct CidConfig {
+	/// CID codec (e.g., raw = 0x55, dag-pb = 0x70).
+	pub codec: CidCodec,
+	/// Hashing algorithm to use for computing the content hash.
+	pub hashing: HashingAlgorithm,
+}
+
+/// Representation of a generated CID.
+pub struct CidData {
+	/// 32-byte content hash of the input data.
+	pub content_hash: ContentHash,
+	/// Hashing algorithm used.
+	pub hashing: HashingAlgorithm,
+	/// Codec used for the CIDv1.
+	pub codec: CidCodec,
+	/// CIDv1 serialized bytes (codec + multihash(content_hash)).
+	pub cid: Cid,
+}
+
+/// Compute a CIDv1 for the given data with optional configuration.
+///
+/// If no configuration is provided, defaults are:
+/// - Codec: raw (0x55)
+/// - Hashing: Blake2b-256
+///
+/// # Errors
+/// Returns `Err(())` if multihash wrapping fails.
+pub fn calculate_cid(data: &[u8], config: Option<CidConfig>) -> Result<CidData, ()> {
+	// Determine hashing algorithm and codec
+	let (hashing, codec) = if let Some(config) = config {
+		(config.hashing, config.codec)
+	} else {
+		// Defaults: raw codec (0x55) and Blake2b-256 hash
+		(HashingAlgorithm::Blake2b256, 0x55)
+	};
+
+	// Hash the data
+	let content_hash = hashing.hash(data);
+
+	// Wrap hash into a multihash
+	let multihash_code = hashing.multihash_code();
+	let mh = Multihash::<32>::wrap(multihash_code, &content_hash).map_err(|e| {
+		log::warn!(
+			target: LOG_TARGET,
+			"Failed to create Multihash for content_hash: {content_hash:?}, multihash_code: {multihash_code:?}, error: {e:?}"
+		);
+		()
+	})?;
+
+	// Create CIDv1 bytes
+	let cid_bytes = CidGeneric::<32>::new_v1(codec, mh).to_bytes();
+
+	// Return all relevant data
+	Ok(CidData { content_hash, hashing, codec, cid: cid_bytes })
+}
+
+// TODO: add here more tests for compatibility.
+

pallets/transaction-storage/src/cids.rs

@@ -17,7 +17,7 @@
 
 //! Custom transaction extension for the transaction storage pallet.
 
-use crate::{Call, CidCodecForStore, Config, LOG_TARGET};
+use crate::{cids::CidConfig, Call, CidConfigForStore, Config, LOG_TARGET};
 use codec::{Decode, DecodeWithMemTracking, Encode};
 use core::{fmt, marker::PhantomData};
 use polkadot_sdk_frame::{
@@ -26,32 +26,23 @@ use polkadot_sdk_frame::{
 	traits::Implication,
 };
 
-/// Type alias representing a CID codec.
-pub type CidCodec = u64;
-
-/// Temporarily tracks provided optional CID codec.
-#[derive(Default)]
-pub struct CidCodecContext {
-	pub codec: Option<CidCodec>,
-}
-
 /// `TransactionExtension` implementation that provides optional `CidCodec` for the `store`
 /// extrinsic.
 #[derive(Clone, PartialEq, Eq, Encode, Decode, DecodeWithMemTracking, scale_info::TypeInfo)]
 #[scale_info(skip_type_params(T))]
-pub struct ProvideCidCodec<T>(pub Option<CidCodec>, PhantomData<T>);
+pub struct ProvideCidConfig<T>(pub Option<CidConfig>, PhantomData<T>);
 
-impl<T> ProvideCidCodec<T> {
-	/// Create a new `ProvideCidCodec` instance.
-	pub fn new(cid_codec: Option<CidCodec>) -> Self {
-		Self(cid_codec, Default::default())
+impl<T> ProvideCidConfig<T> {
+	/// Create a new `ProvideCidConfig` instance.
+	pub fn new(config: Option<CidConfig>) -> Self {
+		Self(config, Default::default())
 	}
 }
 
-impl<T: Config + Send + Sync> fmt::Debug for ProvideCidCodec<T> {
+impl<T: Config + Send + Sync> fmt::Debug for ProvideCidConfig<T> {
 	#[cfg(feature = "std")]
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-		write!(f, "ProvideCidCodec({:?})", self.0)
+		write!(f, "ProvideCidConfig({:?})", self.0)
 	}
 
 	#[cfg(not(feature = "std"))]
@@ -60,18 +51,18 @@ impl<T: Config + Send + Sync> fmt::Debug for ProvideCidCodec<T> {
 	}
 }
 
-impl<T: Config + Send + Sync> TransactionExtension<T::RuntimeCall> for ProvideCidCodec<T>
+impl<T: Config + Send + Sync> TransactionExtension<T::RuntimeCall> for ProvideCidConfig<T>
 where
 	<T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
 {
-	const IDENTIFIER: &'static str = "ProvideCidCodec";
+	const IDENTIFIER: &'static str = "ProvideCidConfig";
 
 	type Implicit = ();
 	fn implicit(&self) -> Result<Self::Implicit, TransactionValidityError> {
 		Ok(())
 	}
 
-	type Val = Option<CidCodec>;
+	type Val = Option<CidConfig>;
 	type Pre = ();
 
 	fn weight(&self, _call: &T::RuntimeCall) -> Weight {
@@ -88,9 +79,9 @@ where
 		_inherited_implication: &impl Implication,
 		_source: TransactionSource,
 	) -> ValidateResult<Self::Val, T::RuntimeCall> {
-		match (self.0, call.is_sub_type()) {
-			(Some(cid_codec), Some(Call::store { .. })) =>
-				Ok((Default::default(), Some(cid_codec), origin)),
+		match (self.0.as_ref(), call.is_sub_type()) {
+			(Some(cid_config), Some(Call::store { .. })) =>
+				Ok((Default::default(), Some(cid_config.clone()), origin)),
 			(Some(_), _) => {
 				// All other calls are invalid with cid_codec.
 				Err(InvalidTransaction::Call.into())
@@ -108,10 +99,17 @@ where
 		_len: usize,
 	) -> Result<Self::Pre, TransactionValidityError> {
 		log::error!(target: LOG_TARGET, "prepare: {val:?}");
-		if let Some(cid_codec) = val {
-			CidCodecForStore::<T>::set(Some(cid_codec));
-
-			// TODO: just attempt, not working, will remove.
+		if let Some(cid_config) = val {
+			// Let's store the codec in the intermediary storage, which will be cleared by the store
+			// extrinsic.
+			CidConfigForStore::<T>::set(Some(cid_config));
+
+			// TODO: just attempt with dispatch `with_context`, not working, will remove.
+			// /// Temporarily tracks provided optional CID codec.
+			// #[derive(Default)]
+			// pub struct CidCodecContext {
+			//	pub codec: Option<CidCodec>,
+			// }
 			// Put cid codec to the dispatch context
 			// with_context::<CidCodecContext, _>(|v| {
 			// 	let context = v.or_default();