Fix paddings

program/Cargo.toml

@@ -18,7 +18,7 @@ utils = []
 benchmarking = ["bonfida-utils/benchmarking"]
 
 [dependencies]
-solana-program = "1.8.0"
+solana-program = "1.18.17"
 bytemuck = {version = "1.7.2", features= ["derive"]}
 num_enum = "0.5.4"
 borsh = "0.9.1"
@@ -31,18 +31,17 @@ bonfida-utils = "0.3.1"
 
 [dev-dependencies]
 hexdump = "0.1.0"
-solana-sdk = "1.8.0"
+solana-sdk = "1.18.17"
 rand = "0.8.4"
 arrayref = "0.3.6"
-solana-program-test = "1.8.0"
+solana-program-test = "1.18.17"
 tokio = {version="1.6", features = ["macros"]}
 regex = "1.5.5"
 gnuplot = "0.0.37"
 lazy_static = "1.4.0"
 serde = "1"
 serde_json = "1"
-
-
+anchor-lang = "0.30.1"
 
 [lib]
 crate-type = ["cdylib", "lib"]

program/src/instruction.rs

@@ -9,6 +9,7 @@ use bonfida_utils::{BorshSize, InstructionsAccount};
 
 pub use crate::processor::{
     cancel_order, close_market, consume_events, create_market, mass_cancel_orders, new_order,
+    pause_matching, resume_matching,
 };
 #[derive(BorshDeserialize, BorshSerialize, FromPrimitive)]
 /// Describes all possible instructions and their required accounts
