Struct Refinery 

#[repr(C)]
pub struct Refinery {

    pub total_network_mining_power: u64,
    pub emission_per_block: u64,
    pub last_emission_update_block: u64,
    pub rig_supplies: [u64; 15],
    pub rig_current: [u64; 15],
    pub rig_configs: [RigConfig; 15],
    pub admin: Pubkey,
    pub refinery_rewards_factor: Numeric,
    pub last_rewards_factor_block: u64,
    pub init_timestamp: i64,
    pub last_emission_update_timestamp: i64,
    pub reserved_a: u64,
    pub reserved_b: u64,
    pub buffer_a: u64,
    pub buffer_b: u64,
    pub buffer_c: u64,
    pub buffer_d: u64,
}

Refinery global state (singleton account)

Fields

total_network_mining_power: u64

Sum of all players’ Mining Power

emission_per_block: u64

Current emission rate per block (in atomic units with 11 decimals)

last_emission_update_block: u64

Block when emission rate was last updated (tracks initialization time for day calculation)

rig_supplies: [u64; 15]

Max supply per rig type (u64::MAX = unlimited, otherwise the max supply)

rig_current: [u64; 15]

Current supply per rig type (number minted)

rig_configs: [RigConfig; 15]

Stats configuration for each rig type (0-14)

admin: Pubkey

Admin authority that can update rig_configs

refinery_rewards_factor: Numeric

Cumulative reward per unit of mining power (updated when advancing emission; used for claim math)

last_rewards_factor_block: u64

Block through which refinery_rewards_factor has been applied (for lazy updates)

init_timestamp: i64

Init timestamp (unix seconds) for emission schedule; set once in initialize.

last_emission_update_timestamp: i64

Last emission rate update timestamp (unix seconds); used for 24h decay and day calculation.

reserved_a: u64

Reserved for future use (do not use for new features; add new named fields or more buffers).

reserved_b: u64

Reserved for future use.

buffer_a: u64

Buffer for future extensions.

buffer_b: u64

Buffer for future extensions.

buffer_c: u64

Buffer for future extensions.

buffer_d: u64

Buffer for future extensions.

Implementations

impl Refinery

pub fn pda() -> (Pubkey, u8)

pub fn initialize( &mut self, admin: Pubkey, clock: &Clock, initial_emission: u64, )

pub fn update_emission_rate(&mut self, clock: &Clock, _blocks_per_day: u64)

Update emission rate based on days elapsed (timestamp-based; robust to block rate drift). Uses Clock::unix_timestamp and init_timestamp / last_emission_update_timestamp.

pub fn can_mint_rig(&self, rig_type: u64) -> bool

Check if rig can be minted (supply limit check)

pub fn increment_rig_supply(&mut self, rig_type: u64)

Increment rig supply after minting

pub fn update_mining_power(&mut self, mining_power_change: i64)

Update mining power when rig is placed/removed

pub fn advance_rewards_factor(&mut self, clock: &Clock)

Advance refinery_rewards_factor up to current block (call before claim or when reading claimable). Claimable for a plot = plot.total_mining_power * (refinery.rewards_factor - plot.last_refinery_rewards_factor).

impl Refinery

pub fn to_bytes(&self) -> &[u8]

Trait Implementations

impl AccountValidation for Refinery

fn assert<F>(&self, condition: F) -> Result<&Self, ProgramError>

where F: Fn(&Self) -> bool,

fn assert_err<F>( &self, condition: F, err: ProgramError, ) -> Result<&Self, ProgramError>

where F: Fn(&Self) -> bool,

fn assert_msg<F>(&self, condition: F, msg: &str) -> Result<&Self, ProgramError>

where F: Fn(&Self) -> bool,

fn assert_mut<F>(&mut self, condition: F) -> Result<&mut Self, ProgramError>

where F: Fn(&Self) -> bool,

fn assert_mut_err<F>( &mut self, condition: F, err: ProgramError, ) -> Result<&mut Self, ProgramError>

where F: Fn(&Self) -> bool,

fn assert_mut_msg<F>( &mut self, condition: F, msg: &str, ) -> Result<&mut Self, ProgramError>

where F: Fn(&Self) -> bool,

impl Clone for Refinery

fn clone(&self) -> Refinery

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Refinery

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Refinery

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Discriminator for Refinery

fn discriminator() -> u8

impl PartialEq for Refinery

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Zeroable for Refinery

fn zeroed() -> Self

Calls zeroed.

impl Copy for Refinery

impl Pod for Refinery

impl StructuralPartialEq for Refinery