d0zingcat/ore
1
0
Fork 0
mirror of https://github.com/d0zingcat/ore.git synced 2026-05-14 15:10:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

polish

Browse Source
This commit is contained in:
Hardhat Chad
2024-02-14 17:01:30 +00:00
parent f917e49b3f
commit bbc1d835ea
21 changed files with 248 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/processor/claim.rs
View File

@@ -4,6 +4,7 @@ use solana_program::{
};
use crate::{
error::OreError,
instruction::ClaimArgs,
loaders::*,
state::{Proof, Treasury},
@@ -24,17 +25,22 @@ pub fn process_claim<'a, 'info>(
return Err(ProgramError::NotEnoughAccountKeys);
};
load_signer(signer)?;
load_token_account(beneficiary_info, None, mint_info.key)?;
load_mint(mint_info)?;
load_treasury(treasury_info)?;
load_token_account(treasury_tokens_info, Some(treasury_info.key), mint_info.key)?;
load_account(token_program, spl_token::id())?;
load_token_account(beneficiary_info, None, mint_info.key, 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())?;
// Validate claim amout
let mut proof_data = proof_info.data.borrow_mut();
let mut proof = bytemuck::try_from_bytes_mut::<Proof>(&mut proof_data).unwrap();
if proof.claimable_rewards.lt(&args.amount) {
return Err(ProgramError::Custom(1));
return Err(OreError::InvalidClaimAmount.into());
}
// Update claimable amount

8
src/processor/proof.rs → src/processor/create_proof.rs
View File

@@ -5,15 +5,15 @@ use solana_program::{
program_error::ProgramError, pubkey::Pubkey, system_program,
};
use crate::{instruction::ProofArgs, loaders::*, state::Proof, utils::create_pda, PROOF};
use crate::{instruction::CreateProofArgs, loaders::*, state::Proof, utils::create_pda, PROOF};
pub fn process_proof<'a, 'info>(
pub fn process_create_proof<'a, 'info>(
_program_id: &Pubkey,
accounts: &'a [AccountInfo<'info>],
data: &[u8],
) -> ProgramResult {
// Parse args
let args = bytemuck::try_from_bytes::<ProofArgs>(data)
let args = bytemuck::try_from_bytes::<CreateProofArgs>(data)
.or(Err(ProgramError::InvalidInstructionData))?;
// Validate accounts
@@ -22,7 +22,7 @@ pub fn process_proof<'a, 'info>(
};
load_signer(signer)?;
load_uninitialized_pda(proof_info, &[PROOF, signer.key.as_ref(), &[args.bump]])?;
load_account(system_program, system_program::id())?;
load_program(system_program, system_program::id())?;
// Initialize proof
create_pda(

8
src/processor/initialize.rs
View File

@@ -47,10 +47,10 @@ pub fn process_initialize<'a, 'info>(
return Err(ProgramError::InvalidSeeds);
}
load_uninitialized_account(treasury_tokens_info)?;
load_account(system_program, system_program::id())?;
load_account(token_program, spl_token::id())?;
load_account(associated_token_program, spl_associated_token_account::id())?;
load_account(rent_sysvar, sysvar::rent::id())?;
load_program(system_program, system_program::id())?;
load_program(token_program, spl_token::id())?;
load_program(associated_token_program, spl_associated_token_account::id())?;
load_sysvar(rent_sysvar, sysvar::rent::id())?;
// Initialize bus accounts
let bus_infos = [

28
src/processor/mine.rs
View File

@@ -6,12 +6,14 @@ use solana_program::{
entrypoint::ProgramResult,
keccak::{hashv, Hash as KeccakHash},
program_error::ProgramError,
program_memory::sol_memcmp,
pubkey::Pubkey,
slot_hashes::SlotHash,
sysvar::{self, Sysvar},
};
use crate::{
error::OreError,
instruction::MineArgs,
loaders::*,
state::{Bus, Proof, Treasury},
@@ -32,18 +34,18 @@ pub fn process_mine<'a, 'info>(
return Err(ProgramError::NotEnoughAccountKeys);
};
load_signer(signer)?;
load_bus(bus_info)?;
load_proof(proof_info, signer.key)?;
load_treasury(treasury_info)?;
load_account(slot_hashes_info, sysvar::slot_hashes::id())?;
load_bus(bus_info, true)?;
load_proof(proof_info, signer.key, true)?;
load_treasury(treasury_info, false)?;
load_sysvar(slot_hashes_info, sysvar::slot_hashes::id())?;
// Validate epoch is active
let clock = Clock::get().unwrap();
let treasury_data = treasury_info.data.borrow();
let treasury = bytemuck::try_from_bytes::<Treasury>(&treasury_data).unwrap();
let epoch_end_at = treasury.epoch_start_at.saturating_add(EPOCH_DURATION);
if !clock.unix_timestamp.lt(&epoch_end_at) {
return Err(ProgramError::Custom(1));
if clock.unix_timestamp.ge(&epoch_end_at) {
return Err(OreError::EpochExpired.into());
}
// Validate provided hash
@@ -61,7 +63,7 @@ pub fn process_mine<'a, 'info>(
let mut bus_data = bus_info.data.borrow_mut();
let mut bus = bytemuck::try_from_bytes_mut::<Bus>(&mut bus_data).unwrap();
if bus.available_rewards.lt(&treasury.reward_rate) {
return Err(ProgramError::Custom(1));
return Err(OreError::InsufficientBusRewards.into());
}
bus.available_rewards = bus.available_rewards.saturating_sub(treasury.reward_rate);
proof.claimable_rewards = proof.claimable_rewards.saturating_add(treasury.reward_rate);
@@ -86,19 +88,19 @@ pub(crate) fn validate_hash(
nonce: u64,
difficulty: KeccakHash,
) -> Result<(), ProgramError> {
// Validate hash correctness.
// Validate hash correctness
let hash_ = hashv(&[
current_hash.as_ref(),
signer.as_ref(),
nonce.to_be_bytes().as_slice(),
]);
if !hash.eq(&hash_) {
return Err(ProgramError::Custom(1));
if sol_memcmp(hash.as_ref(), hash_.as_ref(), 32) != 0 {
return Err(OreError::InvalidHash.into());
}
// Validate hash difficulty.
if !hash.le(&difficulty) {
return Err(ProgramError::Custom(1));
// Validate hash difficulty
if hash.gt(&difficulty) {
return Err(OreError::InsufficientHashDifficulty.into());
}
Ok(())

8
src/processor/mod.rs
View File

@@ -1,15 +1,15 @@
mod claim;
mod epoch;
mod create_proof;
mod initialize;
mod mine;
mod proof;
mod reset;
mod update_admin;
mod update_difficulty;
pub use claim::*;
pub use epoch::*;
pub use create_proof::*;
pub use initialize::*;
pub use mine::*;
pub use proof::*;
pub use reset::*;
pub use update_admin::*;
pub use update_difficulty::*;

36
src/processor/epoch.rs → src/processor/reset.rs
View File

@@ -4,13 +4,14 @@ use solana_program::{
};
use crate::{
error::OreError,
loaders::*,
state::{Bus, Treasury},
BUS_COUNT, BUS_EPOCH_REWARDS, EPOCH_DURATION, MAX_EPOCH_REWARDS, SMOOTHING_FACTOR,
TARGET_EPOCH_REWARDS, TREASURY,
};
pub fn process_epoch<'a, 'info>(
pub fn process_reset<'a, 'info>(
_program_id: &Pubkey,
accounts: &'a [AccountInfo<'info>],
_data: &[u8],
@@ -20,18 +21,23 @@ pub fn process_epoch<'a, 'info>(
return Err(ProgramError::NotEnoughAccountKeys);
};
load_signer(signer)?;
load_bus(bus_0_info)?;
load_bus(bus_1_info)?;
load_bus(bus_2_info)?;
load_bus(bus_3_info)?;
load_bus(bus_4_info)?;
load_bus(bus_5_info)?;
load_bus(bus_6_info)?;
load_bus(bus_7_info)?;
load_mint(mint_info)?;
load_treasury(treasury_info)?;
load_token_account(treasury_tokens_info, Some(treasury_info.key), mint_info.key)?;
load_account(token_program, spl_token::id())?;
load_bus(bus_0_info, true)?;
load_bus(bus_1_info, true)?;
load_bus(bus_2_info, true)?;
load_bus(bus_3_info, true)?;
load_bus(bus_4_info, true)?;
load_bus(bus_5_info, true)?;
load_bus(bus_6_info, true)?;
load_bus(bus_7_info, 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_sysvar(token_program, spl_token::id())?;
let busses: [&AccountInfo; 8] = [
bus_0_info, bus_1_info, bus_2_info, bus_3_info, bus_4_info, bus_5_info, bus_6_info,
bus_7_info,
@@ -42,8 +48,8 @@ pub fn process_epoch<'a, 'info>(
let mut treasury_data = treasury_info.data.borrow_mut();
let mut treasury = bytemuck::try_from_bytes_mut::<Treasury>(&mut treasury_data).unwrap();
let epoch_end_at = treasury.epoch_start_at.saturating_add(EPOCH_DURATION);
if !clock.unix_timestamp.ge(&epoch_end_at) {
return Err(ProgramError::Custom(1));
if clock.unix_timestamp.lt(&epoch_end_at) {
return Err(OreError::EpochActive.into());
}
// Reset busses

2
src/processor/update_admin.rs
View File

@@ -19,7 +19,7 @@ pub fn process_update_admin<'a, 'info>(
return Err(ProgramError::NotEnoughAccountKeys);
};
load_signer(signer)?;
load_treasury(treasury_info)?;
load_treasury(treasury_info, true)?;
// Validate admin signer
let mut treasury_data = treasury_info.data.borrow_mut();

2
src/processor/update_difficulty.rs
View File

@@ -19,7 +19,7 @@ pub fn process_update_difficulty<'a, 'info>(
return Err(ProgramError::NotEnoughAccountKeys);
};
load_signer(signer)?;
load_treasury(treasury_info)?;
load_treasury(treasury_info, true)?;
// Validate admin signer
let mut treasury_data = treasury_info.data.borrow_mut();