Trait gclient::ext::sp_core::crypto::FromEntropy

pub trait FromEntropy: Sized {
    // Required method
    fn from_entropy(input: &mut impl Input) -> Result<Self, Error>;
}

Create random values of Self given a stream of entropy.

Required Methods

fn from_entropy(input: &mut impl Input) -> Result<Self, Error>

Create a random value of Self given a stream of random bytes on input. May only fail if input has an error.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl FromEntropy for bool

fn from_entropy(input: &mut impl Input) -> Result<bool, Error>

impl FromEntropy for i8

fn from_entropy(input: &mut impl Input) -> Result<i8, Error>

impl FromEntropy for i16

fn from_entropy(input: &mut impl Input) -> Result<i16, Error>

impl FromEntropy for i32

fn from_entropy(input: &mut impl Input) -> Result<i32, Error>

impl FromEntropy for i64

fn from_entropy(input: &mut impl Input) -> Result<i64, Error>

impl FromEntropy for i128

fn from_entropy(input: &mut impl Input) -> Result<i128, Error>

impl FromEntropy for u8

fn from_entropy(input: &mut impl Input) -> Result<u8, Error>

impl FromEntropy for u16

fn from_entropy(input: &mut impl Input) -> Result<u16, Error>

impl FromEntropy for u32

fn from_entropy(input: &mut impl Input) -> Result<u32, Error>

impl FromEntropy for u64

fn from_entropy(input: &mut impl Input) -> Result<u64, Error>

impl FromEntropy for u128

fn from_entropy(input: &mut impl Input) -> Result<u128, Error>

impl FromEntropy for ()

Create the unit type for any given input.

fn from_entropy(_: &mut impl Input) -> Result<(), Error>

impl FromEntropy for [i8; 1]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 1], Error>

impl FromEntropy for [i8; 2]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 2], Error>

impl FromEntropy for [i8; 3]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 3], Error>

impl FromEntropy for [i8; 4]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 4], Error>

impl FromEntropy for [i8; 5]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 5], Error>

impl FromEntropy for [i8; 6]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 6], Error>

impl FromEntropy for [i8; 7]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 7], Error>

impl FromEntropy for [i8; 8]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 8], Error>

impl FromEntropy for [i8; 9]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 9], Error>

impl FromEntropy for [i8; 10]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 10], Error>

impl FromEntropy for [i8; 11]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 11], Error>

impl FromEntropy for [i8; 12]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 12], Error>

impl FromEntropy for [i8; 13]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 13], Error>

impl FromEntropy for [i8; 14]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 14], Error>

impl FromEntropy for [i8; 15]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 15], Error>

impl FromEntropy for [i8; 16]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 16], Error>

impl FromEntropy for [i8; 17]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 17], Error>

impl FromEntropy for [i8; 18]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 18], Error>

impl FromEntropy for [i8; 19]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 19], Error>

impl FromEntropy for [i8; 20]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 20], Error>

impl FromEntropy for [i8; 21]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 21], Error>

impl FromEntropy for [i8; 22]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 22], Error>

impl FromEntropy for [i8; 23]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 23], Error>

impl FromEntropy for [i8; 24]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 24], Error>

impl FromEntropy for [i8; 25]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 25], Error>

impl FromEntropy for [i8; 26]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 26], Error>

impl FromEntropy for [i8; 27]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 27], Error>

impl FromEntropy for [i8; 28]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 28], Error>

impl FromEntropy for [i8; 29]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 29], Error>

impl FromEntropy for [i8; 30]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 30], Error>

impl FromEntropy for [i8; 31]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 31], Error>

impl FromEntropy for [i8; 32]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 32], Error>

impl FromEntropy for [i8; 36]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 36], Error>

impl FromEntropy for [i8; 40]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 40], Error>

impl FromEntropy for [i8; 44]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 44], Error>

impl FromEntropy for [i8; 48]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 48], Error>

impl FromEntropy for [i8; 56]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 56], Error>

