Phase 1 of repo reorg (#719)

* Remove unneeded script * Rename Substrate Demo -> Substrate * Rename demo -> node * Build wasm from last rename. * Merge ed25519 into substrate-primitives * Minor tweak * Rename substrate -> core * Move substrate-runtime-support to core/runtime/support * Rename/move substrate-runtime-version * Move codec up a level * Rename substrate-codec -> parity-codec * Move environmental up a level * Move pwasm-* up to top, ready for removal * Remove requirement of s-r-support from s-r-primitives * Move core/runtime/primitives into core/runtime-primitives * Remove s-r-support dep from s-r-version * Remove dep of s-r-support from bft * Remove dep of s-r-support from node/consensus * Sever all other core deps from s-r-support * Forgot the no_std directive * Rename non-SRML modules to sr-* to avoid match clashes * Move runtime/* to srml/* * Rename substrate-runtime-* -> srml-* * Move srml to top-level
2026-05-30 03:31:05 +00:00 · 2018-09-12 11:13:31 +02:00
parent 8fe5aa4c81
commit 1e01162505
374 changed files with 2845 additions and 2902 deletions
@@ -0,0 +1,463 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Primitives for the runtime modules.
+
+use rstd::prelude::*;
+use rstd::{self, result};
+use runtime_io;
+#[cfg(feature = "std")] use std::fmt::{Debug, Display};
+#[cfg(feature = "std")] use serde::{Serialize, de::DeserializeOwned};
+use substrate_primitives;
+use substrate_primitives::Blake2Hasher;
+use codec::{Codec, Encode};
+pub use integer_sqrt::IntegerSquareRoot;
+pub use num_traits::{Zero, One, Bounded};
+pub use num_traits::ops::checked::{CheckedAdd, CheckedSub, CheckedMul, CheckedDiv};
+use rstd::ops::{Add, Sub, Mul, Div, Rem, AddAssign, SubAssign, MulAssign, DivAssign,
+	RemAssign, Shl, Shr};
+
+/// A lazy value.
+pub trait Lazy<T: ?Sized> {
+	fn get(&mut self) -> &T;
+}
+
+impl<'a> Lazy<[u8]> for &'a [u8] {
+	fn get(&mut self) -> &[u8] { &**self }
+}
+
+/// Means of signature verification.
+pub trait Verify {
+	/// Type of the signer.
+	type Signer;
+	/// Verify a signature. Return `true` if signature is valid for the value.
+	fn verify<L: Lazy<[u8]>>(&self, msg: L, signer: &Self::Signer) -> bool;
+}
+
+/// Some sort of check on the origin is performed by this object.
+pub trait EnsureOrigin<OuterOrigin> {
+	type Success;
+	fn ensure_origin(o: OuterOrigin) -> Result<Self::Success, &'static str>;
+}
+
+/// Means of changing one type into another in a manner dependent on the source type.
+pub trait Lookup {
+	/// Type to lookup from.
+	type Source;
+	/// Type to lookup into.
+	type Target;
+	/// Attempt a lookup.
+	fn lookup(s: Self::Source) -> result::Result<Self::Target, &'static str>;
+}
+
+/// Simple payment making trait, operating on a single generic `AccountId` type.
+pub trait MakePayment<AccountId> {
+	/// Make some sort of payment concerning `who` for an extrinsic (transaction) of encoded length
+	/// `encoded_len` bytes. Return true iff the payment was successful.
+	fn make_payment(who: &AccountId, encoded_len: usize) -> Result<(), &'static str>;
+}
+
+impl<T> MakePayment<T> for () {
+	fn make_payment(_: &T, _: usize) -> Result<(), &'static str> { Ok(()) }
+}
+
+/// Extensible conversion trait. Generic over both source and destination types.
+pub trait Convert<A, B> {
+	/// Make conversion.
+	fn convert(a: A) -> B;
+}
+
+/// Simple trait similar to `Into`, except that it can be used to convert numerics between each
+/// other.
+pub trait As<T> {
+	/// Convert forward (ala `Into::into`).
+	fn as_(self) -> T;
+	/// Convert backward (ala `From::from`).
+	fn sa(T) -> Self;
+}
+
+macro_rules! impl_numerics {
+	( $( $t:ty ),* ) => {
+		$(
+			impl_numerics!($t: u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize,);
+		)*
+	};
+	( $f:ty : $t:ty, $( $rest:ty, )* ) => {
+		impl As<$t> for $f {
+			fn as_(self) -> $t { self as $t }
+			fn sa(t: $t) -> Self { t as Self }
+		}
+		impl_numerics!($f: $( $rest, )*);
+	};
+	( $f:ty : ) => {}
+}
+
+impl_numerics!(u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize);
+
+pub struct Identity;
+impl<T> Convert<T, T> for Identity {
+	fn convert(a: T) -> T { a }
+}
+impl<T> Convert<T, ()> for () {
+	fn convert(_: T) -> () { () }
+}
+
+pub trait RefInto<T> {
+	fn ref_into(&self) -> &T;
+}
+impl<T> RefInto<T> for T {
+	fn ref_into(&self) -> &T { &self }
+}
+
+pub trait SimpleArithmetic:
+	Zero + One + IntegerSquareRoot + As<u64> +
+	Add<Self, Output = Self> + AddAssign<Self> +
+	Sub<Self, Output = Self> + SubAssign<Self> +
+	Mul<Self, Output = Self> + MulAssign<Self> +
+	Div<Self, Output = Self> + DivAssign<Self> +
+	Rem<Self, Output = Self> + RemAssign<Self> +
+	Shl<u32, Output = Self> + Shr<u32, Output = Self> +
+	CheckedAdd +
+	CheckedSub +
+	CheckedMul +
+	CheckedDiv +
+	PartialOrd<Self> + Ord
+{}
+impl<T:
+	Zero + One + IntegerSquareRoot + As<u64> +
+	Add<Self, Output = Self> + AddAssign<Self> +
+	Sub<Self, Output = Self> + SubAssign<Self> +
+	Mul<Self, Output = Self> + MulAssign<Self> +
+	Div<Self, Output = Self> + DivAssign<Self> +
+	Rem<Self, Output = Self> + RemAssign<Self> +
+	Shl<u32, Output = Self> + Shr<u32, Output = Self> +
+	CheckedAdd +
+	CheckedSub +
+	CheckedMul +
+	CheckedDiv +
+	PartialOrd<Self> + Ord
+> SimpleArithmetic for T {}
+
+/// Trait for things that can be clear (have no bits set). For numeric types, essentially the same
+/// as `Zero`.
+pub trait Clear {
+	/// True iff no bits are set.
+	fn is_clear(&self) -> bool;
+
+	/// Return the value of Self that is clear.
+	fn clear() -> Self;
+}
+
+impl<T: Default + Eq + PartialEq> Clear for T {
+	fn is_clear(&self) -> bool { *self == Self::clear() }
+	fn clear() -> Self { Default::default() }
+}
+
+pub trait SimpleBitOps:
+	Sized + Clear +
+	rstd::ops::BitOr<Self, Output = Self> +
+	rstd::ops::BitAnd<Self, Output = Self>
+{}
+impl<T:
+	Sized + Clear +
+	rstd::ops::BitOr<Self, Output = Self> +
+	rstd::ops::BitAnd<Self, Output = Self>
+> SimpleBitOps for T {}
+
+/// The block finalisation trait. Implementing this lets you express what should happen
+/// for your module when the block is ending.
+pub trait OnFinalise<BlockNumber> {
+	/// The block is being finalised. Implement to have something happen.
+	fn on_finalise(_n: BlockNumber) {}
+}
+
+impl<N> OnFinalise<N> for () {}
+
+macro_rules! tuple_impl {
+	($one:ident,) => {
+		impl<Number: Copy, $one: OnFinalise<Number>> OnFinalise<Number> for ($one,) {
+			fn on_finalise(n: Number) {
+				$one::on_finalise(n);
+			}
+		}
+	};
+	($first:ident, $($rest:ident,)+) => {
+		impl<
+			Number: Copy,
+			$first: OnFinalise<Number>,
+			$($rest: OnFinalise<Number>),+
+		> OnFinalise<Number> for ($first, $($rest),+) {
+			fn on_finalise(n: Number) {
+				$first::on_finalise(n);
+				$($rest::on_finalise(n);)+
+			}
+		}
+		tuple_impl!($($rest,)+);
+	}
+}
+
+#[allow(non_snake_case)]
+tuple_impl!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z,);
+
+/// Abstraction around hashing
+pub trait Hash: 'static + MaybeSerializeDebug + Clone + Eq + PartialEq {	// Stupid bug in the Rust compiler believes derived
+																	// traits must be fulfilled by all type parameters.
+	/// The hash type produced.
+	type Output: Member + AsRef<[u8]>;
+
+	/// Produce the hash of some byte-slice.
+	fn hash(s: &[u8]) -> Self::Output;
+
+	/// Produce the hash of some codec-encodable value.
+	fn hash_of<S: Codec>(s: &S) -> Self::Output {
+		Encode::using_encoded(s, Self::hash)
+	}
+
+	/// Produce the patricia-trie root of a mapping from indices to byte slices.
+	fn enumerated_trie_root(items: &[&[u8]]) -> Self::Output;
+
+	/// Iterator-based version of `enumerated_trie_root`.
+	fn ordered_trie_root<
+		I: IntoIterator<Item = A>,
+		A: AsRef<[u8]>
+	>(input: I) -> Self::Output;
+
+	/// The Patricia tree root of the given mapping as an iterator.
+	fn trie_root<
+		I: IntoIterator<Item = (A, B)>,
+		A: AsRef<[u8]> + Ord,
+		B: AsRef<[u8]>
+	>(input: I) -> Self::Output;
+
+	/// Acquire the global storage root.
+	fn storage_root() -> Self::Output;
+}
+
+/// Blake2-256 Hash implementation.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
+pub struct BlakeTwo256;
+
+impl Hash for BlakeTwo256 {
+	type Output = substrate_primitives::H256;
+	fn hash(s: &[u8]) -> Self::Output {
+		runtime_io::blake2_256(s).into()
+	}
+	fn enumerated_trie_root(items: &[&[u8]]) -> Self::Output {
+		runtime_io::enumerated_trie_root::<Blake2Hasher>(items).into()
+	}
+	fn trie_root<
+		I: IntoIterator<Item = (A, B)>,
+		A: AsRef<[u8]> + Ord,
+		B: AsRef<[u8]>
+	>(input: I) -> Self::Output {
+		runtime_io::trie_root::<Blake2Hasher, _, _, _>(input).into()
+	}
+	fn ordered_trie_root<
+		I: IntoIterator<Item = A>,
+		A: AsRef<[u8]>
+	>(input: I) -> Self::Output {
+		runtime_io::ordered_trie_root::<Blake2Hasher, _, _>(input).into()
+	}
+	fn storage_root() -> Self::Output {
+		runtime_io::storage_root().into()
+	}
+}
+
+/// Something that can be checked for equality and printed out to a debug channel if bad.
+pub trait CheckEqual {
+	fn check_equal(&self, other: &Self);
+}
+
+impl CheckEqual for substrate_primitives::H256 {
+	#[cfg(feature = "std")]
+	fn check_equal(&self, other: &Self) {
+		use substrate_primitives::hexdisplay::HexDisplay;
+		if &self.0 != &other.0 {
+			println!("Hash: given={}, expected={}", HexDisplay::from(&self.0), HexDisplay::from(&other.0));
+		}
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn check_equal(&self, other: &Self) {
+		if self != other {
+			runtime_io::print("Hash not equal");
+			runtime_io::print(&self.0[..]);
+			runtime_io::print(&other.0[..]);
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+pub trait MaybeSerializeDebugButNotDeserialize: Serialize + Debug {}
+#[cfg(feature = "std")]
+impl<T: Serialize + Debug> MaybeSerializeDebugButNotDeserialize for T {}
+
+#[cfg(not(feature = "std"))]
+pub trait MaybeSerializeDebugButNotDeserialize {}
+#[cfg(not(feature = "std"))]
+impl<T> MaybeSerializeDebugButNotDeserialize for T {}
+
+#[cfg(feature = "std")]
+pub trait MaybeSerializeDebug: Serialize + DeserializeOwned + Debug {}
+#[cfg(feature = "std")]
+impl<T: Serialize + DeserializeOwned + Debug> MaybeSerializeDebug for T {}
+
+#[cfg(not(feature = "std"))]
+pub trait MaybeSerializeDebug {}
+#[cfg(not(feature = "std"))]
+impl<T> MaybeSerializeDebug for T {}
+
+#[cfg(feature = "std")]
+pub trait MaybeDisplay: Display {}
+#[cfg(feature = "std")]
+impl<T: Display> MaybeDisplay for T {}
+
+#[cfg(not(feature = "std"))]
+pub trait MaybeDisplay {}
+#[cfg(not(feature = "std"))]
+impl<T> MaybeDisplay for T {}
+
+pub trait Member: Send + Sync + Sized + MaybeSerializeDebug + Eq + PartialEq + Clone + 'static {}
+impl<T: Send + Sync + Sized + MaybeSerializeDebug + Eq + PartialEq + Clone + 'static> Member for T {}
+
+/// Something which fulfills the abstract idea of a Substrate header. It has types for a `Number`,
+/// a `Hash` and a `Digest`. It provides access to an `extrinsics_root`, `state_root` and
+/// `parent_hash`, as well as a `digest` and a block `number`.
+///
+/// You can also create a `new` one from those fields.
+pub trait Header: Clone + Send + Sync + Codec + Eq + MaybeSerializeDebug + 'static {
+	type Number: Member + ::rstd::hash::Hash + Copy + MaybeDisplay + SimpleArithmetic + Codec;
+	type Hash: Member + ::rstd::hash::Hash + Copy + MaybeDisplay + Default + SimpleBitOps + Codec + AsRef<[u8]>;
+	type Hashing: Hash<Output = Self::Hash>;
+	type Digest: Digest;
+
+	fn new(
+		number: Self::Number,
+		extrinsics_root: Self::Hash,
+		state_root: Self::Hash,
+		parent_hash: Self::Hash,
+		digest: Self::Digest
+	) -> Self;
+
+	fn number(&self) -> &Self::Number;
+	fn set_number(&mut self, Self::Number);
+
+	fn extrinsics_root(&self) -> &Self::Hash;
+	fn set_extrinsics_root(&mut self, Self::Hash);
+
+	fn state_root(&self) -> &Self::Hash;
+	fn set_state_root(&mut self, Self::Hash);
+
+	fn parent_hash(&self) -> &Self::Hash;
+	fn set_parent_hash(&mut self, Self::Hash);
+
+	fn digest(&self) -> &Self::Digest;
+	fn set_digest(&mut self, Self::Digest);
+
+	fn hash(&self) -> Self::Hash {
+		<Self::Hashing as Hash>::hash_of(self)
+	}
+}
+
+/// Something which fulfills the abstract idea of a Substrate block. It has types for an
+/// `Extrinsic` piece of information as well as a `Header`.
+///
+/// You can get an iterator over each of the `extrinsics` and retrieve the `header`.
+pub trait Block: Clone + Send + Sync + Codec + Eq + MaybeSerializeDebug + 'static {
+	type Extrinsic: Member + Codec;
+	type Header: Header<Hash=Self::Hash>;
+	type Hash: Member + ::rstd::hash::Hash + Copy + MaybeDisplay + Default + SimpleBitOps + Codec + AsRef<[u8]>;
+
+	fn header(&self) -> &Self::Header;
+	fn extrinsics(&self) -> &[Self::Extrinsic];
+	fn deconstruct(self) -> (Self::Header, Vec<Self::Extrinsic>);
+	fn new(header: Self::Header, extrinsics: Vec<Self::Extrinsic>) -> Self;
+	fn hash(&self) -> Self::Hash {
+		<<Self::Header as Header>::Hashing as Hash>::hash_of(self.header())
+	}
+}
+
+/// Extract the hashing type for a block.
+pub type HashFor<B> = <<B as Block>::Header as Header>::Hashing;
+/// Extract the number type for a block.
+pub type NumberFor<B> = <<B as Block>::Header as Header>::Number;
+
+/// A "checkable" piece of information, used by the standard Substrate Executive in order to
+/// 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 be
+/// checked.
+pub trait Checkable<Context>: Sized {
+	/// Returned if `check_with` succeeds.
+	type Checked;
+
+	fn check_with(self, context: Context) -> Result<Self::Checked, &'static str>;
+}
+
+/// A "checkable" piece of information, used by the standard Substrate Executive in order to
+/// check the validity of a piece of extrinsic information, usually by verifying the signature.
+/// Implement for pieces of information that don't require additional context in order to be
+/// checked.
+pub trait BlindCheckable: Sized {
+	/// Returned if `check` succeeds.
+	type Checked;
+
+	fn check(self) -> Result<Self::Checked, &'static str>;
+}
+
+// Every `BlindCheckable` is also a `Checkable` for arbitrary `Context`.
+impl<T: BlindCheckable, Context> Checkable<Context> for T {
+	type Checked = <Self as BlindCheckable>::Checked;
+	fn check_with(self, _: Context) -> Result<Self::Checked, &'static str> {
+		BlindCheckable::check(self)
+	}
+}
+
+/// An "executable" piece of information, used by the standard Substrate Executive in order to
+/// enact a piece of extrinsic information by marshalling and dispatching to a named functioon
+/// call.
+///
+/// Also provides information on to whom this information is attributable and an index that allows
+/// each piece of attributable information to be disambiguated.
+pub trait Applyable: Sized + Send + Sync {
+	type AccountId: Member + MaybeDisplay;
+	type Index: Member + MaybeDisplay + SimpleArithmetic;
+	type Call: Member;
+	fn index(&self) -> &Self::Index;
+	fn sender(&self) -> Option<&Self::AccountId>;
+	fn deconstruct(self) -> (Self::Call, Option<Self::AccountId>);
+}
+
+/// Something that acts like a `Digest` - it can have `Log`s `push`ed onto it and these `Log`s are
+/// each `Codec`.
+pub trait Digest: Member + Default {
+	type Item: DigestItem;
+	fn logs(&self) -> &[Self::Item];
+	fn push(&mut self, item: Self::Item);
+}
+
+/// Single digest item. Could be any type that implements `Member` and provides methods
+/// for casting member to 'system' log items, known to substrate.
+///
+/// If the runtime does not supports some 'system' items, use `()` as a stub.
+pub trait DigestItem: Member {
+	type AuthorityId;
+
+ 	/// Returns Some if the entry is the `AuthoritiesChange` entry.
+	fn as_authorities_change(&self) -> Option<&[Self::AuthorityId]> {
+		None
+	}
+}