may_cpi 0.6.0

use anchor_lang::prelude::*;

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

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

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

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

    /// Initialize a platform tenant
    pub fn tenant_init(
        _ctx: Context<TenantInitAccounts>,
        _fee_bps: u32,
        _permissionless_group_creation: bool,
    ) -> Result<()> {
        panic!("not implemented")
    }

    /// Initialize a market group
    /// A market group owns all markets under it and can perform admin actions on them
    pub fn market_group_init(
        _ctx: Context<MarketGroupInitAccounts>,
        _args: MarketGroupInitArgs,
    ) -> Result<()> {
        panic!("not implemented")
    }

    /// Propose a new admin for the market group
    pub fn market_group_propose_admin(
        _ctx: Context<MarketGroupProposeAdminAccounts>,
        _new_admin: Pubkey,
    ) -> Result<MarketGroupProposeAdminEvent> {
        panic!("not implemented")
    }

    /// Accept the new admin for the market group
    pub fn market_group_accept_new_admin(
        _ctx: Context<MarketGroupAcceptNewAdminAccounts>,
    ) -> Result<MarketGroupAcceptNewAdminEvent> {
        panic!("not implemented")
    }

    /// Initialize a linear market
    pub fn market_linear_init(
        _ctx: Context<MarketLinearInitAccounts>,
        _market_linear_args: MarketLinearArgs,
    ) -> Result<()> {
        panic!("not implemented")
    }

    /// Mint options
    pub fn mint_options(
        _ctx: Context<MintOptionsAccounts>,
        _amount: u64,
    ) -> Result<MintOptionsEvent> {
        panic!("not implemented")
    }

    /// Collect revenue for a market group
    pub fn market_group_collect_rev(
        _ctx: Context<MarketGroupCollectRevAccounts>,
        _amount: FullOrPartialU64,
    ) -> Result<MarketGroupCollectRevEvent> {
        panic!("not implemented")
    }

    /// Raise the floor while preserving the area under the curve
    pub fn raise_floor_preserve_area(
        _ctx: Context<RaiseFloorPreserveAreaAccounts>,
        _new_floor: DecimalSerialized,
        _new_shoulder_end: u64,
    ) -> Result<RaiseFloorFromTriggerEvent> {
        panic!("not implemented")
    }

    /// Raise the floor from excess liquidity
    pub fn raise_floor_from_excess_liquidity(
        _ctx: Context<RaiseFloorFromExcessLiquidityAccounts>,
        _new_floor: DecimalSerialized,
    ) -> Result<RaiseFloorFromExcessLiquidityEvent> {
        panic!("not implemented")
    }

    /// Change the flags for a market
    pub fn market_flags_change(
        _ctx: Context<MarketFlagsChangeAccounts>,
        _new_flags: MarketPermissions,
    ) -> Result<MarketFlagsChangeEvent> {
        panic!("not implemented")
    }

    /// Change the fees for a market group
    pub fn market_group_change_fees(
        _ctx: Context<MarketGroupChangeFeesAccounts>,
        _new_fees: Fees,
    ) -> Result<MarketGroupChangeFeesEvent> {
        panic!("not implemented")
    }

    /// Initialize a personal position for a market
    /// This position tracks collateral and debt
    pub fn personal_position_init(
        _ctx: Context<PersonalPositionInitAccounts>,
    ) -> Result<PersonalPositionInitEvent> {
        panic!("not implemented")
    }

    /// Donate liquidity to the market, increasing its cash balance
    /// Adding excess liquidity to the market will enable the floor to be raised
    pub fn donate_liquidity(
        _ctx: Context<DonateLiquidityAccounts>,
        _amount: u64,
    ) -> Result<DonateLiquidityEvent> {
        panic!("not implemented")
    }

    /// Buy a market token with exact cash in, expecting a minimum amount of tokens out
    pub fn buy_with_exact_cash_in(
        _ctx: Context<BuyWithExactCashInAccounts>,
        _cash_in: u64,
        _min_token_out: u64,
    ) -> Result<BuyEvent> {
        panic!("not implemented")
    }

    /// Buy a market token with exact cash in, expecting a minimum amount of tokens out, and deposit the tokens into a personal position
    pub fn buy_with_exact_cash_in_and_deposit(
        _ctx: Context<BuyWithExactCashInAndDepositAccounts>,
        _cash_in: u64,
        _min_token_out: u64,
    ) -> Result<BuyWithExactCashInAndDepositEvent> {
        panic!("not implemented")
    }

    /// Sell exact market tokens in, expecting a minimum amount of cash out
    pub fn sell_with_exact_token_in(
        _ctx: Context<SellWithExactTokenInAccounts>,
        _amount_in: u64,
        _cash_out_min: u64,
    ) -> Result<SellWithExactTokenInEvent> {
        panic!("not implemented")
    }

    /// Sell exact market tokens in, expecting a minimum amount of cash out, and deposit the tokens into a personal position
    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 collateral into a personal position
    pub fn deposit(_ctx: Context<DepositAccounts>, _amount: u64) -> Result<DepositEvent> {
        panic!("not implemented")
    }

    /// Withdraw collateral from a personal position
    pub fn withdraw(_ctx: Context<WithdrawAccounts>, _amount: u64) -> Result<WithdrawEvent> {
        panic!("not implemented")
    }

    /// Borrow cash from the market, using the collateral in the personal position
    pub fn borrow(_ctx: Context<BorrowAccounts>, _amount: u64) -> Result<BorrowEvent> {
        panic!("not implemented")
    }

    /// Repay cash to the market, lowering the debt in the personal position
    pub fn repay(_ctx: Context<RepayAccounts>, _amount: u64) -> Result<RepayEvent> {
        panic!("not implemented")
    }

    /// Exercise options, receiving the market tokens in return
    pub fn exercise_options(
        _ctx: Context<ExerciseOptionsAccounts>,
        _amount: u64,
    ) -> Result<ExerciseOptionsEvent> {
        panic!("not implemented")
    }

    /// Realloc the market meta account
    pub fn realloc_market_meta(_ctx: Context<ReallocMarketMetaAccounts>) -> Result<()> {
        panic!("not implemented")
    }
}

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