impl FromEntropy for [i8; 64]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 64], Error>

impl FromEntropy for [i8; 72]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 72], Error>

impl FromEntropy for [i8; 80]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 80], Error>

impl FromEntropy for [i8; 96]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 96], Error>

impl FromEntropy for [i8; 112]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 112], Error>

impl FromEntropy for [i8; 128]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 128], Error>

impl FromEntropy for [i8; 160]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 160], Error>

impl FromEntropy for [i8; 177]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 177], Error>

impl FromEntropy for [i8; 192]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 192], Error>

impl FromEntropy for [i8; 224]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 224], Error>

impl FromEntropy for [i8; 256]

fn from_entropy(input: &mut impl Input) -> Result<[i8; 256], Error>

impl FromEntropy for [i16; 1]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 1], Error>

impl FromEntropy for [i16; 2]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 2], Error>

impl FromEntropy for [i16; 3]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 3], Error>

impl FromEntropy for [i16; 4]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 4], Error>

impl FromEntropy for [i16; 5]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 5], Error>

impl FromEntropy for [i16; 6]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 6], Error>

impl FromEntropy for [i16; 7]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 7], Error>

impl FromEntropy for [i16; 8]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 8], Error>

impl FromEntropy for [i16; 9]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 9], Error>

impl FromEntropy for [i16; 10]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 10], Error>

impl FromEntropy for [i16; 11]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 11], Error>

impl FromEntropy for [i16; 12]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 12], Error>

impl FromEntropy for [i16; 13]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 13], Error>

impl FromEntropy for [i16; 14]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 14], Error>

impl FromEntropy for [i16; 15]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 15], Error>

impl FromEntropy for [i16; 16]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 16], Error>

impl FromEntropy for [i16; 17]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 17], Error>

impl FromEntropy for [i16; 18]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 18], Error>

impl FromEntropy for [i16; 19]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 19], Error>

impl FromEntropy for [i16; 20]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 20], Error>

impl FromEntropy for [i16; 21]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 21], Error>

impl FromEntropy for [i16; 22]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 22], Error>

impl FromEntropy for [i16; 23]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 23], Error>

impl FromEntropy for [i16; 24]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 24], Error>

impl FromEntropy for [i16; 25]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 25], Error>

impl FromEntropy for [i16; 26]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 26], Error>

impl FromEntropy for [i16; 27]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 27], Error>

impl FromEntropy for [i16; 28]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 28], Error>

impl FromEntropy for [i16; 29]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 29], Error>

impl FromEntropy for [i16; 30]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 30], Error>

impl FromEntropy for [i16; 31]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 31], Error>

impl FromEntropy for [i16; 32]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 32], Error>

impl FromEntropy for [i16; 36]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 36], Error>

impl FromEntropy for [i16; 40]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 40], Error>

impl FromEntropy for [i16; 44]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 44], Error>

impl FromEntropy for [i16; 48]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 48], Error>

impl FromEntropy for [i16; 56]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 56], Error>

impl FromEntropy for [i16; 64]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 64], Error>

impl FromEntropy for [i16; 72]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 72], Error>

impl FromEntropy for [i16; 80]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 80], Error>

impl FromEntropy for [i16; 96]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 96], Error>

impl FromEntropy for [i16; 112]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 112], Error>

impl FromEntropy for [i16; 128]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 128], Error>

impl FromEntropy for [i16; 160]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 160], Error>

impl FromEntropy for [i16; 177]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 177], Error>

impl FromEntropy for [i16; 192]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 192], Error>

impl FromEntropy for [i16; 224]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 224], Error>

impl FromEntropy for [i16; 256]

fn from_entropy(input: &mut impl Input) -> Result<[i16; 256], Error>

impl FromEntropy for [i32; 1]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 1], Error>

impl FromEntropy for [i32; 2]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 2], Error>

impl FromEntropy for [i32; 3]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 3], Error>

impl FromEntropy for [i32; 4]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 4], Error>

