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

optimization

Browse Source
This commit is contained in:
Hardhat Chad
2024-02-13 23:24:57 +00:00
parent 7cba1ff1da
commit 54b7a35433
15 changed files with 495 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
src/instruction.rs
View File

@@ -2,6 +2,8 @@ use bytemuck::{Pod, Zeroable};
use num_enum::TryFromPrimitive;
use shank::ShankInstruction;
use crate::state::Hash;
#[repr(u8)]
#[derive(Clone, Copy, Debug, Eq, PartialEq, ShankInstruction, TryFromPrimitive)]
#[rustfmt::skip]
@@ -33,8 +35,7 @@ pub enum OreInstruction {
#[account(2, name = "bus", desc = "Ore bus account", writable)]
#[account(3, name = "proof", desc = "Ore miner proof account", writable)]
#[account(4, name = "treasury", desc = "Ore treasury account")]
#[account(5, name = "token_program", desc = "SPL token program")]
#[account(6, name = "slot_hashes", desc = "Solana slot hashes sysvar")]
#[account(5, name = "slot_hashes", desc = "Solana slot hashes sysvar")]
Mine = 2,
#[account(0, name = "ore_program", desc = "Ore program")]
@@ -101,3 +102,28 @@ impl InitializeArgs {
bytemuck::bytes_of(self)
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct ProofArgs {
pub bump: u8,
}
impl ProofArgs {
pub fn to_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct MineArgs {
pub hash: Hash,
pub nonce: [u8; 8],
}
impl MineArgs {
pub fn to_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}

33
src/lib.rs
View File

@@ -82,6 +82,22 @@ pub const PROOF: &[u8] = b"proof";
/// The seed of the treasury account PDA.
pub const TREASURY: &[u8] = b"treasury";
/// Treasury address
pub const TREASURY_ADDRESS: Pubkey = pubkey!("67PLJej6iZm915WbEu6NLeZtRZtnHc5nSVQvkHRZyPiC");
// SHA2 const stable
/// Bus pubkeys
pub const BUS_ADDRESSES: [Pubkey; 8] = [
pubkey!("2uwqyH2gKqstgAFCSniirx73X4iQek5ETc2vVJKUiNMg"),
pubkey!("FRMC6jVczm1cRaEs5EhDsfw7X8vsmSDpf3bJWVkawngu"),
pubkey!("9nWyycs4GHjnLujPR2sbA1A8K8CkiLc5VzxWUD4hg2uM"),
pubkey!("Kt7kqD3MyvxLbj4ek9urXUxkDoxaMuQn82K2VdYD1jM"),
pubkey!("8r9mXYnFQXhwrNfvatGUTxbbNSqxScuCwp4sBTSxDVTJ"),
pubkey!("D9cEH32k8p9uWc4w5RrStK9rWssU8NuX1Dg5YaUim4wL"),
pubkey!("H1RKMYADPzd4C1j1RZu51NvRSVktoTYEJyeVy98Kmdyu"),
pubkey!("3XbdZNbBjjp8qnDJjv1RxaKisyfx6ahznYkSigs6dayy"),
];
/// Processes the incoming instruction
pub fn process_instruction(
program_id: &Pubkey,
@@ -93,13 +109,16 @@ pub fn process_instruction(
.ok_or(ProgramError::InvalidInstructionData)?;
let ix = OreInstruction::try_from(*tag).or(Err(ProgramError::InvalidInstructionData))?;
match ix {
OreInstruction::Epoch => process_epoch(program_id, accounts, data)?,
OreInstruction::Proof => process_proof(program_id, accounts, data)?,
OreInstruction::Mine => process_mine(program_id, accounts, data)?,
OreInstruction::Claim => process_claim(program_id, accounts, data)?,
OreInstruction::Initialize => process_initialize(program_id, accounts, data)?,
}
// if ix.eq(&OreInstruction::Proof) {
// process_proof(program_id, accounts, data)?
// }
// match ix {
// OreInstruction::Epoch => process_epoch(program_id, accounts, data)?,
// OreInstruction::Proof => process_proof(program_id, accounts, data)?,
// OreInstruction::Mine => process_mine(program_id, accounts, data)?,
// OreInstruction::Claim => process_claim(program_id, accounts, data)?,
// OreInstruction::Initialize => process_initialize(program_id, accounts, data)?,
// }
Ok(())
}

59
src/loaders.rs
View File

@@ -1,12 +1,12 @@
use solana_program::{
account_info::AccountInfo, program_error::ProgramError, program_pack::Pack, pubkey::Pubkey,
system_program,
syscalls, system_program,
};
use spl_token::state::Mint;
use crate::{
state::{Bus, Treasury},
BUS, MINT_ADDRESS, TREASURY,
state::{Bus, Proof},
BUS_COUNT, MINT_ADDRESS, TREASURY_ADDRESS,
};
pub fn load_signer<'a, 'info>(
@@ -18,26 +18,6 @@ pub fn load_signer<'a, 'info>(
Ok(info)
}
pub fn load_pda<'a, 'info>(
info: &'a AccountInfo<'info>,
seeds: &[&[u8]],
writable: bool,
) -> Result<&'a AccountInfo<'info>, ProgramError> {
let key = Pubkey::create_program_address(seeds, &crate::id())?;
if !info.key.eq(&key) {
return Err(ProgramError::InvalidSeeds);
}
if !info.owner.eq(&crate::id()) {
return Err(ProgramError::InvalidAccountOwner);
}
if writable {
if !info.is_writable {
return Err(ProgramError::InvalidAccountData);
}
}
Ok(info)
}
pub fn load_uninitialized_pda<'a, 'info>(
info: &'a AccountInfo<'info>,
seeds: &[&[u8]],
@@ -62,10 +42,29 @@ pub fn load_bus<'a, 'info>(
let bus_data = info.data.borrow();
let bus = bytemuck::try_from_bytes::<Bus>(&bus_data).unwrap();
let key =
Pubkey::create_program_address(&[BUS, &[bus.id as u8], &[bus.bump as u8]], &crate::id())?;
if !info.key.eq(&key) {
return Err(ProgramError::InvalidSeeds);
if !(0..BUS_COUNT).contains(&(bus.id as usize)) {
return Err(ProgramError::InvalidAccountData);
}
Ok(info)
}
pub fn load_proof<'a, 'info>(
info: &'a AccountInfo<'info>,
signer: &Pubkey,
) -> Result<&'a AccountInfo<'info>, ProgramError> {
if !info.owner.eq(&crate::id()) {
return Err(ProgramError::InvalidAccountOwner);
}
if info.data_is_empty() {
return Err(ProgramError::UninitializedAccount);
}
let proof_data = info.data.borrow();
let proof = bytemuck::try_from_bytes::<Proof>(&proof_data).unwrap();
if !proof.authority.eq(&signer) {
return Err(ProgramError::InvalidAccountData);
}
Ok(info)
@@ -81,11 +80,7 @@ pub fn load_treasury<'a, 'info>(
return Err(ProgramError::UninitializedAccount);
}
let treasury_data = info.data.borrow();
let treasury = bytemuck::try_from_bytes::<Treasury>(&treasury_data).unwrap();
let key = Pubkey::create_program_address(&[TREASURY, &[treasury.bump as u8]], &crate::id())?;
if !info.key.eq(&key) {
if !info.key.eq(&TREASURY_ADDRESS) {
return Err(ProgramError::InvalidSeeds);
}

2
src/processor/epoch.rs
View File

@@ -10,7 +10,7 @@ use solana_program::{
use crate::{
loaders::*,
state::{Bus, Treasury},
BUS, BUS_COUNT, BUS_EPOCH_REWARDS, EPOCH_DURATION, MAX_EPOCH_REWARDS, SMOOTHING_FACTOR,
BUS_COUNT, BUS_EPOCH_REWARDS, EPOCH_DURATION, MAX_EPOCH_REWARDS, SMOOTHING_FACTOR,
TARGET_EPOCH_REWARDS, TREASURY,
};

19
src/processor/initialize.rs
View File

@@ -11,7 +11,7 @@ use solana_program::{
};
use spl_token::state::Mint;
use crate::{instruction::*, BUS, INITIAL_DIFFICULTY, MINT_ADDRESS};
use crate::{instruction::*, BUS, INITIAL_DIFFICULTY, MINT_ADDRESS, TREASURY_ADDRESS};
use crate::{
loaders::*,
state::{Bus, Treasury},
@@ -77,10 +77,13 @@ pub fn process_initialize<'a, 'info>(
}
// Account 11: Treasury
let treasury_account_info = load_uninitialized_pda(
let treasury_info = load_uninitialized_pda(
next_account_info(accounts_iter)?,
&[TREASURY, &[args.treasury_bump]],
)?;
if !treasury_info.key.eq(&TREASURY_ADDRESS) {
return Err(ProgramError::InvalidSeeds);
}
// Account 12: Treasury tokens
let treasury_tokens = load_uninitialized_account(next_account_info(accounts_iter)?)?;
@@ -132,14 +135,14 @@ pub fn process_initialize<'a, 'info>(
// Initialize treasury
create_pda(
treasury_account_info,
treasury_info,
&crate::id(),
size_of::<Treasury>(),
&[TREASURY, &[args.treasury_bump]],
system_program,
signer,
)?;
let mut treasury_data = treasury_account_info.data.borrow_mut();
let mut treasury_data = treasury_info.data.borrow_mut();
let mut treasury = bytemuck::try_from_bytes_mut::<Treasury>(&mut treasury_data).unwrap();
treasury.bump = args.treasury_bump as u64;
treasury.admin = *signer.key;
@@ -162,14 +165,14 @@ pub fn process_initialize<'a, 'info>(
&spl_token::instruction::initialize_mint(
&spl_token::id(),
mint.key,
treasury_account_info.key,
treasury_info.key,
None,
TOKEN_DECIMALS,
)?,
&[
token_program.clone(),
mint.clone(),
treasury_account_info.clone(),
treasury_info.clone(),
rent_sysvar.clone(),
],
&[&[MINT, &[args.mint_bump]]],
@@ -179,7 +182,7 @@ pub fn process_initialize<'a, 'info>(
solana_program::program::invoke(
&spl_associated_token_account::instruction::create_associated_token_account(
signer.key,
treasury_account_info.key,
treasury_info.key,
mint.key,
&spl_token::id(),
),
@@ -187,7 +190,7 @@ pub fn process_initialize<'a, 'info>(
associated_token_program.clone(),
signer.clone(),
treasury_tokens.clone(),
treasury_account_info.clone(),
treasury_info.clone(),
mint.clone(),
system_program.clone(),
token_program.clone(),

91
src/processor/mine.rs
View File

@@ -1,9 +1,21 @@
use std::mem::size_of;
use solana_program::{
account_info::AccountInfo,
account_info::{next_account_info, AccountInfo},
clock::Clock,
entrypoint::ProgramResult,
keccak::{hashv, Hash},
keccak::{hashv, Hash as KeccakHash},
program_error::ProgramError,
pubkey::Pubkey,
slot_hashes::SlotHash,
sysvar::{self, Sysvar},
};
use crate::{
instruction::MineArgs,
loaders::*,
state::{Bus, Proof, Treasury},
EPOCH_DURATION,
};
pub fn process_mine<'a, 'info>(
@@ -11,16 +23,83 @@ pub fn process_mine<'a, 'info>(
accounts: &'a [AccountInfo<'info>],
data: &[u8],
) -> ProgramResult {
// TODO
// let accounts_iter = &mut accounts.iter();
// let args =
// bytemuck::try_from_bytes::<MineArgs>(data).or(Err(ProgramError::InvalidInstructionData))?;
// let [signer, bus_info, proof_info, treasury_info, slot_hashes_info] = accounts else {
// return Err(ProgramError::NotEnoughAccountKeys);
// };
// let _ = load_signer(signer)?;
// let _ = load_bus(bus_info)?;
// let _ = load_proof(proof_info, signer.key)?;
// let _ = load_treasury(treasury_info)?;
// let _ = load_account(slot_hashes_info, sysvar::slot_hashes::id())?;
// Account 1: Signer
// let signer = load_signer(next_account_info(accounts_iter)?)?;
// Account 2: Bus
// let bus_info = load_bus(next_account_info(accounts_iter)?)?;
// Account 3: Proof
// let proof_info = load_proof(next_account_info(accounts_iter)?, signer.key)?;
// Account 4: Treasury
// let treasury_info = load_treasury(next_account_info(accounts_iter)?)?;
// Account 5: Slot hashes svsvar
// let slot_hashes_info =
// load_account(next_account_info(accounts_iter)?, 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));
// }
// Validate provided hash
// let mut proof_data = proof_info.data.borrow_mut();
// let mut proof = bytemuck::try_from_bytes_mut::<Proof>(&mut proof_data).unwrap();
// validate_hash(
// proof.hash.into(),
// args.hash.into(),
// *signer.key,
// u64::from_le_bytes(args.nonce),
// treasury.difficulty.into(),
// )?;
// Update claimable rewards
// 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.ge(&treasury.reward_rate) {
// return Err(ProgramError::Custom(1));
// }
// bus.available_rewards = bus.available_rewards.saturating_sub(treasury.reward_rate);
// proof.claimable_rewards = proof.claimable_rewards.saturating_add(treasury.reward_rate);
// Hash most recent slot hash into the next challenge to prevent pre-mining attacks
// let slot_hash_bytes = &slot_hashes_info.data.borrow()[0..size_of::<SlotHash>()];
// proof.hash = hashv(&[KeccakHash::from(args.hash).as_ref(), slot_hash_bytes]).into();
// Update lifetime stats
// proof.total_hashes = proof.total_hashes.saturating_add(1);
// proof.total_rewards = proof.total_rewards.saturating_add(1);
// TODO Log?
Ok(())
}
pub(crate) fn validate_hash(
current_hash: Hash,
hash: Hash,
current_hash: KeccakHash,
hash: KeccakHash,
signer: Pubkey,
nonce: u64,
difficulty: Hash,
difficulty: KeccakHash,
) -> Result<(), ProgramError> {
// Validate hash correctness.
let hash_ = hashv(&[

48
src/processor/proof.rs
View File

@@ -1,10 +1,54 @@
use solana_program::{account_info::AccountInfo, entrypoint::ProgramResult, pubkey::Pubkey};
use std::mem::size_of;
use solana_program::{
account_info::{next_account_info, AccountInfo},
entrypoint::ProgramResult,
keccak::hashv,
program_error::ProgramError,
pubkey::Pubkey,
system_program,
};
use crate::{instruction::ProofArgs, loaders::*, state::Proof, utils::create_pda, PROOF};
pub fn process_proof<'a, 'info>(
_program_id: &Pubkey,
accounts: &'a [AccountInfo<'info>],
data: &[u8],
) -> ProgramResult {
// TODO
let accounts_iter = &mut accounts.iter();
let args = bytemuck::try_from_bytes::<ProofArgs>(data)
.or(Err(ProgramError::InvalidInstructionData))?;
// Account 1: Signer
let signer = load_signer(next_account_info(accounts_iter)?)?;
// Account 2: Proof
let proof_info = load_uninitialized_pda(
next_account_info(accounts_iter)?,
&[PROOF, signer.key.as_ref(), &[args.bump]],
)?;
// Account 3: System program
let system_program = load_account(next_account_info(accounts_iter)?, system_program::id())?;
// Initialize proof
create_pda(
proof_info,
&crate::id(),
size_of::<Proof>(),
&[PROOF, signer.key.as_ref(), &[args.bump]],
system_program,
signer,
)?;
let mut proof_data = proof_info.data.borrow_mut();
let mut proof = bytemuck::try_from_bytes_mut::<Proof>(&mut proof_data).unwrap();
proof.bump = args.bump as u64;
proof.authority = *signer.key;
proof.claimable_rewards = 0;
proof.hash = hashv(&[&signer.key.to_bytes()]).into();
proof.total_hashes = 0;
proof.total_rewards = 0;
Ok(())
}

2
src/state/hash.rs
View File

@@ -8,12 +8,14 @@ use solana_program::keccak::{Hash as KeccakHash, HASH_BYTES};
pub struct Hash(pub [u8; HASH_BYTES]);
impl From<KeccakHash> for Hash {
#[inline(always)]
fn from(value: KeccakHash) -> Self {
unsafe { transmute(value) }
}
}
impl From<Hash> for KeccakHash {
#[inline(always)]
fn from(value: Hash) -> Self {
unsafe { transmute(value) }
}

2
src/state/mod.rs
View File

@@ -1,7 +1,9 @@
mod bus;
mod hash;
mod proof;
mod treasury;
pub use bus::*;
pub use hash::*;
pub use proof::*;
pub use treasury::*;

32
src/state/proof.rs Normal file
View File

@@ -0,0 +1,32 @@
use bytemuck::{Pod, Zeroable};
use solana_program::pubkey::Pubkey;
use super::Hash;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
pub struct Proof {
/// The bump of the proof account PDA.
pub bump: u64,
/// The account (i.e. miner) authorized to use this proof.
pub authority: Pubkey,
/// The quantity of tokens this miner may claim from the treasury.
pub claimable_rewards: u64,
/// The proof's current hash.
pub hash: Hash,
/// The total lifetime hashes provided by this miner.
pub total_hashes: u64,
/// The total lifetime rewards distributed to this miner.
pub total_rewards: u64,
}
impl Proof {
pub fn to_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}