may_cpi 13.0.0

use anchor_lang::prelude::*;

#[cfg(feature = "local")]
declare_id!("43bYyFn8WBwxXvXh28yQ22SQz1TMY1w5DYnRAzRqpJ1J");

#[cfg(feature = "devnet")]
declare_id!("MD2pPJCjpUT5ttJFUVeP2Xka1ZSvCJMZUoX4XTdPdet");

#[cfg(feature = "mainnet")]
declare_id!("MMkP6WPG4ySTudigPQpKNpranEYBzYRDe8Ua7Dx89Rk");

#[program]
pub mod mayflower {
    use super::*;

    pub fn version(_ctx: Context<VersionAccounts>) -> Result<()> {
        panic!("not implemented")
    }

    pub fn init_log_account(_ctx: Context<InitLogAccountAccounts>) -> Result<()> {
        panic!("not implemented")
    }

    pub fn receive_log(_ctx: Context<ReceiveLogAccounts>, _log: [u8; 504]) -> Result<()> {
        panic!("not implemented")
    }

    pub fn test_log(_ctx: Context<TestLogAccounts>) -> Result<()> {
        panic!("not implemented")
    }

    /// Initialize a platform tenant.
    /// 
    /// Tenants are the top-level organizational units in the protocol. Each tenant can have
    /// multiple market groups, and receives a portion of all fees generated by markets under
    /// their umbrella.
    /// 
    /// # Arguments
    /// 
    /// * `fee_micro_bps` - Platform fee rate in micro basis points (1 micro bp = 0.0001%).
    /// This fee is taken from all market operations and distributed to the tenant.
    /// * `permissionless_group_creation` - If true, anyone can create market groups under this
    /// tenant. If false, only the tenant admin can create new groups.
    /// 
    /// # Access Control
    /// 
    /// This instruction can only be called by the program itself (root authority).
    pub fn tenant_init(_ctx: Context<TenantInitAccounts>, _fee_micro_bps: u32, _permissionless_group_creation: bool) -> Result<()> {
        panic!("not implemented")
    }

    /// Initialize a platform tenant with an admin.
    /// 
    /// This instruction is similar to `tenant_init` but allows specifying an admin
    /// account that will have full control over the tenant.
    /// 
    /// # Arguments
    /// 
    /// * `fee_micro_bps` - Platform fee rate in micro basis points (1 micro bp = 0.0001%).
    /// This fee is taken from all market operations and distributed to the tenant.
    /// * `permissionless_group_creation` - If true, anyone can create market groups under this
    /// tenant. If false, only the tenant admin can create new groups.
    /// * `admin` - Public key of the admin account that will have full control over the tenant.
    pub fn tenant_init_with_admin(_ctx: Context<TenantInitWithAdminAccounts>, _fee_micro_bps: u32, _permissionless_group_creation: bool, _admin: Pubkey) -> Result<()> {
        panic!("not implemented")
    }

    /// Propose a new admin for the tenant.
    /// 
    /// Initiates a two-step ownership transfer process. The current admin proposes a new admin,
    /// who must then accept the role using `tenant_accept_new_admin`.
    pub fn tenant_propose_admin(_ctx: Context<TenantProposeAdminAccounts>, _new_admin: Pubkey) -> Result<TenantProposeAdminEvent> {
        panic!("not implemented")
    }

    /// Accept admin ownership of a tenant.
    /// 
    /// Completes the two-step ownership transfer process. The proposed admin calls this
    /// instruction to accept control of the tenant.
    pub fn tenant_accept_new_admin(_ctx: Context<TenantAcceptNewAdminAccounts>) -> Result<TenantAcceptNewAdminEvent> {
        panic!("not implemented")
    }

    /// Change the fee rate for a tenant.
    /// 
    /// Updates the platform fee rate applied to all market operations under this tenant.
    pub fn tenant_change_fee_mbps(_ctx: Context<TenantChangeFeeMbpsAccounts>, _fee_micro_bps: u32) -> Result<TenantChangeFeeMbpsEvent> {
        panic!("not implemented")
    }

    /// Initialize a market group under a tenant.
    /// 
    /// Market groups are collections of markets that share the same fee structure and admin.
    /// Each group can contain multiple markets with different token pairs and price curves.
    /// The group admin has control over all markets within the group and collects trading fees.
    /// 
    /// # Arguments
    /// 
    /// * `args` - Initialization arguments containing:
    /// - `fees`: Fee structure for buy, sell, borrow, and exercise operations
    /// - `group_admin`: Public key that will administer this market group
    /// 
    /// # Access Control
    /// 
    /// If the tenant has `permissionless_group_creation` disabled, only the tenant admin
    /// can create new market groups.
    pub fn market_group_init(_ctx: Context<MarketGroupInitAccounts>, _args: MarketGroupInitArgs) -> Result<()> {
        panic!("not implemented")
    }

    /// Propose a new admin for the market group.
    /// 
    /// Initiates a two-step ownership transfer process. The current admin proposes a new admin,
    /// who must then accept the role using `market_group_accept_new_admin`.
    /// 
    /// # Arguments
    /// 
    /// * `new_admin` - Public key of the proposed new admin
    /// 
    /// # Access Control
    /// 
    /// Only the current market group admin can propose a new admin.
    /// 
    /// # Security
    /// 
    /// Two-step transfer prevents accidental loss of admin control by requiring the new admin
    /// to explicitly accept the role.
    pub fn market_group_propose_admin(_ctx: Context<MarketGroupProposeAdminAccounts>, _new_admin: Pubkey) -> Result<MarketGroupProposeAdminEvent> {
        panic!("not implemented")
    }

    /// Accept admin ownership of a market group.
    /// 
    /// Completes the two-step ownership transfer process. The proposed admin calls this
    /// instruction to accept control of the market group.
    /// 
    /// # Access Control
    /// 
    /// Only the proposed new admin can accept ownership.
    /// 
    /// # Effects
    /// 
    /// - Transfers full admin control to the new admin
    /// - Clears the proposed admin field
    /// - The new admin gains ability to:
    /// - Create new markets in the group
    /// - Change group fees
    /// - Collect accumulated revenue
    /// - Modify market permissions
    pub fn market_group_accept_new_admin(_ctx: Context<MarketGroupAcceptNewAdminAccounts>) -> Result<MarketGroupAcceptNewAdminEvent> {
        panic!("not implemented")
    }

    /// Initialize a linear market with a simple price curve.
    /// 
    /// Creates a new market with a linear bonding curve that determines token prices based on
    /// supply. The curve has three segments: floor (constant price), shoulder (linear increase),
    /// and tail (constant max price).
    /// 
    /// # Arguments
    /// 
    /// * `market_linear_args` - Configuration parameters including:
    /// - `floor`: Minimum price per token (floor price)
    /// - `target`: Target price where the shoulder segment ends
    /// - `slope_numerator` / `slope_denominator`: Rate of price increase in shoulder segment
    /// - `shoulder_start` / `shoulder_end`: Token supply range for linear price growth
    /// - `tail_start`: Token supply where max price is reached
    /// - `permissions`: Trading restrictions and feature flags
    /// 
    /// # Access Control
    /// 
    /// Only the market group admin can create new markets.
    /// 
    /// # Created Accounts
    /// 
    /// - Market account storing price curve and state
    /// - Token mint for the market's synthetic token
    /// - Option token mint for exercisable options
    /// - Liquidity vault holding backing collateral
    /// - Revenue escrow accounts for fee collection
    pub fn market_linear_init(_ctx: Context<MarketLinearInitAccounts>, _market_linear_args: MarketLinearArgs) -> Result<()> {
        panic!("not implemented")
    }

    /// Initialize a linear market with Dutch auction price boost.
    /// 
    /// Creates a linear market with an additional Dutch auction mechanism that provides
    /// temporary price boosts. The boost decays over time from a maximum multiplier down
    /// to 1x (no boost).
    /// 
    /// # Arguments
    /// 
    /// * `market_linear_init_with_dutch_args` - Configuration containing:
    /// - All standard linear market parameters (floor, target, slopes, etc.)
    /// - `dutch_numerator` / `dutch_denominator`: Maximum price boost multiplier
    /// - `dutch_duration`: Time in seconds for boost to decay from max to 1x
    /// - `dutch_start`: Unix timestamp when the Dutch auction begins
    /// 
    /// # Dutch Auction Mechanics
    /// 
    /// - Initial boost: price × (dutch_numerator / dutch_denominator)
    /// - Linear decay over dutch_duration seconds
    /// - After duration expires, boost remains at 1x (no effect)
    /// - Useful for token launches to incentivize early buyers
    /// 
    /// # Access Control
    /// 
    /// Only the market group admin can create new markets.
    pub fn market_linear_init_with_dutch(_ctx: Context<MarketLinearInitWithDutchAccounts>, _market_linear_init_with_dutch_args: MarketLinearInitWithDutchArgs) -> Result<()> {
        panic!("not implemented")
    }

    /// Mint option tokens by depositing market tokens.
    /// 
    /// Converts market tokens into option tokens at a 1:1 ratio. Option tokens represent
    /// the right to purchase market tokens at the floor price by depositing the main
    /// backing token (e.g., USDC).
    /// 
    /// # Arguments
    /// 
    /// * `amount` - Number of market tokens to convert into options
    /// 
    /// # Requirements
    /// 
    /// - User must have sufficient market token balance
    /// - Market must allow option minting (check permissions)
    /// 
    /// # Use Cases
    /// 
    /// - Hedge against price increases by locking in floor price
    /// - Create structured products with downside protection
    /// - Enable secondary markets for price speculation
    pub fn mint_options(_ctx: Context<MintOptionsAccounts>, _amount: u64) -> Result<MintOptionsEvent> {
        panic!("not implemented")
    }

    /// Collect accumulated trading fees from a market group.
    /// 
    /// Transfers fee revenue from the group's escrow account to the admin's wallet.
    /// Fees accumulate from all trading operations (buy, sell, borrow, exercise) across
    /// all markets in the group.
    /// 
    /// # Arguments
    /// 
    /// * `amount` - Amount to collect:
    /// - `FullOrPartialU64::Full`: Collect entire escrow balance
    /// - `FullOrPartialU64::Partial(n)`: Collect specific amount `n`
    /// 
    /// # Access Control
    /// 
    /// Only the market group admin can collect revenue.
    /// 
    /// # Fee Distribution
    /// 
    /// Trading fees are split between:
    /// - Tenant: Platform-level fee (set during tenant creation)
    /// - Market Group: Admin fee (set during group creation)
    /// 
    /// This instruction collects only the group's portion.
    pub fn market_group_collect_rev(_ctx: Context<MarketGroupCollectRevAccounts>, _amount: FullOrPartialU64) -> Result<MarketGroupCollectRevEvent> {
        panic!("not implemented")
    }

    /// Collect accumulated platform fees from a tenant.
    /// 
    /// Transfers platform fee revenue from the tenant's escrow account to the admin's wallet.
    /// Platform fees accumulate from all trading operations (buy, sell, borrow, exercise) across
    /// all markets under this tenant.
    /// 
    /// # Arguments
    /// 
    /// * `amount` - Amount to collect:
    /// - `FullOrPartialU64::Full`: Collect entire escrow balance
    /// - `FullOrPartialU64::Partial(n)`: Collect specific amount `n`
    /// 
    /// # Access Control
    /// 
    /// Only the tenant admin can collect platform revenue.
    /// 
    /// # Fee Distribution
    /// 
    /// Trading fees are split between:
    /// - Tenant: Platform-level fee (set during tenant creation)
    /// - Market Group: Admin fee (set during group creation)
    /// 
    /// This instruction collects only the tenant's platform fee portion.
    pub fn tenant_collect_rev(_ctx: Context<TenantCollectRevAccounts>, _amount: FullOrPartialU64) -> Result<TenantCollectRevEvent> {
        panic!("not implemented")
    }

    /// DEPRECATED: use raise_floor_preserve_area_checked2 instead, as it is more secure
    /// 
    /// Raise the market floor price while preserving bonding curve area.
    /// 
    /// Increases the minimum (floor) price of the market token while maintaining the
    /// total area under the price curve. This ensures the market's total value capacity
    /// remains constant while providing price support.
    /// 
    /// # Arguments
    /// 
    /// * `new_floor` - New minimum price per token (must be higher than current)
    /// * `new_shoulder_end` - New token supply where shoulder segment ends
    /// 
    /// # Curve Adjustment
    /// 
    /// When the floor rises:
    /// - Floor segment moves up to new price level
    /// - Shoulder segment becomes steeper to preserve area
    /// - Tail segment adjusts to maintain continuity
    /// 
    /// # Requirements
    /// 
    /// - Market must have excess liquidity to support higher floor
    /// - New floor must be greater than current floor
    /// - Curve area preservation must be mathematically valid
    /// 
    /// # Access Control
    /// 
    /// Can be triggered by authorized operators or through automated mechanisms.
    pub fn raise_floor_preserve_area(_ctx: Context<RaiseFloorPreserveAreaAccounts>, _new_floor: DecimalSerialized, _new_shoulder_end: u64) -> Result<RaiseFloorFromTriggerEvent> {
        panic!("not implemented")
    }

    /// DEPRECATED: use raise_floor_preserve_area_checked2 instead, as it is more secure
    /// 
    /// Raise the floor price with additional validation checks.
    /// 
    /// Similar to `raise_floor_preserve_area` but includes extra safety checks to ensure
    /// the operation maintains market integrity. Validates curve parameters and liquidity
    /// requirements before applying changes.
    /// 
    /// # Arguments
    /// 
    /// * `args` - Parameters including:
    /// - `new_floor`: Target floor price
    /// - `new_shoulder_end`: Adjusted shoulder endpoint
    /// - `max_deviation_bps`: Maximum allowed deviation in basis points
    /// 
    /// # Additional Checks
    /// 
    /// - Verifies sufficient backing liquidity exists
    /// - Ensures curve area preservation within tolerance
    /// - Validates no tokens would be instantly profitable to redeem
    /// - Checks market state consistency after adjustment
    /// 
    /// # Use Cases
    /// 
    /// - Automated floor raising based on market conditions
    /// - Protocol-driven price support mechanisms
    /// - Treasury management operations
    pub fn raise_floor_preserve_area_checked(_ctx: Context<RaiseFloorPreserveAreaCheckedAccounts>, _args: RaiseFloorPreserveAreaCheckedArgs) -> Result<RaiseFloorPreserveAreaCheckedEvent> {
        panic!("not implemented")
    }

    /// Raise the floor and preserve the area of the market
    /// This instruction takes in constraints
    /// * `new_floor` - The new floor price (must be greater than the current floor)
    /// * `new_shoulder_end` - The new shoulder end (must be greater than the current shoulder end)
    /// * `min_liq_ratio` - The minimum liquidity ratio (greater than or equal to 0.0)
    /// * `max_area_shrinkage_tolerance_units` - The maximum token units that the total area of the curve is allowed to shrink by
    /// This is set by the client to restrict overly aggressive floor raising, with a tolerance to account for "slippage"
    /// 
    /// # Access Control
    /// Only the market group admin can raise the floor price.
    pub fn raise_floor_preserve_area_checked2(_ctx: Context<RaiseFloorPreserveAreaChecked2Accounts>, _args: RaiseFloorPreserveAreaCheckedArgs2) -> Result<RaiseFloorPreserveAreaChecked2Event> {
        panic!("not implemented")
    }

    /// DEPRECATED: use raise_floor_from_excess_liquidity2 instead, as it is more secure
    /// 
    /// Raise the floor price using excess market liquidity.
    /// 
    /// Automatically increases the floor price when the market has accumulated excess
    /// backing liquidity beyond what's needed for the current token supply. This provides
    /// organic price appreciation based on market performance.
    /// 
    /// # Arguments
    /// 
    /// * `floor_increase_ratio` - Percentage increase for the floor price (as decimal)
    /// - 0.1 = 10% increase
    /// - 0.05 = 5% increase
    /// - Must be positive and reasonable (typically < 0.5)
    /// 
    /// # Mechanism
    /// 
    /// 1. Calculates available excess liquidity (cash above backing requirements)
    /// 2. Determines maximum sustainable floor increase
    /// 3. Applies requested ratio (capped by available excess)
    /// 4. Adjusts curve parameters to preserve total area
    /// 
    /// # Requirements
    /// 
    /// - Market must have excess liquidity
    /// - Floor increase must be sustainable given current token supply
    /// - Market permissions must allow floor raising
    /// 
    /// # Benefits
    /// 
    /// - Rewards token holders when market performs well
    /// - Creates deflationary pressure through higher floor
    /// - Maintains full backing at new price levels
    pub fn raise_floor_from_excess_liquidity(_ctx: Context<RaiseFloorFromExcessLiquidityAccounts>, _floor_increase_ratio: DecimalSerialized) -> Result<RaiseFloorFromExcessLiquidityEvent> {
        panic!("not implemented")
    }

    /// Raise the floor price using excess market liquidity.
    /// 
    /// Automatically increases the floor price when the market has accumulated excess
    /// backing liquidity beyond what's needed for the current token supply. This provides
    /// organic price appreciation based on market performance.
    /// 
    /// # Arguments
    /// 
    /// * `args` - Parameters including:
    /// - `max_new_floor`: The maximum new floor that is allowed
    /// - `increase_ratio_micro_basis_points`: The amount to increase the floor by, in micro basis points
    /// 
    /// # Access Control
    /// 
    /// Only the market group admin can raise the floor price.
    /// 
    /// # Use Cases
    /// - Automated floor raising based on market conditions
    /// - Protocol-driven price support mechanisms
    /// - Treasury management operations
    pub fn raise_floor_from_excess_liquidity_checked(_ctx: Context<RaiseFloorFromExcessLiquidityCheckedAccounts>, _args: RaiseFloorFromExcessLiquidityCheckedArgs) -> Result<RaiseFloorFromExcessLiquidity2Event> {
        panic!("not implemented")
    }

    /// Update market permissions and feature flags.
    /// 
    /// Controls which operations are allowed on a market. Can be used to pause trading,
    /// disable specific features, or adjust market behavior.
    /// 
    /// # Arguments
    /// 
    /// * `new_flags` - New permission set including:
    /// - `can_buy`: Allow token purchases
    /// - `can_sell`: Allow token sales
    /// - `can_borrow`: Allow borrowing against collateral
    /// - `can_add_liquidity`: Allow liquidity donations
    /// - `can_remove_liquidity`: Allow liquidity removal
    /// - `can_open_position`: Allow new position creation
    /// - `can_close_position`: Allow position closure
    /// - `can_change_fees`: Allow fee adjustments
    /// 
    /// # Access Control
    /// 
    /// Only the market group admin can change market flags.
    /// 
    /// # Use Cases
    /// 
    /// - Emergency pause during security incidents
    /// - Gradual feature rollout
    /// - Market maintenance windows
    /// - Compliance-driven restrictions
    pub fn market_flags_change(_ctx: Context<MarketFlagsChangeAccounts>, _new_flags: MarketPermissions) -> Result<MarketFlagsChangeEvent> {
        panic!("not implemented")
    }

    /// Update fee structure for all markets in a group.
    /// 
    /// Changes the fee rates charged on trading operations. New fees apply to all future
    /// transactions across all markets within the group.
    /// 
    /// # Arguments
    /// 
    /// * `new_fees` - Updated fee structure:
    /// - `buy`: Fee on token purchases (micro basis points)
    /// - `sell`: Fee on token sales (micro basis points)
    /// - `borrow`: Fee on borrowing operations (micro basis points)
    /// - `exercise`: Fee on option exercise (micro basis points)
    /// 
    /// # Fee Calculation
    /// 
    /// Fees are specified in micro basis points where:
    /// - 1 micro bp = 1/100 of a basis point = 0.0001%
    /// - 100 micro bps = 1 basis point = 0.01%
    /// - 10,000 micro bps = 100 basis points = 1%
    /// - Example: 50 micro bps = 0.5 basis points = 0.005% fee
    /// 
    /// # Access Control
    /// 
    /// Only the market group admin can change fees.
    /// 
    /// # Considerations
    /// 
    /// - Changes affect all markets in the group immediately
    /// - Cannot exceed maximum fee limits set by protocol
    /// - Platform (tenant) fees are added on top of group fees
    pub fn market_group_change_fees(_ctx: Context<MarketGroupChangeFeesAccounts>, _new_fees: Fees) -> Result<MarketGroupChangeFeesEvent> {
        panic!("not implemented")
    }

    /// Initialize a personal position account for market interaction.
    /// 
    /// Creates a user-specific account that tracks collateral deposits and debt obligations
    /// for a particular market. Required before performing borrow operations or using
    /// collateral-based features.
    /// 
    /// # Position Features
    /// 
    /// Personal positions enable:
    /// - Collateral deposits (market tokens as collateral)
    /// - Borrowing against collateral (up to LTV limits)
    /// - Tracking debt obligations and interest
    /// - Liquidation protection through collateralization
    /// 
    /// # Account Structure
    /// 
    /// - Unique per user per market
    /// - Stores collateral and debt balances
    /// - Tracks last update timestamp for interest
    /// - Immutable market and owner references
    /// 
    /// # One-Time Setup
    /// 
    /// Each user needs only one position per market. Attempting to create a duplicate
    /// will fail. The position persists until explicitly closed.
    pub fn personal_position_init(_ctx: Context<PersonalPositionInitAccounts>) -> Result<PersonalPositionInitEvent> {
        panic!("not implemented")
    }

