spelling

Author: gilescope

frame/example-offchain-worker/src/lib.rs

@@ -53,7 +53,7 @@ use frame_support::traits::Get;
 use sp_core::crypto::KeyTypeId;
 use sp_runtime::{
 	RuntimeDebug,
-	offchain::{http, Duration, storage::{MutateStorageError, StorageRetrivalError, StorageValueRef}},
+	offchain::{http, Duration, storage::{MutateStorageError, StorageRetrievalError, StorageValueRef}},
 	traits::Zero,
 	transaction_validity::{InvalidTransaction, ValidTransaction, TransactionValidity},
 };
@@ -366,7 +366,7 @@ impl<T: Config> Pallet<T> {
 		// low-level method of local storage API, which means that only one worker
 		// will be able to "acquire a lock" and send a transaction if multiple workers
 		// happen to be executed concurrently.
-		let res = val.mutate(|last_send: Result<Option<T::BlockNumber>, StorageRetrivalError>| {
+		let res = val.mutate(|last_send: Result<Option<T::BlockNumber>, StorageRetrievalError>| {
 			match last_send {
 				// If we already have a value in storage and the block number is recent enough
 				// we avoid sending another transaction at this time.

frame/im-online/src/lib.rs

@@ -80,7 +80,7 @@ use sp_core::offchain::OpaqueNetworkState;
 use sp_std::prelude::*;
 use sp_std::convert::TryInto;
 use sp_runtime::{
-	offchain::storage::{MutateStorageError, StorageRetrivalError, StorageValueRef},
+	offchain::storage::{MutateStorageError, StorageRetrievalError, StorageValueRef},
 	traits::{AtLeast32BitUnsigned, Convert, Saturating, TrailingZeroInput},
 	Perbill, Permill, PerThing, RuntimeDebug, SaturatedConversion,
 };
@@ -720,7 +720,7 @@ impl<T: Config> Pallet<T> {
 		};
 		let storage = StorageValueRef::persistent(&key);
 		let res = storage.mutate(
-			|status: Result<Option<HeartbeatStatus<T::BlockNumber>>, StorageRetrivalError>| {
+			|status: Result<Option<HeartbeatStatus<T::BlockNumber>>, StorageRetrievalError>| {
 			// Check if there is already a lock for that particular block.
 			// This means that the heartbeat has already been sent, and we are just waiting
 			// for it to be included. However if it doesn't get included for INCLUDE_THRESHOLD

frame/session/src/historical/offchain.rs

@@ -26,7 +26,7 @@
 //! the off-chain indexing API.
 
 use sp_runtime::{
-	offchain::storage::{MutateStorageError, StorageRetrivalError, StorageValueRef},
+	offchain::storage::{MutateStorageError, StorageRetrievalError, StorageValueRef},
 	KeyTypeId
 };
 use sp_session::MembershipProof;
@@ -104,7 +104,7 @@ pub fn prove_session_membership<T: Config, D: AsRef<[u8]>>(
 pub fn prune_older_than<T: Config>(first_to_keep: SessionIndex) {
 	let derived_key = shared::LAST_PRUNE.to_vec();
 	let entry = StorageValueRef::persistent(derived_key.as_ref());
-	match entry.mutate(|current: Result<Option<SessionIndex>, StorageRetrivalError>| -> Result<_, ()> {
+	match entry.mutate(|current: Result<Option<SessionIndex>, StorageRetrievalError>| -> Result<_, ()> {
 		match current {
 			Ok(Some(current)) if current < first_to_keep => Ok(first_to_keep),
 			// do not move the cursor, if the new one would be behind ours

primitives/runtime/src/offchain/storage.rs

@@ -81,10 +81,10 @@ impl<'a> StorageValueRef<'a> {
 	///
 	/// Returns the value if stored.
 	/// Returns an error if the value could not be decoded.
-	pub fn get<T: codec::Decode>(&self) -> Result<Option<T>, StorageRetrivalError> {
+	pub fn get<T: codec::Decode>(&self) -> Result<Option<T>, StorageRetrievalError> {
 		sp_io::offchain::local_storage_get(self.kind, self.key)
 			.map(|val| T::decode(&mut &*val)
-			.map_err(|_| StorageRetrivalError::Undecodable))
+			.map_err(|_| StorageRetrievalError::Undecodable))
 			.transpose()
 	}
 
@@ -100,13 +100,13 @@ impl<'a> StorageValueRef<'a> {
 	/// 3. `Err(MutateStorageError::ValueFunctionFailed(_))` in case `mutate_val` returns an error.
 	pub fn mutate<T, E, F>(&self, mutate_val: F) -> Result<T, MutateStorageError<T,E>> where
 		T: codec::Codec,
-		F: FnOnce(Result<Option<T>, StorageRetrivalError>) -> Result<T, E>
+		F: FnOnce(Result<Option<T>, StorageRetrievalError>) -> Result<T, E>
 	{
 		let value = sp_io::offchain::local_storage_get(self.kind, self.key);
 		let decoded = value.as_deref()
 			.map(|mut bytes| {
 				T::decode(&mut bytes)
-					.map_err(|_| StorageRetrivalError::Undecodable)
+					.map_err(|_| StorageRetrievalError::Undecodable)
 			}).transpose();
 
 		let val = mutate_val(decoded).map_err(|err| MutateStorageError::ValueFunctionFailed(err))?;
@@ -150,7 +150,7 @@ mod tests {
 			val.set(&15_u32);
 
 			assert_eq!(val.get::<u32>(), Ok(Some(15_u32)));
-			assert_eq!(val.get::<Vec<u8>>(), Err(StorageRetrivalError::Undecodable));
+			assert_eq!(val.get::<Vec<u8>>(), Err(StorageRetrievalError::Undecodable));
 			assert_eq!(
 				state.read().persistent_storage.get(b"testval"),
 				Some(vec![15_u8, 0, 0, 0])

primitives/runtime/src/offchain/storage_lock.rs

@@ -61,7 +61,7 @@
 //! }
 //! ```
 
-use crate::offchain::storage::{StorageRetrivalError, MutateStorageError, StorageValueRef};
+use crate::offchain::storage::{StorageRetrievalError, MutateStorageError, StorageValueRef};
 use crate::traits::AtLeast32BitUnsigned;
 use codec::{Codec, Decode, Encode};
 use sp_core::offchain::{Duration, Timestamp};
@@ -280,7 +280,7 @@ impl<'a, L: Lockable> StorageLock<'a, L> {
 	/// Extend active lock's deadline
 	fn extend_active_lock(&mut self) -> Result<<L as Lockable>::Deadline, ()> {
 		let res = self.value_ref.mutate(
-			|s: Result<Option<L::Deadline>, StorageRetrivalError>| -> Result<<L as Lockable>::Deadline, ()> {
+			|s: Result<Option<L::Deadline>, StorageRetrievalError>| -> Result<<L as Lockable>::Deadline, ()> {
 			match s {
 				// lock is present and is still active, extend the lock.
 				Ok(Some(deadline)) if !<L as Lockable>::has_expired(&deadline) =>
@@ -302,7 +302,7 @@ impl<'a, L: Lockable> StorageLock<'a, L> {
 		new_deadline: L::Deadline,
 	) -> Result<(), <L as Lockable>::Deadline> {
 		let res = self.value_ref.mutate(
-			|s: Result<Option<L::Deadline>, StorageRetrivalError>|
+			|s: Result<Option<L::Deadline>, StorageRetrievalError>|
 			-> Result<<L as Lockable>::Deadline, <L as Lockable>::Deadline> {
 				match s {
 					// no lock set, we can safely acquire it