deserialize properly

Author: snawaz

test-integration/Cargo.lock

@@ -9,7 +9,8 @@ use solana_program::{
 };
 
 use crate::{
-    DelegateCpiArgs, ScheduleCommitCpiArgs, ScheduleCommitInstruction,
+    BookUpdate, DelegateCpiArgs, ScheduleCommitCpiArgs,
+    ScheduleCommitInstruction,
 };
 
 pub fn init_account_instruction(
@@ -161,6 +162,24 @@ pub fn schedule_commit_cpi_instruction(
     )
 }
 
+pub fn update_order_book_instruction(
+    payer: Pubkey,
+    order_book: Pubkey,
+    update: BookUpdate,
+) -> Instruction {
+    let program_id = crate::id();
+    let account_metas = vec![
+        AccountMeta::new(payer, true),
+        AccountMeta::new(order_book, false),
+    ];
+
+    Instruction::new_with_borsh(
+        program_id,
+        &ScheduleCommitInstruction::UpdateOrderBook(update),
+        account_metas,
+    )
+}
+
 pub fn schedule_commit_diff_instruction_for_order_book(
     payer: Pubkey,
     order_book: Pubkey,

test-integration/programs/schedulecommit/src/api.rs

@@ -36,7 +36,7 @@ mod utils;
 
 use order_book::*;
 
-pub use order_book::{OrderBookOwned, OrderLevel};
+pub use order_book::{BookUpdate, OrderBookOwned, OrderLevel};
 
 declare_id!("9hgprgZiRWmy8KkfvUuaVkDGrqo9GzeXMohwq6BazgUY");
 
@@ -372,12 +372,6 @@ pub fn process_delegate_order_book(
     Ok(())
 }
 
-#[derive(BorshSerialize, BorshDeserialize, Debug, Clone)]
-pub struct BookUpdate {
-    bids: Vec<OrderLevel>,
-    asks: Vec<OrderLevel>,
-}
-
 // -----------------
 // UpdateOrderBook
 // -----------------
@@ -393,10 +387,8 @@ fn process_update_order_book<'a>(
     assert_is_signer(payer_info, "payer")?;
 
     let mut book_raw = order_book_account.try_borrow_mut_data()?;
-    let mut order_book = OrderBook::new(&mut book_raw);
 
-    order_book.add_bids(&updates.bids);
-    order_book.add_asks(&updates.asks);
+    OrderBook::new(&mut book_raw).update_from(updates);
 
     Ok(())
 }
@@ -418,17 +410,17 @@ pub fn process_schedulecommit_for_orderbook(
     //  -  TransactionError(InstructionError(0, AccountBorrowFailed))
     //  - Program 9hgprgZiRWmy8KkfvUuaVkDGrqo9GzeXMohwq6BazgUY failed: instruction tries to borrow reference for an account which is already borrowed
     {
-        let mut book_raw = order_book_account.try_borrow_mut_data()?;
-        let mut order_book = OrderBook::new(&mut book_raw);
-
-        order_book.add_bids(&[OrderLevel {
-            price: 90000,
-            size: 10,
-        }]);
-        order_book.add_asks(&[OrderLevel {
-            price: 125000,
-            size: 16,
-        }]);
+        // let mut book_raw = order_book_account.try_borrow_mut_data()?;
+        // let mut order_book = OrderBook::new(&mut book_raw);
+
+        // order_book.add_bids(&[OrderLevel {
+        //     price: 90000,
+        //     size: 10,
+        // }]);
+        // order_book.add_asks(&[OrderLevel {
+        //     price: 125000,
+        //     size: 16,
+        // }]);
     }
 
     commit_diff_and_undelegate_accounts(

test-integration/programs/schedulecommit/src/lib.rs

@@ -4,13 +4,19 @@ use borsh::{BorshDeserialize, BorshSerialize};
 
 #[repr(C)]
 #[derive(
-    BorshSerialize, BorshDeserialize, Debug, Clone, Copy, PartialEq, Eq,
+    BorshSerialize, BorshDeserialize, Debug, Clone, Copy, Default, PartialEq, Eq,
 )]
 pub struct OrderLevel {
-    pub price: u64, // use f64
+    pub price: u64, // ideally both fields could be some decimal value
     pub size: u64,
 }
 
+#[derive(BorshSerialize, BorshDeserialize, Debug, Clone, Default)]
+pub struct BookUpdate {
+    pub bids: Vec<OrderLevel>,
+    pub asks: Vec<OrderLevel>,
+}
+
 #[repr(C, align(4))]
 pub struct OrderBookHeader {
     pub bids_len: u32,
@@ -20,24 +26,37 @@ pub struct OrderBookHeader {
 const ORDER_LEVEL_SIZE: usize = std::mem::size_of::<OrderLevel>();
 const HEADER_SIZE: usize = std::mem::size_of::<OrderBookHeader>();
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
 pub struct OrderBookOwned {
     pub bids: Vec<OrderLevel>,
     pub asks: Vec<OrderLevel>,
 }
 
+impl From<&OrderBook<'_>> for OrderBookOwned {
+    fn from(book_ref: &OrderBook) -> Self {
+        let mut book = Self::default();
+        book.bids.extend_from_slice(book_ref.bids());
+        book.asks.extend(book_ref.asks_reversed().iter().rev());
+        book
+    }
+}
+
 impl borsh::de::BorshDeserialize for OrderBookOwned {
+    fn deserialize(buf: &mut &[u8]) -> Result<Self, borsh::io::Error> {
+        let (book_bytes, rest) = buf.split_at(buf.len());
+        *buf = rest; // rest is actually empty
+
+        Ok(Self::from(&OrderBook::new(unsafe {
+            slice::from_raw_parts_mut(
+                book_bytes.as_ptr() as *mut u8,
+                book_bytes.len(),
+            )
+        })))
+    }
     fn deserialize_reader<R: borsh::io::Read>(
-        reader: &mut R,
+        _reader: &mut R,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        println!("OrderBookOwned deserialization");
-        reader.read_to_end(&mut vec![]);
-        Ok(Self {
-            bids: vec![],
-            asks: vec![],
-        })
-        //let read
-        //reader.read_exact(buf)
+        unimplemented!("deserialize_reader() not implemented. Please use buffer version as it needs to know size of the buffer")
     }
 }
 pub struct OrderBook<'a> {
@@ -74,6 +93,11 @@ impl<'a> OrderBook<'a> {
         }
     }
 
