// This file is part of Substrate.

// Copyright (C) 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.

//! # Substrate Runtime Primitives.

//!

//! This crate, among other things, contains a large library of types and utilities that are used in

//! the Substrate runtime, but are not particularly `FRAME`-oriented.

//!

//! ## Block, Header and Extrinsics

//!

//! Most notable, this crate contains some of the types and trait that enable important

//! communication between the client and the runtime. This includes:

//!

//! - A set of traits to declare what any block/header/extrinsic type should provide.

//! 	- [`traits::Block`], [`traits::Header`], [`traits::Extrinsic`]

//! - A set of types that implement these traits, whilst still providing a high degree of

//!   configurability via generics.

//! 	- [`generic::Block`], [`generic::Header`], [`generic::UncheckedExtrinsic`] and

//!    [`generic::CheckedExtrinsic`]

//!

//! ## Runtime API Types

//!

//! This crate also contains some types that are often used in conjuncture with Runtime APIs. Most

//! notable:

//!

//! - [`ApplyExtrinsicResult`], and [`DispatchOutcome`], which dictate how the client and runtime

//!   communicate about the success or failure of an extrinsic.

//! - [`transaction_validity`], which dictates how the client and runtime communicate about the

//!  validity of an extrinsic while still in the transaction-queue.

#![warn(missing_docs)]

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

#[doc(hidden)]

extern crate alloc;

#[doc(hidden)]

pub use alloc::vec::Vec;

#[doc(hidden)]

pub use codec;

#[doc(hidden)]

pub use scale_info;

#[cfg(feature = "serde")]

#[doc(hidden)]

pub use serde;

#[doc(hidden)]

pub use sp_std;

#[doc(hidden)]

pub use paste;

#[doc(hidden)]

pub use sp_arithmetic::traits::Saturating;

#[doc(hidden)]

pub use sp_application_crypto as app_crypto;

pub use sp_core::storage::StateVersion;

#[cfg(feature = "std")]

pub use sp_core::storage::{Storage, StorageChild};

use sp_core::{

	crypto::{self, ByteArray, FromEntropy},

	ecdsa, ed25519,

	hash::{H256, H512},

	sr25519,

};

#[cfg(all(not(feature = "std"), feature = "serde"))]

use alloc::format;

use alloc::vec;

use codec::{Decode, Encode, MaxEncodedLen};

use scale_info::TypeInfo;

pub mod curve;

pub mod generic;

pub mod legacy;

mod multiaddress;

pub mod offchain;

pub mod runtime_logger;

mod runtime_string;

#[cfg(feature = "std")]

pub mod testing;

pub mod traits;

pub mod transaction_validity;

pub mod type_with_default;

pub use crate::runtime_string::*;

// Re-export Multiaddress

pub use multiaddress::MultiAddress;

/// Re-export these since they're only "kind of" generic.

pub use generic::{Digest, DigestItem};

pub use sp_application_crypto::{BoundToRuntimeAppPublic, RuntimeAppPublic};

/// Re-export this since it's part of the API of this crate.

pub use sp_core::{

	bounded::{BoundedBTreeMap, BoundedBTreeSet, BoundedSlice, BoundedVec, WeakBoundedVec},

	crypto::{key_types, AccountId32, CryptoType, CryptoTypeId, KeyTypeId},

	TypeId,

};

/// Re-export bounded_vec and bounded_btree_map macros only when std is enabled.

#[cfg(feature = "std")]

pub use sp_core::{bounded_btree_map, bounded_vec};

/// Re-export `RuntimeDebug`, to avoid dependency clutter.

pub use sp_core::RuntimeDebug;

/// Re-export big_uint stuff.

pub use sp_arithmetic::biguint;

/// Re-export 128 bit helpers.

pub use sp_arithmetic::helpers_128bit;

/// Re-export top-level arithmetic stuff.

pub use sp_arithmetic::{

	traits::SaturatedConversion, ArithmeticError, FixedI128, FixedI64, FixedPointNumber,

	FixedPointOperand, FixedU128, FixedU64, InnerOf, PerThing, PerU16, Perbill, Percent, Permill,

	Perquintill, Rational128, Rounding, UpperOf,

};

