/// Some type that is able to be collapsed into an account ID. It is not possible to recreate the
/// A `TryMorph` implementation to enforce an upper limit for a result of the outer morphed type.
/// Fallible conversion trait returning an [Option]. Generic over both source and destination types.
/// Fallible conversion trait which returns the argument in the case of being unable to convert.
/// Reversing fallible conversion trait which returns the argument in the case of being unable to
/// Adapter which turns a [Get] implementation into a [Convert] implementation which always returns
/// Multiply and divide by a number that isn't necessarily the same type. Basically just the same
/// Trait for things that can be clear (have no bits set). For numeric types, essentially the same
/// A type that implements Serialize, DeserializeOwned and Debug when in std environment or serde feature is activated.
/// Something which fulfills the abstract idea of a Substrate header. It has types for a `Number`,
// `pallet::call`. Essentially, `construct_runtime` aggregates all calls to create a `RuntimeCall`
// So, if we do not create a trait outside of `Block` that doesn't have `Extrinsic`, we go into a
/// check the validity of a piece of extrinsic information, usually by verifying the signature.
/// Implement for pieces of information that require some additional context `Context` in order to
/// check the validity of a piece of extrinsic information, usually by verifying the signature.
/// Every function call from your runtime has an origin, which specifies where the extrinsic was
/// An opaque set of information attached to the transaction. This could be constructed anywhere
/// Means by which a transaction may be extended. This type embodies both the data and the logic
/// WARNING: It is dangerous to return an error here. To do so will fundamentally invalidate the
for_tuples!( #( let valid = valid.combine_with(Tuple::validate_unsigned(call, info, len)?); )* );
/// Also provides information on to whom this information is attributable and an index that allows
/// [`validate_unsigned`](Self::validate_unsigned) function is mainly being used in the context of
/// (i.e. passing [`validate_unsigned`](Self::validate_unsigned)) from being included in blocks
/// extrinsics, these validity checks should include some checks around uniqueness, for example,
/// Opaque data type that may be destructured into a series of raw byte slices (which represent
/// Convert into an account ID. This is infallible, and may truncate bytes to provide a result.
/// Convert into an account ID, checking that all bytes of the seed are being used in the final
/// NOTE: The account IDs from this and from `into_account` are *not* guaranteed to be distinct
/// Same as `into_sub_account_truncating`, but ensuring that all bytes of the account's seed are
/// used when generating an account. This can help guarantee that different accounts are unique,
/// Format is TYPE_ID ++ encode(sub-seed) ++ 00.... where 00... is indefinite trailing zeroes to
/// Calls a given macro a number of times with a set of fixed params and an incrementing numeral.
($f:ident ($($x:tt)*) $x1:tt, $x2:tt, $x3:tt) => { $f!($($x)* 0); $f!($($x)* 1); $f!($($x)* 2); };
/// Every field type must implement [`BoundToRuntimeAppPublic`](crate::BoundToRuntimeAppPublic).
"a really large amount of additional encoded information which will certainly overflow the account id type ;)"