Struct pallet_randomness_collective_flip::Module

pub struct Module<T: Trait>(_);

Methods

impl<T: Trait + 'static> Module<T>

pub fn random_material() -> Vec<T::Hash>

Series of block headers from the last 81 blocks that acts as random seed material. This is arranged as a ring buffer with block_number % 81 being the index into the Vec of the oldest hash.

Trait Implementations

impl<T: Trait> Callable<T> for Module<T>

type Call = Call<T>

impl<T: Clone + Trait> Clone for Module<T>

fn clone(&self) -> Module<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Copy + Trait> Copy for Module<T>

impl<T: Trait> Debug for Module<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T: Eq + Trait> Eq for Module<T>

impl<T: Trait> ModuleErrorMetadata for Module<T>

fn metadata() -> &'static [ErrorMetadata]

impl<T: Trait> OffchainWorker<<T as Trait>::BlockNumber> for Module<T>

fn offchain_worker(_n: BlockNumber)

This function is being called after every block import (when fully synced).

impl<T: Trait> OnFinalize<<T as Trait>::BlockNumber> for Module<T>

fn on_finalize(_n: BlockNumber)

The block is being finalized. Implement to have something happen.

impl<T: Trait> OnInitialize<<T as Trait>::BlockNumber> for Module<T>

fn on_initialize(block_number: T::BlockNumber)

The block is being initialized. Implement to have something happen.

impl<T: PartialEq + Trait> PartialEq<Module<T>> for Module<T>

fn eq(&self, other: &Module<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Module<T>) -> bool

This method tests for !=.

impl<T: Trait> Randomness<<T as Trait>::Hash> for Module<T>

fn random(subject: &[u8]) -> T::Hash

Get a low-influence "random" value.

Being a deterministic block chain, real randomness is difficult to come by. This gives you something that approximates it. subject is a context identifier and allows you to get a different result to other callers of this function; use it like random(&b"my context"[..]). This is initially implemented through a low-influence "triplet mix" convolution of previous block hash values. In the future it will be generated from a secure verifiable random function (VRF).

Security Notes

This randomness uses a low-influence function, drawing upon the block hashes from the previous 81 blocks. Its result for any given subject will be known far in advance by anyone observing the chain. Any block producer has significant influence over their block hashes bounded only by their computational resources. Our low-influence function reduces the actual block producer's influence over the randomness, but increases the influence of small colluding groups of recent block producers.

Some BABE blocks have VRF outputs where the block producer has exactly one bit of influence, either they make the block or they do not make the block and thus someone else makes the next block. Yet, this randomness is not fresh in all BABE blocks.

If that is an insufficient security guarantee then two things can be used to improve this randomness:

• Name, in advance, the block number whose random value will be used; ensure your module retains a buffer of previous random values for its subject and then index into these in order to obviate the ability of your user to look up the parent hash and choose when to transact based upon it.
• Require your user to first commit to an additional value by first posting its hash. Require them to reveal the value to determine the final result, hashing it with the output of this random function. This reduces the ability of a cabal of block producers from conspiring against individuals.

WARNING: Hashing the result of this function will remove any low-influence properties it has and mean that all bits of the resulting value are entirely manipulatable by the author of the parent block, who can determine the value of parent_hash.

fn random_seed() -> Output

Get the basic random seed.

impl<T: Trait> StructuralEq for Module<T>

impl<T: Trait> StructuralPartialEq for Module<T>

impl<T: Trait> WeighBlock<<T as Trait>::BlockNumber> for Module<T>

fn on_initialize(n: T::BlockNumber) -> Weight

Return the weight of the block's on_initialize hook.

fn on_finalize(BlockNumber) -> u32

Return the weight of the block's on_finalize hook.