pub use either::Either;

/// The number of bytes of the module-specific `error` field defined in [`ModuleError`].

/// In FRAME, this is the maximum encoded size of a pallet error type.

pub const MAX_MODULE_ERROR_ENCODED_SIZE: usize = 4;

/// An abstraction over justification for a block's validity under a consensus algorithm.

///

/// Essentially a finality proof. The exact formulation will vary between consensus

/// algorithms. In the case where there are multiple valid proofs, inclusion within

/// the block itself would allow swapping justifications to change the block's hash

/// (and thus fork the chain). Sending a `Justification` alongside a block instead

/// bypasses this problem.

///

/// Each justification is provided as an encoded blob, and is tagged with an ID

/// to identify the consensus engine that generated the proof (we might have

/// multiple justifications from different engines for the same block).

pub type Justification = (ConsensusEngineId, EncodedJustification);

/// The encoded justification specific to a consensus engine.

pub type EncodedJustification = Vec<u8>;

/// Collection of justifications for a given block, multiple justifications may

/// be provided by different consensus engines for the same block.

#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]

pub struct Justifications(Vec<Justification>);

impl Justifications {

	/// Return an iterator over the justifications.

	/// Append a justification. Returns false if a justification with the same

	/// `ConsensusEngineId` already exists, in which case the justification is

	/// not inserted.

	/// Return the encoded justification for the given consensus engine, if it

	/// exists.

	/// Remove the encoded justification for the given consensus engine, if it exists.

	/// Return a copy of the encoded justification for the given consensus

	/// engine, if it exists.

}

impl IntoIterator for Justifications {

	type Item = Justification;

	type IntoIter = alloc::vec::IntoIter<Self::Item>;

}

impl From<Justification> for Justifications {

}

use traits::{Lazy, Verify};

use crate::traits::IdentifyAccount;

#[cfg(feature = "serde")]

pub use serde::{de::DeserializeOwned, Deserialize, Serialize};

/// Complex storage builder stuff.

#[cfg(feature = "std")]

pub trait BuildStorage {

	/// Build the storage out of this builder.

	/// Assimilate the storage for this module into pre-existing overlays.

	fn assimilate_storage(&self, storage: &mut sp_core::storage::Storage) -> Result<(), String>;

}

/// Something that can build the genesis storage of a module.

#[cfg(feature = "std")]

#[deprecated(

	note = "`BuildModuleGenesisStorage` is planned to be removed in December 2023. Use `BuildStorage` instead of it."

)]

pub trait BuildModuleGenesisStorage<T, I>: Sized {

	/// Create the module genesis storage into the given `storage` and `child_storage`.

	fn build_module_genesis_storage(

		&self,

		storage: &mut sp_core::storage::Storage,

	) -> Result<(), String>;

}

#[cfg(feature = "std")]

impl BuildStorage for sp_core::storage::Storage {

		}

}

#[cfg(feature = "std")]

impl BuildStorage for () {

}

/// Consensus engine unique ID.

pub type ConsensusEngineId = [u8; 4];

/// Signature verify that can work with any known signature types.

pub enum MultiSignature {

}

impl From<ed25519::Signature> for MultiSignature {

}

impl TryFrom<MultiSignature> for ed25519::Signature {

	type Error = ();

		} else {

		}

}

impl From<sr25519::Signature> for MultiSignature {

}

impl TryFrom<MultiSignature> for sr25519::Signature {

	type Error = ();

		} else {

		}

}

impl From<ecdsa::Signature> for MultiSignature {

}

impl TryFrom<MultiSignature> for ecdsa::Signature {

	type Error = ();

		} else {

		}

}

/// Public key for any known crypto algorithm.

pub enum MultiSigner {

}

impl FromEntropy for MultiSigner {

		})

}

/// NOTE: This implementations is required by `SimpleAddressDeterminer`,

/// we convert the hash into some AccountId, it's fine to use any scheme.

