add tests for init market, update config, deposit and withdraw

Cargo.toml

@@ -21,3 +21,13 @@ litesvm = "0.10.0"
 solana-sdk = "3.0.0"
 litesvm-token = "0.10.0"
 spl-associated-token-account = "8.0.0"
+
+solana-instruction = "3.1.0"
+solana-keypair = "3.1.0"
+solana-native-token = "3.0.0"
+solana-pubkey = "4.1.0"
+solana-signer = "3.0.0"
+solana-transaction = "3.0.2"
+solana-message = "3.0.1"
+solana-sdk-ids = "3.1.0"
+spl-token = { version = "9.0.0", features = ["no-entrypoint"]}

src/lib.rs

@@ -4,4 +4,6 @@ pub mod constants;
 pub mod instructions;
 pub mod math;
 pub mod state;
+#[cfg(test)]
+pub mod tests;
 pub mod utils;

src/tests/deposit.rs

@@ -0,0 +1,124 @@
+use super::helpers::program_id;
+use crate::{
+    instructions::DepositArgs,
+    tests::helpers::{MarketSetup, setup_market},
+};
+use litesvm_token::{MintTo, TOKEN_ID as TOKEN_PROGRAM_ID};
+use solana_instruction::{AccountMeta, Instruction};
+use solana_keypair::Keypair;
+use solana_message::Message;
+use solana_signer::Signer;
+use solana_transaction::Transaction;
+use spl_token::solana_program::program_pack::Pack;
+
+#[test]
+fn test_deposit() {
+    let MarketSetup {
+        mut svm,
+        admin,
+        config_pda,
+        mint,
+        vault,
+        maker_ata,
+        ..
+    } = setup_market(1_000, 100, 400, 200);
+
+    let deposit_amount = 500_000_000u64;
+    MintTo::new(&mut svm, &admin, &mint, &maker_ata, 1_000_000_000)
+        .send()
+        .unwrap();
+
+    let deposit_args = DepositArgs {
+        amount: deposit_amount,
+    };
+
+    let mut deposit_data = vec![3u8];
+    deposit_data.extend_from_slice(unsafe {
+        core::slice::from_raw_parts(
+            &deposit_args as *const _ as *const u8,
+            core::mem::size_of::<DepositArgs>(),
+        )
+    });
+
+    let deposit_ix = Instruction {
+        program_id: program_id(),
+        accounts: vec![
+            AccountMeta::new(admin.pubkey(), true),
+            AccountMeta::new(config_pda, false),
+            AccountMeta::new(maker_ata, false),
+            AccountMeta::new(vault, false),
+            AccountMeta::new(TOKEN_PROGRAM_ID, false),
+        ],
+        data: deposit_data,
+    };
+
+    let msg = Message::new(&[deposit_ix], Some(&admin.pubkey()));
+
+    let tx = svm
+        .send_transaction(Transaction::new(&[&admin], msg, svm.latest_blockhash()))
+        .unwrap();
+
+    println!("{:<12} | {:>6} CUs", "deposit", tx.compute_units_consumed);
+
+    let vault_acc = svm.get_account(&vault).unwrap();
+    let vault_data = spl_token::state::Account::unpack(&vault_acc.data).unwrap();
+    assert_eq!(vault_data.amount, deposit_amount);
+}
+
+#[test]
+#[should_panic]
+fn test_deposit_unauthorized() {
+    let MarketSetup {
+        mut svm,
+        config_pda,
+        mint,
+        vault,
+        admin,
+        ..
+    } = setup_market(1_000, 100, 400, 200);
+
+    let unauthorized_user = Keypair::new();
+    svm.airdrop(&unauthorized_user.pubkey(), 1_000_000_000)
+        .unwrap();
+
+    let unauthorized_ata =
+        litesvm_token::CreateAssociatedTokenAccount::new(&mut svm, &unauthorized_user, &mint)
+            .owner(&unauthorized_user.pubkey())
+            .send()
+            .unwrap();
+
+    MintTo::new(&mut svm, &admin, &mint, &unauthorized_ata, 1_000_000_000)
+        .send()
+        .unwrap();
+
+    let deposit_args = DepositArgs {
+        amount: 100_000_000,
+    };
+
+    let mut deposit_data = vec![3u8];
+    deposit_data.extend_from_slice(unsafe {
+        core::slice::from_raw_parts(
+            &deposit_args as *const _ as *const u8,
+            core::mem::size_of::<DepositArgs>(),
+        )
+    });
+
+    let deposit_ix = Instruction {
+        program_id: program_id(),
+        accounts: vec![
+            AccountMeta::new(unauthorized_user.pubkey(), true),
+            AccountMeta::new(config_pda, false),
+            AccountMeta::new(unauthorized_ata, false),
+            AccountMeta::new(vault, false),
+            AccountMeta::new(TOKEN_PROGRAM_ID, false),
+        ],
+        data: deposit_data,
+    };
+
+    svm.send_transaction(Transaction::new(
+        &[&unauthorized_user],
+        Message::new(&[deposit_ix], Some(&unauthorized_user.pubkey())),
+        svm.latest_blockhash(),
+    ))
+    .unwrap();
+}

