Add CloseMarket function to redeem rent from permissioned markets

.gitignore

@@ -6,4 +6,8 @@ target/
 *.swo
 node_modules
 yarn.lock
-.anchor
+.anchor
+.DS_Store
+**/*.rs.bk
+close-markets/Cargo.lock
+close-markets/package-lock.json

dex/src/critbit.rs

@@ -252,13 +252,13 @@ const_assert_eq!(_NODE_ALIGN, align_of::<AnyNode>());
 
 #[derive(Copy, Clone)]
 #[repr(packed)]
-struct SlabHeader {
+pub struct SlabHeader {
     bump_index: u64,
     free_list_len: u64,
     free_list_head: u32,
 
     root_node: u32,
-    leaf_count: u64,
+    pub leaf_count: u64,
 }
 unsafe impl Zeroable for SlabHeader {}
 unsafe impl Pod for SlabHeader {}
@@ -347,7 +347,7 @@ impl Slab {
         (header, nodes)
     }
 
-    fn header(&self) -> &SlabHeader {
+    pub fn header(&self) -> &SlabHeader {
         self.parts().0
     }
 

dex/src/error.rs

@@ -112,6 +112,11 @@ pub enum DexErrorCode {
     WouldSelfTrade,
     InvalidOpenOrdersAuthority,
 
+    BidQueueNotEmpty,
+    AskQueueNotEmpty,
+    RequestQueueNotEmpty,
+    EventQueueNotEmpty,
+
     Unknown = 1000,
 
     // This contains the line number in the lower 16 bits,

dex/src/instruction.rs

@@ -467,6 +467,16 @@ pub enum MarketInstruction {
     /// accounts.len() - 2 `[writable]` event queue
     /// accounts.len() - 1 `[signer]` crank authority
     ConsumeEventsPermissioned(u16),
+    /// Closes a market and retrieves the rent from the bids, asks, event and request queues
+    ///
+    /// 0. `[writable]` market
+    /// 1. `[writable]` request queue
+    /// 2. `[writable]` event queue
+    /// 3. `[writable]` bids
+    /// 4. `[writable]` asks
+    /// 5. `[signer]` prune authority
+    /// 6. `[writable]` the destination account to send the rent exemption SOL to.
+    CloseMarket,
 }
 
 impl MarketInstruction {
@@ -568,6 +578,7 @@ impl MarketInstruction {
                 let limit = array_ref![data, 0, 2];
                 MarketInstruction::ConsumeEventsPermissioned(u16::from_le_bytes(*limit))
             }
+            (18, 0) => MarketInstruction::CloseMarket,
             _ => return None,
         })
     }
@@ -1003,6 +1014,33 @@ pub fn prune(
     })
 }
 
+pub fn close_market(
+    program_id: &Pubkey,
+    market: &Pubkey,
+    request_queue: &Pubkey,
+    event_queue: &Pubkey,
+    bids: &Pubkey,
+    asks: &Pubkey,
+    prune_authority: &Pubkey,
+    destination: &Pubkey,
+) -> Result<Instruction, DexError> {
+    let data = MarketInstruction::CloseMarket.pack();
+    let accounts: Vec<AccountMeta> = vec![
+        AccountMeta::new(*market, false),
+        AccountMeta::new(*request_queue, false),
+        AccountMeta::new(*event_queue, false),
+        AccountMeta::new(*bids, false),
+        AccountMeta::new(*asks, false),
+        AccountMeta::new_readonly(*prune_authority, true),
+        AccountMeta::new(*destination, false),
+    ];
+    Ok(Instruction {
+        program_id: *program_id,
+        data,
+        accounts,
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

dex/src/state.rs

@@ -752,7 +752,7 @@ pub trait QueueHeader: Pod {
 }
 
 pub struct Queue<'a, H: QueueHeader> {
-    header: RefMut<'a, H>,
+    pub header: RefMut<'a, H>,
     buf: RefMut<'a, [H::Item]>,
 }
 
@@ -2418,6 +2418,72 @@ pub(crate) mod account_parser {
             f(args)
         }
     }
+
+    pub struct CloseMarketArgs<'a, 'b: 'a> {
+        pub market: &'a mut MarketState,
+        pub request_q_acc: &'a AccountInfo<'b>,
+        pub event_q_acc: &'a AccountInfo<'b>,
+        pub bids_acc: &'a AccountInfo<'b>,
+        pub asks_acc: &'a AccountInfo<'b>,
+        pub dest_acc: &'a AccountInfo<'b>,
+    }
+
+    impl<'a, 'b: 'a> CloseMarketArgs<'a, 'b> {
+        pub fn with_parsed_args<T>(
+            program_id: &'a Pubkey,
+            accounts: &'a [AccountInfo<'b>],
+            f: impl FnOnce(CloseMarketArgs) -> DexResult<T>,
+        ) -> DexResult<T> {
+            // Parse accounts.
+            check_assert_eq!(accounts.len(), 7)?;
+            #[rustfmt::skip]
+            let &[
+                ref market_acc,
+                ref request_q_acc,
+                ref event_q_acc,
+                ref bids_acc,
+                ref asks_acc,
+                ref prune_auth_acc,
+                ref dest_acc,
+            ] = array_ref![accounts, 0, 7];
+
+            // Validate prune authority.
+            let _prune_authority = SignerAccount::new(prune_auth_acc)?;
+            let mut market = Market::load(market_acc, program_id, false)?;
+            check_assert!(market.prune_authority() == Some(prune_auth_acc.key))?;
+
+            // Check that request q, event q, bids and asks are completely cleared and empty
+            let bids = market.load_bids_mut(bids_acc).or(check_unreachable!())?;
+            let asks = market.load_asks_mut(asks_acc).or(check_unreachable!())?;
+            let req_q = market.load_request_queue_mut(request_q_acc)?;
+            let event_q = market.load_event_queue_mut(event_q_acc)?;
+
+            let bids_header = bids.header();
+            if bids_header.leaf_count != 0 {
+                return Err(DexErrorCode::BidQueueNotEmpty.into());
+            }
+            let asks_header = asks.header();
+            if asks_header.leaf_count != 0 {
+                return Err(DexErrorCode::AskQueueNotEmpty.into());
+            }
+            if req_q.header.count != 0 {
+                return Err(DexErrorCode::RequestQueueNotEmpty.into());
+            }
+            if event_q.header.count != 0 {
+                return Err(DexErrorCode::EventQueueNotEmpty.into());
+            }
+
+            // Invoke Processor
+            f(CloseMarketArgs {
+                market: market.deref_mut(),
+                request_q_acc,
+                event_q_acc,
+                bids_acc,
+                asks_acc,
+                dest_acc,
+            })
+        }
+    }
 }
 
 #[inline]
@@ -2541,6 +2607,11 @@ impl State {
                 limit,
                 Self::process_prune,
             )?,
+            MarketInstruction::CloseMarket => account_parser::CloseMarketArgs::with_parsed_args(
+                program_id,
+                accounts,
+                Self::process_close_market,
+            )?,
         };
         Ok(())
     }
@@ -2550,6 +2621,37 @@ impl State {
         unimplemented!()
     }
 
+    fn process_close_market(args: account_parser::CloseMarketArgs) -> DexResult {
+        let account_parser::CloseMarketArgs {
+            market,
+            request_q_acc,
+            event_q_acc,
+            bids_acc,
+            asks_acc,
+            dest_acc,
+        } = args;
+
+        // Transfer all lamports to the desintation.
+        let dest_starting_lamports = dest_acc.lamports();
+        **dest_acc.lamports.borrow_mut() = dest_starting_lamports
+            .checked_add(request_q_acc.lamports())
+            .unwrap()
+            .checked_add(event_q_acc.lamports())
+            .unwrap()
+            .checked_add(bids_acc.lamports())
+            .unwrap()
+            .checked_add(asks_acc.lamports())
+            .unwrap();
+        **request_q_acc.lamports.borrow_mut() = 0;
+        **event_q_acc.lamports.borrow_mut() = 0;
+        **bids_acc.lamports.borrow_mut() = 0;
+        **asks_acc.lamports.borrow_mut() = 0;
+
+        market.account_flags = market.account_flags | (AccountFlag::Disabled as u64);
+
+        Ok(())
+    }
+
     fn process_prune(args: account_parser::PruneArgs) -> DexResult {
         let account_parser::PruneArgs {
             mut order_book_state,

dex/tests/close-markets/Anchor.toml

@@ -0,0 +1,19 @@
+[programs.localnet]
+close_markets = "Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS"
+
+[test]
+startup_wait = 20000
+
+[registry]
+url = "https://anchor.projectserum.com"
+
+[provider]
+cluster = "localnet"
+wallet = "~/.config/solana/id.json"
+
+[[test.genesis]]
+address = "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin"
+program = "../../target/deploy/serum_dex.so"
+
+[scripts]
+test = "yarn run ts-mocha -p ./tsconfig.json -t 1000000 tests/**/*.ts"

dex/tests/close-markets/Cargo.toml

@@ -0,0 +1,4 @@
+[workspace]
+members = [
+    "programs/*"
+]

dex/tests/close-markets/migrations/deploy.ts

@@ -0,0 +1,12 @@
+// Migrations are an early feature. Currently, they're nothing more than this
+// single deploy script that's invoked from the CLI, injecting a provider
+// configured from the workspace's Anchor.toml.
+
+const anchor = require("@project-serum/anchor");
+
+module.exports = async function (provider) {
+  // Configure client to use the provider.
+  anchor.setProvider(provider);
+
+  // Add your deploy script here.
+}

dex/tests/close-markets/programs/close-markets/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "close-markets"
+version = "0.1.0"
+description = "Created with Anchor"
+edition = "2018"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "close_markets"
+
+[features]
+no-entrypoint = []
+no-idl = []
+cpi = ["no-entrypoint"]
+default = []
+
+[dependencies]
+anchor-lang = "0.19.0"
+anchor-spl = {version = "0.19.0", features = ["dex"]}
+serum_dex = { path = "../../../..", features = ["no-entrypoint"]}
+solana-program = "1.8.0"

dex/tests/close-markets/programs/close-markets/Xargo.toml

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []