Struct BigBang 

pub struct BigBang {
    pub block_state: PredicateAddress,
    pub contract_registry: PredicateAddress,
    pub program_registry: PredicateAddress,
    pub solution_set: SolutionSet,
}

Describes how to construct the big-bang (aka “genesis”) block.

Fields

block_state: PredicateAddress

The address of the contract used to track block state.

This contract includes special keys for the block number and block timestamp. E.g.

• [0] is the key for the block number, which is a Word.
• [1] is the key for the block timestamp, which is a Word for seconds since UNIX_EPOCH.

contract_registry: PredicateAddress

The address of the contract used to register contracts and their associated predicates.

There are two primary regions of storage for the contract registry. The layout can be thought of as the following.

storage {
    contracts: (b256 => Contract),
    predicates: (b256 => Predicate),
}

• contracts have key prefix [0]
• predicates have key prefix [1]

Contracts

Contract entries contain the salt and the addresses of its predicates. E.g.

• [0, <contract-ca>, 0] is the key to the “salt”, a b256.
• [0, <contract-ca>, <predicate-ca>] is a key whose non-empty value specifies that the predicate with the given address is associated with the contract.

Predicates

Predicate entries contain their length in bytes as a Word and their fully byte-encoded form within a int[] with padding in the final word if necessary. E.g.

• [1, <predicate-ca>] to get the length bytes as Word followed by the fully encoded word-padded data as int[].

program_registry: PredicateAddress

The address of the contract used to register programs.

storage {
    programs: (b256 => Program),
}

Programs

Program entries contain their length in bytes as a Word and their bytecode within a int[] with padding in the final word if necessary. E.g.

• [0, <program-ca>] to get the bytecode length as Word followed by the bytecode as int[].

solution_set: SolutionSet

The SolutionSet used to initialize arbitrary state for the big bang block.

The primary purpose is setting the initial block state and registering the big bang contracts.

If constructing a custom BigBang configuration, care must be taken to ensure that this SolutionSet does actually register the aforementioned contracts correctly.

Implementations

impl BigBang

pub fn block(&self) -> Block

Produce the big bang Block.

Trait Implementations

impl Clone for BigBang

fn clone(&self) -> BigBang

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BigBang

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

Formats the value using the given formatter.

impl Default for BigBang

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BigBang

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for BigBang

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for BigBang

fn cmp(&self, other: &BigBang) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for BigBang

fn eq(&self, other: &BigBang) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for BigBang

fn partial_cmp(&self, other: &BigBang) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for BigBang

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for BigBang

impl StructuralPartialEq for BigBang