Rename variables to content_hash (#129)

* Align Events between Bulletin and SDK

* Rename variables to content_hash

* Update comments

Author: raymondkfcheung

pallets/transaction-storage/src/benchmarking.rs

@@ -33,8 +33,8 @@ use sp_transaction_storage_proof::TransactionStorageProof;
 // for _ in 0..DEFAULT_MAX_BLOCK_TRANSACTIONS {
 //   transactions.push(vec![0; tx_size]);
 // }
-// let hash = vec![0; 32];
-// build_proof(hash.as_slice(), transactions).unwrap().encode()
+// let content_hash = vec![0; 32];
+// build_proof(content_hash.as_slice(), transactions).unwrap().encode()
 // ```
 // while hardforcing target chunk key in `build_proof` to [22, 21, 1, 0].
 const PROOF: &str = "\
@@ -210,30 +210,34 @@ mod benchmarks {
 	fn authorize_preimage() -> Result<(), BenchmarkError> {
 		let origin = T::Authorizer::try_successful_origin()
 			.map_err(|_| BenchmarkError::Stop("unable to compute origin"))?;
-		let hash = [0u8; 32];
+		let content_hash = [0u8; 32];
 		let max_size: u64 = 1024 * 1024;
 
 		#[extrinsic_call]
-		_(origin as T::RuntimeOrigin, hash, max_size);
+		_(origin as T::RuntimeOrigin, content_hash, max_size);
 
-		assert_last_event::<T>(Event::PreimageAuthorized { hash, max_size }.into());
+		assert_last_event::<T>(Event::PreimageAuthorized { content_hash, max_size }.into());
 		Ok(())
 	}
 
 	#[benchmark]
 	fn refresh_preimage_authorization() -> Result<(), BenchmarkError> {
 		let origin = T::Authorizer::try_successful_origin()
 			.map_err(|_| BenchmarkError::Stop("unable to compute origin"))?;
-		let hash = [0u8; 32];
+		let content_hash = [0u8; 32];
 		let max_size: u64 = 1024 * 1024;
 		let origin2 = origin.clone();
-		TransactionStorage::<T>::authorize_preimage(origin2 as T::RuntimeOrigin, hash, max_size)
-			.map_err(|_| BenchmarkError::Stop("unable to authorize account"))?;
+		TransactionStorage::<T>::authorize_preimage(
+			origin2 as T::RuntimeOrigin,
+			content_hash,
+			max_size,
+		)
+		.map_err(|_| BenchmarkError::Stop("unable to authorize account"))?;
 
 		#[extrinsic_call]
-		_(origin as T::RuntimeOrigin, hash);
+		_(origin as T::RuntimeOrigin, content_hash);
 
-		assert_last_event::<T>(Event::PreimageAuthorizationRefreshed { hash }.into());
+		assert_last_event::<T>(Event::PreimageAuthorizationRefreshed { content_hash }.into());
 		Ok(())
 	}
 
@@ -260,18 +264,18 @@ mod benchmarks {
 	fn remove_expired_preimage_authorization() -> Result<(), BenchmarkError> {
 		let origin = T::Authorizer::try_successful_origin()
 			.map_err(|_| BenchmarkError::Stop("unable to compute origin"))?;
-		let hash = [0; 32];
-		TransactionStorage::<T>::authorize_preimage(origin, hash, 1)
+		let content_hash = [0; 32];
+		TransactionStorage::<T>::authorize_preimage(origin, content_hash, 1)
 			.map_err(|_| BenchmarkError::Stop("unable to authorize preimage"))?;
 
 		let period = T::AuthorizationPeriod::get();
 		let now = System::<T>::block_number();
 		run_to_block::<T>(now + period);
 
 		#[extrinsic_call]
-		_(RawOrigin::None, hash);
+		_(RawOrigin::None, content_hash);
 
-		assert_last_event::<T>(Event::ExpiredPreimageAuthorizationRemoved { hash }.into());
+		assert_last_event::<T>(Event::ExpiredPreimageAuthorizationRemoved { content_hash }.into());
 		Ok(())
 	}
 

pallets/transaction-storage/src/lib.rs

@@ -462,7 +462,7 @@ pub mod pallet {
 		///
 		/// Parameters:
 		///
-		/// - `hash`: The BLAKE2b hash of the data to be submitted.
+		/// - `content_hash`: The BLAKE2b hash of the data to be submitted.
 		/// - `max_size`: The maximum size, in bytes, of the preimage.
 		///
 		/// The origin for this call must be the pallet's `Authorizer`. Emits
@@ -471,12 +471,12 @@ pub mod pallet {
 		#[pallet::weight(T::WeightInfo::authorize_preimage())]
 		pub fn authorize_preimage(
 			origin: OriginFor<T>,
-			hash: ContentHash,
+			content_hash: ContentHash,
 			max_size: u64,
 		) -> DispatchResult {
 			T::Authorizer::ensure_origin(origin)?;
-			Self::authorize(AuthorizationScope::Preimage(hash), 1, max_size);
-			Self::deposit_event(Event::PreimageAuthorized { hash, max_size });
+			Self::authorize(AuthorizationScope::Preimage(content_hash), 1, max_size);
+			Self::deposit_event(Event::PreimageAuthorized { content_hash, max_size });
 			Ok(())
 		}
 
@@ -503,7 +503,7 @@ pub mod pallet {
 		///
 		/// Parameters:
 		///
-		/// - `hash`: The BLAKE2b hash that was authorized.
+		/// - `content_hash`: The BLAKE2b hash that was authorized.
 		///
 		/// Emits
 		/// [`ExpiredPreimageAuthorizationRemoved`](Event::ExpiredPreimageAuthorizationRemoved)
@@ -512,10 +512,10 @@ pub mod pallet {
 		#[pallet::weight(T::WeightInfo::remove_expired_preimage_authorization())]
 		pub fn remove_expired_preimage_authorization(
 			_origin: OriginFor<T>,
-			hash: ContentHash,
+			content_hash: ContentHash,
 		) -> DispatchResult {
-			Self::remove_expired_authorization(AuthorizationScope::Preimage(hash))?;
-			Self::deposit_event(Event::ExpiredPreimageAuthorizationRemoved { hash });
+			Self::remove_expired_authorization(AuthorizationScope::Preimage(content_hash))?;
+			Self::deposit_event(Event::ExpiredPreimageAuthorizationRemoved { content_hash });
 			Ok(())
 		}
 
@@ -547,7 +547,7 @@ pub mod pallet {
 		///
 		/// Parameters:
 		///
-		/// - `hash`: The BLAKE2b hash of the data to be submitted.
+		/// - `content_hash`: The BLAKE2b hash of the data to be submitted.
 		///
 		/// The origin for this call must be the pallet's `Authorizer`. Emits
 		/// [`PreimageAuthorizationRefreshed`](Event::PreimageAuthorizationRefreshed) when
@@ -556,11 +556,11 @@ pub mod pallet {
 		#[pallet::weight(T::WeightInfo::refresh_preimage_authorization())]
 		pub fn refresh_preimage_authorization(
 			origin: OriginFor<T>,
-			hash: ContentHash,
+			content_hash: ContentHash,
 		) -> DispatchResult {
 			T::Authorizer::ensure_origin(origin)?;
-			Self::refresh_authorization(AuthorizationScope::Preimage(hash))?;
-			Self::deposit_event(Event::PreimageAuthorizationRefreshed { hash });
+			Self::refresh_authorization(AuthorizationScope::Preimage(content_hash))?;
+			Self::deposit_event(Event::PreimageAuthorizationRefreshed { content_hash });
 			Ok(())
 		}
 	}
@@ -578,15 +578,15 @@ pub mod pallet {
 		AccountAuthorized { who: T::AccountId, transactions: u32, bytes: u64 },
 		/// An authorization for account `who` was refreshed.
 		AccountAuthorizationRefreshed { who: T::AccountId },
-		/// Authorization was given for a preimage of `hash` (not exceeding `max_size`) to be
-		/// stored by anyone.
-		PreimageAuthorized { hash: ContentHash, max_size: u64 },
-		/// An authorization for a preimage of `hash` was refreshed.
-		PreimageAuthorizationRefreshed { hash: ContentHash },
+		/// Authorization was given for a preimage of `content_hash` (not exceeding `max_size`) to
+		/// be stored by anyone.
+		PreimageAuthorized { content_hash: ContentHash, max_size: u64 },
+		/// An authorization for a preimage of `content_hash` was refreshed.
+		PreimageAuthorizationRefreshed { content_hash: ContentHash },
 		/// An expired account authorization was removed.
 		ExpiredAccountAuthorizationRemoved { who: T::AccountId },
 		/// An expired preimage authorization was removed.
-		ExpiredPreimageAuthorizationRemoved { hash: ContentHash },
+		ExpiredPreimageAuthorizationRemoved { content_hash: ContentHash },
 	}
 
 	/// Authorizations, keyed by scope.
@@ -753,7 +753,7 @@ pub mod pallet {
 			// In the case of a regular unsigned transaction, pre_dispatch should have checked that
 			// the authorization exists and has expired
 			let Some(authorization) = Authorizations::<T>::take(&scope) else {
-				return Err(Error::<T>::AuthorizationNotFound.into())
+				return Err(Error::<T>::AuthorizationNotFound.into());
 			};
 			ensure!(Self::expired(authorization.expiration), Error::<T>::AuthorizationNotExpired);
 			Self::authorization_removed(&scope);
@@ -762,7 +762,7 @@ pub mod pallet {
 
 		fn authorization_extent(scope: AuthorizationScopeFor<T>) -> AuthorizationExtent {
 			let Some(authorization) = Authorizations::<T>::get(&scope) else {
-				return AuthorizationExtent { transactions: 0, bytes: 0 }
+				return AuthorizationExtent { transactions: 0, bytes: 0 };
 			};
 			if Self::expired(authorization.expiration) {
 				AuthorizationExtent { transactions: 0, bytes: 0 }
@@ -880,7 +880,7 @@ pub mod pallet {
 			scope: AuthorizationScopeFor<T>,
 		) -> Result<(), TransactionValidityError> {
 			let Some(authorization) = Authorizations::<T>::get(&scope) else {
-				return Err(AUTHORIZATION_NOT_FOUND.into())
+				return Err(AUTHORIZATION_NOT_FOUND.into());
 			};
 			if Self::expired(authorization.expiration) {
 				Ok(())
@@ -895,11 +895,11 @@ pub mod pallet {
 			context: CheckContext,
 		) -> Result<Option<ValidTransaction>, TransactionValidityError> {
 			if !Self::data_size_ok(size) {
-				return Err(BAD_DATA_SIZE.into())
+				return Err(BAD_DATA_SIZE.into());
 			}
 
 			if Self::block_transactions_full() {
-				return Err(InvalidTransaction::ExhaustsResources.into())
+				return Err(InvalidTransaction::ExhaustsResources.into());
 			}
 
 			let hash = hash();
@@ -949,13 +949,13 @@ pub mod pallet {
 						.into()
 					}))
 				},
-				Call::<T>::remove_expired_preimage_authorization { hash } => {
-					Self::check_authorization_expired(AuthorizationScope::Preimage(*hash))?;
+				Call::<T>::remove_expired_preimage_authorization { content_hash } => {
+					Self::check_authorization_expired(AuthorizationScope::Preimage(*content_hash))?;
 					Ok(context.want_valid_transaction().then(|| {
 						ValidTransaction::with_tag_prefix(
 							"TransactionStorageRemoveExpiredPreimageAuthorization",
 						)
-						.and_provides(hash)
+						.and_provides(content_hash)
 						.priority(T::RemoveExpiredAuthorizationPriority::get())
 						.longevity(T::RemoveExpiredAuthorizationLongevity::get())
 						.into()
@@ -980,11 +980,11 @@ pub mod pallet {
 			};
 
 			if !Self::data_size_ok(size) {
-				return Err(BAD_DATA_SIZE.into())
+				return Err(BAD_DATA_SIZE.into());
 			}
 
 			if Self::block_transactions_full() {
-				return Err(InvalidTransaction::ExhaustsResources.into())
+				return Err(InvalidTransaction::ExhaustsResources.into());
 			}
 
 			Self::check_authorization(