use anchor_lang::prelude::*;
use anchor_lang::solana_program::system_program;
use anchor_lang::solana_program::sysvar;
use anchor_spl::token::{Mint, TokenAccount};
use crate::errors::*;
use crate::state::*;

use crate::util::*;


/// This instruction creates the global config account and sets the
/// DFlow admin.
/// The DFlow admin controls access to the protocol by granting roles
/// to accounts that allow them to perform privileged actions such
/// as auction management. This instruction must be the first instruction
/// called after program deployment and can only be called once.
#[derive(Accounts)]
#[instruction(
    global_config_account_bump: u8,
)]
pub struct InitGlobalConfigInstruction<'info> {
    /// This account stores the DFlow admin's public key.
    /// This account is being initialized with 40 bytes, paid for by
    /// dflow_admin. This account is a PDA generated by the following
    /// seeds: the string literal `global_config`
    #[account(
        init,
        payer = dflow_admin,
        space = 40,
        seeds = [
            b"global_config".as_ref(),
        ],
        bump
    )]
    pub global_config_account: Account<'info, GlobalConfigAccount>,

    /// The public key of the DFlow admin. This account
    /// is a signer for the instruction. This account is expected to
    /// be mutable
    #[account(
        signer,
        mut,
    )]
    pub dflow_admin: AccountInfo<'info>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
    pub rent: Sysvar<'info, Rent>,
}

/// This instruction updates the DFlow admin.
/// The current DFlow admin can use this instruction to assign a
/// new DFlow admin.
#[derive(Accounts)]
#[instruction(
    global_config_account_bump: u8,
)]
pub struct SetNewDflowAdmin<'info> {
    /// This account stores the DFlow admin's public key.
    /// This account is a PDA generated by the following seeds: the string
    /// literal `global_config`. This account is expected to be mutable
    #[account(
        seeds = [
            b"global_config".as_ref(),
        ],
        bump = global_config_account_bump,
        mut,
    )]
    pub global_config_account: Account<'info, GlobalConfigAccount>,

    /// The public key of the DFlow admin. This account
    /// is a signer for the instruction
    #[account(signer)]
    pub dflow_admin: AccountInfo<'info>,

    /// The new DFlow admin's public key.
    pub new_dflow_admin: AccountInfo<'info>,

}

/// This instruction creates the principal's whitelist entry account
/// and grants the specified role to the principal.
#[derive(Accounts)]
#[instruction(
    global_config_account_bump: u8,
    whitelist_entry_bump: u8,
)]
pub struct GrantRoleUninitializedEntry<'info> {
    /// This account stores the DFlow admin's public key.
    /// This account is a PDA generated by the following seeds: the string
    /// literal `global_config`
    #[account(
        seeds = [
            b"global_config".as_ref(),
        ],
        bump = global_config_account_bump,
    )]
    pub global_config_account: Account<'info, GlobalConfigAccount>,

    /// The account to which the whitelist permissions apply.
    pub principal: AccountInfo<'info>,

    /// The public key of the DFlow admin. This account
    /// is a signer for the instruction. This account is expected to
    /// be mutable
    #[account(
        signer,
        mut,
    )]
    pub dflow_admin: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the principal. This account is being initialized with 42 bytes,
    /// paid for by dflow_admin. This account is a PDA generated by the
    /// following seeds: the string literal `whitelist_entry`, the public
    /// key of the principal account
    #[account(
        init,
        payer = dflow_admin,
        space = 42,
        seeds = [
            b"whitelist_entry".as_ref(),
            principal.key.as_ref(),
        ],
        bump
    )]
    pub whitelist_entry: Account<'info, WhitelistEntry>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
    pub rent: Sysvar<'info, Rent>,
}

/// This instruction grants the specified role to the principal.
#[derive(Accounts)]
#[instruction(
    global_config_account_bump: u8,
    whitelist_entry_bump: u8,
)]
pub struct GrantRole<'info> {
    /// This account stores the DFlow admin's public key.
    /// This account is a PDA generated by the following seeds: the string
    /// literal `global_config`
    #[account(
        seeds = [
            b"global_config".as_ref(),
        ],
        bump = global_config_account_bump,
    )]
    pub global_config_account: Account<'info, GlobalConfigAccount>,

    /// The account to which the whitelist permissions apply.
    pub principal: AccountInfo<'info>,

    /// The public key of the DFlow admin. This account
    /// is a signer for the instruction. This account is expected to
    /// be mutable
    #[account(
        signer,
        mut,
    )]
    pub dflow_admin: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the principal. This account is expected to be mutable. This
    /// account is a PDA generated by the following seeds: the string
    /// literal `whitelist_entry`, the public key of the principal account
    #[account(
        mut,
        seeds = [
            b"whitelist_entry".as_ref(),
            principal.key.as_ref(),
        ],
        bump = whitelist_entry_bump,
    )]
    pub whitelist_entry: Account<'info, WhitelistEntry>,

}

/// This instruction revokes the specified role from the principal
/// and closes the principal's whitelist account if it no longer
/// grants any permissions.
#[derive(Accounts)]
#[instruction(
    global_config_account_bump: u8,
    whitelist_entry_bump: u8,
)]
pub struct RevokeRole<'info> {
    /// This account stores the DFlow admin's public key.
    /// This account is a PDA generated by the following seeds: the string
    /// literal `global_config`
    #[account(
        seeds = [
            b"global_config".as_ref(),
        ],
        bump = global_config_account_bump,
    )]
    pub global_config_account: Account<'info, GlobalConfigAccount>,

    /// This account stores the permissions that apply
    /// to the principal. This account is expected to be mutable. This
    /// account is a PDA generated by the following seeds: the string
    /// literal `whitelist_entry`, the public key of the principal account
    #[account(
        mut,
        seeds = [
            b"whitelist_entry".as_ref(),
            principal.key.as_ref(),
        ],
        bump = whitelist_entry_bump,
    )]
    pub whitelist_entry: Account<'info, WhitelistEntry>,

    /// The account to which the whitelist permissions apply.
    pub principal: AccountInfo<'info>,

    /// The public key of the DFlow admin. This account
    /// is a signer for the instruction. This account is expected to
    /// be mutable
    #[account(
        signer,
        mut,
    )]
    pub dflow_admin: AccountInfo<'info>,

}

/// This instruction creates a recovery vault.
/// Recovery vaults are required for all mints used in the protocol.
/// If a transfer recipient does not have a token account set up,
/// the transferor can direct the protocol to transfer the tokens
/// to the recovery vault. The intended recipient can then recover
/// the tokens by submitting a recovery claim.
#[derive(Accounts)]
#[instruction(
    recovery_state_account_bump: u8,
    recovery_vault_account_bump: u8,
    auction_owner_whitelist_entry_bump: u8,
)]
pub struct InitRecoveryVaultInstruction<'info> {
    /// The recovery state account holds state specific
    /// to the recovery vault. This account is being initialized with
    /// 40 bytes, paid for by auction_owner. This account is a PDA generated
    /// by the following seeds: the public key of the recovery_vault_mint
    /// account, the string literal `recovery_state`
    #[account(
        init,
        payer = auction_owner,
        space = 40,
        seeds = [
            recovery_vault_mint.key().as_ref(),
            b"recovery_state".as_ref(),
        ],
        bump
    )]
    pub recovery_state_account: Account<'info, RecoveryStateAccount>,

    /// The recovery vault account is an SPL token account
    /// that holds assets that could not be transferred to the intended
    /// recipient because the intended recipient did not have a token
    /// account at transfer time. Assets deposited into this account
    /// are held until the intended recipient makes a claim to retrieve
    /// the assets. This account is being initialized and is paid for
    /// by auction_owner. This is a token account which is being initialized,
    /// and is associated with the recovery_vault_mint mint. The authority
    /// for this token account is recovery_state_account. This account
    /// is a PDA generated by the following seeds: the public key of
    /// the recovery_vault_mint account, the string literal `recovery_vault`
    #[account(
        init,
        payer = auction_owner,
        token::mint = recovery_vault_mint,
        token::authority = recovery_state_account,
        seeds = [
            recovery_vault_mint.key().as_ref(),
            b"recovery_vault".as_ref(),
        ],
        bump
    )]
    pub recovery_vault_account: Account<'info, TokenAccount>,

    /// The SPL mint for the recovery vault account.
    pub recovery_vault_mint: Account<'info, Mint>,

    /// The auction owner is an authority with permission
    /// granted by the DFlow admin to create recovery vaults, create
    /// new auctions, and halt, resume, or deprecate existing auctions.
    /// This account is a signer for the instruction. This account is
    /// expected to be mutable
    #[account(
        signer,
        mut,
    )]
    pub auction_owner: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the auction_owner. This account is a PDA generated by the
    /// following seeds: the string literal `whitelist_entry`, the public
    /// key of the auction_owner account
    #[account(
        seeds = [
            b"whitelist_entry".as_ref(),
            auction_owner.key.as_ref(),
        ],
        bump = auction_owner_whitelist_entry_bump,
    )]
    pub auction_owner_whitelist_entry: Account<'info, WhitelistEntry>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
    pub rent: Sysvar<'info, Rent>,
    #[account(address = anchor_spl::token::ID)]
    pub token_program: AccountInfo<'info>,
}

/// This instruction initializes the auction mapper account.
/// The auction mapper account contains a list of auctions that are
/// not deprecated. Auctions will either be in a trading or halted
/// state. This function can only be called by the DFlow admin.
#[derive(Accounts)]
#[instruction(
    global_config_account_bump: u8,
    auction_mapper_bump: u8,
)]
pub struct InitAuctionMapperInstruction<'info> {
    /// This account stores the DFlow admin's public key.
    /// This account is a PDA generated by the following seeds: the string
    /// literal `global_config`
    #[account(
        seeds = [
            b"global_config".as_ref(),
        ],
        bump = global_config_account_bump,
    )]
    pub global_config_account: Account<'info, GlobalConfigAccount>,

    /// This account contains a list of non-deprecated
    /// auction IDs. This account is being initialized with 8240 bytes,
    /// paid for by dflow_admin. This account is a PDA generated by the
    /// following seeds: the string literal `mapper`
    #[account(
        init,
        payer = dflow_admin,
        space = 8240,
        seeds = [
            b"mapper".as_ref(),
        ],
        bump
    )]
    pub auction_mapper: Account<'info, AuctionMapper>,

    /// The public key of the DFlow admin. This account
    /// is a signer for the instruction. This account is expected to
    /// be mutable
    #[account(
        signer,
        mut,
    )]
    pub dflow_admin: AccountInfo<'info>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
    pub rent: Sysvar<'info, Rent>,
}