impl FromEntropy for [i32; 5]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 5], Error>

impl FromEntropy for [i32; 6]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 6], Error>

impl FromEntropy for [i32; 7]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 7], Error>

impl FromEntropy for [i32; 8]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 8], Error>

impl FromEntropy for [i32; 9]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 9], Error>

impl FromEntropy for [i32; 10]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 10], Error>

impl FromEntropy for [i32; 11]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 11], Error>

impl FromEntropy for [i32; 12]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 12], Error>

impl FromEntropy for [i32; 13]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 13], Error>

impl FromEntropy for [i32; 14]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 14], Error>

impl FromEntropy for [i32; 15]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 15], Error>

impl FromEntropy for [i32; 16]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 16], Error>

impl FromEntropy for [i32; 17]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 17], Error>

impl FromEntropy for [i32; 18]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 18], Error>

impl FromEntropy for [i32; 19]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 19], Error>

impl FromEntropy for [i32; 20]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 20], Error>

impl FromEntropy for [i32; 21]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 21], Error>

impl FromEntropy for [i32; 22]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 22], Error>

impl FromEntropy for [i32; 23]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 23], Error>

impl FromEntropy for [i32; 24]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 24], Error>

impl FromEntropy for [i32; 25]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 25], Error>

impl FromEntropy for [i32; 26]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 26], Error>

impl FromEntropy for [i32; 27]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 27], Error>

impl FromEntropy for [i32; 28]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 28], Error>

impl FromEntropy for [i32; 29]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 29], Error>

impl FromEntropy for [i32; 30]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 30], Error>

impl FromEntropy for [i32; 31]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 31], Error>

impl FromEntropy for [i32; 32]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 32], Error>

impl FromEntropy for [i32; 36]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 36], Error>

impl FromEntropy for [i32; 40]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 40], Error>

impl FromEntropy for [i32; 44]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 44], Error>

impl FromEntropy for [i32; 48]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 48], Error>

impl FromEntropy for [i32; 56]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 56], Error>

impl FromEntropy for [i32; 64]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 64], Error>

impl FromEntropy for [i32; 72]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 72], Error>

impl FromEntropy for [i32; 80]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 80], Error>

impl FromEntropy for [i32; 96]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 96], Error>

impl FromEntropy for [i32; 112]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 112], Error>

impl FromEntropy for [i32; 128]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 128], Error>

impl FromEntropy for [i32; 160]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 160], Error>

impl FromEntropy for [i32; 177]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 177], Error>

impl FromEntropy for [i32; 192]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 192], Error>

impl FromEntropy for [i32; 224]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 224], Error>

impl FromEntropy for [i32; 256]

fn from_entropy(input: &mut impl Input) -> Result<[i32; 256], Error>

impl FromEntropy for [i64; 1]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 1], Error>

impl FromEntropy for [i64; 2]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 2], Error>

impl FromEntropy for [i64; 3]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 3], Error>

impl FromEntropy for [i64; 4]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 4], Error>

impl FromEntropy for [i64; 5]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 5], Error>

impl FromEntropy for [i64; 6]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 6], Error>

impl FromEntropy for [i64; 7]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 7], Error>

impl FromEntropy for [i64; 8]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 8], Error>

impl FromEntropy for [i64; 9]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 9], Error>

impl FromEntropy for [i64; 10]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 10], Error>

impl FromEntropy for [i64; 11]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 11], Error>

impl FromEntropy for [i64; 12]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 12], Error>

impl FromEntropy for [i64; 13]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 13], Error>

impl FromEntropy for [i64; 14]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 14], Error>

impl FromEntropy for [i64; 15]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 15], Error>

impl FromEntropy for [i64; 16]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 16], Error>

impl FromEntropy for [i64; 17]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 17], Error>

impl FromEntropy for [i64; 18]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 18], Error>

impl FromEntropy for [i64; 19]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 19], Error>

impl FromEntropy for [i64; 20]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 20], Error>

impl FromEntropy for [i64; 21]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 21], Error>

