d0zingcat/ore
1
0
Fork 0
mirror of https://github.com/d0zingcat/ore.git synced 2026-05-17 07:26:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

mine v2

Browse Source
This commit is contained in:
Hardhat Chad
2024-04-27 16:30:45 +00:00
parent 3a109e7a11
commit f4d36f9b9f
18 changed files with 1019 additions and 721 deletions
Download Patch File Download Diff File Expand all files Collapse all files

180
src/processor/mine.rs
View File

@@ -4,8 +4,7 @@ use solana_program::{
account_info::AccountInfo,
clock::Clock,
entrypoint::ProgramResult,
keccak::{hashv, Hash as KeccakHash},
program::set_return_data,
keccak::hashv,
program_error::ProgramError,
pubkey::Pubkey,
slot_hashes::SlotHash,
@@ -16,24 +15,26 @@ use crate::{
error::OreError,
instruction::MineArgs,
loaders::*,
state::{Bus, Proof, Treasury},
state::{Bus, Config, Proof},
utils::AccountDeserialize,
EPOCH_DURATION, START_AT,
DIFFICULTY_RANGE, EPOCH_DURATION,
};
// TODO Look into tx introspection to require 1 hash per tx
/// Mine is the primary workhorse instruction of the Ore program. Its responsibilities include:
/// 1. Verify the provided hash is valid.
/// 2. Increment the user's claimable rewards counter.
/// 1. Calculate the hash from the provided nonce.
/// 2. Payout rewards based on difficulty, staking multiplier, and liveness penalty.
/// 3. Generate a new challenge for the miner.
/// 4. Update the miner's lifetime stats.
///
/// Safety requirements:
/// - Mine is a permissionless instruction and can be called by any signer.
/// - Can only succeed if START_AT has passed.
/// - Can only succeed if mining is not paused.
/// - Can only succeed if the last reset was less than 60 seconds ago.
/// - Can only succeed if the provided SHA3 hash and nonce are valid and satisfy the difficulty.
/// - Can only succeed if the provided hash satisfies the minimum difficulty requirement.
/// - The the provided proof account must be associated with the signer.
/// - The provided bus, treasury, and slot hash sysvar must be valid.
/// - The provided bus, config, noise, stake, and slot hash sysvar must be valid.
pub fn process_mine<'a, 'info>(
_program_id: &Pubkey,
accounts: &'a [AccountInfo<'info>],
@@ -43,115 +44,118 @@ pub fn process_mine<'a, 'info>(
let args = MineArgs::try_from_bytes(data)?;
// Load accounts
let [signer, bus_info, proof_info, treasury_info, slot_hashes_info] = accounts else {
let [signer, bus_info, config_info, noise_info, proof_info, slot_hashes_info] = accounts else {
return Err(ProgramError::NotEnoughAccountKeys);
};
load_signer(signer)?;
load_any_bus(bus_info, true)?;
load_config(config_info, false)?;
load_noise(noise_info, false)?;
load_proof(proof_info, signer.key, true)?;
load_treasury(treasury_info, false)?;
load_sysvar(slot_hashes_info, sysvar::slot_hashes::id())?;
// Validate mining has starting
// Validate mining is allowed
let config_data = config_info.data.borrow();
let config = Config::try_from_bytes(&config_data)?;
if config.paused.ne(&0) {
return Err(OreError::IsPaused.into());
}
// Validate the clock state
let clock = Clock::get().or(Err(ProgramError::InvalidAccountData))?;
if clock.unix_timestamp.lt(&START_AT) {
return Err(OreError::NotStarted.into());
let mut proof_data = proof_info.data.borrow_mut();
let proof = Proof::try_from_bytes_mut(&mut proof_data)?;
if clock.unix_timestamp.lt(&proof.last_hash_at) {
return Err(OreError::ClockInvalid.into());
}
// Validate epoch is active
let treasury_data = treasury_info.data.borrow();
let treasury = Treasury::try_from_bytes(&treasury_data)?;
let threshold = treasury.last_reset_at.saturating_add(EPOCH_DURATION);
if clock.unix_timestamp.ge(&threshold) {
return Err(OreError::NeedsReset.into());
// let treasury_data = treasury_info.data.borrow();
// let treasury = Treasury::try_from_bytes(&treasury_data)?;
// let threshold = treasury.last_reset_at.saturating_add(EPOCH_DURATION);
// if clock.unix_timestamp.ge(&threshold) {
// return Err(OreError::NeedsReset.into());
// }
// Calculate the hash from the provided nonce
let noise_data = noise_info.data.borrow();
let hx = drillx::hash(&proof.hash, &args.nonce, &noise_data);
drop(noise_data);
// Validate hash satisfies the minimnum difficulty
let difficulty = drillx::difficulty(hx);
if difficulty.le(&config.min_difficulty) {
return Err(OreError::DifficultyInsufficient.into());
}
// Validate provided hash
let mut proof_data = proof_info.data.borrow_mut();
let proof = Proof::try_from_bytes_mut(&mut proof_data)?;
// let hash = validate_hash(
// proof.hash.into(),
// *signer.key,
// u64::from_le_bytes(args.nonce),
// proof.difficulty.into(),
// )?;
// Calculate base reward rate
let difficulty = difficulty
.saturating_sub(config.min_difficulty)
.min(DIFFICULTY_RANGE as u32);
let mut reward = config
.base_reward_rate
.saturating_mul(2u64.saturating_pow(difficulty));
// TODO Calculate reward based on difficulty
// TODO Calculate rewards multiplier
// TODO Calculate reward payout amount
// Apply staking multiplier
if clock.slot.gt(&proof.last_deposit_slot) {
// Only apply if last deposit was at least 1 block ago to prevent flash loan attacks.
// TODO Cleanup math with a const here (unnecessary cus)
// TODO Maybe move const into config!?
let max_stake = reward
.saturating_mul(60) // min/hour
.saturating_mul(24) // hour/day
.saturating_mul(365) // day/year
.saturating_mul(2); // year
let staking_reward = proof
.balance
.min(max_stake)
.saturating_mul(reward)
.saturating_div(max_stake);
reward = reward.saturating_add(staking_reward);
}
// Update claimable rewards
// Apply liveness penalty
// TODO Should penalty be symmetric?
// TODO Or should the curve be steeper on the <1 min side?
// TODO Eg anything more frequent than 40 seconds should get 0
// TODO Anything longer than 2 minutes should be 0
let tolerance = 5i64; // TODO Get from config
let target_time = proof.last_hash_at.saturating_add(EPOCH_DURATION);
if clock
.unix_timestamp
.saturating_sub(target_time)
.abs()
.gt(&tolerance)
{
// TODO Apply
}
// Update balances
let mut bus_data = bus_info.data.borrow_mut();
let bus = Bus::try_from_bytes_mut(&mut bus_data)?;
bus.rewards = bus
.rewards
.checked_sub(treasury.reward_rate)
.checked_sub(reward)
.ok_or(OreError::BusRewardsInsufficient)?;
proof.balance = proof.balance.saturating_add(treasury.reward_rate);
proof.balance = proof.balance.saturating_add(reward);
// Hash recent slot hash into the next challenge to prevent pre-mining attacks
proof.hash = hashv(&[
// TODO
// hash.as_ref(),
hx.as_slice(),
&slot_hashes_info.data.borrow()[0..size_of::<SlotHash>()],
])
.into();
.0;
// Update time trackers
proof.last_deposit_slot = clock.slot;
proof.last_hash_at = clock.unix_timestamp;
// Update lifetime stats
proof.total_hashes = proof.total_hashes.saturating_add(1);
proof.total_rewards = proof.total_rewards.saturating_add(treasury.reward_rate);
proof.total_rewards = proof.total_rewards.saturating_add(reward);
// Log the mined rewards
set_return_data(treasury.reward_rate.to_le_bytes().as_slice());
// set_return_data(reward.to_le_bytes().as_slice());
Ok(())
}
/// Validates the provided hash, ensursing it is equal to SHA3(current_hash, singer, nonce).
/// Fails if the provided hash is valid but does not satisfy the required difficulty.
pub(crate) fn validate_hash(
current_hash: KeccakHash,
signer: Pubkey,
nonce: u64,
difficulty: KeccakHash,
) -> Result<KeccakHash, ProgramError> {
let hash = hashv(&[
nonce.to_le_bytes().as_slice(),
current_hash.as_ref(),
signer.as_ref(),
]);
if hash.gt(&difficulty) {
return Err(OreError::HashInvalid.into());
}
Ok(hash)
}
#[cfg(test)]
mod tests {
use solana_program::{
keccak::{Hash, HASH_BYTES},
pubkey::Pubkey,
};
use crate::validate_hash;
#[test]
fn test_validate_hash_pass() {
let h1 = Hash::new_from_array([1; HASH_BYTES]);
let signer = Pubkey::new_unique();
let nonce = 10u64;
let difficulty = Hash::new_from_array([255; HASH_BYTES]);
let res = validate_hash(h1, signer, nonce, difficulty);
assert!(res.is_ok());
}
#[test]
fn test_validate_hash_fail() {
let h1 = Hash::new_from_array([1; HASH_BYTES]);
let signer = Pubkey::new_unique();
let nonce = 10u64;
let difficulty = Hash::new_from_array([0; HASH_BYTES]);
let res = validate_hash(h1, signer, nonce, difficulty);
assert!(res.is_err());
}
}