/// This instruction initializes an auction for order flow, and describes
/// the specifications of the order flow account.
/// This instruction is only callable by an auction owner. Once the
/// auction is initialized, it remains in a Halted state until the
/// auction owner sets the auction state to Trading.
#[derive(Accounts)]
#[instruction(
    auction_state_account_bump: u8,
    bid_vault_account_bump: u8,
    vote_vault_account_bump: u8,
    auction_mapper_bump: u8,
    auction_owner_whitelist_entry_bump: u8,
    bid_recovery_state_account_bump: u8,
    bid_recovery_vault_account_bump: u8,
    vote_recovery_state_account_bump: u8,
    vote_recovery_vault_account_bump: u8,
    /// An unsigned 64 bit integer. The auction ID used as a seed to
    /// generate the program derived address
    auction_id: u64,
)]
pub struct InitAuctionState<'info> {
    /// The auction state account holds state specific
    /// to the auction. This account is being initialized with 1280 bytes,
    /// paid for by auction_owner. This account is a PDA generated by
    /// the following seeds: the string literal `auction_state`, an unsigned
    /// 64 bit integer
    #[account(
        init,
        payer = auction_owner,
        space = 1280,
        seeds = [
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        bump
    )]
    pub auction_state_account: Account<'info, AuctionStateAccount>,

    /// The bid vault account is an SPL token account
    /// that holds bids made by market makers in the auctions for order
    /// flow. Bids held in this account are held only temporarily, and
    /// are distributed out upon fills and fill arbitration. This account
    /// is being initialized and is paid for by auction_owner. This is
    /// a token account which is being initialized, and is associated
    /// with the bid_mint_account mint. The authority for this token
    /// account is auction_state_account. This account is a PDA generated
    /// by the following seeds: the string literal `bid_vault`, an unsigned
    /// 64 bit integer
    #[account(
        init,
        payer = auction_owner,
        token::mint = bid_mint_account,
        token::authority = auction_state_account,
        seeds = [
            b"bid_vault".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        bump
    )]
    pub bid_vault_account: Account<'info, TokenAccount>,

    /// The vote vault account is an SPL token account
    /// that holds votes made by arbiters on each fill. Vote stakes held
    /// in this account are returned to the arbiters upon honest voting
    /// of the fill. This account is being initialized and is paid for
    /// by auction_owner. This is a token account which is being initialized,
    /// and is associated with the vote_mint_account mint. The authority
    /// for this token account is auction_state_account. This account
    /// is a PDA generated by the following seeds: the string literal
    /// `vote_vault`, an unsigned 64 bit integer
    #[account(
        init,
        payer = auction_owner,
        token::mint = vote_mint_account,
        token::authority = auction_state_account,
        seeds = [
            b"vote_vault".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        bump
    )]
    pub vote_vault_account: Account<'info, TokenAccount>,

    /// This account contains a list of non-deprecated
    /// auction IDs. This account is expected to be mutable. This account
    /// is a PDA generated by the following seeds: the string literal
    /// `mapper`
    #[account(
        mut,
        seeds = [
            b"mapper".as_ref(),
        ],
        bump = auction_mapper_bump,
    )]
    pub auction_mapper: Box<Account<'info, AuctionMapper>>,

    /// The auction owner is an authority with permission
    /// granted by the DFlow admin to create recovery vaults, create
    /// new auctions, and halt, resume, or deprecate existing auctions.
    /// This account is a signer for the instruction. This account is
    /// expected to be mutable
    #[account(
        signer,
        mut,
    )]
    pub auction_owner: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the auction_owner. This account is a PDA generated by the
    /// following seeds: the string literal `whitelist_entry`, the public
    /// key of the auction_owner account
    #[account(
        seeds = [
            b"whitelist_entry".as_ref(),
            auction_owner.key.as_ref(),
        ],
        bump = auction_owner_whitelist_entry_bump,
    )]
    pub auction_owner_whitelist_entry: Account<'info, WhitelistEntry>,

    /// The SPL mint associated with the token that market
    /// makers use to bid in the order flow auctions.
    pub bid_mint_account: Box<Account<'info, Mint>>,

    /// The SPL mint associated with the token that arbiters
    /// use to vote on the fairness of the fills.
    pub vote_mint_account: Box<Account<'info, Mint>>,

    /// The recovery state account for the bid mint. This
    /// account is a PDA generated by the following seeds: the public
    /// key of the bid_mint_account account, the string literal `recovery_state`
    #[account(
        seeds = [
            bid_mint_account.key().as_ref(),
            b"recovery_state".as_ref(),
        ],
        bump = bid_recovery_state_account_bump,
    )]
    pub bid_recovery_state_account: Box<Account<'info, RecoveryStateAccount>>,

    /// The recovery vault account for the bid mint. This
    /// account is a PDA generated by the following seeds: the public
    /// key of the bid_mint_account account, the string literal `recovery_vault`
    #[account(
        seeds = [
            bid_mint_account.key().as_ref(),
            b"recovery_vault".as_ref(),
        ],
        bump = bid_recovery_vault_account_bump,
    )]
    pub bid_recovery_vault_account: Box<Account<'info, TokenAccount>>,

    /// The recovery state account for the vote mint.
    /// This account is a PDA generated by the following seeds: the public
    /// key of the vote_mint_account account, the string literal `recovery_state`
    #[account(
        seeds = [
            vote_mint_account.key().as_ref(),
            b"recovery_state".as_ref(),
        ],
        bump = vote_recovery_state_account_bump,
    )]
    pub vote_recovery_state_account: Box<Account<'info, RecoveryStateAccount>>,

    /// The recovery vault account for the vote mint.
    /// This account is a PDA generated by the following seeds: the public
    /// key of the vote_mint_account account, the string literal `recovery_vault`
    #[account(
        seeds = [
            vote_mint_account.key().as_ref(),
            b"recovery_vault".as_ref(),
        ],
        bump = vote_recovery_vault_account_bump,
    )]
    pub vote_recovery_vault_account: Box<Account<'info, TokenAccount>>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
    pub rent: Sysvar<'info, Rent>,
    #[account(address = anchor_spl::token::ID)]
    pub token_program: AccountInfo<'info>,
}

/// This instruction adds a currency pair to an existing auction.
/// Only a certain number of token pairs are allowed to exist in
/// an auction and an error is thrown if this instruction is called
/// when the token pairs count is saturated
#[derive(Accounts)]
#[instruction(
    auction_state_account_bump: u8,
    base_recovery_state_account_bump: u8,
    base_recovery_vault_account_bump: u8,
    quote_recovery_state_account_bump: u8,
    quote_recovery_vault_account_bump: u8,
    auction_owner_whitelist_entry_bump: u8,
    /// An unsigned 64 bit integer. The auction ID used as a seed to
    /// generate the program derived address
    auction_id: u64,
)]
pub struct AddCurrencyPair<'info> {
    /// The auction state account holds state specific
    /// to the auction. This account is expected to be mutable. This
    /// account is a PDA generated by the following seeds: the string
    /// literal `auction_state`, an unsigned 64 bit integer
    #[account(
        mut,
        seeds = [
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        bump = auction_state_account_bump,
    )]
    pub auction_state_account: Box<Account<'info, AuctionStateAccount>>,

    /// The SPL mint associated with the base token in
    /// a currency pair.
    pub base_currency: Account<'info, Mint>,

    /// The SPL mint associated with the quote token in
    /// a currency pair.
    pub quote_currency: Account<'info, Mint>,

    /// The Pyth price oracle associated with the base
    /// token in a currency pair.
    pub base_oracle: AccountInfo<'info>,

    /// The Pyth price oracle associated with the quote
    /// token in a currency pair.
    pub quote_oracle: AccountInfo<'info>,

    /// The recovery state account for the base mint.
    /// This account is a PDA generated by the following seeds: the public
    /// key of the base_currency account, the string literal `recovery_state`
    #[account(
        seeds = [
            base_currency.key().as_ref(),
            b"recovery_state".as_ref(),
        ],
        bump = base_recovery_state_account_bump,
    )]
    pub base_recovery_state_account: Box<Account<'info, RecoveryStateAccount>>,

    /// The recovery vault account for the base mint.
    /// This account is a PDA generated by the following seeds: the public
    /// key of the base_currency account, the string literal `recovery_vault`
    #[account(
        seeds = [
            base_currency.key().as_ref(),
            b"recovery_vault".as_ref(),
        ],
        bump = base_recovery_vault_account_bump,
    )]
    pub base_recovery_vault_account: Account<'info, TokenAccount>,

    /// The recovery state account for the quote mint.
    /// This account is a PDA generated by the following seeds: the public
    /// key of the quote_currency account, the string literal `recovery_state`
    #[account(
        seeds = [
            quote_currency.key().as_ref(),
            b"recovery_state".as_ref(),
        ],
        bump = quote_recovery_state_account_bump,
    )]
    pub quote_recovery_state_account: Box<Account<'info, RecoveryStateAccount>>,

    /// The recovery vault account for the quote mint.
    /// This account is a PDA generated by the following seeds: the public
    /// key of the quote_currency account, the string literal `recovery_vault`
    #[account(
        seeds = [
            quote_currency.key().as_ref(),
            b"recovery_vault".as_ref(),
        ],
        bump = quote_recovery_vault_account_bump,
    )]
    pub quote_recovery_vault_account: Account<'info, TokenAccount>,

    /// The auction owner is an authority with permission
    /// granted by the DFlow admin to create recovery vaults, create
    /// new auctions, and halt, resume, or deprecate existing auctions.
    /// This account is a signer for the instruction
    #[account(signer)]
    pub auction_owner: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the auction_owner. This account is a PDA generated by the
    /// following seeds: the string literal `whitelist_entry`, the public
    /// key of the auction_owner account
    #[account(
        seeds = [
            b"whitelist_entry".as_ref(),
            auction_owner.key.as_ref(),
        ],
        bump = auction_owner_whitelist_entry_bump,
    )]
    pub auction_owner_whitelist_entry: Account<'info, WhitelistEntry>,

    #[account(address = anchor_spl::token::ID)]
    pub token_program: AccountInfo<'info>,
}

