chore(escrow): align Quasar and Anchor escrow naming for side-by-side comparison

Mike's writing an Anchor-vs-Quasar comparison doc. The two implementations
diverged cosmetically: Anchor had been refactored to canonical names
(`make_offer`/`take_offer`/`cancel_offer`, `Offer` state, `token_mint_a`,
`maker_token_account_a`, etc.), but Quasar still used the older `make`/`take`/
`refund` with `Escrow` state and `mint_a`/`maker_ta_a`-style fields. Those
surface-level differences make it hard to compare framework syntax without
also tracking name differences. This commit renames Quasar to match Anchor.

Renames in Quasar (rename-only, no behaviour change):

Handlers:
- `make`     → `make_offer`
- `take`     → `take_offer`
- `refund`   → `cancel_offer`

Account structs (+ associated `*Bumps`):
- `Make`   → `MakeOffer`
- `Take`   → `TakeOffer`
- `Refund` → `CancelOffer`

State type:
- `Escrow` → `Offer` (in `src/state.rs`)

Account fields:
- `mint_a`     → `token_mint_a`
- `mint_b`     → `token_mint_b`
- `maker_ta_a` → `maker_token_account_a`
- `maker_ta_b` → `maker_token_account_b`
- `taker_ta_a` → `taker_token_account_a`
- `taker_ta_b` → `taker_token_account_b`
- `vault_ta_a` → `vault`
- `escrow`     → `offer` (the state account field on each instruction)

Source files:
- `src/instructions/make.rs`   → `make_offer.rs`
- `src/instructions/take.rs`   → `take_offer.rs`
- `src/instructions/refund.rs` → `cancel_offer.rs`

Internal helper sanity rename (judgement call):
- `handle_make_escrow` → `handle_save_offer` (body now constructs an `Offer`,
  not an `Escrow`; also matches Anchor's `handle_save_offer`).

Deliberately NOT renamed:
- Crate / directory names (`tokens/escrow/anchor/programs/escrow/`,
  `tokens/escrow/quasar/`). The program is called "escrow"; the state inside
  is called "Offer". Both correct.
- Other internal helpers (`handle_deposit_tokens`, `handle_transfer_tokens`,
  `handle_withdraw_tokens_and_close_take`,
  `handle_withdraw_tokens_and_close_refund`). The `_refund` suffix reads worse
  as `_cancel_offer`.
- PDA seed bytes (`b"escrow"`). Changing them would alter PDA derivation
  (behaviour change). This is rename-only.

Verification:

    cd tokens/escrow/anchor && cargo check
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 38.87s

    cd tokens/escrow/quasar && cargo check
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 23.40s

    cd tokens/escrow/quasar && cargo check --tests
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 41.77s

(The Quasar warnings about never-read fields are a `#[account]` codegen
quirk and pre-date this change.)

Author: Mike MacCana

…escrow/quasar/src/instructions/refund.rs …/quasar/src/instructions/cancel_offer.rstokens/escrow/quasar/src/instructions/refund.rs renamed to tokens/escrow/quasar/src/instructions/cancel_offer.rs tokens/escrow/quasar/src/instructions/refund.rs renamed to tokens/escrow/quasar/src/instructions/cancel_offer.rs

@@ -1,38 +1,38 @@
 use {
-    crate::state::Escrow,
+    crate::state::Offer,
     quasar_lang::prelude::*,
     quasar_spl::prelude::*,
 };
 
 #[derive(Accounts)]
-pub struct Refund {
+pub struct CancelOffer {
     #[account(mut)]
     pub maker: Signer,
     #[account(
         mut,
         has_one(maker),
         close(dest = maker),
-        address = Escrow::seeds(maker.address())
+        address = Offer::seeds(maker.address())
     )]
-    pub escrow: Account<Escrow>,
-    pub mint_a: Account<Mint>,
+    pub offer: Account<Offer>,
+    pub token_mint_a: Account<Mint>,
     #[account(
         mut,
         init(idempotent),
         payer = maker,
-        token(mint = mint_a, authority = maker, token_program = token_program),
+        token(mint = token_mint_a, authority = maker, token_program = token_program),
     )]
-    pub maker_ta_a: Account<Token>,
+    pub maker_token_account_a: Account<Token>,
     #[account(mut)]
