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

scaffolding

Browse Source
This commit is contained in:
Hardhat Chad
2025-06-05 16:14:08 -07:00
parent fa1fb5e30c
commit 4138fc2b66
17 changed files with 393 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
program/src/buy.rs
View File

@@ -0,0 +1,23 @@
use ore_api::prelude::*;
use steel::*;
/// Buy hashpower.
pub fn process_buy(accounts: &[AccountInfo<'_>], _data: &[u8]) -> ProgramResult {
// Load accounts.
let clock = Clock::get()?;
let [signer_info, block_info, market_info, miner_info, recipient_info, system_program, token_program] =
accounts
else {
return Err(ProgramError::NotEnoughAccountKeys);
};
signer_info.is_signer()?;
let block = block_info
.as_account_mut::<Block>(&ore_api::ID)?
.assert_mut(|b| clock.slot >= b.start_slot + 1500)?;
system_program.is_program(&system_program::ID)?;
token_program.is_program(&spl_token::ID)?;
// TODO Buy hash tokens
Ok(())
}

69
program/src/close.rs
View File

@@ -0,0 +1,69 @@
use ore_api::prelude::*;
use steel::*;
/// Closes a block.
pub fn process_close(accounts: &[AccountInfo<'_>], _data: &[u8]) -> ProgramResult {
// Load accounts.
let clock = Clock::get()?;
let [signer_info, block_info, market_info, market_hash_info, market_ore_info, mint_hash_info, mint_ore_info, recipient_info, treasury_info, system_program, token_program] =
accounts
else {
return Err(ProgramError::NotEnoughAccountKeys);
};
signer_info.is_signer()?;
let block = block_info
.as_account_mut::<Block>(&ore_api::ID)?
.assert_mut(|b| clock.slot >= b.start_slot + 1500)?;
let market = market_info
.as_account_mut::<Market>(&ore_api::ID)?
.assert_mut(|m| m.id == block.id)?;
let market_hash =
market_hash_info.as_associated_token_account(market_info.key, mint_hash_info.key)?;
let market_ore =
market_ore_info.as_associated_token_account(market_info.key, mint_ore_info.key)?;
mint_hash_info.has_address(&market.mint)?;
mint_ore_info.has_address(&MINT_ADDRESS)?;
system_program.is_program(&system_program::ID)?;
token_program.is_program(&spl_token::ID)?;
// Payout block reward.
if block.best_miner != Pubkey::default() {
recipient_info.as_associated_token_account(&block.best_miner, &MINT_ADDRESS)?;
mint_to_signed(
mint_ore_info,
recipient_info,
treasury_info,
token_program,
block.reward,
&[TREASURY],
)?;
}
// Burn hash tokens.
burn_signed(
market_hash_info,
mint_hash_info,
market_info,
token_program,
market_hash.amount(),
&[MARKET, &market.id.to_le_bytes()],
)?;
// Burn ORE liquidity.
burn_signed(
market_ore_info,
mint_ore_info,
market_info,
token_program,
market_ore.amount(),
&[MARKET, &market.id.to_le_bytes()],
)?;
// Close block.
block_info.close(signer_info)?;
// Close market.
market_info.close(signer_info)?;
Ok(())
}

39
program/src/deposit.rs
View File

@@ -0,0 +1,39 @@
use ore_api::prelude::*;
use steel::*;
/// Deposits stake.
pub fn process_deposit(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResult {
// Parse data.
let args = Deposit::try_from_bytes(data)?;
let amount = u64::from_le_bytes(args.amount);
// Load accounts.
let [signer_info, miner_info, sender_info, treasury_info, treasury_tokens_info, token_program] =
accounts
else {
return Err(ProgramError::NotEnoughAccountKeys);
};
signer_info.is_signer()?;
let miner = miner_info
.as_account_mut::<Miner>(&ore_api::ID)?
.assert_mut(|m| m.authority == *signer_info.key)?;
sender_info.as_associated_token_account(&signer_info.key, &MINT_ADDRESS)?;
let treasury = treasury_info.as_account_mut::<Treasury>(&ore_api::ID)?;
treasury_tokens_info.as_associated_token_account(&treasury_info.key, &MINT_ADDRESS)?;
token_program.is_program(&spl_token::ID)?;
// Update account state.
miner.stake += amount;
treasury.total_stake += amount;
// Execute transfer.
transfer(
signer_info,
sender_info,
treasury_tokens_info,
token_program,
amount,
)?;
Ok(())
}

31
program/src/free.rs
View File

@@ -0,0 +1,31 @@
use ore_api::prelude::*;
use steel::*;
/// Free up capacity.
pub fn process_free(accounts: &[AccountInfo<'_>], _data: &[u8]) -> ProgramResult {
// Load accounts.
let clock = Clock::get()?;
let [signer_info, miner_info, receipt_info] = accounts else {
return Err(ProgramError::NotEnoughAccountKeys);
};
signer_info.is_signer()?;
let miner = miner_info
.as_account_mut::<Miner>(&ore_api::ID)?
.assert_mut(|m| m.authority == *signer_info.key)?;
let receipt = receipt_info
.as_account_mut::<Receipt>(&ore_api::ID)?
.assert_mut(|r| r.authority == *signer_info.key)?;
// Asset that block has ended.
let start_slot = 1500 * receipt.block_id;
let end_slot = start_slot + 1500;
assert!(clock.slot >= end_slot, "Block has not yet closed.");
// Free up miner capacity.
miner.deployed -= receipt.amount;
// Close the receipt.
receipt_info.close(signer_info)?;
Ok(())
}

11
program/src/lib.rs
View File

@@ -27,10 +27,19 @@ pub fn process_instruction(
let (ix, data) = parse_instruction(&ore_api::ID, program_id, data)?;
match ix {
// Mine
OreInstruction::Open => process_open(accounts, data)?,
OreInstruction::Close => process_close(accounts, data)?,
OreInstruction::Mine => process_mine(accounts, data)?,
_ => panic!("Not implemented"),
// Stake
OreInstruction::Deposit => process_deposit(accounts, data)?,
OreInstruction::Withdraw => process_withdraw(accounts, data)?,
OreInstruction::Free => process_free(accounts, data)?,
// Trade
OreInstruction::Buy => process_buy(accounts, data)?,
OreInstruction::Sell => process_sell(accounts, data)?,
}
Ok(())

2
program/src/mine.rs
View File

@@ -2,7 +2,7 @@ use ore_api::prelude::*;
use solana_program::keccak;
use steel::*;
/// Opens a new block for hashpower trading.
/// Mine a block.
pub fn process_mine(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResult {
// Parse data.
let args = Mine::try_from_bytes(data)?;

116
program/src/open.rs
View File

@@ -1,14 +1,15 @@
use ore_api::prelude::*;
use solana_program::program_pack::Pack;
use steel::*;
/// Opens a new block for hashpower trading.
/// Opens a new block.
pub fn process_open(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResult {
// Parse data.
let args = Open::try_from_bytes(data)?;
let id = u64::from_le_bytes(args.id);
// Load accounts.
let [signer_info, block_info, system_program, token_program, associated_token_program] =
let [signer_info, block_info, market_info, market_hash_info, market_ore_info, mint_hash_info, mint_ore_info, system_program, token_program, associated_token_program, rent_sysvar] =
accounts
else {
return Err(ProgramError::NotEnoughAccountKeys);
@@ -18,9 +19,19 @@ pub fn process_open(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResult
.is_empty()?
.is_writable()?
.has_seeds(&[BLOCK, &id.to_le_bytes()], &ore_api::ID)?;
market_info
.is_empty()?
.is_writable()?
.has_seeds(&[MARKET, &id.to_le_bytes()], &ore_api::ID)?;
mint_hash_info
.is_empty()?
.is_writable()?
.has_seeds(&[MINT, &id.to_le_bytes()], &ore_api::ID)?;
mint_ore_info.has_address(&MINT_ADDRESS)?.as_mint()?;
system_program.is_program(&system_program::ID)?;
token_program.is_program(&spl_token::ID)?;
associated_token_program.is_program(&spl_associated_token_account::ID)?;
rent_sysvar.is_sysvar(&sysvar::rent::ID)?;
// Initialize config.
create_program_account::<Block>(
@@ -38,30 +49,85 @@ pub fn process_open(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResult
block.slot_hash = [0; 32];
block.start_slot = 1500 * id;
// TODO Init market
// TODO Init hash token mint
// TODO Init token accounts for market
// TODO Init mint hash tokens to market
// Initialize market.
create_program_account::<Market>(
market_info,
system_program,
signer_info,
&ore_api::ID,
&[MARKET, &id.to_le_bytes()],
)?;
let market = market_info.as_account_mut::<Market>(&ore_api::ID)?;
market.id = id;
// // Initialize block token accounts.
// create_associated_token_account(
// signer_info,
// block_info,
// block_commits_info,
// sol_mint_info,
// system_program,
// token_program,
// associated_token_program,
// )?;
// create_associated_token_account(
// signer_info,
// block_info,
// block_ore_info,
// ore_mint_info,
// system_program,
// token_program,
// associated_token_program,
// )?;
// Initialize hash token mint.
allocate_account(
mint_hash_info,
system_program,
signer_info,
spl_token::state::Mint::LEN,
&spl_token::ID,
&[MINT, &id.to_le_bytes()],
)?;
initialize_mint_signed(
mint_hash_info,
block_info,
None,
token_program,
rent_sysvar,
0,
&[MINT, &id.to_le_bytes()],
)?;
// TODO Initialize hash token metadata.
// Initialize token accounts for market.
if market_hash_info.data_is_empty() {
create_associated_token_account(
signer_info,
market_info,
market_hash_info,
mint_hash_info,
system_program,
token_program,
associated_token_program,
)?;
} else {
market_hash_info.as_associated_token_account(market_info.key, mint_hash_info.key)?;
}
if market_ore_info.data_is_empty() {
create_associated_token_account(
signer_info,
market_info,
market_ore_info,
mint_ore_info,
system_program,
token_program,
associated_token_program,
)?;
} else {
market_ore_info.as_associated_token_account(market_info.key, mint_ore_info.key)?;
}
// Mint hash tokens to market.
mint_to_signed(
mint_hash_info,
market_hash_info,
block_info,
token_program,
10_000_000,
&[BLOCK, &id.to_le_bytes()],
)?;
// Burn mint authority.
set_authority_signed(
mint_hash_info,
block_info,
None,
spl_token_2022::instruction::AuthorityType::MintTokens,
token_program,
&[BLOCK, &id.to_le_bytes()],
)?;
Ok(())
}

23
program/src/sell.rs
View File

@@ -0,0 +1,23 @@
use ore_api::prelude::*;
use steel::*;
/// Sell hashpower.
pub fn process_sell(accounts: &[AccountInfo<'_>], _data: &[u8]) -> ProgramResult {
// Load accounts.
let clock = Clock::get()?;
let [signer_info, block_info, market_info, miner_info, recipient_info, system_program, token_program] =
accounts
else {
return Err(ProgramError::NotEnoughAccountKeys);
};
signer_info.is_signer()?;
let block = block_info
.as_account_mut::<Block>(&ore_api::ID)?
.assert_mut(|b| clock.slot >= b.start_slot + 1500)?;
system_program.is_program(&system_program::ID)?;
token_program.is_program(&spl_token::ID)?;
// TODO Buy hash tokens
Ok(())
}

46
program/src/withdraw.rs
View File

@@ -0,0 +1,46 @@
use ore_api::prelude::*;
use steel::*;
/// Withdraws stake.
pub fn process_withdraw(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResult {
// Parse data.
let args = Withdraw::try_from_bytes(data)?;
let amount = u64::from_le_bytes(args.amount);
// Load accounts.
let [signer_info, miner_info, recipient_info, treasury_info, treasury_tokens_info, token_program] =
accounts
else {
return Err(ProgramError::NotEnoughAccountKeys);
};
signer_info.is_signer()?;
let miner = miner_info
.as_account_mut::<Miner>(&ore_api::ID)?
.assert_mut(|m| m.authority == *signer_info.key)?;
recipient_info.as_associated_token_account(&signer_info.key, &MINT_ADDRESS)?;
let treasury = treasury_info.as_account_mut::<Treasury>(&ore_api::ID)?;
treasury_tokens_info.as_associated_token_account(&treasury_info.key, &MINT_ADDRESS)?;
token_program.is_program(&spl_token::ID)?;
// Update account state.
miner.stake -= amount;
treasury.total_stake -= amount;
// Asset miner has enough stake to cover the withdrawal.
assert!(
miner.stake >= miner.deployed,
"Withdrawal cannot reduce capacity below deployment levels."
);
// Execute transfer.
transfer_signed(
signer_info,
treasury_tokens_info,
recipient_info,
token_program,
amount,
&[TREASURY],
)?;
Ok(())
}