may_cpi/

lib.rs

use anchor_lang::prelude::*;

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

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

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

#[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")
    }

    /// Initialize a linear market with Dutch auction and token unit scaling.
    ///
    /// This instruction extends `market_linear_init_with_dutch` with support for
    /// token unit scaling. The `token_unit_scale` parameter controls how token
    /// units map to curve units via the factor `2^token_unit_scale`:
    ///
    /// - `scale=0`: 1 token = 1 curve unit (no scaling, default behavior)
    /// - `scale=3`: 8 tokens = 1 curve unit (for high-decimal tokens)
    /// - `scale=-2`: 1 token = 4 curve units (for low-decimal tokens)
    ///
    /// # Use Cases
    ///
    /// - High-decimal tokens (e.g., 9 decimals): Use positive scale to reduce
    /// the effective supply range the curve operates over
    /// - Low-decimal tokens: Use negative scale to expand the curve's range
    ///
    /// # Access Control
    ///
    /// Only the market group admin can create new markets.
    pub fn market_simple_init_v2(
        _ctx: Context<MarketSimpleInitV2Accounts>,
        _market_args: MarketSimpleInitV2Args,
    ) -> 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>,
}

/// Initialize a linear market with Dutch auction and token unit scaling.
///
/// This instruction extends `market_linear_init_with_dutch` with support for
/// token unit scaling. The `token_unit_scale` parameter controls how token
/// units map to curve units via the factor `2^token_unit_scale`:
///
/// - `scale=0`: 1 token = 1 curve unit (no scaling, default behavior)
/// - `scale=3`: 8 tokens = 1 curve unit (for high-decimal tokens)
/// - `scale=-2`: 1 token = 4 curve units (for low-decimal tokens)
///
/// # Use Cases
///
/// - High-decimal tokens (e.g., 9 decimals): Use positive scale to reduce
/// the effective supply range the curve operates over
/// - Low-decimal tokens: Use negative scale to expand the curve's range
///
/// # Access Control
///
/// Only the market group admin can create new markets.
#[derive(Accounts)]
pub struct MarketSimpleInitV2Accounts<'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.
/// The `token_unit_scale` for x-axis scaling is stored in MarketMeta.
#[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,
    /// Power-of-2 exponent for scaling raw token units on the price curve's x-axis.
    ///
    /// When computing prices, the raw token supply is scaled by `2^token_unit_scale`:
    /// - Positive k: `scaled_supply = raw_supply >> k` (divide by 2^k)
    /// - Negative k: `scaled_supply = raw_supply << |k|` (multiply by 2^|k|)
    /// - Zero (default): no scaling, `scaled_supply = raw_supply`
    ///
    /// # Purpose
    /// Normalizes the price curve slope to ~1.0 for better fixed-point precision.
    /// Without scaling, tokens with vastly different values produce slopes that
    /// are either extremely small or extremely large, causing precision loss.
    ///
    /// # Example: BTC vs BONK
    /// - **BTC**: 8 decimals, ~$100k → 1 satoshi = $0.001 → slope might be ~15e9
    /// - **BONK**: 5 decimals, ~$1e-6 → 1 raw unit = $1e-11 → slope might be ~1e-22
    ///
    /// After applying appropriate `token_unit_scale`:
    /// - BTC with k=13: slope becomes ~1.2
    /// - BONK with k=76: slope becomes ~1.1
    ///
    /// # Calculation
    /// Use `find_x_scale_for_raw_units()` in `slope_helper.rs` to compute optimal k:
    /// `k = round(-log₂(m_raw))` where `m_raw` is the slope in raw token units.
    ///
    /// # Why Base-2?
    /// - Bit shifts (`>>` / `<<`) are exact operations with no rounding error
    /// - Native to binary fixed-point arithmetic
    /// - More precise than base-10 (~41% max deviation vs ~216%)
    pub token_unit_scale: i8,
}

/// 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,
}

/// Arguments for initializing a market with Dutch auction and token scaling support.
#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct MarketSimpleInitV2Args {
    /// Slope of the main segment after the shoulder.
    pub m2: DecimalSerialized,
    /// Multiplier for the m1 slope as a percentage of m2.
    /// must be greater than 100u32
    pub m1_multiplier_percent: u32,
    /// Floor price - minimum price the token can trade at.
    pub f: DecimalSerialized,
    /// Unix timestamp when trading begins (0 for immediate).
    pub start_time: u64,
    /// Dutch auction configuration for launch price boost.
    pub dutch_config: DutchConfigSerialized,
    /// Market permissions (buy, sell, borrow, etc.).
    pub permissions: MarketPermissions,
    /// Token unit scale factor (power of 2).
    /// Controls the ratio between token units and curve units.
    /// - 0: 1 token = 1 curve unit (default)
    /// - positive: 2^scale tokens = 1 curve unit
    /// - negative: 1 token = 2^|scale| curve units
    pub token_unit_scale: i8,
}

