Struct GenesisAllocator

pub struct GenesisAllocator<'a> { /* private fields */ }

This helps create a custom genesis alloc by making it easy to add funded accounts with known signers to the genesis block.

Example

let mut allocator = GenesisAllocator::default();

// This will add a genesis account to the alloc builder, with the provided balance. The
// signer for the account will be returned.
let (_signer, _addr) = allocator.new_funded_account(U256::from(100_000_000_000_000_000u128));

// You can also provide code for the account.
let code = Bytes::from_str("0x1234").unwrap();
let (_second_signer, _second_addr) =
    allocator.new_funded_account_with_code(U256::from(100_000_000_000_000_000u128), code);

// You can also add an account with a specific address.
// This will not return a signer, since the address is provided by the user and the signer
// may be unknown.
let addr = "0Ac1dF02185025F65202660F8167210A80dD5086".parse::<Address>().unwrap();
allocator.add_funded_account_with_address(addr, U256::from(100_000_000_000_000_000u128));

// Once you're done adding accounts, you can build the alloc.
let alloc = allocator.build();

Implementations

impl<'a> GenesisAllocator<'a>

pub fn new_with_rng<R>(rng: &'a mut R) -> Self

where R: RngCore,

Initialize a new alloc builder with the provided rng.

pub fn with_rng<R>(self, rng: &'a mut R) -> Self

where R: RngCore + Debug,

Use the provided rng for generating key pairs.

pub fn new_funded_account(&mut self, balance: U256) -> (Keypair, Address)

Add a funded account to the genesis alloc.

Returns the key pair for the account and the account’s address.

pub fn new_funded_account_with_code( &mut self, balance: U256, code: Bytes, ) -> (Keypair, Address)

Add a funded account to the genesis alloc with the provided code.

Returns the key pair for the account and the account’s address.

pub fn new_funded_account_with_storage( &mut self, balance: U256, storage: BTreeMap<B256, B256>, ) -> (Keypair, Address)

Adds a funded account to the genesis alloc with the provided storage.

Returns the key pair for the account and the account’s address.

pub fn new_account_with_code_and_storage( &mut self, code: Bytes, storage: BTreeMap<B256, B256>, ) -> (Keypair, Address)

Adds an account with code and storage to the genesis alloc.

Returns the key pair for the account and the account’s address.

pub fn new_account_with_code(&mut self, code: Bytes) -> (Keypair, Address)

Adds an account with code to the genesis alloc.

Returns the key pair for the account and the account’s address.

pub fn add_funded_account_with_address( &mut self, address: Address, balance: U256, )

Add a funded account to the genesis alloc with the provided address.

Neither the key pair nor the account will be returned, since the address is provided by the user and the signer may be unknown.

pub fn add_account(&mut self, account: GenesisAccount) -> Address

Adds the given [GenesisAccount] to the genesis alloc.

Returns the key pair for the account and the account’s address.

pub fn get_account(&self, address: &Address) -> Option<&GenesisAccount>

Gets the account for the provided address.

If it does not exist, this returns None.

pub fn get_account_mut( &mut self, address: &Address, ) -> Option<&mut GenesisAccount>

Gets a mutable version of the account for the provided address, if it exists.

pub fn account_entry( &mut self, address: Address, ) -> Entry<'_, Address, GenesisAccount>

Gets an Entry for the provided address.

pub fn build(self) -> HashMap<Address, GenesisAccount>

Build the genesis alloc.

Trait Implementations

impl Debug for GenesisAllocator<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for GenesisAllocator<'_>

fn default() -> Self

Returns the “default value” for a type.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 64 bytes