    /// DEPRECATED: use donate_liquidity2 instead, as v2 gets logged by the indexer
    /// 
    /// Donate backing liquidity to the market.
    /// 
    /// Adds main tokens (e.g., USDC) to the market's liquidity vault without receiving
    /// market tokens in return. This creates excess liquidity that can be used to raise
    /// the floor price or improve market stability.
    /// 
    /// # Arguments
    /// 
    /// * `amount` - Amount of main tokens to donate
    /// 
    /// # Effects
    /// 
    /// - Increases market's cash balance
    /// - Creates excess liquidity (cash > backing requirements)
    /// - Enables floor price increases
    /// - Benefits all token holders through improved backing
    /// 
    /// # Use Cases
    /// 
    /// - Protocol treasury supporting market stability
    /// - Community-funded price support
    /// - Grants or subsidies to bootstrap markets
    /// - Creating buffer for market operations
    /// 
    /// # Note
    /// 
    /// Donations are irreversible. Donors receive no tokens or claims on the liquidity.
    pub fn donate_liquidity(_ctx: Context<DonateLiquidityAccounts>, _amount: u64) -> Result<DonateLiquidityEvent> {
        panic!("not implemented")
    }

    /// Donate backing liquidity to the market.
    /// 
    /// Adds main tokens (e.g., USDC) to the market's liquidity vault without receiving
    /// market tokens in return. This creates excess liquidity that can be used to raise
    /// the floor price or improve market stability.
    /// 
    /// # Arguments
    /// 
    /// * `amount` - Amount of main tokens to donate
    /// 
    /// # Effects
    /// 
    /// - Increases market's cash balance
    /// - Creates excess liquidity (cash > backing requirements)
    /// - Enables floor price increases
    /// - Benefits all token holders through improved backing
    /// 
    /// # Use Cases
    /// 
    /// - Protocol treasury supporting market stability
    /// - Community-funded price support
    /// - Grants or subsidies to bootstrap markets
    /// - Creating buffer for market operations
    /// 
    /// # Note
    /// 
    /// Donations are irreversible. Donors receive no tokens or claims on the liquidity.
    pub fn donate_liquidity2(_ctx: Context<DonateLiquidity2Accounts>, _amount: u64) -> Result<DonateLiquidityEvent> {
        panic!("not implemented")
    }

    /// Buy market tokens using exact amount of main tokens.
    /// 
    /// Purchases market tokens by depositing a specific amount of main tokens (e.g., USDC).
    /// The number of tokens received depends on the current price curve position. Includes
    /// slippage protection through minimum output requirement.
    /// 
    /// # Arguments
    /// 
    /// * `cash_in` - Exact amount of main tokens to spend
    /// * `min_token_out` - Minimum market tokens to receive (reverts if not met)
    /// 
    /// # Price Calculation
    /// 
    /// Token price follows the bonding curve:
    /// - Floor segment: Constant price at floor level
    /// - Shoulder segment: Linear price increase
    /// - Tail segment: Constant price at maximum
    /// - Dutch boost: Temporary multiplier if active
    /// 
    /// # Fees
    /// 
    /// Buy fee is deducted from input amount:
    /// - Platform fee (tenant level)
    /// - Group fee (market group level)
    /// - Net amount used for token purchase
    /// 
    /// # Slippage Protection
    /// 
    /// Transaction reverts if `tokens_received < min_token_out`
    pub fn buy_with_exact_cash_in(_ctx: Context<BuyWithExactCashInAccounts>, _cash_in: u64, _min_token_out: u64) -> Result<BuyEvent> {
        panic!("not implemented")
    }

    /// Buy market tokens and immediately deposit as collateral.
    /// 
    /// Combines token purchase with collateral deposit in a single atomic transaction.
    /// Useful for users who want to immediately use purchased tokens as collateral for
    /// borrowing operations.
    /// 
    /// # Arguments
    /// 
    /// * `cash_in` - Exact amount of main tokens to spend
    /// * `min_token_out` - Minimum market tokens to receive
    /// 
    /// # Transaction Flow
    /// 
    /// 1. Deduct fees from input amount
    /// 2. Purchase tokens at current curve price
    /// 3. Deposit all tokens into personal position
    /// 4. Update position's collateral balance
    /// 
    /// # Requirements
    /// 
    /// - Personal position must exist (call `personal_position_init` first)
    /// - Sufficient main token balance
    /// - Market must allow buying and deposits
    /// 
    /// # Benefits
    /// 
    /// - Single transaction reduces costs
    /// - Atomic operation prevents MEV
    /// - Immediate collateral availability
    pub fn buy_with_exact_cash_in_and_deposit(_ctx: Context<BuyWithExactCashInAndDepositAccounts>, _cash_in: u64, _min_token_out: u64) -> Result<BuyWithExactCashInAndDepositEvent> {
        panic!("not implemented")
    }

    /// Buy market tokens and immediately deposit as collateral with debt.
    /// 
    /// Combines token purchase with collateral deposit in a single atomic transaction.
    /// Useful for users who want to immediately use purchased tokens as collateral for
    /// borrowing operations.
    /// 
    /// # Arguments
    /// 
    /// * `args` - Arguments for the transaction
    /// - `exact_cash_in` - Exact amount of cash to spend on tokens
    /// - `min_token_received` - Minimum acceptable tokens to receive (slippage protection)
    /// - `new_acquired_debt` - New debt amount to take on
    pub fn buy_with_exact_cash_in_and_deposit_with_debt(_ctx: Context<BuyWithExactCashInAndDepositWithDebtAccounts>, _args: BuyWithExactCashInAndDepositWithDebtArgs) -> Result<BuyWithExactCashInAndDepositWithDebtEvent> {
        panic!("not implemented")
    }

    /// Sell exact amount of market tokens for main tokens.
    /// 
    /// Sells a specific number of market tokens and receives main tokens (e.g., USDC)
    /// based on the current bonding curve price. Includes slippage protection through
    /// minimum output requirement.
    /// 
    /// # Arguments
    /// 
    /// * `amount_in` - Exact number of market tokens to sell
    /// * `cash_out_min` - Minimum main tokens to receive (reverts if not met)
    /// 
    /// # Price Calculation
    /// 
    /// Sell price follows bonding curve in reverse:
    /// - Reduces token supply, moving down the curve
    /// - Higher supplies sell at higher prices first
    /// - Cannot sell below floor price
    /// 
    /// # Fees
    /// 
    /// Sell fee is deducted from output amount:
    /// - Gross proceeds calculated from curve
    /// - Platform and group fees deducted
    /// - Net amount sent to seller
    /// 
    /// # Market Impact
    /// 
    /// Large sells may experience price slippage as they move down the curve.
    /// Consider breaking into smaller transactions for better execution.
    pub fn sell_with_exact_token_in(_ctx: Context<SellWithExactTokenInAccounts>, _amount_in: u64, _cash_out_min: u64) -> Result<SellWithExactTokenInEvent> {
        panic!("not implemented")
    }

    /// Withdraw collateral and sell tokens in one transaction.
    /// 
    /// Atomically withdraws market tokens from a personal position and sells them for
    /// main tokens. Useful for exiting collateralized positions or taking profits.
    /// 
    /// # Arguments
    /// 
    /// * `amount_in` - Number of tokens to withdraw and sell
    /// * `cash_out_min` - Minimum main tokens to receive
    /// 
    /// # Transaction Flow
    /// 
    /// 1. Withdraw tokens from personal position
    /// 2. Check position remains healthy (if debt exists)
    /// 3. Sell tokens on bonding curve
    /// 4. Transfer proceeds to user
    /// 
    /// # Position Health
    /// 
    /// If position has outstanding debt:
    /// - Remaining collateral must maintain required LTV
    /// - Transaction reverts if withdrawal would enable liquidation
    /// - Consider repaying debt before large withdrawals
    /// 
    /// # Use Cases
    /// 
    /// - Taking profits while maintaining position
    /// - Reducing exposure during market volatility
    /// - Exiting positions efficiently
    pub fn sell_with_exact_token_in_after_withdraw(_ctx: Context<SellWithExactTokenInAfterWithdrawAccounts>, _amount_in: u64, _cash_out_min: u64) -> Result<SellWithExactTokenInAfterWithdrawEvent> {
        panic!("not implemented")
    }

    /// Deposit market tokens as collateral into personal position.
    /// 
    /// Adds market tokens to your position's collateral balance, enabling borrowing
    /// operations. Deposited tokens remain locked until withdrawn or liquidated.
    /// 
    /// # Arguments
    /// 
    /// * `amount` - Number of market tokens to deposit
    /// 
    /// # Collateral Benefits
    /// 
    /// - Enables borrowing main tokens up to LTV limit
    /// - Earns potential appreciation if floor price rises
    /// - Protects position from liquidation
    /// - Can be withdrawn anytime (if position healthy)
    /// 
    /// # Requirements
    /// 
    /// - Personal position must exist
    /// - Sufficient token balance in wallet
    /// - Market must allow deposits
    pub fn deposit(_ctx: Context<DepositAccounts>, _amount: u64) -> Result<DepositEvent> {
        panic!("not implemented")
    }

    /// Withdraw collateral from personal position.
    /// 
    /// Removes market tokens from collateral, returning them to your wallet. Withdrawal
    /// is only allowed if the position remains healthy after removal.
    /// 
    /// # Arguments
    /// 
    /// * `amount` - Number of market tokens to withdraw
    /// 
    /// # Health Requirements
    /// 
    /// If position has debt:
    /// - Remaining collateral value must exceed debt × (1 / LTV)
    /// - Example: $1000 debt at 80% LTV requires $1250 collateral
    /// - Transaction reverts if health check fails
    /// 
    /// # Full Withdrawal
    /// 
    /// To withdraw all collateral:
    /// 1. Repay all outstanding debt first
    /// 2. Then withdraw full collateral balance
    pub fn withdraw(_ctx: Context<WithdrawAccounts>, _amount: u64) -> Result<WithdrawEvent> {
        panic!("not implemented")
    }

    /// Borrow main tokens against deposited collateral.
    /// 
    /// Takes a loan in main tokens (e.g., USDC) using market tokens as collateral.
    /// Borrowed amount is limited by position's collateral value and market LTV ratio.
    /// 
    /// # Arguments
    /// 
    /// * `amount` - Amount of main tokens to borrow
    /// 
    /// # Borrowing Limits
    /// 
    /// Maximum borrow = Collateral Value × LTV Ratio
    /// - Collateral valued at current floor price
    /// - LTV typically 50-80% depending on market
    /// - Cannot exceed available market liquidity
    /// 
    /// # Interest Accrual
    /// 
    /// - Interest calculated per-second at market rate
    /// - Compounds continuously on outstanding debt
    /// - Rate may vary based on utilization
    /// 
    /// # Liquidation Risk
    /// 
    /// Position can be liquidated if:
    /// - Market token price drops significantly
    /// - Accumulated interest pushes debt above limit
    /// - Market LTV parameters change
    /// 
    /// Monitor position health regularly to avoid liquidation.
    pub fn borrow(_ctx: Context<BorrowAccounts>, _amount: u64) -> Result<BorrowEvent> {
        panic!("not implemented")
    }

    /// Repay borrowed main tokens to reduce debt.
    /// 
    /// Repays outstanding debt in main tokens, reducing position's obligations and
    /// improving health factor. Can repay partial or full amounts.
    /// 
    /// # Arguments
    /// 
    /// * `amount` - Amount of main tokens to repay
    /// 
    /// # Repayment Order
    /// 
    /// Payments apply to:
    /// 1. Accrued interest first
    /// 2. Principal debt second
    /// 
    /// # Benefits of Repayment
    /// 
    /// - Reduces liquidation risk
    /// - Stops interest accrual on repaid amount
    /// - Frees up borrowing capacity
    /// - Enables collateral withdrawal
    /// 
    /// # Full Repayment
    /// 
    /// To close position completely:
    /// 1. Repay all debt including accrued interest
    /// 2. Withdraw all collateral
    /// 3. Position can then be closed if desired
    pub fn repay(_ctx: Context<RepayAccounts>, _amount: u64) -> Result<RepayEvent> {
        panic!("not implemented")
    }

    /// Withdraw collateral, sell it, and optionally repay debt from proceeds.
    /// 
    /// Atomically combines withdraw, sell, and repay operations. Withdraws collateral tokens
    /// from personal position, sells them back to the market, optionally repays debt from
    /// the proceeds, and transfers remaining cash to the user.
    /// 
    /// # Arguments
    /// 
    /// * `args.collateral_reduce_by` - Amount of collateral tokens to withdraw and sell
    /// * `args.debt_reduce_by` - Amount of debt to repay from sale proceeds (can be 0)
    /// * `args.min_cash_to_user` - Minimum cash to receive after repaying debt (slippage protection)
    /// 
    /// # Operation Flow
    /// 
    /// 1. Withdraw collateral from position
    /// 2. Sell withdrawn collateral to market
    /// 3. Repay debt from sale proceeds (if debt_reduce_by > 0)
    /// 4. Transfer remaining cash to user
    /// 
    /// # Slippage Protection
    /// 
    /// Transaction fails if:
    /// - Sale proceeds < debt_reduce_by + min_cash_to_user
    /// - Protects against unfavorable price movements
    /// 
    /// # Debt Repayment
    /// 
    /// - Debt repayment is optional (debt_reduce_by can be 0)
    /// - If repaying, permission checks ensure repay is allowed
    /// - Remaining sale proceeds go to user after repayment
    /// 
    /// # Use Cases
    /// 
    /// - Close leveraged position: withdraw all collateral, sell, repay all debt
    /// - Partial deleverage: reduce position and debt simultaneously
    /// - Take profit: withdraw and sell collateral, keep debt unchanged (debt_reduce_by = 0)
    pub fn withdraw_sell_and_repay(_ctx: Context<WithdrawSellAndRepayAccounts>, _args: WithdrawSellAndRepayArgs) -> Result<WithdrawSellAndRepayEvent> {
        panic!("not implemented")
    }

    /// Exercise option tokens to purchase market tokens at floor price.
    /// 
    /// Converts option tokens into market tokens by paying the floor price in main tokens.
    /// This allows option holders to acquire tokens at a fixed price regardless of current
    /// market price.
    /// 
    /// # Arguments
    /// 
    /// * `amount` - Number of option tokens to exercise
    /// 
    /// # Economics
    /// 
    /// For each option token:
    /// - Pay: 1 unit of main token × floor price
    /// - Receive: 1 market token
    /// - Burn: 1 option token
    /// 
    /// # Profitability
    /// 
    /// Profitable when: Current Price > Floor Price + Exercise Fee
    /// - Check current bonding curve price
    /// - Account for exercise fees
    /// - Consider immediate sell vs holding
    /// 
    /// # Requirements
    /// 
    /// - Sufficient option token balance
    /// - Sufficient main tokens for payment
    /// - Market must allow option exercise
    pub fn exercise_options(_ctx: Context<ExerciseOptionsAccounts>, _amount: u64) -> Result<ExerciseOptionsEvent> {
        panic!("not implemented")
    }

    /// Redeem market tokens at the guaranteed floor price.
    /// 
    /// Allows token holders to exit at the floor price when market price is at or near
    /// the floor. This provides downside protection and ensures minimum redemption value.
    /// 
    /// # Arguments
    /// 
    /// * `amount_tokens_in` - Number of market tokens to redeem
    /// 
    /// # Redemption Limits
    /// 
    /// Maximum redeemable = Tail Width = (tail_start - shoulder_end)
    /// - Protects bonding curve integrity
    /// - Ensures sufficient liquidity for all holders
    /// - Resets as tokens are bought back
    /// 
    /// # Price Guarantee
    /// 
    /// Receives: Floor Price × Tokens - Fees
    /// - Always redeems at floor regardless of curve position
    /// - Sell fees still apply (platform + group)
    /// - Net proceeds = floor_price × tokens × (1 - total_fee_rate)
    /// 
    /// # Use Cases
    /// 
    /// - Exit strategy during market downturns
    /// - Arbitrage when market price < floor
    /// - Risk management for large positions
    pub fn redeem_at_floor(_ctx: Context<RedeemAtFloorAccounts>, _amount_tokens_in: u64) -> Result<RedeemAtFloorEvent> {
        panic!("not implemented")
    }

    /// Initialize a multi-curve market with Dutch auction configuration.
    /// 
    /// Creates a market using a multi-segment bonding curve that provides more flexibility
    /// than linear markets. Supports variable-length price curves with multiple segments,
    /// each with its own slope. Includes Dutch auction for initial price discovery.
    /// 
    /// # Arguments
    /// 
    /// * `args` - Configuration including:
    /// - `floor`: Base price per token
    /// - `target`: Maximum price per token
    /// - `shoulder_start` / `shoulder_end`: Range for initial linear segment
    /// - `tail_start`: Beginning of constant max price segment
    /// - `middle_segments`: Array of intermediate curve segments
    /// - Dutch auction parameters (multiplier, duration, start time)
    /// 
    /// # Multi-Curve Advantages
    /// 
    /// - Flexible price discovery through custom segments
    /// - Better modeling of complex tokenomics
    /// - Smooth transitions between price regions
    /// - Support for non-linear growth patterns
    /// 
    /// # Segment Structure
    /// 
    /// 1. Floor: Constant price from 0 to shoulder_start
    /// 2. First shoulder: Linear from shoulder_start to first middle segment
    /// 3. Middle segments: Variable slopes and ranges (can be empty)
    /// 4. Final shoulder: From last middle segment to shoulder_end
    /// 5. Tail: Constant max price from tail_start onward
    /// 
    /// # Access Control
    /// 
    /// Only the market group admin can create new markets.
    pub fn multi_market_init_with_dutch(_ctx: Context<MultiMarketInitWithDutchAccounts>, _args: MultiMarketInitWithDutchArgs) -> Result<()> {
        panic!("not implemented")
    }

    /// Raise floor price for multi-curve markets with validation.
    /// 
    /// Increases the minimum token price while preserving the total area under the
    /// multi-segment curve. More complex than linear markets due to multiple segments
    /// requiring coordinated adjustment.
    /// 
    /// # Arguments
    /// 
    /// * `args` - Parameters including:
    /// - `new_floor`: Target floor price
    /// - `new_shoulder_end`: Adjusted endpoint for price curve
    /// - `new_middle_segments`: Recalculated intermediate segments
    /// - `max_deviation_bps`: Tolerance for area preservation
    /// 
    /// # Segment Adjustment
    /// 
    /// When floor rises:
    /// 1. All segments shift up by floor delta
    /// 2. Slopes adjust to maintain total area
    /// 3. Segment boundaries may compress
    /// 4. Continuity preserved at all transitions
    /// 
    /// # Validation Checks
    /// 
    /// - Area preservation within tolerance
    /// - Sufficient backing liquidity
    /// - Valid segment progression (monotonic)
    /// - No instant arbitrage opportunities
    /// 
    /// # Complexity Note
    /// 
    /// Multi-curve floor raising requires careful calculation to maintain curve
    /// properties across all segments while preserving economic invariants.
    pub fn raise_floor_preserve_area_checked_multi(_ctx: Context<RaiseFloorPreserveAreaCheckedMultiAccounts>, _args: RaiseFloorPreserveAreaCheckedMultiArgs) -> Result<RaiseFloorPreserveAreaCheckedEvent> {
        panic!("not implemented")
    }

    /// Buy from multi-curve market and deposit as collateral.
    /// 
    /// Purchases tokens from a multi-segment bonding curve and immediately deposits them
    /// into a personal position. Combines acquisition and collateralization in one step.
    /// 
    /// # Arguments
    /// 
    /// * `cash_in` - Exact amount of main tokens to spend
    /// * `min_token_out` - Minimum tokens to receive (slippage protection)
    /// 
    /// # Multi-Curve Pricing
    /// 
    /// Price depends on current supply position:
    /// - Traverses multiple segments with different slopes
    /// - Large buys may span several segments
    /// - Each segment calculated independently
    /// - Dutch boost applies if active
    /// 
    /// # Atomic Benefits
    /// 
    /// - Single transaction for buy + deposit
    /// - Reduces transaction costs
    /// - Prevents front-running between operations
    /// - Immediate collateral availability
    /// 
    /// # Requirements
    /// 
    /// - Personal position must exist
    /// - Market must allow buying and deposits
    /// - Sufficient main token balance
    pub fn buy_with_exact_cash_in_and_deposit_multi(_ctx: Context<BuyWithExactCashInAndDepositMultiAccounts>, _cash_in: u64, _min_token_out: u64) -> Result<BuyWithExactCashInAndDepositEvent> {
        panic!("not implemented")
    }