+    pub fn update_from(&mut self, updates: BookUpdate) {
+        self.add_bids(&updates.bids);
+        self.add_asks(&updates.asks);
+    }
+
     pub fn add_bids(
         &mut self,
         bids: &[OrderLevel],
@@ -82,18 +106,15 @@ impl<'a> OrderBook<'a> {
             return None;
         }
         let new_bids_len = self.bids_len() + bids.len();
-        let bids_space = unsafe { self.bids(new_bids_len) };
+        let bids_space =
+            unsafe { self.bids_with_uninitialized_slots(new_bids_len) };
 
         bids_space[self.bids_len()..].copy_from_slice(bids);
         self.header.bids_len = new_bids_len as u32;
 
         Some(bids_space)
     }
 
-    pub fn bids_len(&self) -> usize {
-        self.header.bids_len as usize
-    }
-
     pub fn add_asks(
         &mut self,
         asks: &[OrderLevel],
@@ -102,7 +123,8 @@ impl<'a> OrderBook<'a> {
             return None;
         }
         let new_asks_len = self.asks_len() + asks.len();
-        let asks_space = unsafe { self.asks(new_asks_len) };
+        let asks_space =
+            unsafe { self.asks_with_uninitialized_slots(new_asks_len) };
 
         // copy in the reverse order
         for (dst, src) in
@@ -115,15 +137,40 @@ impl<'a> OrderBook<'a> {
         Some(asks_space)
     }
 
+    pub fn bids(&self) -> &'a [OrderLevel] {
+        unsafe { slice::from_raw_parts(self.levels, self.bids_len()) }
+    }
+
+    /// Note that the returned slice is in reverse order, means the first entry is the latest
+    /// entry and the last entry is the oldest entry.
+    pub fn asks_reversed(&self) -> &'a [OrderLevel] {
+        unsafe {
+            slice::from_raw_parts(
+                self.levels.add(self.capacity - self.asks_len()),
+                self.asks_len(),
+            )
+        }
+    }
+
+    pub fn bids_len(&self) -> usize {
+        self.header.bids_len as usize
+    }
+
     pub fn asks_len(&self) -> usize {
         self.header.asks_len as usize
     }
 
-    unsafe fn bids(&mut self, bids_len: usize) -> &'a mut [OrderLevel] {
+    unsafe fn bids_with_uninitialized_slots(
+        &mut self,
+        bids_len: usize,
+    ) -> &'a mut [OrderLevel] {
         slice::from_raw_parts_mut(self.levels, bids_len)
     }
 
-    unsafe fn asks(&mut self, asks_len: usize) -> &'a mut [OrderLevel] {
+    unsafe fn asks_with_uninitialized_slots(
+        &mut self,
+        asks_len: usize,
+    ) -> &'a mut [OrderLevel] {
         slice::from_raw_parts_mut(
             self.levels.add(self.capacity - asks_len),
             asks_len as usize,

test-integration/programs/schedulecommit/src/order_book.rs

@@ -1,11 +1,10 @@
 use std::{fmt, ops::Deref};
 
 use anyhow::{Context, Result};
-use integration_test_tools::{scheduled_commits, IntegrationTestContext};
+use integration_test_tools::IntegrationTestContext;
 use program_schedulecommit::api::{
-    delegate_account_cpi_instruction, grow_order_book_instruction,
-    init_account_instruction, init_order_book_instruction, init_payer_escrow,
-    pda_and_bump,
+    delegate_account_cpi_instruction, init_account_instruction,
+    init_order_book_instruction, init_payer_escrow,
 };
 use solana_rpc_client::rpc_client::{RpcClient, SerializableTransaction};
 use solana_rpc_client_api::config::RpcSendTransactionConfig;
@@ -14,7 +13,6 @@ use solana_sdk::signer::SeedDerivable;
 use solana_sdk::{
     commitment_config::CommitmentConfig,
     compute_budget::ComputeBudgetInstruction,
-    entrypoint::MAX_PERMITTED_DATA_INCREASE,
     hash::Hash,
     native_token::LAMPORTS_PER_SOL,
     pubkey::Pubkey,
@@ -134,7 +132,7 @@ impl ScheduleCommitTestContext {
             //         [grow_order_book_instruction(
             //             payer.pubkey(),
             //             *committee,
-            //             MAX_PERMITTED_DATA_INCREASE as u64,
+            //             10 * 1024
             //         )]
             //     },
             // ));

test-integration/schedulecommit/client/src/schedule_commit_context.rs

@@ -16,3 +16,5 @@ solana-rpc-client = { workspace = true }
 solana-rpc-client-api = { workspace = true }
 solana-sdk = { workspace = true }
 test-tools-core = { workspace = true }
+rand = { workspace = true }
+borsh = { workspace = true }