-    pub vault_ta_a: Account<Token>,
+    pub vault: Account<Token>,
     pub rent: Sysvar<Rent>,
     pub token_program: Program<TokenProgram>,
     pub system_program: Program<SystemProgram>,
 }
 
 #[inline(always)]
-pub fn handle_withdraw_tokens_and_close_refund(accounts: &mut Refund, bumps: &RefundBumps) -> Result<(), ProgramError> {
-    let bump = [bumps.escrow];
+pub fn handle_withdraw_tokens_and_close_refund(accounts: &mut CancelOffer, bumps: &CancelOfferBumps) -> Result<(), ProgramError> {
+    let bump = [bumps.offer];
     let seeds = [
         Seed::from(b"escrow" as &[u8]),
         Seed::from(accounts.maker.address().as_ref()),
@@ -41,15 +41,15 @@ pub fn handle_withdraw_tokens_and_close_refund(accounts: &mut Refund, bumps: &Re
 
     accounts.token_program
         .transfer(
-            &accounts.vault_ta_a,
-            &accounts.maker_ta_a,
-            &accounts.escrow,
-            accounts.vault_ta_a.amount(),
+            &accounts.vault,
+            &accounts.maker_token_account_a,
+            &accounts.offer,
+            accounts.vault.amount(),
         )
         .invoke_signed(&seeds)?;
 
     accounts.token_program
-        .close_account(&accounts.vault_ta_a, &accounts.maker, &accounts.escrow)
+        .close_account(&accounts.vault, &accounts.maker, &accounts.offer)
         .invoke_signed(&seeds)?;
     Ok(())
 }

tokens/escrow/quasar/src/instructions/make.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<Offer>,
+    pub token_mint_a: Account<Mint>,
+    pub token_mint_b: Account<Mint>,
+    #[account(mut)]
+    pub maker_token_account_a: Account<Token>,
+    #[account(
+        mut,
+        init(idempotent),
+        payer = maker,
+        token(mint = token_mint_b, authority = maker, token_program = token_program),
+    )]
+    pub maker_token_account_b: Account<Token>,
+    #[account(
+        mut,
+        init(idempotent),
+        payer = maker,
+        token(mint = token_mint_a, authority = offer, token_program = token_program),
+    )]
+    pub vault: Account<Token>,
+    pub rent: Sysvar<Rent>,
+    pub token_program: Program<TokenProgram>,
+    pub system_program: Program<SystemProgram>,
+}
+
+#[inline(always)]
+pub fn handle_save_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()
+}

tokens/escrow/quasar/src/instructions/make_offer.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::*;

tokens/escrow/quasar/src/instructions/mod.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<Offer>,
+    #[account(mut)]
+    pub maker: UncheckedAccount,
+    pub token_mint_a: Account<Mint>,
+    pub token_mint_b: Account<Mint>,
+    #[account(
+        mut,
+        init(idempotent),
+        payer = taker,
+        token(mint = token_mint_a, authority = taker, token_program = token_program),
+    )]
+    pub taker_token_account_a: Account<Token>,
+    #[account(mut)]
+    pub taker_token_account_b: Account<Token>,
+    #[account(
+        mut,
+        init(idempotent),
+        payer = taker,
+        token(mint = token_mint_b, authority = maker, token_program = token_program),
+    )]
+    pub maker_token_account_b: Account<Token>,
+    #[account(mut)]
+    pub vault: Account<Token>,
+    pub rent: Sysvar<Rent>,
+    pub token_program: Program<TokenProgram>,
+    pub system_program: Program<SystemProgram>,
+}
+
+#[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"escrow" 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(())
+}

tokens/escrow/quasar/src/instructions/take.rs

@@ -18,19 +18,19 @@ mod quasar_escrow {
     use super::*;
 
     #[instruction(discriminator = 0)]
-    pub fn make(ctx: Ctx<Make>, 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<MakeOffer>, deposit: u64, receive: u64) -> Result<(), ProgramError> {
+        instructions::make_offer::handle_save_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<Take>) -> 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<TakeOffer>) -> 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<Refund>) -> Result<(), ProgramError> {
-        instructions::refund::handle_withdraw_tokens_and_close_refund(&mut ctx.accounts, &ctx.bumps)
+    pub fn cancel_offer(ctx: Ctx<CancelOffer>) -> Result<(), ProgramError> {
+        instructions::cancel_offer::handle_withdraw_tokens_and_close_refund(&mut ctx.accounts, &ctx.bumps)
     }
 }