    /// Buy tokens from a multi-curve market.
    /// 
    /// Purchases market tokens using a multi-segment bonding curve that can model
    /// complex price dynamics. Supports large purchases that span multiple curve
    /// segments with different characteristics.
    /// 
    /// # Arguments
    /// 
    /// * `cash_in` - Exact amount of main tokens to spend
    /// * `min_token_out` - Minimum tokens required (reverts if not met)
    /// 
    /// # Execution Across Segments
    /// 
    /// Large purchases may traverse multiple segments:
    /// 1. Start at current supply position
    /// 2. Buy at current segment's price/slope
    /// 3. If segment exhausted, continue to next
    /// 4. Accumulate tokens from each segment
    /// 5. Stop when cash exhausted or curve end reached
    /// 
    /// # Price Impact
    /// 
    /// - Each segment may have different price sensitivity
    /// - Steeper slopes mean higher price impact
    /// - Consider breaking very large orders
    /// 
    /// # Fees
    /// 
    /// Standard fee structure applies:
    /// - Platform fee to tenant
    /// - Group fee to market admin
    /// - Deducted from input amount
    pub fn buy_with_exact_cash_in_multi(_ctx: Context<BuyWithExactCashInMultiAccounts>, _cash_in: u64, _min_token_out: u64) -> Result<BuyEvent> {
        panic!("not implemented")
    }

    /// Sell tokens to a multi-curve market.
    /// 
    /// Sells market tokens back to the protocol following the multi-segment bonding curve
    /// in reverse. Large sales may span multiple segments with varying price impacts.
    /// 
    /// # Arguments
    /// 
    /// * `amount_in` - Exact number of tokens to sell
    /// * `cash_out_min` - Minimum main tokens to receive
    /// 
    /// # Multi-Segment Execution
    /// 
    /// Sells work backwards through curve:
    /// 1. Start at current supply position
    /// 2. Sell into current segment at its price
    /// 3. If more to sell, move to previous segment
    /// 4. Continue until all tokens sold
    /// 5. Cannot sell below floor price
    /// 
    /// # Price Discovery
    /// 
    /// - Higher supplies sell first (higher prices)
    /// - Price decreases as supply reduces
    /// - Each segment has independent characteristics
    /// - Floor provides absolute minimum
    /// 
    /// # Slippage Considerations
    /// 
    /// Multi-curve markets may have:
    /// - Variable liquidity across segments
    /// - Sudden price changes at boundaries
    /// - Different impacts in different regions
    pub fn sell_with_exact_token_in_multi(_ctx: Context<SellWithExactTokenInMultiAccounts>, _amount_in: u64, _cash_out_min: u64) -> Result<SellWithExactTokenInEvent> {
        panic!("not implemented")
    }

    /// Exercise options in a multi-curve market.
    /// 
    /// Converts option tokens to market tokens at the floor price, regardless of the
    /// current position on the multi-segment curve. Options provide downside protection
    /// in volatile multi-curve markets.
    /// 
    /// # Arguments
    /// 
    /// * `amount` - Number of option tokens to exercise
    /// 
    /// # Exercise Mechanics
    /// 
    /// Same as linear markets:
    /// - Pay floor price per option in main tokens
    /// - Receive one market token per option
    /// - Options are burned
    /// 
    /// # Multi-Curve Considerations
    /// 
    /// - Floor price is constant across all segments
    /// - Current curve position doesn't affect exercise
    /// - Especially valuable when price is in higher segments
    /// - Provides arbitrage during market dislocations
    /// 
    /// # Strategic Use
    /// 
    /// In multi-curve markets, options help:
    /// - Navigate complex price dynamics
    /// - Profit from segment transitions
    /// - Hedge against curve adjustments
    pub fn exercise_options_multi(_ctx: Context<ExerciseOptionsMultiAccounts>, _amount: u64) -> Result<ExerciseOptionsEvent> {
        panic!("not implemented")
    }

    /// Repay debt in a multi-curve market.
    /// 
    /// Repays borrowed main tokens to reduce debt obligations in a personal position.
    /// Multi-curve markets may have different interest dynamics based on utilization
    /// across curve segments.
    /// 
    /// # Arguments
    /// 
    /// * `amount` - Amount of main tokens to repay
    /// 
    /// # Interest Considerations
    /// 
    /// Multi-curve markets may feature:
    /// - Variable rates based on curve position
    /// - Different risk profiles across segments
    /// - Dynamic rate adjustments
    /// 
    /// # Repayment Priority
    /// 
    /// Same as linear markets:
    /// 1. Accrued interest first
    /// 2. Principal balance second
    /// 3. Excess returned to payer
    /// 
    /// # Position Management
    /// 
    /// Regular repayments recommended to:
    /// - Maintain healthy LTV ratios
    /// - Reduce liquidation risk
    /// - Take advantage of rate changes
    pub fn repay_multi(_ctx: Context<RepayMultiAccounts>, _amount: u64) -> Result<RepayEvent> {
        panic!("not implemented")
    }

    /// Redeem tokens at floor price in multi-curve market.
    /// 
    /// Provides guaranteed exit at the floor price for multi-curve market tokens.
    /// Essential safety mechanism given the complexity of multi-segment pricing.
    /// 
    /// # Arguments
    /// 
    /// * `amount_tokens_in` - Number of tokens to redeem at floor
    /// 
    /// # Redemption in Complex Markets
    /// 
    /// Multi-curve considerations:
    /// - Floor constant across all segments
    /// - Redemption bypasses curve complexity
    /// - Same tail width limits apply
    /// - Critical during segment transitions
    /// 
    /// # Maximum Redemption
    /// 
    /// Limited to tail width: (tail_start - shoulder_end)
    /// - Protects curve integrity
    /// - Ensures fair access for all holders
    /// - Resets as market activity continues
    /// 
    /// # Use Cases
    /// 
    /// Especially important in multi-curve markets for:
    /// - Exiting during curve adjustments
    /// - Arbitrage across segments
    /// - Risk management in complex dynamics
    /// - Guaranteed liquidity provision
    pub fn redeem_at_floor_multi(_ctx: Context<RedeemAtFloorMultiAccounts>, _amount_tokens_in: u64) -> Result<RedeemAtFloorEvent> {
        panic!("not implemented")
    }

    /// Modify the price curve's sensitivity to supply changes at the current token supply level.
    /// 
    /// Allows market administrators to dynamically adjust how quickly the token price changes
    /// in response to supply increases. The modification is applied at the current token supply
    /// level and affects the curve's behavior for all future supply levels beyond that point.
    /// 
    /// # Arguments
    /// 
    /// * `args` - Curve modification parameters including:
    /// - `multiplier`: Magnitude of slope change (0.0 < multiplier < 1.0)
    /// - `new_middle_segment_count`: Expected number of middle segments after modification
    /// - `increase`: Whether to increase (true) or decrease (false) sensitivity
    /// 
    /// # How it works
    /// 
    /// The function modifies the curve's vertex structure by either:
    /// - **Inserting a new vertex** at the current supply level if it falls within the final segment
    /// - **Removing the last vertex** if the current supply is not in the final segment and the
    /// sensitivity direction doesn't match the final segment's current direction
    /// 
    /// # Sensitivity Direction
    /// 
    /// - **`increase = true`** (`SensitivityDirection::Higher`): Makes the curve more sensitive to supply changes
    /// - Results in steeper slopes = faster price increases as supply grows
    /// - Useful for encouraging early adoption or responding to high demand
    /// 
    /// - **`increase = false`** (`SensitivityDirection::Lower`): Makes the curve less sensitive to supply changes
    /// - Results in gentler slopes = slower price increases as supply grows
    /// - Useful for risk management or stabilizing prices in volatile conditions
    /// 
    /// # Multiplier Effect
    /// 
    /// The `multiplier` parameter (0.0 < multiplier < 1.0) determines the magnitude of change:
    /// - For `Higher` direction: new_slope = current_slope × (1 + multiplier)
    /// - For `Lower` direction: new_slope = current_slope × (1 - multiplier)
    /// 
    /// # Access Control
    /// 
    /// Only the market group admin can modify curves.
    /// 
    /// # Use Cases
    /// 
    /// - **Market Making**: Adjust sensitivity based on trading volume or market volatility
    /// - **Risk Management**: Reduce sensitivity in high-supply regions to prevent extreme price swings
    /// - **Liquidity Provision**: Increase sensitivity in low-supply regions to encourage early adoption
    /// - **Dynamic Pricing**: Respond to market conditions by modifying curve behavior
    /// 
    /// # Constraints
    /// 
    /// - `multiplier` must be between 0.0 and 1.0 (exclusive)
    /// - The function preserves curve continuity at segment boundaries
    /// - Modifications only affect the curve beyond the current supply level
    /// - The account must be reallocated to accommodate the new segment count
    /// 
    /// # Safety Considerations
    /// 
    /// - Changes are irreversible once applied
    /// - The operation will panic if the actual number of middle segments after modification
    /// doesn't match the expected `new_middle_segment_count`
    /// - Consider market impact before significant changes
    /// - Monitor market behavior after curve changes
    pub fn modify_curve_multi(_ctx: Context<ModifyCurveMultiAccounts>, _args: ModifyCurveArgs) -> Result<()> {
        panic!("not implemented")
    }

}

// Instruction account structures
#[derive(Accounts)]
pub struct VersionAccounts<'info> {
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
}

#[derive(Accounts)]
pub struct InitLogAccountAccounts<'info> {
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub system_program: AccountInfo<'info>,
}

#[derive(Accounts)]
pub struct ReceiveLogAccounts<'info> {
    #[account(mut, signer)]
    pub log_account: AccountInfo<'info>,
}

#[derive(Accounts)]
pub struct TestLogAccounts<'info> {
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub self_program: AccountInfo<'info>,
}

/// Initialize a platform tenant.
/// 
/// Tenants are the top-level organizational units in the protocol. Each tenant can have
/// multiple market groups, and receives a portion of all fees generated by markets under
/// their umbrella.
/// 
/// # Arguments
/// 
/// * `fee_micro_bps` - Platform fee rate in micro basis points (1 micro bp = 0.0001%).
/// This fee is taken from all market operations and distributed to the tenant.
/// * `permissionless_group_creation` - If true, anyone can create market groups under this
/// tenant. If false, only the tenant admin can create new groups.
/// 
/// # Access Control
/// 
/// This instruction can only be called by the program itself (root authority).
#[derive(Accounts)]
pub struct TenantInitAccounts<'info> {
    /// Account paying for the tenant account creation.
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    /// Root authority (the program itself) authorizing tenant creation.
    #[account(signer)]
    pub root: AccountInfo<'info>,
    /// Seed signer used to derive the tenant's PDA address.
    #[account(signer)]
    pub tenant_seed: AccountInfo<'info>,
    /// The new tenant account being initialized.
    #[account(mut)]
    pub tenant: AccountInfo<'info>,
    /// System program for creating the tenant account.
    pub system_program: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Initialize a platform tenant with an admin.
/// 
/// This instruction is similar to `tenant_init` but allows specifying an admin
/// account that will have full control over the tenant.
/// 
/// # Arguments
/// 
/// * `fee_micro_bps` - Platform fee rate in micro basis points (1 micro bp = 0.0001%).
/// This fee is taken from all market operations and distributed to the tenant.
/// * `permissionless_group_creation` - If true, anyone can create market groups under this
/// tenant. If false, only the tenant admin can create new groups.
/// * `admin` - Public key of the admin account that will have full control over the tenant.
#[derive(Accounts)]
pub struct TenantInitWithAdminAccounts<'info> {
    /// Account paying for the tenant account creation.
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    /// Root authority (the program itself) authorizing tenant creation.
    #[account(signer)]
    pub root: AccountInfo<'info>,
    /// Seed signer used to derive the tenant's PDA address.
    #[account(signer)]
    pub tenant_seed: AccountInfo<'info>,
    /// The new tenant account being initialized.
    #[account(mut)]
    pub tenant: AccountInfo<'info>,
    /// System program for creating the tenant account.
    pub system_program: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Propose a new admin for the tenant.
/// 
/// Initiates a two-step ownership transfer process. The current admin proposes a new admin,
/// who must then accept the role using `tenant_accept_new_admin`.
#[derive(Accounts)]
pub struct TenantProposeAdminAccounts<'info> {
    /// Current tenant admin proposing the transfer.
    #[account(mut, signer)]
    pub admin: AccountInfo<'info>,
    /// Tenant account for which a new admin is being proposed.
    #[account(mut)]
    pub tenant: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Accept admin ownership of a tenant.
/// 
/// Completes the two-step ownership transfer process. The proposed admin calls this
/// instruction to accept control of the tenant.
#[derive(Accounts)]
pub struct TenantAcceptNewAdminAccounts<'info> {
    /// The proposed admin accepting ownership of the tenant.
    #[account(mut, signer)]
    pub new_admin: AccountInfo<'info>,
    /// Tenant account whose ownership is being transferred.
    #[account(mut)]
    pub tenant: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Change the fee rate for a tenant.
/// 
/// Updates the platform fee rate applied to all market operations under this tenant.
#[derive(Accounts)]
pub struct TenantChangeFeeMbpsAccounts<'info> {
    /// Payer of the fee.
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    /// Root authority (the program itself) authorized to change the fee
    #[account(signer)]
    pub root: AccountInfo<'info>,
    /// Tenant account whose platform fee is being updated.
    #[account(mut)]
    pub tenant: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Initialize a market group under a tenant.
/// 
/// Market groups are collections of markets that share the same fee structure and admin.
/// Each group can contain multiple markets with different token pairs and price curves.
/// The group admin has control over all markets within the group and collects trading fees.
/// 
/// # Arguments
/// 
/// * `args` - Initialization arguments containing:
/// - `fees`: Fee structure for buy, sell, borrow, and exercise operations
/// - `group_admin`: Public key that will administer this market group
/// 
/// # Access Control
/// 
/// If the tenant has `permissionless_group_creation` disabled, only the tenant admin
/// can create new market groups.
#[derive(Accounts)]
pub struct MarketGroupInitAccounts<'info> {
    /// Account paying for the market group account creation.
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    /// Tenant account that will own this market group.
    pub tenant: AccountInfo<'info>,
    /// Optional account, which only needs to match if the tenant does not allow permissionless group creation
    /// Must be the tenant admin if permissionless creation is disabled.
    #[account(signer)]
    pub tenant_admin: AccountInfo<'info>,
    /// Seed signer used to derive the market group's PDA address.
    #[account(signer)]
    pub seed: AccountInfo<'info>,
    /// The new market group account being initialized.
    #[account(mut)]
    pub market_group: AccountInfo<'info>,
    /// System program for creating the market group account.
    pub system_program: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Propose a new admin for the market group.
/// 
/// Initiates a two-step ownership transfer process. The current admin proposes a new admin,
/// who must then accept the role using `market_group_accept_new_admin`.
/// 
/// # Arguments
/// 
/// * `new_admin` - Public key of the proposed new admin
/// 
/// # Access Control
/// 
/// Only the current market group admin can propose a new admin.
/// 
/// # Security
/// 
/// Two-step transfer prevents accidental loss of admin control by requiring the new admin
/// to explicitly accept the role.
#[derive(Accounts)]
pub struct MarketGroupProposeAdminAccounts<'info> {
    /// Current market group admin proposing the transfer.
    #[account(mut, signer)]
    pub admin: AccountInfo<'info>,
    /// Market group account for which a new admin is being proposed.
    #[account(mut)]
    pub market_group: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Accept admin ownership of a market group.
/// 
/// Completes the two-step ownership transfer process. The proposed admin calls this
/// instruction to accept control of the market group.
/// 
/// # Access Control
/// 
/// Only the proposed new admin can accept ownership.
/// 
/// # Effects
/// 
/// - Transfers full admin control to the new admin
/// - Clears the proposed admin field
/// - The new admin gains ability to:
/// - Create new markets in the group
/// - Change group fees
/// - Collect accumulated revenue
/// - Modify market permissions
#[derive(Accounts)]
pub struct MarketGroupAcceptNewAdminAccounts<'info> {
    /// The proposed admin accepting ownership of the market group.
    #[account(mut, signer)]
    pub new_admin: AccountInfo<'info>,
    /// Market group account whose ownership is being transferred.
    #[account(mut)]
    pub market_group: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Initialize a linear market with a simple price curve.
/// 
/// Creates a new market with a linear bonding curve that determines token prices based on
/// supply. The curve has three segments: floor (constant price), shoulder (linear increase),
/// and tail (constant max price).
/// 
/// # Arguments
/// 
/// * `market_linear_args` - Configuration parameters including:
/// - `floor`: Minimum price per token (floor price)
/// - `target`: Target price where the shoulder segment ends
/// - `slope_numerator` / `slope_denominator`: Rate of price increase in shoulder segment
/// - `shoulder_start` / `shoulder_end`: Token supply range for linear price growth
/// - `tail_start`: Token supply where max price is reached
/// - `permissions`: Trading restrictions and feature flags
/// 
/// # Access Control
/// 
/// Only the market group admin can create new markets.
/// 
/// # Created Accounts
/// 
/// - Market account storing price curve and state
/// - Token mint for the market's synthetic token
/// - Option token mint for exercisable options
/// - Liquidity vault holding backing collateral
/// - Revenue escrow accounts for fee collection
#[derive(Accounts)]
pub struct MarketLinearInitAccounts<'info> {
    /// Account paying for the creation of new accounts and transaction fees.
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    /// Market group admin authorizing the creation of this new market.
    #[account(mut, signer)]
    pub group_admin: AccountInfo<'info>,
    /// Seed signer used to derive the market_meta PDA address.
    #[account(signer)]
    pub seed: AccountInfo<'info>,
    /// Tenant account that owns the market group.
    pub tenant: AccountInfo<'info>,
    /// Market group account that will contain this market.
    /// Must be owned by the tenant and administered by group_admin.
    pub market_group: AccountInfo<'info>,
    /// Mint of the main token (e.g., USDC, SOL) used as the market's base currency.
    pub mint_main: AccountInfo<'info>,
    /// The token mint for this market's derivative token.
    /// This account must be created in a previous instruction
    /// With supply set to zero
    /// And mint authority assigned to the market_meta
    pub mint_token: AccountInfo<'info>,
    /// Mint for option tokens that can be exercised to purchase market tokens.
    #[account(mut)]
    pub mint_options: AccountInfo<'info>,
    /// Liquidity vault holding the main token reserves for this market.
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    /// Revenue escrow account for market group admin fees.
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    /// Revenue escrow account for tenant platform fees.
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    /// The linear market account storing price curve and state data.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Market metadata account storing configuration and token references.
    #[account(mut)]
    pub market_meta: AccountInfo<'info>,
    /// System program for creating new accounts.
    pub system_program: AccountInfo<'info>,
    /// Token program for the market's derivative token operations.
    pub token_program: AccountInfo<'info>,
    /// Token program interface for the main token operations.
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Initialize a linear market with Dutch auction price boost.
/// 
/// Creates a linear market with an additional Dutch auction mechanism that provides
/// temporary price boosts. The boost decays over time from a maximum multiplier down
/// to 1x (no boost).
/// 
/// # Arguments
/// 
/// * `market_linear_init_with_dutch_args` - Configuration containing:
/// - All standard linear market parameters (floor, target, slopes, etc.)
/// - `dutch_numerator` / `dutch_denominator`: Maximum price boost multiplier
/// - `dutch_duration`: Time in seconds for boost to decay from max to 1x
/// - `dutch_start`: Unix timestamp when the Dutch auction begins
/// 
/// # Dutch Auction Mechanics
/// 
/// - Initial boost: price × (dutch_numerator / dutch_denominator)
/// - Linear decay over dutch_duration seconds
/// - After duration expires, boost remains at 1x (no effect)
/// - Useful for token launches to incentivize early buyers
/// 
/// # Access Control
/// 
/// Only the market group admin can create new markets.
#[derive(Accounts)]
pub struct MarketLinearInitWithDutchAccounts<'info> {
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    #[account(mut, signer)]
    pub group_admin: AccountInfo<'info>,
    #[account(signer)]
    pub seed: AccountInfo<'info>,
    pub tenant: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    pub mint_main: AccountInfo<'info>,
    /// The token account for the market
    /// This account must be created in a previous instruction
    /// With supply set to zero
    /// And mint authority assigned to the market_meta
    pub mint_token: AccountInfo<'info>,
    #[account(mut)]
    pub mint_options: AccountInfo<'info>,
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
    #[account(mut)]
    pub market_meta: AccountInfo<'info>,
    pub system_program: AccountInfo<'info>,
    pub token_program: AccountInfo<'info>,
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Mint option tokens by depositing market tokens.
/// 
/// Converts market tokens into option tokens at a 1:1 ratio. Option tokens represent
/// the right to purchase market tokens at the floor price by depositing the main
/// backing token (e.g., USDC).
/// 
/// # Arguments
/// 
/// * `amount` - Number of market tokens to convert into options
/// 
/// # Requirements
/// 
/// - User must have sufficient market token balance
/// - Market must allow option minting (check permissions)
/// 
/// # Use Cases
/// 
/// - Hedge against price increases by locking in floor price
/// - Create structured products with downside protection
/// - Enable secondary markets for price speculation
#[derive(Accounts)]
pub struct MintOptionsAccounts<'info> {
    /// Market group admin authorized to mint options.
    #[account(mut, signer)]
    pub admin: AccountInfo<'info>,
    /// Market metadata linking to the options mint.
    pub market_meta: AccountInfo<'info>,
    /// Market group that must be administered by the signer.
    pub market_group: AccountInfo<'info>,
    /// Mint for option tokens to be created.
    #[account(mut)]
    pub mint_options: AccountInfo<'info>,
    /// Destination token account to receive minted options.
    #[account(mut)]
    pub options_dst: AccountInfo<'info>,
    /// Token program for minting option tokens.
    pub token_program: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Collect accumulated trading fees from a market group.
