Reorganising the repository - external renames and moves (#4074)

* Adding first rough ouline of the repository structure * Remove old CI stuff * add title * formatting fixes * move node-exits job's script to scripts dir * Move docs into subdir * move to bin * move maintainence scripts, configs and helpers into its own dir * add .local to ignore * move core->client * start up 'test' area * move test client * move test runtime * make test move compile * Add dependencies rule enforcement. * Fix indexing. * Update docs to reflect latest changes * Moving /srml->/paint * update docs * move client/sr-* -> primitives/ * clean old readme * remove old broken code in rhd * update lock * Step 1. * starting to untangle client * Fix after merge. * start splitting out client interfaces * move children and blockchain interfaces * Move trie and state-machine to primitives. * Fix WASM builds. * fixing broken imports * more interface moves * move backend and light to interfaces * move CallExecutor * move cli off client * moving around more interfaces * re-add consensus crates into the mix * fix subkey path * relieve client from executor * starting to pull out client from grandpa * move is_decendent_of out of client * grandpa still depends on client directly * lemme tests pass * rename srml->paint * Make it compile. * rename interfaces->client-api * Move keyring to primitives. * fixup libp2p dep * fix broken use * allow dependency enforcement to fail * move fork-tree * Moving wasm-builder * make env * move build-script-utils * fixup broken crate depdencies and names * fix imports for authority discovery * fix typo * update cargo.lock * fixing imports * Fix paths and add missing crates * re-add missing crates
2026-06-13 21:01:05 +00:00 · 2019-11-14 21:51:17 +01:00
parent becc3b0a4f
commit 60e5011c72
809 changed files with 7801 additions and 6464 deletions
@@ -0,0 +1,284 @@
+// Copyright 2019 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/>.
+
+//! Private implementation details of BABE digests.
+
+#[cfg(feature = "std")]
+use super::{BABE_ENGINE_ID, AuthoritySignature};
+#[cfg(not(feature = "std"))]
+use super::{VRF_OUTPUT_LENGTH, VRF_PROOF_LENGTH};
+use super::{AuthorityId, AuthorityIndex, SlotNumber, BabeAuthorityWeight};
+#[cfg(feature = "std")]
+use sr_primitives::{DigestItem, generic::OpaqueDigestItemId};
+#[cfg(feature = "std")]
+use std::fmt::Debug;
+use codec::{Decode, Encode};
+#[cfg(feature = "std")]
+use codec::{Codec, Input, Error};
+#[cfg(feature = "std")]
+use schnorrkel::{
+	SignatureError, errors::MultiSignatureStage,
+	vrf::{VRFProof, VRFOutput, VRF_OUTPUT_LENGTH, VRF_PROOF_LENGTH}
+};
+use rstd::vec::Vec;
+
+
+/// A BABE pre-runtime digest. This contains all data required to validate a
+/// block and for the BABE runtime module. Slots can be assigned to a primary
+/// (VRF based) and to a secondary (slot number based).
+#[cfg(feature = "std")]
+#[derive(Clone, Debug)]
+pub enum BabePreDigest {
+	/// A primary VRF-based slot assignment.
+	Primary {
+		/// VRF output
+		vrf_output: VRFOutput,
+		/// VRF proof
+		vrf_proof: VRFProof,
+		/// Authority index
+		authority_index: super::AuthorityIndex,
+		/// Slot number
+		slot_number: SlotNumber,
+	},
+	/// A secondary deterministic slot assignment.
+	Secondary {
+		/// Authority index
+		authority_index: super::AuthorityIndex,
+		/// Slot number
+		slot_number: SlotNumber,
+	},
+}
+
+#[cfg(feature = "std")]
+impl BabePreDigest {
+	/// Returns the slot number of the pre digest.
+	pub fn authority_index(&self) -> AuthorityIndex {
+		match self {
+			BabePreDigest::Primary { authority_index, .. } => *authority_index,
+			BabePreDigest::Secondary { authority_index, .. } => *authority_index,
+		}
+	}
+
+	/// Returns the slot number of the pre digest.
+	pub fn slot_number(&self) -> SlotNumber {
+		match self {
+			BabePreDigest::Primary { slot_number, .. } => *slot_number,
+			BabePreDigest::Secondary { slot_number, .. } => *slot_number,
+		}
+	}
+
+	/// Returns the weight _added_ by this digest, not the cumulative weight
+	/// of the chain.
+	pub fn added_weight(&self) -> crate::BabeBlockWeight {
+		match self {
+			BabePreDigest::Primary { .. } => 1,
+			BabePreDigest::Secondary { .. } => 0,
+		}
+	}
+}
+
+/// The prefix used by BABE for its VRF keys.
+pub const BABE_VRF_PREFIX: &[u8] = b"substrate-babe-vrf";
+
+/// A raw version of `BabePreDigest`, usable on `no_std`.
+#[derive(Copy, Clone, Encode, Decode)]
+pub enum RawBabePreDigest {
+	/// A primary VRF-based slot assignment.
+	#[codec(index = "1")]
+	Primary {
+		/// Authority index
+		authority_index: AuthorityIndex,
+		/// Slot number
+		slot_number: SlotNumber,
+		/// VRF output
+		vrf_output: [u8; VRF_OUTPUT_LENGTH],
+		/// VRF proof
+		vrf_proof: [u8; VRF_PROOF_LENGTH],
+	},
+	/// A secondary deterministic slot assignment.
+	#[codec(index = "2")]
+	Secondary {
+		/// Authority index
+		///
+		/// This is not strictly-speaking necessary, since the secondary slots
+		/// are assigned based on slot number and epoch randomness. But including
+		/// it makes things easier for higher-level users of the chain data to
+		/// be aware of the author of a secondary-slot block.
+		authority_index: AuthorityIndex,
+		/// Slot number
+		slot_number: SlotNumber,
+	},
+}
+
+impl RawBabePreDigest {
+	/// Returns the slot number of the pre digest.
+	pub fn slot_number(&self) -> SlotNumber {
+		match self {
+			RawBabePreDigest::Primary { slot_number, .. } => *slot_number,
+			RawBabePreDigest::Secondary { slot_number, .. } => *slot_number,
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+impl Encode for BabePreDigest {
+	fn encode(&self) -> Vec<u8> {
+		let raw = match self {
+			BabePreDigest::Primary {
+				vrf_output,
+				vrf_proof,
+				authority_index,
+				slot_number,
+			} => {
+				RawBabePreDigest::Primary {
+					vrf_output: *vrf_output.as_bytes(),
+					vrf_proof: vrf_proof.to_bytes(),
+					authority_index: *authority_index,
+					slot_number: *slot_number,
+				}
+			},
+			BabePreDigest::Secondary {
+				authority_index,
+				slot_number,
+			} => {
+				RawBabePreDigest::Secondary {
+					authority_index: *authority_index,
+					slot_number: *slot_number,
+				}
+			},
+		};
+
+		codec::Encode::encode(&raw)
+	}
+}
+
+#[cfg(feature = "std")]
+impl codec::EncodeLike for BabePreDigest {}
+
+#[cfg(feature = "std")]
+impl Decode for BabePreDigest {
+	fn decode<R: Input>(i: &mut R) -> Result<Self, Error> {
+		let pre_digest = match Decode::decode(i)? {
+			RawBabePreDigest::Primary { vrf_output, vrf_proof, authority_index, slot_number } => {
+				// Verify (at compile time) that the sizes in babe_primitives are correct
+				let _: [u8; super::VRF_OUTPUT_LENGTH] = vrf_output;
+				let _: [u8; super::VRF_PROOF_LENGTH] = vrf_proof;
+
+				BabePreDigest::Primary {
+					vrf_proof: VRFProof::from_bytes(&vrf_proof).map_err(convert_error)?,
+					vrf_output: VRFOutput::from_bytes(&vrf_output).map_err(convert_error)?,
+					authority_index,
+					slot_number,
+				}
+			},
+			RawBabePreDigest::Secondary { authority_index, slot_number } => {
+				BabePreDigest::Secondary { authority_index, slot_number }
+			},
+		};
+
+		Ok(pre_digest)
+	}
+}
+
+/// Information about the next epoch. This is broadcast in the first block
+/// of the epoch.
+#[derive(Decode, Encode, Default, PartialEq, Eq, Clone, sr_primitives::RuntimeDebug)]
+pub struct NextEpochDescriptor {
+	/// The authorities.
+	pub authorities: Vec<(AuthorityId, BabeAuthorityWeight)>,
+
+	/// The value of randomness to use for the slot-assignment.
+	pub randomness: [u8; VRF_OUTPUT_LENGTH],
+}
+
+/// A digest item which is usable with BABE consensus.
+#[cfg(feature = "std")]
+pub trait CompatibleDigestItem: Sized {
+	/// Construct a digest item which contains a BABE pre-digest.
+	fn babe_pre_digest(seal: BabePreDigest) -> Self;
+
+	/// If this item is an BABE pre-digest, return it.
+	fn as_babe_pre_digest(&self) -> Option<BabePreDigest>;
+
+	/// Construct a digest item which contains a BABE seal.
+	fn babe_seal(signature: AuthoritySignature) -> Self;
+
+	/// If this item is a BABE signature, return the signature.
+	fn as_babe_seal(&self) -> Option<AuthoritySignature>;
+
+	/// If this item is a BABE epoch, return it.
+	fn as_next_epoch_descriptor(&self) -> Option<NextEpochDescriptor>;
+}
+
+#[cfg(feature = "std")]
+impl<Hash> CompatibleDigestItem for DigestItem<Hash> where
+	Hash: Debug + Send + Sync + Eq + Clone + Codec + 'static
+{
+	fn babe_pre_digest(digest: BabePreDigest) -> Self {
+		DigestItem::PreRuntime(BABE_ENGINE_ID, digest.encode())
+	}
+
+	fn as_babe_pre_digest(&self) -> Option<BabePreDigest> {
+		self.try_to(OpaqueDigestItemId::PreRuntime(&BABE_ENGINE_ID))
+	}
+
+	fn babe_seal(signature: AuthoritySignature) -> Self {
+		DigestItem::Seal(BABE_ENGINE_ID, signature.encode())
+	}
+
+	fn as_babe_seal(&self) -> Option<AuthoritySignature> {
+		self.try_to(OpaqueDigestItemId::Seal(&BABE_ENGINE_ID))
+	}
+
+	fn as_next_epoch_descriptor(&self) -> Option<NextEpochDescriptor> {
+		self.try_to(OpaqueDigestItemId::Consensus(&BABE_ENGINE_ID))
+			.and_then(|x: super::ConsensusLog| match x {
+				super::ConsensusLog::NextEpochData(n) => Some(n),
+				_ => None,
+			})
+	}
+}
+
+#[cfg(feature = "std")]
+fn convert_error(e: SignatureError) -> codec::Error {
+	use SignatureError::*;
+	use MultiSignatureStage::*;
+	match e {
+		EquationFalse => "Signature error: `EquationFalse`".into(),
+		PointDecompressionError => "Signature error: `PointDecompressionError`".into(),
+		ScalarFormatError => "Signature error: `ScalarFormatError`".into(),
+		NotMarkedSchnorrkel => "Signature error: `NotMarkedSchnorrkel`".into(),
+		BytesLengthError { .. } => "Signature error: `BytesLengthError`".into(),
+		MuSigAbsent { musig_stage: Commitment } =>
+			"Signature error: `MuSigAbsent` at stage `Commitment`".into(),
+		MuSigAbsent { musig_stage: Reveal } =>
+			"Signature error: `MuSigAbsent` at stage `Reveal`".into(),
+		MuSigAbsent { musig_stage: Cosignature } =>
+			"Signature error: `MuSigAbsent` at stage `Commitment`".into(),
+		MuSigInconsistent { musig_stage: Commitment, duplicate: true } =>
+			"Signature error: `MuSigInconsistent` at stage `Commitment` on duplicate".into(),
+		MuSigInconsistent { musig_stage: Commitment, duplicate: false } =>
+			"Signature error: `MuSigInconsistent` at stage `Commitment` on not duplicate".into(),
+		MuSigInconsistent { musig_stage: Reveal, duplicate: true } =>
+			"Signature error: `MuSigInconsistent` at stage `Reveal` on duplicate".into(),
+		MuSigInconsistent { musig_stage: Reveal, duplicate: false } =>
+			"Signature error: `MuSigInconsistent` at stage `Reveal` on not duplicate".into(),
+		MuSigInconsistent { musig_stage: Cosignature, duplicate: true } =>
+			"Signature error: `MuSigInconsistent` at stage `Cosignature` on duplicate".into(),
+		MuSigInconsistent { musig_stage: Cosignature, duplicate: false } =>
+			"Signature error: `MuSigInconsistent` at stage `Cosignature` on not duplicate".into(),
+	}
+}
@@ -0,0 +1,176 @@
+// Copyright 2019 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 BABE.
+#![deny(warnings)]
+#![forbid(unsafe_code, missing_docs, unused_variables, unused_imports)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod digest;
+
+use codec::{Encode, Decode};
+use rstd::vec::Vec;
+use sr_primitives::{ConsensusEngineId, RuntimeDebug};
+
+#[cfg(feature = "std")]
+pub use digest::{BabePreDigest, CompatibleDigestItem};
+pub use digest::{BABE_VRF_PREFIX, RawBabePreDigest, NextEpochDescriptor};
+
+mod app {
+	use app_crypto::{app_crypto, key_types::BABE, sr25519};
+	app_crypto!(sr25519, BABE);
+}
+
+/// A Babe authority keypair. Necessarily equivalent to the schnorrkel public key used in
+/// the main Babe module. If that ever changes, then this must, too.
+#[cfg(feature = "std")]
+pub type AuthorityPair = app::Pair;
+
+/// A Babe authority signature.
+pub type AuthoritySignature = app::Signature;
+
+/// A Babe authority identifier. Necessarily equivalent to the schnorrkel public key used in
+/// the main Babe module. If that ever changes, then this must, too.
+pub type AuthorityId = app::Public;
+
+/// The `ConsensusEngineId` of BABE.
+pub const BABE_ENGINE_ID: ConsensusEngineId = *b"BABE";
+
+/// The length of the VRF output
+pub const VRF_OUTPUT_LENGTH: usize = 32;
+
+/// The length of the VRF proof
+pub const VRF_PROOF_LENGTH: usize = 64;
+
+/// The length of the public key
+pub const PUBLIC_KEY_LENGTH: usize = 32;
+
+/// How many blocks to wait before running the median algorithm for relative time
+/// This will not vary from chain to chain as it is not dependent on slot duration
+/// or epoch length.
+pub const MEDIAN_ALGORITHM_CARDINALITY: usize = 1200; // arbitrary suggestion by w3f-research.
+
+/// The index of an authority.
+pub type AuthorityIndex = u32;
+
+/// A slot number.
+pub type SlotNumber = u64;
+
+/// The weight of an authority.
+// NOTE: we use a unique name for the weight to avoid conflicts with other
+//       `Weight` types, since the metadata isn't able to disambiguate.
+pub type BabeAuthorityWeight = u64;
+
+/// The weight of a BABE block.
+pub type BabeBlockWeight = u32;
+
+/// BABE epoch information
+#[derive(Decode, Encode, Default, PartialEq, Eq, Clone, RuntimeDebug)]
+pub struct Epoch {
+	/// The epoch index
+	pub epoch_index: u64,
+	/// The starting slot of the epoch,
+	pub start_slot: SlotNumber,
+	/// The duration of this epoch
+	pub duration: SlotNumber,
+	/// The authorities and their weights
+	pub authorities: Vec<(AuthorityId, BabeAuthorityWeight)>,
+	/// Randomness for this epoch
+	pub randomness: [u8; VRF_OUTPUT_LENGTH],
+}
+
+impl Epoch {
+	/// "increment" the epoch, with given descriptor for the next.
+	pub fn increment(&self, descriptor: NextEpochDescriptor) -> Epoch {
+		Epoch {
+			epoch_index: self.epoch_index + 1,
+			start_slot: self.start_slot + self.duration,
+			duration: self.duration,
+			authorities: descriptor.authorities,
+			randomness: descriptor.randomness,
+		}
+	}
+
+	/// Produce the "end slot" of the epoch. This is NOT inclusive to the epoch,
+	// i.e. the slots covered by the epoch are `self.start_slot .. self.end_slot()`.
+	pub fn end_slot(&self) -> SlotNumber {
+		self.start_slot + self.duration
+	}
+}
+
+/// An consensus log item for BABE.
+#[derive(Decode, Encode, Clone, PartialEq, Eq)]
+pub enum ConsensusLog {
+	/// The epoch has changed. This provides information about the _next_
+	/// epoch - information about the _current_ epoch (i.e. the one we've just
+	/// entered) should already be available earlier in the chain.
+	#[codec(index = "1")]
+	NextEpochData(NextEpochDescriptor),
+	/// Disable the authority with given index.
+	#[codec(index = "2")]
+	OnDisabled(AuthorityIndex),
+}
+
+/// Configuration data used by the BABE consensus engine.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug)]
+pub struct BabeConfiguration {
+	/// The slot duration in milliseconds for BABE. Currently, only
+	/// the value provided by this type at genesis will be used.
+	///
+	/// Dynamic slot duration may be supported in the future.
+	pub slot_duration: u64,
+
+	/// The duration of epochs in slots.
+	pub epoch_length: SlotNumber,
+
+	/// A constant value that is used in the threshold calculation formula.
+	/// Expressed as a rational where the first member of the tuple is the
+	/// numerator and the second is the denominator. The rational should
+	/// represent a value between 0 and 1.
+	/// In the threshold formula calculation, `1 - c` represents the probability
+	/// of a slot being empty.
+	pub c: (u64, u64),
+
+	/// The authorities for the genesis epoch.
+	pub genesis_authorities: Vec<(AuthorityId, BabeAuthorityWeight)>,
+
+	/// The randomness for the genesis epoch.
+	pub randomness: [u8; VRF_OUTPUT_LENGTH],
+
+	/// Whether this chain should run with secondary slots, which are assigned
+	/// in round-robin manner.
+	pub secondary_slots: bool,
+}
+
+#[cfg(feature = "std")]
+impl slots::SlotData for BabeConfiguration {
+	fn slot_duration(&self) -> u64 {
+		self.slot_duration
+	}
+
+	const SLOT_KEY: &'static [u8] = b"babe_configuration";
+}
+
+sr_api::decl_runtime_apis! {
+	/// API necessary for block authorship with BABE.
+	pub trait BabeApi {
+		/// Return the configuration for BABE. Currently,
+		/// only the value provided by this type at genesis will be used.
+		///
+		/// Dynamic configuration may be supported in the future.
+		fn configuration() -> BabeConfiguration;
+	}
+}