Struct StakeAccount 

pub struct StakeAccount {

    pub owner: Pubkey,
    pub pool: Pubkey,
    pub amount: u64,
    pub stake_time: i64,
    pub unlock_time: i64,
    pub last_reward_time: i64,
    pub pending_rewards: u64,
    pub total_rewards_claimed: u64,
    pub entropy_score: u64,
    pub coherence: u64,
    pub pool_id: u32,
    pub last_entropy_update: i64,
    pub unlock_probability: u64,
    pub coherence_bonus: u64,
}

Individual stake account tracking one user’s stake in a pool. Each staker has one account per pool they’re participating in.

Fields

owner: Pubkey

User/owner of this stake

pool: Pubkey

Pool this stake belongs to

amount: u64

Amount of tokens staked

stake_time: i64

Timestamp when the stake was created

unlock_time: i64

Timestamp when the stake can be withdrawn (after lock_duration)

last_reward_time: i64

Last timestamp when rewards were calculated

pending_rewards: u64

Rewards accumulated but not yet claimed

total_rewards_claimed: u64

Total rewards claimed from this stake

entropy_score: u64

Stake’s contribution to network entropy (1e6 scale)

coherence: u64

Device’s ability to preserve quantum coherence (1e6 scale, 0-1000000)

pool_id: u32

ID of the entanglement pool this stake belongs to (0 = not entangled)

last_entropy_update: i64

Last timestamp when entropy metrics were calculated

unlock_probability: u64

Probability of early unlock based on entropy (1e6 scale, 0-1000000)

coherence_bonus: u64

Bonus multiplier from coherence contribution (1e6 scale)

Trait Implementations

impl AccountDeserialize for StakeAccount

fn try_deserialize(buf: &mut &[u8]) -> Result<Self>

Deserializes previously initialized account data. Should fail for all uninitialized accounts, where the bytes are zeroed. Implementations should be unique to a particular account type so that one can never successfully deserialize the data of one account type into another. For example, if the SPL token program were to implement this trait, it should be impossible to deserialize a Mint account into a token Account.

fn try_deserialize_unchecked(buf: &mut &[u8]) -> Result<Self>

Deserializes account data without checking the account discriminator. This should only be used on account initialization, when the bytes of the account are zeroed.

impl AccountSerialize for StakeAccount

fn try_serialize<W: Write>(&self, writer: &mut W) -> Result<()>

Serializes the account data into writer.

impl BorshDeserialize for StakeAccount

where Pubkey: BorshDeserialize, u64: BorshDeserialize, i64: BorshDeserialize, u32: BorshDeserialize,

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for StakeAccount

where Pubkey: BorshSerialize, u64: BorshSerialize, i64: BorshSerialize, u32: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8>, Error>

Serialize this instance into a vector of bytes.

impl Clone for StakeAccount

fn clone(&self) -> StakeAccount

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Discriminator for StakeAccount

const DISCRIMINATOR: [u8; 8]

fn discriminator() -> [u8; 8]

impl Owner for StakeAccount

fn owner() -> Pubkey

impl Space for StakeAccount

const INIT_SPACE: usize