mask

program/Cargo.toml

@@ -19,6 +19,7 @@ default = []
 
 [dependencies]
 bincode.workspace = true
+meteora-pools-sdk.workspace = true
 mpl-token-metadata.workspace = true
 ore-api.workspace = true
 solana-nostd-keccak.workspace = true

program/src/bury.rs

@@ -0,0 +1,80 @@
+use meteora_pools_sdk::instructions::SwapInstructionArgs;
+use ore_api::prelude::*;
+use steel::*;
+
+/// Redeem ORE for SOL backing.
+pub fn process_redeem(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResult {
+    // Parse data.
+    let args = Bury::try_from_bytes(data)?;
+    let min_amount_out = u64::from_le_bytes(args.min_amount_out);
+
+    // Load accounts.
+    let [ore_accounts, meteora_accounts] = accounts.split_at(6);
+    let [signer_info, config_info, mint_info, treasury_info, system_program, token_program] =
+        ore_accounts
+    else {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    };
+    signer_info.is_signer()?;
+    let config = config_info
+        .as_account::<Config>(&ore_api::ID)?
+        .assert_mut(|c| c.admin == *signer_info.key)?;
+    let mint = mint_info.has_address(&MINT_ADDRESS)?.as_mint()?;
+    let treasury = treasury_info.as_account_mut::<Treasury>(&ore_api::ID)?;
+    system_program.is_program(&system_program::ID)?;
+    token_program.is_program(&spl_token::ID)?;
+
+    let [pool, user_source_token, user_destination_token, a_vault, b_vault, a_token_vault, b_token_vault, a_vault_lp_mint, b_vault_lp_mint, a_vault_lp, b_vault_lp, protocol_token_fee, vault_program] =
+        meteora_accounts
+    else {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    };
+
+    // Execute swap from SOL to ORE in Meteora
+    let swap = meteora_pools_sdk::instructions::Swap {
+        pool: *pool.key,
+        user_source_token: *user_source_token.key,
+        user_destination_token: *user_destination_token.key,
+        a_vault: *a_vault.key,
+        b_vault: *b_vault.key,
+        a_token_vault: *a_token_vault.key,
+        b_token_vault: *b_token_vault.key,
+        a_vault_lp_mint: *a_vault_lp_mint.key,
+        b_vault_lp_mint: *b_vault_lp_mint.key,
+        a_vault_lp: *a_vault_lp.key,
+        b_vault_lp: *b_vault_lp.key,
+        protocol_token_fee: *protocol_token_fee.key,
+        user: *user.key,
+        vault_program: *vault_program.key,
+        token_program: *token_program.key,
+        b_token_vault: *b_token_vault.key,
+        a_vault_lp_mint: *a_vault_lp_mint.key,
+        b_vault_lp_mint: *b_vault_lp_mint.key,
+        a_vault_lp: *a_vault_lp.key,
+        b_vault_lp: *b_vault_lp.key,
+        protocol_token_fee: *protocol_token_fee.key,
+        user: *user.key,
+        vault_program: *vault_program.key,
+        token_program: *token_program.key,
+    }
+    .instruction_with_remaining_accounts(
+        SwapInstructionArgs {
+            in_amount: treasury.balance,
+            minimum_out_amount: min_amount_out,
+        },
+        &meteora_accounts,
+    );
+
+    // Burn ORE.
+    burn(sender_info, mint_info, signer_info, token_program, amount)?;
+
+    // // Transfer SOL to recipient.
+    // assert!(
+    //     treasury.balance >= redemption_amount,
+    //     "Redemption too large"
+    // );
+    // treasury_info.send(redemption_amount, signer_info);
+    // treasury.balance -= redemption_amount;
+
+    Ok(())
+}

program/src/deploy.rs

@@ -8,7 +8,13 @@ pub fn process_deploy(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResul
     // Parse data.
     let args = Deploy::try_from_bytes(data)?;
     let amount = u64::from_le_bytes(args.amount);
-    let square_id = usize::from_le_bytes(args.square_id);
+    let mask = u32::from_le_bytes(args.squares);
+
+    // Parse squares.
+    let mut squares = [false; 25];
+    for i in 0..25 {
+        squares[i] = (mask & (1 << i)) != 0;
+    }
 
     // Load accounts.
     let clock = Clock::get()?;
@@ -94,23 +100,36 @@ pub fn process_deploy(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResul
     let fee = amount / 100;
     let amount = amount - fee;
 
-    // Update miner
-    let is_first_move = miner.deployed[square_id] == 0;
-    miner.deployed[square_id] += amount;
+    // Make all deployments.
+    let mut total_fee = 0;
+    let mut total_amount = 0;
+    for (square_id, &should_deploy) in squares.iter().enumerate() {
+        if square_id > 24 {
+            break;
+        }
+        if should_deploy {
+            total_fee += fee;
+            total_amount += amount;
 
-    // Update square
-    if is_first_move {
-        square.miners[square_id][square.count[square_id] as usize] = *signer_info.key;
-        square.count[square_id] += 1;
+            // Update miner
+            let is_first_move = miner.deployed[square_id] == 0;
+            miner.deployed[square_id] += amount;
+
+            // Update square
+            if is_first_move {
+                square.miners[square_id][square.count[square_id] as usize] = *signer_info.key;
+                square.count[square_id] += 1;
+            }
+
+            // Update board
+            board.deployed[square_id] += amount;
+            board.total_deployed += amount;
+        }
     }
 
-    // Update board
-    board.deployed[square_id] += amount;
-    board.total_deployed += amount;
-
     // Transfer deployed.
-    board_info.collect(amount, &signer_info)?;
-    fee_collector_info.collect(fee, &signer_info)?;
+    board_info.collect(total_amount, &signer_info)?;
+    fee_collector_info.collect(total_fee, &signer_info)?;
 
     Ok(())
 }

program/src/lib.rs

@@ -1,4 +1,5 @@
 mod boost;
+// mod bury;
 mod claim_ore;
 mod claim_seeker;
 mod claim_sol;
@@ -11,6 +12,7 @@ mod set_fee_collector;
 mod whitelist;
 
 use boost::*;
+// use bury::*;
 use claim_ore::*;
 use claim_seeker::*;
 use claim_sol::*;

program/src/redeem.rs

@@ -1,41 +0,0 @@
-use ore_api::prelude::*;
-use steel::*;
-
-/// Redeem ORE for SOL backing.
-pub fn process_redeem(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramResult {
-    // Parse data.
-    let args = Redeem::try_from_bytes(data)?;
-    let amount = u64::from_le_bytes(args.amount);
-
-    // Load accounts.
-    let [signer_info, mint_info, sender_info, treasury_info, system_program, token_program] =
-        accounts
-    else {
-        return Err(ProgramError::NotEnoughAccountKeys);
-    };
-    signer_info.is_signer()?;
-    let mint = mint_info.has_address(&MINT_ADDRESS)?.as_mint()?;
-    let sender = sender_info.as_associated_token_account(&signer_info.key, &mint_info.key)?;
-    let treasury = treasury_info.as_account_mut::<Treasury>(&ore_api::ID)?;
-    system_program.is_program(&system_program::ID)?;
-    token_program.is_program(&spl_token::ID)?;
-
-    // Normalize amount.
-    let amount = amount.min(sender.amount());
-
-    // Load redemption amount.
-    let redemption_amount = treasury.balance * amount / mint.supply();
-
-    // Burn ORE.
-    burn(sender_info, mint_info, signer_info, token_program, amount)?;
-
-    // Transfer SOL to recipient.
-    assert!(
-        treasury.balance >= redemption_amount,
-        "Redemption too large"
-    );
-    treasury_info.send(redemption_amount, signer_info);
-    treasury.balance -= redemption_amount;
-
-    Ok(())
-}