/// This instruction changes the status of an auction
/// This instruction can be used to change the status of an auction
/// between Halted, Trading, or Expired. Once Expired, the auction
/// will not be revivable.
#[derive(Accounts)]
#[instruction(
    auction_state_account_bump: u8,
    auction_mapper_bump: u8,
    auction_owner_whitelist_entry_bump: u8,
    /// An unsigned 64 bit integer. The auction ID used as a seed to
    /// generate the program derived address
    auction_id: u64,
)]
pub struct ChangeAuctionStatus<'info> {
    /// The auction state account holds state specific
    /// to the auction. This account is expected to be mutable. This
    /// account is being closed, and the destination of the lamports
    /// will be the auction_owner account. This account is a PDA generated
    /// by the following seeds: the string literal `auction_state`, an
    /// unsigned 64 bit integer
    #[account(
        mut,
        seeds = [
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        bump = auction_state_account_bump,
    )]
    pub auction_state_account: Account<'info, AuctionStateAccount>,

    /// This account contains a list of non-deprecated
    /// auction IDs. This account is expected to be mutable. This account
    /// is a PDA generated by the following seeds: the string literal
    /// `mapper`
    #[account(
        mut,
        seeds = [
            b"mapper".as_ref(),
        ],
        bump = auction_mapper_bump,
    )]
    pub auction_mapper: Account<'info, AuctionMapper>,

    /// The auction owner is an authority with permission
    /// granted by the DFlow admin to create recovery vaults, create
    /// new auctions, and halt, resume, or deprecate existing auctions.
    /// This account is a signer for the instruction. This account is
    /// expected to be mutable
    #[account(
        signer,
        mut,
    )]
    pub auction_owner: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the auction_owner. This account is a PDA generated by the
    /// following seeds: the string literal `whitelist_entry`, the public
    /// key of the auction_owner account
    #[account(
        seeds = [
            b"whitelist_entry".as_ref(),
            auction_owner.key.as_ref(),
        ],
        bump = auction_owner_whitelist_entry_bump,
    )]
    pub auction_owner_whitelist_entry: Account<'info, WhitelistEntry>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
}

/// This instruction initializes the market maker account
/// The market maker account tracks state specific to the market
/// maker's market making activities. This instruction must be called
/// prior to a market maker being active on DFlow.
#[derive(Accounts)]
#[instruction(
    market_maker_whitelist_entry_bump: u8,
)]
pub struct InitMarketMakerAccountInstruction<'info> {
    /// The account storing state specific to the market
    /// maker. This account must be owned by the DFlow program, and this
    /// account must be initialized by calling the initialize market
    /// maker instruction. This account is expected to be zeroed out
    /// upon the start of instruction processing
    #[account(zero)]
    pub market_maker_data_account: Account<'info, MarketMakerDataAccount>,

    /// The public key of the market maker. This account
    /// is a signer for the instruction
    #[account(signer)]
    pub market_maker_account_owner: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the market_maker_account_owner. This account is a PDA generated
    /// by the following seeds: the string literal `whitelist_entry`,
    /// the public key of the market_maker_account_owner account
    #[account(
        seeds = [
            b"whitelist_entry".as_ref(),
            market_maker_account_owner.key.as_ref(),
        ],
        bump = market_maker_whitelist_entry_bump,
    )]
    pub market_maker_whitelist_entry: Account<'info, WhitelistEntry>,

}

/// This instruction updates the market maker's 256-bit X25519 public
/// key.
/// Retail traders use the market maker's 256-bit X25519 public key
/// to encrypt their order details when routing orders to the market
/// maker. This instruction updates the market maker's X25519 public
/// key.
#[derive(Accounts)]
#[instruction(
    market_maker_whitelist_entry_bump: u8,
)]
pub struct UpdateEncryptionKeyInstruction<'info> {
    /// The account storing state specific to the market
    /// maker. This account must be owned by the DFlow program, and this
    /// account must be initialized by calling the initialize market
    /// maker instruction. This account is expected to be mutable
    #[account(mut)]
    pub market_maker_data_account: Account<'info, MarketMakerDataAccount>,

    /// The public key of the market maker. This account
    /// is a signer for the instruction
    #[account(signer)]
    pub market_maker_account_owner: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the market_maker_account_owner. This account is a PDA generated
    /// by the following seeds: the string literal `whitelist_entry`,
    /// the public key of the market_maker_account_owner account
    #[account(
        seeds = [
            b"whitelist_entry".as_ref(),
            market_maker_account_owner.key.as_ref(),
        ],
        bump = market_maker_whitelist_entry_bump,
    )]
    pub market_maker_whitelist_entry: Account<'info, WhitelistEntry>,

}

/// This instruction initializes an auction epoch state account
/// AuctionEpochState carries state specific to a certain auction
/// that needs to be remembered after the epoch ends. The AuctionEpochState
/// accounts associated with auction epochs N and N + 1 need to be
/// initialized when the auction for epoch N begins (i.e. in the
/// first SubmitAuctionBid that auction N will receive). Recall that
/// if the AuctionState has an epoch field that has value X, then
/// auction X is currently active, and auction X - 1 is currently
/// receiving order flow.
#[derive(Accounts)]
#[instruction(
    auction_epoch_state_bump: u8,
    auction_state_account_bump: u8,
    /// An unsigned 64 bit integer. The auction ID used as a seed to
    /// generate the program derived address
    auction_id: u64,
    /// An unsigned 64 bit integer. The integer epoch used to generate
    /// the PDA of the auction epoch account
    auction_epoch: u64,
)]
pub struct InitAuctionEpochStateInstruction<'info> {
    /// The auction epoch state account holds state specific
    /// to an epoch of the auction, if that state must be remembered
    /// beyond the duration of that auction epoch. This account is being
    /// initialized with 101 bytes, paid for by owner. This account is
    /// a PDA generated by the following seeds: the string literal `epoch`,
    /// an unsigned 64 bit integer, an unsigned 64 bit integer
    #[account(
        init,
        payer = owner,
        space = 101,
        seeds = [
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
        ],
        bump
    )]
    pub auction_epoch_state: Account<'info, AuctionEpochState>,

    /// The auction state account holds state specific
    /// to the auction. This account is expected to be mutable. This
    /// account is a PDA generated by the following seeds: the string
    /// literal `auction_state`, an unsigned 64 bit integer
    #[account(
        mut,
        seeds = [
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        bump = auction_state_account_bump,
    )]
    pub auction_state_account: Account<'info, AuctionStateAccount>,

    /// The creator and owner of AuctionEpochState account.
    /// This account is a signer for the instruction. This account is
    /// expected to be mutable
    #[account(
        signer,
        mut,
    )]
    pub owner: AccountInfo<'info>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
    pub rent: Sysvar<'info, Rent>,
}

/// This instruction initializes the retail traders account.
/// The retail data account tracks state specific to the retail trader's
/// trading activities on DFlow.
#[derive(Accounts)]
#[instruction(
)]
pub struct InitRetailDataAccountInstruction<'info> {
    /// The retail data account holds state specific to
    /// the retail trader. This account is expected to be zeroed out
    /// upon the start of instruction processing
    #[account(zero)]
    pub retail_data_account: Account<'info, RetailDataAccount>,

    /// The public key of the retail trader. This account
    /// is a signer for the instruction
    #[account(signer)]
    pub retail_account_owner: AccountInfo<'info>,

}

/// This instruction closes the retail trader's data account.
/// When retail traders wish to close their account, and regain the
/// lamports used to allocate the space for their data account, they
/// can call this instruction. Retail traders may not close their
/// account if they have open orders, and must wait for the orders
/// to be filled, or cancel them.
#[derive(Accounts)]
#[instruction(
)]
pub struct CloseRetailDataAccount<'info> {
    /// The retail data account holds state specific to
    /// the retail trader. This account is being closed, and the destination
    /// of the lamports will be the retail_account_owner account. This
    /// account is expected to be mutable
    #[account(
        mut,
    )]
    pub retail_data_account: Account<'info, RetailDataAccount>,

    /// The public key of the retail trader. This account
    /// is a signer for the instruction. This account is expected to
    /// be mutable
    #[account(
        signer,
        mut,
    )]
    pub retail_account_owner: AccountInfo<'info>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
}

/// This instruction is called by the market maker prior to bidding
/// in an auction.
/// Before a market maker bids in an auction, they must use this
/// instruction to initialize an account to track their current bid
/// in the auction.
#[derive(Accounts)]
#[instruction(
    auction_state_account_bump: u8,
    auction_epoch_state_bump: u8,
    bid_record_account_bump: u8,
    market_maker_whitelist_entry_bump: u8,
    /// An unsigned 64 bit integer. The auction ID used as a seed to
    /// generate the program derived address
    auction_id: u64,
    /// An unsigned 64 bit integer. The integer epoch used to generate
    /// the PDA of the auction epoch account
    auction_epoch: u64,
)]
pub struct InitBidRecordAccount<'info> {
    /// The auction state account holds state specific
    /// to the auction. This account is a PDA generated by the following
    /// seeds: the string literal `auction_state`, an unsigned 64 bit
    /// integer
    #[account(
        seeds = [
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        bump = auction_state_account_bump,
    )]
    pub auction_state_account: Account<'info, AuctionStateAccount>,

    /// The auction epoch state account holds state specific
    /// to an epoch of the auction, if that state must be remembered
    /// beyond the duration of that auction epoch. This account is a
    /// PDA generated by the following seeds: the string literal `epoch`,
    /// an unsigned 64 bit integer, an unsigned 64 bit integer
    #[account(
        seeds = [
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
        ],
        bump = auction_epoch_state_bump,
    )]
    pub auction_epoch_state: Account<'info, AuctionEpochState>,

    /// The account which tracks the market maker's current
    /// bid in the auction. This account is being initialized with 16
    /// bytes, paid for by market_maker_account_owner. This account is
    /// a PDA generated by the following seeds: the string literal `bid_record`,
    /// an unsigned 64 bit integer, an unsigned 64 bit integer, the public
    /// key of the market_maker_data_account account
    #[account(
        init,
        payer = market_maker_account_owner,
        space = 16,
        seeds = [
            b"bid_record".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
            market_maker_data_account.key().as_ref(),
        ],
        bump
    )]
    pub bid_record_account: Account<'info, BidRecordAccount>,

    /// The account storing state specific to the market
    /// maker. This account must be owned by the DFlow program, and this
    /// account must be initialized by calling the initialize market
    /// maker instruction.
    pub market_maker_data_account: Account<'info, MarketMakerDataAccount>,

    /// The public key of the market maker. This account
    /// is a signer for the instruction. This account is expected to
    /// be mutable
    #[account(
        signer,
        mut,
    )]
    pub market_maker_account_owner: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the market_maker_account_owner. This account is a PDA generated
    /// by the following seeds: the string literal `whitelist_entry`,
    /// the public key of the market_maker_account_owner account
    #[account(
        seeds = [
            b"whitelist_entry".as_ref(),
            market_maker_account_owner.key.as_ref(),
        ],
        bump = market_maker_whitelist_entry_bump,
    )]
    pub market_maker_whitelist_entry: Account<'info, WhitelistEntry>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
    pub rent: Sysvar<'info, Rent>,
}

