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

1252
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

1
Cargo.toml
View File

@@ -21,6 +21,7 @@ default = []
[dependencies]
bs58 = "0.5.0"
bytemuck = "1.14.3"
drillx = { git = "https://github.com/hardhatchad/drillx", branch = "master" }
mpl-token-metadata = "4.1.2"
num_enum = "0.7.2"
shank = "0.3.0"

9
src/consts.rs
View File

@@ -1,8 +1,5 @@
use solana_program::{keccak::Hash, pubkey, pubkey::Pubkey};
/// The unix timestamp after which mining can begin.
pub const START_AT: i64 = 1712070600;
/// The reward rate to intialize the program with.
pub const INITIAL_REWARD_RATE: u64 = 10u64.pow(3u32);
@@ -40,6 +37,9 @@ pub const BUS_COUNT: usize = 8;
/// than a factor of this constant from one epoch to the next.
pub const SMOOTHING_FACTOR: u64 = 2;
/// The range of difficulties miners can target above the minimum.
pub const DIFFICULTY_RANGE: usize = 32;
// Assert MAX_EPOCH_REWARDS is evenly divisible by BUS_COUNT.
static_assertions::const_assert!(
(MAX_EPOCH_REWARDS / BUS_COUNT as u64) * BUS_COUNT as u64 == MAX_EPOCH_REWARDS
@@ -96,6 +96,9 @@ pub const CONFIG_ADDRESS: Pubkey = pubkey!("FTap9fv2GPpWGqrLj3o4c9nHH7p36ih7NbSW
/// The address of the mint metadata account.
pub const METADATA_ADDRESS: Pubkey = pubkey!("2nXZSxfjELuRatcoY64yHdFLZFi3mtesxobHmsoU3Dag");
/// The address of the mint metadata account.
pub const NOISE_ADDRESS: Pubkey = pubkey!("2nXZSxfjELuRatcoY64yHdFLZFi3mtesxobHmsoU3Dag");
/// The address of the mint account.
pub const MINT_ADDRESS: Pubkey = pubkey!("oreoN2tQbHXVaZsr3pf66A48miqcBXCDJozganhEJgz");

10
src/error.rs
View File

@@ -5,18 +5,20 @@ use thiserror::Error;
#[derive(Debug, Error, Clone, Copy, PartialEq, Eq, IntoPrimitive)]
#[repr(u32)]
pub enum OreError {
#[error("The starting time has not passed yet")]
NotStarted = 0,
#[error("Mining is paused")]
IsPaused = 0,
#[error("The epoch has ended and needs reset")]
NeedsReset = 1,
#[error("The epoch is active and cannot be reset at this time")]
ResetTooEarly = 2,
#[error("The provided hash was invalid")]
HashInvalid = 3,
#[error("The provided hash did not satisfy the minimum required difficulty")]
DifficultyInsufficient = 3,
#[error("The bus does not have enough rewards to issue at this time")]
BusRewardsInsufficient = 4,
#[error("The claim amount cannot be greater than the claimable rewards")]
ClaimTooLarge = 5,
#[error("The clock time is invalid")]
ClockInvalid = 6,
}
impl From<OreError> for ProgramError {

19
src/instruction.rs
View File

@@ -8,19 +8,10 @@ use solana_program::{
};
use crate::{
impl_instruction_from_bytes, impl_to_bytes, state::Hash, BUS, CONFIG, CONFIG_ADDRESS, METADATA,
MINT, MINT_ADDRESS, MINT_NOISE, PROOF, TREASURY, TREASURY_ADDRESS,
impl_instruction_from_bytes, impl_to_bytes, BUS, CONFIG, CONFIG_ADDRESS, METADATA, MINT,
MINT_ADDRESS, MINT_NOISE, PROOF, TREASURY, TREASURY_ADDRESS,
};
// TODO Stake
// TODO Unstake
// TODO Upgrade (v1 to v2 token)
// TODO Downgrade (v2 to v1 token)
// TODO Personalized difficulty
// TODO Payout rewards based on multiplier and difficulty setting
#[repr(u8)]
#[derive(Clone, Copy, Debug, Eq, PartialEq, ShankInstruction, TryFromPrimitive)]
#[rustfmt::skip]
@@ -138,12 +129,6 @@ pub struct UpdateAdminArgs {
pub new_admin: Pubkey,
}
#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct UpdateDifficultyArgs {
pub new_difficulty: Hash,
}
impl_to_bytes!(InitializeArgs);
impl_to_bytes!(RegisterArgs);
impl_to_bytes!(MineArgs);

6
src/lib.rs
View File

@@ -14,6 +14,12 @@ use solana_program::{
program_error::ProgramError, pubkey::Pubkey,
};
// TODO Stake
// TODO Claim
// TODO Upgrade (v1 to v2 token)
// TODO Downgrade (v2 to v1 token)
declare_id!("mineRHF5r6S7HyD9SppBfVMXMavDkJsxwGesEvxZr2A");
#[cfg(not(feature = "no-entrypoint"))]

28
src/loaders.rs
View File

@@ -7,9 +7,11 @@ use spl_token::state::Mint;
use crate::{
state::{Bus, Config, Proof, Treasury},
utils::AccountDeserialize,
BUS_ADDRESSES, BUS_COUNT, CONFIG_ADDRESS, MINT_ADDRESS, TREASURY_ADDRESS,
BUS_ADDRESSES, BUS_COUNT, CONFIG_ADDRESS, MINT_ADDRESS, NOISE_ADDRESS, TREASURY_ADDRESS,
};
// TODO Account checks don't need to deserialize the whole byte array. They can just check the type byte
/// Errors if:
/// - Account is not a signer.
pub fn load_signer<'a, 'info>(info: &'a AccountInfo<'info>) -> Result<(), ProgramError> {
@@ -127,6 +129,30 @@ pub fn load_config<'a, 'info>(
Ok(())
}
/// asdf
pub fn load_noise<'a, 'info>(
info: &'a AccountInfo<'info>,
is_writable: bool,
) -> Result<(), ProgramError> {
if info.owner.ne(&crate::id()) {
return Err(ProgramError::InvalidAccountOwner);
}
if info.key.ne(&NOISE_ADDRESS) {
return Err(ProgramError::InvalidSeeds);
}
if info.data_is_empty() {
return Err(ProgramError::UninitializedAccount);
}
if is_writable && !info.is_writable {
return Err(ProgramError::InvalidAccountData);
}
Ok(())
}
/// Errors if:
/// - Owner is not Ore program.
/// - Data is empty.

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 @@

6
src/state/bus.rs
View File

@@ -17,12 +17,6 @@ pub struct Bus {
/// The quantity of rewards this bus can issue in the current epoch epoch.
pub rewards: u64,
/// Histogram of hash count per difficulty
pub hash_hist: [u64; 32],
/// Cumulative sum of applied multipliers per difficulty
pub multiplier_hist: [u64; 32],
}
impl Discriminator for Bus {

13
src/state/config.rs
View File

@@ -2,9 +2,10 @@ use bytemuck::{Pod, Zeroable};
use shank::ShankAccount;
use solana_program::pubkey::Pubkey;
// TODO next_min_difficulty: Option<u8>, update on reset
use crate::{
impl_account_from_bytes, impl_to_bytes,
state::Hash,
utils::{AccountDiscriminator, Discriminator},
};
@@ -15,8 +16,14 @@ pub struct Config {
/// The admin authority with permission to update the difficulty.
pub admin: Pubkey,
/// The hash difficulty.
pub difficulty: Hash,
/// The base reward rate paid out for a hash of minimum difficulty.
pub base_reward_rate: u64,
/// The minimum accepted difficulty.
pub min_difficulty: u32,
/// Is mining paused.
pub paused: u32,
}
impl Discriminator for Config {

14
src/state/hash.rs
View File

@@ -30,4 +30,18 @@ impl fmt::Display for Hash {
}
}
impl Hash {
pub fn difficulty(&self) -> u32 {
let mut count = 0;
for &byte in &self.0 {
let lz = byte.leading_zeros();
count += lz;
if lz < 8 {
break;
}
}
count
}
}
impl_to_bytes!(Hash);

4
src/state/mod.rs
View File

@@ -1,11 +1,11 @@
mod bus;
mod config;
mod hash;
// mod hash;
mod proof;
mod treasury;
pub use bus::*;
pub use config::*;
pub use hash::*;
// pub use hash::*;
pub use proof::*;
pub use treasury::*;

14
src/state/proof.rs
View File

@@ -4,7 +4,6 @@ use solana_program::pubkey::Pubkey;
use crate::{
impl_account_from_bytes, impl_to_bytes,
state::Hash,
utils::{AccountDiscriminator, Discriminator},
};
@@ -16,18 +15,17 @@ pub struct Proof {
/// The signer authorized to use this proof.
pub authority: Pubkey,
/// The quantity of tokens this miner may claim from the treasury.
/// The quantity of tokens this miner has staked or earned.
pub balance: u64,
/// The proof's current hash.
pub hash: Hash,
pub hash: [u8; 32],
/// The last slot ore was deposited into this account.
pub last_deposit_slot: u64,
/// The last time this account provided a hash.
pub last_hash_at: u64,
// TODO Figure out multiplier representation
/// The rewards multiplier for this account.
pub multiplier: u64,
pub last_hash_at: i64,
/// The total lifetime hashes provided by this miner.
pub total_hashes: u64,

6
src/state/treasury.rs
View File

@@ -14,12 +14,6 @@ pub struct Treasury {
/// The bump of the treasury account PDA, for signing CPIs.
pub bump: u64,
/// The timestamp of the reset invocation.
pub last_reset_at: i64,
/// The reward rate to payout to miners for submiting valid hashes.
pub reward_rate: u64,
/// The total lifetime claimed rewards of the program.
pub total_claimed_rewards: u64,
}