pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-12 19:21:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor epoch changes to a separate crate (#4785)

Browse Source 
* Init epoch changes module

* Initial integration of new epoch changes module for BABE

* Fix all initial compile errors

* rename: digest -> digests

* Fix babe tests

* Bump impl_version

* Fix more test issues

* Remove test flag for tree

It unfortunately won't work for multiple crates.

* Update cargo lock

* Fix duplicate parking_lot version

* Add missing license header
This commit is contained in:
Wei Tang
2020-02-06 16:48:38 +01:00
committed by GitHub
parent c7a7197f97
commit 4df27e760e
15 changed files with 265 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/primitives/consensus/babe/src/digest.rs → substrate/primitives/consensus/babe/src/digests.rs
+27 -30
View File
@@ -41,7 +41,7 @@ use sp_std::vec::Vec;
/// (VRF based) and to a secondary (slot number based).
#[cfg(feature = "std")]
#[derive(Clone, Debug)]
pub enum BabePreDigest {
pub enum PreDigest {
/// A primary VRF-based slot assignment.
Primary {
/// VRF output
@@ -63,20 +63,20 @@ pub enum BabePreDigest {
}
#[cfg(feature = "std")]
impl BabePreDigest {
impl PreDigest {
/// 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,
PreDigest::Primary { authority_index, .. } => *authority_index,
PreDigest::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,
PreDigest::Primary { slot_number, .. } => *slot_number,
PreDigest::Secondary { slot_number, .. } => *slot_number,
}
}
@@ -84,18 +84,15 @@ impl BabePreDigest {
/// of the chain.
pub fn added_weight(&self) -> crate::BabeBlockWeight {
match self {
BabePreDigest::Primary { .. } => 1,
BabePreDigest::Secondary { .. } => 0,
PreDigest::Primary { .. } => 1,
PreDigest::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 {
pub enum RawPreDigest {
/// A primary VRF-based slot assignment.
#[codec(index = "1")]
Primary {
@@ -123,38 +120,38 @@ pub enum RawBabePreDigest {
},
}
impl RawBabePreDigest {
impl RawPreDigest {
/// 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,
RawPreDigest::Primary { slot_number, .. } => *slot_number,
RawPreDigest::Secondary { slot_number, .. } => *slot_number,
}
}
}
#[cfg(feature = "std")]
impl Encode for BabePreDigest {
impl Encode for PreDigest {
fn encode(&self) -> Vec<u8> {
let raw = match self {
BabePreDigest::Primary {
PreDigest::Primary {
vrf_output,
vrf_proof,
authority_index,
slot_number,
} => {
RawBabePreDigest::Primary {
RawPreDigest::Primary {
vrf_output: *vrf_output.as_bytes(),
vrf_proof: vrf_proof.to_bytes(),
authority_index: *authority_index,
slot_number: *slot_number,
}
},
BabePreDigest::Secondary {
PreDigest::Secondary {
authority_index,
slot_number,
} => {
RawBabePreDigest::Secondary {
RawPreDigest::Secondary {
authority_index: *authority_index,
slot_number: *slot_number,
}
@@ -166,26 +163,26 @@ impl Encode for BabePreDigest {
}
#[cfg(feature = "std")]
impl codec::EncodeLike for BabePreDigest {}
impl codec::EncodeLike for PreDigest {}
#[cfg(feature = "std")]
impl Decode for BabePreDigest {
impl Decode for PreDigest {
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 } => {
RawPreDigest::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 {
PreDigest::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 }
RawPreDigest::Secondary { authority_index, slot_number } => {
PreDigest::Secondary { authority_index, slot_number }
},
};
@@ -208,10 +205,10 @@ pub struct NextEpochDescriptor {
#[cfg(feature = "std")]
pub trait CompatibleDigestItem: Sized {
/// Construct a digest item which contains a BABE pre-digest.
fn babe_pre_digest(seal: BabePreDigest) -> Self;
fn babe_pre_digest(seal: PreDigest) -> Self;
/// If this item is an BABE pre-digest, return it.
fn as_babe_pre_digest(&self) -> Option<BabePreDigest>;
fn as_babe_pre_digest(&self) -> Option<PreDigest>;
/// Construct a digest item which contains a BABE seal.
fn babe_seal(signature: AuthoritySignature) -> Self;
@@ -227,11 +224,11 @@ pub trait CompatibleDigestItem: Sized {
impl<Hash> CompatibleDigestItem for DigestItem<Hash> where
Hash: Debug + Send + Sync + Eq + Clone + Codec + 'static
{
fn babe_pre_digest(digest: BabePreDigest) -> Self {
fn babe_pre_digest(digest: PreDigest) -> Self {
DigestItem::PreRuntime(BABE_ENGINE_ID, digest.encode())
}
fn as_babe_pre_digest(&self) -> Option<BabePreDigest> {
fn as_babe_pre_digest(&self) -> Option<PreDigest> {
self.try_to(OpaqueDigestItemId::PreRuntime(&BABE_ENGINE_ID))
}
substrate/primitives/consensus/babe/src/lib.rs
+5 -39
View File
@@ -19,22 +19,22 @@
#![forbid(unsafe_code, missing_docs, unused_variables, unused_imports)]
#![cfg_attr(not(feature = "std"), no_std)]
mod digest;
pub mod digests;
pub mod inherents;
use codec::{Encode, Decode};
use sp_std::vec::Vec;
use sp_runtime::{ConsensusEngineId, RuntimeDebug};
#[cfg(feature = "std")]
pub use digest::{BabePreDigest, CompatibleDigestItem};
pub use digest::{BABE_VRF_PREFIX, RawBabePreDigest, NextEpochDescriptor};
use crate::digests::NextEpochDescriptor;
mod app {
use sp_application_crypto::{app_crypto, key_types::BABE, sr25519};
app_crypto!(sr25519, BABE);
}
/// The prefix used by BABE for its VRF keys.
pub const BABE_VRF_PREFIX: &[u8] = b"substrate-babe-vrf";
/// 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")]
@@ -78,40 +78,6 @@ 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 {