test: add initial v2 tests to validator

Author: Reisen

runtime/src/bank/pyth_accumulator_tests.rs

@@ -669,6 +669,295 @@ fn test_update_accumulator_end_of_block() {
     );
 }
 
+// This test will
+#[test]
+fn test_accumulator_v2() {
+    let leader_pubkey = solana_sdk::pubkey::new_rand();
+    let GenesisConfigInfo {
+        mut genesis_config, ..
+    } = create_genesis_config_with_leader(5, &leader_pubkey, 3);
+
+    // Set epoch length to 32 so we can advance epochs quickly. We also skip past slot 0 here
+    // due to slot 0 having special handling.
+    let slots_in_epoch = 32;
+    genesis_config.epoch_schedule = EpochSchedule::new(slots_in_epoch);
+    let mut bank = Bank::new_for_tests(&genesis_config);
+    bank = new_from_parent(&Arc::new(bank));
+    bank = new_from_parent(&Arc::new(bank));
+
+    let generate_price = |seeds, generate_buffers| {
+        let (price_feed_key, _bump) = Pubkey::find_program_address(&[seeds], &ORACLE_PUBKEY);
+        let mut price_feed_account =
+            AccountSharedData::new(42, size_of::<PriceAccount>(), &ORACLE_PUBKEY);
+
+        let price_account = PriceAccount::initialize(
+            &AccountInfo::new(
+                &price_feed_key.to_bytes().into(),
+                false,
+                true,
+                &mut 0,
+                &mut price_feed_account.data_mut(),
+                &ORACLE_PUBKEY.to_bytes().into(),
+                false,
+                Epoch::default(),
+            ),
+            0,
+        )
+        .unwrap();
+
+        bank.store_account(&price_feed_key, &price_feed_account);
+
+        if generate_buffers {
+            // Insert into message buffer in reverse order to test that accumulator
+            // sorts first.
+            let message_0 = vec![1u8; 127]; // Price Account
+            let message_1 = vec![2u8; 127]; // Twap
+            let messages = vec![message_1, message_0];
+            let message_buffer_bytes = create_message_buffer_bytes(messages.clone());
+
+            // Create a Message account.
+            let price_message_key = keypair_from_seed(&[1u8; 32]).unwrap();
+            let mut price_message_account = bank
+                .get_account(&price_message_key.pubkey())
+                .unwrap_or_default();
+            price_message_account.set_lamports(1_000_000_000);
+            price_message_account
+                .set_owner(Pubkey::new_from_array(pythnet_sdk::MESSAGE_BUFFER_PID));
+            price_message_account.set_data(message_buffer_bytes);
+
+            // Store Message account so the accumulator sysvar updater can find it.
+            bank.store_account(&price_message_key.pubkey(), &price_message_account);
+        }
+    };
+
+    // TODO: New test functionality here.
+    // 1. Create Price Feed Accounts owned by ORACLE_PUBKEY
+    // 2. Populate Price Feed Accounts
+    // 3. Call update_v2()
+    //    - Cases:
+    //      - No V1 Messages, Only Price Accounts with no V2
+    //      - No V1 Messages, Some Price Accounts with no V2
+    //      - Some V1 Messages, No Price Accounts with no V2
+    //      - Some V1 Messages, Some Price Accounts with no V2
+    //      - Simulate PriceUpdate that WOULD trigger a real V1 aggregate before End of Slot
+    //      - Simulate PriceUpdate that doesn't trigger a real V1 aggregate, only V2.
+
+    // Case 1:
+    {
+        let price_pubkeys = [
+            generate_price(&["seeds_1"], false),
+            generate_price(&["seeds_2"], false),
+            generate_price(&["seeds_3"], false),
+            generate_price(&["seeds_4"], false),
+        ];
+    }
+
+    // Derive the Wormhole Message Account that will be generated by the sysvar updater.
+    let (wormhole_message_pubkey, _bump) = Pubkey::find_program_address(
+        &[b"AccumulatorMessage", &(bank.slot() as u32).to_be_bytes()],
+        &Pubkey::new_from_array(pythnet_sdk::pythnet::WORMHOLE_PID),
+    );
+
+    // Account Data should be empty at this point. Check account data is [].
+    let wormhole_message_account = bank
+        .get_account(&wormhole_message_pubkey)
+        .unwrap_or_default();
+    assert_eq!(wormhole_message_account.data().len(), 0);
+
+    // Run accumulator by creating a new bank from parent, the feature is
+    // disabled so account data should still be empty. Check account data is
+    // still [].
+    bank = new_from_parent(&Arc::new(bank));
+
+    assert_eq!(
+        bank.feature_set
+            .is_active(&feature_set::enable_accumulator_sysvar::id()),
+        false
+    );
+    assert_eq!(
+        bank.feature_set
+            .is_active(&feature_set::move_accumulator_to_end_of_block::id()),
+        false
+    );
+
+    let wormhole_message_account = bank
+        .get_account(&wormhole_message_pubkey)
+        .unwrap_or_default();
+    assert_eq!(wormhole_message_account.data().len(), 0);
+
+    bank.compute_active_feature_set(true);
+    for _ in 0..slots_in_epoch {
+        bank = new_from_parent(&Arc::new(bank));
+    }
+
+    // The current sequence value will be used in the message when the bank advances, so we snapshot
+    // it here before freezing the bank so we can assert the correct sequence is present in the message.
+    let sequence_tracker_before_bank_freeze = get_acc_sequence_tracker(&bank);
+    // Freeze the bank to make sure accumulator is updated
+    bank.freeze();
+
+    // get the timestamp & slot for the message
+    let ring_index = (bank.slot() % ACCUMULATOR_RING_SIZE as u64) as u32;
+    let wormhole_message_account = get_wormhole_message_account(&bank, ring_index);
+
+    assert_ne!(wormhole_message_account.data().len(), 0);
+
+    let wormhole_message =
+        PostedMessageUnreliableData::deserialize(&mut wormhole_message_account.data()).unwrap();
+
+    let messages = messages.iter().map(|m| m.as_slice()).collect::<Vec<_>>();
+    let accumulator_elements = messages.clone().into_iter().sorted_unstable().dedup();
+    let expected_accumulator =
+        MerkleAccumulator::<Keccak160>::from_set(accumulator_elements).unwrap();
+    let expected_wormhole_message_payload =
+        expected_accumulator.serialize(bank.slot(), ACCUMULATOR_RING_SIZE);
+    assert_eq!(
+        wormhole_message.message.payload,
+        expected_wormhole_message_payload
+    );
+
+    let expected_wormhole_message = PostedMessageUnreliableData {
+        message: MessageData {
+            vaa_version: 1,
+            consistency_level: 1,
+            submission_time: bank.clock().unix_timestamp as u32,
+            sequence: sequence_tracker_before_bank_freeze.sequence, // sequence is incremented after the message is processed
+            emitter_chain: 26,
+            emitter_address: ACCUMULATOR_EMITTER_ADDRESS,
+            payload: expected_wormhole_message_payload,
+            ..Default::default()
+        },
+    };
+
+    assert_eq!(
+        wormhole_message_account.data().to_vec(),
+        expected_wormhole_message.try_to_vec().unwrap()
+    );
+
+    // verify hashes verify in accumulator
+    for msg in messages {
+        let msg_hash = Keccak160::hashv(&[[0u8].as_ref(), msg]);
+        let msg_proof = expected_accumulator.prove(msg).unwrap();
+
+        assert!(expected_accumulator.nodes.contains(&msg_hash));
+        assert!(expected_accumulator.check(msg_proof, msg));
+    }
+
+    // verify accumulator state account
+    let accumulator_state = get_accumulator_state(&bank, ring_index);
+    let acc_state_magic = &accumulator_state[..4];
+    let acc_state_slot = LittleEndian::read_u64(&accumulator_state[4..12]);
+    let acc_state_ring_size = LittleEndian::read_u32(&accumulator_state[12..16]);
+
+    assert_eq!(acc_state_magic, b"PAS1");
+    assert_eq!(acc_state_slot, bank.slot());
+    assert_eq!(acc_state_ring_size, ACCUMULATOR_RING_SIZE);
+
+    let mut cursor = std::io::Cursor::new(&accumulator_state[16..]);
+    let num_elems = cursor.read_u32::<LittleEndian>().unwrap();
+    for _ in 0..(num_elems as usize) {
+        let element_len = cursor.read_u32::<LittleEndian>().unwrap();
+        let mut element_data = vec![0u8; element_len as usize];
+        cursor.read_exact(&mut element_data).unwrap();
+
+        let elem_hash = Keccak160::hashv(&[[0u8].as_ref(), element_data.as_slice()]);
+        let elem_proof = expected_accumulator.prove(element_data.as_slice()).unwrap();
+
+        assert!(expected_accumulator.nodes.contains(&elem_hash));
+        assert!(expected_accumulator.check(elem_proof, element_data.as_slice()));
+    }
+
+    // verify sequence_tracker increments
+    assert_eq!(
+        get_acc_sequence_tracker(&bank).sequence,
+        sequence_tracker_before_bank_freeze.sequence + 1
+    );
+
+    // verify ring buffer cycles
+    let ring_index_before_buffer_cycle = (bank.slot() % ACCUMULATOR_RING_SIZE as u64) as u32;
+    let target_slot = bank.slot() + ACCUMULATOR_RING_SIZE as u64;
+    // advance ACCUMULATOR_RING_SIZE slots using warp_from_parent since doing large loops
+    // with new_from_parent takes a long time. warp_from_parent results in a bank that is frozen.
+    bank = Bank::warp_from_parent(&Arc::new(bank), &Pubkey::default(), target_slot);
+
+    // accumulator messages should still be the same before looping around
+    let ring_index_after_buffer_cycle = (bank.slot() % ACCUMULATOR_RING_SIZE as u64) as u32;
+    assert_eq!(
+        ring_index_before_buffer_cycle,
+        ring_index_after_buffer_cycle
+    );
+
+    let accumulator_state_after_skip = get_accumulator_state(&bank, ring_index_after_buffer_cycle);
+    assert_eq!(
+        &accumulator_state[16..],
+        &accumulator_state_after_skip[16..]
+    );
+
+    // insert new message to make sure the update is written in the right position
+    // in the ring buffer and overwrites the existing message
+
+    // advance the bank to unfreeze it (to be able to store accounts). see the comment on warp_from_parent above.
+    bank = new_from_parent(&Arc::new(bank));
+
+    let wh_sequence_before_acc_update = get_acc_sequence_tracker(&bank).sequence;
+
+    let message_0 = vec![1u8; 127];
+    let message_1 = vec![2u8; 127];
+    let message_2 = vec![3u8; 254];
+
+    let updated_messages = vec![message_1.clone(), message_2.clone(), message_0.clone()];
+
+    let updated_message_buffer_bytes = create_message_buffer_bytes(updated_messages.clone());
+    price_message_account.set_data(updated_message_buffer_bytes);
+
+    // Store Message account so the accumulator sysvar updater can find it.
+    bank.store_account(&price_message_key.pubkey(), &price_message_account);
+
+    // Freeze the bank to run accumulator
+    bank.freeze();
+
+    let ring_index = (bank.slot() % ACCUMULATOR_RING_SIZE as u64) as u32;
+    let updated_wormhole_message_account = get_wormhole_message_account(&bank, ring_index);
+
+    let updated_wormhole_message =
+        PostedMessageUnreliableData::deserialize(&mut updated_wormhole_message_account.data())
+            .unwrap();
+
+    let updated_messages = updated_messages
+        .iter()
+        .map(|m| m.as_slice())
+        .collect::<Vec<_>>();
+    let updated_accumulator_elements = updated_messages
+        .clone()
+        .into_iter()
+        .sorted_unstable()
+        .dedup();
+
+    let expected_accumulator =
+        MerkleAccumulator::<Keccak160>::from_set(updated_accumulator_elements).unwrap();
+    assert_eq!(
+        updated_wormhole_message.message.payload,
+        expected_accumulator.serialize(bank.slot(), ACCUMULATOR_RING_SIZE)
+    );
+
+    let expected_wormhole_message = PostedMessageUnreliableData {
+        message: MessageData {
+            vaa_version: 1,
+            consistency_level: 1,
+            submission_time: bank.clock().unix_timestamp as u32,
+            sequence: wh_sequence_before_acc_update,
+            emitter_chain: 26,
+            emitter_address: ACCUMULATOR_EMITTER_ADDRESS,
+            payload: expected_accumulator.serialize(bank.slot(), ACCUMULATOR_RING_SIZE),
+            ..Default::default()
+        },
+    };
+
+    assert_eq!(
+        updated_wormhole_message_account.data(),
+        expected_wormhole_message.try_to_vec().unwrap()
+    );
+}
 #[test]
 fn test_get_accumulator_keys() {
     use pythnet_sdk::{pythnet, ACCUMULATOR_EMITTER_ADDRESS, MESSAGE_BUFFER_PID};