feat: aggregate in the same slot

program/rust/src/tests/mod.rs

@@ -19,13 +19,10 @@ mod test_publish_batch;
 mod test_set_max_latency;
 mod test_set_min_pub;
 mod test_sizes;
+mod test_twap;
 mod test_upd_aggregate;
 mod test_upd_permissions;
 mod test_upd_price;
 mod test_upd_price_no_fail_on_error;
 mod test_upd_product;
 mod test_utils;
-
-
-mod test_twap;
-mod test_upd_price_v2;

program/rust/src/tests/test_upd_price.rs

@@ -88,6 +88,9 @@ fn test_upd_price() {
         assert_eq!(price_data.prev_price_, 0);
         assert_eq!(price_data.prev_conf_, 0);
         assert_eq!(price_data.prev_timestamp_, 0);
+        assert_eq!(price_data.price_cumulative.price, 42);
+        assert_eq!(price_data.price_cumulative.conf, 2);
+        assert_eq!(price_data.price_cumulative.num_down_slots, 0);
     }
 
     // add some prices for current slot - get rejected
@@ -121,6 +124,9 @@ fn test_upd_price() {
         assert_eq!(price_data.prev_price_, 0);
         assert_eq!(price_data.prev_conf_, 0);
         assert_eq!(price_data.prev_timestamp_, 0);
+        assert_eq!(price_data.price_cumulative.price, 42);
+        assert_eq!(price_data.price_cumulative.conf, 2);
+        assert_eq!(price_data.price_cumulative.num_down_slots, 0);
     }
 
     // update new price in new slot, aggregate should be updated and prev values should be updated
@@ -153,6 +159,9 @@ fn test_upd_price() {
         assert_eq!(price_data.prev_price_, 42);
         assert_eq!(price_data.prev_conf_, 2);
         assert_eq!(price_data.prev_timestamp_, 1);
+        assert_eq!(price_data.price_cumulative.price, 42 + 2 * 81);
+        assert_eq!(price_data.price_cumulative.conf, 3 * 2);
+        assert_eq!(price_data.price_cumulative.num_down_slots, 0);
     }
 
     // next price doesn't change but slot and timestamp does
@@ -186,6 +195,9 @@ fn test_upd_price() {
         assert_eq!(price_data.prev_conf_, 2);
         assert_eq!(price_data.timestamp_, 4); // We only check for timestamp_ here because test_upd_price doesn't directly update timestamp_, this is updated through c_upd_aggregate which is tested in test_upd_aggregate, but we assert here to show that in subsequent asserts for prev_timestamp_ the value should be updated to this value
         assert_eq!(price_data.prev_timestamp_, 1);
+        assert_eq!(price_data.price_cumulative.price, 42 + 3 * 81);
+        assert_eq!(price_data.price_cumulative.conf, 4 * 2);
+        assert_eq!(price_data.price_cumulative.num_down_slots, 0);
     }
 
     // next price doesn't change and neither does aggregate but slot does
@@ -217,6 +229,9 @@ fn test_upd_price() {
         assert_eq!(price_data.prev_price_, 81);
         assert_eq!(price_data.prev_conf_, 2);
         assert_eq!(price_data.prev_timestamp_, 4);
+        assert_eq!(price_data.price_cumulative.price, 42 + 81 * 4);
+        assert_eq!(price_data.price_cumulative.conf, 5 * 2);
+        assert_eq!(price_data.price_cumulative.num_down_slots, 0);
     }
 
     // try to publish back-in-time
@@ -250,6 +265,9 @@ fn test_upd_price() {
         assert_eq!(price_data.prev_price_, 81);
         assert_eq!(price_data.prev_conf_, 2);
         assert_eq!(price_data.prev_timestamp_, 4);
+        assert_eq!(price_data.price_cumulative.price, 42 + 81 * 4);
+        assert_eq!(price_data.price_cumulative.conf, 5 * 2);
+        assert_eq!(price_data.price_cumulative.num_down_slots, 0);
     }
 
     populate_instruction(&mut instruction_data, 50, 20, 5);
@@ -289,6 +307,9 @@ fn test_upd_price() {
         assert_eq!(price_data.prev_price_, 81);
         assert_eq!(price_data.prev_conf_, 2);
         assert_eq!(price_data.prev_timestamp_, 4);
+        assert_eq!(price_data.price_cumulative.price, 42 + 81 * 4);
+        assert_eq!(price_data.price_cumulative.conf, 2 * 5);
+        assert_eq!(price_data.price_cumulative.num_down_slots, 0);
     }
 
     // Negative prices are accepted
