oil_api/state/

well.rs

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

use crate::state::well_pda;

use super::{OilAccount, Auction};

/// Well account (one per well)
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable, Serialize, Deserialize)]
pub struct Well {
    /// Well ID (0-3) - which well this is for
    pub well_id: u64,
    
    /// Current epoch ID (increments each auction: 0, 1, 2, 3, etc.)
    pub epoch_id: u64,
    
    /// Current bidder/owner (Pubkey::default() if unowned)
    pub current_bidder: Pubkey,
    
    /// Initial price for current epoch (in lamports)
    pub init_price: u64,
    
    /// Mining per second (MPS) - current mining rate (OIL per second, in atomic units)
    pub mps: u64,
    
    /// Epoch start time (timestamp when current epoch started)
    pub epoch_start_time: u64,
    
    /// Accumulated OIL mined by current owner (not yet claimed)
    pub accumulated_oil: u64,
    
    /// Last time accumulated_oil was updated
    pub last_update_time: u64,
    
    /// Number of halvings that have occurred (for rate calculation)
    pub halving_count: u64,
    
    /// Total OIL ever mined from this well (lifetime)
    pub lifetime_oil_mined: u64,
    
    /// Total OIL mined by current operator (doesn't reset when claimed, only when ownership changes)
    pub operator_total_oil_mined: u64,
    
    /// Buffer field (for future use) - previously is_pool_owned
    pub buffer_c: u64,
    
    /// Total contributed FOGO for current epoch (tracks native SOL balance in Well PDA's system account)
    /// Incremented on each contribution, decremented when pool bids
    /// Reset to 0 when epoch ends
    pub total_contributed: u64,
    
    /// Pool bid cost - stores the bid_amount when pool bids
    /// Used to calculate original_total when pool gets outbid
    /// Reset to 0 when epoch ends
    pub pool_bid_cost: u64,
}

impl Well {
    pub fn pda(well_id: u64) -> (Pubkey, u8) {
        well_pda(well_id)
    }

    pub fn current_price(&self, auction: &Auction, clock: &Clock) -> u64 {
        use crate::consts::AUCTION_FLOOR_PRICE;
        
        // If well has no owner (never been bid on), show starting price
        use solana_program::pubkey::Pubkey;
        if self.current_bidder == Pubkey::default() {
            return self.init_price; // Return starting price for unowned wells
        }
        
        let elapsed = clock.unix_timestamp.saturating_sub(self.epoch_start_time as i64);
        let duration = auction.auction_duration_seconds as i64;
        
        if elapsed >= duration {
            return AUCTION_FLOOR_PRICE; // Auction expired, price is at floor
        }
        
        // Linear decay: price = floor + (init_price - floor) * (remaining / duration)
        let remaining = duration - elapsed;
        let price_range = self.init_price.saturating_sub(AUCTION_FLOOR_PRICE);
        let decayed_amount = (price_range as u128 * remaining as u128 / duration as u128) as u64;
        AUCTION_FLOOR_PRICE + decayed_amount
    }

    pub fn update_accumulated_oil(&mut self, auction: &Auction, clock: &Clock) {
        // Skip if no owner
        use solana_program::pubkey::Pubkey;
        if self.current_bidder == Pubkey::default() {
            return;
        }
        
        let last_update = self.last_update_time as i64;
        let current_time = clock.unix_timestamp as u64;
        let elapsed = clock.unix_timestamp.saturating_sub(last_update);
        if elapsed <= 0 {
            return;
        }
        
        // Calculate OIL mined, accounting for halvings that occurred during the elapsed period
        let oil_mined = if auction.halving_count == 0 {
            // No halvings yet - check if first halving occurred during this period
            let first_halving_time = auction.last_halving_time + Auction::FIRST_HALVING_PERIOD_SECONDS;
            if current_time >= first_halving_time && (last_update as u64) < first_halving_time {
                // First halving occurred during this period - calculate in segments
                let time_before_halving = first_halving_time.saturating_sub(last_update as u64);
                let time_after_halving = current_time.saturating_sub(first_halving_time);
                let rate_before = self.mps;
                let rate_after = self.mps / 2; // 50% reduction
                rate_before.checked_mul(time_before_halving).unwrap_or(0)
                    .checked_add(rate_after.checked_mul(time_after_halving).unwrap_or(0))
                    .unwrap_or(u64::MAX)
            } else {
                // No halving during this period - use current rate
                self.mps.checked_mul(elapsed as u64).unwrap_or(0)
            }
        } else {
            // Halvings have occurred - check if more occurred during this period
            let next_halving_time = auction.last_halving_time + auction.halving_period_seconds;
            if current_time >= next_halving_time && (last_update as u64) < next_halving_time {
                // One or more halvings occurred during this period
                let mut total_oil = 0u64;
                let mut segment_start = last_update as u64;
                let mut current_rate = self.mps;
                let mut last_halving = auction.last_halving_time;
                
                // Calculate segments for each halving that occurred
                while segment_start < current_time {
                    let next_halving = last_halving + auction.halving_period_seconds;
                    if next_halving > current_time {
                        // No more halvings - calculate remaining time
                        let remaining_time = current_time.saturating_sub(segment_start);
                        total_oil = total_oil.checked_add(
                            current_rate.checked_mul(remaining_time).unwrap_or(0)
                        ).unwrap_or(u64::MAX);
                        break;
                    } else {
                        // Halving occurred - calculate segment before halving
                        let segment_time = next_halving.saturating_sub(segment_start);
                        total_oil = total_oil.checked_add(
                            current_rate.checked_mul(segment_time).unwrap_or(0)
                        ).unwrap_or(u64::MAX);
                        // Apply 25% reduction for next segment
                        current_rate = (current_rate * 3) / 4;
                        segment_start = next_halving;
                        last_halving = next_halving;
                    }
                }
                total_oil
            } else {
                // No halving during this period - use current rate
                self.mps.checked_mul(elapsed as u64).unwrap_or(0)
            }
        };
        
        self.accumulated_oil = self.accumulated_oil
            .checked_add(oil_mined)
            .unwrap_or(u64::MAX);
        
        self.lifetime_oil_mined = self.lifetime_oil_mined
            .checked_add(oil_mined)
            .unwrap_or(u64::MAX);
        
        // Track total mined by current operator (persists even after claiming)
        self.operator_total_oil_mined = self.operator_total_oil_mined
            .checked_add(oil_mined)
            .unwrap_or(u64::MAX);
        
        self.last_update_time = current_time;
    }

    pub fn check_and_apply_halving(&mut self, auction: &mut Auction, clock: &Clock) {
        // Check if we should apply halvings based on current time
        let current_time = clock.unix_timestamp as u64;
        let (halvings_to_apply, is_first_halving) = auction.should_apply_halving(current_time);
        
        if halvings_to_apply > 0 {
            if is_first_halving {
                // First halving: 50% reduction
                self.mps = self.mps / 2; // 50% reduction
                self.halving_count += 1;
                auction.halving_count += 1;
                auction.last_halving_time = current_time;
            } else {
                // Subsequent halvings: 25% reduction each (multiply by 0.75)
                for _ in 0..halvings_to_apply {
                    self.mps = (self.mps * 3) / 4; // 25% reduction (multiply by 0.75)
                    self.halving_count += 1;
                    auction.halving_count += 1;
                }
                // Update auction last_halving_time to current time
                auction.last_halving_time = current_time;
            }
        }
    }
}

account!(OilAccount, Well);