Struct Account 

pub struct Account {
    pub public_key: CompressedPubKey,
    pub token_id: TokenId,
    pub token_symbol: TokenSymbol,
    pub balance: Balance,
    pub nonce: Nonce,
    pub receipt_chain_hash: ReceiptChainHash,
    pub delegate: Option<CompressedPubKey>,
    pub voting_for: VotingFor,
    pub timing: Timing,
    pub permissions: Permissions<AuthRequired>,
    pub zkapp: Option<Box<ZkAppAccount>>,
}

Represents a Mina account stored in the ledger.

An account is the fundamental unit of state in the Mina ledger. Each account is uniquely identified by a public key and token ID pair, and contains the account’s balance, transaction nonce, and various protocol metadata.

Accounts can be regular user accounts holding the native Mina token, or more complex entities such as custom token accounts or zkApp accounts with programmable smart contract functionality.

The account structure is designed to support:

• Token transfers and balance tracking
• Stake delegation for consensus participation
• Time-locked vesting schedules
• Flexible permission policies for different operations
• Zero-knowledge application state and verification

OCaml reference: src/lib/mina_base/account.ml L:201-224 Commit: fc6be4c58091c761f827c858229c2edf9519e941 Last verified: 2025-10-13

Fields

public_key: CompressedPubKey

The public key that controls this account. This is the address used to identify the account and authorize transactions.

token_id: TokenId

The token type this account holds. The default token (value 1) represents the native Mina token. Custom tokens have different values derived from their creator’s account.

token_symbol: TokenSymbol

The symbol for a custom token that this account can create or manage. Note: this describes a token ID owned by this account (i.e., a token this account can create), not the token type used by this account’s balance.

balance: Balance

The current balance of the account in the smallest unit (nanomina for the default token, or the smallest unit for custom tokens).

nonce: Nonce

The sequence number for transactions from this account. Incremented by pay_fee_impl for signed commands and by the zkApp application logic in apply when processing account updates.

receipt_chain_hash: ReceiptChainHash

A hash chain of all transaction receipts involving this account, providing a tamper-evident history. Updated by cons_signed_command_payload for signed commands and cons_zkapp_command_commitment for zkApp commands.

delegate: Option<CompressedPubKey>

The public key of the account to which this account delegates its stake for consensus. If None, the account delegates to itself (or cannot delegate if using a custom token). Delegation allows accounts to participate in consensus without running a block producer.

voting_for: VotingFor

The state hash this account is voting for in the consensus protocol. Updated through zkApp account updates in apply.

timing: Timing

The vesting schedule for this account’s funds. Either Untimed (fully liquid) or Timed with parameters defining when and how tokens unlock over time. Updated by pay_fee_impl for signed commands and through zkApp account updates in apply.

permissions: Permissions<AuthRequired>

The permissions controlling what operations can be performed on this account and what authorization is required (none, signature, proof, or both). Updated through zkApp account updates in apply.

zkapp: Option<Box<ZkAppAccount>>

zkApp-specific account data. If Some, this account is a zkApp (zero-knowledge application) with additional state including app state fields, a verification key, action state, and other zkApp metadata. Regular accounts have None. Managed through AccountInterface::make_zkapp and AccountInterface::unmake_zkapp.

Implementations

impl Account

pub fn create_with(account_id: AccountId, balance: Balance) -> Self

pub fn delegate_or_empty(&self) -> MyCow<'_, CompressedPubKey>

pub fn zkapp_or_empty(&self) -> MyCow<'_, Box<ZkAppAccount>>

pub fn initialize(account_id: &AccountId) -> Self

pub fn deserialize(bytes: &[u8]) -> Self

pub fn serialize(&self) -> Vec<u8>

pub fn empty() -> Self

pub fn id(&self) -> AccountId

pub fn has_locked_tokens(&self, global_slot: Slot) -> bool

pub fn has_locked_tokens_checked( &self, global_slot: &CheckedSlot<Fp>, w: &mut Witness<Fp>, ) -> Boolean

pub fn liquid_balance_at_slot(&self, global_slot: Slot) -> Balance

pub fn min_balance_at_slot(&self, global_slot: Slot) -> Balance

