docs+code: spell out all abbreviations in asset-leasing

No abbreviations anywhere — full English words for everything
visible. Drops fake "COLLA" / "LEASED" placeholder tickers,
expands ts → timestamp, bps → basis_points, pda → program-derived
address, ata → associated token account, cpi → cross-program
invocation in comments and local names, plus the usual ctx/acc/
auth/addr/tx/cfg/amt expansions. Anchor / upstream type names
(CpiContext, AccountInfo, etc.) left as-is.

Author: Edward (OpenClaw)

defi/asset-leasing/anchor/README.md

@@ -21,8 +21,8 @@ custom-panic = []
 
 [dependencies]
 # `init-if-needed` is required because several instructions lazily create the
-# counterparty's ATAs (keeper's collateral ATA on first liquidation, lessor's
-# leased ATA on first return, etc.). Anchor forces an opt-in to make us
+# counterparty's associated token accounts (keeper's collateral associated token account on first liquidation, lessor's
+# leased associated token account on first return, etc.). Anchor forces an opt-in to make us
 # re-affirm that we verify ownership on every touch — which we do via the
 # `associated_token::authority = ...` constraints.
 anchor-lang = { version = "1.0.0", features = ["init-if-needed"] }

defi/asset-leasing/anchor/programs/asset-leasing/Cargo.toml

@@ -1,26 +1,26 @@
-/// PDA seed for the `Lease` account. Combined with the lessor pubkey and a
+/// program-derived address 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
+/// program-derived address 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
+/// program-derived address 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;
+/// Denominator for basis-point (basis points) ratios used for the maintenance margin
+/// and the liquidation bounty. 10_000 basis points = 100%.
+pub const BASIS_POINTS_DENOMINATOR: u64 = 10_000;
 
-/// Maximum allowed maintenance margin: 50_000 bps = 500%. Prevents the lessor
+/// Maximum allowed maintenance margin: 50_000 basis points = 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;
+pub const MAX_MAINTENANCE_MARGIN_BASIS_POINTS: u16 = 50_000;
 
-/// Maximum liquidation bounty the keeper can claim: 2_000 bps = 20%. Keeps
+/// Maximum liquidation bounty the keeper can claim: 2_000 basis points = 20%. Keeps
 /// most of the collateral flowing to the lessor on default.
-pub const MAX_LIQUIDATION_BOUNTY_BPS: u16 = 2_000;
+pub const MAX_LIQUIDATION_BOUNTY_BASIS_POINTS: 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

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