@@ -88,6 +89,28 @@ pub enum AgnosticOrderbookInstruction {
     /// | 3     | ✅       | ❌     | The asks account        |
     /// | 4     | ❌       | ✅     | The caller authority    |
     MassCancelOrders,
+    /// Pause the matching engine.
+    ///
+    /// Required accounts
+    ///
+    /// | index | writable | signer   | description                 |
+    /// |-------|----------|----------|-----------------------------|
+    /// | 0     | ✅        | ❌      | The market account          |
+    PauseMatching,
+    /// Resume matching on the order book
+    ///
+    /// The instruction will proceed to match all crossing orders currently extant on the book
+    ///
+    /// Required accounts
+    ///
+    ///
+    /// | index | writable | signer | description             |
+    /// |-------|----------|--------|-------------------------|
+    /// | 0     | ✅       | ❌     | The market account      |
+    /// | 1     | ✅       | ❌     | The event queue account |
+    /// | 2     | ✅       | ❌     | The bids account        |
+    /// | 3     | ✅       | ❌     | The asks account        |
+    ResumeMatching,
 }
 
 /**
@@ -225,3 +248,42 @@ pub fn mass_cancel_orders(
     });
     i
 }
+
+/// Pause the matching engine.
+pub fn pause_matching(
+    accounts: pause_matching::Accounts<Pubkey>,
+    register_account: Pubkey,
+    params: pause_matching::Params,
+) -> Instruction {
+    let mut i = accounts.get_instruction(
+        crate::id(),
+        AgnosticOrderbookInstruction::PauseMatching as u8,
+        params,
+    );
+
+    i.accounts.push(AccountMeta {
+        pubkey: register_account,
+        is_signer: false,
+        is_writable: true,
+    });
+    i
+}
+/// Pause the matching engine.
+pub fn resume_matching(
+    accounts: resume_matching::Accounts<Pubkey>,
+    register_account: Pubkey,
+    params: resume_matching::Params,
+) -> Instruction {
+    let mut i = accounts.get_instruction(
+        crate::id(),
+        AgnosticOrderbookInstruction::ResumeMatching as u8,
+        params,
+    );
+
+    i.accounts.push(AccountMeta {
+        pubkey: register_account,
+        is_signer: false,
+        is_writable: true,
+    });
+    i
+}

program/src/processor.rs

@@ -15,6 +15,8 @@ pub mod consume_events;
 pub mod create_market;
 pub mod mass_cancel_orders;
 pub mod new_order;
+pub mod pause_matching;
+pub mod resume_matching;
 
 pub fn process_instruction<C: Pod + BorshDeserialize + CallbackInfo + PartialEq>(
     program_id: &Pubkey,
@@ -71,6 +73,16 @@ where
                 .map_err(|_| ProgramError::InvalidInstructionData)?;
             return mass_cancel_orders::process::<C>(program_id, accounts, params).map(Some);
         }
+        AgnosticOrderbookInstruction::PauseMatching => {
+            msg!("Instruction: Pause Matching");
+            let accounts = pause_matching::Accounts::parse(accounts)?;
+            pause_matching::process::<C>(program_id, accounts, pause_matching::Params {})?;
+        }
+        AgnosticOrderbookInstruction::ResumeMatching => {
+            msg!("Instruction: Resume Matching");
+            let accounts = resume_matching::Accounts::parse(accounts)?;
+            resume_matching::process::<C>(program_id, accounts, resume_matching::Params {})?;
+        }
     }
     Ok(None)
 }

program/src/processor/cancel_order.rs

@@ -92,7 +92,8 @@ where
 
     let mut order_book = OrderBookState::<C>::new_safe(&mut bids_guard, &mut asks_guard)?;
 
-    let slab = order_book.get_tree(get_side_from_order_id(params.order_id));
+    let side = get_side_from_order_id(params.order_id);
+    let slab = order_book.get_tree(side);
     let (leaf_node, _) = slab
         .remove_by_key(params.order_id)
         .ok_or(AoError::OrderNotFound)?;

program/src/processor/create_market.rs

@@ -97,13 +97,13 @@ pub fn process<'a, 'b: 'a, C: Pod>(
     MarketState::check_buffer_size(&market_data)?;
     let market_state = MarketState::from_buffer(&mut market_data, AccountTag::Uninitialized)?;
 
-    *market_state = MarketState {
-        event_queue: *accounts.event_queue.key,
-        bids: *accounts.bids.key,
-        asks: *accounts.asks.key,
+    *market_state = MarketState::init_new(
+        accounts.event_queue.key,
+        accounts.bids.key,
+        accounts.asks.key,
         min_base_order_size,
         tick_size,
-    };
+    );
 
     let mut event_queue_data = accounts.event_queue.data.borrow_mut();
 

program/src/processor/new_order.rs

@@ -148,8 +148,14 @@ where
     let mut event_queue_guard = accounts.event_queue.data.borrow_mut();
     let mut event_queue = EventQueue::from_buffer(&mut event_queue_guard, AccountTag::EventQueue)?;
 
-    let order_summary =
-        order_book.new_order(params, &mut event_queue, market_state.min_base_order_size)?;
+    let order_summary = match market_state.pause_matching == 0 {
+        true => order_book.new_order(params, &mut event_queue, market_state.min_base_order_size)?,
+        false => order_book.insert_without_matching(
+            params,
+            &mut event_queue,
+            market_state.min_base_order_size,
+        )?,
+    };
     msg!("Order summary : {:?}", order_summary);
 
     Ok(order_summary)

program/src/processor/pause_matching.rs

@@ -0,0 +1,67 @@
+//! Close an existing market.
+use crate::{
+    error::AoError,
+    state::{market_state::MarketState, orderbook::CallbackInfo, AccountTag},
+    utils::check_account_owner,
+};
+use bonfida_utils::{BorshSize, InstructionsAccount};
+use borsh::{BorshDeserialize, BorshSerialize};
+use bytemuck::Pod;
+use solana_program::{
+    account_info::{next_account_info, AccountInfo},
+    entrypoint::ProgramResult,
+    program_error::ProgramError,
+    pubkey::Pubkey,
+};
+
+#[derive(BorshDeserialize, BorshSerialize, BorshSize)]
+/**
+The required arguments for a close_market instruction.
+*/
+pub struct Params {}
+
+/// The required accounts for a close_market instruction.
+#[derive(InstructionsAccount)]
+pub struct Accounts<'a, T> {
+    #[allow(missing_docs)]
+    #[cons(writable)]
+    pub market: &'a T,
+}
+
+impl<'a, 'b: 'a> Accounts<'a, AccountInfo<'b>> {
+    pub(crate) fn parse(accounts: &'a [AccountInfo<'b>]) -> Result<Self, ProgramError> {
+        let accounts_iter = &mut accounts.iter();
+
+        let a = Self {
+            market: next_account_info(accounts_iter)?,
+        };
+        Ok(a)
+    }
+
+    pub(crate) fn perform_checks(&self, program_id: &Pubkey) -> Result<(), ProgramError> {
+        check_account_owner(
+            self.market,
+            &program_id.to_bytes(),
+            AoError::WrongMarketOwner,
+        )?;
+        Ok(())
+    }
+}
+/// Apply the close_market instruction to the provided accounts
+pub fn process<'a, 'b: 'a, C: CallbackInfo + PartialEq + Pod>(
+    program_id: &Pubkey,
+    accounts: Accounts<'a, AccountInfo<'b>>,
+    _params: Params,
+) -> ProgramResult
+where
+    <C as CallbackInfo>::CallbackId: PartialEq,
+{
+    accounts.perform_checks(program_id)?;
+    let mut market_data = accounts.market.data.borrow_mut();
+    let market_state = MarketState::from_buffer(&mut market_data, AccountTag::Market)?;
+
+    // bytemuck does not like boolean values
+    market_state.pause_matching = true as u8;
+
+    Ok(())
+}

program/src/processor/resume_matching.rs