/// 
/// Transfers fee revenue from the group's escrow account to the admin's wallet.
/// Fees accumulate from all trading operations (buy, sell, borrow, exercise) across
/// all markets in the group.
/// 
/// # Arguments
/// 
/// * `amount` - Amount to collect:
/// - `FullOrPartialU64::Full`: Collect entire escrow balance
/// - `FullOrPartialU64::Partial(n)`: Collect specific amount `n`
/// 
/// # Access Control
/// 
/// Only the market group admin can collect revenue.
/// 
/// # Fee Distribution
/// 
/// Trading fees are split between:
/// - Tenant: Platform-level fee (set during tenant creation)
/// - Market Group: Admin fee (set during group creation)
/// 
/// This instruction collects only the group's portion.
#[derive(Accounts)]
pub struct MarketGroupCollectRevAccounts<'info> {
    /// Market group admin authorized to collect revenue.
    #[account(mut, signer)]
    pub group_admin: AccountInfo<'info>,
    /// Market group that has accumulated revenue.
    pub market_group: AccountInfo<'info>,
    /// Market metadata linking to the revenue escrow account.
    pub market_meta: AccountInfo<'info>,
    /// Mint of the main token for revenue collection.
    pub mint_main: AccountInfo<'info>,
    /// Revenue escrow account holding accumulated fees for the market group.
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    /// Destination token account to receive collected revenue.
    #[account(mut)]
    pub rev_dst: AccountInfo<'info>,
    /// Token program for transferring the revenue.
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Collect accumulated platform fees from a tenant.
/// 
/// Transfers platform fee revenue from the tenant's escrow account to the admin's wallet.
/// Platform fees accumulate from all trading operations (buy, sell, borrow, exercise) across
/// all markets under this tenant.
/// 
/// # Arguments
/// 
/// * `amount` - Amount to collect:
/// - `FullOrPartialU64::Full`: Collect entire escrow balance
/// - `FullOrPartialU64::Partial(n)`: Collect specific amount `n`
/// 
/// # Access Control
/// 
/// Only the tenant admin can collect platform revenue.
/// 
/// # Fee Distribution
/// 
/// Trading fees are split between:
/// - Tenant: Platform-level fee (set during tenant creation)
/// - Market Group: Admin fee (set during group creation)
/// 
/// This instruction collects only the tenant's platform fee portion.
#[derive(Accounts)]
pub struct TenantCollectRevAccounts<'info> {
    /// Root authority (the program itself) authorized to collect platform revenue.
    #[account(mut, signer)]
    pub root: AccountInfo<'info>,
    /// Market metadata linking to the revenue escrow account.
    pub market_meta: AccountInfo<'info>,
    /// Mint of the main token for revenue collection.
    pub mint_main: AccountInfo<'info>,
    /// Revenue escrow account holding accumulated platform fees for the tenant.
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    /// Destination token account to receive collected platform revenue.
    #[account(mut)]
    pub rev_dst: AccountInfo<'info>,
    /// Token program for transferring the revenue.
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// DEPRECATED: use raise_floor_preserve_area_checked2 instead, as it is more secure
/// 
/// Raise the market floor price while preserving bonding curve area.
/// 
/// Increases the minimum (floor) price of the market token while maintaining the
/// total area under the price curve. This ensures the market's total value capacity
/// remains constant while providing price support.
/// 
/// # Arguments
/// 
/// * `new_floor` - New minimum price per token (must be higher than current)
/// * `new_shoulder_end` - New token supply where shoulder segment ends
/// 
/// # Curve Adjustment
/// 
/// When the floor rises:
/// - Floor segment moves up to new price level
/// - Shoulder segment becomes steeper to preserve area
/// - Tail segment adjusts to maintain continuity
/// 
/// # Requirements
/// 
/// - Market must have excess liquidity to support higher floor
/// - New floor must be greater than current floor
/// - Curve area preservation must be mathematically valid
/// 
/// # Access Control
/// 
/// Can be triggered by authorized operators or through automated mechanisms.
#[derive(Accounts)]
pub struct RaiseFloorPreserveAreaAccounts<'info> {
    /// Market group admin authorized to adjust floor parameters.
    #[account(mut, signer)]
    pub admin: AccountInfo<'info>,
    /// Market group that must be administered by the signer.
    pub market_group: AccountInfo<'info>,
    /// Market metadata linking to the market group.
    pub market_meta: AccountInfo<'info>,
    /// Linear market account whose floor price will be raised.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// DEPRECATED: use raise_floor_preserve_area_checked2 instead, as it is more secure
/// 
/// Raise the floor price with additional validation checks.
/// 
/// Similar to `raise_floor_preserve_area` but includes extra safety checks to ensure
/// the operation maintains market integrity. Validates curve parameters and liquidity
/// requirements before applying changes.
/// 
/// # Arguments
/// 
/// * `args` - Parameters including:
/// - `new_floor`: Target floor price
/// - `new_shoulder_end`: Adjusted shoulder endpoint
/// - `max_deviation_bps`: Maximum allowed deviation in basis points
/// 
/// # Additional Checks
/// 
/// - Verifies sufficient backing liquidity exists
/// - Ensures curve area preservation within tolerance
/// - Validates no tokens would be instantly profitable to redeem
/// - Checks market state consistency after adjustment
/// 
/// # Use Cases
/// 
/// - Automated floor raising based on market conditions
/// - Protocol-driven price support mechanisms
/// - Treasury management operations
#[derive(Accounts)]
pub struct RaiseFloorPreserveAreaCheckedAccounts<'info> {
    #[account(mut, signer)]
    pub admin: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Raise the floor and preserve the area of the market
/// This instruction takes in constraints
/// * `new_floor` - The new floor price (must be greater than the current floor)
/// * `new_shoulder_end` - The new shoulder end (must be greater than the current shoulder end)
/// * `min_liq_ratio` - The minimum liquidity ratio (greater than or equal to 0.0)
/// * `max_area_shrinkage_tolerance_units` - The maximum token units that the total area of the curve is allowed to shrink by
/// This is set by the client to restrict overly aggressive floor raising, with a tolerance to account for "slippage"
/// 
/// # Access Control
/// Only the market group admin can raise the floor price.
#[derive(Accounts)]
pub struct RaiseFloorPreserveAreaChecked2Accounts<'info> {
    #[account(mut, signer)]
    pub admin: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// DEPRECATED: use raise_floor_from_excess_liquidity2 instead, as it is more secure
/// 
/// Raise the floor price using excess market liquidity.
/// 
/// Automatically increases the floor price when the market has accumulated excess
/// backing liquidity beyond what's needed for the current token supply. This provides
/// organic price appreciation based on market performance.
/// 
/// # Arguments
/// 
/// * `floor_increase_ratio` - Percentage increase for the floor price (as decimal)
/// - 0.1 = 10% increase
/// - 0.05 = 5% increase
/// - Must be positive and reasonable (typically < 0.5)
/// 
/// # Mechanism
/// 
/// 1. Calculates available excess liquidity (cash above backing requirements)
/// 2. Determines maximum sustainable floor increase
/// 3. Applies requested ratio (capped by available excess)
/// 4. Adjusts curve parameters to preserve total area
/// 
/// # Requirements
/// 
/// - Market must have excess liquidity
/// - Floor increase must be sustainable given current token supply
/// - Market permissions must allow floor raising
/// 
/// # Benefits
/// 
/// - Rewards token holders when market performs well
/// - Creates deflationary pressure through higher floor
/// - Maintains full backing at new price levels
#[derive(Accounts)]
pub struct RaiseFloorFromExcessLiquidityAccounts<'info> {
    #[account(mut, signer)]
    pub admin: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Raise the floor price using excess market liquidity.
/// 
/// Automatically increases the floor price when the market has accumulated excess
/// backing liquidity beyond what's needed for the current token supply. This provides
/// organic price appreciation based on market performance.
/// 
/// # Arguments
/// 
/// * `args` - Parameters including:
/// - `max_new_floor`: The maximum new floor that is allowed
/// - `increase_ratio_micro_basis_points`: The amount to increase the floor by, in micro basis points
/// 
/// # Access Control
/// 
/// Only the market group admin can raise the floor price.
/// 
/// # Use Cases
/// - Automated floor raising based on market conditions
/// - Protocol-driven price support mechanisms
/// - Treasury management operations
#[derive(Accounts)]
pub struct RaiseFloorFromExcessLiquidityCheckedAccounts<'info> {
    #[account(mut, signer)]
    pub admin: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Update market permissions and feature flags.
/// 
/// Controls which operations are allowed on a market. Can be used to pause trading,
/// disable specific features, or adjust market behavior.
/// 
/// # Arguments
/// 
/// * `new_flags` - New permission set including:
/// - `can_buy`: Allow token purchases
/// - `can_sell`: Allow token sales
/// - `can_borrow`: Allow borrowing against collateral
/// - `can_add_liquidity`: Allow liquidity donations
/// - `can_remove_liquidity`: Allow liquidity removal
/// - `can_open_position`: Allow new position creation
/// - `can_close_position`: Allow position closure
/// - `can_change_fees`: Allow fee adjustments
/// 
/// # Access Control
/// 
/// Only the market group admin can change market flags.
/// 
/// # Use Cases
/// 
/// - Emergency pause during security incidents
/// - Gradual feature rollout
/// - Market maintenance windows
/// - Compliance-driven restrictions
#[derive(Accounts)]
pub struct MarketFlagsChangeAccounts<'info> {
    /// Market group admin authorized to change market permissions.
    #[account(mut, signer)]
    pub admin: AccountInfo<'info>,
    /// Market group that must be administered by the signer.
    pub market_group: AccountInfo<'info>,
    /// Market metadata whose permissions will be updated.
    #[account(mut)]
    pub market_meta: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Update fee structure for all markets in a group.
/// 
/// Changes the fee rates charged on trading operations. New fees apply to all future
/// transactions across all markets within the group.
/// 
/// # Arguments
/// 
/// * `new_fees` - Updated fee structure:
/// - `buy`: Fee on token purchases (micro basis points)
/// - `sell`: Fee on token sales (micro basis points)
/// - `borrow`: Fee on borrowing operations (micro basis points)
/// - `exercise`: Fee on option exercise (micro basis points)
/// 
/// # Fee Calculation
/// 
/// Fees are specified in micro basis points where:
/// - 1 micro bp = 1/100 of a basis point = 0.0001%
/// - 100 micro bps = 1 basis point = 0.01%
/// - 10,000 micro bps = 100 basis points = 1%
/// - Example: 50 micro bps = 0.5 basis points = 0.005% fee
/// 
/// # Access Control
/// 
/// Only the market group admin can change fees.
/// 
/// # Considerations
/// 
/// - Changes affect all markets in the group immediately
/// - Cannot exceed maximum fee limits set by protocol
/// - Platform (tenant) fees are added on top of group fees
#[derive(Accounts)]
pub struct MarketGroupChangeFeesAccounts<'info> {
    /// Market group admin authorized to change fees.
    #[account(mut, signer)]
    pub admin: AccountInfo<'info>,
    /// Market group account whose fees will be updated.
    #[account(mut)]
    pub market_group: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Initialize a personal position account for market interaction.
/// 
/// Creates a user-specific account that tracks collateral deposits and debt obligations
/// for a particular market. Required before performing borrow operations or using
/// collateral-based features.
/// 
/// # Position Features
/// 
/// Personal positions enable:
/// - Collateral deposits (market tokens as collateral)
/// - Borrowing against collateral (up to LTV limits)
/// - Tracking debt obligations and interest
/// - Liquidation protection through collateralization
/// 
/// # Account Structure
/// 
/// - Unique per user per market
/// - Stores collateral and debt balances
/// - Tracks last update timestamp for interest
/// - Immutable market and owner references
/// 
/// # One-Time Setup
/// 
/// Each user needs only one position per market. Attempting to create a duplicate
/// will fail. The position persists until explicitly closed.
#[derive(Accounts)]
pub struct PersonalPositionInitAccounts<'info> {
    /// Account paying for the personal position and escrow account creation.
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    /// The owner who will control the personal position.
    pub owner: AccountInfo<'info>,
    /// Market metadata identifying which market this position belongs to.
    pub market_meta: AccountInfo<'info>,
    /// Mint for the market tokens that can be deposited as collateral.
    pub mint_token: AccountInfo<'info>,
    /// The new personal position account being initialized.
    #[account(mut)]
    pub personal_position: AccountInfo<'info>,
    /// Escrow token account for holding collateral tokens.
    #[account(mut)]
    pub escrow: AccountInfo<'info>,
    /// Token program for creating the escrow account.
    pub token_program: AccountInfo<'info>,
    /// System program for creating new accounts.
    pub system_program: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// DEPRECATED: use donate_liquidity2 instead, as v2 gets logged by the indexer
/// 
/// Donate backing liquidity to the market.
/// 
/// Adds main tokens (e.g., USDC) to the market's liquidity vault without receiving
/// market tokens in return. This creates excess liquidity that can be used to raise
/// the floor price or improve market stability.
/// 
/// # Arguments
/// 
/// * `amount` - Amount of main tokens to donate
/// 
/// # Effects
/// 
/// - Increases market's cash balance
/// - Creates excess liquidity (cash > backing requirements)
/// - Enables floor price increases
/// - Benefits all token holders through improved backing
/// 
/// # Use Cases
/// 
/// - Protocol treasury supporting market stability
/// - Community-funded price support
/// - Grants or subsidies to bootstrap markets
/// - Creating buffer for market operations
/// 
/// # Note
/// 
/// Donations are irreversible. Donors receive no tokens or claims on the liquidity.
#[derive(Accounts)]
pub struct DonateLiquidityAccounts<'info> {
    /// Donor of the liquidity
    /// Account providing main tokens to boost market liquidity.
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    /// Market metadata with all market configuration and references.
    pub market_meta: AccountInfo<'info>,
    /// Linear market account to update cash balance.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Source account containing main tokens to donate.
    #[account(mut)]
    pub main_src: AccountInfo<'info>,
    /// The liquidity vault for the main token in the market
    /// Receives the donated tokens to increase market reserves.
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    /// Mint for the main token being donated.
    pub mint_main: AccountInfo<'info>,
    /// Token program for the main token.
    pub token_program_main: AccountInfo<'info>,
}

/// Donate backing liquidity to the market.
/// 
/// Adds main tokens (e.g., USDC) to the market's liquidity vault without receiving
/// market tokens in return. This creates excess liquidity that can be used to raise
/// the floor price or improve market stability.
/// 
/// # Arguments
/// 
/// * `amount` - Amount of main tokens to donate
/// 
/// # Effects
/// 
/// - Increases market's cash balance
/// - Creates excess liquidity (cash > backing requirements)
/// - Enables floor price increases
/// - Benefits all token holders through improved backing
/// 
/// # Use Cases
/// 
/// - Protocol treasury supporting market stability
/// - Community-funded price support
/// - Grants or subsidies to bootstrap markets
/// - Creating buffer for market operations
/// 
/// # Note
/// 
/// Donations are irreversible. Donors receive no tokens or claims on the liquidity.
#[derive(Accounts)]
pub struct DonateLiquidity2Accounts<'info> {
    /// Donor of the liquidity
    /// Account providing main tokens to boost market liquidity.
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    /// Market metadata with all market configuration and references.
    pub market_meta: AccountInfo<'info>,
    /// Linear market account to update cash balance.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Source account containing main tokens to donate.
    #[account(mut)]
    pub main_src: AccountInfo<'info>,
    /// The liquidity vault for the main token in the market
    /// Receives the donated tokens to increase market reserves.
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    /// Mint for the main token being donated.
    pub mint_main: AccountInfo<'info>,
    /// Token program for the main token.
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Buy market tokens using exact amount of main tokens.
/// 
/// Purchases market tokens by depositing a specific amount of main tokens (e.g., USDC).
/// The number of tokens received depends on the current price curve position. Includes
/// slippage protection through minimum output requirement.
/// 
/// # Arguments
/// 
/// * `cash_in` - Exact amount of main tokens to spend
/// * `min_token_out` - Minimum market tokens to receive (reverts if not met)
/// 
/// # Price Calculation
/// 
/// Token price follows the bonding curve:
/// - Floor segment: Constant price at floor level
/// - Shoulder segment: Linear price increase
/// - Tail segment: Constant price at maximum
/// - Dutch boost: Temporary multiplier if active
/// 
/// # Fees
/// 
/// Buy fee is deducted from input amount:
/// - Platform fee (tenant level)
/// - Group fee (market group level)
/// - Net amount used for token purchase
/// 
/// # Slippage Protection
/// 
/// Transaction reverts if `tokens_received < min_token_out`
#[derive(Accounts)]
pub struct BuyWithExactCashInAccounts<'info> {
    /// The trader buying tokens from the market.
    #[account(mut, signer)]
    pub signer: AccountInfo<'info>,
    /// Tenant account for platform fee distribution.
    pub tenant: AccountInfo<'info>,
    /// Market group containing fee configuration.
    pub market_group: AccountInfo<'info>,
    /// Market metadata with all market configuration and references.
    pub market_meta: AccountInfo<'info>,
    /// Linear market account containing price curve and state.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Mint for the market's derivative token.
    #[account(mut)]
    pub mint_token: AccountInfo<'info>,
    /// Mint for the main token used as payment.
    pub mint_main: AccountInfo<'info>,
    /// Destination token account to receive the purchased market tokens.
    #[account(mut)]
    pub token_dst: AccountInfo<'info>,
    /// Source account containing main tokens for payment.
    #[account(mut)]
    pub main_src: AccountInfo<'info>,
    /// Market's liquidity vault receiving the main token payment.
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    /// Revenue escrow for market group admin fees.
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    /// Revenue escrow for tenant platform fees.
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    /// Token program for the market's derivative token.
    pub token_program: AccountInfo<'info>,
    /// Token program for the main token.
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Buy market tokens and immediately deposit as collateral.
/// 
/// Combines token purchase with collateral deposit in a single atomic transaction.
/// Useful for users who want to immediately use purchased tokens as collateral for
/// borrowing operations.
/// 
/// # Arguments
/// 
/// * `cash_in` - Exact amount of main tokens to spend
/// * `min_token_out` - Minimum market tokens to receive
/// 
/// # Transaction Flow
/// 
/// 1. Deduct fees from input amount
/// 2. Purchase tokens at current curve price
/// 3. Deposit all tokens into personal position
/// 4. Update position's collateral balance
/// 
/// # Requirements
/// 
/// - Personal position must exist (call `personal_position_init` first)
/// - Sufficient main token balance
/// - Market must allow buying and deposits
/// 
/// # Benefits
/// 
/// - Single transaction reduces costs
/// - Atomic operation prevents MEV
/// - Immediate collateral availability
#[derive(Accounts)]
pub struct BuyWithExactCashInAndDepositAccounts<'info> {
    /// The trader buying tokens and depositing them as collateral.
    #[account(mut, signer)]
    pub owner: AccountInfo<'info>,
    /// Tenant account for platform fee collection.
    pub tenant: AccountInfo<'info>,
    /// Market group that owns this market.
    pub market_group: AccountInfo<'info>,
    /// Market metadata containing configuration and linked accounts.
    pub market_meta: AccountInfo<'info>,
    /// Linear market account with price curve and state.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Personal position that will receive the purchased tokens as collateral.
    #[account(mut)]
    pub personal_position: AccountInfo<'info>,
    /// Escrow account that will receive the purchased tokens as collateral.
    #[account(mut)]
    pub escrow: AccountInfo<'info>,
    /// Mint for the market's derivative token being purchased.
    #[account(mut)]
    pub mint_token: AccountInfo<'info>,
    /// Mint for the main token used as payment.
    pub mint_main: AccountInfo<'info>,
    /// Temporary destination for purchased tokens before deposit to escrow.
    #[account(mut)]
    pub token_dst: AccountInfo<'info>,
    /// Source account containing main tokens for payment.
    #[account(mut)]
    pub main_src: AccountInfo<'info>,
    /// Liquidity vault receiving the main token payment.
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    /// Revenue escrow for market group admin fees.
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    /// Revenue escrow for tenant platform fees.
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    /// Token program for the market's derivative token.
    pub token_program: AccountInfo<'info>,
    /// Token program for the main token.
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Buy market tokens and immediately deposit as collateral with debt.
/// 
/// Combines token purchase with collateral deposit in a single atomic transaction.
/// Useful for users who want to immediately use purchased tokens as collateral for
/// borrowing operations.
/// 
/// # Arguments
/// 
/// * `args` - Arguments for the transaction
/// - `exact_cash_in` - Exact amount of cash to spend on tokens
/// - `min_token_received` - Minimum acceptable tokens to receive (slippage protection)
/// - `new_acquired_debt` - New debt amount to take on
#[derive(Accounts)]
pub struct BuyWithExactCashInAndDepositWithDebtAccounts<'info> {
    /// The trader buying tokens and depositing them as collateral.
    #[account(mut, signer)]
    pub owner: AccountInfo<'info>,
    /// Tenant account for platform fee collection.
    pub tenant: AccountInfo<'info>,
    /// Market group that owns this market.
    pub market_group: AccountInfo<'info>,
    /// Market metadata containing configuration and linked accounts.
    pub market_meta: AccountInfo<'info>,
    /// Linear market account with price curve and state.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Personal position that will receive the purchased tokens as collateral.
    #[account(mut)]
    pub personal_position: AccountInfo<'info>,
    /// Escrow account that will receive the purchased tokens as collateral.
    #[account(mut)]
    pub escrow: AccountInfo<'info>,
    /// Mint for the market's derivative token being purchased.
    #[account(mut)]
    pub mint_token: AccountInfo<'info>,
    /// Mint for the main token used as payment.
    pub mint_main: AccountInfo<'info>,
    /// Source account containing main tokens for payment.
    #[account(mut)]
    pub main_src: AccountInfo<'info>,
    /// Liquidity vault receiving the main token payment.
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    /// Revenue escrow for market group admin fees.
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    /// Revenue escrow for tenant platform fees.
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    /// Token program for the market's derivative token.
    pub token_program: AccountInfo<'info>,
    /// Token program for the main token.
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Sell exact amount of market tokens for main tokens.
/// 
/// Sells a specific number of market tokens and receives main tokens (e.g., USDC)
/// based on the current bonding curve price. Includes slippage protection through
/// minimum output requirement.
/// 
/// # Arguments
/// 
/// * `amount_in` - Exact number of market tokens to sell
/// * `cash_out_min` - Minimum main tokens to receive (reverts if not met)
/// 
/// # Price Calculation
/// 
/// Sell price follows bonding curve in reverse:
/// - Reduces token supply, moving down the curve
/// - Higher supplies sell at higher prices first
/// - Cannot sell below floor price
/// 
/// # Fees
/// 
/// Sell fee is deducted from output amount:
/// - Gross proceeds calculated from curve
/// - Platform and group fees deducted
/// - Net amount sent to seller
/// 
/// # Market Impact
/// 
/// Large sells may experience price slippage as they move down the curve.
/// Consider breaking into smaller transactions for better execution.
#[derive(Accounts)]
pub struct SellWithExactTokenInAccounts<'info> {
    /// The trader selling tokens back to the market.
    #[account(mut, signer)]
    pub user: AccountInfo<'info>,
    /// Tenant account for platform fee distribution.
    pub tenant: AccountInfo<'info>,
    /// Market group containing fee configuration.
    pub market_group: AccountInfo<'info>,
    /// Market metadata with all market configuration and references.
    pub market_meta: AccountInfo<'info>,
    /// Linear market account containing price curve and state.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Revenue escrow for market group admin fees.
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    /// Revenue escrow for tenant platform fees.
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    /// Market's liquidity vault providing main tokens for the sale.
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    /// Mint for the market's derivative token being sold.
    #[account(mut)]
    pub mint_token: AccountInfo<'info>,
    /// Mint for the main token received from the sale.
    pub mint_main: AccountInfo<'info>,
    /// Destination account to receive main tokens from the sale.
    #[account(mut)]
    pub main_dst: AccountInfo<'info>,
    /// Source account containing market tokens to sell.
    #[account(mut)]
    pub token_src: AccountInfo<'info>,
    /// Token program for the main token.
    pub token_program_main: AccountInfo<'info>,
    /// Token program for the market's derivative token.
    pub token_program: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Withdraw collateral and sell tokens in one transaction.