impl FromEntropy for [i64; 22]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 22], Error>

impl FromEntropy for [i64; 23]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 23], Error>

impl FromEntropy for [i64; 24]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 24], Error>

impl FromEntropy for [i64; 25]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 25], Error>

impl FromEntropy for [i64; 26]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 26], Error>

impl FromEntropy for [i64; 27]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 27], Error>

impl FromEntropy for [i64; 28]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 28], Error>

impl FromEntropy for [i64; 29]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 29], Error>

impl FromEntropy for [i64; 30]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 30], Error>

impl FromEntropy for [i64; 31]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 31], Error>

impl FromEntropy for [i64; 32]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 32], Error>

impl FromEntropy for [i64; 36]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 36], Error>

impl FromEntropy for [i64; 40]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 40], Error>

impl FromEntropy for [i64; 44]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 44], Error>

impl FromEntropy for [i64; 48]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 48], Error>

impl FromEntropy for [i64; 56]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 56], Error>

impl FromEntropy for [i64; 64]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 64], Error>

impl FromEntropy for [i64; 72]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 72], Error>

impl FromEntropy for [i64; 80]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 80], Error>

impl FromEntropy for [i64; 96]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 96], Error>

impl FromEntropy for [i64; 112]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 112], Error>

impl FromEntropy for [i64; 128]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 128], Error>

impl FromEntropy for [i64; 160]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 160], Error>

impl FromEntropy for [i64; 177]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 177], Error>

impl FromEntropy for [i64; 192]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 192], Error>

impl FromEntropy for [i64; 224]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 224], Error>

impl FromEntropy for [i64; 256]

fn from_entropy(input: &mut impl Input) -> Result<[i64; 256], Error>

impl FromEntropy for [i128; 1]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 1], Error>

impl FromEntropy for [i128; 2]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 2], Error>

impl FromEntropy for [i128; 3]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 3], Error>

impl FromEntropy for [i128; 4]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 4], Error>

impl FromEntropy for [i128; 5]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 5], Error>

impl FromEntropy for [i128; 6]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 6], Error>

impl FromEntropy for [i128; 7]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 7], Error>

impl FromEntropy for [i128; 8]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 8], Error>

impl FromEntropy for [i128; 9]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 9], Error>

impl FromEntropy for [i128; 10]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 10], Error>

impl FromEntropy for [i128; 11]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 11], Error>

impl FromEntropy for [i128; 12]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 12], Error>

impl FromEntropy for [i128; 13]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 13], Error>

impl FromEntropy for [i128; 14]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 14], Error>

impl FromEntropy for [i128; 15]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 15], Error>

impl FromEntropy for [i128; 16]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 16], Error>

impl FromEntropy for [i128; 17]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 17], Error>

impl FromEntropy for [i128; 18]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 18], Error>

impl FromEntropy for [i128; 19]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 19], Error>

impl FromEntropy for [i128; 20]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 20], Error>

impl FromEntropy for [i128; 21]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 21], Error>

impl FromEntropy for [i128; 22]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 22], Error>

impl FromEntropy for [i128; 23]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 23], Error>

impl FromEntropy for [i128; 24]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 24], Error>

impl FromEntropy for [i128; 25]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 25], Error>

impl FromEntropy for [i128; 26]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 26], Error>

impl FromEntropy for [i128; 27]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 27], Error>

impl FromEntropy for [i128; 28]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 28], Error>

impl FromEntropy for [i128; 29]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 29], Error>

impl FromEntropy for [i128; 30]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 30], Error>

impl FromEntropy for [i128; 31]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 31], Error>

impl FromEntropy for [i128; 32]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 32], Error>

impl FromEntropy for [i128; 36]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 36], Error>

impl FromEntropy for [i128; 40]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 40], Error>

impl FromEntropy for [i128; 44]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 44], Error>

impl FromEntropy for [i128; 48]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 48], Error>

impl FromEntropy for [i128; 56]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 56], Error>