impl<T: Into<H256>> crypto::UncheckedFrom<T> for MultiSigner {

}

impl AsRef<[u8]> for MultiSigner {

		}

}

impl traits::IdentifyAccount for MultiSigner {

	type AccountId = AccountId32;

		}

}

impl From<ed25519::Public> for MultiSigner {

}

impl TryFrom<MultiSigner> for ed25519::Public {

	type Error = ();

		} else {

		}

}

impl From<sr25519::Public> for MultiSigner {

}

impl TryFrom<MultiSigner> for sr25519::Public {

	type Error = ();

		} else {

		}

}

impl From<ecdsa::Public> for MultiSigner {

}

impl TryFrom<MultiSigner> for ecdsa::Public {

	type Error = ();

		} else {

		}

}

#[cfg(feature = "std")]

impl std::fmt::Display for MultiSigner {

		}

}

impl Verify for MultiSignature {

	type Signer = MultiSigner;

			},

			},

				}

			},

		}

}

/// Signature verify that can work with any known signature types..

pub struct AnySignature(H512);

impl Verify for AnySignature {

	type Signer = sr25519::Public;

}

impl From<sr25519::Signature> for AnySignature {

}

impl From<ed25519::Signature> for AnySignature {

}

impl From<DispatchError> for DispatchOutcome {

}

/// This is the legacy return type of `Dispatchable`. It is still exposed for compatibility reasons.

/// The new return type is `DispatchResultWithInfo`. FRAME runtimes should use

/// `frame_support::dispatch::DispatchResult`.

pub type DispatchResult = core::result::Result<(), DispatchError>;

/// Return type of a `Dispatchable` which contains the `DispatchResult` and additional information

/// about the `Dispatchable` that is only known post dispatch.

pub type DispatchResultWithInfo<T> = core::result::Result<T, DispatchErrorWithPostInfo<T>>;

/// Reason why a pallet call failed.

pub struct ModuleError {

	/// Module index, matching the metadata module index.

	pub index: u8,

	/// Module specific error value.

	pub error: [u8; MAX_MODULE_ERROR_ENCODED_SIZE],

	/// Optional error message.

	#[codec(skip)]

	#[cfg_attr(feature = "serde", serde(skip_deserializing))]

	pub message: Option<&'static str>,

}

impl PartialEq for ModuleError {

}

/// Errors related to transactional storage layers.

pub enum TransactionalError {

}

impl From<TransactionalError> for &'static str {

		}

}

impl From<TransactionalError> for DispatchError {

}

/// Reason why a dispatch call failed.

pub enum DispatchError {

	/// layer.

}

/// Result of a `Dispatchable` which contains the `DispatchResult` and additional information about

/// the `Dispatchable` that is only known post dispatch.

pub struct DispatchErrorWithPostInfo<Info>

where

	Info: Eq + PartialEq + Clone + Copy + Encode + Decode + traits::Printable,

{

	/// Additional information about the `Dispatchable` which is only known post dispatch.

	pub post_info: Info,

	/// The actual `DispatchResult` indicating whether the dispatch was successful.

	pub error: DispatchError,

}

impl DispatchError {

	/// Return the same error but without the attached message.

		}

}

impl<T, E> From<E> for DispatchErrorWithPostInfo<T>

where

	T: Eq + PartialEq + Clone + Copy + Encode + Decode + traits::Printable + Default,

	E: Into<DispatchError>,

{

}

impl From<crate::traits::LookupError> for DispatchError {

}

impl From<crate::traits::BadOrigin> for DispatchError {

}

/// Description of what went wrong when trying to complete an operation on a token.

pub enum TokenError {

}

impl From<TokenError> for &'static str {

			TokenError::CannotCreateHold =>

		}

}

impl From<TokenError> for DispatchError {

}

impl From<ArithmeticError> for DispatchError {

}

impl From<&'static str> for DispatchError {

}

impl From<DispatchError> for &'static str {

		use DispatchError::*;

		}

}

impl<T> From<DispatchErrorWithPostInfo<T>> for &'static str

where

	T: Eq + PartialEq + Clone + Copy + Encode + Decode + traits::Printable,

