New interface with time machine

docker/Dockerfile

@@ -27,8 +27,9 @@ RUN apt-get install -qq \
   qt5-qmake \
   qtbase5-dev-tools \
   libqt5websockets5-dev\
-  libclang-dev
-
+  libclang-dev\
+  python3-pip 
+
 # Install jcon-cpp library
 RUN git clone https://github.com/joncol/jcon-cpp.git /jcon-cpp && cd /jcon-cpp && git checkout 2235654e39c7af505d7158bf996e47e37a23d6e3 && mkdir build && cd build && cmake .. && make -j4 && make install
 
@@ -56,6 +57,8 @@ export PYTHONPATH=\"\${PYTHONPATH:+\$PYTHONPATH:}\${HOME}/pyth-client\"\n\
 
 COPY --chown=pyth:pyth . pyth-client/
 
+RUN pip3 install solana
+
 # Build off-chain binaries.
 RUN cd pyth-client && ./scripts/build.sh
 

program/c/src/oracle/oracle.h

@@ -270,11 +270,11 @@ typedef enum {
   // key[2] sysvar_clock account  [readable]
   e_cmd_upd_price_no_fail_on_error,
 
-  // performs migation logic on the upgraded account. (resizes price accounts)
+  // resizes a price accpunt so that it fits the Time Machine
   // key[0] funding account       [signer writable]
-  // key[1] upgraded account      [writable]
+  // key[1] price account         [Signer writable]
   // key[2] system program        [readable]
-  e_cmd_upd_account_version,
+  e_cmd_resize_price_account,
 } command_t;
 
 typedef struct cmd_hdr

program/rust/src/log.rs

@@ -85,6 +85,11 @@ pub fn pre_log(accounts: &[AccountInfo], instruction_data: &[u8]) -> ProgramResu
         command_t_e_cmd_upd_product => {
             msg!("UpdateProduct");
         }
