scaffolding

program/Cargo.toml

@@ -25,6 +25,7 @@ ore-api.workspace = true
 ore-boost-api.workspace = true
 solana-program.workspace = true
 spl-token.workspace = true
+spl-token-2022.workspace = true
 spl-associated-token-account.workspace = true
 steel.workspace = true
 

program/src/buy.rs

@@ -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(())
+}

program/src/close.rs

@@ -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(())
+}

program/src/deposit.rs

@@ -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(())
+}

program/src/free.rs

@@ -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(())
+}

program/src/lib.rs

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

program/src/mine.rs

@@ -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)?;

program/src/open.rs

@@ -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(())
 }

program/src/sell.rs

@@ -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(())
+}

program/src/withdraw.rs

@@ -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(())
+}