{

}

impl traits::Printable for DispatchError {

		use DispatchError::*;

			},

		}

}

impl<T> traits::Printable for DispatchErrorWithPostInfo<T>

where

	T: Eq + PartialEq + Clone + Copy + Encode + Decode + traits::Printable,

{

}

/// This type specifies the outcome of dispatching a call to a module.

///

/// In case of failure an error specific to the module is returned.

///

/// Failure of the module call dispatching doesn't invalidate the extrinsic and it is still included

/// in the block, therefore all state changes performed by the dispatched call are still persisted.

///

/// For example, if the dispatching of an extrinsic involves inclusion fee payment then these

/// changes are going to be preserved even if the call dispatched failed.

pub type DispatchOutcome = Result<(), DispatchError>;

/// The result of applying of an extrinsic.

///

/// This type is typically used in the context of `BlockBuilder` to signal that the extrinsic

/// in question cannot be included.

///

/// A block containing extrinsics that have a negative inclusion outcome is invalid. A negative

/// result can only occur during the block production, where such extrinsics are detected and

/// removed from the block that is being created and the transaction pool.

///

/// To rehash: every extrinsic in a valid block must return a positive `ApplyExtrinsicResult`.

///

/// Examples of reasons preventing inclusion in a block:

/// - More block weight is required to process the extrinsic than is left in the block being built.

///   This doesn't necessarily mean that the extrinsic is invalid, since it can still be included in

///   the next block if it has enough spare weight available.

/// - The sender doesn't have enough funds to pay the transaction inclusion fee. Including such a

///   transaction in the block doesn't make sense.

/// - The extrinsic supplied a bad signature. This transaction won't become valid ever.

pub type ApplyExtrinsicResult =

	Result<DispatchOutcome, transaction_validity::TransactionValidityError>;

/// Same as `ApplyExtrinsicResult` but augmented with `PostDispatchInfo` on success.

pub type ApplyExtrinsicResultWithInfo<T> =

	Result<DispatchResultWithInfo<T>, transaction_validity::TransactionValidityError>;

/// The error type used as return type in try runtime hooks.

pub type TryRuntimeError = DispatchError;

/// Verify a signature on an encoded value in a lazy manner. This can be

/// an optimization if the signature scheme has an "unsigned" escape hash.

	// The `Lazy<T>` trait expresses something like `X: FnMut<Output = for<'a> &'a T>`.

	// unfortunately this is a lifetime relationship that can't

	// be expressed without generic associated types, better unification of HRTBs in type position,

	// and some kind of integration into the Fn* traits.

	struct LazyEncode<F> {

		inner: F,

		encoded: Option<Vec<u8>>,

	}

	impl<F: Fn() -> Vec<u8>> traits::Lazy<[u8]> for LazyEncode<F> {

	}

/// Checks that `$x` is equal to `$y` with an error rate of `$error`.

///

/// # Example

///

/// ```rust

/// # fn main() {

/// sp_runtime::assert_eq_error_rate!(10, 10, 0);

/// sp_runtime::assert_eq_error_rate!(10, 11, 1);

/// sp_runtime::assert_eq_error_rate!(12, 10, 2);

/// # }

/// ```

///

/// ```rust,should_panic

/// # fn main() {

/// sp_runtime::assert_eq_error_rate!(12, 10, 1);

/// # }

/// ```

#[macro_export]

#[cfg(feature = "std")]

macro_rules! assert_eq_error_rate {

	($x:expr, $y:expr, $error:expr $(,)?) => {

		assert!(

			($x >= $crate::Saturating::saturating_sub($y, $error)) &&

				($x <= $crate::Saturating::saturating_add($y, $error)),

			"{:?} != {:?} (with error rate {:?})",

			$x,

			$y,

			$error,

		);

	};

}

/// Same as [`assert_eq_error_rate`], but intended to be used with floating point number, or

/// generally those who do not have over/underflow potentials.

#[macro_export]

#[cfg(feature = "std")]