#[derive(Accounts)]
pub struct MarketGroupInitAccounts<'info> {
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    pub tenant: AccountInfo<'info>,
    /// Optional account, which only needs to match if the tenant does not allow permissionless group creation
    #[account(signer)]
    pub tenant_admin: AccountInfo<'info>,
    #[account(signer)]
    pub seed: AccountInfo<'info>,
    #[account(mut)]
    pub market_group: AccountInfo<'info>,
    pub system_program: AccountInfo<'info>,
}

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

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

#[derive(Accounts)]
pub struct MarketLinearInitAccounts<'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>,
}

#[derive(Accounts)]
pub struct MintOptionsAccounts<'info> {
    #[account(mut, signer)]
    pub admin: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    #[account(mut)]
    pub mint_options: AccountInfo<'info>,
    #[account(mut)]
    pub options_dst: AccountInfo<'info>,
    pub token_program: AccountInfo<'info>,
}

#[derive(Accounts)]
pub struct MarketGroupCollectRevAccounts<'info> {
    #[account(mut, signer)]
    pub group_admin: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    pub mint_main: AccountInfo<'info>,
    #[account(mut)]
    pub rev_escrow_group: AccountInfo<'info>,
    #[account(mut)]
    pub rev_dst: AccountInfo<'info>,
    pub token_program_main: AccountInfo<'info>,
}

#[derive(Accounts)]
pub struct RaiseFloorPreserveAreaAccounts<'info> {
    #[account(mut, signer)]
    pub admin: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
}

#[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>,
}

