Struct tp_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 tp_runtime::traits::{Hash, BlakeTwo256};
use tp_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, 

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

Attempt to deserialise the value from input.

fn skip<I>(input: &mut I) -> Result<(), Error> where
    I: Input, 

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

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

fn encode_to<__CodecOutputEdqy: Output + ?Sized>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
)

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

fn size_hint(&self) -> usize

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

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

Convert self to an owned vector.

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.

fn encoded_size(&self) -> usize

Calculates the encoded size.

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