+
+        command_t_e_cmd_resize_price_account => {
+            //accounts[1] is the updated account
+            msg!("ResizePriceAccount: {}", accounts[1].key);
+        }
         _ => {
             msg!("UnrecognizedInstruction");
             return Err(OracleError::UnrecognizedInstruction.into());

program/rust/src/processor.rs

@@ -11,8 +11,8 @@ use crate::c_oracle_header::{
     command_t_e_cmd_add_publisher,
     command_t_e_cmd_agg_price,
     command_t_e_cmd_init_mapping,
+    command_t_e_cmd_resize_price_account,
     command_t_e_cmd_set_min_pub,
-    command_t_e_cmd_upd_account_version,
     command_t_e_cmd_upd_price,
     command_t_e_cmd_upd_price_no_fail_on_error,
     command_t_e_cmd_upd_product,
@@ -29,10 +29,10 @@ use crate::rust_oracle::{
     add_product,
     add_publisher,
     init_mapping,
+    resize_price_account,
     set_min_pub,
     upd_product,
     update_price,
-    update_version,
 };
 
 ///dispatch to the right instruction in the oracle
@@ -59,8 +59,8 @@ pub fn process_instruction(
         command_t_e_cmd_upd_price
         | command_t_e_cmd_upd_price_no_fail_on_error
         | command_t_e_cmd_agg_price => update_price(program_id, accounts, instruction_data, input),
-        command_t_e_cmd_upd_account_version => {
-            update_version(program_id, accounts, instruction_data)
+        command_t_e_cmd_resize_price_account => {
+            resize_price_account(program_id, accounts, instruction_data)
         }
         command_t_e_cmd_add_price => add_price(program_id, accounts, instruction_data),
         command_t_e_cmd_init_mapping => init_mapping(program_id, accounts, instruction_data),

program/rust/src/rust_oracle.rs

@@ -19,6 +19,13 @@ use solana_program::program_memory::{
 use solana_program::pubkey::Pubkey;
 use solana_program::rent::Rent;
 
+
+use crate::time_machine_types::PriceAccountWrapper;
+use solana_program::program::invoke;
+use solana_program::system_instruction::transfer;
+use solana_program::system_program::check_id;
+
+
 use crate::c_oracle_header::{
     cmd_add_price_t,
     cmd_add_publisher_t,
@@ -38,41 +45,119 @@ use crate::c_oracle_header::{
     PC_MAX_NUM_DECIMALS,
     PC_PROD_ACC_SIZE,
     PC_PTYPE_UNKNOWN,
+    PC_VERSION,
+    SUCCESSFULLY_UPDATED_AGGREGATE,
 };
 use crate::deserialize::{
     load,
     load_account_as,
     load_account_as_mut,
 };
 use crate::error::OracleResult;
-use crate::utils::pyth_assert;
 use crate::OracleError;
 
+use crate::utils::pyth_assert;
+
 use super::c_entrypoint_wrapper;
+const PRICE_T_SIZE: usize = size_of::<pc_price_t>();
+const PRICE_ACCOUNT_SIZE: usize = size_of::<PriceAccountWrapper>();
+
 
 ///Calls the c oracle update_price, and updates the Time Machine if needed
 pub fn update_price(
     _program_id: &Pubkey,
-    _accounts: &[AccountInfo],
+    accounts: &[AccountInfo],
     _instruction_data: &[u8],
     input: *mut u8,
 ) -> OracleResult {
-    //For now, we did not change the behavior of this. this is just to show the proposed structure
-    // of the program
-    c_entrypoint_wrapper(input)
+    let [_funding_account_info, price_account_info, _sysvar_clock] = match accounts {
+        [x, y, z] => Ok([x, y, z]),
+        _ => Err(ProgramError::InvalidArgument),
+    }?;
+    //accounts checks happen in c_entrypoint
+    let account_len = price_account_info.try_data_len()?;
+    match account_len {
+        PRICE_T_SIZE => c_entrypoint_wrapper(input),
+        PRICE_ACCOUNT_SIZE => {
+            let c_ret_value = c_entrypoint_wrapper(input)?;
+            if c_ret_value == SUCCESSFULLY_UPDATED_AGGREGATE {
+                let mut price_account =
+                    load_account_as_mut::<PriceAccountWrapper>(price_account_info)?;
+                price_account.add_price_to_time_machine()?;
+            }
+            Ok(c_ret_value)
+        }
+        _ => Err(ProgramError::InvalidArgument),
+    }
 }
-/// has version number/ account type dependant logic to make sure the given account is compatible
-/// with the current version
-/// updates the version number for all accounts, and resizes price accounts
-pub fn update_version(
-    _program_id: &Pubkey,
-    _accounts: &[AccountInfo],
+fn send_lamports<'a>(
+    from: &AccountInfo<'a>,
+    to: &AccountInfo<'a>,
+    system_program: &AccountInfo<'a>,
+    amount: u64,
+) -> Result<(), ProgramError> {
+    let transfer_instruction = transfer(from.key, to.key, amount);
+    invoke(
+        &transfer_instruction,
+        &[from.clone(), to.clone(), system_program.clone()],
+    )?;
+    Ok(())
+}
+
+/// resizes a price accpunt so that it fits the Time Machine
+/// key[0] funding account       [signer writable]
+/// key[1] price account         [Signer writable]
+/// key[2] system program        [readable]
+pub fn resize_price_account(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
     _instruction_data: &[u8],
 ) -> OracleResult {
-    panic!("Need to merge fix to pythd in order to implement this");
-    // Ok(SUCCESS)
+    let [funding_account_info, price_account_info, system_program] = match accounts {
+        [x, y, z] => Ok([x, y, z]),
+        _ => Err(ProgramError::InvalidArgument),
+    }?;
+
+    check_valid_funding_account(funding_account_info)?;
+    check_valid_signable_account(program_id, price_account_info, size_of::<pc_price_t>())?;
+    pyth_assert(
+        check_id(system_program.key),
+        OracleError::InvalidSystemAccount.into(),
+    )?;
+    let account_len = price_account_info.try_data_len()?;
+    match account_len {
+        PRICE_T_SIZE => {
+            //ensure account is still rent exempt after resizing
+            let rent: Rent = Default::default();
+            let lamports_needed: u64 = rent
+                .minimum_balance(size_of::<PriceAccountWrapper>())
+                .saturating_sub(price_account_info.lamports());
+            if lamports_needed > 0 {
+                send_lamports(
+                    funding_account_info,
+                    price_account_info,
+                    system_program,
+                    lamports_needed,
+                )?;
+            }
+            //resize
+            //we do not need to zero initialize since this is the first time this memory
+            //is allocated
+            price_account_info.realloc(size_of::<PriceAccountWrapper>(), false)?;
+            //The load below would fail if the account was not a price account, reverting the whole
+            // transaction
+            let mut price_account =
+                load_checked::<PriceAccountWrapper>(price_account_info, PC_VERSION)?;
+            //Initialize Time Machine
+            price_account.initialize_time_machine()?;
+            Ok(SUCCESS)
+        }
+        PRICE_ACCOUNT_SIZE => Ok(SUCCESS),
+        _ => Err(ProgramError::InvalidArgument),
+    }
 }
 
+
 /// initialize the first mapping account in a new linked-list of mapping accounts
 /// accounts[0] funding account           [signer writable]
 /// accounts[1] new mapping account       [signer writable]
@@ -147,6 +232,7 @@ pub fn add_price(
         return Err(ProgramError::InvalidArgument);
     }
 
+
     let [funding_account, product_account, price_account] = match accounts {
         [x, y, z] => Ok([x, y, z]),
         _ => Err(ProgramError::InvalidArgument),

program/rust/src/time_machine_types.rs

@@ -1,4 +1,19 @@
-#[derive(Debug, Clone)]
+use crate::c_oracle_header::{
+    pc_price_t,
+    PythAccount,
+    EXTRA_PUBLISHER_SPACE,
+    PC_ACCTYPE_PRICE,
+};
+use crate::error::OracleError;
+use bytemuck::{
+    Pod,
+    Zeroable,
+};
+use solana_program::msg;
+use std::mem::size_of;
+
+
+#[derive(Debug, Clone, Copy)]
 #[repr(C)]
 /// this wraps multiple SMA and tick trackers, and includes all the state
 /// used by the time machine
@@ -7,10 +22,52 @@ pub struct TimeMachineWrapper {
     place_holder: [u8; 1864],
 }
 
+#[derive(Copy, Clone)]
+#[repr(C)]
+/// wraps everything stored in a price account
+pub struct PriceAccountWrapper {
+    //an instance of the c price_t type
+    pub price_data:            pc_price_t,
+    //space for more publishers
+    pub extra_publisher_space: [u8; EXTRA_PUBLISHER_SPACE as usize],
+    //TimeMachine
+    pub time_machine:          TimeMachineWrapper,
+}
+impl PriceAccountWrapper {
+    pub fn initialize_time_machine(&mut self) -> Result<(), OracleError> {
+        msg!("implement me");
+        Ok(())
+    }
+
+    pub fn add_price_to_time_machine(&mut self) -> Result<(), OracleError> {
+        msg!("implement me");
+        Ok(())
+    }
+}
+
+#[cfg(target_endian = "little")]
+unsafe impl Zeroable for PriceAccountWrapper {
+}
+
+#[cfg(target_endian = "little")]
+unsafe impl Pod for PriceAccountWrapper {
+}
+
+impl PythAccount for PriceAccountWrapper {
+    const ACCOUNT_TYPE: u32 = PC_ACCTYPE_PRICE;
+    const INITIAL_SIZE: u32 = size_of::<PriceAccountWrapper>() as u32;
+}
+
 #[cfg(test)]
 pub mod tests {
-    use crate::c_oracle_header::TIME_MACHINE_STRUCT_SIZE;
-    use crate::time_machine_types::TimeMachineWrapper;
+    use crate::c_oracle_header::{
+        PRICE_ACCOUNT_SIZE,
+        TIME_MACHINE_STRUCT_SIZE,
+    };
+    use crate::time_machine_types::{
+        PriceAccountWrapper,
+        TimeMachineWrapper,
+    };
     use std::mem::size_of;
     #[test]
     ///test that the size defined in C matches that
@@ -24,4 +81,15 @@ pub mod tests {
         size_of::<TimeMachineWrapper>()
     );
     }
+    #[test]
+    ///test that priceAccountWrapper has a correct size
+    fn c_price_account_size_is_correct() {
+        assert_eq!(
+        size_of::<PriceAccountWrapper>(),
+        PRICE_ACCOUNT_SIZE.try_into().unwrap(),
+        "expected PRICE_ACCOUNT_SIZE ({}) in oracle.h to the same as the size of PriceAccountWrapper ({})",
+        PRICE_ACCOUNT_SIZE,
+        size_of::<PriceAccountWrapper>()
+    );
+    }
 }