#[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.
    /// DIMENSIONLESS - no scaling
    pub floor: [u8; 16],
    /// Slope of the shoulder segment (m1, serialized Decimal).
    /// Steeper initial slope providing higher prices at low supply.
    /// SCALED by market meta 2^token_unit_scale
    pub m1: [u8; 16],
    /// Slope of the main segment (m2, serialized Decimal).
    /// Gentler slope for bulk of the curve after shoulder point.
    /// SCALED by market meta 2^token_unit_scale
    pub m2: [u8; 16],
    /// X-coordinate where shoulder transitions to main slope (supply units).
    /// Defines the breakpoint between steep and gentle price curves.
    /// NOT SCALED - stored in raw token units
    pub x2: u64,
    /// Y-intercept of the main segment (b2, serialized Decimal).
    /// Determines vertical offset of the main price curve.
    /// DIMENSIONLESS - no scaling
    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 and scales with remaining fee space:
/// - Maximum fee boost (`init_boost`) at t=0 (market launch)
/// - Boost scales with remaining space: `effective_fee = base_fee + boost * (1 - base_fee)`
/// - This ensures effective_fee never exceeds 100% regardless of configuration
/// - Gradually decreases over `duration` seconds
/// - Curvature parameter controls the decay shape
/// - Boost reaches 0 after duration expires
///
/// # Example
/// With base_fee = 5% and init_boost = 0.50 (50%):
/// - remaining_space = 100% - 5% = 95%
/// - scaled_boost = 50% × 95% = 47.5%
/// - effective_fee = 5% + 47.5% = 52.5%
///
/// # 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).
/// The scaling mechanism guarantees effective fees stay bounded regardless of configuration.
#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct DutchConfigSerialized {
    /// Initial fee boost value representing fraction of remaining fee space to consume.
    /// Must be in range [0, 1.0) and gradually decays to 0 over the auction duration.
    /// Example: init_boost = 0.50 with base_fee = 5% → effective_fee = 5% + 50% × 95% = 52.5%
    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 DutchConfigValidationError {
    InitBoostNotPositive,
    CurvatureZero,
    CurvatureNegative,
    InitBoostInfinity,
    InitBoostNaN,
    CurvatureInfinity,
    CurvatureNaN,
    InitBoostTooLarge,
    CurvatureTooLarge,
    DurationZero,
    InvalidParameters,
}

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

pub type MicroBasisPoints = u32;