@@ -8,7 +8,7 @@ use crate::{
     constants::{COLLATERAL_VAULT_SEED, LEASED_VAULT_SEED, LEASE_SEED},
     errors::AssetLeasingError,
     instructions::{
-        pay_lease_fee::update_last_paid_ts,
+        pay_lease_fee::update_last_paid_timestamp,
         shared::{close_vault, transfer_tokens_from_vault},
     },
     state::{Lease, LeaseStatus},
@@ -18,7 +18,7 @@ use crate::{
 ///
 /// - 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
+/// - The lease was `Active` but the lessee ghosted past `end_timestamp`. The lessor
 ///   takes the collateral as compensation and closes the books.
 #[derive(Accounts)]
 pub struct CloseExpired<'info> {
@@ -93,7 +93,7 @@ pub fn handle_close_expired(context: Context<CloseExpired>) -> Result<()> {
     // no start/end so the check is skipped.
     if status == LeaseStatus::Active {
         require!(
-            now >= context.accounts.lease.end_ts,
+            now >= context.accounts.lease.end_timestamp,
             AssetLeasingError::LeaseNotExpired
         );
     }
@@ -159,18 +159,18 @@ pub fn handle_close_expired(context: Context<CloseExpired>) -> Result<()> {
     //
     // We are not forwarding any accrued lease fees to the lessor here — on default
     // the lessor takes the whole collateral vault as compensation — but we
-    // still bump \`last_paid_ts\` so the invariant
-    // \`last_paid_ts <= now.min(end_ts)\` stays intact. That matters for
+    // still bump \`last_paid_timestamp\` so the invariant
+    // \`last_paid_timestamp <= now.min(end_timestamp)\` stays intact. That matters for
     // any future version of the program that wants to split the collateral
     // differently (pro-rata lease fees, partial refund on default, haircut to the
     // lessee for unused time): such a version can read
-    // \`last_paid_ts\` and trust that everything up to \`now\` is already
+    // \`last_paid_timestamp\` and trust that everything up to \`now\` is already
     // settled, rather than having to reason about whether this branch ever
     // bumped the timestamp.
     //
     // No-op on the \`Listed\` branch because Lease fees never started accruing.
     if status == LeaseStatus::Active {
-        update_last_paid_ts(&mut context.accounts.lease, now);
+        update_last_paid_timestamp(&mut context.accounts.lease, now);
     }
     context.accounts.lease.collateral_amount = 0;
     context.accounts.lease.status = LeaseStatus::Closed;

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

@@ -3,8 +3,8 @@ use anchor_spl::token_interface::{Mint, TokenAccount, TokenInterface};
 
 use crate::{
     constants::{
-        COLLATERAL_VAULT_SEED, LEASED_VAULT_SEED, LEASE_SEED, MAX_LIQUIDATION_BOUNTY_BPS,
-        MAX_MAINTENANCE_MARGIN_BPS,
+        COLLATERAL_VAULT_SEED, LEASED_VAULT_SEED, LEASE_SEED, MAX_LIQUIDATION_BOUNTY_BASIS_POINTS,
+        MAX_MAINTENANCE_MARGIN_BASIS_POINTS,
     },
     errors::AssetLeasingError,
     instructions::shared::transfer_tokens_from_user,
@@ -40,8 +40,8 @@ pub struct CreateLease<'info> {
     )]
     pub lease: Account<'info, Lease>,
 
-    /// PDA-owned vault holding the leased tokens while `Listed`. Authority is
-    /// the vault PDA itself so the lease account does not need to sign for
+    /// program-derived address-owned vault holding the leased tokens while `Listed`. Authority is
+    /// the vault program-derived address itself so the lease account does not need to sign for
     /// returns / liquidation; any handler just signs with the vault seeds.
     #[account(
         init,
@@ -77,8 +77,8 @@ pub fn handle_create_lease(
     required_collateral_amount: u64,
     lease_fee_per_second: u64,
     duration_seconds: i64,
-    maintenance_margin_bps: u16,
-    liquidation_bounty_bps: u16,
+    maintenance_margin_basis_points: u16,
+    liquidation_bounty_basis_points: u16,
     feed_id: [u8; 32],
 ) -> Result<()> {
     // Reject leased_mint == collateral_mint. Allowing both to be the same
@@ -99,11 +99,11 @@ pub fn handle_create_lease(
     require!(lease_fee_per_second > 0, AssetLeasingError::InvalidLeaseFeePerSecond);
     require!(duration_seconds > 0, AssetLeasingError::InvalidDuration);
     require!(
-        maintenance_margin_bps > 0 && maintenance_margin_bps <= MAX_MAINTENANCE_MARGIN_BPS,
+        maintenance_margin_basis_points > 0 && maintenance_margin_basis_points <= MAX_MAINTENANCE_MARGIN_BASIS_POINTS,
         AssetLeasingError::InvalidMaintenanceMargin
     );
     require!(
-        liquidation_bounty_bps <= MAX_LIQUIDATION_BOUNTY_BPS,
+        liquidation_bounty_basis_points <= MAX_LIQUIDATION_BOUNTY_BASIS_POINTS,
         AssetLeasingError::InvalidLiquidationBounty
     );
 
@@ -133,13 +133,13 @@ pub fn handle_create_lease(
         required_collateral_amount,
         lease_fee_per_second,
         duration_seconds,
-        // start_ts / end_ts / last_paid_ts are set when the lease
+        // start_timestamp / end_timestamp / last_paid_timestamp are set when the lease
         // activates in `take_lease`.
-        start_ts: 0,
-        end_ts: 0,
-        last_paid_ts: 0,
-        maintenance_margin_bps,
-        liquidation_bounty_bps,
+        start_timestamp: 0,
+        end_timestamp: 0,
+        last_paid_timestamp: 0,
+        maintenance_margin_basis_points,
+        liquidation_bounty_basis_points,
         feed_id,
         status: LeaseStatus::Listed,
         bump: context.bumps.lease,

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

@@ -6,7 +6,7 @@ use anchor_spl::{
 
 use crate::{
     constants::{
-        BPS_DENOMINATOR, COLLATERAL_VAULT_SEED, LEASED_VAULT_SEED, LEASE_SEED,
+        BASIS_POINTS_DENOMINATOR, COLLATERAL_VAULT_SEED, LEASED_VAULT_SEED, LEASE_SEED,
         PYTH_MAX_AGE_SECONDS,
     },
     errors::AssetLeasingError,
@@ -34,7 +34,7 @@ pub struct Liquidate<'info> {
     #[account(mut)]
     pub keeper: Signer<'info>,
 
-    /// CHECK: PDA seed + lease-fee / collateral destination.
+    /// CHECK: program-derived address seed + lease-fee / collateral destination.
     #[account(mut)]
     pub lessor: UncheckedAccount<'info>,
 
@@ -174,7 +174,7 @@ pub fn handle_liquidate(context: Context<Liquidate>) -> Result<()> {
         AssetLeasingError::PositionHealthy
     );
 
-    // Settle accrued lease fees first (up to end_ts) so the lessor is paid for the
+    // Settle accrued lease fees first (up to end_timestamp) so the lessor is paid for the
     // time the lessee actually used. Only then slice off bounty + remainder.
     let lease_fee_due = compute_lease_fee_due(&context.accounts.lease, now)?;
     let lease_fee_payable = lease_fee_due.min(context.accounts.lease.collateral_amount);
@@ -215,9 +215,9 @@ pub fn handle_liquidate(context: Context<Liquidate>) -> Result<()> {
     // Bounty is a percentage of the collateral *after* lease fees — guarantees we
     // never try to pay out more than what actually sits in the vault.
     let bounty = (remaining as u128)
-        .checked_mul(context.accounts.lease.liquidation_bounty_bps as u128)
+        .checked_mul(context.accounts.lease.liquidation_bounty_basis_points as u128)
         .ok_or(AssetLeasingError::MathOverflow)?
-        .checked_div(BPS_DENOMINATOR as u128)
+        .checked_div(BASIS_POINTS_DENOMINATOR as u128)
         .ok_or(AssetLeasingError::MathOverflow)? as u64;
 
     if bounty > 0 {
@@ -264,7 +264,7 @@ pub fn handle_liquidate(context: Context<Liquidate>) -> Result<()> {
     )?;
 
     context.accounts.lease.collateral_amount = 0;
-    context.accounts.lease.last_paid_ts = now.min(context.accounts.lease.end_ts);
+    context.accounts.lease.last_paid_timestamp = now.min(context.accounts.lease.end_timestamp);
     context.accounts.lease.status = LeaseStatus::Liquidated;
 
     Ok(())
@@ -285,8 +285,8 @@ pub fn is_underwater(lease: &Lease, price: &DecodedPriceUpdate, now: i64) -> Res
 
     let leased_amount = lease.leased_amount as u128;
     let collateral_amount = lease.collateral_amount as u128;
-    let margin_bps = lease.maintenance_margin_bps as u128;
-    let denom = BPS_DENOMINATOR as u128;
+    let margin_basis_points = lease.maintenance_margin_basis_points as u128;
+    let denom = BASIS_POINTS_DENOMINATOR as u128;
 
     let (collateral_scaled, debt_scaled) = if price.exponent >= 0 {
         let scale = ten_pow(price.exponent as u32)?;
@@ -310,7 +310,7 @@ pub fn is_underwater(lease: &Lease, price: &DecodedPriceUpdate, now: i64) -> Res
         .checked_mul(denom)
         .ok_or(AssetLeasingError::MathOverflow)?;
     let rhs = debt_scaled
-        .checked_mul(margin_bps)
+        .checked_mul(margin_basis_points)
         .ok_or(AssetLeasingError::MathOverflow)?;
 
     Ok(lhs < rhs)

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

@@ -19,7 +19,7 @@ pub struct PayLeaseFee<'info> {
     #[account(mut)]
     pub payer: Signer<'info>,
 
-    /// CHECK: Referenced only for PDA derivation + has_one check on `lease`.
+    /// CHECK: Referenced only for program-derived address derivation + has_one check on `lease`.
     pub lessor: UncheckedAccount<'info>,
 
     #[account(
@@ -44,7 +44,7 @@ pub struct PayLeaseFee<'info> {
     )]
     pub collateral_vault: Box<InterfaceAccount<'info, TokenAccount>>,
 
-    /// Lessor's collateral-mint ATA, created on demand so the lessor does not
+    /// Lessor's collateral-mint associated token account, created on demand so the lessor does not
     /// need to pre-fund it with the lease fee.
     #[account(
         init_if_needed,
@@ -65,9 +65,9 @@ pub fn handle_pay_lease_fee(context: Context<PayLeaseFee>) -> Result<()> {
 
     let lease_fee_amount = compute_lease_fee_due(&context.accounts.lease, now)?;
 
-    // No time has passed (or already capped at end_ts). Nothing to do.
+    // No time has passed (or already capped at end_timestamp). Nothing to do.
     if lease_fee_amount == 0 {
-        update_last_paid_ts(&mut context.accounts.lease, now);
+        update_last_paid_timestamp(&mut context.accounts.lease, now);
         return Ok(());
     }
 
@@ -104,28 +104,28 @@ pub fn handle_pay_lease_fee(context: Context<PayLeaseFee>) -> Result<()> {
             .ok_or(AssetLeasingError::MathOverflow)?;
     }
 
-    update_last_paid_ts(&mut context.accounts.lease, now);
+    update_last_paid_timestamp(&mut context.accounts.lease, now);
     Ok(())
 }
 
-/// Lease fee accrues linearly: `(min(now, end_ts) - last_paid_ts) * rate`.
+/// Lease fee accrues linearly: `(min(now, end_timestamp) - last_paid_timestamp) * rate`.
 /// Extracted so it can be re-used by `return_lease` and `liquidate` for a
 /// final settlement before closing the lease.
 pub fn compute_lease_fee_due(lease: &Lease, now: i64) -> Result<u64> {
-    let cutoff = now.min(lease.end_ts);
-    if cutoff <= lease.last_paid_ts {
+    let cutoff = now.min(lease.end_timestamp);
+    if cutoff <= lease.last_paid_timestamp {
         return Ok(0);
     }
-    let elapsed = (cutoff - lease.last_paid_ts) as u64;
+    let elapsed = (cutoff - lease.last_paid_timestamp) as u64;
     elapsed
         .checked_mul(lease.lease_fee_per_second)
         .ok_or(AssetLeasingError::MathOverflow.into())
 }
 
-/// Advance `last_paid_ts` but never past the lease end — after end_ts
+/// Advance `last_paid_timestamp` but never past the lease end — after end_timestamp
 /// the lease is settled and extra Lease fees do not accrue.
-pub fn update_last_paid_ts(lease: &mut Lease, now: i64) {
-    lease.last_paid_ts = now.min(lease.end_ts);
+pub fn update_last_paid_timestamp(lease: &mut Lease, now: i64) {
+    lease.last_paid_timestamp = now.min(lease.end_timestamp);
 }
 
 impl<'info> PayLeaseFee<'info> {

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

@@ -8,7 +8,7 @@ use crate::{
     constants::{COLLATERAL_VAULT_SEED, LEASED_VAULT_SEED, LEASE_SEED},
     errors::AssetLeasingError,
     instructions::{
-        pay_lease_fee::{compute_lease_fee_due, update_last_paid_ts},
+        pay_lease_fee::{compute_lease_fee_due, update_last_paid_timestamp},
         shared::{close_vault, transfer_tokens_from_user, transfer_tokens_from_vault},
     },
     state::{Lease, LeaseStatus},
@@ -77,7 +77,7 @@ pub struct ReturnLease<'info> {
     )]
     pub lessee_collateral_account: Box<InterfaceAccount<'info, TokenAccount>>,
 
-    /// Lessor's leased-mint ATA, created on demand. They may have sent the
+    /// Lessor's leased-mint associated token account, created on demand. They may have sent the
     /// original tokens from a different account.
     #[account(
         init_if_needed,
@@ -194,7 +194,7 @@ pub fn handle_return_lease(context: Context<ReturnLease>) -> Result<()> {
         &[collateral_vault_seeds],
     )?;
 
-    update_last_paid_ts(&mut context.accounts.lease, now);
+    update_last_paid_timestamp(&mut context.accounts.lease, now);
     context.accounts.lease.collateral_amount = 0;
     context.accounts.lease.status = LeaseStatus::Closed;
 

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

@@ -27,7 +27,7 @@ pub fn transfer_tokens_from_user<'info>(
     )
 }
 
-/// Transfer tokens out of a PDA-owned vault using the supplied signer seeds.
+/// Transfer tokens out of a program-derived address-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>,
@@ -51,10 +51,10 @@ pub fn transfer_tokens_from_vault<'info>(
     )
 }
 
-/// Close a PDA-owned token vault and forward its rent-exempt lamports to
+/// Close a program-derived address-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.
+/// authority, with the vault's signer seeds for the cross-program invocation.
 ///
 /// `destination` is an `AccountInfo` so callers can pass whichever wrapper
 /// they hold (`Signer`, `UncheckedAccount`, etc.) via `.to_account_info()`.

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

@@ -16,7 +16,7 @@ pub struct TakeLease<'info> {
     #[account(mut)]
     pub lessee: Signer<'info>,
 
-    /// CHECK: Only used as a reference for the PDA seeds; no data accessed.
+    /// CHECK: Only used as a reference for the program-derived address seeds; no data accessed.
     pub lessor: UncheckedAccount<'info>,
 
     #[account(
@@ -63,7 +63,7 @@ pub struct TakeLease<'info> {
     )]
     pub lessee_collateral_account: Box<InterfaceAccount<'info, TokenAccount>>,
 
-    /// Lessee's ATA for the leased mint. Created on-demand if missing so the
+    /// Lessee's associated token account for the leased mint. Created on-demand if missing so the
     /// UI only has to hand over a lessee keypair plus the two mints.
     #[account(
         init_if_needed,
@@ -98,7 +98,7 @@ pub fn handle_take_lease(context: Context<TakeLease>) -> Result<()> {
         &context.accounts.token_program,
     )?;
 
-    // Pay out leased tokens from the vault PDA.
+    // Pay out leased tokens from the vault program-derived address.
     let lease_key = context.accounts.lease.key();
     let leased_vault_bump = context.accounts.lease.leased_vault_bump;
     let leased_vault_seeds: &[&[u8]] = &[
@@ -118,16 +118,16 @@ pub fn handle_take_lease(context: Context<TakeLease>) -> Result<()> {
         &signer_seeds,
     )?;
 
-    let end_ts = now
+    let end_timestamp = now
         .checked_add(duration_seconds)
         .ok_or(AssetLeasingError::MathOverflow)?;
 
     let lease = &mut context.accounts.lease;
     lease.lessee = context.accounts.lessee.key();
     lease.collateral_amount = required_collateral_amount;
-    lease.start_ts = now;
-    lease.end_ts = end_ts;
-    lease.last_paid_ts = now;
+    lease.start_timestamp = now;
+    lease.end_timestamp = end_timestamp;
+    lease.last_paid_timestamp = now;
     lease.status = LeaseStatus::Active;
 
     Ok(())