/// 
/// Atomically withdraws market tokens from a personal position and sells them for
/// main tokens. Useful for exiting collateralized positions or taking profits.
/// 
/// # Arguments
/// 
/// * `amount_in` - Number of tokens to withdraw and sell
/// * `cash_out_min` - Minimum main tokens to receive
/// 
/// # Transaction Flow
/// 
/// 1. Withdraw tokens from personal position
/// 2. Check position remains healthy (if debt exists)
/// 3. Sell tokens on bonding curve
/// 4. Transfer proceeds to user
/// 
/// # Position Health
/// 
/// If position has outstanding debt:
/// - Remaining collateral must maintain required LTV
/// - Transaction reverts if withdrawal would enable liquidation
/// - Consider repaying debt before large withdrawals
/// 
/// # Use Cases
/// 
/// - Taking profits while maintaining position
/// - Reducing exposure during market volatility
/// - Exiting positions efficiently
#[derive(Accounts)]
pub struct SellWithExactTokenInAfterWithdrawAccounts<'info> {
    /// Owner of the personal position withdrawing and selling tokens.
    #[account(mut, signer)]
    pub owner: AccountInfo<'info>,
    /// Tenant account for platform fee collection.
    pub tenant: AccountInfo<'info>,
    /// Market group that owns this market.
    pub market_group: AccountInfo<'info>,
    /// Market metadata containing configuration and linked accounts.
    pub market_meta: AccountInfo<'info>,
    /// Linear market account with price curve and state.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Personal position from which collateral will be withdrawn.
    #[account(mut)]
    pub personal_position: AccountInfo<'info>,
    /// Liquidity vault sending out main tokens from the sale.
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    /// Revenue escrow for market group admin fees.
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    /// Revenue escrow for tenant platform fees.
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    /// Mint for the market tokens being sold.
    #[account(mut)]
    pub mint_token: AccountInfo<'info>,
    /// Mint for the main token received from sale.
    pub mint_main: AccountInfo<'info>,
    /// Destination account to receive main tokens from sale.
    #[account(mut)]
    pub main_dst: AccountInfo<'info>,
    /// Source account for tokens (will be the escrow after withdrawal).
    #[account(mut)]
    pub token_src: AccountInfo<'info>,
    /// Escrow account from which tokens are withdrawn before selling.
    #[account(mut)]
    pub escrow: AccountInfo<'info>,
    /// Token program for the main token.
    pub token_program_main: AccountInfo<'info>,
    /// Token program for the market's derivative token.
    pub token_program: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Deposit market tokens as collateral into personal position.
/// 
/// Adds market tokens to your position's collateral balance, enabling borrowing
/// operations. Deposited tokens remain locked until withdrawn or liquidated.
/// 
/// # Arguments
/// 
/// * `amount` - Number of market tokens to deposit
/// 
/// # Collateral Benefits
/// 
/// - Enables borrowing main tokens up to LTV limit
/// - Earns potential appreciation if floor price rises
/// - Protects position from liquidation
/// - Can be withdrawn anytime (if position healthy)
/// 
/// # Requirements
/// 
/// - Personal position must exist
/// - Sufficient token balance in wallet
/// - Market must allow deposits
#[derive(Accounts)]
pub struct DepositAccounts<'info> {
    /// The depositor can be anyone
    /// They are depositing tokens into the personal position's escrow.
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    /// Market metadata identifying which market these tokens belong to.
    pub market_meta: AccountInfo<'info>,
    /// Mint for the market tokens being deposited.
    pub mint_token: AccountInfo<'info>,
    /// Linear market account to update collateral tracking.
    /// Constrained by market_meta
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Personal position receiving the collateral deposit.
    #[account(mut)]
    pub personal_position: AccountInfo<'info>,
    /// Escrow token account holding the position's collateral.
    #[account(mut)]
    pub escrow: AccountInfo<'info>,
    /// Source token account containing tokens to deposit.
    #[account(mut)]
    pub token_src: AccountInfo<'info>,
    /// Token program for the market's derivative token.
    pub token_program: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Withdraw collateral from personal position.
/// 
/// Removes market tokens from collateral, returning them to your wallet. Withdrawal
/// is only allowed if the position remains healthy after removal.
/// 
/// # Arguments
/// 
/// * `amount` - Number of market tokens to withdraw
/// 
/// # Health Requirements
/// 
/// If position has debt:
/// - Remaining collateral value must exceed debt × (1 / LTV)
/// - Example: $1000 debt at 80% LTV requires $1250 collateral
/// - Transaction reverts if health check fails
/// 
/// # Full Withdrawal
/// 
/// To withdraw all collateral:
/// 1. Repay all outstanding debt first
/// 2. Then withdraw full collateral balance
#[derive(Accounts)]
pub struct WithdrawAccounts<'info> {
    /// Owner of the personal position withdrawing collateral.
    #[account(mut, signer)]
    pub owner: AccountInfo<'info>,
    /// Market metadata identifying which market these tokens belong to.
    pub market_meta: AccountInfo<'info>,
    /// Mint for the market tokens being withdrawn.
    pub mint_token: AccountInfo<'info>,
    /// Linear market account to update collateral tracking.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Personal position from which collateral is being withdrawn.
    /// Must be owned by the signer and have no outstanding debt.
    #[account(mut)]
    pub personal_position: AccountInfo<'info>,
    /// Escrow token account holding the position's collateral.
    #[account(mut)]
    pub escrow: AccountInfo<'info>,
    /// Destination token account to receive withdrawn tokens.
    #[account(mut)]
    pub token_dst: AccountInfo<'info>,
    /// Token program for the market's derivative token.
    pub token_program: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Borrow main tokens against deposited collateral.
/// 
/// Takes a loan in main tokens (e.g., USDC) using market tokens as collateral.
/// Borrowed amount is limited by position's collateral value and market LTV ratio.
/// 
/// # Arguments
/// 
/// * `amount` - Amount of main tokens to borrow
/// 
/// # Borrowing Limits
/// 
/// Maximum borrow = Collateral Value × LTV Ratio
/// - Collateral valued at current floor price
/// - LTV typically 50-80% depending on market
/// - Cannot exceed available market liquidity
/// 
/// # Interest Accrual
/// 
/// - Interest calculated per-second at market rate
/// - Compounds continuously on outstanding debt
/// - Rate may vary based on utilization
/// 
/// # Liquidation Risk
/// 
/// Position can be liquidated if:
/// - Market token price drops significantly
/// - Accumulated interest pushes debt above limit
/// - Market LTV parameters change
/// 
/// Monitor position health regularly to avoid liquidation.
#[derive(Accounts)]
pub struct BorrowAccounts<'info> {
    /// Owner of the personal position borrowing funds.
    #[account(mut, signer)]
    pub owner: AccountInfo<'info>,
    /// Tenant account for platform fee distribution.
    pub tenant: AccountInfo<'info>,
    /// Market group containing borrow fee configuration.
    pub market_group: AccountInfo<'info>,
    /// Market metadata with all market configuration and references.
    pub market_meta: AccountInfo<'info>,
    /// Market's liquidity vault providing the borrowed funds.
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    /// Revenue escrow for market group admin fees.
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    /// Revenue escrow for tenant platform fees.
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    /// Mint for the main token being borrowed.
    pub mint_main: AccountInfo<'info>,
    /// Destination account to receive borrowed main tokens.
    #[account(mut)]
    pub main_dst: AccountInfo<'info>,
    /// Linear market account to update liquidity and debt tracking.
    /// Constrained by market_meta
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Personal position using collateral to secure the loan.
    /// Must have sufficient collateral for the requested borrow amount.
    #[account(mut)]
    pub personal_position: AccountInfo<'info>,
    /// Token program for the main token.
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Repay borrowed main tokens to reduce debt.
/// 
/// Repays outstanding debt in main tokens, reducing position's obligations and
/// improving health factor. Can repay partial or full amounts.
/// 
/// # Arguments
/// 
/// * `amount` - Amount of main tokens to repay
/// 
/// # Repayment Order
/// 
/// Payments apply to:
/// 1. Accrued interest first
/// 2. Principal debt second
/// 
/// # Benefits of Repayment
/// 
/// - Reduces liquidation risk
/// - Stops interest accrual on repaid amount
/// - Frees up borrowing capacity
/// - Enables collateral withdrawal
/// 
/// # Full Repayment
/// 
/// To close position completely:
/// 1. Repay all debt including accrued interest
/// 2. Withdraw all collateral
/// 3. Position can then be closed if desired
#[derive(Accounts)]
pub struct RepayAccounts<'info> {
    /// The account repaying the debt (can be anyone, not just the position owner).
    #[account(mut, signer)]
    pub repayer: AccountInfo<'info>,
    /// Market metadata with all market configuration and references.
    pub market_meta: AccountInfo<'info>,
    /// Linear market account to update liquidity and debt tracking.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Personal position whose debt is being repaid.
    #[account(mut)]
    pub personal_position: AccountInfo<'info>,
    /// Mint for the main token being repaid.
    pub mint_main: AccountInfo<'info>,
    /// Source account containing main tokens for repayment.
    #[account(mut)]
    pub main_src: AccountInfo<'info>,
    /// Market's liquidity vault receiving the repayment.
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    /// Token program for the main token.
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Withdraw collateral, sell it, and optionally repay debt from proceeds.
/// 
/// Atomically combines withdraw, sell, and repay operations. Withdraws collateral tokens
/// from personal position, sells them back to the market, optionally repays debt from
/// the proceeds, and transfers remaining cash to the user.
/// 
/// # Arguments
/// 
/// * `args.collateral_reduce_by` - Amount of collateral tokens to withdraw and sell
/// * `args.debt_reduce_by` - Amount of debt to repay from sale proceeds (can be 0)
/// * `args.min_cash_to_user` - Minimum cash to receive after repaying debt (slippage protection)
/// 
/// # Operation Flow
/// 
/// 1. Withdraw collateral from position
/// 2. Sell withdrawn collateral to market
/// 3. Repay debt from sale proceeds (if debt_reduce_by > 0)
/// 4. Transfer remaining cash to user
/// 
/// # Slippage Protection
/// 
/// Transaction fails if:
/// - Sale proceeds < debt_reduce_by + min_cash_to_user
/// - Protects against unfavorable price movements
/// 
/// # Debt Repayment
/// 
/// - Debt repayment is optional (debt_reduce_by can be 0)
/// - If repaying, permission checks ensure repay is allowed
/// - Remaining sale proceeds go to user after repayment
/// 
/// # Use Cases
/// 
/// - Close leveraged position: withdraw all collateral, sell, repay all debt
/// - Partial deleverage: reduce position and debt simultaneously
/// - Take profit: withdraw and sell collateral, keep debt unchanged (debt_reduce_by = 0)
#[derive(Accounts)]
pub struct WithdrawSellAndRepayAccounts<'info> {
    /// Owner of the personal position performing the operation.
    #[account(mut, signer)]
    pub owner: AccountInfo<'info>,
    /// Tenant account for platform fee collection.
    pub tenant: AccountInfo<'info>,
    /// Market group that owns this market.
    pub market_group: AccountInfo<'info>,
    /// Market metadata containing configuration and linked accounts.
    pub market_meta: AccountInfo<'info>,
    /// Linear market account with price curve and state.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Personal position from which collateral is being withdrawn.
    #[account(mut)]
    pub personal_position: AccountInfo<'info>,
    /// Escrow account holding the position's collateral tokens.
    #[account(mut)]
    pub escrow: AccountInfo<'info>,
    /// Mint for the market's derivative token being sold.
    #[account(mut)]
    pub mint_token: AccountInfo<'info>,
    /// Mint for the main token received from the sale.
    pub mint_main: AccountInfo<'info>,
    /// Destination account to receive main tokens from the sale (after debt repayment).
    #[account(mut)]
    pub main_dst: AccountInfo<'info>,
    /// Liquidity vault that provides cash for the sale.
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    /// Revenue escrow for market group admin fees.
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    /// Revenue escrow for tenant platform fees.
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    /// Token program for the market's derivative token.
    pub token_program: AccountInfo<'info>,
    /// Token program for the main token.
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Exercise option tokens to purchase market tokens at floor price.
/// 
/// Converts option tokens into market tokens by paying the floor price in main tokens.
/// This allows option holders to acquire tokens at a fixed price regardless of current
/// market price.
/// 
/// # Arguments
/// 
/// * `amount` - Number of option tokens to exercise
/// 
/// # Economics
/// 
/// For each option token:
/// - Pay: 1 unit of main token × floor price
/// - Receive: 1 market token
/// - Burn: 1 option token
/// 
/// # Profitability
/// 
/// Profitable when: Current Price > Floor Price + Exercise Fee
/// - Check current bonding curve price
/// - Account for exercise fees
/// - Consider immediate sell vs holding
/// 
/// # Requirements
/// 
/// - Sufficient option token balance
/// - Sufficient main tokens for payment
/// - Market must allow option exercise
#[derive(Accounts)]
pub struct ExerciseOptionsAccounts<'info> {
    /// The account exercising options and paying the exercise price.
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    /// Tenant account for platform fee distribution.
    pub tenant: AccountInfo<'info>,
    /// Market group containing exercise option fee configuration.
    pub market_group: AccountInfo<'info>,
    /// Market metadata with all market configuration and references.
    pub market_meta: AccountInfo<'info>,
    /// Linear market account to update supply tracking.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Source account containing main tokens to pay exercise price.
    #[account(mut)]
    pub main_src: AccountInfo<'info>,
    /// Source account containing option tokens to burn.
    #[account(mut)]
    pub options_src: AccountInfo<'info>,
    /// Destination account to receive market tokens.
    #[account(mut)]
    pub token_dst: AccountInfo<'info>,
    /// Market's liquidity vault receiving the exercise payment.
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    /// Mint for option tokens being burned.
    #[account(mut)]
    pub mint_options: AccountInfo<'info>,
    /// Mint for market tokens being received.
    #[account(mut)]
    pub mint_token: AccountInfo<'info>,
    /// Mint for main tokens used as payment.
    pub mint_main: AccountInfo<'info>,
    /// Revenue escrow for tenant platform fees.
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    /// Revenue escrow for market group admin fees.
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    /// Token program for option and market tokens.
    pub token_program: AccountInfo<'info>,
    /// Token program for the main token.
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Redeem market tokens at the guaranteed floor price.
/// 
/// Allows token holders to exit at the floor price when market price is at or near
/// the floor. This provides downside protection and ensures minimum redemption value.
/// 
/// # Arguments
/// 
/// * `amount_tokens_in` - Number of market tokens to redeem
/// 
/// # Redemption Limits
/// 
/// Maximum redeemable = Tail Width = (tail_start - shoulder_end)
/// - Protects bonding curve integrity
/// - Ensures sufficient liquidity for all holders
/// - Resets as tokens are bought back
/// 
/// # Price Guarantee
/// 
/// Receives: Floor Price × Tokens - Fees
/// - Always redeems at floor regardless of curve position
/// - Sell fees still apply (platform + group)
/// - Net proceeds = floor_price × tokens × (1 - total_fee_rate)
/// 
/// # Use Cases
/// 
/// - Exit strategy during market downturns
/// - Arbitrage when market price < floor
/// - Risk management for large positions
#[derive(Accounts)]
pub struct RedeemAtFloorAccounts<'info> {
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    pub tenant: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    #[account(mut)]
    pub mint_token: AccountInfo<'info>,
    pub mint_main: AccountInfo<'info>,
    #[account(mut)]
    pub main_dst: AccountInfo<'info>,
    #[account(mut)]
    pub token_src: AccountInfo<'info>,
    pub token_program_main: AccountInfo<'info>,
    pub token_program: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Initialize a multi-curve market with Dutch auction configuration.
/// 
/// Creates a market using a multi-segment bonding curve that provides more flexibility
/// than linear markets. Supports variable-length price curves with multiple segments,
/// each with its own slope. Includes Dutch auction for initial price discovery.
/// 
/// # Arguments
/// 
/// * `args` - Configuration including:
/// - `floor`: Base price per token
/// - `target`: Maximum price per token
/// - `shoulder_start` / `shoulder_end`: Range for initial linear segment
/// - `tail_start`: Beginning of constant max price segment
/// - `middle_segments`: Array of intermediate curve segments
/// - Dutch auction parameters (multiplier, duration, start time)
/// 
/// # Multi-Curve Advantages
/// 
/// - Flexible price discovery through custom segments
/// - Better modeling of complex tokenomics
/// - Smooth transitions between price regions
/// - Support for non-linear growth patterns
/// 
/// # Segment Structure
/// 
/// 1. Floor: Constant price from 0 to shoulder_start
/// 2. First shoulder: Linear from shoulder_start to first middle segment
/// 3. Middle segments: Variable slopes and ranges (can be empty)
/// 4. Final shoulder: From last middle segment to shoulder_end
/// 5. Tail: Constant max price from tail_start onward
/// 
/// # Access Control
/// 
/// Only the market group admin can create new markets.
#[derive(Accounts)]
pub struct MultiMarketInitWithDutchAccounts<'info> {
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    #[account(signer)]
    pub group_admin: AccountInfo<'info>,
    #[account(signer)]
    pub seed: AccountInfo<'info>,
    pub tenant: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    pub mint_main: AccountInfo<'info>,
    /// The token account for the market
    /// This account must be created in a previous instruction
    /// With supply set to zero
    /// And mint authority assigned to the market_meta
    pub mint_token: AccountInfo<'info>,
    #[account(mut)]
    pub mint_options: AccountInfo<'info>,
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
    #[account(mut)]
    pub market_meta: AccountInfo<'info>,
    pub system_program: AccountInfo<'info>,
    pub token_program: AccountInfo<'info>,
    pub token_program_main: AccountInfo<'info>,
}