// Event structures
#[event]
pub struct BorrowEvent {
    pub fee_market_group: u64,
    pub fee_tenant: u64,
    pub net_cash_out: u64,
    pub new_debt: u64,
    pub personal_position_owner: Pubkey,
    pub personal_position_address: Pubkey,
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct BuyEvent {
    pub trader: Pubkey,
    pub token_out: u64,
    pub net_cash_in: u64,
    pub fee_market_group: u64,
    pub fee_tenant: u64,
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct BuyWithExactCashInAndDepositWithDebtEvent {
    pub personal_position_owner: Pubkey,
    pub personal_position: Pubkey,
    pub trader: Pubkey,
    pub net_cash_spent: u64,
    pub trader_cash_spend: u64,
    pub newly_acquired_debt: u64,
    pub token_out: u64,
    pub new_personal_position_collateral: u64,
    pub new_personal_position_debt: u64,
    pub fee_market_group_borrow: u64,
    pub fee_market_group_buy: u64,
    pub fee_platform_borrow: u64,
    pub fee_platform_buy: u64,
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct DepositEvent {
    pub payer: Pubkey,
    pub personal_position_address: Pubkey,
    pub amount: u64,
    pub new_balance: u64,
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct ExerciseOptionsEvent {
    pub owner: Pubkey,
    pub amount: u64,
    pub fee_tenant: u64,
    pub fee_market_group: u64,
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct RedeemAtFloorEvent {
    pub trader: Pubkey,
    pub token_in: u64,
    pub fee_platform: u64,
    pub fee_market_group: u64,
    pub net_cash_out: u64,
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct RepayEvent {
    pub repayer: Pubkey,
    pub personal_position_owner: Pubkey,
    pub personal_position_address: Pubkey,
    pub amount: u64,
    pub new_debt: u64,
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct SellWithExactTokenInEvent {
    pub trader: Pubkey,
    pub token_in: u64,
    pub actual_cash_out: u64,
    pub fee_platform: u64,
    pub fee_market_group: u64,
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct WithdrawEvent {
    pub personal_position_owner: Pubkey,
    pub personal_position_address: Pubkey,
    pub amount: u64,
    pub new_balance: u64,
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct WithdrawSellAndRepayEvent {
    pub personal_position_owner: Pubkey,
    pub personal_position_address: Pubkey,
    pub fee_to_platform: u64,
    pub fee_to_market_group: u64,
    pub cash_to_user: u64,
    pub collateral_sold: u64,
    pub debt_repaid: u64,
    pub new_personal_position_collateral_balance: u64,
    pub new_personal_position_debt_balance: u64,
    pub market_state_snapshot: MarketStateSnapshot,
}

#[event]
pub struct DonateLiquidityEvent {
    pub payer: Pubkey,
    pub market_meta: Pubkey,
    pub new_cash_balance: u64,
    pub amount: u64,
}

#[event]
pub struct MarketLinearInitEvent {
    pub market_meta: Pubkey,
    pub market_state: Pubkey,
    pub group: Pubkey,
}

#[event]
pub struct RaiseFloorFromExcessLiquidity2Event {
    pub market_meta: Pubkey,
    pub prev_floor: DecimalSerialized,
    pub new_floor: DecimalSerialized,
    pub new_area_under_curve: u64,
    pub prev_area_under_curve: u64,
    pub total_liquidity: u64,
}

#[event]
pub struct RaiseFloorFromExcessLiquidityEvent {
    pub market_meta: Pubkey,
    pub new_floor: DecimalSerialized,
    pub new_area_under_curve: u64,
}

#[event]
pub struct RaiseFloorFromTriggerEvent {
    pub market_meta: Pubkey,
    pub new_floor: DecimalSerialized,
    pub new_shoulder_end: u64,
    pub new_area: u64,
    pub prev_area: u64,
}

#[event]
pub struct RaiseFloorPreserveAreaChecked2Event {
    pub market_meta: Pubkey,
    pub new_floor: DecimalSerialized,
    pub new_shoulder_end: u64,
    pub new_liq_ratio: DecimalSerialized,
    pub prev_area: u64,
    pub new_area: u64,
}

#[event]
pub struct RaiseFloorPreserveAreaCheckedEvent {
    pub new_floor: DecimalSerialized,
    pub new_shoulder_end: u64,
    pub new_liq_ratio: DecimalSerialized,
}

#[event]
pub struct MarketFlagsChangeEvent {
    pub market_meta: Pubkey,
    pub new_flags: MarketPermissions,
}

#[event]
pub struct MarketGroupAcceptNewAdminEvent {
    pub market_group: Pubkey,
    pub new_admin: Pubkey,
}

#[event]
pub struct MarketGroupChangeFeesEvent {
    pub market_group: Pubkey,
    pub new_fees: Fees,
}

#[event]
pub struct MarketGroupCollectRevEvent {
    pub market_meta: Pubkey,
    pub amount: u64,
    pub to: Pubkey,
}

#[event]
pub struct MarketGroupInitialized {
    pub tenant: Pubkey,
    pub market_group_seed: Pubkey,
    pub group_admin: Pubkey,
    pub fees: Fees,
}

#[event]
pub struct MarketGroupProposeAdminEvent {
    pub market_group: Pubkey,
    pub new_admin: Pubkey,
}

#[event]
pub struct MintOptionsEvent {
    pub market_meta: Pubkey,
    pub options_dst: Pubkey,
    pub amount: u64,
}

#[event]
pub struct PersonalPositionInitEvent {
    pub market_meta: Pubkey,
    pub payer: Pubkey,
    pub owner: Pubkey,
    pub personal_position: Pubkey,
}

#[event]
pub struct TenantAcceptNewAdminEvent {
    pub tenant: Pubkey,
    pub new_admin: Pubkey,
}

#[event]
pub struct TenantChangeFeeMbpsEvent {
    pub tenant: Pubkey,
    pub fee_micro_bps: u32,
}

#[event]
pub struct TenantCollectRevEvent {
    pub market_meta: Pubkey,
    pub amount: u64,
    pub to: Pubkey,
}

#[event]
pub struct TenantInitialized {
    pub tenant_seed: Pubkey,
    pub admin: Pubkey,
    pub fee_micro_bps: u32,
    pub permissionless_group_creation: bool,
}

#[event]
pub struct TenantProposeAdminEvent {
    pub tenant: Pubkey,
    pub new_admin: Pubkey,
}

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

#[event]
pub struct MarketSnapshotEvent {
    pub market_state_snapshot: MarketStateSnapshot,
}