oil_api/state/

refinery.rs

use serde::{Deserialize, Serialize};
use steel::*;

use crate::state::refinery_pda;

use super::OilAccount;

/// Rig configuration (stats for each rig type)
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable, Serialize, Deserialize)]
pub struct RigConfig {
    /// Mining power for this rig type
    pub mining_power: u64,

    /// Fuel requirement for placement
    pub fuel_requirement: u64,

    /// Fuel consumption rate per block (in atomic units with 11 decimals)
    pub fuel_consumption_rate: u64,
}

/// Refinery global state (singleton account)
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable, Serialize, Deserialize)]
pub struct Refinery {
    /// Sum of all players' Mining Power
    pub total_network_mining_power: u64,

    /// Current emission rate per block (in atomic units with 11 decimals)
    pub emission_per_block: u64,

    /// Block when emission rate was last updated (tracks initialization time for day calculation)
    pub last_emission_update_block: u64,

    /// Max supply per rig type (u64::MAX = unlimited, otherwise the max supply)
    pub rig_supplies: [u64; 15],

    /// Current supply per rig type (number minted)
    pub rig_current: [u64; 15],

    /// Stats configuration for each rig type (0-14)
    pub rig_configs: [RigConfig; 15],

    /// Admin authority that can update rig_configs
    pub admin: Pubkey,

    /// Cumulative reward per unit of mining power (updated when advancing emission; used for claim math)
    pub refinery_rewards_factor: Numeric,

    /// Block through which refinery_rewards_factor has been applied (for lazy updates)
    pub last_rewards_factor_block: u64,

    /// Buffer field (for future extensions)
    pub buffer_a: u64,

    /// Buffer field (for future extensions)
    pub buffer_b: u64,
}

impl Refinery {
    pub fn pda() -> (Pubkey, u8) {
        refinery_pda()
    }

    pub fn initialize(&mut self, admin: Pubkey, clock: &Clock, initial_emission: u64) {
        self.total_network_mining_power = 0;
        self.emission_per_block = initial_emission; // In atomic units (e.g., 7,100,000,000 for 0.071 OIL/block)
        self.last_emission_update_block = clock.slot;
        self.rig_supplies = [u64::MAX; 15]; // u64::MAX = unlimited
        self.rig_current = [0; 15];
        // rig_configs should be set by caller with initial values
        self.admin = admin;
        self.refinery_rewards_factor = Numeric::ZERO;
        self.last_rewards_factor_block = clock.slot;
        self.buffer_a = 0;
        self.buffer_b = 0;
    }

    /// Update emission rate based on days elapsed (growth/decreasing phase)
    pub fn update_emission_rate(&mut self, clock: &Clock, blocks_per_day: u64) {
        let initialization_block = self.last_emission_update_block;
        let blocks_elapsed = clock.slot.saturating_sub(initialization_block);
        let days_elapsed = blocks_elapsed / blocks_per_day;

        // Growth phase (Day 1-7): Linear interpolation from 0.071 → 0.179
        if days_elapsed <= 7 {
            let start_emission = 7_100_000_000u64; // 0.071 OIL/block in atomic units
            let peak_emission = 17_900_000_000u64; // 0.179 OIL/block in atomic units
            
            if days_elapsed == 0 {
                self.emission_per_block = start_emission;
            } else if days_elapsed >= 7 {
                self.emission_per_block = peak_emission;
            } else {
                // Linear interpolation: start + (peak - start) × (days - 1) / 6
                let days_progress = (days_elapsed - 1) as u128;
                let emission_range = (peak_emission - start_emission) as u128;
                let interpolated = start_emission as u128
                    + (emission_range * days_progress) / 6;
                self.emission_per_block = interpolated as u64;
            }
            self.last_emission_update_block = clock.slot;
            return;
        }

        // Peak phase (Day 8-14): Maintain peak
        if days_elapsed <= 14 {
            self.emission_per_block = 17_900_000_000u64; // 0.179 OIL/block
            self.last_emission_update_block = clock.slot;
            return;
        }

        // Decreasing phase (Day 15+): Decrease by 2% per day
        // Check if 24 hours (in blocks) have passed since last update
        let blocks_since_update = clock.slot.saturating_sub(self.last_emission_update_block);
        let blocks_per_day = blocks_per_day;
        
        if blocks_since_update >= blocks_per_day {
            // Apply 2% reduction
            let min_emission = 3_600_000_000u64; // 0.036 OIL/block minimum
            let new_emission = (self.emission_per_block as u128 * 98) / 100; // Multiply by 0.98
            self.emission_per_block = new_emission.max(min_emission as u128) as u64;
            self.last_emission_update_block = clock.slot;
        }
    }

    /// Check if rig can be minted (supply limit check)
    pub fn can_mint_rig(&self, rig_type: u64) -> bool {
        let idx = rig_type as usize;
        if idx >= 15 {
            return false;
        }
        
        let max_supply = self.rig_supplies[idx];
        if max_supply == u64::MAX {
            true // Unlimited supply
        } else {
            self.rig_current[idx] < max_supply
        }
    }

    /// Increment rig supply after minting
    pub fn increment_rig_supply(&mut self, rig_type: u64) {
        let idx = rig_type as usize;
        if idx < 15 {
            self.rig_current[idx] = self.rig_current[idx].saturating_add(1);
        }
    }

    /// Update mining power when rig is placed/removed
    pub fn update_mining_power(&mut self, mining_power_change: i64) {
        if mining_power_change > 0 {
            self.total_network_mining_power = self.total_network_mining_power
                .saturating_add(mining_power_change as u64);
        } else {
            self.total_network_mining_power = self.total_network_mining_power
                .saturating_sub((-mining_power_change) as u64);
        }
    }

    /// 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).
    pub fn advance_rewards_factor(&mut self, clock: &Clock) {
        let blocks = clock.slot.saturating_sub(self.last_rewards_factor_block);
        if self.total_network_mining_power > 0 && blocks > 0 {
            let total_emission = self.emission_per_block.saturating_mul(blocks);
            self.refinery_rewards_factor +=
                Numeric::from_fraction(total_emission, self.total_network_mining_power);
        }
        self.last_rewards_factor_block = clock.slot;
    }
}

account!(OilAccount, Refinery);