feat(asset-leasing): add Quasar port and apply Mike's README feedback

Why add a Quasar port:
Every other example in this repo has a Quasar sibling. Asset-leasing
shipped as Anchor-only, breaking that parity. The Quasar port covers
all seven instruction handlers (create_lease, take_lease, pay_rent,
top_up_collateral, return_lease, liquidate, close_expired) and all
eleven LiteSVM tests from the Anchor version, using the same Pyth
PriceUpdateV2 layout and the same two-mint vault design.

Why rewrite the README:

- "Token" not "SPL Token". Tokens are the default; no qualifier
  needed unless contrasting with native SOL. The old phrasing treated
  "SPL Token" as if it were a distinct product rather than the norm.

- "Instruction handler" not "instruction" when referring to the
  Rust function that processes the call. An *instruction* is the
  INPUT to a program (transaction call data); the *instruction
  handler* is the code. Conflating them confuses readers who are
  learning how the runtime dispatches work.

- Dropped the Glossary. Solana already defines lamports, signers,
  accounts, PDAs, CPIs, etc. at https://solana.com/docs/terminology.
  Redefining them here is both redundant and drifts over time. The
  README now links there once and inline-defines only genuinely
  project-specific terms (maintenance margin, liquidation bounty,
  keeper, rent-the-stream vs rent-the-account).

- Removed the Ethereum reference ("Solana's equivalent of an
  ERC-20"). Readers cannot be assumed to know Ethereum, and Solana
  is explainable on its own terms.

- Rewrote the "tradfi picture" analogies. Car rentals and pawn
  shops are not finance — nobody at Hertz or a pawn shop says they
  work in finance. Replaced with real financial-markets analogies:
  leasing gold bars from a bullion dealer, and securities lending
  (borrowing stock to short). These are the actual tradfi patterns
  this program models.

- Added a Quasar port section documenting how to build and test the
  new port alongside Anchor.

Why the code comment sweep:

Same terminology fixes applied in-code — "SPL token"/"SPL mint"/
"SPL vault" → "token"/"mint"/"vault" in doc comments across
constants.rs, create_lease.rs, shared.rs, and the test file. No
function, file, or struct names changed.

Local validation:

- Quasar: cargo test --release → 12/12 green (11 ported + test_id).
- Anchor: build succeeds with --ignore-keys; the pre-existing
  duplicate-entrypoint linker error on the local host is unrelated to
  this change (present on 04367b8 before any edits). CI builds both
  sides cleanly.

Author: Edward (Mike's AI sidekick)

defi/asset-leasing/anchor/README.md

@@ -2,11 +2,11 @@
 /// u64 `lease_id` so one lessor can run many leases in parallel.
 pub const LEASE_SEED: &[u8] = b"lease";
 
-/// PDA seed for the SPL vault that holds the leased tokens while the lease is
-/// `Listed` and that accepts returned tokens on settlement.
+/// PDA seed for the token vault that holds the leased tokens while the lease
+/// is `Listed` and that accepts returned tokens on settlement.
 pub const LEASED_VAULT_SEED: &[u8] = b"leased_vault";
 
-/// PDA seed for the SPL vault that escrows the lessee's collateral for the
+/// PDA seed for the token vault that escrows the lessee's collateral for the
 /// life of the lease.
 pub const COLLATERAL_VAULT_SEED: &[u8] = b"collateral_vault";
 

defi/asset-leasing/anchor/programs/asset-leasing/src/constants.rs

@@ -81,7 +81,7 @@ pub fn handle_create_lease(
     liquidation_bounty_bps: u16,
     feed_id: [u8; 32],
 ) -> Result<()> {
-    // Reject leased_mint == collateral_mint. Allowing both to be the same SPL
+    // Reject leased_mint == collateral_mint. Allowing both to be the same
     // mint would collapse the two vaults' seed derivations into one shared
     // token-balance pool, making rent-vs-collateral accounting ambiguous and
     // enabling griefing paths where the lessee's "collateral" is the same

defi/asset-leasing/anchor/programs/asset-leasing/src/instructions/create_lease.rs

@@ -4,7 +4,7 @@ use anchor_spl::token_interface::{
     TransferChecked,
 };
 
-/// Transfer SPL tokens from a user-controlled account to a program-controlled
+/// Transfer tokens from a user-controlled account to a program-controlled
 /// vault (or any other account the signer owns). Authority is a plain signer.
 pub fn transfer_tokens_from_user<'info>(
     from: &InterfaceAccount<'info, TokenAccount>,
@@ -27,8 +27,8 @@ pub fn transfer_tokens_from_user<'info>(
     )
 }
 
-/// Transfer SPL tokens out of a PDA-owned vault using the supplied signer
-/// seeds. Used by the program when moving tokens held under its authority.
+/// Transfer tokens out of a PDA-owned vault using the supplied signer seeds.
+/// Used by the program when moving tokens held under its authority.
 pub fn transfer_tokens_from_vault<'info>(
     from: &InterfaceAccount<'info, TokenAccount>,
     to: &InterfaceAccount<'info, TokenAccount>,
@@ -51,7 +51,7 @@ pub fn transfer_tokens_from_vault<'info>(
     )
 }
 