impl FromEntropy for [i128; 64]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 64], Error>

impl FromEntropy for [i128; 72]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 72], Error>

impl FromEntropy for [i128; 80]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 80], Error>

impl FromEntropy for [i128; 96]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 96], Error>

impl FromEntropy for [i128; 112]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 112], Error>

impl FromEntropy for [i128; 128]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 128], Error>

impl FromEntropy for [i128; 160]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 160], Error>

impl FromEntropy for [i128; 177]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 177], Error>

impl FromEntropy for [i128; 192]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 192], Error>

impl FromEntropy for [i128; 224]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 224], Error>

impl FromEntropy for [i128; 256]

fn from_entropy(input: &mut impl Input) -> Result<[i128; 256], Error>

impl FromEntropy for [u8; 1]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 1], Error>

impl FromEntropy for [u8; 2]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 2], Error>

impl FromEntropy for [u8; 3]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 3], Error>

impl FromEntropy for [u8; 4]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 4], Error>

impl FromEntropy for [u8; 5]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 5], Error>

impl FromEntropy for [u8; 6]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 6], Error>

impl FromEntropy for [u8; 7]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 7], Error>

impl FromEntropy for [u8; 8]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 8], Error>

impl FromEntropy for [u8; 9]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 9], Error>

impl FromEntropy for [u8; 10]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 10], Error>

impl FromEntropy for [u8; 11]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 11], Error>

impl FromEntropy for [u8; 12]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 12], Error>

impl FromEntropy for [u8; 13]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 13], Error>

impl FromEntropy for [u8; 14]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 14], Error>

impl FromEntropy for [u8; 15]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 15], Error>

impl FromEntropy for [u8; 16]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 16], Error>

impl FromEntropy for [u8; 17]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 17], Error>

impl FromEntropy for [u8; 18]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 18], Error>

impl FromEntropy for [u8; 19]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 19], Error>

impl FromEntropy for [u8; 20]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 20], Error>

impl FromEntropy for [u8; 21]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 21], Error>

impl FromEntropy for [u8; 22]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 22], Error>

impl FromEntropy for [u8; 23]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 23], Error>

impl FromEntropy for [u8; 24]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 24], Error>

impl FromEntropy for [u8; 25]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 25], Error>

impl FromEntropy for [u8; 26]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 26], Error>

impl FromEntropy for [u8; 27]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 27], Error>

impl FromEntropy for [u8; 28]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 28], Error>

impl FromEntropy for [u8; 29]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 29], Error>

impl FromEntropy for [u8; 30]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 30], Error>

impl FromEntropy for [u8; 31]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 31], Error>

impl FromEntropy for [u8; 32]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 32], Error>

impl FromEntropy for [u8; 36]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 36], Error>

impl FromEntropy for [u8; 40]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 40], Error>

impl FromEntropy for [u8; 44]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 44], Error>

impl FromEntropy for [u8; 48]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 48], Error>

impl FromEntropy for [u8; 56]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 56], Error>

impl FromEntropy for [u8; 64]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 64], Error>

impl FromEntropy for [u8; 72]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 72], Error>

impl FromEntropy for [u8; 80]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 80], Error>

impl FromEntropy for [u8; 96]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 96], Error>

impl FromEntropy for [u8; 112]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 112], Error>

impl FromEntropy for [u8; 128]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 128], Error>

impl FromEntropy for [u8; 160]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 160], Error>

impl FromEntropy for [u8; 177]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 177], Error>

impl FromEntropy for [u8; 192]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 192], Error>

impl FromEntropy for [u8; 224]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 224], Error>

impl FromEntropy for [u8; 256]

fn from_entropy(input: &mut impl Input) -> Result<[u8; 256], Error>

impl FromEntropy for [u16; 1]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 1], Error>

impl FromEntropy for [u16; 2]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 2], Error>

impl FromEntropy for [u16; 3]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 3], Error>

impl FromEntropy for [u16; 4]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 4], Error>