/// Raise floor price for multi-curve markets with validation.
/// 
/// Increases the minimum token price while preserving the total area under the
/// multi-segment curve. More complex than linear markets due to multiple segments
/// requiring coordinated adjustment.
/// 
/// # Arguments
/// 
/// * `args` - Parameters including:
/// - `new_floor`: Target floor price
/// - `new_shoulder_end`: Adjusted endpoint for price curve
/// - `new_middle_segments`: Recalculated intermediate segments
/// - `max_deviation_bps`: Tolerance for area preservation
/// 
/// # Segment Adjustment
/// 
/// When floor rises:
/// 1. All segments shift up by floor delta
/// 2. Slopes adjust to maintain total area
/// 3. Segment boundaries may compress
/// 4. Continuity preserved at all transitions
/// 
/// # Validation Checks
/// 
/// - Area preservation within tolerance
/// - Sufficient backing liquidity
/// - Valid segment progression (monotonic)
/// - No instant arbitrage opportunities
/// 
/// # Complexity Note
/// 
/// Multi-curve floor raising requires careful calculation to maintain curve
/// properties across all segments while preserving economic invariants.
#[derive(Accounts)]
pub struct RaiseFloorPreserveAreaCheckedMultiAccounts<'info> {
    #[account(mut, signer)]
    pub admin: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
}

/// Buy from multi-curve market and deposit as collateral.
/// 
/// Purchases tokens from a multi-segment bonding curve and immediately deposits them
/// into a personal position. Combines acquisition and collateralization in one step.
/// 
/// # Arguments
/// 
/// * `cash_in` - Exact amount of main tokens to spend
/// * `min_token_out` - Minimum tokens to receive (slippage protection)
/// 
/// # Multi-Curve Pricing
/// 
/// Price depends on current supply position:
/// - Traverses multiple segments with different slopes
/// - Large buys may span several segments
/// - Each segment calculated independently
/// - Dutch boost applies if active
/// 
/// # Atomic Benefits
/// 
/// - Single transaction for buy + deposit
/// - Reduces transaction costs
/// - Prevents front-running between operations
/// - Immediate collateral availability
/// 
/// # Requirements
/// 
/// - Personal position must exist
/// - Market must allow buying and deposits
/// - Sufficient main token balance
#[derive(Accounts)]
pub struct BuyWithExactCashInAndDepositMultiAccounts<'info> {
    /// The trader buying tokens and depositing them as collateral.
    #[account(mut, signer)]
    pub owner: AccountInfo<'info>,
    /// Tenant account for platform fee collection.
    pub tenant: AccountInfo<'info>,
    /// Market group that owns this market.
    pub market_group: AccountInfo<'info>,
    /// Market metadata containing configuration and linked accounts.
    pub market_meta: AccountInfo<'info>,
    /// Multi-curve market account with price curve and state.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Personal position that will receive the purchased tokens as collateral.
    #[account(mut)]
    pub personal_position: AccountInfo<'info>,
    /// Escrow account that will receive the purchased tokens as collateral.
    #[account(mut)]
    pub escrow: AccountInfo<'info>,
    /// Mint for the market's derivative token being purchased.
    #[account(mut)]
    pub mint_token: AccountInfo<'info>,
    /// Mint for the main token used as payment.
    pub mint_main: AccountInfo<'info>,
    /// Temporary destination for purchased tokens before deposit to escrow.
    #[account(mut)]
    pub token_dst: AccountInfo<'info>,
    /// Source account containing main tokens for payment.
    #[account(mut)]
    pub main_src: AccountInfo<'info>,
    /// Liquidity vault receiving the main token payment.
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    /// Revenue escrow for market group admin fees.
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    /// Revenue escrow for tenant platform fees.
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    /// Token program for the market's derivative token.
    pub token_program: AccountInfo<'info>,
    /// Token program for the main token.
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Buy tokens from a multi-curve market.
/// 
/// Purchases market tokens using a multi-segment bonding curve that can model
/// complex price dynamics. Supports large purchases that span multiple curve
/// segments with different characteristics.
/// 
/// # Arguments
/// 
/// * `cash_in` - Exact amount of main tokens to spend
/// * `min_token_out` - Minimum tokens required (reverts if not met)
/// 
/// # Execution Across Segments
/// 
/// Large purchases may traverse multiple segments:
/// 1. Start at current supply position
/// 2. Buy at current segment's price/slope
/// 3. If segment exhausted, continue to next
/// 4. Accumulate tokens from each segment
/// 5. Stop when cash exhausted or curve end reached
/// 
/// # Price Impact
/// 
/// - Each segment may have different price sensitivity
/// - Steeper slopes mean higher price impact
/// - Consider breaking very large orders
/// 
/// # Fees
/// 
/// Standard fee structure applies:
/// - Platform fee to tenant
/// - Group fee to market admin
/// - Deducted from input amount
#[derive(Accounts)]
pub struct BuyWithExactCashInMultiAccounts<'info> {
    /// The buyer purchasing market tokens.
    #[account(mut, signer)]
    pub signer: AccountInfo<'info>,
    /// Tenant account for platform fee collection.
    pub tenant: AccountInfo<'info>,
    /// Market group that owns this market.
    pub market_group: AccountInfo<'info>,
    /// Market metadata containing configuration and linked accounts.
    pub market_meta: AccountInfo<'info>,
    /// Multi-curve market account with price curve and state.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Mint for the market's derivative token.
    #[account(mut)]
    pub mint_token: AccountInfo<'info>,
    /// Mint for the main token used as payment.
    pub mint_main: AccountInfo<'info>,
    /// Destination token account to receive purchased tokens.
    #[account(mut)]
    pub token_dst: AccountInfo<'info>,
    /// Source account containing main tokens for payment.
    #[account(mut)]
    pub main_src: AccountInfo<'info>,
    /// Liquidity vault receiving the main tokens.
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    /// Revenue escrow for market group admin fees.
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    /// Revenue escrow for tenant platform fees.
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    /// Token program for the market's derivative token.
    pub token_program: AccountInfo<'info>,
    /// Token program for the main token.
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Sell tokens to a multi-curve market.
/// 
/// Sells market tokens back to the protocol following the multi-segment bonding curve
/// in reverse. Large sales may span multiple segments with varying price impacts.
/// 
/// # Arguments
/// 
/// * `amount_in` - Exact number of tokens to sell
/// * `cash_out_min` - Minimum main tokens to receive
/// 
/// # Multi-Segment Execution
/// 
/// Sells work backwards through curve:
/// 1. Start at current supply position
/// 2. Sell into current segment at its price
/// 3. If more to sell, move to previous segment
/// 4. Continue until all tokens sold
/// 5. Cannot sell below floor price
/// 
/// # Price Discovery
/// 
/// - Higher supplies sell first (higher prices)
/// - Price decreases as supply reduces
/// - Each segment has independent characteristics
/// - Floor provides absolute minimum
/// 
/// # Slippage Considerations
/// 
/// Multi-curve markets may have:
/// - Variable liquidity across segments
/// - Sudden price changes at boundaries
/// - Different impacts in different regions
#[derive(Accounts)]
pub struct SellWithExactTokenInMultiAccounts<'info> {
    /// User selling market tokens back to the protocol.
    #[account(mut, signer)]
    pub user: AccountInfo<'info>,
    /// Tenant account for platform fee collection.
    pub tenant: AccountInfo<'info>,
    /// Market group that owns this market.
    pub market_group: AccountInfo<'info>,
    /// Market metadata containing configuration and linked accounts.
    pub market_meta: AccountInfo<'info>,
    /// Multi-curve market account with price curve and state.
    #[account(mut)]
    pub market: AccountInfo<'info>,
    /// Revenue escrow for market group admin fees.
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    /// Revenue escrow for tenant platform fees.
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    /// Liquidity vault sending out main tokens.
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    /// Mint for the market tokens being sold.
    #[account(mut)]
    pub mint_token: AccountInfo<'info>,
    /// Mint for the main token received from sale.
    pub mint_main: AccountInfo<'info>,
    /// Destination account to receive main tokens from sale.
    #[account(mut)]
    pub main_dst: AccountInfo<'info>,
    /// Source account containing market tokens to sell.
    #[account(mut)]
    pub token_src: AccountInfo<'info>,
    /// Token program for the main token.
    pub token_program_main: AccountInfo<'info>,
    /// Token program for the market's derivative token.
    pub token_program: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Exercise options in a multi-curve market.
/// 
/// Converts option tokens to market tokens at the floor price, regardless of the
/// current position on the multi-segment curve. Options provide downside protection
/// in volatile multi-curve markets.
/// 
/// # Arguments
/// 
/// * `amount` - Number of option tokens to exercise
/// 
/// # Exercise Mechanics
/// 
/// Same as linear markets:
/// - Pay floor price per option in main tokens
/// - Receive one market token per option
/// - Options are burned
/// 
/// # Multi-Curve Considerations
/// 
/// - Floor price is constant across all segments
/// - Current curve position doesn't affect exercise
/// - Especially valuable when price is in higher segments
/// - Provides arbitrage during market dislocations
/// 
/// # Strategic Use
/// 
/// In multi-curve markets, options help:
/// - Navigate complex price dynamics
/// - Profit from segment transitions
/// - Hedge against curve adjustments
#[derive(Accounts)]
pub struct ExerciseOptionsMultiAccounts<'info> {
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    pub tenant: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
    #[account(mut)]
    pub main_src: AccountInfo<'info>,
    #[account(mut)]
    pub options_src: AccountInfo<'info>,
    #[account(mut)]
    pub token_dst: AccountInfo<'info>,
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    #[account(mut)]
    pub mint_options: AccountInfo<'info>,
    #[account(mut)]
    pub mint_token: AccountInfo<'info>,
    pub mint_main: AccountInfo<'info>,
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    pub token_program: AccountInfo<'info>,
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Repay debt in a multi-curve market.
/// 
/// Repays borrowed main tokens to reduce debt obligations in a personal position.
/// Multi-curve markets may have different interest dynamics based on utilization
/// across curve segments.
/// 
/// # Arguments
/// 
/// * `amount` - Amount of main tokens to repay
/// 
/// # Interest Considerations
/// 
/// Multi-curve markets may feature:
/// - Variable rates based on curve position
/// - Different risk profiles across segments
/// - Dynamic rate adjustments
/// 
/// # Repayment Priority
/// 
/// Same as linear markets:
/// 1. Accrued interest first
/// 2. Principal balance second
/// 3. Excess returned to payer
/// 
/// # Position Management
/// 
/// Regular repayments recommended to:
/// - Maintain healthy LTV ratios
/// - Reduce liquidation risk
/// - Take advantage of rate changes
#[derive(Accounts)]
pub struct RepayMultiAccounts<'info> {
    #[account(mut, signer)]
    pub repayer: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
    #[account(mut)]
    pub personal_position: AccountInfo<'info>,
    pub mint_main: AccountInfo<'info>,
    #[account(mut)]
    pub main_src: AccountInfo<'info>,
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    pub token_program_main: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Redeem tokens at floor price in multi-curve market.
/// 
/// Provides guaranteed exit at the floor price for multi-curve market tokens.
/// Essential safety mechanism given the complexity of multi-segment pricing.
/// 
/// # Arguments
/// 
/// * `amount_tokens_in` - Number of tokens to redeem at floor
/// 
/// # Redemption in Complex Markets
/// 
/// Multi-curve considerations:
/// - Floor constant across all segments
/// - Redemption bypasses curve complexity
/// - Same tail width limits apply
/// - Critical during segment transitions
/// 
/// # Maximum Redemption
/// 
/// Limited to tail width: (tail_start - shoulder_end)
/// - Protects curve integrity
/// - Ensures fair access for all holders
/// - Resets as market activity continues
/// 
/// # Use Cases
/// 
/// Especially important in multi-curve markets for:
/// - Exiting during curve adjustments
/// - Arbitrage across segments
/// - Risk management in complex dynamics
/// - Guaranteed liquidity provision
#[derive(Accounts)]
pub struct RedeemAtFloorMultiAccounts<'info> {
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    pub tenant: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    #[account(mut)]
    pub rev_escrow_tenant: AccountInfo<'info>,
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    #[account(mut)]
    pub mint_token: AccountInfo<'info>,
    pub mint_main: AccountInfo<'info>,
    #[account(mut)]
    pub main_dst: AccountInfo<'info>,
    #[account(mut)]
    pub token_src: AccountInfo<'info>,
    pub token_program_main: AccountInfo<'info>,
    pub token_program: AccountInfo<'info>,
    #[account(mut)]
    pub log_account: AccountInfo<'info>,
    pub mayflower_program: AccountInfo<'info>,
}

/// Modify the price curve's sensitivity to supply changes at the current token supply level.
/// 
/// Allows market administrators to dynamically adjust how quickly the token price changes
/// in response to supply increases. The modification is applied at the current token supply
/// level and affects the curve's behavior for all future supply levels beyond that point.
/// 
/// # Arguments
/// 
/// * `args` - Curve modification parameters including:
/// - `multiplier`: Magnitude of slope change (0.0 < multiplier < 1.0)
/// - `new_middle_segment_count`: Expected number of middle segments after modification
/// - `increase`: Whether to increase (true) or decrease (false) sensitivity
/// 
/// # How it works
/// 
/// The function modifies the curve's vertex structure by either:
/// - **Inserting a new vertex** at the current supply level if it falls within the final segment
/// - **Removing the last vertex** if the current supply is not in the final segment and the
/// sensitivity direction doesn't match the final segment's current direction
/// 
/// # Sensitivity Direction
/// 
/// - **`increase = true`** (`SensitivityDirection::Higher`): Makes the curve more sensitive to supply changes
/// - Results in steeper slopes = faster price increases as supply grows
/// - Useful for encouraging early adoption or responding to high demand
/// 
/// - **`increase = false`** (`SensitivityDirection::Lower`): Makes the curve less sensitive to supply changes
/// - Results in gentler slopes = slower price increases as supply grows
/// - Useful for risk management or stabilizing prices in volatile conditions
/// 
/// # Multiplier Effect
/// 
/// The `multiplier` parameter (0.0 < multiplier < 1.0) determines the magnitude of change:
/// - For `Higher` direction: new_slope = current_slope × (1 + multiplier)
/// - For `Lower` direction: new_slope = current_slope × (1 - multiplier)
/// 
/// # Access Control
/// 
/// Only the market group admin can modify curves.
/// 
/// # Use Cases
/// 
/// - **Market Making**: Adjust sensitivity based on trading volume or market volatility
/// - **Risk Management**: Reduce sensitivity in high-supply regions to prevent extreme price swings
/// - **Liquidity Provision**: Increase sensitivity in low-supply regions to encourage early adoption
/// - **Dynamic Pricing**: Respond to market conditions by modifying curve behavior
/// 
/// # Constraints
/// 
/// - `multiplier` must be between 0.0 and 1.0 (exclusive)
/// - The function preserves curve continuity at segment boundaries
/// - Modifications only affect the curve beyond the current supply level
/// - The account must be reallocated to accommodate the new segment count
/// 
/// # Safety Considerations
/// 
/// - Changes are irreversible once applied
/// - The operation will panic if the actual number of middle segments after modification
/// doesn't match the expected `new_middle_segment_count`
/// - Consider market impact before significant changes
/// - Monitor market behavior after curve changes
#[derive(Accounts)]
pub struct ModifyCurveMultiAccounts<'info> {
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    #[account(mut, signer)]
    pub admin: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
    pub system_program: AccountInfo<'info>,
}

// Account structures
#[account]
pub struct LogAccount {
    pub counter: u64,
    pub bump: [u8; 1],
}

/// Market group account managing a collection of related markets with shared fee structures.
/// 
/// A MarketGroup acts as an intermediate administrative layer between a Tenant and individual
/// Markets. It defines the fee structure that applies to all markets within the group and
/// manages permissions for market operations. Multiple markets can belong to the same group,
/// sharing common fee configurations while maintaining independent bonding curves and liquidity.
/// 
/// # Ownership Hierarchy
/// - Owned by a single Tenant account
/// - Owns multiple MarketMeta accounts (which reference specific Market implementations)
/// - Controls fee distribution between market group admin and tenant platform
/// 
/// # Fee Management
/// The MarketGroup defines four types of fees that apply to all its markets:
/// - Buy fees: charged when purchasing tokens from the market
/// - Sell fees: charged when selling tokens back to the market
/// - Borrow fees: charged when borrowing against collateral
/// - Exercise option fees: charged when exercising token options
/// 
/// Fees collected are split between the market group admin and the tenant based on
/// the tenant's platform fee configuration.
#[account]
pub struct MarketGroup {
    /// The tenant account that owns this market group.
    /// All markets in this group must belong to the same tenant.
    pub tenant: Pubkey,
    /// The admin public key with control over this market group.
    /// Can update group settings, manage fees, and create new markets.
    pub admin: Pubkey,
    /// The proposed new admin for ownership transfer (None if no transfer pending).
    /// Requires acceptance by the proposed admin to complete the transfer.
    pub proposed_admin: Option<Pubkey>,
    /// PDA metadata containing the seed and bump used to derive this account's address.
    /// Used for signing operations and address verification.
    pub pda_meta: PdaMeta,
    /// Fee configuration for all markets within this group.
    /// Contains buy, sell, borrow, and exercise option fee rates.
    pub fees: Fees,
}

/// Market implementation using a linear bonding curve with shoulder configuration.
/// 
/// MarketLinear implements a two-segment linear price curve that provides dynamic pricing
/// for token purchases and sales. The curve consists of a steeper "shoulder" segment at
/// low supply levels (providing higher initial prices) and a gentler "tail" segment for
/// the bulk of the supply range.
/// 
/// # Bonding Curve Design
/// The linear market uses a piecewise linear function:
/// - Shoulder segment: Higher slope (m1) from 0 to shoulder point
/// - Tail segment: Lower slope (m2) from shoulder point onwards
/// - Floor price: Minimum price below which tokens cannot trade
/// 
/// # Use Cases
/// - Simple bonding curve markets with predictable price dynamics
/// - Markets requiring a price premium for early adopters
/// - Token launches with controlled price discovery
/// 
/// # Relationship to MarketMeta
/// Each MarketLinear is paired with exactly one MarketMeta account that contains
/// the market's configuration, token mints, vaults, and permissions.
#[account]
pub struct MarketLinear {
    /// Reference to the MarketMeta account containing shared market configuration.
    /// Links this market implementation to its metadata and token mints.
    pub market_meta: Pubkey,
    /// Current state of the market including liquidity, debt, supply, and collateral.
    /// Tracks all dynamic values that change during market operations.
    pub state: MarketState,
    /// Serialized linear price curve parameters defining market pricing.
    /// Contains slopes, floor price, and shoulder configuration for the bonding curve.
    pub price_curve: LinearPriceCurveSerialized,
}

