oil-api 0.7.8

use steel::*;
use bytemuck;

#[repr(u8)]
#[derive(Clone, Copy, Debug, Eq, PartialEq, TryFromPrimitive)]
pub enum OilInstruction {
    // Miner
    Automate = 0,
    AutomateWithSession = 40,
    Initialize = 1,
    Checkpoint = 2,
    CheckpointWithSession = 52,
    ClaimSOL = 3,
    ClaimSOLWithSession = 44,
    ClaimOIL = 4,
    ClaimOILWithSession = 45,
    Close = 5,
    Deploy = 6,
    DeployWithSession = 39,
    Log = 8,
    Reset = 9,
    ReloadSOL = 22,
    CreateReferral = 27,
    CreateReferralWithSession = 49,
    ClaimReferral = 28,
    ClaimReferralWithSession = 50,

    // Auction-based mining
    PlaceBid = 29,
    PlaceBidWithSession = 41,
    ClaimAuctionOIL = 31,
    ClaimAuctionOILWithSession = 42,
    ClaimAuctionSOL = 32,
    ClaimAuctionSOLWithSession = 43,
    Contribute = 53,
    ContributeWithSession = 54,
    CheckpointAuction = 55,
    CheckpointAuctionWithSession = 56,

    // Refinery system
    InitializeRefinery = 57,
    PurchasePlot = 58,
    UpgradePlot = 59,
    PurchaseRig = 60,
    PlaceRig = 61,
    RemoveRig = 62,
    ClaimRefineryRewards = 63,
    RefuelPlot = 64,
    SetRigConfig = 65,
    PurchasePlotWithSession = 66,
    UpgradePlotWithSession = 67,
    PurchaseRigWithSession = 68,
    PlaceRigWithSession = 69,
    RemoveRigWithSession = 70,
    RefuelPlotWithSession = 71,
    ClaimRefineryRewardsWithSession = 72,
    InitOilOracle = 73,
    SetOilOraclePrice = 74,
    SetOracleAuthority = 75,
    InitCollection = 76,

    // Staker
    Deposit = 10,
    DepositWithSession = 48,
    Withdraw = 11,
    WithdrawWithSession = 47,
    ClaimYield = 12,
    ClaimYieldWithSession = 51,

