CID support and ensure compatibility

Author: bkontur

examples/common.js

@@ -1,6 +1,8 @@
-import { blake2AsU8a } from '@polkadot/util-crypto'
+import {blake2AsU8a, keccak256AsU8a, sha256AsU8a} from '@polkadot/util-crypto'
 import * as multihash from 'multiformats/hashes/digest'
 import { CID } from 'multiformats/cid'
+import * as sha256 from "multiformats/hashes/sha2";
+import assert from "assert";
 
 export async function waitForNewBlock() {
     // TODO: wait for a new block.
@@ -9,18 +11,83 @@ export async function waitForNewBlock() {
 }
 
 /**
- * helper: create CID for raw data
+ * Create CID for data.
+ * Default to `0x55 (raw)` with blake2b_256 hash.
+ *
+ * 0xb220:
+ * - 0xb2 = the multihash algorithm family for BLAKE2b
+ * - 0x20 = the digest length in bytes (32 bytes = 256 bits)
+ *
+ * See: https://github.com/multiformats/multicodec/blob/master/table.csv
  */
-export function cidFromBytes(bytes, cidCodec) {
-    const hash = blake2AsU8a(bytes)
+export async function cidFromBytes(bytes, cidCodec = 0x55, mhCode = 0xb220) {
+    console.log(`Using cidCodec: ${cidCodec} and mhCode: ${mhCode}`);
+    let mh;
+    switch (mhCode) {
+        case 0xb220: // blake2b-256
+            mh = multihash.create(mhCode, blake2AsU8a(bytes));
+            break;
+        case 0x12:   // sha2-256
+            mh = multihash.create(mhCode, sha256AsU8a(bytes));
+            // Equivalent to:
+            //  import * as sha256 from "multiformats/hashes/sha2";
+            //  mh = sha256.sha256.digest(bytes);
+            break;
+        case 0x1b:   // keccak-256
+            mh = multihash.create(mhCode, keccak256AsU8a(bytes));
+            break;
 
-    // 0xb2 = the multihash algorithm family for BLAKE2b
-    // 0x20 = the digest length in bytes (32 bytes = 256 bits)
-    const mh = multihash.create(0xb220, hash)
+        default:
+            throw new Error("Unhandled multihash code: " + mhCode)
+    }
+    console.log("Multihash:", mh);
+    return CID.createV1(cidCodec, mh)
+}
+
+async function test() {
+    let bytes = new Uint8Array(Buffer.from("Hello, Bulletin with PAPI - Fri Nov 21 2025 11:09:18 GMT+0000"));
+    let cid;
+
+    console.log("\n == blake2b_256 ==");
+    // Raw with blake2b_256 hash:
+    cid = await cidFromBytes(bytes);
+    console.log("Generated CID:", cid.toString(), "\n");
+    // Generated CID: bafk2bzacedvk4eijklisgdjijnxky24pmkg7jgk5vsct4mwndj3nmx7plzz7m
+
+    // DAG-PB with blake2b_256 hash:
+    cid = await cidFromBytes(bytes, 0x70);
+    console.log("Generated CID:", cid.toString(), "\n");
+    // Generated CID: bafykbzacedvk4eijklisgdjijnxky24pmkg7jgk5vsct4mwndj3nmx7plzz7m
 
-    // Default to `0x55 (raw)` if cidCodec is not provided.
-    const codec = cidCodec != null ? cidCodec : 0x55;
+    console.log("\n == ssha2_256 ==");
+    // Raw with ssha2_256 hash:
+    cid = await cidFromBytes(bytes, 0x55, 0x12);
+    console.log("Generated CID:", cid.toString(), "\n");
 
-    console.log("Generate CID - using codec:", codec);
-    return CID.createV1(codec, mh)
+    // DAG-PB with ssha2_256 hash:
+    cid = await cidFromBytes(bytes, 0x70, 0x12);
+    console.log("Generated CID:", cid.toString(), "\n");
+
+    console.log("\n == keccak_256 ==");
+    // Raw with keccak_256 hash:
+    cid = await cidFromBytes(bytes, 0x55, 0x1b);
+    console.log("Generated CID:", cid.toString(), "\n");
+
+    // DAG-PB with ssha2_256 hash:
+    cid = await cidFromBytes(bytes, 0x70, 0x1b);
+    console.log("Generated CID:", cid.toString(), "\n");
+
+    // Make sure sha equivalent works:
+    console.log("\n\n == SHA256 equivalent ==");
+    let hash = await sha256.sha256.digest(bytes);
+    let cid_sha256 = CID.createV1(0x70, hash);
+    cid = await cidFromBytes(bytes, 0x70, 0x12);
+    assert.deepStrictEqual(
+        cid_sha256,
+        cid,
+        '❌ SHA CID calculation not compatible!'
+    );
+    console.log("Matches!");
 }
+
+test().catch(console.error);

pallets/transaction-storage/src/cids.rs

@@ -17,8 +17,11 @@
 //!
 //! This module provides types and functions to compute CIDs for raw data or
 //! DAG blocks using supported hashing algorithms and codecs.
+//!
+//! See [`CidData`].
 
 use crate::LOG_TARGET;
+use alloc::vec::Vec;
 use cid::{multihash::Multihash, CidGeneric};
 use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen};
 use polkadot_sdk_frame::deps::sp_io;
@@ -66,12 +69,12 @@ impl HashingAlgorithm {
 	/// 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)
+	/// - Blake2b-256 = 0xb220
+	/// - SHA2-256 = 0x12
+	/// - Keccak-256 = 0x1b
 	pub fn multihash_code(&self) -> u64 {
 		match self {
-			HashingAlgorithm::Blake2b256 => 0xb2,
+			HashingAlgorithm::Blake2b256 => 0xb220,
 			HashingAlgorithm::Sha2_256 => 0x12,
 			HashingAlgorithm::Keccak256 => 0x1b,
 		}
@@ -98,8 +101,12 @@ pub struct CidConfig {
 }
 
 /// Representation of a generated CID.
+#[derive(Debug, PartialEq, Eq)]
 pub struct CidData {
 	/// 32-byte content hash of the input data.
+	///
+	/// Note: This is used for indexing transactions and retrieving
+	/// `self.client.indexed_transaction(hash)`. Note: This is equal to `cid.hash().digest()`.
 	pub content_hash: ContentHash,
 	/// Hashing algorithm used.
 	pub hashing: HashingAlgorithm,
@@ -146,5 +153,92 @@ pub fn calculate_cid(data: &[u8], config: Option<CidConfig>) -> Result<CidData,
 	Ok(CidData { content_hash, hashing, codec, cid: cid_bytes })
 }
 
-// TODO: add here more tests for compatibility.
+#[cfg(test)]
+mod tests {
+	use super::{calculate_cid, CidConfig, HashingAlgorithm};
+	use cid::{
+		multibase::{encode as to_base32, Base},
+		CidGeneric,
+	};
+	use core::str::FromStr;
+	use polkadot_sdk_frame::deps::sp_io;
+
+	#[test]
+	fn test_cid_raw_blake2b_256_roundtrip_works() {
+		// Prepare data.
+		let data = "Hello, Bulletin with PAPI - Fri Nov 21 2025 11:09:18 GMT+0000";
+		let expected_content_hash = sp_io::hashing::blake2_256(data.as_bytes());
+
+		// Expected raw CID calculated for the same data with `examples/common.js`.
+		let expected_cid_base32 = "bafk2bzacedvk4eijklisgdjijnxky24pmkg7jgk5vsct4mwndj3nmx7plzz7m";
+		let expected_cid = CidGeneric::<32>::from_str(expected_cid_base32).expect("valid_cid");
+		assert_eq!(expected_cid.codec(), 0x55);
+		assert_eq!(expected_cid.hash().code(), 0xb220);
+		assert_eq!(expected_cid.hash().size(), 0x20);
+		assert_eq!(expected_cid.hash().digest(), expected_content_hash);
+
+		// Calculate CIDv1 with default raw codec and blake2b-256.
+		let cid_raw = calculate_cid(data.as_ref(), None).expect("valid_cid");
+		let cid_blake2b_256_raw = calculate_cid(
+			data.as_ref(),
+			Some(CidConfig { codec: 0x55, hashing: HashingAlgorithm::Blake2b256 }),
+		)
+		.expect("valid_cid");
+		assert_eq!(cid_raw.cid, expected_cid.to_bytes());
+		assert_eq!(to_base32(Base::Base32Lower, &cid_raw.cid), expected_cid_base32);
+		assert_eq!(cid_raw.codec, expected_cid.codec());
+		assert_eq!(cid_raw.hashing.multihash_code(), expected_cid.hash().code());
+		assert_eq!(cid_raw.content_hash, expected_cid.hash().digest());
+		assert_eq!(cid_raw, cid_blake2b_256_raw);
+	}
+
+	/// Return the HashingAlgorithm corresponding to a multihash code.
+	pub fn from_multihash_code(code: u64) -> HashingAlgorithm {
+		match code {
+			0xb220 => HashingAlgorithm::Blake2b256,
+			0x12 => HashingAlgorithm::Sha2_256,
+			0x1b => HashingAlgorithm::Keccak256,
+			code @ _ => panic!("{code} is not supported"),
+		}
+	}
 
+	#[test]
+	fn test_cid_various_codecs_and_hashes() {
+		let data = "Hello, Bulletin with PAPI - Fri Nov 21 2025 11:09:18 GMT+0000";
+
+		// Expected results from `examples/common.js`.
+		let expected_cids = vec![
+			// raw + blake2b_256
+			("bafk2bzacedvk4eijklisgdjijnxky24pmkg7jgk5vsct4mwndj3nmx7plzz7m", 0x55, 0xb220),
+			// DAG-PB + blake2b_256
+			("bafykbzacedvk4eijklisgdjijnxky24pmkg7jgk5vsct4mwndj3nmx7plzz7m", 0x70, 0xb220),
+			// Raw + sha2_256
+			("bafkreig5pw2of63kmkldboh6utfovo3o3czig4yj7eb2ragxwca4c4jlke", 0x55, 0x12),
+			// DAG-PB + sha2_256
+			("bafybeig5pw2of63kmkldboh6utfovo3o3czig4yj7eb2ragxwca4c4jlke", 0x70, 0x12),
+			// Raw + keccak_256
+			("bafkrwifr4p73tsatchlyp3hivjee4prqqpcqayikzen46bqldwmt5mzd6e", 0x55, 0x1b),
+			// DAG-PB + keccak_256
+			("bafybwifr4p73tsatchlyp3hivjee4prqqpcqayikzen46bqldwmt5mzd6e", 0x70, 0x1b),
+		];
+
+		for (expected_cid_str, codec, mh_code) in expected_cids {
+			let cid = CidGeneric::<32>::from_str(expected_cid_str).expect("valid CID");
+			// Check codec and multihash code
+			assert_eq!(cid.codec(), codec);
+			assert_eq!(cid.hash().code(), mh_code);
+
+			// Test `calculate_cid`
+			let calculated = calculate_cid(
+				data.as_ref(),
+				Some(CidConfig { codec, hashing: from_multihash_code(mh_code) }),
+			)
+			.expect("calculate_cid succeeded");
+
+			assert_eq!(to_base32(Base::Base32Lower, &calculated.cid), expected_cid_str);
+			assert_eq!(calculated.codec, codec);
+			assert_eq!(calculated.hashing.multihash_code(), mh_code);
+			assert_eq!(calculated.content_hash, cid.hash().digest());
+		}
+	}
+}

pallets/transaction-storage/src/lib.rs

@@ -24,6 +24,8 @@
 // Ensure we're `no_std` when compiling for Wasm.
 #![cfg_attr(not(feature = "std"), no_std)]
 
+extern crate alloc;
+
 mod benchmarking;
 pub mod extension;
 pub mod weights;
@@ -34,6 +36,7 @@ mod mock;
 #[cfg(test)]
 mod tests;
 
+use alloc::vec::Vec;
 use cids::{calculate_cid, Cid, CidConfig, ContentHash};
 use codec::{Decode, Encode, MaxEncodedLen};
 use polkadot_sdk_frame::{
@@ -111,7 +114,7 @@ pub struct TransactionInfo {
 	chunk_root: <BlakeTwo256 as Hash>::Output,
 
 	/// Plain hash of indexed data.
-	content_hash: ContentHash,
+	pub content_hash: ContentHash,
 	/// Used hashing algorithm for `content_hash`.
 	hashing: HashingAlgorithm,
 	/// Requested codec for CIDs.

runtimes/bulletin-polkadot/src/lib.rs

@@ -697,7 +697,7 @@ pub type TxExtension = (
 	frame_system::CheckWeight<Runtime>,
 	ValidateSigned,
 	BridgeRejectObsoleteHeadersAndMessages,
-	pallet_transaction_storage::extension::ProvideCidCodec<Runtime>,
+	pallet_transaction_storage::extension::ProvideCidConfig<Runtime>,
 );
 
 /// Unchecked extrinsic type as expected by this runtime.