/// Market metadata account containing configuration shared across all market implementations.
/// 
/// MarketMeta serves as the central configuration hub for a market, storing references to
/// all associated accounts (tokens, vaults, escrows) and operational parameters. It acts
/// as a bridge between the market's administrative structure (Tenant/MarketGroup) and its
/// implementation (MarketLinear or MarketMultiCurve).
/// 
/// # Key Relationships
/// - References its parent MarketGroup for fee configurations
/// - Referenced by exactly one Market implementation (Linear or MultiCurve)
/// - Controls three token mints: main (collateral), token (traded), and options
/// - Manages liquidity vault and revenue distribution escrows
/// 
/// # Permissions System
/// MarketMeta includes a flexible permissions bitfield that controls which operations
/// are allowed on the market. This enables fine-grained control over market functionality,
/// allowing administrators to disable specific features during maintenance or in response
/// to market conditions.
/// 
/// # Dutch Auction
/// Markets can optionally use a Dutch auction mechanism at launch, providing time-based
/// price incentives to early participants. The auction boost decreases over time according
/// to the configured parameters.
#[account]
pub struct MarketMeta {
    /// Mint for the main backing token (the cash token).
    /// This is the token used as collateral and for liquidity (e.g., USDC, SOL).
    pub mint_main: Pubkey,
    /// Mint for the token being traded in this market.
    /// This is the derivative token that users can buy/sell/borrow.
    pub mint_token: Pubkey,
    /// Mint for the options token associated with this market.
    /// Options tokens can be minted and later exercised to purchase the traded token.
    pub mint_options: Pubkey,
    /// The market group that this market belongs to.
    /// Determines fee structure and admin permissions for this market.
    pub market_group: Pubkey,
    /// The market account (Linear or MultiCurve) associated with this metadata.
    /// Ensures a 1:1 relationship between market and market meta accounts.
    pub market: Pubkey,
    /// The token program ID for the main token.
    /// Usually SPL Token or Token-2022, used for CPI calls.
    pub token_program_main: Pubkey,
    /// Vault that holds the liquidity pool for the main token.
    /// All market liquidity (cash) is stored here.
    pub liq_vault_main: Pubkey,
    /// Revenue escrow account for the market group.
    /// Collects group admin's share of fees from market operations.
    pub rev_escrow_group: Pubkey,
    /// Revenue escrow account for the tenant.
    /// Collects platform fees allocated to the tenant.
    pub rev_escrow_tenant: Pubkey,
    /// PDA metadata containing the seed and bump used to derive this account's address.
    /// Used for signing operations when the market acts as an authority.
    pub pda_meta: PdaMeta,
    /// Number of decimal places for the main token.
    /// Used for precise calculations and proper display formatting.
    pub decimals: u8,
    /// Bitfield controlling which operations are permitted on this market.
    /// Allows fine-grained control over market functionality.
    pub permissions: MarketPermissions,
    /// Unix timestamp when the market becomes active.
    /// Trading operations are restricted before this time.
    pub start_time: u64,
    /// Configuration for Dutch auction price boost mechanism.
    /// Provides time-based price incentives after market launch.
    pub dutch_config: DutchConfigSerialized,
}

/// Market implementation using a multi-segment bonding curve with dynamic complexity.
/// 
/// MarketMultiCurve extends the linear market concept by supporting multiple linear segments,
/// allowing for more sophisticated price curves that can adapt over time. This is particularly
/// useful when the floor price is raised, as the curve can maintain area-under-curve invariants
/// by adding intermediate segments.
/// 
/// # Advanced Bonding Curve
/// The multi-curve market supports:
/// - Initial shoulder segment with configurable slope multiplier
/// - Dynamic middle segments added when floor is raised
/// - Final tail segment extending to maximum supply
/// - Area preservation during floor adjustments
/// 
/// # Use Cases
/// - Markets requiring complex price dynamics
/// - Adaptive curves that evolve with market conditions
/// - Floor raising with liquidity preservation
/// - Multi-phase token distribution strategies
/// 
/// # Dynamic Segment Management
/// When the floor is raised, the curve automatically adds middle segments to:
/// - Preserve the total area under the curve (maintaining market cap)
/// - Ensure price continuity at segment boundaries
/// - Maintain monotonic price increases
#[account]
pub struct MarketMultiCurve {
    /// Reference to the MarketMeta account containing shared market configuration.
    /// Links this market implementation to its metadata and token mints.
    pub market_meta: Pubkey,
    /// Current state of the market including liquidity, debt, supply, and collateral.
    /// Tracks all dynamic values that change during market operations.
    pub state: MarketState,
    /// Serialized multi-segment price curve with dynamic middle segments.
    /// Supports complex bonding curves with multiple linear segments.
    pub price_curve: MultiPriceCurveSerialized,
}

/// Personal position account tracking an individual user's collateral and debt in a market.
/// 
/// PersonalPosition represents a user's borrowing position within a specific market. It tracks
/// both the collateral deposited (in market tokens) and any outstanding debt (in main tokens
/// like USDC). This account enables collateralized borrowing, where users can deposit market
/// tokens and borrow main tokens against them.
/// 
/// # Collateralization Model
/// - Users deposit market tokens as collateral into an escrow account
/// - Against this collateral, users can borrow main tokens (e.g., USDC)
/// - The maximum borrowing capacity depends on the market's collateralization ratio
/// - Collateral remains locked until all debt is repaid
/// 
/// # Account Lifecycle
/// 1. Created when a user first deposits collateral or borrows
/// 2. Persists as long as there's collateral or debt
/// 3. Can be closed when both collateral and debt reach zero
/// 
/// # Security
/// - Only the owner can perform operations on their position
/// - Collateral is held in a separate escrow account for security
/// - Position is tied to a specific market and cannot be transferred
#[account]
pub struct PersonalPosition {
    /// The market metadata account this position belongs to.
    /// Determines which market's tokens can be deposited and borrowed against.
    pub market_meta: Pubkey,
    /// The owner's public key who controls this position.
    /// Only the owner can deposit, withdraw, borrow, or repay.
    pub owner: Pubkey,
    /// The escrow token account holding deposited collateral tokens.
    /// Tokens are locked here while being used as collateral for borrowing.
    pub escrow: Pubkey,
    /// Amount of market tokens deposited as collateral.
    /// Can be withdrawn if debt is zero, or used to secure borrows.
    pub deposited_token_balance: u64,
    /// Amount of main tokens (e.g., USDC) currently borrowed against collateral.
    /// Must be repaid before collateral can be withdrawn.
    pub debt: u64,
    /// The PDA bump seed used to derive this account's address.
    /// Stored to avoid recalculation during operations.
    pub bump: [u8; 1],
}

/// Tenant account representing a platform operator or protocol administrator.
/// 
/// The Tenant is the top-level entity in the Mayflower protocol hierarchy. Each tenant
/// can manage multiple market groups, set platform-wide fees, and control permissions
/// for market group creation. Tenants enable multi-tenancy within the protocol, allowing
/// different operators to run their own instances with custom configurations.
/// 
/// # Account Hierarchy
/// ```
/// Tenant (Platform Operator)
/// └── MarketGroup (Fee Configuration)
/// └── MarketMeta (Market Configuration)
/// └── Market (Linear or MultiCurve Implementation)
/// ```
/// 
/// # Key Responsibilities
/// - Platform fee collection across all markets under this tenant
/// - Control over market group creation permissions
/// - Admin transfer and succession management
/// - Platform-level configuration and governance
#[account]
pub struct Tenant {
    /// The seed public key used to derive this tenant's PDA address.
    /// This ensures deterministic address generation and prevents duplicate tenants.
    pub seed: Pubkey,
    /// The PDA bump seed used to derive this account's address.
    /// Stored to avoid recalculation during CPI calls.
    pub bump: [u8; 1],
    /// The admin public key with control to create market groups.
    pub admin: Pubkey,
    /// The proposed new admin for ownership transfer (None if no transfer pending).
    /// Requires acceptance by the proposed admin to complete the transfer.
    pub proposed_admin: Option<Pubkey>,
    /// Platform fee rate in micro basis points (1 micro bp = 1/100 bp = 0.0001%).
    /// Applied to transactions within markets under this tenant.
    pub platform_fee_micro_bps: u32,
    /// Whether market groups can be created without explicit permission from the tenant admin.
    /// When true, any user can create market groups under this tenant.
    pub permissionless_group_creation: bool,
}

// Type structures
#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct BuyWithExactCashInAndDepositEvent {
    /// The account that purchased tokens and deposited them as collateral.
    pub trader: Pubkey,
    /// The address of the market metadata account.
    pub market_meta: Pubkey,
    /// The address of the personal position account.
    pub personal_position: Pubkey,
    /// The amount of market tokens purchased.
    pub token_out: u64,
    /// The amount of main tokens paid by the trader (excluding fees).
    pub net_cash_in: u64,
    /// The fee amount allocated to the market group admin.
    pub fee_market_group: u64,
    /// The fee amount allocated to the platform.
    pub fee_platform: u64,
    /// The new market price after the purchase and deposit.
    pub new_market_price: DecimalSerialized,
    /// The new balance of the personal position after the purchase and deposit.
    pub new_personal_position_balance: u64,
}