src/tests/helpers.rs

@@ -0,0 +1,201 @@
+use std::path::PathBuf;
+
+use litesvm::LiteSVM;
+use litesvm_token::{
+    CreateAssociatedTokenAccount, CreateMint, MintTo, TOKEN_ID as TOKEN_PROGRAM_ID,
+};
+use solana_keypair::Keypair;
+use solana_message::{AccountMeta, Instruction, Message};
+use solana_native_token::LAMPORTS_PER_SOL;
+use solana_pubkey::Pubkey;
+use solana_signer::Signer;
+use solana_transaction::Transaction;
+
+use crate::instructions::{DepositArgs, InitializeMarketArgs};
+
+pub fn program_id() -> Pubkey {
+    Pubkey::from_str_const("9FmdmGsrkXuhiLZYPD25BctczFmT5DQkpvKekA6v9tPh")
+}
+
+pub fn load_svm() -> (LiteSVM, Keypair) {
+    let mut svm = LiteSVM::new();
+    let payer = Keypair::new();
+
+    svm.airdrop(&payer.pubkey(), 10 * LAMPORTS_PER_SOL).unwrap();
+
+    let so_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("target/sbpf-solana-solana/release/enclave.so");
+
+    let program_data = std::fs::read(so_path).expect("Failed to read program SO file");
+    svm.add_program(program_id(), &program_data).unwrap();
+
+    (svm, payer)
+}
+
+pub struct MarketSetup {
+    pub svm: LiteSVM,
+    pub admin: Keypair,
+    pub config_pda: Pubkey,
+    pub vault: Pubkey,
+    pub mint: Pubkey,
+    pub maker_ata: Pubkey,
+    pub init_cu: u64,
+}
+
+pub fn setup_market(
+    target_inventory: u64,
+    risk_aversion: u64,
+    variance: u64,
+    spread_factor: u64,
+) -> MarketSetup {
+    let (mut svm, admin) = load_svm();
+    let (config_pda, bump) = Pubkey::find_program_address(&[b"maker_config"], &program_id());
+
+    let mint = CreateMint::new(&mut svm, &admin)
+        .decimals(6)
+        .authority(&admin.pubkey())
+        .send()
+        .unwrap();
+
+    let maker_ata = CreateAssociatedTokenAccount::new(&mut svm, &admin, &mint)
+        .owner(&admin.pubkey())
+        .send()
+        .unwrap();
+
+    let vault = CreateAssociatedTokenAccount::new(&mut svm, &admin, &mint)
+        .owner(&config_pda)
+        .send()
+        .unwrap();
+
+    let args = InitializeMarketArgs {
+        target_inventory,
+        risk_aversion,
+        variance,
+        spread_factor,
+        bump,
+    };
+
+    let mut data = vec![1u8];
+    data.extend_from_slice(unsafe {
+        core::slice::from_raw_parts(
+            &args as *const _ as *const u8,
+            core::mem::size_of::<InitializeMarketArgs>(),
+        )
+    });
+
+    let ix = Instruction {
+        program_id: program_id(),
+        accounts: vec![
+            AccountMeta::new(admin.pubkey(), true),
+            AccountMeta::new(config_pda, false),
+            AccountMeta::new(solana_sdk_ids::system_program::ID, false),
+        ],
+        data,
+    };
+
+    let msg = Message::new(&[ix], Some(&admin.pubkey()));
+    let blockhash = svm.latest_blockhash();
+    let tx = svm
+        .send_transaction(Transaction::new(&[&admin], msg, blockhash))
+        .unwrap();
+
+    MarketSetup {
+        svm,
+        admin,
+        config_pda,
+        vault,
+        mint,
+        maker_ata,
+        init_cu: tx.compute_units_consumed,
+    }
+}
+
+pub fn setup_market_and_deposit(amount: u64) -> MarketSetup {
+    let (mut svm, admin) = load_svm();
+    let admin_pubkey = admin.pubkey();
+    let (config_pda, bump) = Pubkey::find_program_address(&[b"maker_config"], &program_id());
+
+    let mint = CreateMint::new(&mut svm, &admin)
+        .decimals(6)
+        .authority(&admin_pubkey)
+        .send()
+        .unwrap();
+    let maker_ata = CreateAssociatedTokenAccount::new(&mut svm, &admin, &mint)
+        .owner(&admin_pubkey)
+        .send()
+        .unwrap();
+    let vault = CreateAssociatedTokenAccount::new(&mut svm, &admin, &mint)
+        .owner(&config_pda)
+        .send()
+        .unwrap();
+
+    MintTo::new(&mut svm, &admin, &mint, &maker_ata, amount)
+        .send()
+        .unwrap();
+
+    let init_args = InitializeMarketArgs {
+        target_inventory: amount,
+        risk_aversion: 100,
+        variance: 400,
+        spread_factor: 200,
+        bump,
+    };
+
+    let mut init_data = vec![1u8];
+    init_data.extend_from_slice(unsafe {
+        core::slice::from_raw_parts(
+            &init_args as *const _ as *const u8,
+            core::mem::size_of::<InitializeMarketArgs>(),
+        )
+    });
+
+    let deposit_args = DepositArgs { amount };
+    let mut deposit_data = vec![3u8];
+    deposit_data.extend_from_slice(unsafe {
+        core::slice::from_raw_parts(
+            &deposit_args as *const _ as *const u8,
+            core::mem::size_of::<DepositArgs>(),
+        )
+    });
+
+    let ixs = [
+        Instruction {
+            program_id: program_id(),
+            accounts: vec![
+                AccountMeta::new(admin_pubkey, true),
+                AccountMeta::new(config_pda, false),
+                AccountMeta::new(solana_sdk_ids::system_program::ID, false),
+            ],
+            data: init_data,
+        },
+        Instruction {
+            program_id: program_id(),
+            accounts: vec![
+                AccountMeta::new(admin_pubkey, true),
+                AccountMeta::new(config_pda, false),
+                AccountMeta::new(maker_ata, false),
+                AccountMeta::new(vault, false),
+                AccountMeta::new(TOKEN_PROGRAM_ID, false),
+            ],
+            data: deposit_data,
+        },
+    ];
+
+    let tx = svm
+        .send_transaction(Transaction::new(
+            &[&admin],
+            Message::new(&ixs, Some(&admin_pubkey)),
+            svm.latest_blockhash(),
+        ))
+        .unwrap();
+
+    MarketSetup {
+        svm,
+        admin,
+        config_pda,
+        vault,
+        mint,
+        maker_ata,
+        init_cu: tx.compute_units_consumed,
+    }
+}