/// This instruction is called by the market maker to bid in an auction.
/// When a market maker wishes to bid in an auction, they can use
/// this instruction to specify the parameters of their bid. Note
/// that the first bidder in auction epoch N must ensure that auction
/// epoch state accounts are initialized for auction epochs N and
/// N + 1.
#[derive(Accounts)]
#[instruction(
    auction_state_account_bump: u8,
    auction_epoch_state_bump: u8,
    next_auction_epoch_state_bump: u8,
    bid_vault_account_bump: u8,
    bid_record_account_bump: u8,
    market_maker_whitelist_entry_bump: u8,
    /// An unsigned 64 bit integer. The auction ID used as a seed to
    /// generate the program derived address
    auction_id: u64,
    /// An unsigned 64 bit integer. The integer epoch used to generate
    /// the PDA of the auction epoch account
    auction_epoch: u64,
    /// An unsigned 64 bit integer. The next auction epoch number. If
    /// bidding in auction epoch N, this must be N + 1.
    next_auction_epoch: u64,
)]
pub struct SubmitAuctionBidInstruction<'info> {
    /// The auction state account holds state specific
    /// to the auction. This account is expected to be mutable. This
    /// account is a PDA generated by the following seeds: the string
    /// literal `auction_state`, an unsigned 64 bit integer
    #[account(
        mut,
        seeds = [
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        bump = auction_state_account_bump,
    )]
    pub auction_state_account: Box<Account<'info, AuctionStateAccount>>,

    /// The auction epoch state account holds state specific
    /// to an epoch of the auction, if that state must be remembered
    /// beyond the duration of that auction epoch. This account is expected
    /// to be mutable. This account is a PDA generated by the following
    /// seeds: the string literal `epoch`, an unsigned 64 bit integer,
    /// an unsigned 64 bit integer
    #[account(
        mut,
        seeds = [
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
        ],
        bump = auction_epoch_state_bump,
    )]
    pub auction_epoch_state: Account<'info, AuctionEpochState>,

    /// The auction epoch state account for the next epoch.
    /// This account is a PDA generated by the following seeds: the string
    /// literal `epoch`, an unsigned 64 bit integer, an unsigned 64 bit
    /// integer
    #[account(
        seeds = [
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &next_auction_epoch.to_le_bytes(),
        ],
        bump = next_auction_epoch_state_bump,
    )]
    pub next_auction_epoch_state: Box<Account<'info, AuctionEpochState>>,

    /// The bid vault account is an SPL token account
    /// that holds bids made by market makers in the auctions for order
    /// flow. Bids held in this account are held only temporarily, and
    /// are distributed out upon fills and fill arbitration. This account
    /// is expected to be mutable. This account is a PDA generated by
    /// the following seeds: the string literal `bid_vault`, an unsigned
    /// 64 bit integer
    #[account(
        mut,
        seeds = [
            b"bid_vault".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        bump = bid_vault_account_bump,
    )]
    pub bid_vault_account: Account<'info, TokenAccount>,

    /// The account storing state specific to the market
    /// maker. This account must be owned by the DFlow program, and this
    /// account must be initialized by calling the initialize market
    /// maker instruction.
    pub market_maker_data_account: Box<Account<'info, MarketMakerDataAccount>>,

    /// The SPL token account associated with the market
    /// maker used to bid in the auctions. This account is expected to
    /// be mutable
    #[account(mut)]
    pub market_maker_auction_token_account: Account<'info, TokenAccount>,

    /// The account which tracks the market maker's current
    /// bid in the auction. This account is expected to be mutable. This
    /// account is a PDA generated by the following seeds: the string
    /// literal `bid_record`, an unsigned 64 bit integer, an unsigned
    /// 64 bit integer, the public key of the market_maker_data_account
    /// account
    #[account(
        mut,
        seeds = [
            b"bid_record".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
            market_maker_data_account.key().as_ref(),
        ],
        bump = bid_record_account_bump,
    )]
    pub bid_record_account: Account<'info, BidRecordAccount>,

    /// The public key of the market maker. This account
    /// is a signer for the instruction
    #[account(signer)]
    pub market_maker_account_owner: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the market_maker_account_owner. This account is a PDA generated
    /// by the following seeds: the string literal `whitelist_entry`,
    /// the public key of the market_maker_account_owner account
    #[account(
        seeds = [
            b"whitelist_entry".as_ref(),
            market_maker_account_owner.key.as_ref(),
        ],
        bump = market_maker_whitelist_entry_bump,
    )]
    pub market_maker_whitelist_entry: Account<'info, WhitelistEntry>,

    #[account(address = anchor_spl::token::ID)]
    pub token_program: AccountInfo<'info>,
}

/// This instruction is called by the market maker to withdraw its
/// losing auction bids and close its bid record account for the
/// given auction.
/// A market maker who is outbid in an auction can use this instruction
/// to withdraw its bids in the auction and close its bid record
/// account for the auction. A market maker who has won an auction
/// can use this instruction to close its bid record account for
/// the auction.
#[derive(Accounts)]
#[instruction(
    auction_state_account_bump: u8,
    auction_epoch_state_bump: u8,
    bid_vault_account_bump: u8,
    bid_record_account_bump: u8,
    market_maker_whitelist_entry_bump: u8,
    /// An unsigned 64 bit integer. The auction ID used as a seed to
    /// generate the program derived address
    auction_id: u64,
    /// An unsigned 64 bit integer. The integer epoch used to generate
    /// the PDA of the auction epoch account
    auction_epoch: u64,
)]
pub struct ReclaimAuctionBidInstruction<'info> {
    /// The auction state account holds state specific
    /// to the auction. This account is a PDA generated by the following
    /// seeds: the string literal `auction_state`, an unsigned 64 bit
    /// integer
    #[account(
        seeds = [
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        bump = auction_state_account_bump,
    )]
    pub auction_state_account: Box<Account<'info, AuctionStateAccount>>,

    /// The auction epoch state account holds state specific
    /// to an epoch of the auction, if that state must be remembered
    /// beyond the duration of that auction epoch. This account is a
    /// PDA generated by the following seeds: the string literal `epoch`,
    /// an unsigned 64 bit integer, an unsigned 64 bit integer
    #[account(
        seeds = [
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
        ],
        bump = auction_epoch_state_bump,
    )]
    pub auction_epoch_state: Account<'info, AuctionEpochState>,

    /// The bid vault account is an SPL token account
    /// that holds bids made by market makers in the auctions for order
    /// flow. Bids held in this account are held only temporarily, and
    /// are distributed out upon fills and fill arbitration. This account
    /// is expected to be mutable. This account is a PDA generated by
    /// the following seeds: the string literal `bid_vault`, an unsigned
    /// 64 bit integer
    #[account(
        mut,
        seeds = [
            b"bid_vault".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        bump = bid_vault_account_bump,
    )]
    pub bid_vault_account: Account<'info, TokenAccount>,

    /// The account storing state specific to the market
    /// maker. This account must be owned by the DFlow program, and this
    /// account must be initialized by calling the initialize market
    /// maker instruction.
    pub market_maker_data_account: Box<Account<'info, MarketMakerDataAccount>>,

    /// The SPL token account associated with the market
    /// maker used to bid in the auctions. This account is expected to
    /// be mutable
    #[account(mut)]
    pub market_maker_auction_token_account: Account<'info, TokenAccount>,

    /// The account which tracks the market maker's current
    /// bid in the auction. This account is expected to be mutable. This
    /// account is a PDA generated by the following seeds: the string
    /// literal `bid_record`, an unsigned 64 bit integer, an unsigned
    /// 64 bit integer, the public key of the market_maker_data_account
    /// account
    #[account(
        mut,
        seeds = [
            b"bid_record".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
            market_maker_data_account.key().as_ref(),
        ],
        bump = bid_record_account_bump,
    )]
    pub bid_record_account: Account<'info, BidRecordAccount>,

    /// The public key of the market maker. This account
    /// is expected to be mutable. This account is a signer for the instruction
    #[account(
        mut,
        signer,
    )]
    pub market_maker_account_owner: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the market_maker_account_owner. This account is a PDA generated
    /// by the following seeds: the string literal `whitelist_entry`,
    /// the public key of the market_maker_account_owner account
    #[account(
        seeds = [
            b"whitelist_entry".as_ref(),
            market_maker_account_owner.key.as_ref(),
        ],
        bump = market_maker_whitelist_entry_bump,
    )]
    pub market_maker_whitelist_entry: Account<'info, WhitelistEntry>,

    #[account(address = anchor_spl::token::ID)]
    pub token_program: AccountInfo<'info>,
}

