diff --git a/tokens/escrow/quasar/src/instructions/cancel_offer.rs b/tokens/escrow/quasar/src/instructions/cancel_offer.rs new file mode 100644 index 000000000..11d222163 --- /dev/null +++ b/tokens/escrow/quasar/src/instructions/cancel_offer.rs @@ -0,0 +1,55 @@ +use { + crate::state::Offer, + quasar_lang::prelude::*, + quasar_spl::prelude::*, +}; + +#[derive(Accounts)] +pub struct CancelOffer { + #[account(mut)] + pub maker: Signer, + #[account( + mut, + has_one(maker), + close(dest = maker), + address = Offer::seeds(maker.address()) + )] + pub offer: Account, + pub token_mint_a: Account, + #[account( + mut, + init(idempotent), + payer = maker, + token(mint = token_mint_a, authority = maker, token_program = token_program), + )] + pub maker_token_account_a: Account, + #[account(mut)] + pub vault: Account, + pub rent: Sysvar, + pub token_program: Program, + pub system_program: Program, +} + +#[inline(always)] +pub fn handle_withdraw_tokens_and_close_cancel_offer(accounts: &mut CancelOffer, bumps: &CancelOfferBumps) -> Result<(), ProgramError> { + let bump = [bumps.offer]; + let seeds = [ + Seed::from(b"offer" as &[u8]), + Seed::from(accounts.maker.address().as_ref()), + Seed::from(bump.as_ref()), + ]; + + accounts.token_program + .transfer( + &accounts.vault, + &accounts.maker_token_account_a, + &accounts.offer, + accounts.vault.amount(), + ) + .invoke_signed(&seeds)?; + + accounts.token_program + .close_account(&accounts.vault, &accounts.maker, &accounts.offer) + .invoke_signed(&seeds)?; + Ok(()) +} diff --git a/tokens/escrow/quasar/src/instructions/make.rs b/tokens/escrow/quasar/src/instructions/make.rs deleted file mode 100644 index 8c298e365..000000000 --- a/tokens/escrow/quasar/src/instructions/make.rs +++ /dev/null @@ -1,54 +0,0 @@ -use { - crate::state::{Escrow, EscrowInner}, - quasar_lang::prelude::*, - quasar_spl::prelude::*, -}; - -#[derive(Accounts)] -pub struct Make { - #[account(mut)] - pub maker: Signer, - #[account(mut, init, payer = maker, address = Escrow::seeds(maker.address()))] - pub escrow: Account, - pub mint_a: Account, - pub mint_b: Account, - #[account(mut)] - pub maker_ta_a: Account, - #[account( - mut, - init(idempotent), - payer = maker, - token(mint = mint_b, authority = maker, token_program = token_program), - )] - pub maker_ta_b: Account, - #[account( - mut, - init(idempotent), - payer = maker, - token(mint = mint_a, authority = escrow, token_program = token_program), - )] - pub vault_ta_a: Account, - pub rent: Sysvar, - pub token_program: Program, - pub system_program: Program, -} - -#[inline(always)] -pub fn handle_make_escrow(accounts: &mut Make, receive: u64, bumps: &MakeBumps) -> Result<(), ProgramError> { - accounts.escrow.set_inner(EscrowInner { - maker: *accounts.maker.address(), - mint_a: *accounts.mint_a.address(), - mint_b: *accounts.mint_b.address(), - maker_ta_b: *accounts.maker_ta_b.address(), - receive, - bump: bumps.escrow, - }); - Ok(()) -} - -#[inline(always)] -pub fn handle_deposit_tokens(accounts: &mut Make, amount: u64) -> Result<(), ProgramError> { - accounts.token_program - .transfer(&accounts.maker_ta_a, &accounts.vault_ta_a, &accounts.maker, amount) - .invoke() -} diff --git a/tokens/escrow/quasar/src/instructions/make_offer.rs b/tokens/escrow/quasar/src/instructions/make_offer.rs new file mode 100644 index 000000000..7def1c214 --- /dev/null +++ b/tokens/escrow/quasar/src/instructions/make_offer.rs @@ -0,0 +1,54 @@ +use { + crate::state::{Offer, OfferInner}, + quasar_lang::prelude::*, + quasar_spl::prelude::*, +}; + +#[derive(Accounts)] +pub struct MakeOffer { + #[account(mut)] + pub maker: Signer, + #[account(mut, init, payer = maker, address = Offer::seeds(maker.address()))] + pub offer: Account, + pub token_mint_a: Account, + pub token_mint_b: Account, + #[account(mut)] + pub maker_token_account_a: Account, + #[account( + mut, + init(idempotent), + payer = maker, + token(mint = token_mint_b, authority = maker, token_program = token_program), + )] + pub maker_token_account_b: Account, + #[account( + mut, + init(idempotent), + payer = maker, + token(mint = token_mint_a, authority = offer, token_program = token_program), + )] + pub vault: Account, + pub rent: Sysvar, + pub token_program: Program, + pub system_program: Program, +} + +#[inline(always)] +pub fn handle_make_offer(accounts: &mut MakeOffer, receive: u64, bumps: &MakeOfferBumps) -> Result<(), ProgramError> { + accounts.offer.set_inner(OfferInner { + maker: *accounts.maker.address(), + token_mint_a: *accounts.token_mint_a.address(), + token_mint_b: *accounts.token_mint_b.address(), + maker_token_account_b: *accounts.maker_token_account_b.address(), + receive, + bump: bumps.offer, + }); + Ok(()) +} + +#[inline(always)] +pub fn handle_deposit_tokens(accounts: &mut MakeOffer, amount: u64) -> Result<(), ProgramError> { + accounts.token_program + .transfer(&accounts.maker_token_account_a, &accounts.vault, &accounts.maker, amount) + .invoke() +} diff --git a/tokens/escrow/quasar/src/instructions/mod.rs b/tokens/escrow/quasar/src/instructions/mod.rs index 29eaa13a6..2567ff99c 100644 --- a/tokens/escrow/quasar/src/instructions/mod.rs +++ b/tokens/escrow/quasar/src/instructions/mod.rs @@ -1,8 +1,8 @@ -pub mod make; -pub use make::*; +pub mod make_offer; +pub use make_offer::*; -pub mod take; -pub use take::*; +pub mod take_offer; +pub use take_offer::*; -pub mod refund; -pub use refund::*; +pub mod cancel_offer; +pub use cancel_offer::*; diff --git a/tokens/escrow/quasar/src/instructions/refund.rs b/tokens/escrow/quasar/src/instructions/refund.rs deleted file mode 100644 index 03403e8a9..000000000 --- a/tokens/escrow/quasar/src/instructions/refund.rs +++ /dev/null @@ -1,55 +0,0 @@ -use { - crate::state::Escrow, - quasar_lang::prelude::*, - quasar_spl::prelude::*, -}; - -#[derive(Accounts)] -pub struct Refund { - #[account(mut)] - pub maker: Signer, - #[account( - mut, - has_one(maker), - close(dest = maker), - address = Escrow::seeds(maker.address()) - )] - pub escrow: Account, - pub mint_a: Account, - #[account( - mut, - init(idempotent), - payer = maker, - token(mint = mint_a, authority = maker, token_program = token_program), - )] - pub maker_ta_a: Account, - #[account(mut)] - pub vault_ta_a: Account, - pub rent: Sysvar, - pub token_program: Program, - pub system_program: Program, -} - -#[inline(always)] -pub fn handle_withdraw_tokens_and_close_refund(accounts: &mut Refund, bumps: &RefundBumps) -> Result<(), ProgramError> { - let bump = [bumps.escrow]; - let seeds = [ - Seed::from(b"escrow" as &[u8]), - Seed::from(accounts.maker.address().as_ref()), - Seed::from(bump.as_ref()), - ]; - - accounts.token_program - .transfer( - &accounts.vault_ta_a, - &accounts.maker_ta_a, - &accounts.escrow, - accounts.vault_ta_a.amount(), - ) - .invoke_signed(&seeds)?; - - accounts.token_program - .close_account(&accounts.vault_ta_a, &accounts.maker, &accounts.escrow) - .invoke_signed(&seeds)?; - Ok(()) -} diff --git a/tokens/escrow/quasar/src/instructions/take.rs b/tokens/escrow/quasar/src/instructions/take.rs deleted file mode 100644 index b95176aac..000000000 --- a/tokens/escrow/quasar/src/instructions/take.rs +++ /dev/null @@ -1,81 +0,0 @@ -use { - crate::state::Escrow, - quasar_lang::prelude::*, - quasar_spl::prelude::*, -}; - -#[derive(Accounts)] -pub struct Take { - #[account(mut)] - pub taker: Signer, - #[account( - mut, - has_one(maker), - has_one(maker_ta_b), - constraints(escrow.receive > 0), - close(dest = taker), - address = Escrow::seeds(maker.address()) - )] - pub escrow: Account, - #[account(mut)] - pub maker: UncheckedAccount, - pub mint_a: Account, - pub mint_b: Account, - #[account( - mut, - init(idempotent), - payer = taker, - token(mint = mint_a, authority = taker, token_program = token_program), - )] - pub taker_ta_a: Account, - #[account(mut)] - pub taker_ta_b: Account, - #[account( - mut, - init(idempotent), - payer = taker, - token(mint = mint_b, authority = maker, token_program = token_program), - )] - pub maker_ta_b: Account, - #[account(mut)] - pub vault_ta_a: Account, - pub rent: Sysvar, - pub token_program: Program, - pub system_program: Program, -} - -#[inline(always)] -pub fn handle_transfer_tokens(accounts: &mut Take) -> Result<(), ProgramError> { - accounts.token_program - .transfer( - &accounts.taker_ta_b, - &accounts.maker_ta_b, - &accounts.taker, - accounts.escrow.receive, - ) - .invoke() -} - -#[inline(always)] -pub fn handle_withdraw_tokens_and_close_take(accounts: &mut Take, bumps: &TakeBumps) -> Result<(), ProgramError> { - let bump = [bumps.escrow]; - let seeds = [ - Seed::from(b"escrow" as &[u8]), - Seed::from(accounts.maker.address().as_ref()), - Seed::from(bump.as_ref()), - ]; - - accounts.token_program - .transfer( - &accounts.vault_ta_a, - &accounts.taker_ta_a, - &accounts.escrow, - accounts.vault_ta_a.amount(), - ) - .invoke_signed(&seeds)?; - - accounts.token_program - .close_account(&accounts.vault_ta_a, &accounts.taker, &accounts.escrow) - .invoke_signed(&seeds)?; - Ok(()) -} diff --git a/tokens/escrow/quasar/src/instructions/take_offer.rs b/tokens/escrow/quasar/src/instructions/take_offer.rs new file mode 100644 index 000000000..a6c0c9079 --- /dev/null +++ b/tokens/escrow/quasar/src/instructions/take_offer.rs @@ -0,0 +1,81 @@ +use { + crate::state::Offer, + quasar_lang::prelude::*, + quasar_spl::prelude::*, +}; + +#[derive(Accounts)] +pub struct TakeOffer { + #[account(mut)] + pub taker: Signer, + #[account( + mut, + has_one(maker), + has_one(maker_token_account_b), + constraints(offer.receive > 0), + close(dest = taker), + address = Offer::seeds(maker.address()) + )] + pub offer: Account, + #[account(mut)] + pub maker: UncheckedAccount, + pub token_mint_a: Account, + pub token_mint_b: Account, + #[account( + mut, + init(idempotent), + payer = taker, + token(mint = token_mint_a, authority = taker, token_program = token_program), + )] + pub taker_token_account_a: Account, + #[account(mut)] + pub taker_token_account_b: Account, + #[account( + mut, + init(idempotent), + payer = taker, + token(mint = token_mint_b, authority = maker, token_program = token_program), + )] + pub maker_token_account_b: Account, + #[account(mut)] + pub vault: Account, + pub rent: Sysvar, + pub token_program: Program, + pub system_program: Program, +} + +#[inline(always)] +pub fn handle_transfer_tokens(accounts: &mut TakeOffer) -> Result<(), ProgramError> { + accounts.token_program + .transfer( + &accounts.taker_token_account_b, + &accounts.maker_token_account_b, + &accounts.taker, + accounts.offer.receive, + ) + .invoke() +} + +#[inline(always)] +pub fn handle_withdraw_tokens_and_close_take(accounts: &mut TakeOffer, bumps: &TakeOfferBumps) -> Result<(), ProgramError> { + let bump = [bumps.offer]; + let seeds = [ + Seed::from(b"offer" as &[u8]), + Seed::from(accounts.maker.address().as_ref()), + Seed::from(bump.as_ref()), + ]; + + accounts.token_program + .transfer( + &accounts.vault, + &accounts.taker_token_account_a, + &accounts.offer, + accounts.vault.amount(), + ) + .invoke_signed(&seeds)?; + + accounts.token_program + .close_account(&accounts.vault, &accounts.taker, &accounts.offer) + .invoke_signed(&seeds)?; + Ok(()) +} diff --git a/tokens/escrow/quasar/src/lib.rs b/tokens/escrow/quasar/src/lib.rs index d779c4770..bfb4f76aa 100644 --- a/tokens/escrow/quasar/src/lib.rs +++ b/tokens/escrow/quasar/src/lib.rs @@ -18,19 +18,19 @@ mod quasar_escrow { use super::*; #[instruction(discriminator = 0)] - pub fn make(ctx: Ctx, deposit: u64, receive: u64) -> Result<(), ProgramError> { - instructions::make::handle_make_escrow(&mut ctx.accounts, receive, &ctx.bumps)?; - instructions::make::handle_deposit_tokens(&mut ctx.accounts, deposit) + pub fn make_offer(ctx: Ctx, deposit: u64, receive: u64) -> Result<(), ProgramError> { + instructions::make_offer::handle_make_offer(&mut ctx.accounts, receive, &ctx.bumps)?; + instructions::make_offer::handle_deposit_tokens(&mut ctx.accounts, deposit) } #[instruction(discriminator = 1)] - pub fn take(ctx: Ctx) -> Result<(), ProgramError> { - instructions::take::handle_transfer_tokens(&mut ctx.accounts)?; - instructions::take::handle_withdraw_tokens_and_close_take(&mut ctx.accounts, &ctx.bumps) + pub fn take_offer(ctx: Ctx) -> Result<(), ProgramError> { + instructions::take_offer::handle_transfer_tokens(&mut ctx.accounts)?; + instructions::take_offer::handle_withdraw_tokens_and_close_take(&mut ctx.accounts, &ctx.bumps) } #[instruction(discriminator = 2)] - pub fn refund(ctx: Ctx) -> Result<(), ProgramError> { - instructions::refund::handle_withdraw_tokens_and_close_refund(&mut ctx.accounts, &ctx.bumps) + pub fn cancel_offer(ctx: Ctx) -> Result<(), ProgramError> { + instructions::cancel_offer::handle_withdraw_tokens_and_close_cancel_offer(&mut ctx.accounts, &ctx.bumps) } } diff --git a/tokens/escrow/quasar/src/state.rs b/tokens/escrow/quasar/src/state.rs index 04c6b2d07..7357e1814 100644 --- a/tokens/escrow/quasar/src/state.rs +++ b/tokens/escrow/quasar/src/state.rs @@ -1,14 +1,14 @@ use quasar_lang::prelude::*; -/// Escrow state: records the maker's desired receive amount and the +/// Offer state: records the maker's desired receive amount and the /// associated mint/token-account addresses. #[account(discriminator = 1, set_inner)] -#[seeds(b"escrow", maker: Address)] -pub struct Escrow { +#[seeds(b"offer", maker: Address)] +pub struct Offer { pub maker: Address, - pub mint_a: Address, - pub mint_b: Address, - pub maker_ta_b: Address, + pub token_mint_a: Address, + pub token_mint_b: Address, + pub maker_token_account_b: Address, pub receive: u64, pub bump: u8, } diff --git a/tokens/escrow/quasar/src/tests.rs b/tokens/escrow/quasar/src/tests.rs index 5389b79a5..ca81289a9 100644 --- a/tokens/escrow/quasar/src/tests.rs +++ b/tokens/escrow/quasar/src/tests.rs @@ -54,48 +54,48 @@ fn token(address: Pubkey, mint: Pubkey, owner: Pubkey, amount: u64) -> Account { ) } -/// Build escrow account data manually. +/// Build offer account data manually. /// Layout (from #[account] codegen): /// [disc: 1 byte = 1] /// [maker: 32 bytes (Address)] -/// [mint_a: 32 bytes] -/// [mint_b: 32 bytes] -/// [maker_ta_b: 32 bytes] +/// [token_mint_a: 32 bytes] +/// [token_mint_b: 32 bytes] +/// [maker_token_account_b: 32 bytes] /// [receive: 8 bytes (PodU64 LE)] /// [bump: 1 byte] /// Total: 138 bytes -fn escrow_data( +fn offer_data( maker: Pubkey, - mint_a: Pubkey, - mint_b: Pubkey, - maker_ta_b: Pubkey, + token_mint_a: Pubkey, + token_mint_b: Pubkey, + maker_token_account_b: Pubkey, receive: u64, bump: u8, ) -> Vec { let mut data = Vec::with_capacity(138); data.push(1u8); // discriminator data.extend_from_slice(maker.as_ref()); - data.extend_from_slice(mint_a.as_ref()); - data.extend_from_slice(mint_b.as_ref()); - data.extend_from_slice(maker_ta_b.as_ref()); + data.extend_from_slice(token_mint_a.as_ref()); + data.extend_from_slice(token_mint_b.as_ref()); + data.extend_from_slice(maker_token_account_b.as_ref()); data.extend_from_slice(&receive.to_le_bytes()); data.push(bump); data } -fn escrow_account( +fn offer_account( address: Pubkey, maker: Pubkey, - mint_a: Pubkey, - mint_b: Pubkey, - maker_ta_b: Pubkey, + token_mint_a: Pubkey, + token_mint_b: Pubkey, + maker_token_account_b: Pubkey, receive: u64, bump: u8, ) -> Account { Account { address, lamports: 2_000_000, - data: escrow_data(maker, mint_a, mint_b, maker_ta_b, receive, bump), + data: offer_data(maker, token_mint_a, token_mint_b, maker_token_account_b, receive, bump), owner: crate::ID, executable: false, } @@ -109,198 +109,198 @@ fn with_signers(mut ix: Instruction, indices: &[usize]) -> Instruction { ix } -/// Build make instruction data. +/// Build make_offer instruction data. /// Wire format: [discriminator: u8 = 0] [deposit: u64 LE] [receive: u64 LE] -fn build_make_data(deposit: u64, receive: u64) -> Vec { +fn build_make_offer_data(deposit: u64, receive: u64) -> Vec { let mut data = vec![0u8]; data.extend_from_slice(&deposit.to_le_bytes()); data.extend_from_slice(&receive.to_le_bytes()); data } -/// Build take instruction data. +/// Build take_offer instruction data. /// Wire format: [discriminator: u8 = 1] -fn build_take_data() -> Vec { +fn build_take_offer_data() -> Vec { vec![1u8] } -/// Build refund instruction data. +/// Build cancel_offer instruction data. /// Wire format: [discriminator: u8 = 2] -fn build_refund_data() -> Vec { +fn build_cancel_offer_data() -> Vec { vec![2u8] } #[test] -fn test_make() { +fn test_make_offer() { let mut svm = setup(); let token_program = quasar_svm::SPL_TOKEN_PROGRAM_ID; let system_program = quasar_svm::system_program::ID; let maker = Pubkey::new_unique(); - let mint_a = Pubkey::new_unique(); - let mint_b = Pubkey::new_unique(); - let maker_ta_a = Pubkey::new_unique(); - let maker_ta_b = Pubkey::new_unique(); - let vault_ta_a = Pubkey::new_unique(); - let (escrow, escrow_bump) = - Pubkey::find_program_address(&[b"escrow", maker.as_ref()], &crate::ID); + let token_mint_a = Pubkey::new_unique(); + let token_mint_b = Pubkey::new_unique(); + let maker_token_account_a = Pubkey::new_unique(); + let maker_token_account_b = Pubkey::new_unique(); + let vault = Pubkey::new_unique(); + let (offer, offer_bump) = + Pubkey::find_program_address(&[b"offer", maker.as_ref()], &crate::ID); let rent = quasar_svm::solana_sdk_ids::sysvar::rent::ID; - let data = build_make_data(1337, 1337); + let data = build_make_offer_data(1337, 1337); let instruction = with_signers( Instruction { program_id: crate::ID, accounts: vec![ solana_instruction::AccountMeta::new(maker.into(), true), - solana_instruction::AccountMeta::new(escrow.into(), false), - solana_instruction::AccountMeta::new_readonly(mint_a.into(), false), - solana_instruction::AccountMeta::new_readonly(mint_b.into(), false), - solana_instruction::AccountMeta::new(maker_ta_a.into(), false), - solana_instruction::AccountMeta::new(maker_ta_b.into(), false), - solana_instruction::AccountMeta::new(vault_ta_a.into(), false), + solana_instruction::AccountMeta::new(offer.into(), false), + solana_instruction::AccountMeta::new_readonly(token_mint_a.into(), false), + solana_instruction::AccountMeta::new_readonly(token_mint_b.into(), false), + solana_instruction::AccountMeta::new(maker_token_account_a.into(), false), + solana_instruction::AccountMeta::new(maker_token_account_b.into(), false), + solana_instruction::AccountMeta::new(vault.into(), false), solana_instruction::AccountMeta::new_readonly(rent.into(), false), solana_instruction::AccountMeta::new_readonly(token_program.into(), false), solana_instruction::AccountMeta::new_readonly(system_program.into(), false), ], data, }, - &[5, 6], // maker_ta_b, vault_ta_a as signers for create_account CPI + &[5, 6], // maker_token_account_b, vault as signers for create_account CPI ); let result = svm.process_instruction( &instruction, &[ signer(maker), - empty(escrow), - mint(mint_a, maker), - mint(mint_b, maker), - token(maker_ta_a, mint_a, maker, 1_000_000), - empty(maker_ta_b), - empty(vault_ta_a), + empty(offer), + mint(token_mint_a, maker), + mint(token_mint_b, maker), + token(maker_token_account_a, token_mint_a, maker, 1_000_000), + empty(maker_token_account_b), + empty(vault), ], ); - assert!(result.is_ok(), "make failed: {:?}", result.raw_result); + assert!(result.is_ok(), "make_offer failed: {:?}", result.raw_result); - // Verify escrow state - let escrow_data = &result.account(&escrow).unwrap().data; - assert_eq!(escrow_data[0], 1, "discriminator"); - assert_eq!(&escrow_data[1..33], maker.as_ref(), "maker"); - assert_eq!(&escrow_data[129..137], &1337u64.to_le_bytes(), "receive"); - assert_eq!(escrow_data[137], escrow_bump, "bump"); + // Verify offer state + let offer_data = &result.account(&offer).unwrap().data; + assert_eq!(offer_data[0], 1, "discriminator"); + assert_eq!(&offer_data[1..33], maker.as_ref(), "maker"); + assert_eq!(&offer_data[129..137], &1337u64.to_le_bytes(), "receive"); + assert_eq!(offer_data[137], offer_bump, "bump"); - println!(" MAKE CU: {}", result.compute_units_consumed); + println!(" MAKE_OFFER CU: {}", result.compute_units_consumed); } #[test] -fn test_take() { +fn test_take_offer() { let mut svm = setup(); let token_program = quasar_svm::SPL_TOKEN_PROGRAM_ID; let system_program = quasar_svm::system_program::ID; let maker = Pubkey::new_unique(); let taker = Pubkey::new_unique(); - let mint_a = Pubkey::new_unique(); - let mint_b = Pubkey::new_unique(); - let taker_ta_a = Pubkey::new_unique(); - let taker_ta_b = Pubkey::new_unique(); - let maker_ta_b = Pubkey::new_unique(); - let vault_ta_a = Pubkey::new_unique(); - let (escrow, escrow_bump) = - Pubkey::find_program_address(&[b"escrow", maker.as_ref()], &crate::ID); + let token_mint_a = Pubkey::new_unique(); + let token_mint_b = Pubkey::new_unique(); + let taker_token_account_a = Pubkey::new_unique(); + let taker_token_account_b = Pubkey::new_unique(); + let maker_token_account_b = Pubkey::new_unique(); + let vault = Pubkey::new_unique(); + let (offer, offer_bump) = + Pubkey::find_program_address(&[b"offer", maker.as_ref()], &crate::ID); let rent = quasar_svm::solana_sdk_ids::sysvar::rent::ID; - let data = build_take_data(); + let data = build_take_offer_data(); let instruction = with_signers( Instruction { program_id: crate::ID, accounts: vec![ solana_instruction::AccountMeta::new(taker.into(), true), - solana_instruction::AccountMeta::new(escrow.into(), false), + solana_instruction::AccountMeta::new(offer.into(), false), solana_instruction::AccountMeta::new(maker.into(), false), - solana_instruction::AccountMeta::new_readonly(mint_a.into(), false), - solana_instruction::AccountMeta::new_readonly(mint_b.into(), false), - solana_instruction::AccountMeta::new(taker_ta_a.into(), false), - solana_instruction::AccountMeta::new(taker_ta_b.into(), false), - solana_instruction::AccountMeta::new(maker_ta_b.into(), false), - solana_instruction::AccountMeta::new(vault_ta_a.into(), false), + solana_instruction::AccountMeta::new_readonly(token_mint_a.into(), false), + solana_instruction::AccountMeta::new_readonly(token_mint_b.into(), false), + solana_instruction::AccountMeta::new(taker_token_account_a.into(), false), + solana_instruction::AccountMeta::new(taker_token_account_b.into(), false), + solana_instruction::AccountMeta::new(maker_token_account_b.into(), false), + solana_instruction::AccountMeta::new(vault.into(), false), solana_instruction::AccountMeta::new_readonly(rent.into(), false), solana_instruction::AccountMeta::new_readonly(token_program.into(), false), solana_instruction::AccountMeta::new_readonly(system_program.into(), false), ], data, }, - &[5, 7], // taker_ta_a, maker_ta_b as signers for create_account CPI + &[5, 7], // taker_token_account_a, maker_token_account_b as signers for create_account CPI ); let result = svm.process_instruction( &instruction, &[ signer(taker), - escrow_account(escrow, maker, mint_a, mint_b, maker_ta_b, 1337, escrow_bump), + offer_account(offer, maker, token_mint_a, token_mint_b, maker_token_account_b, 1337, offer_bump), signer(maker), - mint(mint_a, maker), - mint(mint_b, maker), - empty(taker_ta_a), - token(taker_ta_b, mint_b, taker, 10_000), - empty(maker_ta_b), - token(vault_ta_a, mint_a, escrow, 1337), + mint(token_mint_a, maker), + mint(token_mint_b, maker), + empty(taker_token_account_a), + token(taker_token_account_b, token_mint_b, taker, 10_000), + empty(maker_token_account_b), + token(vault, token_mint_a, offer, 1337), ], ); - assert!(result.is_ok(), "take failed: {:?}", result.raw_result); - println!(" TAKE CU: {}", result.compute_units_consumed); + assert!(result.is_ok(), "take_offer failed: {:?}", result.raw_result); + println!(" TAKE_OFFER CU: {}", result.compute_units_consumed); } #[test] -fn test_refund() { +fn test_cancel_offer() { let mut svm = setup(); let token_program = quasar_svm::SPL_TOKEN_PROGRAM_ID; let system_program = quasar_svm::system_program::ID; let maker = Pubkey::new_unique(); - let mint_a = Pubkey::new_unique(); - let mint_b = Pubkey::new_unique(); - let maker_ta_a = Pubkey::new_unique(); - let maker_ta_b = Pubkey::new_unique(); - let vault_ta_a = Pubkey::new_unique(); - let (escrow, escrow_bump) = - Pubkey::find_program_address(&[b"escrow", maker.as_ref()], &crate::ID); + let token_mint_a = Pubkey::new_unique(); + let token_mint_b = Pubkey::new_unique(); + let maker_token_account_a = Pubkey::new_unique(); + let maker_token_account_b = Pubkey::new_unique(); + let vault = Pubkey::new_unique(); + let (offer, offer_bump) = + Pubkey::find_program_address(&[b"offer", maker.as_ref()], &crate::ID); let rent = quasar_svm::solana_sdk_ids::sysvar::rent::ID; - let data = build_refund_data(); + let data = build_cancel_offer_data(); let instruction = with_signers( Instruction { program_id: crate::ID, accounts: vec![ solana_instruction::AccountMeta::new(maker.into(), true), - solana_instruction::AccountMeta::new(escrow.into(), false), - solana_instruction::AccountMeta::new_readonly(mint_a.into(), false), - solana_instruction::AccountMeta::new(maker_ta_a.into(), false), - solana_instruction::AccountMeta::new(vault_ta_a.into(), false), + solana_instruction::AccountMeta::new(offer.into(), false), + solana_instruction::AccountMeta::new_readonly(token_mint_a.into(), false), + solana_instruction::AccountMeta::new(maker_token_account_a.into(), false), + solana_instruction::AccountMeta::new(vault.into(), false), solana_instruction::AccountMeta::new_readonly(rent.into(), false), solana_instruction::AccountMeta::new_readonly(token_program.into(), false), solana_instruction::AccountMeta::new_readonly(system_program.into(), false), ], data, }, - &[3], // maker_ta_a as signer for create_account CPI + &[3], // maker_token_account_a as signer for create_account CPI ); let result = svm.process_instruction( &instruction, &[ signer(maker), - escrow_account(escrow, maker, mint_a, mint_b, maker_ta_b, 1337, escrow_bump), - mint(mint_a, maker), - empty(maker_ta_a), - token(vault_ta_a, mint_a, escrow, 1337), + offer_account(offer, maker, token_mint_a, token_mint_b, maker_token_account_b, 1337, offer_bump), + mint(token_mint_a, maker), + empty(maker_token_account_a), + token(vault, token_mint_a, offer, 1337), ], ); - assert!(result.is_ok(), "refund failed: {:?}", result.raw_result); - println!(" REFUND CU: {}", result.compute_units_consumed); + assert!(result.is_ok(), "cancel_offer failed: {:?}", result.raw_result); + println!(" CANCEL_OFFER CU: {}", result.compute_units_consumed); }