/// Snapshot of the complete state of a market at a specific point in time.
/// This struct captures all relevant market data for off-chain analysis and record-keeping.
#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct MarketStateSnapshot {
    /// The market metadata account address for this market.
    /// This is the PDA that stores configuration and references to all associated accounts.
    pub market_metadata_address: Pubkey,
    /// Total amount of market tokens deposited as collateral across all personal positions.
    /// These tokens are held in escrow and can be withdrawn if debt obligations are met.
    pub total_market_deposited_collateral: u64,
    /// Total amount of main tokens (e.g., USDC, SOL) in the market's liquidity pool.
    /// This is the reserve available for purchases, borrows, and redemptions.
    pub total_main_token_in_liquidity_pool: u64,
    /// Total debt owed to the market across all personal positions.
    /// Represents main tokens that were borrowed and must be repaid.
    pub total_market_debt: u64,
    /// The floor price of the market (minimum price at supply = 0).
    /// This is the lowest price at which tokens can be sold back to the market.
    pub floor_price: DecimalSerialized,
    /// The current market price (marginal price at current supply).
    /// This is the price for buying the next infinitesimal amount of tokens.
    pub market_price: DecimalSerialized,
    /// The area under the price curve from 0 to current supply.
    /// Measured in token units, represents the total value locked in the curve.
    pub area_under_curve: u64,
    /// Total supply of market tokens currently minted and in circulation.
    /// This includes tokens in personal positions (collateral) and tokens held by traders.
    pub token_supply: u64,
    /// Unix timestamp (in seconds) when this snapshot was created.
    pub unix_timestamp: u64,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct SellWithExactTokenInAfterWithdrawEvent {
    /// The account that sold tokens back to the market.
    pub trader: Pubkey,
    /// The address of the market metadata account.
    pub market_meta: Pubkey,
    /// The amount of market tokens burned in the sale.
    pub token_in: u64,
    /// The amount of main tokens received by the trader after fees.
    /// This is the net amount transferred to the trader.
    pub net_cash_out: u64,
    /// The fee amount allocated to the platform.
    pub fee_platform: u64,
    /// The fee amount allocated to the market group admin.
    pub fee_market_group: u64,
    /// The new balance of the personal position
    pub new_personal_position_balance: u64,
    /// The address of the personal position account.
    pub personal_position: Pubkey,
    /// The new market price after the sell.
    pub new_market_price: DecimalSerialized,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct ModifyCurveArgs {
    /// The multiplier to apply to the curve (between 0.0 and 1.0)
    pub multiplier: f32,
    /// The new number of middle segments
    pub new_middle_segment_count: u8,
    /// If true, the sensitivity direction is higher, otherwise it is lower
    pub increase: bool,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct MultiMarketInitWithDutchArgs {
    pub shoulder_slope_scalar: f64,
    pub main_slope: f64,
    pub f: f32,
    pub start_time: u64,
    pub dutch_config: DutchConfigSerialized,
    pub permissions: MarketPermissions,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct RaiseFloorPreserveAreaCheckedMultiArgs {
    /// The ratio of the floor increase (greater than 0.0)
    pub floor_increase_ratio: DecimalSerialized,
    /// The new shoulder end (must be greater than the current shoulder end)
    pub new_shoulder_end: u64,
    /// The minimum liquidity ratio (greater than or equal to 0.0)
    /// This is the ratio of the liqudity after the shoulder end to the liquidity of the shoulder
    pub min_liq_ratio: DecimalSerialized,
    /// If true, there was no way to raise the floor without backtracking from a vertex,
    /// extending the a neighbor segment backwards
    /// 
    /// This happens if the shoulder must sweep forward over segments that increase in slope
    /// and there is no solution, since the shoulder slope increases when it intersects the new higher slope
    /// the area under the curve would be too small
    pub must_backtrack: bool,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct BuyWithExactCashInAndDepositWithDebtArgs {
    /// Exact amount of cash to spend on tokens
    pub exact_cash_in: u64,
    /// Minimum acceptable tokens to receive (slippage protection)
    pub min_token_received: u64,
    /// New debt amount to take on
    pub new_acquired_debt: u64,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct MarketLinearInitWithDutchArgs {
    pub x2: u64,
    pub m2: DecimalSerialized,
    pub m1: DecimalSerialized,
    pub f: DecimalSerialized,
    pub b2: DecimalSerialized,
    pub start_time: u64,
    pub dutch_config: DutchConfigSerialized,
    pub permissions: MarketPermissions,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct MarketLinearArgs {
    pub x2: u64,
    pub m2: DecimalSerialized,
    pub m1: DecimalSerialized,
    pub f: DecimalSerialized,
    pub b2: DecimalSerialized,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct RaiseFloorFromExcessLiquidityCheckedArgs {
    /// the maximum new floor that is allowed
    pub max_new_floor: DecimalSerialized,
    /// the amount to increase the floor by
    pub increase_ratio_micro_basis_points: u32,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct RaiseFloorPreserveAreaCheckedArgs2 {
    /// The maximum new floor price (must be greater than the current floor)
    pub max_new_floor: DecimalSerialized,
    /// The increase ratio
    pub floor_increase_ratio: DecimalSerialized,
    /// The new shoulder end (must be greater than the current shoulder end)
    pub new_shoulder_end: u64,
    /// The minimum liquidity ratio (greater than or equal to 0.0)
    /// This is the ratio of the liqudity after the shoulder end to the liquidity of the shoulder
    /// if the ratio is 0.0, then the floor is permitted to rise such that the new shoulder is equal to supply
    pub min_liq_ratio: DecimalSerialized,
    /// the maximum token units that the total area of the curve is allowed to shrink by
    /// this is set by the client to restrict overly aggressive floor raising, with a tolerance to account for "slippage"
    pub max_area_shrinkage_tolerance_units: u64,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct RaiseFloorPreserveAreaCheckedArgs {
    /// The ratio of the floor increase (greater than 0.0)
    pub floor_increase_ratio: DecimalSerialized,
    /// The new shoulder end (must be greater than the current shoulder end)
    pub new_shoulder_end: u64,
    /// The minimum liquidity ratio (greater than or equal to 0.0)
    /// This is the ratio of the liqudity after the shoulder end to the liquidity of the shoulder
    pub min_liq_ratio: DecimalSerialized,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct WithdrawSellAndRepayArgs {
    /// Amount of collateral to withdraw and sell
    pub collateral_reduce_by: u64,
    /// Amount of debt to repay from sale proceeds
    pub debt_reduce_by: u64,
    /// Minimum cash to receive after repaying debt (slippage protection)
    pub min_cash_to_user: u64,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct MarketGroupInitArgs {
    pub fees: Fees,
    pub group_admin: Pubkey,
}

/// Wrapper for serializing and deserializing high-precision decimal values.
/// 
/// Solana accounts require all data to be serialized as bytes. This struct provides
/// a bridge between Rust's Decimal type (used for precise financial calculations)
/// and the byte array representation stored on-chain.
/// 
/// # Usage
/// - Serialize: Convert Decimal to 16-byte array for storage
/// - Deserialize: Reconstruct Decimal from stored bytes
/// - Preserves full decimal precision across serialization
/// 
/// # Why This Matters
/// Financial calculations require high precision to avoid rounding errors that could
/// accumulate over thousands of transactions. The 16-byte representation maintains
/// the full 128-bit precision of the Decimal type.
#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct DecimalSerialized {
    /// Serialized Decimal value as a 16-byte array.
    /// Used for storing fixed-point decimal numbers in Solana accounts.
    pub val: [u8; 16],
}

/// Metadata for Program Derived Address (PDA) accounts.
/// 
/// PDAs are deterministically derived addresses that can only be controlled by the program.
/// This struct stores the components needed to derive and verify PDA addresses, enabling
/// efficient Cross-Program Invocations (CPIs) without recomputing the address.
/// 
/// # PDA Derivation
/// Solana PDAs are derived from:
/// 1. A string seed (defined per account type)
/// 2. A unique seed (usually a Pubkey)
/// 3. A bump seed (ensures the address is off-curve)
/// 
/// # Performance Optimization
/// Storing the bump seed avoids expensive recomputation during CPIs, as finding the bump
/// requires iterating through possible values until finding one that produces an off-curve point.
/// 
/// # Security
/// PDAs cannot be controlled by external signers, making them ideal for program-controlled
/// accounts like escrows, vaults, and authority accounts.
#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct PdaMeta {
    /// The PDA bump seed used to derive the account address.
    /// Stored to enable efficient CPI calls without recomputation.
    pub bump: [u8; 1],
    /// The seed public key used as input to the PDA derivation.
    /// Combined with string seeds and bump to create unique addresses.
    pub seed: Pubkey,
}

/// Fee configuration structure for market operations within a market group.
/// 
/// All fees are denominated in micro-basis points (micro-bps), where:
/// - 1 micro-bp = 1/100 of a basis point = 0.0001%
/// - 100 micro-bps = 1 basis point = 0.01%
/// - 10,000 micro-bps = 100 basis points = 1%
/// 
/// This granular fee precision allows for fine-tuned economic models while maintaining
/// integer arithmetic for computational efficiency on-chain.
/// 
/// # Example
/// A buy fee of 250 micro-bps equals 2.5 basis points or 0.025% of the transaction amount.
#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct Fees {
    /// Fee charged when buying tokens from the market (in micro basis points).
    /// Applied to the purchase amount before tokens are transferred.
    pub buy: u32,
    /// Fee charged when selling tokens back to the market (in micro basis points).
    /// Applied to the sale proceeds before main tokens are transferred.
    pub sell: u32,
    /// Fee charged when borrowing against collateral (in micro basis points).
    /// Applied to the borrowed amount at the time of borrowing.
    pub borrow: u32,
    /// Fee charged when exercising options to purchase tokens (in micro basis points).
    /// Applied to the option exercise amount.
    pub exercise_option: u32,
}

/// Serialized representation of a linear bonding curve with shoulder configuration.
/// 
/// This structure stores the parameters that define a two-segment linear price curve.
/// The curve provides higher prices at low supply (shoulder) and more gradual price
/// increases at higher supply (tail), creating favorable conditions for early participants
/// while maintaining sustainable economics at scale.
/// 
/// # Curve Equation
/// ```text
/// if x < x2 (shoulder region):
/// price = floor + m1 * x
/// else (tail region):
/// price = floor + m2 * x + b2
/// ```
/// 
/// # Parameters
/// - `floor`: Minimum price guarantee
/// - `m1`: Shoulder slope (typically steeper)
/// - `m2`: Tail slope (typically gentler)
/// - `x2`: Transition point from shoulder to tail
/// - `b2`: Y-intercept adjustment for tail segment continuity
#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct LinearPriceCurveSerialized {
    /// Minimum price floor for the token (serialized Decimal).
    /// Price cannot fall below this value regardless of supply.
    pub floor: [u8; 16],
    /// Slope of the shoulder segment (m1, serialized Decimal).
    /// Steeper initial slope providing higher prices at low supply.
    pub m1: [u8; 16],
    /// Slope of the main segment (m2, serialized Decimal).
    /// Gentler slope for bulk of the curve after shoulder point.
    pub m2: [u8; 16],
    /// X-coordinate where shoulder transitions to main slope (supply units).
    /// Defines the breakpoint between steep and gentle price curves.
    pub x2: u64,
    /// Y-intercept of the main segment (b2, serialized Decimal).
    /// Determines vertical offset of the main price curve.
    pub b2: [u8; 16],
}

/// Bitfield structure managing market operation permissions.
/// 
/// Uses a compact 16-bit representation where each bit corresponds to a specific
/// market operation. This allows for efficient storage and checking of multiple
/// permissions simultaneously. All permissions default to enabled (0xFFFF) for
/// new markets.
/// 
/// # Permission Management
/// - Individual bits can be toggled without affecting others
/// - Permissions are checked before each corresponding operation
/// - Failed permission checks return specific error codes for debugging
#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct MarketPermissions {
    /// Bitfield value storing all permission flags.
    /// Each bit represents a different permission from the MarketPermission enum.
    pub val: u16,
}

/// Configuration for Dutch auction fee boost mechanism.
/// 
/// Implements a time-decaying fee boost that increases trading fees immediately
/// after market launch, gradually decreasing to normal fees over the auction duration.
/// This mechanism incentivizes early liquidity provision and helps with price discovery.
/// 
/// # Auction Mechanics
/// The boost follows an exponential decay curve:
/// - Maximum fee boost (`init_boost`) at t=0 (market launch)
/// - Boost value is added directly to the base_fee: `effective_fee = base_fee + boost`
/// - Gradually decreases over `duration` seconds
/// - Curvature parameter controls the decay shape
/// - Boost reaches 0 after duration expires
/// - Effective fee is capped to stay in range [0, 1.0) - strictly less than 100%
/// 
/// # Safety
/// All float parameters are validated to prevent NaN, infinity, and overflow conditions
/// that could compromise market operations. init_boost must be in range [0, 1.0).
#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct DutchConfigSerialized {
    /// Initial fee boost value at market launch (added directly to base_fee).
    /// Must be in range [0, 1.0) and gradually decays to 0 over the auction duration.
    /// Example: init_boost = 0.10 means add 10% to the base fee during initial trading.
    pub init_boost: f64,
    /// Duration of the Dutch auction in seconds.
    /// After this period, the boost reaches 0 and normal pricing applies.
    pub duration: u32,
    /// Curvature parameter controlling the decay rate of the boost.
    /// Higher values create steeper initial drops and slower final decay.
    pub curvature: f64,
}

/// Serialized representation of a single linear segment in a multi-segment curve.
/// 
/// Each segment defines a linear price function over a specific supply range,
/// with seamless transitions to adjacent segments ensuring price continuity.
#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct SegmentSerialized {
    /// Starting X-coordinate of this segment (serialized Decimal).
    /// Represents the supply level where this segment begins.
    pub start: [u8; 16],
    /// Ending X-coordinate of this segment (serialized Decimal).
    /// Represents the supply level where this segment ends.
    pub end: [u8; 16],
    /// Slope of this linear segment (serialized Decimal).
    /// Determines how quickly price changes with supply in this range.
    pub m: [u8; 16],
    /// Y-intercept of this segment (serialized Decimal).
    /// Base price offset for the linear equation y = mx + b.
    pub b: [u8; 16],
}

/// Serialized representation of a multi-segment bonding curve with adaptive complexity.
/// 
/// This structure enables sophisticated price curves that can evolve over time while
/// maintaining important invariants like area-under-curve preservation. The curve
/// consists of an initial shoulder region, optional middle segments, and a final
/// tail segment extending to maximum supply.
/// 
/// # Curve Evolution
/// The curve starts simple (shoulder + tail) but gains complexity when:
/// - Floor price is raised (adds middle segments)
/// - Market conditions require price curve adjustments
/// - Area preservation constraints need to be maintained
/// 
/// # Segment Organization
/// 1. Implicit shoulder: [0, shoulder_end] with slope = final_segment.m * shoulder_slope_scalar
/// 2. Middle segments: Variable-length array for intermediate price regions
/// 3. Final segment: Extends from last middle segment (or shoulder) to u64::MAX
#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct MultiPriceCurveSerialized {
    /// Minimum price floor for the token (serialized Decimal).
    /// Price cannot fall below this value regardless of supply.
    pub floor_height: [u8; 16],
    /// Multiplier for shoulder slope relative to neighboring segment (serialized Decimal).
    /// Creates steeper initial pricing for early adopters.
    pub shoulder_slope_scalar: [u8; 16],
    /// Variable-length array of middle curve segments.
    /// Empty for simple curves, populated when floor is raised.
    pub middle_segments: Vec<SegmentSerialized>,
    /// The main segment extending to maximum supply (u64::MAX).
    /// Defines the long-tail pricing behavior of the market.
    pub final_segment: SegmentSerialized,
}

/// Dynamic state tracking for market operations and accounting.
/// 
/// MarketState maintains all mutable values that change during market operations,
/// separate from the static configuration in MarketMeta and the price curve parameters.
/// This separation allows for efficient state updates without modifying larger structures.
/// 
/// # State Components
/// - **Token Supply**: Total minted tokens in circulation
/// - **Cash Liquidity**: Available main token (e.g., USDC) for operations
/// - **Debt**: Total borrowed amount across all positions
/// - **Collateral**: Total deposited tokens used as collateral
/// - **Revenue**: Cumulative fees collected for market group and tenant
/// 
/// # Accounting Invariants
/// The state maintains several important invariants:
/// - Token supply reflects actual minted tokens
/// - Cash liquidity equals vault balance minus outstanding debt
/// - Total debt equals sum of all individual position debts
/// - Total collateral equals sum of all position collateral deposits
/// 
/// # Revenue Distribution
/// Fees collected from market operations are tracked separately for:
/// - Market group admin (receives majority of fees)
/// - Tenant platform (receives platform fee percentage)
#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct MarketState {
    /// Total supply of tokens minted by this market.
    /// Increases when users buy tokens, decreases when tokens are sold back.
    pub token_supply: u64,
    /// Total amount of main token (cash) held in the market's liquidity vault.
    /// Represents available liquidity for sells and borrows.
    pub total_cash_liquidity: u64,
    /// Total outstanding debt across all borrowers in this market.
    /// Sum of all individual borrow positions.
    pub total_debt: u64,
    /// Total token collateral deposited across all positions in this market.
    /// Sum of all individual collateral deposits.
    pub total_collateral: u64,
    /// Cumulative revenue earned by the market group (in main token units).
    /// Tracks total fees collected for the market group admin.
    pub cumulative_revenue_market: u128,
    /// Cumulative revenue earned by the tenant (in main token units).
    /// Tracks platform fees collected for the tenant.
    pub cumulative_revenue_tenant: u128,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub enum MultiMarketInitValidationError {
    ShoulderSlopeScalarNotGreaterThanOne,
    ShoulderSlopeScalarNotFinite,
    MainSlopeNotPositive,
    MainSlopeNotFinite,
    FloorNotPositive,
    FloorNotFinite,
    DutchConfigValidationError(/* Complex fields */),
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub enum MarketLinearInitValidationError {
    M2MustBeGreaterThanZero,
    M1MustBeGreaterThanM2,
    FMustBeGreaterThanZero,
    InvalidCurveParameters,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub enum FeeBoundsError {
    GreaterThanOne,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub enum SetFeeError {
    NegativeFee,
    GreaterThanOne,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub enum MarketPermission {
    CanBuy,
    CanSell,
    CanBorrow,
    CanRepay,
    CanMintOptions,
    CanExerciseOptions,
    CanRaiseFloor,
    CanDepositCollateral,
    CanWithdrawCollateral,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub enum DutchConfigValidationError {
    InitBoostNotPositive,
    CurvatureZero,
    CurvatureNegative,
    InitBoostInfinity,
    InitBoostNaN,
    CurvatureInfinity,
    CurvatureNaN,
    InitBoostTooLarge,
    CurvatureTooLarge,
    DurationZero,
    CBProductOverflow,
    InvalidParameters,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub enum FullOrPartialU64 {
    Full,
    Partial(u64),
}

pub type MicroBasisPoints = u32;

// Event structures
#[event]
pub struct BorrowEvent {
    /// Fee amount allocated to the market group admin (in main token units).
    /// Part of the total borrow fee after platform fee deduction.
    pub fee_market_group: u64,
    /// Platform fee amount allocated to the tenant (in main token units).
    /// Calculated as a percentage of the total borrow fee.
    pub fee_tenant: u64,
    /// Net amount of main tokens received by the borrower after fees.
    /// This is the actual amount transferred to the borrower's account.
    pub net_cash_out: u64,
    /// New debt balance for the personal position
    pub new_debt: u64,
    /// Owner of the personal position account
    pub personal_position_owner: Pubkey,
    /// Address of the personal position account
    pub personal_position_address: Pubkey,
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct BuyEvent {
    /// The account that purchased tokens from the market.
    pub trader: Pubkey,
    /// Amount of market tokens minted and sent to the trader.
    pub token_out: u64,
    /// Amount of main tokens paid by the trader (excluding fees).
    /// This is the amount that went into the liquidity pool.
    pub net_cash_in: u64,
    /// Fee amount allocated to the market group admin (in main token units).
    pub fee_market_group: u64,
    /// Platform fee amount allocated to the tenant (in main token units).
    pub fee_tenant: u64,
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct BuyWithExactCashInAndDepositWithDebtEvent {
    /// The owner of the personal position (who is also the trader in this case)
    pub personal_position_owner: Pubkey,
    /// The personal position account
    pub personal_position: Pubkey,
    /// The account that provided cash for the purchase
    pub trader: Pubkey,
    /// The net cash spent (after fees, including debt used in purchase - market volume)
    pub net_cash_spent: u64,
    /// The total cash in from the trader (amount deducted from trader's account)
    pub trader_cash_spend: u64,
    /// The new acquired debt
    pub newly_acquired_debt: u64,
    /// The number of tokens purchased and deposited as collateral
    pub token_out: u64,
    /// New collateral balance in the personal position after deposit
    pub new_personal_position_collateral: u64,
    /// New debt balance in the personal position after borrowing
    pub new_personal_position_debt: u64,
    /// Borrow fee allocated to the market group admin (in main token units)
    pub fee_market_group_borrow: u64,
    /// Buy fee allocated to the market group admin (in main token units)
    pub fee_market_group_buy: u64,
    /// Borrow fee allocated to the tenant platform (in main token units)
    pub fee_platform_borrow: u64,
    /// Buy fee allocated to the tenant platform (in main token units)
    pub fee_platform_buy: u64,
    /// Market state snapshot at the time of the transaction
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct DepositEvent {
    /// The account that paid for and transferred the market tokens being deposited as collateral.
    pub payer: Pubkey,
    /// The address of the personal position account receiving the deposited collateral.
    pub personal_position_address: Pubkey,
    /// Amount of market tokens deposited as collateral into the personal position.
    /// These tokens are transferred to the position's escrow account.
    pub amount: u64,
    /// The new collateral balance of the personal position after the deposit.
    /// This will be greater than the previous balance by the deposited amount.
    pub new_balance: u64,
    /// Snapshot of the market state after the deposit transaction.
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct ExerciseOptionsEvent {
    /// The account that exercised the options.
    pub owner: Pubkey,
    /// Number of option tokens exercised (and market tokens received).
    pub amount: u64,
    /// Platform fee amount allocated to the tenant (in main token units).
    pub fee_tenant: u64,
    /// Fee amount allocated to the market group admin (in main token units).
    pub fee_market_group: u64,
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct RedeemAtFloorEvent {
    /// The account that redeemed tokens at floor price.
    pub trader: Pubkey,
    /// Amount of market tokens burned for redemption.
    /// These tokens are exchanged at the floor price rate.
    pub token_in: u64,
    /// Platform fee amount allocated to the tenant (in main token units).
    pub fee_platform: u64,
    /// Fee amount allocated to the market group admin (in main token units).
    pub fee_market_group: u64,
    /// Net amount of main tokens received by the trader after fees.
    /// Calculated as: token_in * floor_price - total_fees.
    pub net_cash_out: u64,
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct RepayEvent {
    /// The account that provided main tokens to repay the debt.
    /// This may be the position owner or another authorized party.
    pub repayer: Pubkey,
    /// The owner of the personal position whose debt is being repaid.
    pub personal_position_owner: Pubkey,
    /// The address of the personal position account that had its debt reduced.
    pub personal_position_address: Pubkey,
    /// Amount of main tokens used to repay debt.
    /// This amount is transferred from the repayer to the market's liquidity pool.
    pub amount: u64,
    /// The new debt balance of the personal position after repayment.
    /// This will be less than the previous debt by the repaid amount (minus any accrued interest).
    pub new_debt: u64,
    /// Snapshot of the market state after the repayment transaction.
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct SellWithExactTokenInEvent {
    /// The account that sold tokens back to the market.
    pub trader: Pubkey,
    /// Amount of market tokens burned in the sale.
    pub token_in: u64,
    /// Amount of main tokens received by the trader after fees.
    /// This is the net amount transferred to the trader.
    pub actual_cash_out: u64,
    /// Platform fee amount allocated to the tenant (in main token units).
    pub fee_platform: u64,
    /// Fee amount allocated to the market group admin (in main token units).
    pub fee_market_group: u64,
    /// The market state snapshot at the time of the sell
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct WithdrawEvent {
    /// The owner of the personal position making the withdrawal.
    pub personal_position_owner: Pubkey,
    /// The address of the personal position account from which collateral is being withdrawn.
    pub personal_position_address: Pubkey,
    /// Amount of market tokens being withdrawn from the position's collateral.
    /// These tokens are transferred from the position's escrow to the user's destination account.
    pub amount: u64,
    /// The new collateral balance of the personal position after withdrawal.
    /// This will be less than the previous balance by the withdrawn amount.
    pub new_balance: u64,
    /// Snapshot of the market state after the withdrawal transaction.
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct WithdrawSellAndRepayEvent {
    /// The owner of the personal position (who is also the trader in this case)
    pub personal_position_owner: Pubkey,
    /// The address of the personal position
    pub personal_position_address: Pubkey,
    /// The fee to the platform (from selling)
    pub fee_to_platform: u64,
    /// The fee to the market group (from selling)
    pub fee_to_market_group: u64,
    /// Cash to user (not including fees)
    pub cash_to_user: u64,
    /// The amount of collateral sold
    pub collateral_sold: u64,
    /// The amount of debt repaid
    pub debt_repaid: u64,
    /// The new collateral balance in the personal position
    pub new_personal_position_collateral_balance: u64,
    /// The new debt balance in the personal position
    pub new_personal_position_debt_balance: u64,
    /// The market state snapshot after the trade
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct DonateLiquidityEvent {
    /// The account that donated liquidity to the market.
    pub payer: Pubkey,
    /// The market metadata account that received the donation.
    pub market_meta: Pubkey,
    /// Total cash balance in the market after the donation.
    /// This increased liquidity may enable floor price increases.
    pub new_cash_balance: u64,
    /// Amount of main tokens donated to the market's liquidity pool.
    pub amount: u64,
}

#[event]
pub struct MarketLinearInitEvent {
    /// The market metadata account that stores configuration and references to all associated token accounts.
    /// This account holds information about the market's tokens, vaults, revenue escrows, and permissions.
    pub market_meta: Pubkey,
    /// The market state account that stores the linear price curve parameters and market state.
    /// This account contains the mathematical definition of the pricing curve (floor, slopes, shoulder) and tracks supply/collateral/debt.
    pub market_state: Pubkey,
    /// The market group that owns this market.
    /// The market inherits fee configuration from the market group and distributes revenue to the group admin.
    pub group: Pubkey,
}

#[event]
pub struct RaiseFloorFromExcessLiquidity2Event {
    /// The market metadata account where the floor was raised.
    pub market_meta: Pubkey,
    pub prev_floor: DecimalSerialized,
    /// New minimum price floor after utilizing excess liquidity (serialized Decimal).
    /// Raised proportionally based on available excess liquidity in the market.
    pub new_floor: DecimalSerialized,
    /// Area under the curve after the floor raise
    pub new_area_under_curve: u64,
    /// Area under the curve before the floor raise
    pub prev_area_under_curve: u64,
    /// cash + debt (ie, the max area under the curve)
    pub total_liquidity: u64,
}

#[event]
pub struct RaiseFloorFromExcessLiquidityEvent {
    /// The market metadata account where the floor was raised.
    pub market_meta: Pubkey,
    /// New minimum price floor after utilizing excess liquidity (serialized Decimal).
    /// Raised proportionally based on available excess liquidity in the market.
    pub new_floor: DecimalSerialized,
    /// Area under the price curve up to current supply after raising the floor.
    /// Measured in token units and represents the total value locked in the curve.
    pub new_area_under_curve: u64,
}

#[event]
pub struct RaiseFloorFromTriggerEvent {
    /// The market metadata account where the floor was raised.
    pub market_meta: Pubkey,
    /// New minimum price floor for the token (serialized Decimal).
    /// Price cannot fall below this value after the adjustment.
    pub new_floor: DecimalSerialized,
    /// New X-coordinate where the shoulder segment ends (supply units).
    /// Determines the transition point between price curve segments.
    pub new_shoulder_end: u64,
    /// Area under the price curve after the floor raise.
    /// Represents total liquidity backing up to current supply.
    pub new_area: u64,
    /// Area under the price curve before the floor raise.
    /// Used to verify the operation maintained proper backing.
    pub prev_area: u64,
}

#[event]
pub struct RaiseFloorPreserveAreaChecked2Event {
    /// The market metadata account where the floor was raised.
    pub market_meta: Pubkey,
    /// New minimum price floor after the adjustment (serialized Decimal).
    pub new_floor: DecimalSerialized,
    /// New X-coordinate where the shoulder segment ends (supply units).
    pub new_shoulder_end: u64,
    /// Resulting liquidity buffer ratio after the floor raise (serialized Decimal).
    pub new_liq_ratio: DecimalSerialized,
    /// Area under the price curve up to current supply before raising the floor.
    /// Measured in token units and represents the integral of the price curve from 0 to supply.
    pub prev_area: u64,
    /// Area under the price curve up to current supply after raising the floor.
    /// Should not shrink by more than the maximum allowed tolerance to prevent excessive value extraction.
    pub new_area: u64,
}

#[event]
pub struct RaiseFloorPreserveAreaCheckedEvent {
    /// New minimum price floor after the adjustment (serialized Decimal).
    /// Calculated as: old_floor * (1 + floor_increase_ratio).
    pub new_floor: DecimalSerialized,
    /// New X-coordinate where the shoulder segment ends (supply units).
    /// Must be greater than the previous shoulder end to maintain curve validity.
    pub new_shoulder_end: u64,
    /// Resulting liquidity buffer ratio after the floor raise (serialized Decimal).
    /// Ratio of excess liquidity to required liquidity, must meet minimum threshold.
    pub new_liq_ratio: DecimalSerialized,
}

#[event]
pub struct MarketFlagsChangeEvent {
    /// The market metadata account whose permissions were changed.
    pub market_meta: Pubkey,
    /// New permission flags controlling market operations.
    /// Determines which operations (buy, sell, borrow, etc.) are allowed.
    pub new_flags: MarketPermissions,
}

#[event]
pub struct MarketGroupAcceptNewAdminEvent {
    /// The market group account whose admin was transferred.
    pub market_group: Pubkey,
    /// The new admin public key that accepted ownership.
    /// This account now has full control over the market group.
    pub new_admin: Pubkey,
}

#[event]
pub struct MarketGroupChangeFeesEvent {
    /// The market group account whose fees were updated.
    pub market_group: Pubkey,
    /// New fee structure for all markets in this group.
    /// Contains updated buy, sell, borrow, and exercise option fee rates.
    pub new_fees: Fees,
}

#[event]
pub struct MarketGroupCollectRevEvent {
    /// The market metadata account from which revenue was collected.
    pub market_meta: Pubkey,
    /// Amount of revenue collected (in main token units).
    /// This represents accumulated fees from market operations.
    pub amount: u64,
    /// The destination token account that received the revenue.
    pub to: Pubkey,
}

#[event]
pub struct MarketGroupInitialized {
    /// The tenant account that owns this market group.
    pub tenant: Pubkey,
    /// The seed public key used to derive the market group's PDA address.
    pub market_group_seed: Pubkey,
    /// The admin public key with control over this market group.
    pub group_admin: Pubkey,
    /// Fee configuration for all markets in this group.
    /// Contains buy, sell, borrow, and exercise option fee rates.
    pub fees: Fees,
}

#[event]
pub struct MarketGroupProposeAdminEvent {
    /// The market group account for which a new admin was proposed.
    pub market_group: Pubkey,
    /// The proposed new admin public key.
    /// Must be accepted by this account to complete the transfer.
    pub new_admin: Pubkey,
}

#[event]
pub struct MintOptionsEvent {
    /// The market metadata account for which options were minted.
    pub market_meta: Pubkey,
    /// The destination token account that received the minted options.
    pub options_dst: Pubkey,
    /// Number of option tokens minted.
    /// These can later be exercised to purchase market tokens.
    pub amount: u64,
}

#[event]
pub struct PersonalPositionInitEvent {
    /// The market metadata account this position is associated with.
    pub market_meta: Pubkey,
    /// The account that paid for creating the position accounts.
    pub payer: Pubkey,
    /// The owner public key who will control this position.
    pub owner: Pubkey,
    /// The newly created personal position account address.
    pub personal_position: Pubkey,
}

#[event]
pub struct TenantAcceptNewAdminEvent {
    /// The tenant account whose admin was transferred.
    pub tenant: Pubkey,
    /// The new admin public key that accepted ownership.
    /// This account now has full control over the tenant.
    pub new_admin: Pubkey,
}

#[event]
pub struct TenantChangeFeeMbpsEvent {
    /// The tenant account whose fee was changed.
    pub tenant: Pubkey,
    /// The new fee in micro basis points.
    pub fee_micro_bps: u32,
}

#[event]
pub struct TenantCollectRevEvent {
    /// The market metadata account associated with the revenue collection.
    pub market_meta: Pubkey,
    /// Amount of platform revenue collected (in main token units).
    /// This represents accumulated platform fees from market operations.
    pub amount: u64,
    /// The destination token account that received the platform revenue.
    pub to: Pubkey,
}

#[event]
pub struct TenantInitialized {
    /// The seed public key used to derive the tenant's PDA address.
    pub tenant_seed: Pubkey,
    /// The admin public key with control over this tenant.
    pub admin: Pubkey,
    /// Platform fee rate in micro basis points (1 micro bp = 0.0001%).
    /// This fee is taken from all market operations under this tenant.
    pub fee_micro_bps: u32,
    /// Whether market groups can be created without tenant admin approval.
    /// If true, anyone can create market groups under this tenant.
    pub permissionless_group_creation: bool,
}

#[event]
pub struct TenantProposeAdminEvent {
    /// The tenant account for which a new admin was proposed.
    pub tenant: Pubkey,
    /// The proposed new admin public key.
    /// Must be accepted by this account to complete the transfer.
    pub new_admin: Pubkey,
}

#[event]
pub struct TestLogEvent {
    pub payer: Pubkey,
    pub log_account: Pubkey,
    pub data: u64,
}