msg.rs

// ---
// tags: cw-cyber, rust
// crystal-type: source
// crystal-domain: cyber
// ---
use cosmwasm_schema::{cw_serde, QueryResponses};
use cosmwasm_std::Uint128;

#[cw_serde]
pub struct InstantiateMsg {
    /// Maximum proof age in seconds.
    pub max_proof_age: u64,
    /// Estimated gas cost in uboot.
    pub estimated_gas_cost_uboot: Option<Uint128>,
    /// litium-core contract address.
    pub core_contract: String,
    /// litium-stake contract address.
    pub stake_contract: String,
    /// litium-refer contract address.
    pub refer_contract: String,
    /// litium-core CW-20 contract address (token contract).
    pub token_contract: String,
    /// Admin address (defaults to sender).
    pub admin: Option<String>,
    /// Sliding window size N (default: 5000).
    pub window_size: Option<u32>,
    /// PID update interval K (default: 100).
    pub pid_interval: Option<u64>,
    /// Genesis time override (unix seconds). Defaults to 1772619159.
    pub genesis_time: Option<u64>,
    /// Fixed base_rate during warmup (first N proofs).
    pub warmup_base_rate: Uint128,
    /// Seconds per fee bucket (default: 600).
    pub fee_bucket_duration: Option<u64>,
    /// Number of fee buckets in ring buffer (default: 36).
    pub fee_num_buckets: Option<u32>,
}

#[cw_serde]
pub enum ExecuteMsg {
    /// Submit a proof with client-chosen difficulty.
    SubmitProof {
        hash: String,
        nonce: u64,
        miner_address: String,
        challenge: String,
        difficulty: u32,
        timestamp: u64,
        referrer: Option<String>,
    },
    /// Accrue transfer fees from litium-core (called by core contract only).
    AccrueFees {
        amount: Uint128,
    },
    /// Update config. Admin only.
    UpdateConfig {
        max_proof_age: Option<u64>,
        admin: Option<String>,
        estimated_gas_cost_uboot: Option<Uint128>,
        core_contract: Option<String>,
        stake_contract: Option<String>,
        refer_contract: Option<String>,
        warmup_base_rate: Option<Uint128>,
        pid_interval: Option<u64>,
        genesis_time: Option<u64>,
    },
    /// Testing helper: mutate critical runtime state in-place (admin only).
    ApplyTestingOverrides {
        overrides: TestingOverrides,
    },
    /// Full state reset for daily testing (admin only).
    /// Zeroes stats, window, PID, fees, miner stats, proof hashes.
    /// Optionally sets a new genesis_time (defaults to current block time).
    ResetState {
        genesis_time: Option<u64>,
    },
    Pause {},
    Unpause {},
}

#[cw_serde]
pub struct TestingOverrides {
    pub max_proof_age: Option<u64>,
    pub stats_total_proofs: Option<u64>,
    pub stats_total_rewards: Option<Uint128>,
    pub window_count: Option<u64>,
    pub window_total_d: Option<u64>,
    pub pid_alpha: Option<u64>,
    pub pid_beta: Option<u64>,
    pub override_windowed_fees: Option<Uint128>,
}

#[cw_serde]
#[derive(QueryResponses)]
pub enum QueryMsg {
    #[returns(ConfigResponse)]
    Config {},
    #[returns(WindowStatusResponse)]
    WindowStatus {},
    #[returns(StatsResponse)]
    Stats {},
    #[returns(MinerStatsResponse)]
    MinerStats { address: String },
    #[returns(RewardCalculationResponse)]
    CalculateReward { difficulty_bits: u32 },
    #[returns(EmissionInfoResponse)]
    EmissionInfo {},
}

#[cw_serde]
pub struct ConfigResponse {
    pub max_proof_age: u64,
    pub estimated_gas_cost_uboot: Uint128,
    pub core_contract: String,
    pub stake_contract: String,
    pub refer_contract: String,
    pub token_contract: String,
    pub admin: String,
    pub paused: bool,
    pub window_size: u32,
    pub pid_interval: u64,
    pub genesis_time: u64,
    /// Dynamic minimum difficulty based on gas cost and base_rate (spec §8.4).
    pub min_profitable_difficulty: u32,
    /// PID alpha as micros [300_000..700_000].
    pub alpha: u64,
    /// PID beta as micros [0..900_000].
    pub beta: u64,
    pub fee_bucket_duration: u64,
    pub fee_num_buckets: u32,
    pub warmup_base_rate: Uint128,
}

#[cw_serde]
pub struct WindowStatusResponse {
    /// Total proofs ever accepted (monotonic).
    pub proof_count: u64,
    /// Current D_rate as decimal string (difficulty bits per second).
    pub window_d_rate: String,
    /// Configured window size N.
    pub window_size: u32,
    /// Current number of entries in the window buffer.
    pub window_entries: u32,
    /// Current base_rate (atomic LI per difficulty bit).
    pub base_rate: Uint128,
    /// Dynamic minimum profitable difficulty (spec §8.4).
    pub min_profitable_difficulty: u32,
    /// Current PID alpha as decimal string.
    pub alpha: String,
    /// Current PID beta as decimal string.
    pub beta: String,
}

#[cw_serde]
pub struct EmissionInfoResponse {
    /// Current PID alpha as micros.
    pub alpha: u64,
    /// Current PID beta as micros.
    pub beta: u64,
    /// Current emission rate (atomic LI per second).
    pub emission_rate: Uint128,
    /// Gross reward rate G (emission + fees*(1-beta)) per second.
    pub gross_rate: Uint128,
    /// Mining share of gross rate.
    pub mining_rate: Uint128,
    /// Staking share of gross rate.
    pub staking_rate: Uint128,
    /// Windowed fee sum (raw fees in current window).
    pub windowed_fees: Uint128,
}

#[cw_serde]
pub struct StatsResponse {
    pub total_proofs: u64,
    pub total_rewards: Uint128,
    pub unique_miners: u64,
    pub avg_difficulty: u32,
}

#[cw_serde]
pub struct MinerStatsResponse {
    pub address: String,
    pub proofs_submitted: u64,
    pub total_rewards: Uint128,
    pub last_proof_time: u64,
}

#[cw_serde]
pub struct RewardCalculationResponse {
    pub gross_reward: Uint128,
    pub estimated_gas_cost_uboot: Uint128,
    pub earns_reward: bool,
}