@@ -320,13 +341,16 @@ fn test_upd_price() {
         assert_eq!(price_data.prev_price_, 81);
         assert_eq!(price_data.prev_conf_, 2);
         assert_eq!(price_data.prev_timestamp_, 4);
+        assert_eq!(price_data.price_cumulative.price, 42 + 81 * 4 - 100 * 3);
+        assert_eq!(price_data.price_cumulative.conf, 2 * 5 + 3); // 2 * 5 + 1 * 3
+        assert_eq!(price_data.price_cumulative.num_down_slots, 0);
     }
 
     // add new test for multiple publishers and ensure that agg price is not updated multiple times when program upgrade happens in the same slot after the first update
     let mut funding_setup_two = AccountSetup::new_funding();
     let funding_account_two = funding_setup_two.as_account_info();
 
-    add_publisher(&mut price_account, funding_account_two.key, 1);
+    add_publisher(&mut price_account, funding_account_two.key);
 
     populate_instruction(&mut instruction_data, 10, 1, 10);
     update_clock_slot(&mut clock_account, 10);
@@ -359,7 +383,12 @@ fn test_upd_price() {
         assert_eq!(price_data.prev_timestamp_, 4);
         assert_eq!(price_data.twap_.numer_, 1677311098);
         assert_eq!(price_data.twap_.denom_, 1279419481);
-        assert_eq!(price_data.price_cumulative.price, 86);
+        assert_eq!(
+            price_data.price_cumulative.price,
+            42 + 81 * 4 - 100 * 3 + 10 * 2
+        );
+        assert_eq!(price_data.price_cumulative.conf, 2 * 5 + 5); // 2 * 5 + 1 * 5
+        assert_eq!(price_data.price_cumulative.num_down_slots, 0);
     }
 
     // reset twap_.denom_ to 0 to simulate program upgrade in the same slot and make sure agg_.price_ is not updated again