#[derive(Accounts)]
pub struct MarketFlagsChangeAccounts<'info> {
    #[account(mut, signer)]
    pub admin: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    #[account(mut)]
    pub market_meta: AccountInfo<'info>,
}

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

#[derive(Accounts)]
pub struct PersonalPositionInitAccounts<'info> {
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    pub owner: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    pub mint_token: AccountInfo<'info>,
    #[account(mut)]
    pub personal_position: AccountInfo<'info>,
    #[account(mut)]
    pub escrow: AccountInfo<'info>,
    pub token_program: AccountInfo<'info>,
    pub system_program: AccountInfo<'info>,
}

#[derive(Accounts)]
pub struct DonateLiquidityAccounts<'info> {
    /// Donor of the liquidity
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
    #[account(mut)]
    pub main_src: AccountInfo<'info>,
    /// The liquidity vault for the main token in the market
    #[account(mut)]
    pub liq_vault_main: AccountInfo<'info>,
    pub mint_main: AccountInfo<'info>,
    pub token_program_main: AccountInfo<'info>,
}

#[derive(Accounts)]
pub struct BuyWithExactCashInAccounts<'info> {
    #[account(mut, signer)]
    pub signer: 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 mint_token: AccountInfo<'info>,
    pub mint_main: AccountInfo<'info>,
    #[account(mut)]
    pub token_dst: AccountInfo<'info>,
    #[account(mut)]
    pub main_src: 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>,
    pub token_program: AccountInfo<'info>,
    pub token_program_main: AccountInfo<'info>,
}

#[derive(Accounts)]
pub struct BuyWithExactCashInAndDepositAccounts<'info> {
    #[account(mut, signer)]
    pub owner: 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 personal_position: AccountInfo<'info>,
    #[account(mut)]
    pub escrow: AccountInfo<'info>,
    #[account(mut)]
    pub mint_token: AccountInfo<'info>,
    pub mint_main: AccountInfo<'info>,
    #[account(mut)]
    pub token_dst: AccountInfo<'info>,
    #[account(mut)]
    pub main_src: 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>,
    pub token_program: AccountInfo<'info>,
    pub token_program_main: AccountInfo<'info>,
}

#[derive(Accounts)]
pub struct SellWithExactTokenInAccounts<'info> {
    #[account(mut, signer)]
    pub user: 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>,
}

#[derive(Accounts)]
pub struct SellWithExactTokenInAfterWithdrawAccounts<'info> {
    #[account(mut, signer)]
    pub owner: 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 personal_position: 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 mint_token: AccountInfo<'info>,
    pub mint_main: AccountInfo<'info>,
    #[account(mut)]
    pub main_dst: AccountInfo<'info>,
    #[account(mut)]
    pub token_src: AccountInfo<'info>,
    #[account(mut)]
    pub escrow: AccountInfo<'info>,
    pub token_program_main: AccountInfo<'info>,
    pub token_program: AccountInfo<'info>,
}

#[derive(Accounts)]
pub struct DepositAccounts<'info> {
    #[account(mut, signer)]
    pub payer: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    pub mint_token: AccountInfo<'info>,
    #[account(mut)]
    pub market_linear: AccountInfo<'info>,
    #[account(mut)]
    pub personal_position: AccountInfo<'info>,
    #[account(mut)]
    pub escrow: AccountInfo<'info>,
    #[account(mut)]
    pub token_src: AccountInfo<'info>,
    pub token_program: AccountInfo<'info>,
}

#[derive(Accounts)]
pub struct WithdrawAccounts<'info> {
    #[account(mut, signer)]
    pub owner: AccountInfo<'info>,
    pub market_meta: AccountInfo<'info>,
    pub mint_token: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
    #[account(mut)]
    pub personal_position: AccountInfo<'info>,
    #[account(mut)]
    pub escrow: AccountInfo<'info>,
    #[account(mut)]
    pub token_dst: AccountInfo<'info>,
    pub token_program: AccountInfo<'info>,
}