macro_rules! assert_eq_error_rate_float {

	($x:expr, $y:expr, $error:expr $(,)?) => {

		assert!(

			($x >= $y - $error) && ($x <= $y + $error),

			"{:?} != {:?} (with error rate {:?})",

			$x,

			$y,

			$error,

		);

	};

}

/// Simple blob to hold an extrinsic without committing to its format and ensure it is serialized

/// correctly.

pub struct OpaqueExtrinsic(Vec<u8>);

impl OpaqueExtrinsic {

	/// Convert an encoded extrinsic to an `OpaqueExtrinsic`.

}

impl core::fmt::Debug for OpaqueExtrinsic {

	#[cfg(feature = "std")]

	#[cfg(not(feature = "std"))]

	fn fmt(&self, _fmt: &mut core::fmt::Formatter) -> core::fmt::Result {

		Ok(())

	}

}

#[cfg(feature = "serde")]

impl ::serde::Serialize for OpaqueExtrinsic {

}

#[cfg(feature = "serde")]

impl<'a> ::serde::Deserialize<'a> for OpaqueExtrinsic {

}

impl traits::Extrinsic for OpaqueExtrinsic {

	type Call = ();

	type SignaturePayload = ();

}

/// Print something that implements `Printable` from the runtime.

/// Utility function to declare string literals backed by an array of length N.

///

/// The input can be shorter than N, in that case the end of the array is padded with zeros.

///

/// [`str_array`] is useful when converting strings that end up in the storage as fixed size arrays

/// or in const contexts where static data types have strings that could also end up in the storage.

///

/// # Example

///

/// ```rust

/// # use sp_runtime::str_array;

/// const MY_STR: [u8; 6] = str_array("data");

/// assert_eq!(MY_STR, *b"data\0\0");

/// ```

/// Describes on what should happen with a storage transaction.

pub enum TransactionOutcome<R> {

	/// Commit the transaction.

	Commit(R),

	/// Rollback the transaction.

	Rollback(R),

}

impl<R> TransactionOutcome<R> {

	/// Convert into the inner type.

		}

}

/// Confines the kind of extrinsics that can be included in a block.

pub enum ExtrinsicInclusionMode {

}

/// Simple blob that hold a value in an encoded form without committing to its type.

pub struct OpaqueValue(Vec<u8>);

impl OpaqueValue {

	/// Create a new `OpaqueValue` using the given encoded representation.

	/// Try to decode this `OpaqueValue` into the given concrete type.

}

#[cfg(test)]

mod tests {

	use crate::traits::BlakeTwo256;

	use super::*;

	use codec::{Decode, Encode};

	use sp_core::crypto::Pair;

	use sp_io::TestExternalities;

	use sp_state_machine::create_proof_check_backend;

	#[test]

	fn opaque_extrinsic_serialization() {

		let ex = super::OpaqueExtrinsic(vec![1, 2, 3, 4]);

		assert_eq!(serde_json::to_string(&ex).unwrap(), "\"0x1001020304\"".to_owned());

	}

	#[test]

	fn dispatch_error_encoding() {

		let error = DispatchError::Module(ModuleError {

			index: 1,

			error: [2, 0, 0, 0],

			message: Some("error message"),

		});

		let encoded = error.encode();

		let decoded = DispatchError::decode(&mut &encoded[..]).unwrap();

		assert_eq!(encoded, vec![3, 1, 2, 0, 0, 0]);

		assert_eq!(

			decoded,

			DispatchError::Module(ModuleError { index: 1, error: [2, 0, 0, 0], message: None })

		);

	}

	#[test]