impl FromEntropy for [u16; 5]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 5], Error>

impl FromEntropy for [u16; 6]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 6], Error>

impl FromEntropy for [u16; 7]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 7], Error>

impl FromEntropy for [u16; 8]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 8], Error>

impl FromEntropy for [u16; 9]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 9], Error>

impl FromEntropy for [u16; 10]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 10], Error>

impl FromEntropy for [u16; 11]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 11], Error>

impl FromEntropy for [u16; 12]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 12], Error>

impl FromEntropy for [u16; 13]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 13], Error>

impl FromEntropy for [u16; 14]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 14], Error>

impl FromEntropy for [u16; 15]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 15], Error>

impl FromEntropy for [u16; 16]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 16], Error>

impl FromEntropy for [u16; 17]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 17], Error>

impl FromEntropy for [u16; 18]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 18], Error>

impl FromEntropy for [u16; 19]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 19], Error>

impl FromEntropy for [u16; 20]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 20], Error>

impl FromEntropy for [u16; 21]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 21], Error>

impl FromEntropy for [u16; 22]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 22], Error>

impl FromEntropy for [u16; 23]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 23], Error>

impl FromEntropy for [u16; 24]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 24], Error>

impl FromEntropy for [u16; 25]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 25], Error>

impl FromEntropy for [u16; 26]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 26], Error>

impl FromEntropy for [u16; 27]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 27], Error>

impl FromEntropy for [u16; 28]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 28], Error>

impl FromEntropy for [u16; 29]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 29], Error>

impl FromEntropy for [u16; 30]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 30], Error>

impl FromEntropy for [u16; 31]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 31], Error>

impl FromEntropy for [u16; 32]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 32], Error>

impl FromEntropy for [u16; 36]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 36], Error>

impl FromEntropy for [u16; 40]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 40], Error>

impl FromEntropy for [u16; 44]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 44], Error>

impl FromEntropy for [u16; 48]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 48], Error>

impl FromEntropy for [u16; 56]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 56], Error>

impl FromEntropy for [u16; 64]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 64], Error>

impl FromEntropy for [u16; 72]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 72], Error>

impl FromEntropy for [u16; 80]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 80], Error>

impl FromEntropy for [u16; 96]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 96], Error>

impl FromEntropy for [u16; 112]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 112], Error>

impl FromEntropy for [u16; 128]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 128], Error>

impl FromEntropy for [u16; 160]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 160], Error>

impl FromEntropy for [u16; 177]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 177], Error>

impl FromEntropy for [u16; 192]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 192], Error>

impl FromEntropy for [u16; 224]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 224], Error>

impl FromEntropy for [u16; 256]

fn from_entropy(input: &mut impl Input) -> Result<[u16; 256], Error>

impl FromEntropy for [u32; 1]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 1], Error>

impl FromEntropy for [u32; 2]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 2], Error>

impl FromEntropy for [u32; 3]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 3], Error>

impl FromEntropy for [u32; 4]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 4], Error>

impl FromEntropy for [u32; 5]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 5], Error>

impl FromEntropy for [u32; 6]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 6], Error>

impl FromEntropy for [u32; 7]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 7], Error>

impl FromEntropy for [u32; 8]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 8], Error>

impl FromEntropy for [u32; 9]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 9], Error>

impl FromEntropy for [u32; 10]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 10], Error>

impl FromEntropy for [u32; 11]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 11], Error>

impl FromEntropy for [u32; 12]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 12], Error>

impl FromEntropy for [u32; 13]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 13], Error>

impl FromEntropy for [u32; 14]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 14], Error>

impl FromEntropy for [u32; 15]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 15], Error>

impl FromEntropy for [u32; 16]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 16], Error>

impl FromEntropy for [u32; 17]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 17], Error>

impl FromEntropy for [u32; 18]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 18], Error>

impl FromEntropy for [u32; 19]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 19], Error>

impl FromEntropy for [u32; 20]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 20], Error>