/// This instruction is called by retail traders when they submit
/// their order. A transaction containing this instruction must be
/// signed by a signatory server.
/// When submitting orders, retail traders must encrypt the details
/// of their order in order to hide information regarding which token
/// is being received.
#[derive(Accounts)]
#[instruction(
    vault_token_account_bump: u8,
    vault_meta_account_bump: u8,
    current_auction_epoch_state_bump: u8,
    previous_auction_epoch_state_bump: u8,
    auction_state_account_bump: u8,
    signatory_record_bump: u8,
    /// An unsigned 64 bit integer. The auction ID used as a seed to
    /// generate the program derived address
    auction_id: u64,
    /// An unsigned 64 bit integer. The integer epoch used to generate
    /// the PDA of the auction epoch account
    auction_epoch: u64,
    /// An unsigned 64 bit integer. The previous epoch. This must be
    /// equal to auction_epoch - 1.
    previous_auction_epoch: u64,
)]
pub struct NewOrderInstruction<'info> {
    /// The SPL token account owned by the escrow vault,
    /// which holds the sold tokens during a swap from the retail trader.
    /// This account is being initialized and is paid for by retail_account_owner.
    /// This is a token account which is being initialized, and is associated
    /// with the x_mint mint. The authority for this token account is
    /// vault_meta_account. This account is a PDA generated by the following
    /// seeds: the public key of the retail_account_owner account, the
    /// string literal `vault`, the unsigned integer field named nonce
    /// in the retail_data_account account
    #[account(
        init,
        payer = retail_account_owner,
        token::mint = x_mint,
        token::authority = vault_meta_account,
        seeds = [
            retail_account_owner.key.as_ref(),
            b"vault".as_ref(),
            &retail_data_account.nonce.to_le_bytes(),
        ],
        bump
    )]
    pub vault_token_account: Account<'info, TokenAccount>,

    /// The account which holds state specific to a given
    /// order initiated by the retail trader. This account is being initialized
    /// with 816 bytes, paid for by retail_account_owner. This account
    /// is a PDA generated by the following seeds: the public key of
    /// the retail_account_owner account, the string literal `vault_meta`,
    /// the unsigned integer field named nonce in the retail_data_account
    /// account
    #[account(
        init,
        payer = retail_account_owner,
        space = 816,
        seeds = [
            retail_account_owner.key.as_ref(),
            b"vault_meta".as_ref(),
            &retail_data_account.nonce.to_le_bytes(),
        ],
        bump
    )]
    pub vault_meta_account: Box<Account<'info, VaultMetaAccount>>,

    /// The auction epoch state account for the current
    /// epoch. This account is expected to be mutable. This account is
    /// a PDA generated by the following seeds: the string literal `epoch`,
    /// an unsigned 64 bit integer, an unsigned 64 bit integer
    #[account(
        mut,
        seeds = [
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
        ],
        bump = current_auction_epoch_state_bump,
    )]
    pub current_auction_epoch_state: Box<Account<'info, AuctionEpochState>>,

    /// The auction epoch state account for the previous
    /// epoch. This account is expected to be mutable. This account is
    /// a PDA generated by the following seeds: the string literal `epoch`,
    /// an unsigned 64 bit integer, an unsigned 64 bit integer
    #[account(
        mut,
        seeds = [
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &previous_auction_epoch.to_le_bytes(),
        ],
        bump = previous_auction_epoch_state_bump,
    )]
    pub previous_auction_epoch_state: Account<'info, AuctionEpochState>,

    /// The SPL token account associated with the retail
    /// trader which is used to deposit the sold token into escrow prior
    /// to the trade occurring. This account is expected to be mutable
    #[account(mut)]
    pub retail_x_token_account: Account<'info, TokenAccount>,

    /// The SPL token account associated with the order
    /// used to receive a payment from the network, with the same mint
    /// as the token accounts used by market makers to bid in the associated
    /// auction.
    pub rebate_receiver_token_account: Box<Account<'info, TokenAccount>>,

    /// The auction state account holds state specific
    /// to the auction. This account is expected to be mutable. This
    /// account is a PDA generated by the following seeds: the string
    /// literal `auction_state`, an unsigned 64 bit integer
    #[account(
        mut,
        seeds = [
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        bump = auction_state_account_bump,
    )]
    pub auction_state_account: Box<Account<'info, AuctionStateAccount>>,

    /// The retail data account holds state specific to
    /// the retail trader. This account is expected to be mutable
    #[account(mut)]
    pub retail_data_account: Box<Account<'info, RetailDataAccount>>,

    /// The account storing state specific to the market
    /// maker. This account must be owned by the DFlow program, and this
    /// account must be initialized by calling the initialize market
    /// maker instruction. This account is expected to be mutable
    #[account(mut)]
    pub market_maker_data_account: Box<Account<'info, MarketMakerDataAccount>>,

    /// The public key of the retail trader. This account
    /// is a signer for the instruction. This account is expected to
    /// be mutable
    #[account(
        signer,
        mut,
    )]
    pub retail_account_owner: AccountInfo<'info>,

    /// The SPL mint account associated with the token
    /// that is sold by the retail trader during the swap.
    pub x_mint: Account<'info, Mint>,

    /// The signatory record account holds information
    /// about a signatory server, and the existence of the signatory
    /// record account is a valid proof that the signatory server has
    /// staked the requisite value in the protocol allowing it to endorse
    /// flow as originating from a retail source. This account is a PDA
    /// generated by the following seeds: the public key of the signatory_server
    /// account
    #[account(
        seeds = [
            signatory_server.key.as_ref(),
        ],
        bump = signatory_record_bump,
    )]
    pub signatory_record: Account<'info, SignatoryRecord>,

    /// The public key of the signatory server that endorses
    /// new orders as originating from a retail source. This account
    /// is a signer for the instruction. This account is expected to
    /// be mutable
    #[account(
        signer,
        mut,
    )]
    pub signatory_server: AccountInfo<'info>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
    pub rent: Sysvar<'info, Rent>,
    #[account(address = anchor_spl::token::ID)]
    pub token_program: AccountInfo<'info>,
}

/// This instruction cancels an open order.
/// Cancelling an open order can only be done if it has not been
/// filled and if the order has been filled partially, the retail
/// trader can only cancel the part of the order which is still open.
#[derive(Accounts)]
#[instruction(
    vault_token_account_bump: u8,
    vault_meta_account_bump: u8,
    auction_epoch_state_bump: u8,
    /// An unsigned 64 bit integer. The nonce used as a seed to generate
    /// the PDA for the vault token account, taken from the retail trader's
    /// account when the order in question was initially created.
    nonce: u64,
)]
pub struct CancelOrderInstruction<'info> {
    /// The SPL token account owned by the escrow vault,
    /// which holds the sold tokens during a swap from the retail trader.
    /// This account is expected to be mutable. This account is being
    /// closed, and the destination of the lamports will be the retail_account_owner
    /// account. This account is a PDA generated by the following seeds:
    /// the public key of the retail_account_owner account, the string
    /// literal `vault`, an unsigned 64 bit integer
    #[account(
        mut,
        seeds = [
            retail_account_owner.key.as_ref(),
            b"vault".as_ref(),
            &nonce.to_le_bytes(),
        ],
        bump = vault_token_account_bump,
    )]
    pub vault_token_account: Account<'info, TokenAccount>,

    /// The account which holds state specific to a given
    /// order initiated by the retail trader. This account is expected
    /// to be mutable. This account is being closed, and the destination
    /// of the lamports will be the retail_account_owner account. This
    /// account is a PDA generated by the following seeds: the public
    /// key of the retail_account_owner account, the string literal `vault_meta`,
    /// an unsigned 64 bit integer
    #[account(
        mut,
        seeds = [
            retail_account_owner.key.as_ref(),
            b"vault_meta".as_ref(),
            &nonce.to_le_bytes(),
        ],
        bump = vault_meta_account_bump,
    )]
    pub vault_meta_account: Box<Account<'info, VaultMetaAccount>>,

    /// The auction epoch state account holds state specific
    /// to an epoch of the auction, if that state must be remembered
    /// beyond the duration of that auction epoch. This account is expected
    /// to be mutable. This account is a PDA generated by the following
    /// seeds: the string literal `epoch`, the unsigned integer field
    /// named auction_id in the vault_meta_account account, the unsigned
    /// integer field named auction_epoch in the vault_meta_account account
    #[account(
        mut,
        seeds = [
            b"epoch".as_ref(),
            &vault_meta_account.auction_id.to_le_bytes(),
            &vault_meta_account.auction_epoch.to_le_bytes(),
        ],
        bump = auction_epoch_state_bump,
    )]
    pub auction_epoch_state: Account<'info, AuctionEpochState>,

    /// The retail data account holds state specific to
    /// the retail trader. This account is expected to be mutable
    #[account(mut)]
    pub retail_data_account: Account<'info, RetailDataAccount>,

    /// The account storing state specific to the market
    /// maker. This account must be owned by the DFlow program, and this
    /// account must be initialized by calling the initialize market
    /// maker instruction. This account is expected to be mutable
    #[account(mut)]
    pub market_maker_data_account: Account<'info, MarketMakerDataAccount>,

    /// The SPL token account associated with the retail
    /// trader which is used to deposit the sold token into escrow prior
    /// to the trade occurring. This account is expected to be mutable
    #[account(mut)]
    pub retail_x_token_account: Account<'info, TokenAccount>,

    /// The public key of the retail trader. This account
    /// is a signer for the instruction. This account is expected to
    /// be mutable
    #[account(
        signer,
        mut,
    )]
    pub retail_account_owner: AccountInfo<'info>,

    /// The SPL mint account associated with the token
    /// that is sold by the retail trader during the swap.
    pub x_mint: Box<Account<'info, Mint>>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
    #[account(address = anchor_spl::token::ID)]
    pub token_program: AccountInfo<'info>,
}