#[derive(Accounts)]
pub struct BorrowAccounts<'info> {
    #[account(mut, signer)]
    pub owner: AccountInfo<'info>,
    pub tenant: AccountInfo<'info>,
    pub market_group: AccountInfo<'info>,
    pub market_meta: 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>,
    pub mint_main: AccountInfo<'info>,
    #[account(mut)]
    pub main_dst: AccountInfo<'info>,
    #[account(mut)]
    pub market: AccountInfo<'info>,
    #[account(mut)]
    pub personal_position: AccountInfo<'info>,
    pub token_program_main: AccountInfo<'info>,
}

#[derive(Accounts)]
pub struct RepayAccounts<'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>,
}

#[derive(Accounts)]
pub struct ExerciseOptionsAccounts<'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>,
    #[account(mut)]
    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>,
}

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

// Account structures
/// Configuration for a group of markets
#[account]
pub struct MarketGroup {
    pub tenant: Pubkey,
    pub admin: Pubkey,
    pub proposed_admin: Option<Pubkey>,
    pub pda_meta: PdaMeta,
    pub fees: Fees,
}

#[account]
pub struct MarketLinear {
    /// The market_meta for the linear
    pub market_meta: Pubkey,
    /// The state for the market
    pub state: MarketState,
    /// The price curve for the market
    pub price_curve: LinearPriceCurveSerialized,
}

#[account]
pub struct MarketMultiCurve {
    /// The market_meta for the multi-curve
    pub market_meta: Pubkey,
    /// The state for the market
    pub state: MarketState,
    /// The price curve for the market
    pub price_curve: MultiPriceCurveSerialized,
}

/// Generic metadata for all kinds of markets
#[account]
pub struct MarketMeta {
    /// Mint for the main backing token (the cash token)
    pub mint_main: Pubkey,
    /// Mint for the token being traded
    pub mint_token: Pubkey,
    /// Mint for the options token
    pub mint_options: Pubkey,
    /// The market group for the market
    pub market_group: Pubkey,
    /// The market for the meta
    /// Must link here in order to ensure that there is a 1:1 relationship between market and market meta
    pub market: Pubkey,
    /// The program ID for the main token
    pub token_program_main: Pubkey,
    /// Vault that holds the liquidity for the main token
    pub liq_vault_main: Pubkey,
    /// The token account that holds the revenue for the market
    pub rev_escrow_group: Pubkey,
    /// The token account that holds the revenue for the tenant
    pub rev_escrow_tenant: Pubkey,
    /// The PDA meta for the market
    pub pda_meta: PdaMeta,
    /// Decimals for the main token
    pub decimals: u8,
    pub permissions: MarketPermissions,
    /// Timestamp of when the market starts
    pub start_time: u32,
    /// The Dutch auction config for the market
    pub dutch_config: DutchConfigSerialized,
}

#[account]
pub struct PersonalPosition {
    pub market_meta: Pubkey,
    pub owner: Pubkey,
    pub escrow: Pubkey,
    pub deposited_token_balance: u64,
    pub debt: u64,
    pub bump: [u8; 1],
}

#[account]
pub struct Tenant {
    pub seed: Pubkey,
    pub bump: [u8; 1],
    pub admin: Pubkey,
    pub proposed_admin: Option<Pubkey>,
    pub platform_fee_micro_bps: u32,
    /// Whether a group can be created without permission from the root admin
    pub permissionless_group_creation: bool,
}