    // Admin
    Buyback = 13,
    Wrap = 14,
    SetAdmin = 16,
    SetFeeCollector = 17,
    SetSwapProgram = 18,
    SetVarAddress = 19,
    NewVar = 20,
    SetAdminFee = 21,
    Migrate = 26,
    SetAuction = 33,
    CreateWhitelist = 34,
    SetTgeTimestamp = 35,
    Liq = 37,
    Barrel = 38,
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Automate {
    pub amount: [u8; 8],
    pub deposit: [u8; 8],
    pub fee: [u8; 8],
    pub mask: [u8; 8],
    pub strategy: u8,
    pub reload: [u8; 8],
    /// Optional referrer pubkey for new miners. Set to Pubkey::default() for no referrer.
    pub referrer: [u8; 32],
    /// Whether automated deployments should be pooled (1 = pooled, 0 = not pooled).
    pub pooled: u8,
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct ClaimSOL {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct ClaimOIL {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Deploy {
    pub amount: [u8; 8],
    pub squares: [u8; 4],
    /// Optional referrer pubkey. Set to Pubkey::default() for no referrer.
    pub referrer: [u8; 32],
    /// Whether this deploy is pooled. 0 = solo, 1 = pooled.
    pub pooled: u8,
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Log {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Reset {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Close {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct SetAdmin {
    pub admin: [u8; 32],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct SetFeeCollector {
    pub fee_collector: [u8; 32],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Buyback {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Liq {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Barrel {
    pub amount: [u8; 8],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Wrap {
    /// 0 = use balance, 1 = use liquidity
    pub use_liquidity: u8,
    pub amount: [u8; 8],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct ReloadSOL {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Deposit {
    pub amount: [u8; 8],
    pub lock_duration_days: [u8; 8],  // 0 = no lock, 1-730 days
    pub stake_id: [u8; 8],  // Unique ID for this stake account (allows multiple stakes per user)
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Withdraw {
    pub amount: [u8; 8],
    pub stake_id: [u8; 8],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct ClaimYield {
    pub amount: [u8; 8],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Checkpoint {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct NewVar {
    pub id: [u8; 8],
    pub commit: [u8; 32],
    pub samples: [u8; 8],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct SetAdminFee {
    pub admin_fee: [u8; 8],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct SetSwapProgram {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct SetVarAddress {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Migrate {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct CreateReferral {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct ClaimReferral {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct CreateWhitelist {
    /// The code hash (first 32 bytes of keccak256 hash of the code string)
    pub code_hash: [u8; 32],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct SetTgeTimestamp {
    /// Unix timestamp for Token Generation Event (TGE).
    /// If current time < tge_timestamp, pre-mine is active.
    /// Set to 0 to disable pre-mine.
    pub tge_timestamp: [u8; 8],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Initialize {
    pub barrel_authority: [u8; 32],
    pub fee_collector: [u8; 32],
    pub swap_program: [u8; 32],
    pub var_address: [u8; 32],
    pub admin_fee: [u8; 8],
    // Auction configuration (optional - only used if auction accounts need initialization)
    pub halving_period_seconds: [u8; 8],
    pub base_mining_rates: [[u8; 8]; 4],  // 4 wells
    pub auction_duration_seconds: [u8; 8],
    pub starting_prices: [[u8; 8]; 4],  // 4 wells
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct PlaceBid {
    pub square_id: [u8; 8],
    /// Optional referrer pubkey for new miners. Set to Pubkey::default() for no referrer.
    pub referrer: [u8; 32],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct ClaimAuctionOIL {
    /// Well IDs to claim OIL from (0-3), can claim multiple at once
    /// Bitmask: bit 0 = well 0, bit 1 = well 1, etc.
    pub well_mask: u8,
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct ClaimAuctionSOL {
    /// Reserved for future use (currently unused, but kept for consistency)
    pub _reserved: u8,
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct SetAuction {
    pub halving_period_seconds: [u8; 8],
    pub last_halving_time: [u8; 8],
    pub base_mining_rates: [[u8; 8]; 4],  // 4 wells
    pub auction_duration_seconds: [u8; 8],
    pub starting_prices: [[u8; 8]; 4],  // 4 wells
    pub well_id: [u8; 8],  // Well ID to update (0-3). If >= 4, only updates auction account.
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Contribute {
    /// Well ID to contribute to (0-3)
    pub well_id: [u8; 8],
    /// Amount to contribute (in lamports) - treated as maximum, may be less if pool becomes eligible
    pub amount: [u8; 8],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct CheckpointAuction {
    /// Well mask: bit 0 = well 0, bit 1 = well 1, bit 2 = well 2, bit 3 = well 3
    /// Allows checkpointing multiple wells in a single instruction
    pub well_mask: u8,
    /// Epoch IDs for each well (0-3), in order
    /// If well_mask bit is set, corresponding epoch_id must be provided
    /// If well_mask bit is not set, epoch_id is ignored
    pub epoch_ids: [[u8; 8]; 4],
}

instruction!(OilInstruction, Automate);
instruction!(OilInstruction, Initialize);
instruction!(OilInstruction, Checkpoint);
instruction!(OilInstruction, ClaimSOL);
instruction!(OilInstruction, ClaimOIL);
instruction!(OilInstruction, ReloadSOL);
instruction!(OilInstruction, Deploy);
instruction!(OilInstruction, Log);
instruction!(OilInstruction, Buyback);
instruction!(OilInstruction, Wrap);
instruction!(OilInstruction, Reset);
instruction!(OilInstruction, Close);
instruction!(OilInstruction, SetAdmin);
instruction!(OilInstruction, SetFeeCollector);
instruction!(OilInstruction, Deposit);
instruction!(OilInstruction, Withdraw);
instruction!(OilInstruction, ClaimYield);
instruction!(OilInstruction, NewVar);
instruction!(OilInstruction, SetAdminFee);
instruction!(OilInstruction, SetSwapProgram);
instruction!(OilInstruction, SetVarAddress);
instruction!(OilInstruction, Migrate);
instruction!(OilInstruction, CreateReferral);
instruction!(OilInstruction, ClaimReferral);
instruction!(OilInstruction, PlaceBid);
instruction!(OilInstruction, ClaimAuctionOIL);
instruction!(OilInstruction, ClaimAuctionSOL);
instruction!(OilInstruction, SetAuction);
instruction!(OilInstruction, CreateWhitelist);
instruction!(OilInstruction, SetTgeTimestamp);
instruction!(OilInstruction, Liq);
instruction!(OilInstruction, Barrel);
instruction!(OilInstruction, Contribute);
instruction!(OilInstruction, CheckpointAuction);

// Refinery system instruction structs
#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct InitializeRefinery {
    /// Initial emission per block in atomic units (11 decimals)
    pub initial_emission: [u8; 8],
    /// Mining power for each rig type (0-14), 15 values
    pub mining_powers: [[u8; 8]; 15],
    /// Fuel requirement for each rig type (0-14), 15 values
    pub fuel_requirements: [[u8; 8]; 15],
    /// Fuel consumption rate for each rig type (0-14) in atomic units (11 decimals), 15 values
    pub fuel_consumption_rates: [[u8; 8]; 15],
    /// Max supply for each rig type (0-14), u64::MAX = unlimited, 15 values
    pub rig_supplies: [[u8; 8]; 15],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct PurchasePlot {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct UpgradePlot {
    pub plot_level: [u8; 8],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct PurchaseRig {
    pub rig_type: [u8; 8],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct PlaceRig {
    pub rig_mint: [u8; 32],
    pub slot: [u8; 8],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct RemoveRig {
    pub rig_mint: [u8; 32],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct ClaimRefineryRewards {
    /// Claim fee in lamports (35% of claim value in SOL/FOGO). Client computes from OIL price (e.g. Valiant API) and FOGO price.
    pub fee_lamports: [u8; 8],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct RefuelPlot {}

#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct SetRigConfig {
    pub rig_type: [u8; 8],
    pub mining_power: [u8; 8],
    pub fuel_requirement: [u8; 8],
    pub fuel_consumption_rate: [u8; 8],
}

/// Init OIL price oracle (one-time; payer creates account, sets oracle_authority).
#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct InitOilOracle {
    /// Authority that may call SetOilOraclePrice (32 bytes).
    pub oracle_authority: [u8; 32],
}

/// Set OIL price (Valiant-backed; only oracle_authority).
#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct SetOilOraclePrice {
    pub price: [u8; 8],
    pub expo: [u8; 4],
    pub conf: [u8; 8],
    pub ema: [u8; 8],
    pub publish_time: [u8; 8],
}

/// Set oracle authority (only current oracle_authority).
#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct SetOracleAuthority {
    /// New authority allowed to call SetOilOraclePrice (32 bytes).
    pub new_oracle_authority: [u8; 32],
}

instruction!(OilInstruction, InitializeRefinery);
instruction!(OilInstruction, PurchasePlot);
instruction!(OilInstruction, UpgradePlot);
instruction!(OilInstruction, PurchaseRig);
instruction!(OilInstruction, PlaceRig);
instruction!(OilInstruction, RemoveRig);
instruction!(OilInstruction, ClaimRefineryRewards);
instruction!(OilInstruction, RefuelPlot);
instruction!(OilInstruction, SetRigConfig);
instruction!(OilInstruction, InitOilOracle);
instruction!(OilInstruction, SetOilOraclePrice);
instruction!(OilInstruction, SetOracleAuthority);

/// Init OIL rig collection NFT (one-time, admin only). Creates collection NFT for verified rig metadata.
#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct InitCollection {}

instruction!(OilInstruction, InitCollection);