d0zingcat/ore
1
0
Fork 0
mirror of https://github.com/d0zingcat/ore.git synced 2026-05-14 23:16:48 +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

10
src/processor/initialize.rs
View File

@@ -17,8 +17,8 @@ use crate::{
utils::create_pda,
utils::AccountDeserialize,
utils::Discriminator,
BUS, BUS_COUNT, CONFIG, INITIAL_DIFFICULTY, INITIAL_REWARD_RATE, METADATA, METADATA_NAME,
METADATA_SYMBOL, METADATA_URI, MINT, MINT_ADDRESS, MINT_NOISE, TOKEN_DECIMALS, TREASURY,
BUS, BUS_COUNT, CONFIG, METADATA, METADATA_NAME, METADATA_SYMBOL, METADATA_URI, MINT,
MINT_ADDRESS, MINT_NOISE, TOKEN_DECIMALS, TREASURY,
};
/// Initialize sets up the Ore program. Its responsibilities include:
@@ -131,7 +131,7 @@ pub fn process_initialize<'a, 'info>(
config_data[0] = Config::discriminator() as u8;
let config = Config::try_from_bytes_mut(&mut config_data)?;
config.admin = *signer.key;
config.difficulty = INITIAL_DIFFICULTY.into();
// config.difficulty = INITIAL_DIFFICULTY.into();
// Initialize treasury
create_pda(
@@ -146,8 +146,8 @@ pub fn process_initialize<'a, 'info>(
treasury_data[0] = Treasury::discriminator() as u8;
let treasury = Treasury::try_from_bytes_mut(&mut treasury_data)?;
treasury.bump = args.treasury_bump as u64;
treasury.last_reset_at = 0;
treasury.reward_rate = INITIAL_REWARD_RATE;
// treasury.last_reset_at = 0;
// treasury.reward_rate = INITIAL_REWARD_RATE;
treasury.total_claimed_rewards = 0;
drop(treasury_data);

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());
}
}

7
src/processor/register.rs
View File

@@ -14,7 +14,9 @@ use crate::{
PROOF,
};
// TODO Create a stake account
// TODO Create a stake account (token account)
// TODO Need to keep claimable balance (from treasury) separate from staking balance (from stake account)
// TODO Multiplier calculations should account for both
/// Register generates a new hash chain for a prospective miner. Its responsibilities include:
/// 1. Initialize a new proof account.
@@ -65,9 +67,8 @@ pub fn process_register<'a, 'info>(
signer.key.as_ref(),
&slot_hashes_info.data.borrow()[0..size_of::<SlotHash>()],
])
.into();
.0;
proof.last_hash_at = 0;
proof.multiplier = 1; // TODO
proof.total_hashes = 0;
proof.total_rewards = 0;

160
src/processor/reset.rs
View File