// Type structures
#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct BuyWithExactCashInAndDepositEvent {
    pub trader: Pubkey,
    pub market: Pubkey,
    pub personal_position: Pubkey,
    pub token_out: u64,
    pub new_personal_position_balance: u64,
}

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

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

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct SellWithExactTokenInAfterWithdrawEvent {
    pub trader: Pubkey,
    pub market_meta: Pubkey,
    pub token_in: u64,
    pub actual_cash_out: u64,
    pub fee_platform: u64,
    pub fee_market_group: u64,
    /// The new balance of the personal position
    pub new_token_balance: u64,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct DecimalSerialized {
    pub val: [u8; 16],
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct PdaMeta {
    pub bump: [u8; 1],
    pub seed: Pubkey,
}

/// All fees denominated in micro-basis points (1/10000th of a percent)
#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct Fees {
    pub buy: u32,
    pub sell: u32,
    pub borrow: u32,
    pub exercise_option: u32,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct MultiPriceCurveSerialized {
    /// Height of the floor
    pub floor: [u8; 16],
    /// End of the floor (beginning of the shoulder)
    pub floor_end: u64,
    /// Slope of the shoulder as a multiple of the next neighbor's slope
    pub shoulder_slope_scalar: [u8; 16],
    /// Middle vertices could be empty
    pub middle_vertices: Vec<Vertex>,
    /// Final vertex, which extends into infinity
    pub final_vertex: Vertex,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct Vertex {
    pub x: u64,
    pub m: [u8; 16],
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct MarketState {
    /// The total supply of the token
    pub token_supply: u64,
    /// The total cash liquidity in the market
    pub total_cash_liquidity: u64,
    /// The total debt in the market
    pub total_debt: u64,
    /// The total collateral in the market
    pub total_collateral: u64,
    /// The cumulative revenue for the market
    pub cumulative_revenue_market: u128,
    /// The cumulative revenue for the tenant
    pub cumulative_revenue_tenant: u128,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct MarketPermissions {
    pub val: u16,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct DutchConfigSerialized {
    /// Initial boost for the dutch auction
    pub init_boost: f64,
    /// Duration of the dutch auction in seconds
    pub duration: u32,
    /// Curvature of the dutch auction
    pub curvature: f64,
}

#[derive(Clone, Debug, AnchorSerialize, AnchorDeserialize)]
pub struct LinearPriceCurveSerialized {
    pub floor: [u8; 16],
    /// Shoulder slope
    pub m1: [u8; 16],
    /// main slope
    pub m2: [u8; 16],
    /// Shoulder end
    pub x2: u64,
    /// Main y-intercept
    pub b2: [u8; 16],
}

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

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

pub type MicroBasisPoints = u32;

// Event structures
#[event]
pub struct BorrowEvent {
    pub market: Pubkey,
    pub personal_position: Pubkey,
    pub fee_market_group: u64,
    pub fee_tenant: u64,
    pub net_cash_out: u64,
}

#[event]
pub struct BuyEvent {
    pub trader: Pubkey,
    pub market: Pubkey,
    pub token_out: u64,
    pub net_cash_in: u64,
    pub fee_market: u64,
    pub fee_tenant: u64,
}

#[event]
pub struct DepositEvent {
    pub payer: Pubkey,
    pub market: Pubkey,
    pub personal_position: Pubkey,
    pub amount: u64,
    pub new_balance: u64,
}

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

#[event]
pub struct ExerciseOptionsEvent {
    pub owner: Pubkey,
    pub market_meta: Pubkey,
    pub amount: u64,
    pub fee_tenant: u64,
    pub fee_market: u64,
}

#[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_group: Pubkey,
    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 amount: u64,
}

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

#[event]
pub struct RaiseFloorFromExcessLiquidityEvent {
    pub market: Pubkey,
    pub new_floor: DecimalSerialized,
}

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

#[event]
pub struct RepayEvent {
    pub repayer: Pubkey,
    pub market: Pubkey,
    pub amount: u64,
    pub new_debt: u64,
}

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

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

#[event]
pub struct WithdrawEvent {
    pub owner: Pubkey,
    pub market_meta: Pubkey,
    pub personal_position: Pubkey,
    pub amount: u64,
    pub new_balance: u64,
}