Add RPC support for versioned transactions (#22530)

* Add RPC support for versioned transactions

* fix doc tests

* Add rpc test for versioned txs

* Switch to preflight bank

sdk/src/transaction/sanitized.rs

@@ -65,10 +65,11 @@ impl SanitizedTransaction {
         let signatures = tx.signatures;
         let message = match tx.message {
             VersionedMessage::Legacy(message) => SanitizedMessage::Legacy(message),
-            VersionedMessage::V0(message) => SanitizedMessage::V0(v0::LoadedMessage {
-                loaded_addresses: address_loader.load_addresses(&message.address_table_lookups)?,
-                message,
-            }),
+            VersionedMessage::V0(message) => {
+                let loaded_addresses =
+                    address_loader.load_addresses(&message.address_table_lookups)?;
+                SanitizedMessage::V0(v0::LoadedMessage::new(message, loaded_addresses))
+            }
         };
 
         let is_simple_vote_tx = is_simple_vote_tx.unwrap_or_else(|| {
@@ -139,7 +140,7 @@ impl SanitizedTransaction {
         match &self.message {
             SanitizedMessage::V0(sanitized_msg) => VersionedTransaction {
                 signatures,
-                message: VersionedMessage::V0(sanitized_msg.message.clone()),
+                message: VersionedMessage::V0(v0::Message::clone(&sanitized_msg.message)),
             },
             SanitizedMessage::Legacy(message) => VersionedTransaction {
                 signatures,
@@ -191,7 +192,7 @@ impl SanitizedTransaction {
     pub fn get_loaded_addresses(&self) -> LoadedAddresses {
         match &self.message {
             SanitizedMessage::Legacy(_) => LoadedAddresses::default(),
-            SanitizedMessage::V0(message) => message.loaded_addresses.clone(),
+            SanitizedMessage::V0(message) => LoadedAddresses::clone(&message.loaded_addresses),
         }
     }
 
@@ -204,7 +205,7 @@ impl SanitizedTransaction {
     fn message_data(&self) -> Vec<u8> {
         match &self.message {
             SanitizedMessage::Legacy(message) => message.serialize(),
-            SanitizedMessage::V0(message) => message.serialize(),
+            SanitizedMessage::V0(loaded_msg) => loaded_msg.message.serialize(),
         }
     }
 

sdk/src/transaction/versioned.rs

@@ -17,6 +17,24 @@ use {
     std::cmp::Ordering,
 };
 
+/// Type that serializes to the string "legacy"
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Legacy {
+    Legacy,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", untagged)]
+pub enum TransactionVersion {
+    Legacy(Legacy),
+    Number(u8),
+}
+
+impl TransactionVersion {
+    pub const LEGACY: Self = Self::Legacy(Legacy::Legacy);
+}
+
 // NOTE: Serialization-related changes must be paired with the direct read at sigverify.
 /// An atomic transaction
 #[derive(Debug, PartialEq, Default, Eq, Clone, Serialize, Deserialize, AbiExample)]
@@ -93,6 +111,14 @@ impl VersionedTransaction {
         })
     }
 
+    /// Returns the version of the transaction
+    pub fn version(&self) -> TransactionVersion {
+        match self.message {
+            VersionedMessage::Legacy(_) => TransactionVersion::LEGACY,
+            VersionedMessage::V0(_) => TransactionVersion::Number(0),
+        }
+    }
+
     /// Returns a legacy transaction if the transaction message is legacy.
     pub fn into_legacy_transaction(self) -> Option<Transaction> {
         match self.message {