pub fn has_permission_to(&self, control: ControlTag, to: PermissionTo) -> bool

https://github.com/MinaProtocol/mina/blob/2ff0292b637684ce0372e7b8e23ec85404dc5091/src/lib/mina_base/account.ml#L794

pub fn checked_has_permission_to<F: FieldWitness>( &self, consts: PermsConst, signature_verifies: Option<Boolean>, to: PermissionTo, w: &mut Witness<F>, ) -> Boolean

pub fn has_permission_to_send(&self) -> bool

true iff account has permissions set that enable them to transfer Mina (assuming the command is signed)

pub fn has_permission_to_receive(&self) -> bool

true iff account has permissions set that enable them to receive Mina

pub fn has_permission_to_set_delegate(&self) -> bool

true iff account has permissions set that enable them to set their delegate (assuming the command is signed)

pub fn has_permission_to_increment_nonce(&self) -> bool

true iff account has permissions set that enable them to increment their nonce (assuming the command is signed)

pub fn hash(&self) -> Fp

pub fn checked_hash(&self, w: &mut Witness<Fp>) -> Fp

pub fn rand() -> Self

Trait Implementations

impl AccountInterface for Account

type W = ()

type Bool = bool

type Balance = Balance

type GlobalSlot = Slot

type D = ()

type VerificationKeyHash = Option<Fp<MontBackend<FqConfig, 4>, 4>>

fn register_verification_key(&self, data: &Self::D, w: &mut Self::W)

fn get(&self) -> &Account

fn get_mut(&mut self) -> &mut Account

fn set_delegate(&mut self, new: CompressedPubKey)

fn zkapp(&self) -> MyCow<'_, ZkAppAccount>

fn zkapp_mut(&mut self) -> &mut ZkAppAccount

fn verification_key_hash(&self) -> Option<Fp>

fn set_token_id(&mut self, token_id: TokenId)

fn is_timed(&self) -> Self::Bool

fn balance(&self) -> Self::Balance

fn set_balance(&mut self, balance: Self::Balance)

fn check_timing( &self, txn_global_slot: &Self::GlobalSlot, w: &mut Self::W, ) -> (TimingValidation<Self::Bool>, Timing)

fn make_zkapp(&mut self)

fn unmake_zkapp(&mut self)

fn proved_state(&self) -> Self::Bool

fn set_proved_state(&mut self, proved_state: Self::Bool)

fn app_state(&self) -> [Fp; 8]

fn last_action_slot(&self) -> Self::GlobalSlot

fn set_last_action_slot(&mut self, slot: Self::GlobalSlot)

impl BinProtRead for Account

fn binprot_read<R: Read + ?Sized>(r: &mut R) -> Result<Self, Error>

where Self: Sized,

impl BinProtWrite for Account

fn binprot_write<W: Write>(&self, w: &mut W) -> Result<()>

impl<F: FieldWitness> Check<F> for Box<Account>

fn check(&self, w: &mut Witness<F>)

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<'de> Deserialize<'de> for Account

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Account> for MinaBaseAccountBinableArgStableV2

fn from(acc: &Account) -> Self

Converts to this type from the input type.

impl From<Account> for MinaBaseAccountBinableArgStableV2

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 Serialize for Account

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToFieldElements<Fp<MontBackend<FqConfig, 4>, 4>> for Box<Account>

fn to_field_elements(&self, fields: &mut Vec<Fp>)

fn to_field_elements_owned(&self) -> Vec<F>

impl ToInputs for Account

fn to_inputs(&self, inputs: &mut Inputs)

fn to_inputs_owned(&self) -> Inputs

fn hash_with_param(&self, param: &LazyParam) -> Fp

fn checked_hash_with_param(&self, param: &LazyParam, w: &mut Witness<Fp>) -> Fp

impl TryFrom<&MinaBaseAccountBinableArgStableV2> for Account

type Error = InvalidBigInt

The type returned in the event of a conversion error.

fn try_from( acc: &MinaBaseAccountBinableArgStableV2, ) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<MinaBaseAccountBinableArgStableV2> for Account

type Error = InvalidBigInt

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Eq for Account

impl StructuralPartialEq for Account