impl FromEntropy for [u32; 21]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 21], Error>

impl FromEntropy for [u32; 22]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 22], Error>

impl FromEntropy for [u32; 23]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 23], Error>

impl FromEntropy for [u32; 24]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 24], Error>

impl FromEntropy for [u32; 25]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 25], Error>

impl FromEntropy for [u32; 26]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 26], Error>

impl FromEntropy for [u32; 27]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 27], Error>

impl FromEntropy for [u32; 28]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 28], Error>

impl FromEntropy for [u32; 29]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 29], Error>

impl FromEntropy for [u32; 30]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 30], Error>

impl FromEntropy for [u32; 31]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 31], Error>

impl FromEntropy for [u32; 32]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 32], Error>

impl FromEntropy for [u32; 36]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 36], Error>

impl FromEntropy for [u32; 40]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 40], Error>

impl FromEntropy for [u32; 44]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 44], Error>

impl FromEntropy for [u32; 48]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 48], Error>

impl FromEntropy for [u32; 56]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 56], Error>

impl FromEntropy for [u32; 64]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 64], Error>

impl FromEntropy for [u32; 72]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 72], Error>

impl FromEntropy for [u32; 80]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 80], Error>

impl FromEntropy for [u32; 96]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 96], Error>

impl FromEntropy for [u32; 112]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 112], Error>

impl FromEntropy for [u32; 128]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 128], Error>

impl FromEntropy for [u32; 160]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 160], Error>

impl FromEntropy for [u32; 177]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 177], Error>

impl FromEntropy for [u32; 192]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 192], Error>

impl FromEntropy for [u32; 224]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 224], Error>

impl FromEntropy for [u32; 256]

fn from_entropy(input: &mut impl Input) -> Result<[u32; 256], Error>

impl FromEntropy for [u64; 1]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 1], Error>

impl FromEntropy for [u64; 2]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 2], Error>

impl FromEntropy for [u64; 3]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 3], Error>

impl FromEntropy for [u64; 4]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 4], Error>

impl FromEntropy for [u64; 5]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 5], Error>

impl FromEntropy for [u64; 6]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 6], Error>

impl FromEntropy for [u64; 7]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 7], Error>

impl FromEntropy for [u64; 8]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 8], Error>

impl FromEntropy for [u64; 9]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 9], Error>

impl FromEntropy for [u64; 10]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 10], Error>

impl FromEntropy for [u64; 11]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 11], Error>

impl FromEntropy for [u64; 12]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 12], Error>

impl FromEntropy for [u64; 13]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 13], Error>

impl FromEntropy for [u64; 14]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 14], Error>

impl FromEntropy for [u64; 15]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 15], Error>

impl FromEntropy for [u64; 16]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 16], Error>

impl FromEntropy for [u64; 17]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 17], Error>

impl FromEntropy for [u64; 18]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 18], Error>

impl FromEntropy for [u64; 19]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 19], Error>

impl FromEntropy for [u64; 20]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 20], Error>

impl FromEntropy for [u64; 21]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 21], Error>

impl FromEntropy for [u64; 22]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 22], Error>

impl FromEntropy for [u64; 23]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 23], Error>

impl FromEntropy for [u64; 24]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 24], Error>

impl FromEntropy for [u64; 25]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 25], Error>

impl FromEntropy for [u64; 26]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 26], Error>

impl FromEntropy for [u64; 27]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 27], Error>

impl FromEntropy for [u64; 28]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 28], Error>

impl FromEntropy for [u64; 29]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 29], Error>

impl FromEntropy for [u64; 30]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 30], Error>

impl FromEntropy for [u64; 31]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 31], Error>

impl FromEntropy for [u64; 32]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 32], Error>

impl FromEntropy for [u64; 36]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 36], Error>

impl FromEntropy for [u64; 40]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 40], Error>

impl FromEntropy for [u64; 44]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 44], Error>

impl FromEntropy for [u64; 48]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 48], Error>

impl FromEntropy for [u64; 56]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 56], Error>

