Merge branch 'main' into upd_just

Author: x3c41a

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 = "\
@@ -124,27 +124,27 @@ mod benchmarks {
 	#[benchmark]
 	fn store(l: Linear<{ 1 }, { T::MaxTransactionSize::get() }>) -> Result<(), BenchmarkError> {
 		let data = vec![0u8; l as usize];
-		let hash = sp_io::hashing::blake2_256(&data);
+		let content_hash = sp_io::hashing::blake2_256(&data);
 
 		#[extrinsic_call]
 		_(RawOrigin::None, data);
 
 		assert!(!BlockTransactions::<T>::get().is_empty());
-		assert_last_event::<T>(Event::Stored { index: 0, hash }.into());
+		assert_last_event::<T>(Event::Stored { index: 0, content_hash }.into());
 		Ok(())
 	}
 
 	#[benchmark]
 	fn renew() -> Result<(), BenchmarkError> {
 		let data = vec![0u8; T::MaxTransactionSize::get() as usize];
-		let hash = sp_io::hashing::blake2_256(&data);
+		let content_hash = sp_io::hashing::blake2_256(&data);
 		TransactionStorage::<T>::store(RawOrigin::None.into(), data)?;
 		run_to_block::<T>(1u32.into());
 
 		#[extrinsic_call]
 		_(RawOrigin::None, BlockNumberFor::<T>::zero(), 0);
 
-		assert_last_event::<T>(Event::Renewed { index: 0, hash }.into());
+		assert_last_event::<T>(Event::Renewed { index: 0, content_hash }.into());
 		Ok(())
 	}
 
@@ -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

@@ -200,16 +200,26 @@ pub mod pallet {
 		BadDataSize,
 		/// Too many transactions in the block.
 		TooManyTransactions,
-		/// Renewed extrinsic not found.
+		/// Invalid configuration.
+		NotConfigured,
+		/// Renewed extrinsic is not found.
 		RenewedNotFound,
+		/// Attempting to store an empty transaction
+		EmptyTransaction,
 		/// Proof was not expected in this block.
 		UnexpectedProof,
 		/// Proof failed verification.
 		InvalidProof,
-		/// Unable to verify proof becasue state data is missing.
+		/// Missing storage proof.
+		MissingProof,
+		/// Unable to verify proof because state data is missing.
 		MissingStateData,
 		/// Double proof check in the block.
 		DoubleCheck,
+		/// Storage proof was not checked in the block.
+		ProofNotChecked,
+		/// Transaction is too large.
+		TransactionTooLarge,
 		/// Authorization was not found.
 		AuthorizationNotFound,
 		/// Authorization has not expired.
@@ -329,7 +339,7 @@ pub mod pallet {
 					})
 					.map_err(|_| Error::<T>::TooManyTransactions)
 			})?;
-			Self::deposit_event(Event::Stored { index, hash: content_hash });
+			Self::deposit_event(Event::Stored { index, content_hash });
 			Ok(())
 		}
 
@@ -378,7 +388,7 @@ pub mod pallet {
 					})
 					.map_err(|_| Error::<T>::TooManyTransactions)
 			})?;
-			Self::deposit_event(Event::Renewed { index, hash: content_hash });
+			Self::deposit_event(Event::Renewed { index, content_hash });
 			Ok(().into())
 		}
 
@@ -452,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
@@ -461,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(())
 		}
 
@@ -493,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)
@@ -502,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(())
 		}
 
@@ -537,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
@@ -546,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(())
 		}
 	}
@@ -559,24 +569,24 @@ pub mod pallet {
 	#[pallet::generate_deposit(pub(super) fn deposit_event)]
 	pub enum Event<T: Config> {
 		/// Stored data under specified index.
-		Stored { index: u32, hash: ContentHash },
+		Stored { index: u32, content_hash: ContentHash },
 		/// Renewed data under specified index.
-		Renewed { index: u32, hash: ContentHash },
+		Renewed { index: u32, content_hash: ContentHash },
 		/// Storage proof was successfully checked.
 		ProofChecked,
 		/// An account `who` was authorized to store `bytes` bytes in `transactions` transactions.
 		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.
@@ -743,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);
@@ -752,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 }
@@ -870,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(())
@@ -885,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();
@@ -939,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()
@@ -970,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(