use anchor_client::solana_sdk::{
    pubkey::Pubkey,
    signer::Signer,
    hash::Hash,
    instruction::Instruction
};
use anchor_client::solana_sdk::{system_program, sysvar};
use anchor_client::Program;
use anchor_lang::prelude::*;
use spl_token;
use crate::instruction;
use crate::accounts;

/// 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.
///
/// # Arguments
/// * `dflow_admin` The public key of the DFlow admin. This account
///    is a signer for the instruction. This account is expected to
///    be mutable
///
/// Returns an instruction
pub fn init_global_config_instruction(
    program: &Program,
    // Non-PDA Non-Seed Dep Accounts
    dflow_admin: Pubkey,
) -> Instruction {
    let (global_config_account, global_config_account_bump) = Pubkey::find_program_address(
        &[
            b"global_config".as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::InitGlobalConfigInstruction {
                global_config_account: global_config_account,
                dflow_admin: dflow_admin,
                system_program: system_program::id(),
                rent: sysvar::rent::id()
            })
        .args(instruction::InitGlobalConfigInstruction {
                // Bumps
                global_config_account_bump: global_config_account_bump,
            })
        .instructions()
        .expect("init_global_config_instruction construction failed")
        .swap_remove(0)
}

/// This instruction updates the DFlow admin.
///
/// The current DFlow admin can use this instruction
/// to assign a new DFlow admin.
///
/// # Arguments
/// * `dflow_admin` The public key of the DFlow admin. This account
///    is a signer for the instruction
/// * `new_dflow_admin` The new DFlow admin's public key.
///
/// Returns an instruction
pub fn set_new_dflow_admin(
    program: &Program,
    // Non-PDA Non-Seed Dep Accounts
    dflow_admin: Pubkey,
    new_dflow_admin: Pubkey,
) -> Instruction {
    let (global_config_account, global_config_account_bump) = Pubkey::find_program_address(
        &[
            b"global_config".as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::SetNewDflowAdmin {
                global_config_account: global_config_account,
                dflow_admin: dflow_admin,
                new_dflow_admin: new_dflow_admin
            })
        .args(instruction::SetNewDflowAdmin {
                // Bumps
                global_config_account_bump: global_config_account_bump,
            })
        .instructions()
        .expect("set_new_dflow_admin construction failed")
        .swap_remove(0)
}

/// This instruction creates the principal's whitelist
/// entry account and grants the specified role to the principal.
/// # Arguments
/// * `principal` The public key of the principal account.
/// * `role` The role to grant to the principal.
/// * `dflow_admin` The public key of the DFlow admin. This account
///    is a signer for the instruction. This account is expected to
///    be mutable
///
/// Returns an instruction
pub fn grant_role_uninitialized_entry(
    program: &Program,
    // Seed Deps
    principal: Pubkey,
    // Function Args
    role: u8,
    // Non-PDA Non-Seed Dep Accounts
    dflow_admin: Pubkey,
) -> Instruction {
    let (global_config_account, global_config_account_bump) = Pubkey::find_program_address(
        &[
            b"global_config".as_ref(),
        ],
        &program.id(),
    );
    let (whitelist_entry, whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            principal.as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::GrantRoleUninitializedEntry {
                global_config_account: global_config_account,
                principal: principal,
                dflow_admin: dflow_admin,
                whitelist_entry: whitelist_entry,
                system_program: system_program::id(),
                rent: sysvar::rent::id()
            })
        .args(instruction::GrantRoleUninitializedEntry {
                // Bumps
                global_config_account_bump: global_config_account_bump,
                whitelist_entry_bump: whitelist_entry_bump,
                // Function Arguments
                role: role,
            })
        .instructions()
        .expect("grant_role_uninitialized_entry construction failed")
        .swap_remove(0)
}

/// This instruction grants the specified role to the principal.
/// # Arguments
/// * `principal` The public key of the principal account.
/// * `role` The role to grant to the principal.
/// * `dflow_admin` The public key of the DFlow admin. This account
///    is a signer for the instruction. This account is expected to
///    be mutable
///
/// Returns an instruction
pub fn grant_role(
    program: &Program,
    // Seed Deps
    principal: Pubkey,
    // Function Args
    role: u8,
    // Non-PDA Non-Seed Dep Accounts
    dflow_admin: Pubkey,
) -> Instruction {
    let (global_config_account, global_config_account_bump) = Pubkey::find_program_address(
        &[
            b"global_config".as_ref(),
        ],
        &program.id(),
    );
    let (whitelist_entry, whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            principal.as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::GrantRole {
                global_config_account: global_config_account,
                principal: principal,
                dflow_admin: dflow_admin,
                whitelist_entry: whitelist_entry
            })
        .args(instruction::GrantRole {
                // Bumps
                global_config_account_bump: global_config_account_bump,
                whitelist_entry_bump: whitelist_entry_bump,
                // Function Arguments
                role: role,
            })
        .instructions()
        .expect("grant_role construction failed")
        .swap_remove(0)
}

/// This instruction revokes the specified role from
/// the principal and closes the principal's whitelist account if
/// it no longer grants any permissions.
/// # Arguments
/// * `principal` The public key of the principal account.
/// * `role` The role to revoke from the principal.
/// * `dflow_admin` The public key of the DFlow admin. This account
///    is a signer for the instruction. This account is expected to
///    be mutable
///
/// Returns an instruction
pub fn revoke_role(
    program: &Program,
    // Seed Deps
    principal: Pubkey,
    // Function Args
    role: u8,
    // Non-PDA Non-Seed Dep Accounts
    dflow_admin: Pubkey,
) -> Instruction {
    let (global_config_account, global_config_account_bump) = Pubkey::find_program_address(
        &[
            b"global_config".as_ref(),
        ],
        &program.id(),
    );
    let (whitelist_entry, whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            principal.as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::RevokeRole {
                global_config_account: global_config_account,
                whitelist_entry: whitelist_entry,
                principal: principal,
                dflow_admin: dflow_admin
            })
        .args(instruction::RevokeRole {
                // Bumps
                global_config_account_bump: global_config_account_bump,
                whitelist_entry_bump: whitelist_entry_bump,
                // Function Arguments
                role: role,
            })
        .instructions()
        .expect("revoke_role construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `recovery_vault_mint` The public key of the recovery_vault_mint account.
/// * `auction_owner` The public key of the auction_owner account.
///
/// Returns an instruction
pub fn init_recovery_vault(
    program: &Program,
    // Seed Deps
    recovery_vault_mint: Pubkey,
    auction_owner: Pubkey,
) -> Instruction {
    let (recovery_state_account, recovery_state_account_bump) = Pubkey::find_program_address(
        &[
            recovery_vault_mint.as_ref(),
            b"recovery_state".as_ref(),
        ],
        &program.id(),
    );
    let (recovery_vault_account, recovery_vault_account_bump) = Pubkey::find_program_address(
        &[
            recovery_vault_mint.as_ref(),
            b"recovery_vault".as_ref(),
        ],
        &program.id(),
    );
    let (auction_owner_whitelist_entry, auction_owner_whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            auction_owner.as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::InitRecoveryVaultInstruction {
                recovery_state_account: recovery_state_account,
                recovery_vault_account: recovery_vault_account,
                recovery_vault_mint: recovery_vault_mint,
                auction_owner: auction_owner,
                auction_owner_whitelist_entry: auction_owner_whitelist_entry,
                system_program: system_program::id(),
                rent: sysvar::rent::id(),
                token_program: spl_token::ID
            })
        .args(instruction::InitRecoveryVaultInstruction {
                // Bumps
                recovery_state_account_bump: recovery_state_account_bump,
                recovery_vault_account_bump: recovery_vault_account_bump,
                auction_owner_whitelist_entry_bump: auction_owner_whitelist_entry_bump,
            })
        .instructions()
        .expect("init_recovery_vault construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `dflow_admin` The public key of the DFlow admin. This account
///    is a signer for the instruction. This account is expected to
///    be mutable
///
/// Returns an instruction
pub fn init_auction_mapper(
    program: &Program,
    // Non-PDA Non-Seed Dep Accounts
    dflow_admin: Pubkey,
) -> Instruction {
    let (global_config_account, global_config_account_bump) = Pubkey::find_program_address(
        &[
            b"global_config".as_ref(),
        ],
        &program.id(),
    );
    let (auction_mapper, auction_mapper_bump) = Pubkey::find_program_address(
        &[
            b"mapper".as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::InitAuctionMapperInstruction {
                global_config_account: global_config_account,
                auction_mapper: auction_mapper,
                dflow_admin: dflow_admin,
                system_program: system_program::id(),
                rent: sysvar::rent::id()
            })
        .args(instruction::InitAuctionMapperInstruction {
                // Bumps
                global_config_account_bump: global_config_account_bump,
                auction_mapper_bump: auction_mapper_bump,
            })
        .instructions()
        .expect("init_auction_mapper construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `auction_id` An unsigned 64 bit integer. The auction ID used
///    as a seed to generate the program derived address
/// * `auction_owner` The public key of the auction_owner account.
/// * `bid_mint_account` The public key of the bid_mint_account account.
/// * `vote_mint_account` The public key of the vote_mint_account account.
/// * `min_notional_order_size` The minimum notional size accepted by this newly
///    initialized auction. The notional size of all order flow purchased
///    in this auction must be greater than or equal to this value
/// * `max_notional_order_size` The maximum notional size accepted by this newly
///    initialized auction. The notional size of all order flow purchased
///    in this auction must be less than or equal to this value
/// * `notional_decimals` The number of decimals in `min_notional_order_size`,
///    `max_notional_order_size`, and `batch_notional_size`
/// * `batch_notional_size` The total notional size of the orders that will
///    be routed to the market maker when the market maker wins this
///    auction. A winning market maker will receive order flow with
///    a total notional size in the range [batch_notional_size, batch_notional_size
///    + max_notional_order_size)
/// * `vote_size` The amount of tokens in the currency of the vote
///    mint that the arbiter will need to stake every time the arbiter
///    votes on a fill.
/// * `supported_pairs_count` The number of token pairs for which order flow
///    is sold in this auction.
/// * `vote_period` The length in seconds of the voting period for
///    orders routed through this auction.
/// * `claim_period` The length in seconds of the reward claiming period
///    for orders routed through this auction.
///
/// Returns an instruction
pub fn init_auction_state(
    program: &Program,
    // Seed Deps
    auction_id: u64,
    auction_owner: Pubkey,
    bid_mint_account: Pubkey,
    vote_mint_account: Pubkey,
    // Function Args
    min_notional_order_size: u64,
    max_notional_order_size: u64,
    notional_decimals: u8,
    batch_notional_size: u64,
    vote_size: u64,
    supported_pairs_count: u8,
    vote_period: u32,
    claim_period: u32,
) -> Instruction {
    let (auction_state_account, auction_state_account_bump) = Pubkey::find_program_address(
        &[
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (bid_vault_account, bid_vault_account_bump) = Pubkey::find_program_address(
        &[
            b"bid_vault".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (vote_vault_account, vote_vault_account_bump) = Pubkey::find_program_address(
        &[
            b"vote_vault".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (auction_mapper, auction_mapper_bump) = Pubkey::find_program_address(
        &[
            b"mapper".as_ref(),
        ],
        &program.id(),
    );
    let (auction_owner_whitelist_entry, auction_owner_whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            auction_owner.as_ref(),
        ],
        &program.id(),
    );
    let (bid_recovery_state_account, bid_recovery_state_account_bump) = Pubkey::find_program_address(
        &[
            bid_mint_account.as_ref(),
            b"recovery_state".as_ref(),
        ],
        &program.id(),
    );
    let (bid_recovery_vault_account, bid_recovery_vault_account_bump) = Pubkey::find_program_address(
        &[
            bid_mint_account.as_ref(),
            b"recovery_vault".as_ref(),
        ],
        &program.id(),
    );
    let (vote_recovery_state_account, vote_recovery_state_account_bump) = Pubkey::find_program_address(
        &[
            vote_mint_account.as_ref(),
            b"recovery_state".as_ref(),
        ],
        &program.id(),
    );
    let (vote_recovery_vault_account, vote_recovery_vault_account_bump) = Pubkey::find_program_address(
        &[
            vote_mint_account.as_ref(),
            b"recovery_vault".as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::InitAuctionState {
                auction_state_account: auction_state_account,
                bid_vault_account: bid_vault_account,
                vote_vault_account: vote_vault_account,
                auction_mapper: auction_mapper,
                auction_owner: auction_owner,
                auction_owner_whitelist_entry: auction_owner_whitelist_entry,
                bid_mint_account: bid_mint_account,
                vote_mint_account: vote_mint_account,
                bid_recovery_state_account: bid_recovery_state_account,
                bid_recovery_vault_account: bid_recovery_vault_account,
                vote_recovery_state_account: vote_recovery_state_account,
                vote_recovery_vault_account: vote_recovery_vault_account,
                system_program: system_program::id(),
                rent: sysvar::rent::id(),
                token_program: spl_token::ID
            })
        .args(instruction::InitAuctionState {
                // Bumps
                auction_state_account_bump: auction_state_account_bump,
                bid_vault_account_bump: bid_vault_account_bump,
                vote_vault_account_bump: vote_vault_account_bump,
                auction_mapper_bump: auction_mapper_bump,
                auction_owner_whitelist_entry_bump: auction_owner_whitelist_entry_bump,
                bid_recovery_state_account_bump: bid_recovery_state_account_bump,
                bid_recovery_vault_account_bump: bid_recovery_vault_account_bump,
                vote_recovery_state_account_bump: vote_recovery_state_account_bump,
                vote_recovery_vault_account_bump: vote_recovery_vault_account_bump,
                // Seed Dependencies
                auction_id: auction_id,
                // Function Arguments
                min_notional_order_size: min_notional_order_size,
                max_notional_order_size: max_notional_order_size,
                notional_decimals: notional_decimals,
                batch_notional_size: batch_notional_size,
                vote_size: vote_size,
                supported_pairs_count: supported_pairs_count,
                vote_period: vote_period,
                claim_period: claim_period,
            })
        .instructions()
        .expect("init_auction_state construction failed")
        .swap_remove(0)
}

/// 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
///
/// # Arguments
/// * `auction_id` An unsigned 64 bit integer. The auction ID used
///    as a seed to generate the program derived address
/// * `base_currency` The public key of the base_currency account.
/// * `quote_currency` The public key of the quote_currency account.
/// * `auction_owner` The public key of the auction_owner account.
/// * `base_oracle` The Pyth price oracle associated with the base
///    token in a currency pair.
/// * `quote_oracle` The Pyth price oracle associated with the quote
///    token in a currency pair.
///
/// Returns an instruction
pub fn add_pair_to_auction(
    program: &Program,
    // Seed Deps
    auction_id: u64,
    base_currency: Pubkey,
    quote_currency: Pubkey,
    auction_owner: Pubkey,
    // Non-PDA Non-Seed Dep Accounts
    base_oracle: Pubkey,
    quote_oracle: Pubkey,
) -> Instruction {
    let (auction_state_account, auction_state_account_bump) = Pubkey::find_program_address(
        &[
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (base_recovery_state_account, base_recovery_state_account_bump) = Pubkey::find_program_address(
        &[
            base_currency.as_ref(),
            b"recovery_state".as_ref(),
        ],
        &program.id(),
    );
    let (base_recovery_vault_account, base_recovery_vault_account_bump) = Pubkey::find_program_address(
        &[
            base_currency.as_ref(),
            b"recovery_vault".as_ref(),
        ],
        &program.id(),
    );
    let (quote_recovery_state_account, quote_recovery_state_account_bump) = Pubkey::find_program_address(
        &[
            quote_currency.as_ref(),
            b"recovery_state".as_ref(),
        ],
        &program.id(),
    );
    let (quote_recovery_vault_account, quote_recovery_vault_account_bump) = Pubkey::find_program_address(
        &[
            quote_currency.as_ref(),
            b"recovery_vault".as_ref(),
        ],
        &program.id(),
    );
    let (auction_owner_whitelist_entry, auction_owner_whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            auction_owner.as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::AddCurrencyPair {
                auction_state_account: auction_state_account,
                base_currency: base_currency,
                quote_currency: quote_currency,
                base_oracle: base_oracle,
                quote_oracle: quote_oracle,
                base_recovery_state_account: base_recovery_state_account,
                base_recovery_vault_account: base_recovery_vault_account,
                quote_recovery_state_account: quote_recovery_state_account,
                quote_recovery_vault_account: quote_recovery_vault_account,
                auction_owner: auction_owner,
                auction_owner_whitelist_entry: auction_owner_whitelist_entry,
                token_program: spl_token::ID
            })
        .args(instruction::AddCurrencyPair {
                // Bumps
                auction_state_account_bump: auction_state_account_bump,
                base_recovery_state_account_bump: base_recovery_state_account_bump,
                base_recovery_vault_account_bump: base_recovery_vault_account_bump,
                quote_recovery_state_account_bump: quote_recovery_state_account_bump,
                quote_recovery_vault_account_bump: quote_recovery_vault_account_bump,
                auction_owner_whitelist_entry_bump: auction_owner_whitelist_entry_bump,
                // Seed Dependencies
                auction_id: auction_id,
            })
        .instructions()
        .expect("add_pair_to_auction construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `auction_id` An unsigned 64 bit integer. The auction ID used
///    as a seed to generate the program derived address
/// * `auction_owner` The public key of the auction_owner account.
/// * `new_status` The new status for the given auction, specified
///    by the auction ID parameter. A value of 0 indicates Trading.
///    A value of 1 indicates Halted. A value of 2 indicates expired.
///    All other values result in a failed transaction.
///
/// Returns an instruction
pub fn change_auction_status(
    program: &Program,
    // Seed Deps
    auction_id: u64,
    auction_owner: Pubkey,
    // Function Args
    new_status: u8,
) -> Instruction {
    let (auction_state_account, auction_state_account_bump) = Pubkey::find_program_address(
        &[
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (auction_mapper, auction_mapper_bump) = Pubkey::find_program_address(
        &[
            b"mapper".as_ref(),
        ],
        &program.id(),
    );
    let (auction_owner_whitelist_entry, auction_owner_whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            auction_owner.as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::ChangeAuctionStatus {
                auction_state_account: auction_state_account,
                auction_mapper: auction_mapper,
                auction_owner: auction_owner,
                auction_owner_whitelist_entry: auction_owner_whitelist_entry,
                system_program: system_program::id()
            })
        .args(instruction::ChangeAuctionStatus {
                // Bumps
                auction_state_account_bump: auction_state_account_bump,
                auction_mapper_bump: auction_mapper_bump,
                auction_owner_whitelist_entry_bump: auction_owner_whitelist_entry_bump,
                // Seed Dependencies
                auction_id: auction_id,
                // Function Arguments
                new_status: new_status,
            })
        .instructions()
        .expect("change_auction_status construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `market_maker_account_owner` The public key of the market_maker_account_owner account.
/// * `max_orders_supported` The maximum number of orders supported in the
///    market maker's queue of orders
/// * `encryption_pub_key` The market maker's 256-bit X25519 public key which
///    will be used by retail traders to encrypt their order details
/// * `market_maker_data_account` 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
///
/// Returns an instruction
pub fn init_market_maker_account(
    program: &Program,
    // Seed Deps
    market_maker_account_owner: Pubkey,
    // Function Args
    max_orders_supported: u64,
    encryption_pub_key: [u8; 32],
    // Non-PDA Non-Seed Dep Accounts
    market_maker_data_account: Pubkey,
) -> Instruction {
    let (market_maker_whitelist_entry, market_maker_whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            market_maker_account_owner.as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::InitMarketMakerAccountInstruction {
                market_maker_data_account: market_maker_data_account,
                market_maker_account_owner: market_maker_account_owner,
                market_maker_whitelist_entry: market_maker_whitelist_entry
            })
        .args(instruction::InitMarketMakerAccountInstruction {
                // Bumps
                market_maker_whitelist_entry_bump: market_maker_whitelist_entry_bump,
                // Function Arguments
                max_orders_supported: max_orders_supported,
                encryption_pub_key: encryption_pub_key,
            })
        .instructions()
        .expect("init_market_maker_account construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `market_maker_account_owner` The public key of the market_maker_account_owner account.
/// * `encryption_pub_key` The market maker's 256-bit X25519 public key which
///    will be used by retail traders to encrypt their order details
/// * `market_maker_data_account` 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
///
/// Returns an instruction
pub fn update_encryption_key(
    program: &Program,
    // Seed Deps
    market_maker_account_owner: Pubkey,
    // Function Args
    encryption_pub_key: [u8; 32],
    // Non-PDA Non-Seed Dep Accounts
    market_maker_data_account: Pubkey,
) -> Instruction {
    let (market_maker_whitelist_entry, market_maker_whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            market_maker_account_owner.as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::UpdateEncryptionKeyInstruction {
                market_maker_data_account: market_maker_data_account,
                market_maker_account_owner: market_maker_account_owner,
                market_maker_whitelist_entry: market_maker_whitelist_entry
            })
        .args(instruction::UpdateEncryptionKeyInstruction {
                // Bumps
                market_maker_whitelist_entry_bump: market_maker_whitelist_entry_bump,
                // Function Arguments
                encryption_pub_key: encryption_pub_key,
            })
        .instructions()
        .expect("update_encryption_key construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `auction_id` An unsigned 64 bit integer. The auction ID used
///    as a seed to generate the program derived address
/// * `auction_epoch` An unsigned 64 bit integer. The integer epoch
///    used to generate the PDA of the auction epoch account
/// * `owner` The creator and owner of AuctionEpochState account.
///    This account is a signer for the instruction. This account is
///    expected to be mutable
///
/// Returns an instruction
pub fn init_auction_epoch_state_account(
    program: &Program,
    // Seed Deps
    auction_id: u64,
    auction_epoch: u64,
    // Non-PDA Non-Seed Dep Accounts
    owner: Pubkey,
) -> Instruction {
    let (auction_epoch_state, auction_epoch_state_bump) = Pubkey::find_program_address(
        &[
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
        ],
        &program.id(),
    );
    let (auction_state_account, auction_state_account_bump) = Pubkey::find_program_address(
        &[
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::InitAuctionEpochStateInstruction {
                auction_epoch_state: auction_epoch_state,
                auction_state_account: auction_state_account,
                owner: owner,
                system_program: system_program::id(),
                rent: sysvar::rent::id()
            })
        .args(instruction::InitAuctionEpochStateInstruction {
                // Bumps
                auction_epoch_state_bump: auction_epoch_state_bump,
                auction_state_account_bump: auction_state_account_bump,
                // Seed Dependencies
                auction_id: auction_id,
                auction_epoch: auction_epoch,
            })
        .instructions()
        .expect("init_auction_epoch_state_account construction failed")
        .swap_remove(0)
}

/// This instruction initializes the retail traders account.
///
/// The retail data account tracks state specific
/// to the retail trader's trading activities on DFlow.
///
/// # Arguments
/// * `max_orders_supported` The maximum number of orders allowed to be active
///    at once by a retail trader
/// * `retail_data_account` 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
/// * `retail_account_owner` The public key of the retail trader. This account
///    is a signer for the instruction
///
/// Returns an instruction
pub fn init_retail_account(
    program: &Program,
    // Function Args
    max_orders_supported: u64,
    // Non-PDA Non-Seed Dep Accounts
    retail_data_account: Pubkey,
    retail_account_owner: Pubkey,
) -> Instruction {
    program
        .request()
        .accounts(
            accounts::InitRetailDataAccountInstruction {
                retail_data_account: retail_data_account,
                retail_account_owner: retail_account_owner
            })
        .args(instruction::InitRetailDataAccountInstruction {
                // Function Arguments
                max_orders_supported: max_orders_supported,
            })
        .instructions()
        .expect("init_retail_account construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `retail_data_account` 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
/// * `retail_account_owner` The public key of the retail trader. This account
///    is a signer for the instruction. This account is expected to
///    be mutable
///
/// Returns an instruction
pub fn close_retail_account(
    program: &Program,
    // Non-PDA Non-Seed Dep Accounts
    retail_data_account: Pubkey,
    retail_account_owner: Pubkey,
) -> Instruction {
    program
        .request()
        .accounts(
            accounts::CloseRetailDataAccount {
                retail_data_account: retail_data_account,
                retail_account_owner: retail_account_owner,
                system_program: system_program::id()
            })
        .args(instruction::CloseRetailDataAccount {
            })
        .instructions()
        .expect("close_retail_account construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `auction_id` An unsigned 64 bit integer. The auction ID used
///    as a seed to generate the program derived address
/// * `auction_epoch` An unsigned 64 bit integer. The integer epoch
///    used to generate the PDA of the auction epoch account
/// * `market_maker_data_account` The public key of the market_maker_data_account account.
/// * `market_maker_account_owner` The public key of the market_maker_account_owner account.
///
/// Returns an instruction
pub fn init_bid_record_account(
    program: &Program,
    // Seed Deps
    auction_id: u64,
    auction_epoch: u64,
    market_maker_data_account: Pubkey,
    market_maker_account_owner: Pubkey,
) -> Instruction {
    let (auction_state_account, auction_state_account_bump) = Pubkey::find_program_address(
        &[
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (auction_epoch_state, auction_epoch_state_bump) = Pubkey::find_program_address(
        &[
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
        ],
        &program.id(),
    );
    let (bid_record_account, bid_record_account_bump) = Pubkey::find_program_address(
        &[
            b"bid_record".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
            market_maker_data_account.as_ref(),
        ],
        &program.id(),
    );
    let (market_maker_whitelist_entry, market_maker_whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            market_maker_account_owner.as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::InitBidRecordAccount {
                auction_state_account: auction_state_account,
                auction_epoch_state: auction_epoch_state,
                bid_record_account: bid_record_account,
                market_maker_data_account: market_maker_data_account,
                market_maker_account_owner: market_maker_account_owner,
                market_maker_whitelist_entry: market_maker_whitelist_entry,
                system_program: system_program::id(),
                rent: sysvar::rent::id()
            })
        .args(instruction::InitBidRecordAccount {
                // Bumps
                auction_state_account_bump: auction_state_account_bump,
                auction_epoch_state_bump: auction_epoch_state_bump,
                bid_record_account_bump: bid_record_account_bump,
                market_maker_whitelist_entry_bump: market_maker_whitelist_entry_bump,
                // Seed Dependencies
                auction_id: auction_id,
                auction_epoch: auction_epoch,
            })
        .instructions()
        .expect("init_bid_record_account construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `auction_id` An unsigned 64 bit integer. The auction ID used
///    as a seed to generate the program derived address
/// * `auction_epoch` An unsigned 64 bit integer. The integer epoch
///    used to generate the PDA of the auction epoch account
/// * `next_auction_epoch` An unsigned 64 bit integer. The next auction epoch
///    number. If bidding in auction epoch N, this must be N + 1.
/// * `market_maker_data_account` The public key of the market_maker_data_account account.
/// * `market_maker_account_owner` The public key of the market_maker_account_owner account.
/// * `bid_size` The size of the bid being placed into the auction.
///    This number must strictly exceed the best bid in order for the
///    transaction to be executed.
/// * `market_maker_auction_token_account` The SPL token account associated with the market
///    maker used to bid in the auctions. This account is expected to
///    be mutable
///
/// Returns an instruction
pub fn submit_auction_bid(
    program: &Program,
    // Seed Deps
    auction_id: u64,
    auction_epoch: u64,
    next_auction_epoch: u64,
    market_maker_data_account: Pubkey,
    market_maker_account_owner: Pubkey,
    // Function Args
    bid_size: u64,
    // Non-PDA Non-Seed Dep Accounts
    market_maker_auction_token_account: Pubkey,
) -> Instruction {
    let (auction_state_account, auction_state_account_bump) = Pubkey::find_program_address(
        &[
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (auction_epoch_state, auction_epoch_state_bump) = Pubkey::find_program_address(
        &[
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
        ],
        &program.id(),
    );
    let (next_auction_epoch_state, next_auction_epoch_state_bump) = Pubkey::find_program_address(
        &[
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &next_auction_epoch.to_le_bytes(),
        ],
        &program.id(),
    );
    let (bid_vault_account, bid_vault_account_bump) = Pubkey::find_program_address(
        &[
            b"bid_vault".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (bid_record_account, bid_record_account_bump) = Pubkey::find_program_address(
        &[
            b"bid_record".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
            market_maker_data_account.as_ref(),
        ],
        &program.id(),
    );
    let (market_maker_whitelist_entry, market_maker_whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            market_maker_account_owner.as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::SubmitAuctionBidInstruction {
                auction_state_account: auction_state_account,
                auction_epoch_state: auction_epoch_state,
                next_auction_epoch_state: next_auction_epoch_state,
                bid_vault_account: bid_vault_account,
                market_maker_data_account: market_maker_data_account,
                market_maker_auction_token_account: market_maker_auction_token_account,
                bid_record_account: bid_record_account,
                market_maker_account_owner: market_maker_account_owner,
                market_maker_whitelist_entry: market_maker_whitelist_entry,
                token_program: spl_token::ID
            })
        .args(instruction::SubmitAuctionBidInstruction {
                // Bumps
                auction_state_account_bump: auction_state_account_bump,
                auction_epoch_state_bump: auction_epoch_state_bump,
                next_auction_epoch_state_bump: next_auction_epoch_state_bump,
                bid_vault_account_bump: bid_vault_account_bump,
                bid_record_account_bump: bid_record_account_bump,
                market_maker_whitelist_entry_bump: market_maker_whitelist_entry_bump,
                // Seed Dependencies
                auction_id: auction_id,
                auction_epoch: auction_epoch,
                next_auction_epoch: next_auction_epoch,
                // Function Arguments
                bid_size: bid_size,
            })
        .instructions()
        .expect("submit_auction_bid construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `auction_id` An unsigned 64 bit integer. The auction ID used
///    as a seed to generate the program derived address
/// * `auction_epoch` An unsigned 64 bit integer. The integer epoch
///    used to generate the PDA of the auction epoch account
/// * `market_maker_data_account` The public key of the market_maker_data_account account.
/// * `market_maker_account_owner` The public key of the market_maker_account_owner account.
/// * `market_maker_auction_token_account` The SPL token account associated with the market
///    maker used to bid in the auctions. This account is expected to
///    be mutable
///
/// Returns an instruction
pub fn reclaim_auction_bid(
    program: &Program,
    // Seed Deps
    auction_id: u64,
    auction_epoch: u64,
    market_maker_data_account: Pubkey,
    market_maker_account_owner: Pubkey,
    // Non-PDA Non-Seed Dep Accounts
    market_maker_auction_token_account: Pubkey,
) -> Instruction {
    let (auction_state_account, auction_state_account_bump) = Pubkey::find_program_address(
        &[
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (auction_epoch_state, auction_epoch_state_bump) = Pubkey::find_program_address(
        &[
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
        ],
        &program.id(),
    );
    let (bid_vault_account, bid_vault_account_bump) = Pubkey::find_program_address(
        &[
            b"bid_vault".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (bid_record_account, bid_record_account_bump) = Pubkey::find_program_address(
        &[
            b"bid_record".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
            market_maker_data_account.as_ref(),
        ],
        &program.id(),
    );
    let (market_maker_whitelist_entry, market_maker_whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            market_maker_account_owner.as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::ReclaimAuctionBidInstruction {
                auction_state_account: auction_state_account,
                auction_epoch_state: auction_epoch_state,
                bid_vault_account: bid_vault_account,
                market_maker_data_account: market_maker_data_account,
                market_maker_auction_token_account: market_maker_auction_token_account,
                bid_record_account: bid_record_account,
                market_maker_account_owner: market_maker_account_owner,
                market_maker_whitelist_entry: market_maker_whitelist_entry,
                token_program: spl_token::ID
            })
        .args(instruction::ReclaimAuctionBidInstruction {
                // Bumps
                auction_state_account_bump: auction_state_account_bump,
                auction_epoch_state_bump: auction_epoch_state_bump,
                bid_vault_account_bump: bid_vault_account_bump,
                bid_record_account_bump: bid_record_account_bump,
                market_maker_whitelist_entry_bump: market_maker_whitelist_entry_bump,
                // Seed Dependencies
                auction_id: auction_id,
                auction_epoch: auction_epoch,
            })
        .instructions()
        .expect("reclaim_auction_bid construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `retail_account_owner` The public key of the retail_account_owner account.
/// * `retail_data_account_nonce` The unsigned integer field named nonce in the
///    retail_data_account account. The nonce in the retail trader's
///    account used to generate a PDA for the vault token account. This
///    nonce must be saved and used when referencing this order in the
///    future.
/// * `auction_id` An unsigned 64 bit integer. The auction ID used
///    as a seed to generate the program derived address
/// * `auction_epoch` An unsigned 64 bit integer. The integer epoch
///    used to generate the PDA of the auction epoch account
/// * `previous_auction_epoch` An unsigned 64 bit integer. The previous epoch.
///    This must be equal to auction_epoch - 1.
/// * `signatory_server` The public key of the signatory_server account.
/// * `retail_encryption_pub_key` The retail trader's X25519 public key.
/// * `mm_encryption_pub_key` The market maker's X25519 public key.
/// * `encrypted_order_details` The ciphertext of the order details, encrypted
///    using a 24-byte nonce of zeros and the key derived from the market
///    maker's X25519 public key and the retail trader's X25519 private
///    key.
/// * `retail_signing_pub_key` The public key of the Ed25519 key pair that the
///    retail trader used to generate the signature.
/// * `retail_signature` The signature of the plaintext order details.
/// * `deposit_amount` The amount of tokens being sent by the retail
///    trader in the trade.
/// * `order_type` The order type, must be either 0 for limit or
///    1 for market. All other values result in a failed transaction.
/// * `retail_x_token_account` 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
/// * `rebate_receiver_token_account` 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.
/// * `retail_data_account` The retail data account holds state specific to
///    the retail trader. This account is expected to be mutable
/// * `market_maker_data_account` 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
/// * `x_mint` The SPL mint account associated with the token
///    that is sold by the retail trader during the swap.
/// * `price_oracles` These price oracles are the Pyth price accounts
///    associated with the products that could possibly be received
///    by the retail trader based on which token they are selling. For
///    example, if a retail trader is swapping X for some other token,
///    then the price oracles that must be passed here are all price
///    oracles which exist as a pair with X in this auction.
///
/// Returns an instruction
pub fn new_order(
    program: &Program,
    // Seed Deps
    retail_account_owner: Pubkey,
    retail_data_account_nonce: u64,
    auction_id: u64,
    auction_epoch: u64,
    previous_auction_epoch: u64,
    signatory_server: Pubkey,
    // Function Args
    retail_encryption_pub_key: [u8; 32],
    mm_encryption_pub_key: [u8; 32],
    encrypted_order_details: String,
    retail_signing_pub_key: [u8; 32],
    retail_signature: [u8; 64],
    deposit_amount: u64,
    order_type: u8,
    // Non-PDA Non-Seed Dep Accounts
    retail_x_token_account: Pubkey,
    rebate_receiver_token_account: Pubkey,
    retail_data_account: Pubkey,
    market_maker_data_account: Pubkey,
    x_mint: Pubkey,
    // Remaining Accounts
    price_oracles: Vec<Pubkey>,
) -> Instruction {
    let (vault_token_account, vault_token_account_bump) = Pubkey::find_program_address(
        &[
            retail_account_owner.as_ref(),
            b"vault".as_ref(),
            &retail_data_account_nonce.to_le_bytes(),
        ],
        &program.id(),
    );
    let (vault_meta_account, vault_meta_account_bump) = Pubkey::find_program_address(
        &[
            retail_account_owner.as_ref(),
            b"vault_meta".as_ref(),
            &retail_data_account_nonce.to_le_bytes(),
        ],
        &program.id(),
    );
    let (current_auction_epoch_state, current_auction_epoch_state_bump) = Pubkey::find_program_address(
        &[
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
        ],
        &program.id(),
    );
    let (previous_auction_epoch_state, previous_auction_epoch_state_bump) = Pubkey::find_program_address(
        &[
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &previous_auction_epoch.to_le_bytes(),
        ],
        &program.id(),
    );
    let (auction_state_account, auction_state_account_bump) = Pubkey::find_program_address(
        &[
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (signatory_record, signatory_record_bump) = Pubkey::find_program_address(
        &[
            signatory_server.as_ref(),
        ],
        &program.id(),
    );
    let mut remaining_accounts: Vec<AccountMeta> = Vec::new();
    remaining_accounts.extend(price_oracles.iter().map(|&x| AccountMeta {pubkey: x, is_signer: false, is_writable: false}));
    program
        .request()
        .accounts(
            accounts::NewOrderInstruction {
                vault_token_account: vault_token_account,
                vault_meta_account: vault_meta_account,
                current_auction_epoch_state: current_auction_epoch_state,
                previous_auction_epoch_state: previous_auction_epoch_state,
                retail_x_token_account: retail_x_token_account,
                rebate_receiver_token_account: rebate_receiver_token_account,
                auction_state_account: auction_state_account,
                retail_data_account: retail_data_account,
                market_maker_data_account: market_maker_data_account,
                retail_account_owner: retail_account_owner,
                x_mint: x_mint,
                signatory_record: signatory_record,
                signatory_server: signatory_server,
                token_program: spl_token::ID,
                system_program: system_program::id(),
                rent: sysvar::rent::id()
            })
        .accounts(remaining_accounts.to_account_metas(None))
        .args(instruction::NewOrderInstruction {
                // Bumps
                vault_token_account_bump: vault_token_account_bump,
                vault_meta_account_bump: vault_meta_account_bump,
                current_auction_epoch_state_bump: current_auction_epoch_state_bump,
                previous_auction_epoch_state_bump: previous_auction_epoch_state_bump,
                auction_state_account_bump: auction_state_account_bump,
                signatory_record_bump: signatory_record_bump,
                // Seed Dependencies
                auction_id: auction_id,
                auction_epoch: auction_epoch,
                previous_auction_epoch: previous_auction_epoch,
                // Function Arguments
                retail_encryption_pub_key: retail_encryption_pub_key,
                mm_encryption_pub_key: mm_encryption_pub_key,
                encrypted_order_details: encrypted_order_details,
                retail_signing_pub_key: retail_signing_pub_key,
                retail_signature: retail_signature,
                deposit_amount: deposit_amount,
                order_type: order_type,
            })
        .instructions()
        .expect("new_order construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `retail_account_owner` The public key of the retail_account_owner account.
/// * `nonce` 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.
/// * `vault_meta_account_auction_id` The unsigned integer field named auction_id in
///    the vault_meta_account account.
/// * `vault_meta_account_auction_epoch` The unsigned integer field named auction_epoch
///    in the vault_meta_account account.
/// * `retail_data_account` The retail data account holds state specific to
///    the retail trader. This account is expected to be mutable
/// * `market_maker_data_account` 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
/// * `retail_x_token_account` 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
/// * `x_mint` The SPL mint account associated with the token
///    that is sold by the retail trader during the swap.
///
/// Returns an instruction
pub fn cancel_order(
    program: &Program,
    // Seed Deps
    retail_account_owner: Pubkey,
    nonce: u64,
    vault_meta_account_auction_id: u64,
    vault_meta_account_auction_epoch: u64,
    // Non-PDA Non-Seed Dep Accounts
    retail_data_account: Pubkey,
    market_maker_data_account: Pubkey,
    retail_x_token_account: Pubkey,
    x_mint: Pubkey,
) -> Instruction {
    let (vault_token_account, vault_token_account_bump) = Pubkey::find_program_address(
        &[
            retail_account_owner.as_ref(),
            b"vault".as_ref(),
            &nonce.to_le_bytes(),
        ],
        &program.id(),
    );
    let (vault_meta_account, vault_meta_account_bump) = Pubkey::find_program_address(
        &[
            retail_account_owner.as_ref(),
            b"vault_meta".as_ref(),
            &nonce.to_le_bytes(),
        ],
        &program.id(),
    );
    let (auction_epoch_state, auction_epoch_state_bump) = Pubkey::find_program_address(
        &[
            b"epoch".as_ref(),
            &vault_meta_account_auction_id.to_le_bytes(),
            &vault_meta_account_auction_epoch.to_le_bytes(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::CancelOrderInstruction {
                vault_token_account: vault_token_account,
                vault_meta_account: vault_meta_account,
                auction_epoch_state: auction_epoch_state,
                retail_data_account: retail_data_account,
                market_maker_data_account: market_maker_data_account,
                retail_x_token_account: retail_x_token_account,
                retail_account_owner: retail_account_owner,
                x_mint: x_mint,
                token_program: spl_token::ID,
                system_program: system_program::id()
            })
        .args(instruction::CancelOrderInstruction {
                // Bumps
                vault_token_account_bump: vault_token_account_bump,
                vault_meta_account_bump: vault_meta_account_bump,
                auction_epoch_state_bump: auction_epoch_state_bump,
                // Seed Dependencies
                nonce: nonce,
            })
        .instructions()
        .expect("cancel_order construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `retail_account_owner` The public key of the retail_account_owner account.
/// * `nonce` 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.
/// * `vault_meta_account_fill_nonce` The unsigned integer field named fill_nonce in
///    the vault_meta_account account. The fill nonce taken from the
///    vault meta account at fill time, and used to generate the PDA
///    for the fill record account.
/// * `vault_meta_account_auction_id` The unsigned integer field named auction_id in
///    the vault_meta_account account.
/// * `vault_meta_account_auction_epoch` The unsigned integer field named auction_epoch
///    in the vault_meta_account account.
/// * `market_maker_account_owner` The public key of the market_maker_account_owner account.
/// * `y_mint` The public key of the y_mint account.
/// * `order_details` The unencrypted order details sent by the retail trader.
/// * `fill_amount` The fill amount, referring to the amount of tokens
///    to be received by the retail trader in the trade.
/// * `fill_price` The price, quoted in the quote currency for the
///    given pair, at which the fill is being completed.
/// * `retail_data_account` The retail data account holds state specific to
///    the retail trader. This account is expected to be mutable
/// * `market_maker_data_account` 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
/// * `x_mint` The SPL mint account associated with the token
///    that is sold by the retail trader during the swap.
/// * `market_maker_y_token_account` 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
/// * `retail_y_token_account` 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
/// * `is_y_token_account_uninitialized` True if and only if the retail trader's Y token
///    account is uninitialized
///
/// Returns an instruction
pub fn fill_order(
    program: &Program,
    // Seed Deps
    retail_account_owner: Pubkey,
    nonce: u64,
    vault_meta_account_fill_nonce: u16,
    vault_meta_account_auction_id: u64,
    vault_meta_account_auction_epoch: u64,
    market_maker_account_owner: Pubkey,
    y_mint: Pubkey,
    // Function Args
    order_details: String,
    fill_amount: u64,
    fill_price: u64,
    // Non-PDA Non-Seed Dep Accounts
    retail_data_account: Pubkey,
    market_maker_data_account: Pubkey,
    x_mint: Pubkey,
    market_maker_y_token_account: Pubkey,
    retail_y_token_account: Pubkey,
    // Optional Account Flags
    is_y_token_account_uninitialized: bool,
) -> Instruction {
    let (vault_meta_account, vault_meta_account_bump) = Pubkey::find_program_address(
        &[
            retail_account_owner.as_ref(),
            b"vault_meta".as_ref(),
            &nonce.to_le_bytes(),
        ],
        &program.id(),
    );
    let (fill_record_account, fill_record_account_bump) = Pubkey::find_program_address(
        &[
            vault_meta_account.as_ref(),
            &vault_meta_account_fill_nonce.to_le_bytes(),
            b"fra".as_ref(),
        ],
        &program.id(),
    );
    let (auction_epoch_state, auction_epoch_state_bump) = Pubkey::find_program_address(
        &[
            b"epoch".as_ref(),
            &vault_meta_account_auction_id.to_le_bytes(),
            &vault_meta_account_auction_epoch.to_le_bytes(),
        ],
        &program.id(),
    );
    let (auction_state_account, auction_state_account_bump) = Pubkey::find_program_address(
        &[
            b"auction_state".as_ref(),
            &vault_meta_account_auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (market_maker_whitelist_entry, market_maker_whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            market_maker_account_owner.as_ref(),
        ],
        &program.id(),
    );
    let (y_recovery_vault_account, y_recovery_vault_account_bump) = Pubkey::find_program_address(
        &[
            y_mint.as_ref(),
            b"recovery_vault".as_ref(),
        ],
        &program.id(),
    );
    let mut remaining_accounts: Vec<AccountMeta> = Vec::new();
    if is_y_token_account_uninitialized {
        remaining_accounts.push(AccountMeta {pubkey: y_recovery_vault_account, is_signer: false, is_writable: true});
    }
    program
        .request()
        .accounts(
            accounts::FillOrderInstruction {
                vault_meta_account: vault_meta_account,
                fill_record_account: fill_record_account,
                retail_data_account: retail_data_account,
                market_maker_data_account: market_maker_data_account,
                auction_epoch_state: auction_epoch_state,
                auction_state_account: auction_state_account,
                retail_account_owner: retail_account_owner,
                x_mint: x_mint,
                y_mint: y_mint,
                market_maker_y_token_account: market_maker_y_token_account,
                market_maker_account_owner: market_maker_account_owner,
                market_maker_whitelist_entry: market_maker_whitelist_entry,
                retail_y_token_account: retail_y_token_account,
                system_program: system_program::id(),
                rent: sysvar::rent::id(),
                token_program: spl_token::ID,
                instructions: sysvar::instructions::id()
            })
        .accounts(remaining_accounts.to_account_metas(None))
        .args(instruction::FillOrderInstruction {
                // Bumps
                vault_meta_account_bump: vault_meta_account_bump,
                fill_record_account_bump: fill_record_account_bump,
                auction_epoch_state_bump: auction_epoch_state_bump,
                auction_state_account_bump: auction_state_account_bump,
                market_maker_whitelist_entry_bump: market_maker_whitelist_entry_bump,
                y_recovery_vault_account_bump: y_recovery_vault_account_bump,
                // Seed Dependencies
                nonce: nonce,
                // Function Arguments
                order_details: order_details,
                fill_amount: fill_amount,
                fill_price: fill_price,
            })
        .instructions()
        .expect("fill_order construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `retail_account_owner` The public key of the retail_account_owner account.
/// * `nonce` 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.
/// * `fill_nonce` 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.
/// * `arbiter` The public key of the arbiter account.
/// * `vault_meta_account_auction_id` The unsigned integer field named auction_id in
///    the vault_meta_account account.
/// * `vote` The vote value made by the retail trader. Must
///    be populated with 0 for an unfair vote, and 1 for a fair vote.
/// * `arbiter_token_account` 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
///
/// Returns an instruction
pub fn fill_vote(
    program: &Program,
    // Seed Deps
    retail_account_owner: Pubkey,
    nonce: u64,
    fill_nonce: u16,
    arbiter: Pubkey,
    vault_meta_account_auction_id: u64,
    // Function Args
    vote: u8,
    // Non-PDA Non-Seed Dep Accounts
    arbiter_token_account: Pubkey,
) -> Instruction {
    let (vault_meta_account, vault_meta_account_bump) = Pubkey::find_program_address(
        &[
            retail_account_owner.as_ref(),
            b"vault_meta".as_ref(),
            &nonce.to_le_bytes(),
        ],
        &program.id(),
    );
    let (fill_record_account, fill_record_account_bump) = Pubkey::find_program_address(
        &[
            vault_meta_account.as_ref(),
            &fill_nonce.to_le_bytes(),
            b"fra".as_ref(),
        ],
        &program.id(),
    );
    let (vote_record_account, vote_record_account_bump) = Pubkey::find_program_address(
        &[
            fill_record_account.as_ref(),
            arbiter.as_ref(),
            b"vra".as_ref(),
        ],
        &program.id(),
    );
    let (auction_state_account, auction_state_account_bump) = Pubkey::find_program_address(
        &[
            b"auction_state".as_ref(),
            &vault_meta_account_auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (arbiter_whitelist_entry, arbiter_whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            arbiter.as_ref(),
        ],
        &program.id(),
    );
    let (vote_vault_account, vote_vault_account_bump) = Pubkey::find_program_address(
        &[
            b"vote_vault".as_ref(),
            &vault_meta_account_auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::FillVoteInstruction {
                vault_meta_account: vault_meta_account,
                fill_record_account: fill_record_account,
                vote_record_account: vote_record_account,
                auction_state_account: auction_state_account,
                arbiter: arbiter,
                arbiter_whitelist_entry: arbiter_whitelist_entry,
                retail_account_owner: retail_account_owner,
                arbiter_token_account: arbiter_token_account,
                vote_vault_account: vote_vault_account,
                system_program: system_program::id(),
                rent: sysvar::rent::id(),
                token_program: spl_token::ID
            })
        .args(instruction::FillVoteInstruction {
                // Bumps
                vault_meta_account_bump: vault_meta_account_bump,
                fill_record_account_bump: fill_record_account_bump,
                vote_record_account_bump: vote_record_account_bump,
                auction_state_account_bump: auction_state_account_bump,
                arbiter_whitelist_entry_bump: arbiter_whitelist_entry_bump,
                vote_vault_account_bump: vote_vault_account_bump,
                // Seed Dependencies
                nonce: nonce,
                fill_nonce: fill_nonce,
                // Function Arguments
                vote: vote,
            })
        .instructions()
        .expect("fill_vote construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `retail_account_owner` The public key of the retail_account_owner account.
/// * `nonce` 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.
/// * `fill_nonce` 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.
/// * `arbiter` The public key of the arbiter account.
/// * `vault_meta_account_auction_id` The unsigned integer field named auction_id in
///    the vault_meta_account account.
/// * `vault_meta_account_auction_epoch` The unsigned integer field named auction_epoch
///    in the vault_meta_account account.
/// * `arbiter_bid_token_account` 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
/// * `arbiter_token_account` 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
///
/// Returns an instruction
pub fn claim_vote_reward(
    program: &Program,
    // Seed Deps
    retail_account_owner: Pubkey,
    nonce: u64,
    fill_nonce: u16,
    arbiter: Pubkey,
    vault_meta_account_auction_id: u64,
    vault_meta_account_auction_epoch: u64,
    // Non-PDA Non-Seed Dep Accounts
    arbiter_bid_token_account: Pubkey,
    arbiter_token_account: Pubkey,
) -> Instruction {
    let (vault_meta_account, vault_meta_account_bump) = Pubkey::find_program_address(
        &[
            retail_account_owner.as_ref(),
            b"vault_meta".as_ref(),
            &nonce.to_le_bytes(),
        ],
        &program.id(),
    );
    let (fill_record_account, fill_record_account_bump) = Pubkey::find_program_address(
        &[
            vault_meta_account.as_ref(),
            &fill_nonce.to_le_bytes(),
            b"fra".as_ref(),
        ],
        &program.id(),
    );
    let (vote_record_account, vote_record_account_bump) = Pubkey::find_program_address(
        &[
            fill_record_account.as_ref(),
            arbiter.as_ref(),
            b"vra".as_ref(),
        ],
        &program.id(),
    );
    let (vote_vault_account, vote_vault_account_bump) = Pubkey::find_program_address(
        &[
            b"vote_vault".as_ref(),
            &vault_meta_account_auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (bid_vault_account, bid_vault_account_bump) = Pubkey::find_program_address(
        &[
            b"bid_vault".as_ref(),
            &vault_meta_account_auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (auction_state_account, auction_state_account_bump) = Pubkey::find_program_address(
        &[
            b"auction_state".as_ref(),
            &vault_meta_account_auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (auction_epoch_state, auction_epoch_state_bump) = Pubkey::find_program_address(
        &[
            b"epoch".as_ref(),
            &vault_meta_account_auction_id.to_le_bytes(),
            &vault_meta_account_auction_epoch.to_le_bytes(),
        ],
        &program.id(),
    );
    let (arbiter_whitelist_entry, arbiter_whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            arbiter.as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::ClaimVoteRewardInstruction {
                vault_meta_account: vault_meta_account,
                fill_record_account: fill_record_account,
                vote_record_account: vote_record_account,
                vote_vault_account: vote_vault_account,
                bid_vault_account: bid_vault_account,
                auction_state_account: auction_state_account,
                auction_epoch_state: auction_epoch_state,
                arbiter_bid_token_account: arbiter_bid_token_account,
                arbiter: arbiter,
                arbiter_whitelist_entry: arbiter_whitelist_entry,
                retail_account_owner: retail_account_owner,
                arbiter_token_account: arbiter_token_account,
                system_program: system_program::id(),
                token_program: spl_token::ID
            })
        .args(instruction::ClaimVoteRewardInstruction {
                // Bumps
                vault_meta_account_bump: vault_meta_account_bump,
                fill_record_account_bump: fill_record_account_bump,
                vote_record_account_bump: vote_record_account_bump,
                vote_vault_account_bump: vote_vault_account_bump,
                bid_vault_account_bump: bid_vault_account_bump,
                auction_state_account_bump: auction_state_account_bump,
                auction_epoch_state_bump: auction_epoch_state_bump,
                arbiter_whitelist_entry_bump: arbiter_whitelist_entry_bump,
                // Seed Dependencies
                nonce: nonce,
                fill_nonce: fill_nonce,
            })
        .instructions()
        .expect("claim_vote_reward construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `retail_account_owner` The public key of the retail_account_owner account.
/// * `nonce` 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.
/// * `fill_nonce` 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.
/// * `vault_meta_account_auction_id` The unsigned integer field named auction_id in
///    the vault_meta_account account.
/// * `vault_meta_account_auction_epoch` The unsigned integer field named auction_epoch
///    in the vault_meta_account account.
/// * `arbiter` The public key of the arbiter account.
/// * `auction_state_account_bid_mint` The public key field named bid_mint in the auction_state_account
///    account.
/// * `vault_token_account_mint` The public key field named mint in the vault_token_account
///    account.
/// * `market_maker_x_token_account` 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
/// * `retail_data_account` 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
/// * `market_maker_account_owner` The public key of the market maker. This account
///    is expected to be mutable
/// * `rebate_receiver_token_account` 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
/// * `is_rebate_receiver_token_account_uninitialized` True if and only if the rebate receiver token
///    account is uninitialized
/// * `is_x_token_account_uninitialized` True if and only if the market maker's X token
///    account is uninitialized
///
/// Returns an instruction
pub fn close_fill_accounts(
    program: &Program,
    // Seed Deps
    retail_account_owner: Pubkey,
    nonce: u64,
    fill_nonce: u16,
    vault_meta_account_auction_id: u64,
    vault_meta_account_auction_epoch: u64,
    arbiter: Pubkey,
    auction_state_account_bid_mint: Pubkey,
    vault_token_account_mint: Pubkey,
    // Non-PDA Non-Seed Dep Accounts
    market_maker_x_token_account: Pubkey,
    retail_data_account: Pubkey,
    market_maker_account_owner: Pubkey,
    rebate_receiver_token_account: Pubkey,
    // Optional Account Flags
    is_rebate_receiver_token_account_uninitialized: bool,
    is_x_token_account_uninitialized: bool,
) -> Instruction {
    let (vault_token_account, vault_token_account_bump) = Pubkey::find_program_address(
        &[
            retail_account_owner.as_ref(),
            b"vault".as_ref(),
            &nonce.to_le_bytes(),
        ],
        &program.id(),
    );
    let (vault_meta_account, vault_meta_account_bump) = Pubkey::find_program_address(
        &[
            retail_account_owner.as_ref(),
            b"vault_meta".as_ref(),
            &nonce.to_le_bytes(),
        ],
        &program.id(),
    );
    let (fill_record_account, fill_record_account_bump) = Pubkey::find_program_address(
        &[
            vault_meta_account.as_ref(),
            &fill_nonce.to_le_bytes(),
            b"fra".as_ref(),
        ],
        &program.id(),
    );
    let (bid_vault_account, bid_vault_account_bump) = Pubkey::find_program_address(
        &[
            b"bid_vault".as_ref(),
            &vault_meta_account_auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (auction_state_account, auction_state_account_bump) = Pubkey::find_program_address(
        &[
            b"auction_state".as_ref(),
            &vault_meta_account_auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    let (auction_epoch_state, auction_epoch_state_bump) = Pubkey::find_program_address(
        &[
            b"epoch".as_ref(),
            &vault_meta_account_auction_id.to_le_bytes(),
            &vault_meta_account_auction_epoch.to_le_bytes(),
        ],
        &program.id(),
    );
    let (arbiter_whitelist_entry, arbiter_whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            arbiter.as_ref(),
        ],
        &program.id(),
    );
    let (bid_recovery_vault_account, bid_recovery_vault_account_bump) = Pubkey::find_program_address(
        &[
            auction_state_account_bid_mint.as_ref(),
            b"recovery_vault".as_ref(),
        ],
        &program.id(),
    );
    let (x_recovery_vault_account, x_recovery_vault_account_bump) = Pubkey::find_program_address(
        &[
            vault_token_account_mint.as_ref(),
            b"recovery_vault".as_ref(),
        ],
        &program.id(),
    );
    let mut remaining_accounts: Vec<AccountMeta> = Vec::new();
    if is_rebate_receiver_token_account_uninitialized {
        remaining_accounts.push(AccountMeta {pubkey: bid_recovery_vault_account, is_signer: false, is_writable: true});
    }
    if is_x_token_account_uninitialized {
        remaining_accounts.push(AccountMeta {pubkey: x_recovery_vault_account, is_signer: false, is_writable: true});
    }
    program
        .request()
        .accounts(
            accounts::CloseFillAccounts {
                vault_token_account: vault_token_account,
                vault_meta_account: vault_meta_account,
                fill_record_account: fill_record_account,
                bid_vault_account: bid_vault_account,
                auction_state_account: auction_state_account,
                auction_epoch_state: auction_epoch_state,
                market_maker_x_token_account: market_maker_x_token_account,
                retail_data_account: retail_data_account,
                market_maker_account_owner: market_maker_account_owner,
                arbiter: arbiter,
                arbiter_whitelist_entry: arbiter_whitelist_entry,
                retail_account_owner: retail_account_owner,
                rebate_receiver_token_account: rebate_receiver_token_account,
                token_program: spl_token::ID,
                system_program: system_program::id()
            })
        .accounts(remaining_accounts.to_account_metas(None))
        .args(instruction::CloseFillAccounts {
                // Bumps
                vault_token_account_bump: vault_token_account_bump,
                vault_meta_account_bump: vault_meta_account_bump,
                fill_record_account_bump: fill_record_account_bump,
                bid_vault_account_bump: bid_vault_account_bump,
                auction_state_account_bump: auction_state_account_bump,
                auction_epoch_state_bump: auction_epoch_state_bump,
                arbiter_whitelist_entry_bump: arbiter_whitelist_entry_bump,
                bid_recovery_vault_account_bump: bid_recovery_vault_account_bump,
                x_recovery_vault_account_bump: x_recovery_vault_account_bump,
                // Seed Dependencies
                nonce: nonce,
                fill_nonce: fill_nonce,
            })
        .instructions()
        .expect("close_fill_accounts construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `signatory_stake_mint` The SPL mint account associated with the token
///    that is staked by the signatory server.
/// * `dflow_admin` The public key of the DFlow admin. This account
///    is a signer for the instruction. This account is expected to
///    be mutable
///
/// Returns an instruction
pub fn init_signatory_system(
    program: &Program,
    // Non-PDA Non-Seed Dep Accounts
    signatory_stake_mint: Pubkey,
    dflow_admin: Pubkey,
) -> Instruction {
    let (global_config_account, global_config_account_bump) = Pubkey::find_program_address(
        &[
            b"global_config".as_ref(),
        ],
        &program.id(),
    );
    let (signatory_state, signatory_state_bump) = Pubkey::find_program_address(
        &[
            b"sigstate".as_ref(),
        ],
        &program.id(),
    );
    let (signatory_stake_vault, signatory_stake_vault_bump) = Pubkey::find_program_address(
        &[
            b"sigstake".as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::InitSignatorySystem {
                global_config_account: global_config_account,
                signatory_state: signatory_state,
                signatory_stake_vault: signatory_stake_vault,
                signatory_stake_mint: signatory_stake_mint,
                dflow_admin: dflow_admin,
                system_program: system_program::id(),
                rent: sysvar::rent::id(),
                token_program: spl_token::ID
            })
        .args(instruction::InitSignatorySystem {
                // Bumps
                global_config_account_bump: global_config_account_bump,
                signatory_state_bump: signatory_state_bump,
                signatory_stake_vault_bump: signatory_stake_vault_bump,
            })
        .instructions()
        .expect("init_signatory_system construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `signatory_server` The public key of the signatory_server account.
/// * `signatory_server_token_account` The signatory server's token account used for
///    originating the stake transfer. This account is expected to be
///    mutable
///
/// Returns an instruction
pub fn create_signatory(
    program: &Program,
    // Seed Deps
    signatory_server: Pubkey,
    // Non-PDA Non-Seed Dep Accounts
    signatory_server_token_account: Pubkey,
) -> Instruction {
    let (signatory_record, signatory_record_bump) = Pubkey::find_program_address(
        &[
            signatory_server.as_ref(),
        ],
        &program.id(),
    );
    let (signatory_stake_vault, signatory_stake_vault_bump) = Pubkey::find_program_address(
        &[
            b"sigstake".as_ref(),
        ],
        &program.id(),
    );
    let (signatory_server_whitelist_entry, signatory_server_whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            signatory_server.as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::CreateSignatory {
                signatory_record: signatory_record,
                signatory_stake_vault: signatory_stake_vault,
                signatory_server_token_account: signatory_server_token_account,
                signatory_server: signatory_server,
                signatory_server_whitelist_entry: signatory_server_whitelist_entry,
                system_program: system_program::id(),
                rent: sysvar::rent::id(),
                token_program: spl_token::ID
            })
        .args(instruction::CreateSignatory {
                // Bumps
                signatory_record_bump: signatory_record_bump,
                signatory_stake_vault_bump: signatory_stake_vault_bump,
                signatory_server_whitelist_entry_bump: signatory_server_whitelist_entry_bump,
            })
        .instructions()
        .expect("create_signatory construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `signatory_server` The public key of the signatory_server account.
/// * `stake_size` The amount of signatory 'stake mint' tokens to stake
/// * `signatory_server_token_account` The signatory server's token account used for
///    originating the stake transfer. This account is expected to be
///    mutable
///
/// Returns an instruction
pub fn stake_signatory(
    program: &Program,
    // Seed Deps
    signatory_server: Pubkey,
    // Function Args
    stake_size: u64,
    // Non-PDA Non-Seed Dep Accounts
    signatory_server_token_account: Pubkey,
) -> Instruction {
    let (signatory_record, signatory_record_bump) = Pubkey::find_program_address(
        &[
            signatory_server.as_ref(),
        ],
        &program.id(),
    );
    let (signatory_stake_vault, signatory_stake_vault_bump) = Pubkey::find_program_address(
        &[
            b"sigstake".as_ref(),
        ],
        &program.id(),
    );
    let (signatory_server_whitelist_entry, signatory_server_whitelist_entry_bump) = Pubkey::find_program_address(
        &[
            b"whitelist_entry".as_ref(),
            signatory_server.as_ref(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::StakeSignatory {
                signatory_record: signatory_record,
                signatory_stake_vault: signatory_stake_vault,
                signatory_server_token_account: signatory_server_token_account,
                signatory_server: signatory_server,
                signatory_server_whitelist_entry: signatory_server_whitelist_entry,
                token_program: spl_token::ID
            })
        .args(instruction::StakeSignatory {
                // Bumps
                signatory_record_bump: signatory_record_bump,
                signatory_stake_vault_bump: signatory_stake_vault_bump,
                signatory_server_whitelist_entry_bump: signatory_server_whitelist_entry_bump,
                // Function Arguments
                stake_size: stake_size,
            })
        .instructions()
        .expect("stake_signatory construction failed")
        .swap_remove(0)
}

/// 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.
///
/// # Arguments
/// * `auction_id` An unsigned 64 bit integer. The auction ID used
///    as a seed to generate the program derived address
/// * `auction_epoch` An unsigned 64 bit integer. The integer epoch
///    used to generate the PDA of the auction epoch account
/// * `owner` 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
///
/// Returns an instruction
pub fn close_auction_epoch_state(
    program: &Program,
    // Seed Deps
    auction_id: u64,
    auction_epoch: u64,
    // Non-PDA Non-Seed Dep Accounts
    owner: Pubkey,
) -> Instruction {
    let (auction_epoch_state, auction_epoch_state_bump) = Pubkey::find_program_address(
        &[
            b"epoch".as_ref(),
            &auction_id.to_le_bytes(),
            &auction_epoch.to_le_bytes(),
        ],
        &program.id(),
    );
    let (auction_state_account, auction_state_account_bump) = Pubkey::find_program_address(
        &[
            b"auction_state".as_ref(),
            &auction_id.to_le_bytes(),
        ],
        &program.id(),
    );
    program
        .request()
        .accounts(
            accounts::CloseAuctionEpochState {
                auction_epoch_state: auction_epoch_state,
                auction_state_account: auction_state_account,
                owner: owner,
                system_program: system_program::id()
            })
        .args(instruction::CloseAuctionEpochState {
                // Bumps
                auction_epoch_state_bump: auction_epoch_state_bump,
                auction_state_account_bump: auction_state_account_bump,
                // Seed Dependencies
                auction_id: auction_id,
                auction_epoch: auction_epoch,
            })
        .instructions()
        .expect("close_auction_epoch_state construction failed")
        .swap_remove(0)
}