impl FromEntropy for [u64; 64]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 64], Error>

impl FromEntropy for [u64; 72]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 72], Error>

impl FromEntropy for [u64; 80]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 80], Error>

impl FromEntropy for [u64; 96]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 96], Error>

impl FromEntropy for [u64; 112]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 112], Error>

impl FromEntropy for [u64; 128]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 128], Error>

impl FromEntropy for [u64; 160]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 160], Error>

impl FromEntropy for [u64; 177]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 177], Error>

impl FromEntropy for [u64; 192]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 192], Error>

impl FromEntropy for [u64; 224]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 224], Error>

impl FromEntropy for [u64; 256]

fn from_entropy(input: &mut impl Input) -> Result<[u64; 256], Error>

impl FromEntropy for [u128; 1]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 1], Error>

impl FromEntropy for [u128; 2]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 2], Error>

impl FromEntropy for [u128; 3]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 3], Error>

impl FromEntropy for [u128; 4]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 4], Error>

impl FromEntropy for [u128; 5]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 5], Error>

impl FromEntropy for [u128; 6]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 6], Error>

impl FromEntropy for [u128; 7]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 7], Error>

impl FromEntropy for [u128; 8]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 8], Error>

impl FromEntropy for [u128; 9]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 9], Error>

impl FromEntropy for [u128; 10]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 10], Error>

impl FromEntropy for [u128; 11]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 11], Error>

impl FromEntropy for [u128; 12]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 12], Error>

impl FromEntropy for [u128; 13]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 13], Error>

impl FromEntropy for [u128; 14]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 14], Error>

impl FromEntropy for [u128; 15]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 15], Error>

impl FromEntropy for [u128; 16]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 16], Error>

impl FromEntropy for [u128; 17]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 17], Error>

impl FromEntropy for [u128; 18]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 18], Error>

impl FromEntropy for [u128; 19]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 19], Error>

impl FromEntropy for [u128; 20]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 20], Error>

impl FromEntropy for [u128; 21]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 21], Error>

impl FromEntropy for [u128; 22]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 22], Error>

impl FromEntropy for [u128; 23]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 23], Error>

impl FromEntropy for [u128; 24]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 24], Error>

impl FromEntropy for [u128; 25]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 25], Error>

impl FromEntropy for [u128; 26]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 26], Error>

impl FromEntropy for [u128; 27]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 27], Error>

impl FromEntropy for [u128; 28]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 28], Error>

impl FromEntropy for [u128; 29]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 29], Error>

impl FromEntropy for [u128; 30]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 30], Error>

impl FromEntropy for [u128; 31]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 31], Error>

impl FromEntropy for [u128; 32]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 32], Error>

impl FromEntropy for [u128; 36]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 36], Error>

impl FromEntropy for [u128; 40]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 40], Error>

impl FromEntropy for [u128; 44]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 44], Error>

impl FromEntropy for [u128; 48]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 48], Error>

impl FromEntropy for [u128; 56]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 56], Error>

impl FromEntropy for [u128; 64]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 64], Error>

impl FromEntropy for [u128; 72]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 72], Error>

impl FromEntropy for [u128; 80]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 80], Error>

impl FromEntropy for [u128; 96]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 96], Error>

impl FromEntropy for [u128; 112]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 112], Error>

impl FromEntropy for [u128; 128]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 128], Error>

impl FromEntropy for [u128; 160]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 160], Error>

impl FromEntropy for [u128; 177]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 177], Error>

impl FromEntropy for [u128; 192]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 192], Error>

impl FromEntropy for [u128; 224]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 224], Error>

impl FromEntropy for [u128; 256]

fn from_entropy(input: &mut impl Input) -> Result<[u128; 256], Error>

Implementors

impl FromEntropy for MultiSigner

impl FromEntropy for AccountId32

Creates an AccountId32 from the input, which should contain at least 32 bytes.

impl<const N: usize, T> FromEntropy for CryptoBytes<N, T>