lib.rs

// This file is part of Substrate.

// Copyright (C) 2017-2021 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// 	http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! Support code for the runtime.

#![cfg_attr(not(feature = "std"), no_std)]

/// Export ourself as `frame_support` to make tests happy.
extern crate self as frame_support;

#[doc(hidden)]
pub use sp_tracing;

#[cfg(feature = "std")]
pub use serde;
pub use sp_core::Void;
#[doc(hidden)]
pub use sp_std;
#[doc(hidden)]
pub use codec;
#[cfg(feature = "std")]
#[doc(hidden)]
pub use once_cell;
#[doc(hidden)]
pub use paste;
#[cfg(feature = "std")]
#[doc(hidden)]
pub use sp_state_machine::BasicExternalities;
#[doc(hidden)]
pub use sp_io::{storage::root as storage_root, self};
#[doc(hidden)]
pub use sp_runtime::RuntimeDebug;
#[doc(hidden)]
pub use log;
#[doc(hidden)]
pub use frame_metadata as metadata;

#[macro_use]
mod origin;
#[macro_use]
pub mod dispatch;
pub mod storage;
mod hash;
#[macro_use]
pub mod event;
#[macro_use]
pub mod genesis_config;
#[macro_use]
pub mod inherent;
#[macro_use]
pub mod unsigned;
#[macro_use]
pub mod error;
pub mod traits;
pub mod weights;
pub mod instances;

pub use self::hash::{
	Twox256, Twox128, Blake2_256, Blake2_128, Identity, Twox64Concat, Blake2_128Concat, Hashable,
	StorageHasher, ReversibleStorageHasher
};
pub use self::storage::{
	StorageValue, StorageMap, StorageDoubleMap, StorageNMap, StoragePrefixedMap,
	IterableStorageMap, IterableStorageDoubleMap, IterableStorageNMap, migration,
	bounded_vec::{BoundedVec, BoundedSlice}, weak_bounded_vec::WeakBoundedVec,
};
pub use self::dispatch::{Parameter, Callable};
pub use sp_runtime::{self, ConsensusEngineId, print, traits::Printable};

use codec::{Encode, Decode};
use sp_runtime::TypeId;

/// A unified log target for support operations.
pub const LOG_TARGET: &'static str = "runtime::frame-support";

/// A type that cannot be instantiated.
#[derive(Debug, PartialEq, Eq, Clone)]
pub enum Never {}

/// A pallet identifier. These are per pallet and should be stored in a registry somewhere.
#[derive(Clone, Copy, Eq, PartialEq, Encode, Decode)]
pub struct PalletId(pub [u8; 8]);

impl TypeId for PalletId {
	const TYPE_ID: [u8; 4] = *b"modl";
}

/// Generate a new type alias for [`storage::types::StorageValue`],
/// [`storage::types::StorageMap`] and [`storage::types::StorageDoubleMap`].
///
/// Useful for creating a *storage-like* struct for test and migrations.
///
///```
/// # use frame_support::generate_storage_alias;
/// use frame_support::codec;
/// use frame_support::Twox64Concat;
/// // generate a storage value with type u32.
/// generate_storage_alias!(Prefix, StorageName => Value<u32>);
///
/// // generate a double map from `(u32, u32)` (with hasher `Twox64Concat`) to `Vec<u8>`
/// generate_storage_alias!(
/// 	OtherPrefix, OtherStorageName => DoubleMap<
/// 		(u32, u32),
/// 		(u32, u32),
/// 		Vec<u8>
/// 	>
/// );
///
/// // generate a map from `Config::AccountId` (with hasher `Twox64Concat`) to `Vec<u8>`
/// trait Config { type AccountId: codec::FullCodec; }
/// generate_storage_alias!(
/// 	Prefix, GenericStorage<T: Config> => Map<(Twox64Concat, T::AccountId), Vec<u8>>
/// );
/// # fn main() {}
/// ```
#[macro_export]
macro_rules! generate_storage_alias {
	// without generic for $name.
	($pallet:ident, $name:ident => Map<($key:ty, $hasher:ty), $value:ty>) => {
		$crate::paste::paste! {
			$crate::generate_storage_alias!(@GENERATE_INSTANCE_STRUCT $pallet, $name);
			type $name = $crate::storage::types::StorageMap<
				[<$name Instance>],
				$hasher,
				$key,
				$value,
			>;
		}
	};
	($pallet:ident, $name:ident => DoubleMap<($key1:ty, $hasher1:ty), ($key2:ty, $hasher2:ty), $value:ty>) => {
		$crate::paste::paste! {
			$crate::generate_storage_alias!(@GENERATE_INSTANCE_STRUCT $pallet, $name);
			type $name = $crate::storage::types::StorageDoubleMap<
				[<$name Instance>],
				$hasher1,
				$key1,
				$hasher2,
				$key2,
				$value,
			>;
		}
	};
	($pallet:ident, $name:ident => Value<$value:ty>) => {
		$crate::paste::paste! {
			$crate::generate_storage_alias!(@GENERATE_INSTANCE_STRUCT $pallet, $name);
			type $name = $crate::storage::types::StorageValue<
				[<$name Instance>],
				$value,
			>;
		}
	};
	// with generic for $name.
	($pallet:ident, $name:ident<$t:ident : $bounds:tt> => Map<($key:ty, $hasher:ty), $value:ty>) => {
		$crate::paste::paste! {
			$crate::generate_storage_alias!(@GENERATE_INSTANCE_STRUCT $pallet, $name);
			#[allow(type_alias_bounds)]
			type $name<$t : $bounds> = $crate::storage::types::StorageMap<
				[<$name Instance>],
				$key,
				$hasher,
				$value,
			>;
		}
	};
	(
		$pallet:ident,
		$name:ident<$t:ident : $bounds:tt>
		=> DoubleMap<($key1:ty, $hasher1:ty), ($key2:ty, $hasher2:ty), $value:ty>) => {
		$crate::paste::paste! {
			$crate::generate_storage_alias!(@GENERATE_INSTANCE_STRUCT $pallet, $name);
			#[allow(type_alias_bounds)]
			type $name<$t : $bounds> = $crate::storage::types::StorageDoubleMap<
				[<$name Instance>],
				$key1,
				$hasher1,
				$key2,
				$hasher2,
				$value,
			>;
		}
	};
	($pallet:ident, $name:ident<$t:ident : $bounds:tt> => Value<$value:ty>) => {
		$crate::paste::paste! {
			$crate::generate_storage_alias!(@GENERATE_INSTANCE_STRUCT $pallet, $name);
			#[allow(type_alias_bounds)]
			type $name<$t : $bounds> = $crate::storage::types::StorageValue<