Struct ParentBlockRandomness

pub struct ParentBlockRandomness<T>(/* private fields */);

Randomness produced semi-freshly with each block, but inherits limitations of RandomnessFromTwoEpochsAgo from which it derives.

All randomness is relative to commitments to any other inputs to the computation: If Alice samples randomness near perfectly using radioactive decay, but then afterwards Eve selects an arbitrary value with which to xor Alice’s randomness, then Eve always wins whatever game they play.

As with RandomnessFromTwoEpochsAgo, all input commitments combined with ParentBlockRandomness should come from at least two epoch ago, except preferably not near epoch ending, and thus ideally three epochs ago.

Almost all users learn this randomness for a given block by the time they receive it’s parent block, which makes this randomness appear fresh enough. Yet, the block producer themselves learned this randomness at the beginning of epoch current_epoch - 2, at the same time as they learn RandomnessFromTwoEpochsAgo.

Aside from just biasing RandomnessFromTwoEpochsAgo, adversaries could also bias ParentBlockRandomness by never announcing their block if doing so yields an unfavorable randomness. As such, ParentBlockRandomness should be considered weaker than both other randomness sources provided by BABE, but ParentBlockRandomness remains constrained by declared staking, while a randomness source like block hash is only constrained by adversaries’ unknowable computational power.

As an example use, parachains could assign block production slots based upon the ParentBlockRandomness of their relay parent or relay parent’s parent, provided the parachain registers collators but avoids censorship sensitive functionality like slashing. Any parachain with slashing could operate BABE itself or perhaps better yet a BABE-like approach that derives its ParentBlockRandomness, and authorizes block production, based upon the relay parent’s ParentBlockRandomness or more likely the relay parent’s RandomnessFromTwoEpochsAgo.

NOTE: there is some nuance here regarding what is current and parent randomness. If you are using this trait from within the runtime (i.e. as part of block execution) then the randomness provided here will always be generated from the parent block. If instead you are using this randomness externally, i.e. after block execution, then this randomness will be provided by the “current” block (this stems from the fact that we process VRF outputs on block execution finalization, i.e. on_finalize).

Trait Implementations

impl<T: Config> Randomness<Option<<T as Config>::Hash>, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for ParentBlockRandomness<T>

fn random(subject: &[u8]) -> (Option<T::Hash>, BlockNumberFor<T>)

Get the most recently determined random seed, along with the time in the past since when it was determinable by chain observers.

fn random_seed() -> (Output, BlockNumber)

Get the basic random seed.