/// This instruction is used to fill an open order
/// When a market maker fills an order that is assigned to them,
/// this instruction will partially settle the trade; the retail
/// trader will receive the tokens from the market maker, but the
/// market maker must wait until arbiters have voted on the fairness
/// of the fill in order to receive the retail trader's tokens.
#[derive(Accounts)]
#[instruction(
    vault_meta_account_bump: u8,
    fill_record_account_bump: u8,
    auction_epoch_state_bump: u8,
    auction_state_account_bump: u8,
    market_maker_whitelist_entry_bump: u8,
    y_recovery_vault_account_bump: u8,
    /// An unsigned 64 bit integer. The nonce used as a seed to generate
    /// the PDA for the vault meta account, taken from the retail trader's
    /// account when the order in question was initially created.
    nonce: u64,
)]
pub struct FillOrderInstruction<'info> {
    /// The account which holds state specific to a given
    /// order initiated by the retail trader. This account is expected
    /// to be mutable. This account is a PDA generated by the following
    /// seeds: the public key of the retail_account_owner account, the
    /// string literal `vault_meta`, an unsigned 64 bit integer
    #[account(
        mut,
        seeds = [
            retail_account_owner.key.as_ref(),
            b"vault_meta".as_ref(),
            &nonce.to_le_bytes(),
        ],
        bump = vault_meta_account_bump,
    )]
    pub vault_meta_account: Box<Account<'info, VaultMetaAccount>>,

    /// The account which holds meta-information about
    /// the fill, so that arbiters can reference the information when
    /// voting on the fairness of the fill. This account is being initialized
    /// with 194 bytes, paid for by market_maker_account_owner. This
    /// account is a PDA generated by the following seeds: the public
    /// key of the vault_meta_account account, the unsigned integer field
    /// named fill_nonce in the vault_meta_account account, the string
    /// literal `fra`
    #[account(
        init,
        payer = market_maker_account_owner,
        space = 194,
        seeds = [
            vault_meta_account.key().as_ref(),
            &vault_meta_account.fill_nonce.to_le_bytes(),
            b"fra".as_ref(),
        ],
        bump
    )]
    pub fill_record_account: Box<Account<'info, FillRecordAccount>>,

    /// The retail data account holds state specific to
    /// the retail trader. This account is expected to be mutable
    #[account(mut)]
    pub retail_data_account: Box<Account<'info, RetailDataAccount>>,

    /// The account storing state specific to the market
    /// maker. This account must be owned by the DFlow program, and this
    /// account must be initialized by calling the initialize market
    /// maker instruction. This account is expected to be mutable
    #[account(mut)]
    pub market_maker_data_account: Box<Account<'info, MarketMakerDataAccount>>,

    /// The auction epoch state account holds state specific
    /// to an epoch of the auction, if that state must be remembered
    /// beyond the duration of that auction epoch. This account is expected
    /// to be mutable. This account is a PDA generated by the following
    /// seeds: the string literal `epoch`, the unsigned integer field
    /// named auction_id in the vault_meta_account account, the unsigned
    /// integer field named auction_epoch in the vault_meta_account account
    #[account(
        mut,
        seeds = [
            b"epoch".as_ref(),
            &vault_meta_account.auction_id.to_le_bytes(),
            &vault_meta_account.auction_epoch.to_le_bytes(),
        ],
        bump = auction_epoch_state_bump,
    )]
    pub auction_epoch_state: Account<'info, AuctionEpochState>,

    /// The auction state account holds state specific
    /// to the auction. This account is a PDA generated by the following
    /// seeds: the string literal `auction_state`, the unsigned integer
    /// field named auction_id in the vault_meta_account account
    #[account(
        seeds = [
            b"auction_state".as_ref(),
            &vault_meta_account.auction_id.to_le_bytes(),
        ],
        bump = auction_state_account_bump,
    )]
    pub auction_state_account: Box<Account<'info, AuctionStateAccount>>,

    /// The public key of the retail trader.
    pub retail_account_owner: AccountInfo<'info>,

    /// The SPL mint account associated with the token
    /// that is sold by the retail trader during the swap.
    pub x_mint: Box<Account<'info, Mint>>,

    /// The SPL mint account associated with the token
    /// that is received by the retail trader during the swap.
    pub y_mint: Box<Account<'info, Mint>>,

    /// The SPL token account associated with the market
    /// maker, and which sends the asset being received by the retail
    /// trader during a trade. This account is expected to be mutable
    #[account(mut)]
    pub market_maker_y_token_account: Account<'info, TokenAccount>,

    /// The public key of the market maker. This account
    /// is a signer for the instruction. This account is expected to
    /// be mutable
    #[account(
        signer,
        mut,
    )]
    pub market_maker_account_owner: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the market_maker_account_owner. This account is a PDA generated
    /// by the following seeds: the string literal `whitelist_entry`,
    /// the public key of the market_maker_account_owner account
    #[account(
        seeds = [
            b"whitelist_entry".as_ref(),
            market_maker_account_owner.key.as_ref(),
        ],
        bump = market_maker_whitelist_entry_bump,
    )]
    pub market_maker_whitelist_entry: Account<'info, WhitelistEntry>,

    /// The SPL token account associated with the retail
    /// trader, and which receives the asset being sent by the market
    /// maker during a trade. This account is expected to be mutable.
    /// This account is the retail_y_token_account's associated token
    /// account for the mint of the asset sent by the market maker
    #[account(
        mut,
        constraint = is_associated_token_account_address(
            &retail_y_token_account.key(),
            retail_account_owner.key,
            &y_mint.key(),
        ) @ DFlowError::InvalidRetailYTokenAccount,
    )]
    pub retail_y_token_account: AccountInfo<'info>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
    pub rent: Sysvar<'info, Rent>,
    #[account(address = anchor_spl::token::ID)]
    pub token_program: AccountInfo<'info>,
    #[account(address = sysvar::instructions::ID)]
    pub instructions: UncheckedAccount<'info>,
}

/// This instruction is used to vote on the fairness of a fill
/// Arbiters vote on the fairness of a fill when the fill is open
/// for voting. In order to vote on a fill, the arbiter must stake
/// tokens on the accuracy of their vote. If the arbiter voted in
/// the majority, they receive their tokens back. Otherwise the tokens
/// are deposited into a DAO governed backstop fund for the protocol.
#[derive(Accounts)]
#[instruction(
    vault_meta_account_bump: u8,
    fill_record_account_bump: u8,
    vote_record_account_bump: u8,
    auction_state_account_bump: u8,
    arbiter_whitelist_entry_bump: u8,
    vote_vault_account_bump: u8,
    /// An unsigned 64 bit integer. The nonce used as a seed to generate
    /// the PDA for the vault meta account, taken from the retail trader's
    /// account when the order in question was initially created.
    nonce: u64,
    /// An unsigned 16 bit integer. The fill nonce taken from the vault
    /// meta account at fill time, and used to generate the PDA for the
    /// fill record account.
    fill_nonce: u16,
)]
pub struct FillVoteInstruction<'info> {
    /// The account which holds state specific to a given
    /// order initiated by the retail trader. This account is a PDA generated
    /// by the following seeds: the public key of the retail_account_owner
    /// account, the string literal `vault_meta`, an unsigned 64 bit
    /// integer
    #[account(
        seeds = [
            retail_account_owner.key.as_ref(),
            b"vault_meta".as_ref(),
            &nonce.to_le_bytes(),
        ],
        bump = vault_meta_account_bump,
    )]
    pub vault_meta_account: Box<Account<'info, VaultMetaAccount>>,

    /// The account which holds meta-information about
    /// the fill, so that arbiters can reference the information when
    /// voting on the fairness of the fill. This account is expected
    /// to be mutable. This account is a PDA generated by the following
    /// seeds: the public key of the vault_meta_account account, an unsigned
    /// 16 bit integer, the string literal `fra`
    #[account(
        mut,
        seeds = [
            vault_meta_account.key().as_ref(),
            &fill_nonce.to_le_bytes(),
            b"fra".as_ref(),
        ],
        bump = fill_record_account_bump,
    )]
    pub fill_record_account: Box<Account<'info, FillRecordAccount>>,

    /// The account which holds the voting record made
    /// by an arbiter when the arbiter votes on the fairness of the fill.
    /// This account is being initialized with 9 bytes, paid for by arbiter.
    /// This account is a PDA generated by the following seeds: the public
    /// key of the fill_record_account account, the public key of the
    /// arbiter account, the string literal `vra`
    #[account(
        init,
        payer = arbiter,
        space = 9,
        seeds = [
            fill_record_account.key().as_ref(),
            arbiter.key.as_ref(),
            b"vra".as_ref(),
        ],
        bump
    )]
    pub vote_record_account: Box<Account<'info, VoteRecordAccount>>,

    /// The auction state account holds state specific
    /// to the auction. This account is a PDA generated by the following
    /// seeds: the string literal `auction_state`, the unsigned integer
    /// field named auction_id in the vault_meta_account account
    #[account(
        seeds = [
            b"auction_state".as_ref(),
            &vault_meta_account.auction_id.to_le_bytes(),
        ],
        bump = auction_state_account_bump,
    )]
    pub auction_state_account: Account<'info, AuctionStateAccount>,

    /// The public key associated with the arbiter. This
    /// account is a signer for the instruction. This account is expected
    /// to be mutable
    #[account(
        signer,
        mut,
    )]
    pub arbiter: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the arbiter. This account is a PDA generated by the following
    /// seeds: the string literal `whitelist_entry`, the public key of
    /// the arbiter account
    #[account(
        seeds = [
            b"whitelist_entry".as_ref(),
            arbiter.key.as_ref(),
        ],
        bump = arbiter_whitelist_entry_bump,
    )]
    pub arbiter_whitelist_entry: Account<'info, WhitelistEntry>,

    /// The public key of the retail trader.
    pub retail_account_owner: AccountInfo<'info>,

    /// The SPL token account associated with the arbiter
    /// used to vote on the fairness of the fill by the market maker.
    /// This account is expected to be mutable
    #[account(mut)]
    pub arbiter_token_account: Account<'info, TokenAccount>,

    /// The vote vault account is an SPL token account
    /// that holds votes made by arbiters on each fill. Vote stakes held
    /// in this account are returned to the arbiters upon honest voting
    /// of the fill. This account is expected to be mutable. This account
    /// is a PDA generated by the following seeds: the string literal
    /// `vote_vault`, the unsigned integer field named auction_id in
    /// the vault_meta_account account
    #[account(
        mut,
        seeds = [
            b"vote_vault".as_ref(),
            &vault_meta_account.auction_id.to_le_bytes(),
        ],
        bump = vote_vault_account_bump,
    )]
    pub vote_vault_account: Account<'info, TokenAccount>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
    pub rent: Sysvar<'info, Rent>,
    #[account(address = anchor_spl::token::ID)]
    pub token_program: AccountInfo<'info>,
}

