tests

Author: 2501babe

svm-transaction/src/tests.rs

@@ -10,7 +10,7 @@ use {
         VersionedMessage,
     },
     solana_pubkey::Pubkey,
-    solana_sdk_ids::system_program,
+    solana_sdk_ids::{bpf_loader_upgradeable, system_program},
     solana_system_interface::instruction::SystemInstruction,
     std::collections::HashSet,
 };
@@ -23,6 +23,24 @@ fn test_get_durable_nonce() {
         account_keys: Vec<Pubkey>,
         instructions: Vec<CompiledInstruction>,
         loaded_addresses: Option<LoadedAddresses>,
+    ) -> SanitizedMessage {
+        create_message_for_test_with_reserved_keys(
+            num_signers,
+            num_writable,
+            account_keys,
+            instructions,
+            loaded_addresses,
+            &HashSet::new(),
+        )
+    }
+
+    fn create_message_for_test_with_reserved_keys(
+        num_signers: u8,
+        num_writable: u8,
+        account_keys: Vec<Pubkey>,
+        instructions: Vec<CompiledInstruction>,
+        loaded_addresses: Option<LoadedAddresses>,
+        reserved_account_keys: &HashSet<Pubkey>,
     ) -> SanitizedMessage {
         let header = MessageHeader {
             num_required_signatures: num_signers,
@@ -64,7 +82,7 @@ fn test_get_durable_nonce() {
         SanitizedMessage::try_new(
             SanitizedVersionedMessage::try_new(versioned_message).unwrap(),
             loader,
-            &HashSet::new(),
+            reserved_account_keys,
         )
         .unwrap()
     }
@@ -73,6 +91,7 @@ fn test_get_durable_nonce() {
     {
         let message = create_message_for_test(1, 1, vec![Pubkey::new_unique()], vec![], None);
         assert!(SVMMessage::get_durable_nonce(&message).is_none());
+        assert!(SVMStaticMessage::get_durable_nonce_simd602(&message).is_none());
     }
 
     // system program id instruction - invalid
@@ -85,6 +104,7 @@ fn test_get_durable_nonce() {
             None,
         );
         assert!(SVMMessage::get_durable_nonce(&message).is_none());
+        assert!(SVMStaticMessage::get_durable_nonce_simd602(&message).is_none());
     }
 
     // system program id instruction - not nonce
@@ -101,6 +121,7 @@ fn test_get_durable_nonce() {
             None,
         );
         assert!(SVMMessage::get_durable_nonce(&message).is_none());
+        assert!(SVMStaticMessage::get_durable_nonce_simd602(&message).is_none());
     }
 
     // system program id - nonce instruction (no accounts)
@@ -117,6 +138,7 @@ fn test_get_durable_nonce() {
             None,
         );
         assert!(SVMMessage::get_durable_nonce(&message).is_none());
+        assert!(SVMStaticMessage::get_durable_nonce_simd602(&message).is_none());
     }
 
     // system program id - nonce instruction (non-fee-payer, non-writable)
@@ -135,6 +157,7 @@ fn test_get_durable_nonce() {
             None,
         );
         assert!(SVMMessage::get_durable_nonce(&message).is_none());
+        assert!(SVMStaticMessage::get_durable_nonce_simd602(&message).is_none());
     }
 
     // system program id - nonce instruction fee-payer
@@ -152,6 +175,10 @@ fn test_get_durable_nonce() {
             None,
         );
         assert_eq!(SVMMessage::get_durable_nonce(&message), Some(&payer_nonce));
+        assert_eq!(
+            SVMStaticMessage::get_durable_nonce_simd602(&message),
+            Some(&payer_nonce)
+        );
     }
 
     // system program id - nonce instruction w/ trailing bytes fee-payer
@@ -171,6 +198,10 @@ fn test_get_durable_nonce() {
             None,
         );
         assert_eq!(SVMMessage::get_durable_nonce(&message), Some(&payer_nonce));
+        assert_eq!(
+            SVMStaticMessage::get_durable_nonce_simd602(&message),
+            Some(&payer_nonce)
+        );
     }
 
     // system program id - nonce instruction (non-fee-payer)
@@ -189,6 +220,10 @@ fn test_get_durable_nonce() {
             None,
         );
         assert_eq!(SVMMessage::get_durable_nonce(&message), Some(&nonce));
+        assert_eq!(
+            SVMStaticMessage::get_durable_nonce_simd602(&message),
+            Some(&nonce)
+        );
     }
 
     // system program id - nonce instruction (non-fee-payer, multiple accounts)
@@ -208,6 +243,10 @@ fn test_get_durable_nonce() {
             None,
         );
         assert_eq!(SVMMessage::get_durable_nonce(&message), Some(&nonce));
+        assert_eq!(
+            SVMStaticMessage::get_durable_nonce_simd602(&message),
+            Some(&nonce)
+        );
     }
 
     // system program id - nonce instruction (non-fee-payer, loaded account)
@@ -229,6 +268,73 @@ fn test_get_durable_nonce() {
             }),
         );
         assert_eq!(SVMMessage::get_durable_nonce(&message), None);
+        assert_eq!(SVMStaticMessage::get_durable_nonce_simd602(&message), None);
+    }
+
+    // system program id - nonce instruction (nonce is program id, write-demoted)
+    {
+        let payer = Pubkey::new_unique();
+        let nonce = Pubkey::new_unique();
+        let message = create_message_for_test(
+            1,
+            2,
+            vec![payer, nonce, system_program::id()],
+            vec![
+                CompiledInstruction::new(2, &SystemInstruction::AdvanceNonceAccount, vec![1]),
+                CompiledInstruction::new_from_raw_parts(1, vec![], vec![]),
+            ],
+            None,
+        );
+        assert!(SVMMessage::get_durable_nonce(&message).is_none());
+        assert!(SVMStaticMessage::get_durable_nonce_simd602(&message).is_none());
+    }
+
+    // system program id - nonce instruction (nonce is program id, upgradeable loader present)
+    // pre-simd602 relies on write demotion, which the loader disables; simd602 rejects outright
+    {
+        let payer = Pubkey::new_unique();
+        let nonce = Pubkey::new_unique();
+        let message = create_message_for_test(
+            1,
+            2,
+            vec![
+                payer,
+                nonce,
+                system_program::id(),
+                bpf_loader_upgradeable::id(),
+            ],
+            vec![
+                CompiledInstruction::new(2, &SystemInstruction::AdvanceNonceAccount, vec![1]),
+                CompiledInstruction::new_from_raw_parts(1, vec![], vec![]),
+            ],
+            None,
+        );
+        assert_eq!(SVMMessage::get_durable_nonce(&message), Some(&nonce));
+        assert!(SVMStaticMessage::get_durable_nonce_simd602(&message).is_none());
+    }
+
+    // system program id - nonce instruction (nonce is reserved key)
+    // pre-simd602 applies reserved key demotion; simd602 does not
+    {
+        let payer = Pubkey::new_unique();
+        let nonce = Pubkey::new_unique();
+        let message = create_message_for_test_with_reserved_keys(
+            1,
+            2,
+            vec![payer, nonce, system_program::id()],
+            vec![CompiledInstruction::new(
+                2,
+                &SystemInstruction::AdvanceNonceAccount,
+                vec![1],
+            )],
+            None,
+            &HashSet::from([nonce]),
+        );
+        assert!(SVMMessage::get_durable_nonce(&message).is_none());
+        assert_eq!(
+            SVMStaticMessage::get_durable_nonce_simd602(&message),
+            Some(&nonce)
+        );
     }
 }