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

cleanup

Browse Source
This commit is contained in:
Hardhat Chad
2025-09-25 12:36:20 -07:00
parent a9a2e87031
commit d7d3cb8463
6 changed files with 171 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
api/src/sdk.rs
View File

@@ -151,13 +151,12 @@ pub fn claim_ore(signer: Pubkey, amount: u64) -> Instruction {
pub fn deploy(
signer: Pubkey,
authority: Pubkey,
fee_collector: Pubkey,
amount: u64,
squares: [bool; 25],
alt_miners: Vec<Pubkey>,
) -> Instruction {
let automation_address = automation_pda(authority).0;
let board_address = board_pda().0;
let config_address = config_pda().0;
let miner_address = miner_pda(authority).0;
let square_address = square_pda().0;
@@ -170,19 +169,26 @@ pub fn deploy(
}
}
let mut accounts = vec![
AccountMeta::new(signer, true),
AccountMeta::new(authority, false),
AccountMeta::new(automation_address, false),
AccountMeta::new(board_address, false),
AccountMeta::new(miner_address, false),
AccountMeta::new(square_address, false),
AccountMeta::new_readonly(system_program::ID, false),
];
// Add miners that might need to be refunded.
for miner in alt_miners {
if miner != Pubkey::default() {
accounts.push(AccountMeta::new(miner_pda(miner).0, false));
}
}
Instruction {
program_id: crate::ID,
accounts: vec![
AccountMeta::new(signer, true),
AccountMeta::new(authority, false),
AccountMeta::new(automation_address, false),
AccountMeta::new(board_address, false),
AccountMeta::new(config_address, false),
AccountMeta::new(fee_collector, false),
AccountMeta::new(miner_address, false),
AccountMeta::new(square_address, false),
AccountMeta::new_readonly(system_program::ID, false),
],
accounts,
data: Deploy {
amount: amount.to_le_bytes(),
squares: mask.to_le_bytes(),
@@ -273,7 +279,7 @@ pub fn wrap(signer: Pubkey) -> Instruction {
// let [signer_info, board_info, mint_info, treasury_info, treasury_tokens_info, system_program, token_program, slot_hashes_sysvar] =
pub fn reset(signer: Pubkey, miners: Vec<Pubkey>) -> Instruction {
pub fn reset(signer: Pubkey, fee_collector: Pubkey, miners: Vec<Pubkey>) -> Instruction {
let board_address = board_pda().0;
let config_address = config_pda().0;
let mint_address = MINT_ADDRESS;
@@ -284,6 +290,7 @@ pub fn reset(signer: Pubkey, miners: Vec<Pubkey>) -> Instruction {
AccountMeta::new(signer, true),
AccountMeta::new(board_address, false),
AccountMeta::new(config_address, false),
AccountMeta::new(fee_collector, false),
AccountMeta::new(mint_address, false),
AccountMeta::new(square_address, false),
AccountMeta::new(treasury_address, false),

6
api/src/state/square.rs
View File

@@ -7,13 +7,13 @@ use super::OreAccount;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
pub struct Square {
/// The count of miners on this square.
/// The count of miners on each square.
pub count: [u64; 25],
/// The deployments of all players.
/// The deployments of all players on each square.
pub deployed: [[u64; 16]; 25],
/// The miners in each square.
/// The miners authorities on each square.
pub miners: [[Pubkey; 16]; 25],
}

195
cli/src/main.rs
View File

@@ -34,11 +34,8 @@ async fn main() {
.expect("Missing COMMAND env var")
.as_str()
{
"migrate_squares" => {
migrate_squares(&rpc, &payer).await.unwrap();
}
"migrate_miners" => {
migrate_miners(&rpc, &payer).await.unwrap();
"test_kick" => {
test_kick(&rpc, &payer).await.unwrap();
}
"automations" => {
log_automations(&rpc).await.unwrap();
@@ -49,11 +46,8 @@ async fn main() {
"clock" => {
log_clock(&rpc).await.unwrap();
}
"claim_sol" => {
claim_sol(&rpc, &payer).await.unwrap();
}
"claim_ore" => {
claim_ore(&rpc, &payer).await.unwrap();
"claim" => {
claim(&rpc, &payer).await.unwrap();
}
"board" => {
log_board(&rpc).await.unwrap();
@@ -106,46 +100,56 @@ async fn main() {
_ => panic!("Invalid command"),
};
}
// Dmy2fqxpkUocwvkALMDwfCRFeYfkdGqgB5PLfmZW5ASR
// Az9Xia5f6EXU9MGHuuMCKyHMy3MfNnsoyTbh7HTuFw5G
// 5muLAbcjsAMcP8438KPfo2Jqw2vgAtuSDvMFNWb6Bexi
// FRYaFLiE384yeqqjM9smbz17HrJAWGVmicmWYCEMAL16
// 9D3hfN4FJWVdCMZStAhJbx93m2WLYXVEbkwdehsjihSK
// GNVEy8fcCwfDFHFXiKBrnmxDwQDFq9JfACgnjirWvzXa
// 7sBX4kPzB87tBw7xGsaLMyUjbPvoKRz2HA5kgxruUYfr
// BeqD2wuermavKMivfRMw3eFaXpAosh5pCVotF89PLfZk
// 3xrxQD2DcxiTeBKQqu129aijrVt6iAJ9yiEAV83yd61a
// GQA2EL4FJhFvKrQwLTUvq2kczS8t4MxpAzfbgroUX8oP
// Ddh1CP9vA3kjizVsr2J18VetznQiaY3EjPs8uPLVDFSd
// A21sYbqWbURRnUQEsVnyjEJq1hackmspp7RYaZFh4dw8
// 9fhLoSqzG9dfBja9mCHeYo4pG3jNyw47xqoZ9R3sihug
// FuWRwcvKBs3EHq9eUNy3xUSYETwhoK4jCHq93rFRas1i
// 8N8xX3dX4QhYtsmkU1jH6qPhT46or8TU8gvk9sF7PKrA
// Da6QdrpoSsZUffj7RBmVmnvP4HJZTBwcDv47YQErm45E
// Fjyo6xK6KdfaejYdZnb46aEXxmKHgkb3JoAW41ydF6gA
// EYuhVmfAG6WoKVkwnb1TEeXKek5J14YAkJn4VTEgu4ip
// CJmSeXLA2LrX8qLehn1vaMHGj2pX3hXmnJstgU3uhNeM
// 34QyjRFFU2Vp7ZAxdNm3FRCChEMbStAh9Zf58W84q7Fh
async fn test_kick(
rpc: &RpcClient,
payer: &solana_sdk::signer::keypair::Keypair,
) -> Result<(), anyhow::Error> {
let kps = [
read_keypair_file(&std::env::var("KEYPAIR_1").expect("Missing KEYPAIR_1 env var")).unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_2").expect("Missing KEYPAIR_2 env var")).unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_3").expect("Missing KEYPAIR_3 env var")).unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_4").expect("Missing KEYPAIR_4 env var")).unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_5").expect("Missing KEYPAIR_5 env var")).unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_6").expect("Missing KEYPAIR_6 env var")).unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_7").expect("Missing KEYPAIR_7 env var")).unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_8").expect("Missing KEYPAIR_8 env var")).unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_9").expect("Missing KEYPAIR_9 env var")).unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_10").expect("Missing KEYPAIR_10 env var"))
.unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_11").expect("Missing KEYPAIR_11 env var"))
.unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_12").expect("Missing KEYPAIR_12 env var"))
.unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_13").expect("Missing KEYPAIR_13 env var"))
.unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_14").expect("Missing KEYPAIR_14 env var"))
.unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_15").expect("Missing KEYPAIR_15 env var"))
.unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_16").expect("Missing KEYPAIR_16 env var"))
.unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_17").expect("Missing KEYPAIR_17 env var"))
.unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_18").expect("Missing KEYPAIR_18 env var"))
.unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_19").expect("Missing KEYPAIR_19 env var"))
.unwrap(),
read_keypair_file(&std::env::var("KEYPAIR_20").expect("Missing KEYPAIR_20 env var"))
.unwrap(),
read_keypair_file("~/.config/solana/tester-1.json").unwrap(),
read_keypair_file("~/.config/solana/tester-2.json").unwrap(),
read_keypair_file("~/.config/solana/tester-3.json").unwrap(),
read_keypair_file("~/.config/solana/tester-4.json").unwrap(),
read_keypair_file("~/.config/solana/tester-5.json").unwrap(),
read_keypair_file("~/.config/solana/tester-6.json").unwrap(),
read_keypair_file("~/.config/solana/tester-7.json").unwrap(),
read_keypair_file("~/.config/solana/tester-8.json").unwrap(),
read_keypair_file("~/.config/solana/tester-9.json").unwrap(),
read_keypair_file("~/.config/solana/tester-10.json").unwrap(),
read_keypair_file("~/.config/solana/tester-11.json").unwrap(),
read_keypair_file("~/.config/solana/tester-12.json").unwrap(),
read_keypair_file("~/.config/solana/tester-13.json").unwrap(),
read_keypair_file("~/.config/solana/tester-14.json").unwrap(),
read_keypair_file("~/.config/solana/tester-15.json").unwrap(),
read_keypair_file("~/.config/solana/tester-16.json").unwrap(),
read_keypair_file("~/.config/solana/tester-17.json").unwrap(),
read_keypair_file("~/.config/solana/tester-18.json").unwrap(),
read_keypair_file("~/.config/solana/tester-19.json").unwrap(),
read_keypair_file("~/.config/solana/tester-20.json").unwrap(),
];
let config = get_config(rpc).await?;
let alt_miners = kps.iter().map(|kp| kp.pubkey()).collect::<Vec<Pubkey>>();
for (i, kp) in kps.iter().enumerate() {
let amount = 1000 + i as u64;
let mut squares = [false; 25];
@@ -153,45 +157,17 @@ async fn test_kick(
let deploy_ix = ore_api::sdk::deploy(
kp.pubkey(),
kp.pubkey(),
config.fee_collector,
amount,
squares,
alt_miners.clone(),
);
println!("Deploying {} to square 0 for {}", amount, kp.pubkey());
submit_transaction(rpc, &kp, &[deploy_ix]).await?;
submit_transaction_no_confirm(rpc, &kp, &[deploy_ix]).await?;
}
Ok(())
}
async fn migrate_miners(
rpc: &RpcClient,
payer: &solana_sdk::signer::keypair::Keypair,
) -> Result<(), anyhow::Error> {
let miners = get_old_miners(rpc).await?;
for (i, (address, miner)) in miners.iter().enumerate() {
println!(
"[{}/{}] Migrating miner: {}",
i + 1,
miners.len(),
miner.authority
);
let ix = ore_api::sdk::migrate_miner(payer.pubkey(), *address);
submit_transaction(rpc, payer, &[ix]).await?;
}
Ok(())
}
async fn migrate_squares(
rpc: &RpcClient,
payer: &solana_sdk::signer::keypair::Keypair,
) -> Result<(), anyhow::Error> {
let ix = ore_api::sdk::migrate_squares(payer.pubkey());
// simulate_transaction(rpc, payer, &[ix]).await;
submit_transaction(rpc, payer, &[ix]).await?;
Ok(())
}
async fn ata(
rpc: &RpcClient,
payer: &solana_sdk::signer::keypair::Keypair,
@@ -244,21 +220,13 @@ async fn initialize(
Ok(())
}
async fn claim_sol(
async fn claim(
rpc: &RpcClient,
payer: &solana_sdk::signer::keypair::Keypair,
) -> Result<(), anyhow::Error> {
let ix = ore_api::sdk::claim_sol(payer.pubkey(), u64::MAX);
submit_transaction(rpc, payer, &[ix]).await?;
Ok(())
}
async fn claim_ore(
rpc: &RpcClient,
payer: &solana_sdk::signer::keypair::Keypair,
) -> Result<(), anyhow::Error> {
let ix = ore_api::sdk::claim_ore(payer.pubkey(), u64::MAX);
submit_transaction(rpc, payer, &[ix]).await?;
let ix_sol = ore_api::sdk::claim_sol(payer.pubkey(), u64::MAX);
let ix_ore = ore_api::sdk::claim_ore(payer.pubkey(), u64::MAX);
submit_transaction(rpc, payer, &[ix_sol, ix_ore]).await?;
Ok(())
}
@@ -281,16 +249,17 @@ async fn reset(
payer: &solana_sdk::signer::keypair::Keypair,
) -> Result<(), anyhow::Error> {
let board = get_board(rpc).await?;
let config = get_config(rpc).await?;
let slot_hashes = get_slot_hashes(rpc).await?;
let mut miners = vec![];
if let Some(slot_hash) = slot_hashes.get(&board.end_slot) {
let id = get_winning_square(&slot_hash.to_bytes());
let square = get_square(rpc).await?;
println!("Winning square: {}", id);
println!("Miners: {:?}", square.miners);
// println!("Miners: {:?}", square.miners);
miners = square.miners[id as usize].to_vec();
};
let reset_ix = ore_api::sdk::reset(payer.pubkey(), miners);
let reset_ix = ore_api::sdk::reset(payer.pubkey(), config.fee_collector, miners);
submit_transaction(rpc, payer, &[reset_ix]).await?;
Ok(())
}
@@ -303,18 +272,11 @@ async fn deploy(
let amount = u64::from_str(&amount).expect("Invalid AMOUNT");
let square_id = std::env::var("SQUARE").expect("Missing SQUARE env var");
let square_id = u64::from_str(&square_id).expect("Invalid SQUARE");
let config = get_config(rpc).await?;
let mut squares = [false; 25];
squares[square_id as usize] = true;
let ix = ore_api::sdk::deploy(
payer.pubkey(),
payer.pubkey(),
config.fee_collector,
amount,
squares,
);
let ix = ore_api::sdk::deploy(payer.pubkey(), payer.pubkey(), amount, squares, vec![]);
submit_transaction(rpc, payer, &[ix]).await?;
Ok(())
}
@@ -325,15 +287,8 @@ async fn deploy_all(
) -> Result<(), anyhow::Error> {
let amount = std::env::var("AMOUNT").expect("Missing AMOUNT env var");
let amount = u64::from_str(&amount).expect("Invalid AMOUNT");
let config = get_config(rpc).await?;
let squares = [true; 25];
let ix = ore_api::sdk::deploy(
payer.pubkey(),
payer.pubkey(),
config.fee_collector,
amount,
squares,
);
let ix = ore_api::sdk::deploy(payer.pubkey(), payer.pubkey(), amount, squares, vec![]);
submit_transaction(rpc, payer, &[ix]).await?;
Ok(())
}
@@ -439,6 +394,7 @@ async fn log_square(rpc: &RpcClient) -> Result<(), anyhow::Error> {
let square = get_square(rpc).await?;
println!("Square");
println!(" count: {:?}", square.count[id]);
println!(" deployed: {:?}", square.deployed[id]);
println!(" miners: {:?}", square.miners[id]);
Ok(())
}
@@ -590,11 +546,6 @@ async fn get_miners(rpc: &RpcClient) -> Result<Vec<(Pubkey, Miner)>, anyhow::Err
Ok(miners)
}
async fn get_old_miners(rpc: &RpcClient) -> Result<Vec<(Pubkey, MinerOLD)>, anyhow::Error> {
let miners = get_program_accounts::<MinerOLD>(rpc, ore_api::ID, vec![]).await?;
Ok(miners)
}
fn get_winning_square(slot_hash: &[u8]) -> u64 {
// Use slot hash to generate a random u64
let r1 = u64::from_le_bytes(slot_hash[0..8].try_into().unwrap());
@@ -655,6 +606,36 @@ async fn submit_transaction(
}
}
async fn submit_transaction_no_confirm(
rpc: &RpcClient,
payer: &solana_sdk::signer::keypair::Keypair,
instructions: &[solana_sdk::instruction::Instruction],
) -> Result<solana_sdk::signature::Signature, anyhow::Error> {
let blockhash = rpc.get_latest_blockhash().await?;
let mut all_instructions = vec![
ComputeBudgetInstruction::set_compute_unit_limit(1_400_000),
ComputeBudgetInstruction::set_compute_unit_price(1_000_000),
];
all_instructions.extend_from_slice(instructions);
let transaction = Transaction::new_signed_with_payer(
&all_instructions,
Some(&payer.pubkey()),
&[payer],
blockhash,
);
match rpc.send_transaction(&transaction).await {
Ok(signature) => {
println!("Transaction submitted: {:?}", signature);
Ok(signature)
}
Err(e) => {
println!("Error submitting transaction: {:?}", e);
Err(e.into())
}
}
}
pub async fn get_program_accounts<T>(
client: &RpcClient,
program_id: Pubkey,

43
program/src/deploy.rs
View File

@@ -13,8 +13,8 @@ pub fn process_deploy(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResul
// Load accounts.
let clock = Clock::get()?;
let (required_accounts, miner_accounts) = accounts.split_at(9);
let [signer_info, authority_info, automation_info, board_info, config_info, fee_collector_info, miner_info, square_info, system_program] =
let (required_accounts, miner_accounts) = accounts.split_at(7);
let [signer_info, authority_info, automation_info, board_info, miner_info, square_info, system_program] =
required_accounts
else {
return Err(ProgramError::NotEnoughAccountKeys);
@@ -28,10 +28,6 @@ pub fn process_deploy(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResul
(clock.slot >= b.start_slot && clock.slot < b.end_slot && b.slot_hash == [0; 32])
|| (clock.slot >= b.end_slot + INTERMISSION_SLOTS && b.slot_hash != [0; 32])
})?;
let config = config_info.as_account::<Config>(&ore_api::ID)?;
fee_collector_info
.has_address(&config.fee_collector)?
.is_writable()?;
miner_info.is_writable()?;
let square = square_info.as_account_mut::<Square>(&ore_api::ID)?;
system_program.is_program(&system_program::ID)?;
@@ -149,14 +145,9 @@ pub fn process_deploy(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResul
miner.round_id = board.id;
}
// Normalize amount.
let fee = amount / 100;
let amount = amount - fee;
// Calculate all deployments.
let mut refund_amounts = [0; 25];
let mut refund_miner_infos = [None; 25];
let mut total_fee = 0;
let mut total_amount = 0;
'deploy: for (square_id, &should_deploy) in squares.iter().enumerate() {
// Skip if square index is out of bounds.
@@ -233,6 +224,14 @@ pub fn process_deploy(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResul
square.deployed[square_id][idx] -= smallest_deployment;
square.miners[square_id][idx] = Pubkey::default();
square.count[square_id] -= 1;
sol_log(
&format!(
"Kicking miner {} from square {}. Refunding: {}",
smallest_miner.authority, square_id, smallest_deployment
)
.as_str(),
);
break 'refund;
}
}
@@ -245,6 +244,7 @@ pub fn process_deploy(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResul
// Safety check.
// Skip if square count is still >= 16. This can only happen if the signer didn't provide a miner account to refund.
if square.count[square_id] >= 16 {
sol_log(&format!("Square {} is full. Skipping deployment.", square_id).as_str());
continue 'deploy;
}
@@ -264,23 +264,14 @@ pub fn process_deploy(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResul
// Update square deployed
square.deployed[square_id][idx] += amount;
// Update total fee and amount
total_fee += fee;
// Update total amount
total_amount += amount;
}
// Transfer SOL refunds.
for (square_id, refund_amount) in refund_amounts.iter().enumerate() {
if let Some(refund_miner_info) = refund_miner_infos[square_id] {
board_info.send(*refund_amount, &refund_miner_info);
}
}
// Transfer SOL.
if let Some(automation) = automation {
automation.balance -= total_amount + total_fee + automation.fee;
automation.balance -= total_amount + automation.fee;
automation_info.send(total_amount, &board_info);
automation_info.send(total_fee, &fee_collector_info);
automation_info.send(automation.fee, &signer_info);
// Close automation if balance is 0.
@@ -289,7 +280,13 @@ pub fn process_deploy(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResul
}
} else {
board_info.collect(total_amount, &signer_info)?;
fee_collector_info.collect(total_fee, &signer_info)?;
}
// Transfer SOL refunds.
for (square_id, refund_amount) in refund_amounts.iter().enumerate() {
if let Some(refund_miner_info) = refund_miner_infos[square_id] {
board_info.send(*refund_amount, &refund_miner_info);
}
}
Ok(())

23
program/src/reset.rs
View File

@@ -2,12 +2,12 @@ use ore_api::prelude::*;
use solana_program::slot_hashes::SlotHashes;
use steel::*;
/// Claims a block reward.
/// Pays out the winners and block reward.
pub fn process_reset(accounts: &[AccountInfo<'_>], _data: &[u8]) -> ProgramResult {
// Load accounts.
let clock = Clock::get()?;
let (required_accounts, miner_accounts) = accounts.split_at(11);
let [signer_info, board_info, config_info, mint_info, square_info, treasury_info, treasury_tokens_info, system_program, token_program, ore_program, slot_hashes_sysvar] =
let (required_accounts, miner_accounts) = accounts.split_at(12);
let [signer_info, board_info, config_info, fee_collector_info, mint_info, square_info, treasury_info, treasury_tokens_info, system_program, token_program, ore_program, slot_hashes_sysvar] =
required_accounts
else {
return Err(ProgramError::NotEnoughAccountKeys);
@@ -17,7 +17,10 @@ pub fn process_reset(accounts: &[AccountInfo<'_>], _data: &[u8]) -> ProgramResul
.as_account_mut::<Board>(&ore_api::ID)?
.assert_mut(|b| b.slot_hash == [0; 32])?
.assert_mut(|b| clock.slot > b.end_slot)?;
config_info.as_account::<Config>(&ore_api::ID)?;
let config = config_info.as_account::<Config>(&ore_api::ID)?;
fee_collector_info
.is_writable()?
.has_address(&config.fee_collector)?;
let mint = mint_info.has_address(&MINT_ADDRESS)?.as_mint()?;
let square = square_info.as_account_mut::<Square>(&ore_api::ID)?;
let treasury = treasury_info.as_account_mut::<Treasury>(&ore_api::ID)?;
@@ -42,6 +45,9 @@ pub fn process_reset(accounts: &[AccountInfo<'_>], _data: &[u8]) -> ProgramResul
(u64::MAX as usize, 0)
};
// Collect fees.
let fee = board.total_deployed / 100;
// No one won. Vault all deployed.
if square_deployed == 0 {
// Update board.
@@ -69,7 +75,8 @@ pub fn process_reset(accounts: &[AccountInfo<'_>], _data: &[u8]) -> ProgramResul
)?;
// Do SOL transfers.
board_info.send(board.total_deployed, &treasury_info);
board_info.send(fee, &fee_collector_info);
board_info.send(board.total_deployed - fee, &treasury_info);
return Ok(());
}
@@ -77,7 +84,7 @@ pub fn process_reset(accounts: &[AccountInfo<'_>], _data: &[u8]) -> ProgramResul
let mut winnings = 0;
for (i, deployed) in board.deployed.iter().enumerate() {
if i != winning_square {
winnings += deployed;
winnings += deployed - (deployed / 100);
}
}
@@ -87,6 +94,9 @@ pub fn process_reset(accounts: &[AccountInfo<'_>], _data: &[u8]) -> ProgramResul
board.total_vaulted = vault_amount;
treasury.balance += vault_amount;
// Assert
assert!(board.total_deployed >= vault_amount + winnings + fee);
// Record miner rewards.
let mut miner_deployments = [0; 16];
let mut rewards_sol = [0; 16];
@@ -162,6 +172,7 @@ pub fn process_reset(accounts: &[AccountInfo<'_>], _data: &[u8]) -> ProgramResul
)?;
// Do SOL transfers.
board_info.send(fee, &fee_collector_info);
board_info.send(vault_amount, &treasury_info);
for (i, miner_info) in miner_accounts.iter().enumerate() {
board_info.send(rewards_sol[i], &miner_info);

23
program/src/whitelist.rs
View File

@@ -1,8 +1,29 @@
use solana_program::pubkey;
use steel::*;
pub const AUTHORIZED_ACCOUNTS: [Pubkey; 1] = [
pub const AUTHORIZED_ACCOUNTS: [Pubkey; 21] = [
pubkey!("pqspJ298ryBjazPAr95J9sULCVpZe3HbZTWkbC1zrkS"),
// TESTERS
pubkey!("Dmy2fqxpkUocwvkALMDwfCRFeYfkdGqgB5PLfmZW5ASR"),
pubkey!("Az9Xia5f6EXU9MGHuuMCKyHMy3MfNnsoyTbh7HTuFw5G"),
pubkey!("5muLAbcjsAMcP8438KPfo2Jqw2vgAtuSDvMFNWb6Bexi"),
pubkey!("FRYaFLiE384yeqqjM9smbz17HrJAWGVmicmWYCEMAL16"),
pubkey!("9D3hfN4FJWVdCMZStAhJbx93m2WLYXVEbkwdehsjihSK"),
pubkey!("GNVEy8fcCwfDFHFXiKBrnmxDwQDFq9JfACgnjirWvzXa"),
pubkey!("7sBX4kPzB87tBw7xGsaLMyUjbPvoKRz2HA5kgxruUYfr"),
pubkey!("BeqD2wuermavKMivfRMw3eFaXpAosh5pCVotF89PLfZk"),
pubkey!("3xrxQD2DcxiTeBKQqu129aijrVt6iAJ9yiEAV83yd61a"),
pubkey!("GQA2EL4FJhFvKrQwLTUvq2kczS8t4MxpAzfbgroUX8oP"),
pubkey!("Ddh1CP9vA3kjizVsr2J18VetznQiaY3EjPs8uPLVDFSd"),
pubkey!("A21sYbqWbURRnUQEsVnyjEJq1hackmspp7RYaZFh4dw8"),
pubkey!("9fhLoSqzG9dfBja9mCHeYo4pG3jNyw47xqoZ9R3sihug"),
pubkey!("FuWRwcvKBs3EHq9eUNy3xUSYETwhoK4jCHq93rFRas1i"),
pubkey!("8N8xX3dX4QhYtsmkU1jH6qPhT46or8TU8gvk9sF7PKrA"),
pubkey!("Da6QdrpoSsZUffj7RBmVmnvP4HJZTBwcDv47YQErm45E"),
pubkey!("Fjyo6xK6KdfaejYdZnb46aEXxmKHgkb3JoAW41ydF6gA"),
pubkey!("EYuhVmfAG6WoKVkwnb1TEeXKek5J14YAkJn4VTEgu4ip"),
pubkey!("CJmSeXLA2LrX8qLehn1vaMHGj2pX3hXmnJstgU3uhNeM"),
pubkey!("34QyjRFFU2Vp7ZAxdNm3FRCChEMbStAh9Zf58W84q7Fh"),
// pubkey!("HNWhK5f8RMWBqcA7mXJPaxdTPGrha3rrqUrri7HSKb3T"),
// pubkey!("6B9PjpHfbhPcSakS5UQ7ZctgbPujfsryVRpDecskGLiz"),
// pubkey!("HBUh9g46wk2X89CvaNN15UmsznP59rh6od1h8JwYAopk"),