Struct Account 

pub struct Account {
    pub spores: u64,
    pub spendable: u64,
    pub staked: u64,
    pub locked: u64,
    pub data: Vec<u8>,
    pub public_key: Option<PqPublicKey>,
    pub owner: Pubkey,
    pub executable: bool,
    pub rent_epoch: u64,
    pub dormant: bool,
    pub missed_rent_epochs: u64,
}

Account structure with balance separation

Fields

spores: u64

Total balance in spores (1 LICN = 1_000_000_000 spores) Total = spendable + staked + locked

spendable: u64

Spendable balance (available for transfers)

staked: u64

Staked balance (locked in validator staking)

locked: u64

Locked balance (locked in contracts, escrow, multisig)

data: Vec<u8>

Arbitrary data storage

public_key: Option<PqPublicKey>

Optional cache of the first PQ public key observed for this account.

owner: Pubkey

Program that owns this account

executable: bool

Is this account an executable program?

rent_epoch: u64

Last epoch when rent was assessed

dormant: bool

Whether this account is dormant (excluded from active state root)

missed_rent_epochs: u64

Consecutive epochs where rent could not be fully paid

Implementations

impl Account

pub fn fixup_legacy(&mut self)

M11 fix: repair legacy accounts where spendable/staked/locked are all 0 but spores > 0. This happens when deserializing accounts created before the balance separation fields existed.

pub const fn licn_to_spores(licn: u64) -> u64

Convert LICN to spores

pub const fn spores_to_licn(spores: u64) -> u64

Convert spores to LICN (integer division — truncates fractional LICN). AUDIT-FIX 3.2: Callers needing rounding should use (spores + 999_999_999) / 1_000_000_000 for round-up.

pub fn new(licn: u64, owner: Pubkey) -> Account

Create a new account with LICN balance (all spendable)

pub fn stake(&mut self, amount: u64) -> Result<(), String>

Stake some balance (moves from spendable to staked) T3.3 fix: spores total is unchanged (just a reclassification) AUDIT-FIX 1.1a: checked arithmetic, compute-before-mutate

pub fn unstake(&mut self, amount: u64) -> Result<(), String>

Unstake balance (moves from staked to spendable) AUDIT-FIX 1.1b: checked arithmetic, compute-before-mutate

pub fn lock(&mut self, amount: u64) -> Result<(), String>

Lock balance (moves from spendable to locked) AUDIT-FIX 1.1c: checked arithmetic, compute-before-mutate

pub fn unlock(&mut self, amount: u64) -> Result<(), String>

Unlock balance (moves from locked to spendable) AUDIT-FIX 1.1d: checked arithmetic, compute-before-mutate

pub fn add_spendable(&mut self, amount: u64) -> Result<(), String>

Add to spendable balance (for rewards, transfers)

pub fn deduct_spendable(&mut self, amount: u64) -> Result<(), String>

Deduct from spendable balance (for transfers, fees) AUDIT-FIX 1.1e: checked arithmetic, compute-before-mutate

pub fn deduct_locked(&mut self, amount: u64) -> Result<(), String>

Deduct from locked balance (burns/removes locked collateral)

pub fn balance_licn(&self) -> u64

Get balance in LICN

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<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Account

fn deserialize<__D>( __deserializer: __D, ) -> Result<Account, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Account

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

where __S: Serializer,

Serialize this value into the given Serde serializer.