@@ -0,0 +1,128 @@
+//! Execute a new order on the orderbook
+
+use bonfida_utils::{BorshSize, InstructionsAccount};
+use borsh::{BorshDeserialize, BorshSerialize};
+use bytemuck::Pod;
+use solana_program::{
+    account_info::{next_account_info, AccountInfo},
+    entrypoint::ProgramResult,
+    msg,
+    program_error::ProgramError,
+    pubkey::Pubkey,
+};
+
+use crate::{
+    error::AoError,
+    state::{
+        event_queue::EventQueue,
+        market_state::MarketState,
+        orderbook::{CallbackInfo, OrderBookState},
+        AccountTag,
+    },
+    utils::{check_account_key, check_account_owner},
+};
+
+#[derive(BorshDeserialize, BorshSerialize, BorshSize)]
+/**
+The required arguments for a new_order instruction.
+*/
+pub struct Params {}
+
+/// The required accounts for a new_order instruction.
+#[derive(InstructionsAccount)]
+pub struct Accounts<'a, T> {
+    #[allow(missing_docs)]
+    pub market: &'a T,
+    #[allow(missing_docs)]
+    #[cons(writable)]
+    pub event_queue: &'a T,
+    #[allow(missing_docs)]
+    #[cons(writable)]
+    pub bids: &'a T,
+    #[allow(missing_docs)]
+    #[cons(writable)]
+    pub asks: &'a T,
+}
+
+impl<'a, 'b: 'a> Accounts<'a, AccountInfo<'b>> {
+    pub(crate) fn parse(accounts: &'a [AccountInfo<'b>]) -> Result<Self, ProgramError> {
+        let accounts_iter = &mut accounts.iter();
+
+        let a = Self {
+            market: next_account_info(accounts_iter)?,
+            event_queue: next_account_info(accounts_iter)?,
+            bids: next_account_info(accounts_iter)?,
+            asks: next_account_info(accounts_iter)?,
+        };
+        Ok(a)
+    }
+    pub(crate) fn perform_checks(&self, program_id: &Pubkey) -> Result<(), ProgramError> {
+        check_account_owner(
+            self.market,
+            &program_id.to_bytes(),
+            AoError::WrongMarketOwner,
+        )?;
+        check_account_owner(
+            self.event_queue,
+            &program_id.to_bytes(),
+            AoError::WrongEventQueueOwner,
+        )?;
+        check_account_owner(self.bids, &program_id.to_bytes(), AoError::WrongBidsOwner)?;
+        check_account_owner(self.asks, &program_id.to_bytes(), AoError::WrongAsksOwner)?;
+        Ok(())
+    }
+}
+
+/// Apply the new_order instruction to the provided accounts
+pub fn process<'a, 'b: 'a, C: Pod + CallbackInfo + PartialEq>(
+    program_id: &Pubkey,
+    accounts: Accounts<'a, AccountInfo<'b>>,
+    _params: Params,
+) -> ProgramResult
+where
+    <C as CallbackInfo>::CallbackId: PartialEq,
+{
+    accounts.perform_checks(program_id)?;
+    let mut market_data = accounts.market.data.borrow_mut();
+    let market_state = MarketState::from_buffer(&mut market_data, AccountTag::Market)?;
+
+    check_accounts(&accounts, market_state)?;
+
+    let mut bids_guard = accounts.bids.data.borrow_mut();
+    let mut asks_guard = accounts.asks.data.borrow_mut();
+
+    let mut order_book = OrderBookState::<C>::new_safe(&mut bids_guard, &mut asks_guard)?;
+
+    let mut event_queue_guard = accounts.event_queue.data.borrow_mut();
+    let mut event_queue =
+        EventQueue::<C>::from_buffer(&mut event_queue_guard, AccountTag::EventQueue)?;
+
+    match order_book.match_existing_orders(&mut event_queue, market_state.min_base_order_size) {
+        Ok(completed) => {
+            if completed {
+                msg!("All sitting orders have been filled. Regular mathcing behavior resumed.");
+                market_state.pause_matching = false as u8;
+            } else {
+                msg!("Unmatched orders remain. Please run this instruction again to clear them before resuming regular behavior.");
+            }
+
+            Ok(())
+        }
+        Err(e) => Err(e.into()),
+    }
+}
+
+fn check_accounts<'a, 'b: 'a>(
+    accounts: &Accounts<'a, AccountInfo<'b>>,
+    market_state: &MarketState,
+) -> ProgramResult {
+    check_account_key(
+        accounts.event_queue,
+        &market_state.event_queue,
+        AoError::WrongEventQueueAccount,
+    )?;
+    check_account_key(accounts.bids, &market_state.bids, AoError::WrongBidsAccount)?;
+    check_account_key(accounts.asks, &market_state.asks, AoError::WrongAsksAccount)?;
+
+    Ok(())
+}