Add auth refresh

Signed-off-by: georgepisaltu <[email protected]>

Author: georgepisaltu

pallets/transaction-storage/src/benchmarking.rs

@@ -181,6 +181,29 @@ mod benchmarks {
 		Ok(())
 	}
 
+	#[benchmark]
+	fn refresh_account_authorization() -> Result<(), BenchmarkError> {
+		let origin = T::Authorizer::try_successful_origin()
+			.map_err(|_| BenchmarkError::Stop("unable to compute origin"))?;
+		let who: T::AccountId = whitelisted_caller();
+		let transactions = 10;
+		let bytes: u64 = 1024 * 1024;
+		let origin2 = origin.clone();
+		TransactionStorage::<T>::authorize_account(
+			origin2 as T::RuntimeOrigin,
+			who.clone(),
+			transactions,
+			bytes,
+		)
+		.map_err(|_| BenchmarkError::Stop("unable to authorize account"))?;
+
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, who.clone());
+
+		assert_last_event::<T>(Event::AccountAuthorizationRefreshed { who }.into());
+		Ok(())
+	}
+
 	#[benchmark]
 	fn authorize_preimage() -> Result<(), BenchmarkError> {
 		let origin = T::Authorizer::try_successful_origin()
@@ -195,6 +218,27 @@ mod benchmarks {
 		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 max_size: u64 = 1024 * 1024;
+		let origin2 = origin.clone();
+		TransactionStorage::<T>::authorize_preimage(
+			origin2 as T::RuntimeOrigin,
+			hash.clone(),
+			max_size,
+		)
+		.map_err(|_| BenchmarkError::Stop("unable to authorize account"))?;
+
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, hash.clone());
+
+		assert_last_event::<T>(Event::PreimageAuthorizationRefreshed { hash }.into());
+		Ok(())
+	}
+
 	#[benchmark]
 	fn remove_expired_account_authorization() -> Result<(), BenchmarkError> {
 		let origin = T::Authorizer::try_successful_origin()

pallets/transaction-storage/src/lib.rs

@@ -513,6 +513,51 @@ pub mod pallet {
 			Self::deposit_event(Event::ExpiredPreimageAuthorizationRemoved { hash });
 			Ok(())
 		}
+
+		/// Refresh the expiration of an existing authorization for an account.
+		///
+		/// If the account does not have an authorization, the call will fail.
+		///
+		/// Parameters:
+		///
+		/// - `who`: The account to be credited with an authorization to store data.
+		///
+		/// The origin for this call must be the pallet's `Authorizer`. Emits
+		/// [`AccountAuthorizationRefreshed`](Event::AccountAuthorizationRefreshed) when successful.
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::WeightInfo::refresh_account_authorization())]
+		pub fn refresh_account_authorization(
+			origin: OriginFor<T>,
+			who: T::AccountId,
+		) -> DispatchResult {
+			T::Authorizer::ensure_origin(origin)?;
+			Self::refresh_authorization(AuthorizationScope::Account(who.clone()))?;
+			Self::deposit_event(Event::AccountAuthorizationRefreshed { who });
+			Ok(())
+		}
+
+		/// Refresh the expiration of an existing authorization for a preimage of a BLAKE2b hash.
+		///
+		/// If the preimage does not have an authorization, the call will fail.
+		///
+		/// Parameters:
+		///
+		/// - `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
+		/// successful.
+		#[pallet::call_index(8)]
+		#[pallet::weight(T::WeightInfo::refresh_preimage_authorization())]
+		pub fn refresh_preimage_authorization(
+			origin: OriginFor<T>,
+			hash: ContentHash,
+		) -> DispatchResult {
+			T::Authorizer::ensure_origin(origin)?;
+			Self::refresh_authorization(AuthorizationScope::Preimage(hash))?;
+			Self::deposit_event(Event::PreimageAuthorizationRefreshed { hash });
+			Ok(())
+		}
 	}
 
 	#[pallet::event]
@@ -526,9 +571,13 @@ pub mod pallet {
 		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 },
 		/// An expired account authorization was removed.
 		ExpiredAccountAuthorizationRemoved { who: T::AccountId },
 		/// An expired preimage authorization was removed.
@@ -678,6 +727,22 @@ pub mod pallet {
 			});
 		}
 
+		/// Authorize data storage.
+		fn refresh_authorization(scope: AuthorizationScopeFor<T>) -> DispatchResult {
+			let expiration = frame_system::Pallet::<T>::block_number()
+				.saturating_add(T::AuthorizationPeriod::get());
+
+			Authorizations::<T>::mutate(&scope, |maybe_authorization| {
+				if let Some(authorization) = maybe_authorization {
+					authorization.expiration = expiration;
+					Ok(())
+				} else {
+					// No previous authorization to refresh.
+					return Err(Error::<T>::AuthorizationNotFound.into())
+				}
+			})
+		}
+
 		/// Remove an expired authorization.
 		fn remove_expired_authorization(scope: AuthorizationScopeFor<T>) -> DispatchResult {
 			// In the case of a regular unsigned transaction, pre_dispatch should have checked that

pallets/transaction-storage/src/weights.rs

@@ -56,7 +56,9 @@ pub trait WeightInfo {
 	fn renew() -> Weight;
 	fn check_proof() -> Weight;
 	fn authorize_account() -> Weight;
+	fn refresh_account_authorization() -> Weight;
 	fn authorize_preimage() -> Weight;
+	fn refresh_preimage_authorization() -> Weight;
 	fn remove_expired_account_authorization() -> Weight;
 	fn remove_expired_preimage_authorization() -> Weight;
 }
@@ -121,9 +123,15 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	fn authorize_account() -> Weight {
 		Weight::from_parts(1_000, 1_000)
 	}
+	fn refresh_account_authorization() -> Weight {
+		Weight::from_parts(1_000, 1_000)
+	}
 	fn authorize_preimage() -> Weight {
 		Weight::from_parts(1_000, 1_000)
 	}
+	fn refresh_preimage_authorization() -> Weight {
+		Weight::from_parts(1_000, 1_000)
+	}
 	fn remove_expired_account_authorization() -> Weight {
 		Weight::from_parts(1_000, 1_000)
 	}
@@ -191,9 +199,15 @@ impl WeightInfo for () {
 	fn authorize_account() -> Weight {
 		Weight::from_parts(1_000, 1_000)
 	}
+	fn refresh_account_authorization() -> Weight {
+		Weight::from_parts(1_000, 1_000)
+	}
 	fn authorize_preimage() -> Weight {
 		Weight::from_parts(1_000, 1_000)
 	}
+	fn refresh_preimage_authorization() -> Weight {
+		Weight::from_parts(1_000, 1_000)
+	}
 	fn remove_expired_account_authorization() -> Weight {
 		Weight::from_parts(1_000, 1_000)
 	}