@@ -396,7 +425,111 @@ fn test_upd_price() {
         assert_eq!(price_data.prev_timestamp_, 4);
         assert_eq!(price_data.twap_.numer_, 1677311098); // twap_.numer_ should not be updated
         assert_eq!(price_data.twap_.denom_, 1279419481); // twap_.denom_ should not be updated
-        assert_eq!(price_data.price_cumulative.price, 86); // price_cumulative should not be updated
+
+        // price_cumulative should not be updated
+        assert_eq!(
+            price_data.price_cumulative.price,
+            42 + 81 * 4 - 100 * 3 + 10 * 2
+        );
+        assert_eq!(price_data.price_cumulative.conf, 2 * 5 + 5);
+        assert_eq!(price_data.price_cumulative.num_down_slots, 0);
+    }
+
+    remove_publisher(&mut price_account);
+    // Big gap
+    populate_instruction(&mut instruction_data, 60, 4, 50);
+    update_clock_slot(&mut clock_account, 50);
+
+    assert!(process_instruction(
+        &program_id,
+        &[
+            funding_account.clone(),
+            price_account.clone(),
+            clock_account.clone()
+        ],
+        &instruction_data
+    )
+    .is_ok());
+
+    {
+        let price_data = load_checked::<PriceAccount>(&price_account, PC_VERSION).unwrap();
+        assert_eq!(price_data.comp_[0].latest_.price_, 60);
+        assert_eq!(price_data.comp_[0].latest_.conf_, 4);
+        assert_eq!(price_data.comp_[0].latest_.pub_slot_, 50);
+        assert_eq!(price_data.comp_[0].latest_.status_, PC_STATUS_TRADING);
+        assert_eq!(price_data.valid_slot_, 10);
+        assert_eq!(price_data.agg_.pub_slot_, 50);
+        assert_eq!(price_data.agg_.price_, 60);
+        assert_eq!(price_data.agg_.conf_, 4);
+        assert_eq!(price_data.agg_.status_, PC_STATUS_TRADING);
+        assert_eq!(
+            price_data.price_cumulative.price,
+            42 + 81 * 4 - 100 * 3 + 10 * 2 + 60 * 40
+        );
+        assert_eq!(price_data.price_cumulative.conf, 2 * 5 + 5 + 40 * 4);
+        assert_eq!(price_data.price_cumulative.num_down_slots, 15);
+    }
+
+    // add new test for multiple publishers and ensure that price_cumulative is updated correctly
+    add_publisher(&mut price_account, funding_account_two.key);
+    populate_instruction(&mut instruction_data, 10, 1, 100);
+    update_clock_slot(&mut clock_account, 100);
+    assert!(process_instruction(
+        &program_id,
+        &[
+            funding_account.clone(),
+            price_account.clone(),
+            clock_account.clone()
+        ],
+        &instruction_data
+    )
+    .is_ok());
+
+    populate_instruction(&mut instruction_data, 20, 2, 100);
+    assert!(process_instruction(
+        &program_id,
+        &[
+            funding_account_two.clone(),
+            price_account.clone(),
+            clock_account.clone()
+        ],
+        &instruction_data
+    )
+    .is_ok());
+
+    {
+        let price_data = load_checked::<PriceAccount>(&price_account, PC_VERSION).unwrap();
+        assert_eq!(price_data.comp_[0].latest_.price_, 10);
+        assert_eq!(price_data.comp_[0].latest_.conf_, 1);
+        assert_eq!(price_data.comp_[0].latest_.pub_slot_, 100);
+        assert_eq!(price_data.comp_[0].latest_.status_, PC_STATUS_TRADING);
+        assert_eq!(price_data.comp_[1].latest_.price_, 20);
+        assert_eq!(price_data.comp_[1].latest_.conf_, 2);
+        assert_eq!(price_data.comp_[1].latest_.pub_slot_, 100);
+        assert_eq!(price_data.comp_[1].latest_.status_, PC_STATUS_TRADING);
+        assert_eq!(price_data.valid_slot_, 100);
+        assert_eq!(price_data.agg_.pub_slot_, 100);
+        assert_eq!(price_data.agg_.price_, 14);
+        assert_eq!(price_data.agg_.conf_, 6);
+        assert_eq!(price_data.agg_.status_, PC_STATUS_TRADING);
+        assert_eq!(price_data.prev_slot_, 50);
+        assert_eq!(price_data.prev_price_, 60);
+        assert_eq!(price_data.prev_conf_, 4);
+        assert_eq!(
+            price_data.prev_price_cumulative.price,
+            42 + 81 * 4 - 100 * 3 + 10 * 2 + 60 * 40
+        );
+        assert_eq!(price_data.prev_price_cumulative.conf, 2 * 5 + 5 + 40 * 4);
+        assert_eq!(price_data.prev_price_cumulative.num_down_slots, 15);
+        assert_eq!(
+            price_data.price_cumulative.price,
+            42 + 81 * 4 - 100 * 3 + 10 * 2 + 60 * 40 + 14 * 50
+        ); // (42 + 81 * 4 - 100 * 3 + 10 * 2 + 60 * 40 + 55) is the price cumulative from the previous test and 14 * 49 (slot_gap) is the price cumulative from this test
+        assert_eq!(
+            price_data.price_cumulative.conf,
+            2 * 5 + 5 + 40 * 4 + 6 * 50
+        );
+        assert_eq!(price_data.price_cumulative.num_down_slots, 40); // prev num_down_slots was 15 and since pub slot is 100 and last pub slot was 50, slot_gap is 50 and default latency is 25, so num_down_slots = 50 - 25 = 25, so total num_down_slots = 15 + 25 = 40
     }
 }
 
@@ -411,8 +544,16 @@ fn populate_instruction(instruction_data: &mut [u8], price: i64, conf: u64, pub_
     cmd.unused_ = 0;
 }
 
-fn add_publisher(price_account: &mut AccountInfo, publisher_key: &Pubkey, index: usize) {
+fn add_publisher(price_account: &mut AccountInfo, publisher_key: &Pubkey) {
     let mut price_data = load_checked::<PriceAccount>(price_account, PC_VERSION).unwrap();
-    price_data.num_ = (index + 1) as u32;
+    let index = price_data.num_ as usize;
     price_data.comp_[index].pub_ = *publisher_key;
+    price_data.num_ += 1;
+}
+
+fn remove_publisher(price_account: &mut AccountInfo) {
+    let mut price_data = load_checked::<PriceAccount>(price_account, PC_VERSION).unwrap();
+    if price_data.num_ > 0 {
+        price_data.num_ -= 1;
+    }
 }