Struct Account 

pub struct Account { /* private fields */ }

An account which can store assets and define rules for manipulating them.

An account consists of the following components:

• Account ID, which uniquely identifies the account and also defines basic properties of the account.
• Account vault, which stores assets owned by the account.
• Account storage, which is a key-value map (both keys and values are words) used to store arbitrary user-defined data.
• Account code, which is a set of Miden VM programs defining the public interface of the account.
• Account nonce, a value which is incremented whenever account state is updated.

Out of the above components account ID is always immutable (once defined it can never be changed). Other components may be mutated throughout the lifetime of the account. However, account state can be changed only by invoking one of account interface methods.

The recommended way to build an account is through an AccountBuilder, which can be instantiated through Account::builder. See the type’s documentation for details.

Implementations

impl Account

pub fn new( id: AccountId, vault: AssetVault, storage: AccountStorage, code: AccountCode, nonce: Felt, seed: Option<Word>, ) -> Result<Self, AccountError>

Returns an Account instantiated with the provided components.

Errors

Returns an error if:

• an account seed is provided but the account’s nonce indicates the account already exists.
• an account seed is not provided but the account’s nonce indicates the account is new.
• an account seed is provided but the account ID derived from it is invalid or does not match the provided account’s ID.

pub fn new_unchecked( id: AccountId, vault: AssetVault, storage: AccountStorage, code: AccountCode, nonce: Felt, seed: Option<Word>, ) -> Self

Returns an Account instantiated with the provided components.

Warning

This does not check that the provided seed is valid with respect to the provided components. Prefer using Account::new whenever possible.

pub fn builder(init_seed: [u8; 32]) -> AccountBuilder

Creates a new AccountBuilder for an account and sets the initial seed from which the grinding process for that account’s AccountId will start.

This initial seed should come from a cryptographic random number generator.

pub fn commitment(&self) -> Word

Returns the commitment of this account.

The commitment of an account is computed as hash(id, nonce, vault_root, storage_commitment, code_commitment). Computing the account commitment requires 2 permutations of the hash function.

pub fn initial_commitment(&self) -> Word

Returns the commitment of this account as used for the initial account state commitment in transaction proofs.

For existing accounts, this is exactly the same as Account::commitment(), however, for new accounts this value is set to crate::EMPTY_WORD. This is because when a transaction is executed against a new account, public input for the initial account state is set to crate::EMPTY_WORD to distinguish new accounts from existing accounts. The actual commitment of the initial account state (and the initial state itself), are provided to the VM via the advice provider.

pub fn id(&self) -> AccountId

Returns unique identifier of this account.

pub fn account_type(&self) -> AccountType

Returns the account type

pub fn vault(&self) -> &AssetVault

Returns a reference to the vault of this account.

pub fn storage(&self) -> &AccountStorage

Returns a reference to the storage of this account.

pub fn code(&self) -> &AccountCode

Returns a reference to the code of this account.

pub fn nonce(&self) -> Felt

Returns nonce for this account.

pub fn seed(&self) -> Option<Word>

Returns the seed of the account’s ID if the account is new.

That is, if Account::is_new returns true, the seed will be Some.

pub fn is_faucet(&self) -> bool

Returns true if this account can issue assets.

pub fn is_regular_account(&self) -> bool

Returns true if this is a regular account.

pub fn has_public_state(&self) -> bool

Returns true if the full state of the account is public on chain, i.e. if the modes are AccountStorageMode::Public or AccountStorageMode::Network, false otherwise.

pub fn is_public(&self) -> bool

Returns true if the storage mode is AccountStorageMode::Public, false otherwise.

pub fn is_private(&self) -> bool

Returns true if the storage mode is AccountStorageMode::Private, false otherwise.

pub fn is_network(&self) -> bool

Returns true if the storage mode is AccountStorageMode::Network, false otherwise.

pub fn is_new(&self) -> bool

Returns true if the account is new, false otherwise.

An account is considered new if the account’s nonce is zero and it hasn’t been registered on chain yet.

pub fn into_parts( self, ) -> (AccountId, AssetVault, AccountStorage, AccountCode, Felt, Option<Word>)

Decomposes the account into the underlying account components.

pub fn apply_delta(&mut self, delta: &AccountDelta) -> Result<(), AccountError>

Applies the provided delta to this account. This updates account vault, storage, and nonce to the values specified by the delta.

Errors

Returns an error if:

• AccountDelta::is_full_state returns true, i.e. represents the state of an entire account. Only partial state deltas can be applied to an account.
• Applying vault sub-delta to the vault of this account fails.
• Applying storage sub-delta to the storage of this account fails.
• The nonce specified in the provided delta smaller than or equal to the current account nonce.

pub fn increment_nonce(&mut self, nonce_delta: Felt) -> Result<(), AccountError>

Increments the nonce of this account by the provided increment.

Errors

Returns an error if:

• Incrementing the nonce overflows a Felt.

Trait Implementations

impl Clone for Account

fn clone(&self) -> Account

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Account

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

Formats the value using the given formatter.

impl Deserializable for Account

fn read_from<R: ByteReader>( source: &mut R, ) -> Result<Self, DeserializationError>

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

impl From<&Account> for AccountHeader

fn from(account: &Account) -> Self

Converts to this type from the input type.

impl From<&Account> for PartialAccount

fn from(account: &Account) -> Self

Constructs a PartialAccount from the provided account.

The behavior is different whether the Account::is_new or not:

• For new accounts, the storage is tracked in full. This is because transactions that create accounts need the full state.
• For existing accounts, the storage is tracked minimally, i.e. the minimal necessary data is included.

Because new accounts always have empty vaults, in both cases, the asset vault is a minimal representation.

For precise control over how an account is converted to a partial account, use PartialAccount::new.

impl From<Account> for AccountHeader

fn from(account: Account) -> Self

Converts to this type from the input type.

impl PartialEq for Account

fn eq(&self, other: &Account) -> 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 Serializable for Account

fn write_into<W: ByteWriter>(&self, target: &mut W)

Serializes self into bytes and writes these bytes into the target.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

impl TryFrom<&AccountDelta> for Account

fn try_from(delta: &AccountDelta) -> Result<Self, Self::Error>

Converts an AccountDelta into an Account.

Conceptually, this applies the delta onto an empty account.

Errors

Returns an error if:

• If the delta is not a full state delta. See AccountDelta for details.
• If any vault delta operation removes an asset.
• If any vault delta operation adds an asset that would overflow the maximum representable amount.
• If any storage delta update violates account storage constraints.

type Error = AccountError

The type returned in the event of a conversion error.

impl TryFrom<Account> for AccountDelta

fn try_from(account: Account) -> Result<Self, Self::Error>

Converts an Account into an AccountDelta.

Errors

Returns an error if:

• the account has a seed. Accounts with seeds have a nonce of 0. Representing such accounts as deltas is not possible because deltas with a non-empty state change need a nonce_delta greater than 0.

type Error = AccountError

The type returned in the event of a conversion error.

impl Eq for Account

impl StructuralPartialEq for Account