-/// Close a PDA-owned SPL token vault and forward its rent-exempt lamports to
+/// Close a PDA-owned token vault and forward its rent-exempt lamports to
 /// `destination`. The vault is its own token-account authority, so the caller
 /// just passes the same vault `AccountInfo` as both the account and the
 /// authority, with the vault's signer seeds for the CPI.

defi/asset-leasing/anchor/programs/asset-leasing/src/instructions/shared.rs

@@ -965,7 +965,7 @@ fn close_expired_cancels_listed_lease() {
 
 #[test]
 fn create_lease_rejects_same_mint_for_leased_and_collateral() {
-    // Collapsing leased_mint and collateral_mint into a single SPL mint would
+    // Collapsing leased_mint and collateral_mint into a single mint would
     // also collapse the two vaults into one token-balance pool (same mint,
     // same authority seed pattern) and make rent-vs-collateral accounting
     // ambiguous. The program rejects this up-front with

defi/asset-leasing/anchor/programs/asset-leasing/tests/test_asset_leasing.rs

@@ -0,0 +1,36 @@
+[package]
+name = "quasar-asset-leasing"
+version = "0.1.0"
+edition = "2021"
+
+# Standalone workspace — not part of the root program-examples workspace.
+# Quasar uses a different resolver and dependency tree from the Anchor
+# projects, so it must declare its own [workspace] root.
+[workspace]
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+check-cfg = [
+    'cfg(target_os, values("solana"))',
+]
+
+[lib]
+# `cdylib` for the on-chain .so; `lib` so `cargo test` can link the Rust
+# code as a regular library and exercise handlers against QuasarSvm.
+crate-type = ["cdylib", "lib"]
+
+[features]
+alloc = []
+client = []
+debug = []
+
+[dependencies]
+quasar-lang = "0.0"
+quasar-spl = "0.0"
+solana-address = { version = "2.2.0" }
+solana-instruction = { version = "3.2.0" }
+
+[dev-dependencies]
+quasar-svm = { version = "0.1" }
+spl-token-interface = { version = "2.0.0" }
+solana-program-pack = { version = "3.1.0" }

defi/asset-leasing/quasar/Cargo.toml

@@ -0,0 +1,22 @@
+[project]
+name = "quasar_asset_leasing"
+
+[toolchain]
+type = "solana"
+
+[testing]
+language = "rust"
+
+[testing.rust]
+framework = "quasar-svm"
+
+[testing.rust.test]
+program = "cargo"
+args = [
+    "test",
+    "tests::",
+]
+
+[clients]
+path = "target/client"
+languages = ["rust"]

defi/asset-leasing/quasar/Quasar.toml

@@ -0,0 +1,28 @@
+/// PDA seed for the `Lease` account. Combined with the lessor pubkey and a
+/// u64 `lease_id` so one lessor can run many leases in parallel.
+pub const LEASE_SEED: &[u8] = b"lease";
+
+/// PDA seed for the token vault that holds the leased tokens while the lease
+/// is `Listed` and that accepts returned tokens on settlement.
+pub const LEASED_VAULT_SEED: &[u8] = b"leased_vault";
+
+/// PDA seed for the token vault that escrows the lessee's collateral for the
+/// life of the lease.
+pub const COLLATERAL_VAULT_SEED: &[u8] = b"collateral_vault";
+
+/// Denominator for basis-point (bps) ratios used for the maintenance margin
+/// and the liquidation bounty. 10_000 bps = 100%.
+pub const BPS_DENOMINATOR: u64 = 10_000;
+
+/// Maximum allowed maintenance margin: 50_000 bps = 500%. Prevents the lessor
+/// setting an impossible margin that would let them liquidate on day one.
+pub const MAX_MAINTENANCE_MARGIN_BPS: u16 = 50_000;
+
+/// Maximum liquidation bounty the keeper can claim: 2_000 bps = 20%. Keeps
+/// most of the collateral flowing to the lessor on default.
+pub const MAX_LIQUIDATION_BOUNTY_BPS: u16 = 2_000;
+
+/// A Pyth price update is considered stale if its `publish_time` is older
+/// than this many seconds versus the current on-chain clock. 60 s matches
+/// the default staleness window used in the Pyth SDK docs.
+pub const PYTH_MAX_AGE_SECONDS: u64 = 60;

defi/asset-leasing/quasar/src/constants.rs

@@ -0,0 +1,26 @@
+use quasar_lang::prelude::*;
+
+/// Program-specific errors. Codes start at 6000 (Quasar's default
+/// `#[error_code]` offset, matching Anchor), so they never collide with
+/// Solana's built-in `ProgramError` codes or the framework's
+/// `QuasarError` codes.
+#[error_code]
+pub enum AssetLeasingError {
+    InvalidLeaseStatus,
+    InvalidDuration,
+    InvalidLeasedAmount,
+    InvalidCollateralAmount,
+    InvalidRentPerSecond,
+    InvalidMaintenanceMargin,
+    InvalidLiquidationBounty,
+    LeaseExpired,
+    LeaseNotExpired,
+    PositionHealthy,
+    StalePrice,
+    NonPositivePrice,
+    MathOverflow,
+    Unauthorised,
+    LeasedMintEqualsCollateralMint,
+    PriceFeedMismatch,
+    InvalidStatusByte,
+}

defi/asset-leasing/quasar/src/errors.rs

@@ -0,0 +1,156 @@
+use {
+    crate::{
+        constants::{COLLATERAL_VAULT_SEED, LEASED_VAULT_SEED, LEASE_SEED},
+        errors::AssetLeasingError,
+        instructions::pay_rent::update_last_paid_ts,
+        state::{Lease, LeaseStatus},
+    },
+    quasar_lang::prelude::*,
+    quasar_spl::{Mint, Token, TokenCpi},
+};
+
+/// Lessor-only recovery path. Two situations collapse into this handler:
+///
+/// - The lease sat in `Listed` and the lessor wants to cancel it,
+///   recovering the leased tokens they pre-funded. Allowed any time.
+/// - The lease was `Active` but the lessee ghosted past `end_ts`. The
+///   lessor takes the collateral as compensation and closes the books.
+#[derive(Accounts)]
+pub struct CloseExpired<'info> {
+    #[account(mut)]
+    pub lessor: &'info Signer,
+
+    #[account(
+        mut,
+        seeds = [LEASE_SEED, lessor],
+        bump = lease.bump,
+        has_one = lessor,
+        has_one = leased_mint,
+        has_one = collateral_mint,
+        constraint = {
+            let s = LeaseStatus::from_u8(lease.status);
+            s == Some(LeaseStatus::Listed) || s == Some(LeaseStatus::Active)
+        } @ AssetLeasingError::InvalidLeaseStatus,
+        close = lessor,
+    )]
+    pub lease: &'info mut Account<Lease>,
+
+    pub leased_mint: &'info Account<Mint>,
+    pub collateral_mint: &'info Account<Mint>,
+
+    #[account(
+        mut,
+        seeds = [LEASED_VAULT_SEED, lease],
+        bump = lease.leased_vault_bump,
+    )]
+    pub leased_vault: &'info mut Account<Token>,
+
+    #[account(
+        mut,
+        seeds = [COLLATERAL_VAULT_SEED, lease],
+        bump = lease.collateral_vault_bump,
+    )]
+    pub collateral_vault: &'info mut Account<Token>,
+
+    #[account(mut)]
+    pub lessor_leased_account: &'info mut Account<Token>,
+
+    #[account(mut)]
+    pub lessor_collateral_account: &'info mut Account<Token>,
+
+    pub token_program: &'info Program<Token>,
+}
+
+#[inline(always)]
+pub fn handle_close_expired(accounts: &mut CloseExpired) -> Result<(), ProgramError> {
+    let now = <Clock as quasar_lang::sysvars::Sysvar>::get()?.unix_timestamp.get();
+    let lease_address = *accounts.lease.address();
+    let status = LeaseStatus::from_u8(accounts.lease.status)
+        .ok_or(AssetLeasingError::InvalidStatusByte)?;
+
+    // Active leases can only be closed after they expire. Listed leases
+    // have no start/end so the check is skipped.
+    if status == LeaseStatus::Active {
+        let end_ts = accounts.lease.end_ts.get();
+        if now < end_ts {
+            return Err(AssetLeasingError::LeaseNotExpired.into());
+        }
+    }
+
+    let leased_vault_bump = [accounts.lease.leased_vault_bump];
+    let leased_vault_seeds: &[Seed] = &[
+        Seed::from(LEASED_VAULT_SEED),
+        Seed::from(lease_address.as_ref()),
+        Seed::from(&leased_vault_bump as &[u8]),
+    ];
+    let collateral_vault_bump = [accounts.lease.collateral_vault_bump];
+    let collateral_vault_seeds: &[Seed] = &[
+        Seed::from(COLLATERAL_VAULT_SEED),
+        Seed::from(lease_address.as_ref()),
+        Seed::from(&collateral_vault_bump as &[u8]),
+    ];
+
+    // Drain whatever is in the leased vault back to the lessor. For a
+    // Listed lease this is the full leased_amount; for a defaulted
+    // Active lease the vault is empty (the lessee never returned) so
+    // this is a no-op.
+    let leased_vault_balance = accounts.leased_vault.amount();
+    if leased_vault_balance > 0 {
+        accounts
+            .token_program
+            .transfer(
+                accounts.leased_vault,
+                accounts.lessor_leased_account,
+                accounts.leased_vault,
+                leased_vault_balance,
+            )
+            .invoke_signed(leased_vault_seeds)?;
+    }
+
+    // Drain the collateral vault to the lessor. For a Listed lease this
+    // is 0. For a defaulted Active lease this is the lessee's forfeited
+    // collateral.
+    let collateral_vault_balance = accounts.collateral_vault.amount();
+    if collateral_vault_balance > 0 {
+        accounts
+            .token_program
+            .transfer(
+                accounts.collateral_vault,
+                accounts.lessor_collateral_account,
+                accounts.collateral_vault,
+                collateral_vault_balance,
+            )
+            .invoke_signed(collateral_vault_seeds)?;
+    }
+
+    accounts
+        .token_program
+        .close_account(
+            accounts.leased_vault,
+            accounts.lessor,
+            accounts.leased_vault,
+        )
+        .invoke_signed(leased_vault_seeds)?;
+    accounts
+        .token_program
+        .close_account(
+            accounts.collateral_vault,
+            accounts.lessor,
+            accounts.collateral_vault,
+        )
+        .invoke_signed(collateral_vault_seeds)?;
+
+    // Keep the rent-settlement invariant intact even on default: the
+    // lessor takes the whole collateral vault as compensation here, but
+    // any future version of the program that wants to split the
+    // collateral differently (pro-rata rent, partial refund on default)
+    // can read `last_rent_paid_ts` and trust that everything up to
+    // `now` is already settled.
+    if status == LeaseStatus::Active {
+        update_last_paid_ts(accounts.lease, now);
+    }
+    accounts.lease.collateral_amount = 0u64.into();
+    accounts.lease.status = LeaseStatus::Closed as u8;
+
+    Ok(())
+}