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.

Implementations

impl Account

pub fn new( seed: Word, code: AccountCode, storage: AccountStorage, ) -> Result<Self, AccountError>

Creates and returns a new Account instantiated with the specified code, storage, and account seed.

The returned account has an empty asset vault and the nonce which is initialized to ZERO.

Errors

Returns an error if deriving account ID from the specified seed fails.

pub fn from_parts( id: AccountId, vault: AssetVault, storage: AccountStorage, code: AccountCode, nonce: Felt, ) -> Self

Returns an Account instantiated with the provided components.

pub fn initialize_from_components( account_type: AccountType, components: &[AccountComponent], ) -> Result<(AccountCode, AccountStorage), AccountError>

Creates an account’s AccountCode and AccountStorage from the provided components.

This merges all libraries of the components into a single MastForest to produce the AccountCode. For each procedure in the resulting forest, the storage offset and size are set so that the procedure can only access the storage slots of the component in which it was defined and each component’s storage offset is the total number of slots in the previous components. To illustrate, given two components with one and two storage slots respectively:

• RpoFalcon512 Component: Component slot 0 stores the public key.
• Custom Component: Component slot 0 stores a custom StorageSlot::Value and component slot 1 stores a custom StorageSlot::Map.

When combined, their assigned slots in the AccountStorage would be:

• The RpoFalcon512 Component has offset 0 and size 1: Account slot 0 stores the public key.
• The Custom Component has offset 1 and size 2: Account slot 1 stores the value and account slot 2 stores the map.

The resulting commitments from code and storage can then be used to construct an AccountId. Finally, a new account can then be instantiated from those parts using Account::new.

If the account type is faucet the reserved slot (slot 0) will be initialized.

• For Fungible Faucets the value is StorageSlot::empty_value.
• For Non-Fungible Faucets the value is StorageSlot::empty_map.

If the storage needs to be initialized with certain values in that slot, those can be added after construction with the standard set methods for items and maps.

Errors

Returns an error if:

• Any of the components does not support account_type.
• The number of procedures in all merged libraries is 0 or exceeds AccountCode::MAX_NUM_PROCEDURES.
• Two or more libraries export a procedure with the same MAST root.
• The number of StorageSlots of all components exceeds 255.
• MastForest::merge fails on all libraries.

pub fn builder() -> AccountBuilder

Returns a new AccountBuilder. See its documentation for details.

pub fn hash(&self) -> Digest

Returns hash of this account.

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

pub fn init_hash(&self) -> Digest

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

For existing accounts, this is exactly the same as Account::hash(), 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 hash 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 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 is_public(&self) -> bool

Returns true if this account is public.

pub fn is_new(&self) -> bool

Returns true if the account is new (i.e. it has not been initialized yet).

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:

• 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 set_nonce(&mut self, nonce: Felt) -> Result<(), AccountError>

Sets the nonce of this account to the specified nonce value.

Errors

Returns an error if:

• The new nonce is smaller than the actual account nonce
• The new nonce is equal to the actual account nonce

Trait Implementations

impl Clone for Account

fn clone(&self) -> Account

Returns a copy 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 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 Eq for Account

impl StructuralPartialEq for Account