Add TWAP Message format (#364)

* Yes

* Make size smaller

* Fix message format

* Comments

* Refactor

* Cleanup

Author: guibescos

program/rust/src/accounts.rs

@@ -56,6 +56,7 @@ pub use {
         PriceEma,
         PriceFeedMessage,
         PriceInfo,
+        TwapMessage,
     },
     product::{
         read_pc_str_t,

program/rust/src/accounts/price.rs

@@ -96,7 +96,7 @@ pub struct PriceAccountV2 {
     pub timestamp_:         i64,
     /// Minimum valid publisher quotes for a succesful aggregation
     pub min_pub_:           u8,
-    pub unused_1_:          i8,
+    pub message_sent_:      u8,
     pub unused_2_:          i16,
     pub unused_3_:          i32,
     /// Corresponding product account
@@ -120,6 +120,7 @@ pub struct PriceAccountV2 {
     pub price_cumulative:   PriceCumulative,
 }
 
+
 impl PriceAccountV2 {
     /// This function gets triggered when there's a succesful aggregation and updates the cumulative sums
     pub fn update_price_cumulative(&mut self) -> Result<(), OracleError> {
@@ -139,7 +140,7 @@ impl PriceAccountV2 {
 // This struct can't overflow since :
 // |sum(price * slotgap)| <= sum(|price * slotgap|) <= max(|price|) * sum(slotgap) <= i64::MAX * * current_slot <= i64::MAX * u64::MAX <= i128::MAX
 // |sum(conf * slotgap)| <= sum(|conf * slotgap|) <= max(|conf|) * sum(slotgap) <= u64::MAX * current_slot <= u64::MAX * u64::MAX <= u128::MAX
-// num_gaps <= current_slot <= u64::MAX
+// num_down_slots <= current_slot <= u64::MAX
 /// Contains cumulative sums of aggregative price and confidence used to compute arithmetic moving averages.
 /// Informally the TWAP between time t and time T can be computed as :
 /// `(T.price_cumulative.price - t.price_cumulative.price) / (T.agg_.pub_slot_ - t.agg_.pub_slot_)`
@@ -240,7 +241,7 @@ impl PriceFeedMessage {
     pub const MESSAGE_SIZE: usize = 1 + 32 + 8 + 8 + 4 + 8 + 8 + 8 + 8;
     pub const DISCRIMINATOR: u8 = 0;
 
-    pub fn from_price_account(key: &Pubkey, account: &PriceAccount) -> Self {
+    pub fn from_price_account(key: &Pubkey, account: &PriceAccountV2) -> Self {
         let (price, conf, publish_time) = if account.agg_.status_ == PC_STATUS_TRADING {
             (account.agg_.price_, account.agg_.conf_, account.timestamp_)
         } else {
@@ -267,12 +268,12 @@ impl PriceFeedMessage {
     /// Note that it would be more idiomatic to return a `Vec`, but that approach adds
     /// to the size of the compiled binary (which is already close to the size limit).
     #[allow(unused_assignments)]
-    pub fn as_bytes(&self) -> [u8; PriceFeedMessage::MESSAGE_SIZE] {
-        let mut bytes = [0u8; PriceFeedMessage::MESSAGE_SIZE];
+    pub fn as_bytes(&self) -> [u8; Self::MESSAGE_SIZE] {
+        let mut bytes = [0u8; Self::MESSAGE_SIZE];
 
         let mut i: usize = 0;
 
-        bytes[i..i + 1].clone_from_slice(&[PriceFeedMessage::DISCRIMINATOR]);
+        bytes[i..i + 1].clone_from_slice(&[Self::DISCRIMINATOR]);
         i += 1;
 
         bytes[i..i + 32].clone_from_slice(&self.id[..]);
@@ -302,3 +303,82 @@ impl PriceFeedMessage {
         bytes
     }
 }
+
+/// Message format for sending Twap data via the accumulator program
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub struct TwapMessage {
+    pub id:                [u8; 32],
+    pub cumulative_price:  i128,
+    pub cumulative_conf:   u128,
+    pub num_down_slots:    u64,
+    pub exponent:          i32,
+    pub publish_time:      i64,
+    pub prev_publish_time: i64,
+    pub publish_slot:      u64,
+}
+
+impl TwapMessage {
+    // The size of the serialized message. Note that this is not the same as the size of the struct
+    // (because of the discriminator & struct padding/alignment).
+    pub const MESSAGE_SIZE: usize = 1 + 32 + 16 + 16 + 8 + 4 + 8 + 8 + 8;
+    pub const DISCRIMINATOR: u8 = 1;
+
+    pub fn from_price_account(key: &Pubkey, account: &PriceAccountV2) -> Self {
+        let publish_time = if account.agg_.status_ == PC_STATUS_TRADING {
+            account.timestamp_
+        } else {
+            account.prev_timestamp_
+        };
+
+        Self {
+            id: key.to_bytes(),
+            cumulative_price: account.price_cumulative.price,
+            cumulative_conf: account.price_cumulative.conf,
+            num_down_slots: account.price_cumulative.num_down_slots,
+            exponent: account.exponent,
+            publish_time,
+            prev_publish_time: account.prev_timestamp_,
+            publish_slot: account.last_slot_,
+        }
+    }
+
+    /// Serialize this message as an array of bytes (including the discriminator)
+    /// Note that it would be more idiomatic to return a `Vec`, but that approach adds
+    /// to the size of the compiled binary (which is already close to the size limit).
+    #[allow(unused_assignments)]
+    pub fn as_bytes(&self) -> [u8; Self::MESSAGE_SIZE] {
+        let mut bytes = [0u8; Self::MESSAGE_SIZE];
+
+        let mut i: usize = 0;
+
+        bytes[i..i + 1].clone_from_slice(&[Self::DISCRIMINATOR]);
+        i += 1;
+
+        bytes[i..i + 32].clone_from_slice(&self.id[..]);
+        i += 32;
+
+        bytes[i..i + 16].clone_from_slice(&self.cumulative_price.to_be_bytes());
+        i += 16;
+
+        bytes[i..i + 16].clone_from_slice(&self.cumulative_conf.to_be_bytes());
+        i += 16;
+
+        bytes[i..i + 8].clone_from_slice(&self.num_down_slots.to_be_bytes());
+        i += 8;
+
+        bytes[i..i + 4].clone_from_slice(&self.exponent.to_be_bytes());
+        i += 4;
+
+        bytes[i..i + 8].clone_from_slice(&self.publish_time.to_be_bytes());
+        i += 8;
+
+        bytes[i..i + 8].clone_from_slice(&self.prev_publish_time.to_be_bytes());
+        i += 8;
+
+        bytes[i..i + 8].clone_from_slice(&self.publish_slot.to_be_bytes());
+        i += 8;
+
+        bytes
+    }
+}

program/rust/src/processor/upd_price.rs

@@ -6,6 +6,7 @@ use {
             PriceFeedMessage,
             PriceInfo,
             PythAccount,
+            TwapMessage,
             UPD_PRICE_WRITE_SEED,
         },
         deserialize::{
@@ -152,10 +153,8 @@ pub fn upd_price(
     }
 
     // Try to update the aggregate
-    #[allow(unused_variables)]
     let mut aggregate_updated = false;
     if clock.slot > latest_aggregate_price.pub_slot_ {
-        #[allow(unused_assignments)]
         unsafe {
             aggregate_updated = c_upd_aggregate(
                 price_account.try_borrow_mut_data()?.as_mut_ptr(),
@@ -165,82 +164,86 @@ pub fn upd_price(
         }
     }
 
-    {
-        let account_len = price_account.try_data_len()?;
-        if aggregate_updated && account_len >= PriceAccountV2::MINIMUM_SIZE {
-            let mut price_data =
-                load_checked::<PriceAccountV2>(price_account, cmd_args.header.version)?;
+
+    let account_len = price_account.try_data_len()?;
+    if account_len >= PriceAccountV2::MINIMUM_SIZE {
+        let mut price_data =
+            load_checked::<PriceAccountV2>(price_account, cmd_args.header.version)?;
+
+        if aggregate_updated {
             price_data.update_price_cumulative()?;
+            // We want to send a message every time the aggregate price updates. However, during the migration,
+            // not every publisher will necessarily provide the accumulator accounts. The message_sent_ flag
+            // ensures that after every aggregate update, the next publisher who provides the accumulator accounts
+            // will send the message.
+            price_data.message_sent_ = 0;
         }
-    }
 
-    let mut price_data = load_checked::<PriceAccount>(price_account, cmd_args.header.version)?;
-    // We want to send a message every time the aggregate price updates. However, during the migration,
-    // not every publisher will necessarily provide the accumulator accounts. The message_sent_ flag
-    // ensures that after every aggregate update, the next publisher who provides the accumulator accounts
-    // will send the message.
-    if aggregate_updated {
-        price_data.message_sent_ = 0;
-    }
 
-    if let Some(accumulator_accounts) = maybe_accumulator_accounts {
-        if price_data.message_sent_ == 0 {
-            // Check that the oracle PDA is correctly configured for the program we are calling.
-            let oracle_auth_seeds: &[&[u8]] = &[
-                UPD_PRICE_WRITE_SEED.as_bytes(),
-                &accumulator_accounts.program_id.key.to_bytes(),
-            ];
-            let (expected_oracle_auth_pda, bump) =
-                Pubkey::find_program_address(oracle_auth_seeds, program_id);
-            pyth_assert(
-                expected_oracle_auth_pda == *accumulator_accounts.oracle_auth_pda.key,
-                OracleError::InvalidPda.into(),
-            )?;
+        if let Some(accumulator_accounts) = maybe_accumulator_accounts {
+            if price_data.message_sent_ == 0 {
+                // Check that the oracle PDA is correctly configured for the program we are calling.
+                let oracle_auth_seeds: &[&[u8]] = &[
+                    UPD_PRICE_WRITE_SEED.as_bytes(),
+                    &accumulator_accounts.program_id.key.to_bytes(),
+                ];
+                let (expected_oracle_auth_pda, bump) =
+                    Pubkey::find_program_address(oracle_auth_seeds, program_id);
+                pyth_assert(
+                    expected_oracle_auth_pda == *accumulator_accounts.oracle_auth_pda.key,
+                    OracleError::InvalidPda.into(),
+                )?;
 
-            let account_metas = vec![
-                AccountMeta {
-                    pubkey:      *accumulator_accounts.whitelist.key,
-                    is_signer:   false,
-                    is_writable: false,
-                },
-                AccountMeta {
-                    pubkey:      *accumulator_accounts.oracle_auth_pda.key,
-                    is_signer:   true,
-                    is_writable: false,
-                },
-                AccountMeta {
-                    pubkey:      *accumulator_accounts.message_buffer_data.key,
-                    is_signer:   false,
-                    is_writable: true,
-                },
-            ];
+                let account_metas = vec![
+                    AccountMeta {
+                        pubkey:      *accumulator_accounts.whitelist.key,
+                        is_signer:   false,
+                        is_writable: false,
+                    },
+                    AccountMeta {
+                        pubkey:      *accumulator_accounts.oracle_auth_pda.key,
+                        is_signer:   true,
+                        is_writable: false,
+                    },
+                    AccountMeta {
+                        pubkey:      *accumulator_accounts.message_buffer_data.key,
+                        is_signer:   false,
+                        is_writable: true,
+                    },
+                ];
 
-            let message =
-                vec![
+                let message = vec![
                     PriceFeedMessage::from_price_account(price_account.key, &price_data)
                         .as_bytes()
                         .to_vec(),
+                    TwapMessage::from_price_account(price_account.key, &price_data)
+                        .as_bytes()
+                        .to_vec(),
                 ];
 
-            // anchor discriminator for "global:put_all"
-            let discriminator = [212, 225, 193, 91, 151, 238, 20, 93];
-            let create_inputs_ix = Instruction::new_with_borsh(
-                *accumulator_accounts.program_id.key,
-                &(discriminator, price_account.key.to_bytes(), message),
-                account_metas,
-            );
+                // anchor discriminator for "global:put_all"
+                let discriminator = [212, 225, 193, 91, 151, 238, 20, 93];
+                let create_inputs_ix = Instruction::new_with_borsh(
+                    *accumulator_accounts.program_id.key,
+                    &(discriminator, price_account.key.to_bytes(), message),
+                    account_metas,
+                );
 
-            let auth_seeds_with_bump: &[&[u8]] = &[
-                UPD_PRICE_WRITE_SEED.as_bytes(),
-                &accumulator_accounts.program_id.key.to_bytes(),
-                &[bump],
-            ];
+                let auth_seeds_with_bump: &[&[u8]] = &[
+                    UPD_PRICE_WRITE_SEED.as_bytes(),
+                    &accumulator_accounts.program_id.key.to_bytes(),
+                    &[bump],
+                ];
 
-            invoke_signed(&create_inputs_ix, accounts, &[auth_seeds_with_bump])?;
-            price_data.message_sent_ = 1;
+                invoke_signed(&create_inputs_ix, accounts, &[auth_seeds_with_bump])?;
+                price_data.message_sent_ = 1;
+            }
         }
     }
 
+
+    let mut price_data = load_checked::<PriceAccount>(price_account, cmd_args.header.version)?;
+
     // Try to update the publisher's price
     if is_component_update(cmd_args)? {
         let status: u32 =