Struct sp_runtime::random_number_generator::RandomNumberGenerator

pub struct RandomNumberGenerator<Hashing: Hash> { /* fields omitted */ }

Pseudo-random number streamer. This retains the state of the random number stream. It's as secure as the combination of the seed with which it is constructed and the hash function it uses to cycle elements.

It can be saved and later reloaded using the Codec traits.

Example:

use sp_runtime::traits::{Hash, BlakeTwo256};
use sp_runtime::RandomNumberGenerator;
let random_seed = BlakeTwo256::hash(b"Sixty-nine");
let mut rng = <RandomNumberGenerator<BlakeTwo256>>::new(random_seed);
assert_eq!(rng.pick_u32(100), 59);
assert_eq!(rng.pick_item(&[1, 2, 3]), Some(&1));

This can use any cryptographic Hash function as the means of entropy-extension, and avoids needless extensions of entropy.

If you're persisting it over blocks, be aware that the sequence will start to repeat. This won't be a practical issue unless you're using tiny hash types (e.g. 64-bit) and pulling hundred of megabytes of data from it.

Implementations

impl<Hashing: Hash> RandomNumberGenerator<Hashing>

pub fn new(seed: Hashing::Output) -> Self

A new source of random data.

pub fn pick_u32(&mut self, max: u32) -> u32

Returns a number at least zero, at most max.

pub fn pick_usize(&mut self, max: usize) -> usize

Returns a number at least zero, at most max.

This returns a usize, but internally it only uses u32 so avoid consensus problems.

pub fn pick_item<'a, T>(&mut self, items: &'a [T]) -> Option<&'a T>

Pick a random element from an array of items.

This is guaranteed to return Some except in the case that the given array items is empty.

Trait Implementations

impl<Hashing: Hash> Decode for RandomNumberGenerator<Hashing> where
    Hashing::Output: Decode,
    Hashing::Output: Decode, 

pub fn decode<__CodecInputEdqy: Input>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>

Attempt to deserialise the value from input.

impl<Hashing: Hash> Encode for RandomNumberGenerator<Hashing> where
    Hashing::Output: Encode,
    Hashing::Output: Encode, 

pub fn encode_to<__CodecOutputEdqy: Output>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
)

Convert self to a slice and append it to the destination.

pub fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

pub fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

pub fn using_encoded<R, F>(&self, f: F) -> R where
    F: FnOnce(&[u8]) -> R, 

Convert self to a slice and then invoke the given closure with it.

impl<Hashing: Hash> EncodeLike<RandomNumberGenerator<Hashing>> for RandomNumberGenerator<Hashing> where
    Hashing::Output: Encode,
    Hashing::Output: Encode,