/// This instruction is used to claim back the tokens staked during
/// a fill vote by an arbiter.
/// If voting with the majority, the arbiter will receieve a payment
/// from the network along with their original vote. However, if
/// the arbiter did not vote in the majority on the fill, they will
/// not receive their tokens back.
#[derive(Accounts)]
#[instruction(
    vault_meta_account_bump: u8,
    fill_record_account_bump: u8,
    vote_record_account_bump: u8,
    vote_vault_account_bump: u8,
    bid_vault_account_bump: u8,
    auction_state_account_bump: u8,
    auction_epoch_state_bump: u8,
    arbiter_whitelist_entry_bump: u8,
    /// An unsigned 64 bit integer. The nonce used as a seed to generate
    /// the PDA for the vault meta account, taken from the retail trader's
    /// account when the order in question was initially created.
    nonce: u64,
    /// An unsigned 16 bit integer. The fill nonce taken from the vault
    /// meta account at fill time, and used to generate the PDA for the
    /// fill record account.
    fill_nonce: u16,
)]
pub struct ClaimVoteRewardInstruction<'info> {
    /// The account which holds state specific to a given
    /// order initiated by the retail trader. This account is a PDA generated
    /// by the following seeds: the public key of the retail_account_owner
    /// account, the string literal `vault_meta`, an unsigned 64 bit
    /// integer
    #[account(
        seeds = [
            retail_account_owner.key.as_ref(),
            b"vault_meta".as_ref(),
            &nonce.to_le_bytes(),
        ],
        bump = vault_meta_account_bump,
    )]
    pub vault_meta_account: Box<Account<'info, VaultMetaAccount>>,

    /// The account which holds meta-information about
    /// the fill, so that arbiters can reference the information when
    /// voting on the fairness of the fill. This account is being closed,
    /// and the destination of the lamports will be the market_maker_account_owner
    /// account. This account is a PDA generated by the following seeds:
    /// the public key of the vault_meta_account account, an unsigned
    /// 16 bit integer, the string literal `fra`
    #[account(
        seeds = [
            vault_meta_account.key().as_ref(),
            &fill_nonce.to_le_bytes(),
            b"fra".as_ref(),
        ],
        bump = fill_record_account_bump,
    )]
    pub fill_record_account: Box<Account<'info, FillRecordAccount>>,

    /// The account which holds the voting record made
    /// by an arbiter when the arbiter votes on the fairness of the fill.
    /// This account is expected to be mutable. This account is being
    /// closed, and the destination of the lamports will be the market_maker_account_owner
    /// account. This account is a PDA generated by the following seeds:
    /// the public key of the fill_record_account account, the public
    /// key of the arbiter account, the string literal `vra`
    #[account(
        mut,
        seeds = [
            fill_record_account.key().as_ref(),
            arbiter.key.as_ref(),
            b"vra".as_ref(),
        ],
        bump = vote_record_account_bump,
    )]
    pub vote_record_account: Box<Account<'info, VoteRecordAccount>>,

    /// The vote vault account is an SPL token account
    /// that holds votes made by arbiters on each fill. Vote stakes held
    /// in this account are returned to the arbiters upon honest voting
    /// of the fill. This account is expected to be mutable. This account
    /// is a PDA generated by the following seeds: the string literal
    /// `vote_vault`, the unsigned integer field named auction_id in
    /// the vault_meta_account account
    #[account(
        mut,
        seeds = [
            b"vote_vault".as_ref(),
            &vault_meta_account.auction_id.to_le_bytes(),
        ],
        bump = vote_vault_account_bump,
    )]
    pub vote_vault_account: Account<'info, TokenAccount>,

    /// The bid vault account is an SPL token account
    /// that holds bids made by market makers in the auctions for order
    /// flow. Bids held in this account are held only temporarily, and
    /// are distributed out upon fills and fill arbitration. This account
    /// is expected to be mutable. This account is a PDA generated by
    /// the following seeds: the string literal `bid_vault`, the unsigned
    /// integer field named auction_id in the vault_meta_account account
    #[account(
        mut,
        seeds = [
            b"bid_vault".as_ref(),
            &vault_meta_account.auction_id.to_le_bytes(),
        ],
        bump = bid_vault_account_bump,
    )]
    pub bid_vault_account: Account<'info, TokenAccount>,

    /// The auction state account holds state specific
    /// to the auction. This account is a PDA generated by the following
    /// seeds: the string literal `auction_state`, the unsigned integer
    /// field named auction_id in the vault_meta_account account
    #[account(
        seeds = [
            b"auction_state".as_ref(),
            &vault_meta_account.auction_id.to_le_bytes(),
        ],
        bump = auction_state_account_bump,
    )]
    pub auction_state_account: Box<Account<'info, AuctionStateAccount>>,

    /// The auction epoch state account holds state specific
    /// to an epoch of the auction, if that state must be remembered
    /// beyond the duration of that auction epoch. This account is a
    /// PDA generated by the following seeds: the string literal `epoch`,
    /// the unsigned integer field named auction_id in the vault_meta_account
    /// account, the unsigned integer field named auction_epoch in the
    /// vault_meta_account account
    #[account(
        seeds = [
            b"epoch".as_ref(),
            &vault_meta_account.auction_id.to_le_bytes(),
            &vault_meta_account.auction_epoch.to_le_bytes(),
        ],
        bump = auction_epoch_state_bump,
    )]
    pub auction_epoch_state: Account<'info, AuctionEpochState>,

    /// The SPL token account associated with the arbiter
    /// used to receive a payment from the network, with the same mint
    /// as the token accounts used by market makers to bid in the associated
    /// auction. This account is expected to be mutable
    #[account(mut)]
    pub arbiter_bid_token_account: Box<Account<'info, TokenAccount>>,

    /// The public key associated with the arbiter. This
    /// account is a signer for the instruction. This account is expected
    /// to be mutable
    #[account(
        signer,
        mut,
    )]
    pub arbiter: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the arbiter. This account is a PDA generated by the following
    /// seeds: the string literal `whitelist_entry`, the public key of
    /// the arbiter account
    #[account(
        seeds = [
            b"whitelist_entry".as_ref(),
            arbiter.key.as_ref(),
        ],
        bump = arbiter_whitelist_entry_bump,
    )]
    pub arbiter_whitelist_entry: Account<'info, WhitelistEntry>,

    /// The public key of the retail trader.
    pub retail_account_owner: AccountInfo<'info>,

    /// The SPL token account associated with the arbiter
    /// used to vote on the fairness of the fill by the market maker.
    /// This account is expected to be mutable
    #[account(mut)]
    pub arbiter_token_account: Account<'info, TokenAccount>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
    #[account(address = anchor_spl::token::ID)]
    pub token_program: AccountInfo<'info>,
}

/// This instruction is used to close the various accounts opened
/// during the lifecycle of the trade, and additionally give a rebate
/// to the order flow source for its order flow.
/// Lamports used to open the accounts will be returned to the payers
/// who opened the accounts.
#[derive(Accounts)]
#[instruction(
    vault_token_account_bump: u8,
    vault_meta_account_bump: u8,
    fill_record_account_bump: u8,
    bid_vault_account_bump: u8,
    auction_state_account_bump: u8,
    auction_epoch_state_bump: u8,
    arbiter_whitelist_entry_bump: u8,
    bid_recovery_vault_account_bump: u8,
    x_recovery_vault_account_bump: u8,
    /// An unsigned 64 bit integer. The nonce used as a seed to generate
    /// the PDA for the vault token account, taken from the retail trader's
    /// account when the order in question was initially created.
    nonce: u64,
    /// An unsigned 16 bit integer. The fill nonce taken from the vault
    /// meta account at fill time, and used to generate the PDA for the
    /// fill record account.
    fill_nonce: u16,
)]
pub struct CloseFillAccounts<'info> {
    /// The SPL token account owned by the escrow vault,
    /// which holds the sold tokens during a swap from the retail trader.
    /// This account is expected to be mutable. This account is being
    /// closed, and the destination of the lamports will be the retail_account_owner
    /// account. This account is a PDA generated by the following seeds:
    /// the public key of the retail_account_owner account, the string
    /// literal `vault`, an unsigned 64 bit integer
    #[account(
        mut,
        seeds = [
            retail_account_owner.key.as_ref(),
            b"vault".as_ref(),
            &nonce.to_le_bytes(),
        ],
        bump = vault_token_account_bump,
    )]
    pub vault_token_account: Account<'info, TokenAccount>,

    /// The account which holds state specific to a given
    /// order initiated by the retail trader. This account is expected
    /// to be mutable. This account is being closed, and the destination
    /// of the lamports will be the retail_account_owner account. This
    /// account is a PDA generated by the following seeds: the public
    /// key of the retail_account_owner account, the string literal `vault_meta`,
    /// an unsigned 64 bit integer. The key of rebate_receiver_token_account
    /// must match the field named rebate_receiver_token_account in this
    /// account
    #[account(
        mut,
        seeds = [
            retail_account_owner.key.as_ref(),
            b"vault_meta".as_ref(),
            &nonce.to_le_bytes(),
        ],
        bump = vault_meta_account_bump,
        has_one = rebate_receiver_token_account @ DFlowError::InvalidRebateReceiverTokenAccount,
    )]
    pub vault_meta_account: Box<Account<'info, VaultMetaAccount>>,

    /// The account which holds meta-information about
    /// the fill, so that arbiters can reference the information when
    /// voting on the fairness of the fill. This account is expected
    /// to be mutable. This account is being closed, and the destination
    /// of the lamports will be the market_maker_account_owner account.
    /// This account is a PDA generated by the following seeds: the public
    /// key of the vault_meta_account account, an unsigned 16 bit integer,
    /// the string literal `fra`. The key of market_maker_account_owner
    /// must match the field named market_maker_account_owner in this
    /// account
    #[account(
        mut,
        seeds = [
            vault_meta_account.key().as_ref(),
            &fill_nonce.to_le_bytes(),
            b"fra".as_ref(),
        ],
        bump = fill_record_account_bump,
        has_one = market_maker_account_owner @ DFlowError::InvalidMarketMakerAccountOwner,
    )]
    pub fill_record_account: Box<Account<'info, FillRecordAccount>>,

    /// The bid vault account is an SPL token account
    /// that holds bids made by market makers in the auctions for order
    /// flow. Bids held in this account are held only temporarily, and
    /// are distributed out upon fills and fill arbitration. This account
    /// is expected to be mutable. This account is a PDA generated by
    /// the following seeds: the string literal `bid_vault`, the unsigned
    /// integer field named auction_id in the vault_meta_account account
    #[account(
        mut,
        seeds = [
            b"bid_vault".as_ref(),
            &vault_meta_account.auction_id.to_le_bytes(),
        ],
        bump = bid_vault_account_bump,
    )]
    pub bid_vault_account: Account<'info, TokenAccount>,

    /// The auction state account holds state specific
    /// to the auction. This account is a PDA generated by the following
    /// seeds: the string literal `auction_state`, the unsigned integer
    /// field named auction_id in the vault_meta_account account
    #[account(
        seeds = [
            b"auction_state".as_ref(),
            &vault_meta_account.auction_id.to_le_bytes(),
        ],
        bump = auction_state_account_bump,
    )]
    pub auction_state_account: Box<Account<'info, AuctionStateAccount>>,

    /// The auction epoch state account holds state specific
    /// to an epoch of the auction, if that state must be remembered
    /// beyond the duration of that auction epoch. This account is expected
    /// to be mutable. This account is a PDA generated by the following
    /// seeds: the string literal `epoch`, the unsigned integer field
    /// named auction_id in the vault_meta_account account, the unsigned
    /// integer field named auction_epoch in the vault_meta_account account
    #[account(
        mut,
        seeds = [
            b"epoch".as_ref(),
            &vault_meta_account.auction_id.to_le_bytes(),
            &vault_meta_account.auction_epoch.to_le_bytes(),
        ],
        bump = auction_epoch_state_bump,
    )]
    pub auction_epoch_state: Account<'info, AuctionEpochState>,

    /// The SPL token account associated with the market
    /// maker, and which receives the asset sold by the retail trader
    /// during a trade. This account is expected to be mutable. This
    /// account is the market_maker_account_owner's associated token
    /// account for the mint of the asset sent by the retail trader
    #[account(
        mut,
        constraint = is_associated_token_account_address(
            &market_maker_x_token_account.key(),
            market_maker_account_owner.key,
            &vault_token_account.mint,
        ) @ DFlowError::InvalidMarketMakerXTokenAccount,
    )]
    pub market_maker_x_token_account: AccountInfo<'info>,

    /// The retail data account holds state specific to
    /// the retail trader. This account is expected to be mutable. The
    /// key of retail_account_owner must match the field named retail_account_owner
    /// in this account
    #[account(
        mut,
        has_one = retail_account_owner @ DFlowError::InvalidCloseFillRetailDataAccount,
    )]
    pub retail_data_account: Account<'info, RetailDataAccount>,

    /// The public key of the market maker. This account
    /// is expected to be mutable
    #[account(mut)]
    pub market_maker_account_owner: AccountInfo<'info>,

    /// The public key associated with the arbiter. This
    /// account is a signer for the instruction
    #[account(signer)]
    pub arbiter: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the arbiter. This account is a PDA generated by the following
    /// seeds: the string literal `whitelist_entry`, the public key of
    /// the arbiter account
    #[account(
        seeds = [
            b"whitelist_entry".as_ref(),
            arbiter.key.as_ref(),
        ],
        bump = arbiter_whitelist_entry_bump,
    )]
    pub arbiter_whitelist_entry: Account<'info, WhitelistEntry>,

    /// The public key of the retail trader. This account
    /// is expected to be mutable
    #[account(mut)]
    pub retail_account_owner: AccountInfo<'info>,

    /// The SPL token account associated with the order
    /// used to receive a payment from the network, with the same mint
    /// as the token accounts used by market makers to bid in the associated
    /// auction. This account is expected to be mutable
    #[account(mut)]
    pub rebate_receiver_token_account: AccountInfo<'info>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
    #[account(address = anchor_spl::token::ID)]
    pub token_program: AccountInfo<'info>,
}