	fn dispatch_error_equality() {

		use DispatchError::*;

		let variants = vec![

			Other("foo"),

			Other("bar"),

			CannotLookup,

			BadOrigin,

			Module(ModuleError { index: 1, error: [1, 0, 0, 0], message: None }),

			Module(ModuleError { index: 1, error: [2, 0, 0, 0], message: None }),

			Module(ModuleError { index: 2, error: [1, 0, 0, 0], message: None }),

			ConsumerRemaining,

			NoProviders,

			Token(TokenError::FundsUnavailable),

			Token(TokenError::OnlyProvider),

			Token(TokenError::BelowMinimum),

			Token(TokenError::CannotCreate),

			Token(TokenError::UnknownAsset),

			Token(TokenError::Frozen),

			Arithmetic(ArithmeticError::Overflow),

			Arithmetic(ArithmeticError::Underflow),

			Arithmetic(ArithmeticError::DivisionByZero),

		];

		for (i, variant) in variants.iter().enumerate() {

			for (j, other_variant) in variants.iter().enumerate() {

				if i == j {

					assert_eq!(variant, other_variant);

				} else {

					assert_ne!(variant, other_variant);

				}

			}

		}

		// Ignores `message` field in `Module` variant.

		assert_eq!(

			Module(ModuleError { index: 1, error: [1, 0, 0, 0], message: Some("foo") }),

			Module(ModuleError { index: 1, error: [1, 0, 0, 0], message: None }),

		);

	}

	#[test]

	fn multi_signature_ecdsa_verify_works() {

		let msg = &b"test-message"[..];

		let (pair, _) = ecdsa::Pair::generate();

		let signature = pair.sign(&msg);

		assert!(ecdsa::Pair::verify(&signature, msg, &pair.public()));

		let multi_sig = MultiSignature::from(signature);

		let multi_signer = MultiSigner::from(pair.public());

		assert!(multi_sig.verify(msg, &multi_signer.into_account()));

		let multi_signer = MultiSigner::from(pair.public());

		assert!(multi_sig.verify(msg, &multi_signer.into_account()));

	}

	#[test]

	fn execute_and_generate_proof_works() {

		use codec::Encode;

		use sp_state_machine::Backend;

		let mut ext = TestExternalities::default();

		ext.insert(b"a".to_vec(), vec![1u8; 33]);

		ext.insert(b"b".to_vec(), vec![2u8; 33]);

		ext.insert(b"c".to_vec(), vec![3u8; 33]);

		ext.insert(b"d".to_vec(), vec![4u8; 33]);

		let pre_root = *ext.backend.root();

		let (_, proof) = ext.execute_and_prove(|| {

			sp_io::storage::get(b"a");

			sp_io::storage::get(b"b");

			sp_io::storage::get(b"v");

			sp_io::storage::get(b"d");

		});

		let compact_proof = proof.clone().into_compact_proof::<BlakeTwo256>(pre_root).unwrap();

		let compressed_proof = zstd::stream::encode_all(&compact_proof.encode()[..], 0).unwrap();

		// just an example of how you'd inspect the size of the proof.

		println!("proof size: {:?}", proof.encoded_size());

		println!("compact proof size: {:?}", compact_proof.encoded_size());

		println!("zstd-compressed compact proof size: {:?}", &compressed_proof.len());

		// create a new trie-backed from the proof and make sure it contains everything

		let proof_check = create_proof_check_backend::<BlakeTwo256>(pre_root, proof).unwrap();

		assert_eq!(proof_check.storage(b"a",).unwrap().unwrap(), vec![1u8; 33]);

		let _ = ext.execute_and_prove(|| {

			sp_io::storage::set(b"a", &vec![1u8; 44]);

		});

		// ensure that these changes are propagated to the backend.

		ext.execute_with(|| {

			assert_eq!(sp_io::storage::get(b"a").unwrap(), vec![1u8; 44]);

			assert_eq!(sp_io::storage::get(b"b").unwrap(), vec![2u8; 33]);

		});

	}

}

// NOTE: we have to test the sp_core stuff also from a different crate to check that the macro

// can access the sp_core crate.

#[cfg(test)]

mod sp_core_tests {

	use super::*;

	#[test]

	#[should_panic]

	fn generate_feature_enabled_macro_panics() {

		sp_core::generate_feature_enabled_macro!(if_test, test, $);

		if_test!(panic!("This should panic"));

	}

	#[test]

	fn generate_feature_enabled_macro_works() {

		sp_core::generate_feature_enabled_macro!(if_not_test, not(test), $);

		if_not_test!(panic!("This should not panic"));

	}

}