@@ -1,16 +1,6 @@
use solana_program::{
account_info::AccountInfo, clock::Clock, entrypoint::ProgramResult,
program_error::ProgramError, pubkey::Pubkey, sysvar::Sysvar,
};
use solana_program::{account_info::AccountInfo, entrypoint::ProgramResult, pubkey::Pubkey};
use crate::{
error::OreError,
loaders::*,
state::{Bus, Treasury},
utils::AccountDeserialize,
BUS_COUNT, BUS_EPOCH_REWARDS, EPOCH_DURATION, MAX_EPOCH_REWARDS, SMOOTHING_FACTOR, START_AT,
TARGET_EPOCH_REWARDS, TREASURY,
};
use crate::{BUS_EPOCH_REWARDS, SMOOTHING_FACTOR, TARGET_EPOCH_REWARDS};
/// Reset sets up the Ore program for the next epoch. Its responsibilities include:
/// 1. Reset bus account rewards counters.
@@ -33,85 +23,85 @@ pub fn process_reset<'a, 'info>(
accounts: &'a [AccountInfo<'info>],
_data: &[u8],
) -> ProgramResult {
// Load accounts
let [signer, bus_0_info, bus_1_info, bus_2_info, bus_3_info, bus_4_info, bus_5_info, bus_6_info, bus_7_info, mint_info, treasury_info, treasury_tokens_info, token_program] =
accounts
else {
return Err(ProgramError::NotEnoughAccountKeys);
};
load_signer(signer)?;
load_bus(bus_0_info, 0, true)?;
load_bus(bus_1_info, 1, true)?;
load_bus(bus_2_info, 2, true)?;
load_bus(bus_3_info, 3, true)?;
load_bus(bus_4_info, 4, true)?;
load_bus(bus_5_info, 5, true)?;
load_bus(bus_6_info, 6, true)?;
load_bus(bus_7_info, 7, true)?;
load_mint(mint_info, true)?;
load_treasury(treasury_info, true)?;
load_token_account(
treasury_tokens_info,
Some(treasury_info.key),
mint_info.key,
true,
)?;
load_program(token_program, spl_token::id())?;
let busses: [&AccountInfo; BUS_COUNT] = [
bus_0_info, bus_1_info, bus_2_info, bus_3_info, bus_4_info, bus_5_info, bus_6_info,
bus_7_info,
];
// // Load accounts
// let [signer, bus_0_info, bus_1_info, bus_2_info, bus_3_info, bus_4_info, bus_5_info, bus_6_info, bus_7_info, mint_info, treasury_info, treasury_tokens_info, token_program] =
// accounts
// else {
// return Err(ProgramError::NotEnoughAccountKeys);
// };
// load_signer(signer)?;
// load_bus(bus_0_info, 0, true)?;
// load_bus(bus_1_info, 1, true)?;
// load_bus(bus_2_info, 2, true)?;
// load_bus(bus_3_info, 3, true)?;
// load_bus(bus_4_info, 4, true)?;
// load_bus(bus_5_info, 5, true)?;
// load_bus(bus_6_info, 6, true)?;
// load_bus(bus_7_info, 7, true)?;
// load_mint(mint_info, true)?;
// load_treasury(treasury_info, true)?;
// load_token_account(
// treasury_tokens_info,
// Some(treasury_info.key),
// mint_info.key,
// true,
// )?;
// load_program(token_program, spl_token::id())?;
// let busses: [&AccountInfo; BUS_COUNT] = [
// bus_0_info, bus_1_info, bus_2_info, bus_3_info, bus_4_info, bus_5_info, bus_6_info,
// bus_7_info,
// ];
// Validate mining has starting
let clock = Clock::get().or(Err(ProgramError::InvalidAccountData))?;
if clock.unix_timestamp.lt(&START_AT) {
return Err(OreError::NotStarted.into());
}
// // Validate mining has starting
// let clock = Clock::get().or(Err(ProgramError::InvalidAccountData))?;
// if clock.unix_timestamp.lt(&START_AT) {
// return Err(OreError::NotStarted.into());
// }
// Validate at least 60 seconds have passed since last reset
let mut treasury_data = treasury_info.data.borrow_mut();
let treasury = Treasury::try_from_bytes_mut(&mut treasury_data)?;
let threshold = treasury.last_reset_at.saturating_add(EPOCH_DURATION);
if clock.unix_timestamp.lt(&threshold) {
return Err(OreError::ResetTooEarly.into());
}
// // Validate at least 60 seconds have passed since last reset
// let mut treasury_data = treasury_info.data.borrow_mut();
// let treasury = Treasury::try_from_bytes_mut(&mut treasury_data)?;
// let threshold = treasury.last_reset_at.saturating_add(EPOCH_DURATION);
// if clock.unix_timestamp.lt(&threshold) {
// return Err(OreError::ResetTooEarly.into());
// }
// Record current timestamp
treasury.last_reset_at = clock.unix_timestamp;
// // Record current timestamp
// treasury.last_reset_at = clock.unix_timestamp;
// Reset bus accounts and calculate actual rewards mined since last reset
let mut total_remaining_rewards = 0u64;
for i in 0..BUS_COUNT {
let mut bus_data = busses[i].data.borrow_mut();
let bus = Bus::try_from_bytes_mut(&mut bus_data)?;
total_remaining_rewards = total_remaining_rewards.saturating_add(bus.rewards);
bus.rewards = BUS_EPOCH_REWARDS;
}
let total_epoch_rewards = MAX_EPOCH_REWARDS.saturating_sub(total_remaining_rewards);
// // Reset bus accounts and calculate actual rewards mined since last reset
// let mut total_remaining_rewards = 0u64;
// for i in 0..BUS_COUNT {
// let mut bus_data = busses[i].data.borrow_mut();
// let bus = Bus::try_from_bytes_mut(&mut bus_data)?;
// total_remaining_rewards = total_remaining_rewards.saturating_add(bus.rewards);
// bus.rewards = BUS_EPOCH_REWARDS;
// }
// let total_epoch_rewards = MAX_EPOCH_REWARDS.saturating_sub(total_remaining_rewards);
// Update reward rate for next epoch
treasury.reward_rate = calculate_new_reward_rate(treasury.reward_rate, total_epoch_rewards);
// // Update reward rate for next epoch
// treasury.reward_rate = calculate_new_reward_rate(treasury.reward_rate, total_epoch_rewards);
// Fund treasury token account
let treasury_bump = treasury.bump as u8;
drop(treasury_data);
solana_program::program::invoke_signed(
&spl_token::instruction::mint_to(
&spl_token::id(),
mint_info.key,
treasury_tokens_info.key,
treasury_info.key,
&[treasury_info.key],
total_epoch_rewards,
)?,
&[
token_program.clone(),
mint_info.clone(),
treasury_tokens_info.clone(),
treasury_info.clone(),
],
&[&[TREASURY, &[treasury_bump]]],
)?;
// // Fund treasury token account
// let treasury_bump = treasury.bump as u8;
// drop(treasury_data);
// solana_program::program::invoke_signed(
// &spl_token::instruction::mint_to(
// &spl_token::id(),
// mint_info.key,
// treasury_tokens_info.key,
// treasury_info.key,
// &[treasury_info.key],
// total_epoch_rewards,
// )?,
// &[
// token_program.clone(),
// mint_info.clone(),
// treasury_tokens_info.clone(),
// treasury_info.clone(),
// ],
// &[&[TREASURY, &[treasury_bump]]],
// )?;
Ok(())
}

1
src/processor/stake.rs Normal file
View File

@@ -0,0 +1 @@