/// This instruction is used to initialize global state for tracking
/// the system of signatory servers.
/// This instruction can only be called by the DFlow admin and can
/// only be called once.
#[derive(Accounts)]
#[instruction(
    global_config_account_bump: u8,
    signatory_state_bump: u8,
    signatory_stake_vault_bump: u8,
)]
pub struct InitSignatorySystem<'info> {
    /// This account stores the DFlow admin's public key.
    /// This account is a PDA generated by the following seeds: the string
    /// literal `global_config`
    #[account(
        seeds = [
            b"global_config".as_ref(),
        ],
        bump = global_config_account_bump,
    )]
    pub global_config_account: Account<'info, GlobalConfigAccount>,

    /// The signatory state account holds information
    /// about the global system of signatory servers, and the existence
    /// of the signatory state account is a valid proof that the signatory
    /// server system has been initialized. This account is being initialized
    /// with 40 bytes, paid for by dflow_admin. This account is a PDA
    /// generated by the following seeds: the string literal `sigstate`
    #[account(
        init,
        payer = dflow_admin,
        space = 40,
        seeds = [
            b"sigstate".as_ref(),
        ],
        bump
    )]
    pub signatory_state: Account<'info, SignatoryState>,

    /// The signatory stake vault holds staked assets
    /// from signatory server operators. This account is being initialized
    /// and is paid for by dflow_admin. This is a token account which
    /// is being initialized, and is associated with the signatory_stake_mint
    /// mint. The authority for this token account is signatory_state.
    /// This account is a PDA generated by the following seeds: the string
    /// literal `sigstake`
    #[account(
        init,
        payer = dflow_admin,
        token::mint = signatory_stake_mint,
        token::authority = signatory_state,
        seeds = [
            b"sigstake".as_ref(),
        ],
        bump
    )]
    pub signatory_stake_vault: Account<'info, TokenAccount>,

    /// The SPL mint account associated with the token
    /// that is staked by the signatory server.
    pub signatory_stake_mint: Account<'info, Mint>,

    /// The public key of the DFlow admin. This account
    /// is a signer for the instruction. This account is expected to
    /// be mutable
    #[account(
        signer,
        mut,
    )]
    pub dflow_admin: AccountInfo<'info>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
    pub rent: Sysvar<'info, Rent>,
    #[account(address = anchor_spl::token::ID)]
    pub token_program: AccountInfo<'info>,
}

/// This instruction is used to stake the requisite amount of tokens
/// necessary to endorse flow as retail. This stake is subject to
/// slashing based on the quality of the order flow sent by the signatory
/// server.
/// Signatory server operators provide helpful network participation
/// by endorsing and forwarding retail order flow to the network.
/// This helpful network participation is rewarded, or slashed based
/// on the quality of order flow sent.
#[derive(Accounts)]
#[instruction(
    signatory_record_bump: u8,
    signatory_stake_vault_bump: u8,
    signatory_server_whitelist_entry_bump: u8,
)]
pub struct CreateSignatory<'info> {
    /// The signatory record account holds information
    /// about a signatory server, and the existence of the signatory
    /// record account is a valid proof that the signatory server has
    /// staked the requisite value in the protocol allowing it to endorse
    /// flow as originating from a retail source. This account is being
    /// initialized with 48 bytes, paid for by signatory_server. This
    /// account is a PDA generated by the following seeds: the public
    /// key of the signatory_server account
    #[account(
        init,
        payer = signatory_server,
        space = 48,
        seeds = [
            signatory_server.key.as_ref(),
        ],
        bump
    )]
    pub signatory_record: Account<'info, SignatoryRecord>,

    /// The signatory stake vault holds staked assets
    /// from signatory server operators. This account is expected to
    /// be mutable. This account is a PDA generated by the following
    /// seeds: the string literal `sigstake`
    #[account(
        mut,
        seeds = [
            b"sigstake".as_ref(),
        ],
        bump = signatory_stake_vault_bump,
    )]
    pub signatory_stake_vault: Account<'info, TokenAccount>,

    /// The signatory server's token account used for
    /// originating the stake transfer. This account is expected to be
    /// mutable
    #[account(mut)]
    pub signatory_server_token_account: Account<'info, TokenAccount>,

    /// The public key of the signatory server that endorses
    /// new orders as originating from a retail source. This account
    /// is a signer for the instruction. This account is expected to
    /// be mutable
    #[account(
        signer,
        mut,
    )]
    pub signatory_server: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the signatory_server. This account is a PDA generated by the
    /// following seeds: the string literal `whitelist_entry`, the public
    /// key of the signatory_server account
    #[account(
        seeds = [
            b"whitelist_entry".as_ref(),
            signatory_server.key.as_ref(),
        ],
        bump = signatory_server_whitelist_entry_bump,
    )]
    pub signatory_server_whitelist_entry: Account<'info, WhitelistEntry>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
    pub rent: Sysvar<'info, Rent>,
    #[account(address = anchor_spl::token::ID)]
    pub token_program: AccountInfo<'info>,
}

/// This instruction is used to stake additional tokens into an existing
/// signatory server stake vault.
/// Signatory servers are subject to slashing, and if slashed to
/// below the stake minimum they may no longer be qualified to endorse
/// order flow as originated from a retail source.
#[derive(Accounts)]
#[instruction(
    signatory_record_bump: u8,
    signatory_stake_vault_bump: u8,
    signatory_server_whitelist_entry_bump: u8,
)]
pub struct StakeSignatory<'info> {
    /// The signatory record account holds information
    /// about a signatory server, and the existence of the signatory
    /// record account is a valid proof that the signatory server has
    /// staked the requisite value in the protocol allowing it to endorse
    /// flow as originating from a retail source. This account is expected
    /// to be mutable. This account is a PDA generated by the following
    /// seeds: the public key of the signatory_server account
    #[account(
        mut,
        seeds = [
            signatory_server.key.as_ref(),
        ],
        bump = signatory_record_bump,
    )]
    pub signatory_record: Account<'info, SignatoryRecord>,

    /// The signatory stake vault holds staked assets
    /// from signatory server operators. This account is expected to
    /// be mutable. This account is a PDA generated by the following
    /// seeds: the string literal `sigstake`
    #[account(
        mut,
        seeds = [
            b"sigstake".as_ref(),
        ],
        bump = signatory_stake_vault_bump,
    )]
    pub signatory_stake_vault: Account<'info, TokenAccount>,

    /// The signatory server's token account used for
    /// originating the stake transfer. This account is expected to be
    /// mutable
    #[account(mut)]
    pub signatory_server_token_account: Account<'info, TokenAccount>,

    /// The public key of the signatory server that endorses
    /// new orders as originating from a retail source. This account
    /// is a signer for the instruction. This account is expected to
    /// be mutable
    #[account(
        signer,
        mut,
    )]
    pub signatory_server: AccountInfo<'info>,

    /// This account stores the permissions that apply
    /// to the signatory_server. This account is a PDA generated by the
    /// following seeds: the string literal `whitelist_entry`, the public
    /// key of the signatory_server account
    #[account(
        seeds = [
            b"whitelist_entry".as_ref(),
            signatory_server.key.as_ref(),
        ],
        bump = signatory_server_whitelist_entry_bump,
    )]
    pub signatory_server_whitelist_entry: Account<'info, WhitelistEntry>,

    #[account(address = anchor_spl::token::ID)]
    pub token_program: AccountInfo<'info>,
}

/// This instruction is used to close an AuctionEpochState account.
/// The auction owner can use this instruction to close the AuctionEpochState
/// account for an old epoch that has no open orders or fills pending
/// settlement. The auction owner can also use this instruction close
/// the AuctionEpochState account for the last, current, or next
/// epoch if the auction is in the Draining state.
#[derive(Accounts)]
#[instruction(
    auction_epoch_state_bump: u8,
    auction_state_account_bump: u8,
    /// An unsigned 64 bit integer. The auction ID used as a seed to
    /// generate the program derived address
    auction_id: u64,
    /// An unsigned 64 bit integer. The integer epoch used to generate
    /// the PDA of the auction epoch account
    auction_epoch: u64,
)]
pub struct CloseAuctionEpochState<'info> {
    /// The auction epoch state account holds state specific
    /// to an epoch of the auction, if that state must be remembered
    /// beyond the duration of that auction epoch. This account is expected
    /// to be mutable. This account is being closed, and the destination
    /// of the lamports will be the auction_owner account. This account
    /// is a PDA generated by the following seeds: the string literal
    /// `epoch`, an unsigned 64 bit integer, an unsigned 64 bit integer.
    /// The key of owner must match the field named owner in this account
    #[account(
        mut,
        seeds = [
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
        ],
        bump = auction_epoch_state_bump,
        has_one = owner @ DFlowError::InvalidCloseAuctionEpochStateOwner,
    )]
    pub auction_epoch_state: Account<'info, AuctionEpochState>,

    /// The auction state account holds state specific
    /// to the auction. This account is expected to be mutable. This
    /// account is a PDA generated by the following seeds: the string
    /// literal `auction_state`, an unsigned 64 bit integer
    #[account(
        mut,
        seeds = [
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        bump = auction_state_account_bump,
    )]
    pub auction_state_account: Account<'info, AuctionStateAccount>,

    /// The account that created the AuctionEpochState
    /// account by calling init_auction_epoch_state_account. This account
    /// is a signer for the instruction. This account is expected to
    /// be mutable
    #[account(
        signer,
        mut,
    )]
    pub owner: AccountInfo<'info>,

    #[account(address = system_program::ID)]
    pub system_program: AccountInfo<'info>,
}