refactor(transaction-view): `try_from` -> `try_new` (#9182)

core/src/banking_stage/consume_worker.rs

@@ -1367,8 +1367,8 @@ pub(crate) mod external {
             fn to_resolved_view(
                 tx: &'_ [u8],
             ) -> RuntimeTransaction<ResolvedTransactionView<&'_ [u8]>> {
-                RuntimeTransaction::<ResolvedTransactionView<_>>::try_from(
-                    RuntimeTransaction::<SanitizedTransactionView<_>>::try_from(
+                RuntimeTransaction::<ResolvedTransactionView<_>>::try_new(
+                    RuntimeTransaction::<SanitizedTransactionView<_>>::try_new(
                         SanitizedTransactionView::try_new_sanitized(tx, true).unwrap(),
                         solana_transaction::sanitized::MessageHash::Compute,
                         Some(false),

core/src/banking_stage/transaction_scheduler/receive_and_buffer.rs

@@ -456,7 +456,7 @@ pub(crate) fn translate_to_runtime_view<D: TransactionData>(
         return Err(PacketHandlingError::Sanitization);
     };
 
-    let Ok(view) = RuntimeTransaction::<SanitizedTransactionView<_>>::try_from(
+    let Ok(view) = RuntimeTransaction::<SanitizedTransactionView<_>>::try_new(
         view,
         MessageHash::Compute,
         None,
@@ -475,7 +475,7 @@ pub(crate) fn translate_to_runtime_view<D: TransactionData>(
 
     let (loaded_addresses, deactivation_slot) = load_addresses_for_view(&view, bank)?;
 
-    let Ok(view) = RuntimeTransaction::<ResolvedTransactionView<_>>::try_from(
+    let Ok(view) = RuntimeTransaction::<ResolvedTransactionView<_>>::try_new(
         view,
         loaded_addresses,
         bank.get_reserved_account_keys(),

core/src/banking_stage/transaction_scheduler/transaction_state_container.rs

@@ -475,13 +475,13 @@ mod tests {
         let reserved_addresses = HashSet::default();
         let packet_parser = |data, priority, cost| {
             let view = SanitizedTransactionView::try_new_sanitized(data, true).unwrap();
-            let view = RuntimeTransaction::<SanitizedTransactionView<_>>::try_from(
+            let view = RuntimeTransaction::<SanitizedTransactionView<_>>::try_new(
                 view,
                 MessageHash::Compute,
                 None,
             )
             .unwrap();
-            let view = RuntimeTransaction::<ResolvedTransactionView<_>>::try_from(
+            let view = RuntimeTransaction::<ResolvedTransactionView<_>>::try_new(
                 view,
                 None,
                 &reserved_addresses,

core/src/banking_stage/vote_worker.rs

@@ -514,7 +514,7 @@ fn consume_scan_should_process_packet(
     error_counters: &mut TransactionErrorMetrics,
 ) -> Option<RuntimeTransactionView> {
     // Construct the RuntimeTransaction.
-    let Ok(view) = RuntimeTransaction::<SanitizedTransactionView<_>>::try_from(
+    let Ok(view) = RuntimeTransaction::<SanitizedTransactionView<_>>::try_new(
         packet,
         MessageHash::Compute,
         None,
@@ -529,7 +529,7 @@ fn consume_scan_should_process_packet(
 
     // Resolve the transaction (votes do not have LUTs).
     debug_assert!(!matches!(view.version(), TransactionVersion::V0));
-    let Ok(view) = RuntimeTransactionView::try_from(view, None, bank.get_reserved_account_keys())
+    let Ok(view) = RuntimeTransactionView::try_new(view, None, bank.get_reserved_account_keys())
     else {
         return None;
     };
@@ -574,14 +574,14 @@ mod tests {
         let tx =
             SanitizedTransactionView::try_new_sanitized(Arc::new(packet.buffer().to_vec()), false)
                 .unwrap();
-        let tx = RuntimeTransaction::<SanitizedTransactionView<_>>::try_from(
+        let tx = RuntimeTransaction::<SanitizedTransactionView<_>>::try_new(
             tx,
             MessageHash::Compute,
             None,
         )
         .unwrap();
 
-        RuntimeTransactionView::try_from(tx, None, &HashSet::default()).unwrap()
+        RuntimeTransactionView::try_new(tx, None, &HashSet::default()).unwrap()
     }
 
     #[test]

core/src/forwarding_stage.rs

@@ -320,7 +320,7 @@ impl<VoteClient: ForwardingClient, NonVoteClient: ForwardingClient>
                 )
                 .map_err(|_| ())
                 .and_then(|transaction| {
-                    RuntimeTransaction::<SanitizedTransactionView<_>>::try_from(
+                    RuntimeTransaction::<SanitizedTransactionView<_>>::try_new(
                         transaction,
                         MessageHash::Compute,
                         Some(packet.meta().is_simple_vote_tx()),

runtime-transaction/src/runtime_transaction/transaction_view.rs

@@ -39,7 +39,7 @@ fn is_simple_vote_transaction<D: TransactionData>(
 }
 
 impl<D: TransactionData> RuntimeTransaction<SanitizedTransactionView<D>> {
-    pub fn try_from(
+    pub fn try_new(
         transaction: SanitizedTransactionView<D>,
         message_hash: MessageHash,
         is_simple_vote_tx: Option<bool>,
@@ -82,7 +82,7 @@ impl<D: TransactionData> RuntimeTransaction<ResolvedTransactionView<D>> {
     /// Create a new `RuntimeTransaction<ResolvedTransactionView>` from a
     /// `RuntimeTransaction<SanitizedTransactionView>` that already has
     /// static metadata loaded.
-    pub fn try_from(
+    pub fn try_new(
         statically_loaded_runtime_tx: RuntimeTransaction<SanitizedTransactionView<D>>,
         loaded_addresses: Option<LoadedAddresses>,
         reserved_account_keys: &HashSet<Pubkey>,
@@ -222,7 +222,7 @@ mod tests {
         let transaction =
             SanitizedTransactionView::try_new_sanitized(&serialized_transaction[..], true).unwrap();
         let static_runtime_transaction =
-            RuntimeTransaction::<SanitizedTransactionView<_>>::try_from(
+            RuntimeTransaction::<SanitizedTransactionView<_>>::try_new(
                 transaction,
                 MessageHash::Precomputed(hash),
                 None,
@@ -233,7 +233,7 @@ mod tests {
         assert!(!static_runtime_transaction.is_simple_vote_transaction());
 
         let dynamic_runtime_transaction =
-            RuntimeTransaction::<ResolvedTransactionView<_>>::try_from(
+            RuntimeTransaction::<ResolvedTransactionView<_>>::try_new(
                 static_runtime_transaction,
                 None,
                 &ReservedAccountKeys::empty_key_set(),
@@ -254,13 +254,13 @@ mod tests {
             let bytes = bincode::serialize(&original_transaction).unwrap();
             let transaction_view =
                 SanitizedTransactionView::try_new_sanitized(&bytes[..], true).unwrap();
-            let runtime_transaction = RuntimeTransaction::<SanitizedTransactionView<_>>::try_from(
+            let runtime_transaction = RuntimeTransaction::<SanitizedTransactionView<_>>::try_new(
                 transaction_view,
                 MessageHash::Compute,
                 None,
             )
             .unwrap();
-            let runtime_transaction = RuntimeTransaction::<ResolvedTransactionView<_>>::try_from(
+            let runtime_transaction = RuntimeTransaction::<ResolvedTransactionView<_>>::try_new(
                 runtime_transaction,
                 loaded_addresses,
                 reserved_account_keys,
@@ -321,13 +321,13 @@ mod tests {
                 bincode::serialize(&original_transaction.to_versioned_transaction()).unwrap();
             let transaction_view =
                 SanitizedTransactionView::try_new_sanitized(&bytes[..], true).unwrap();
-            let runtime_transaction = RuntimeTransaction::<SanitizedTransactionView<_>>::try_from(
+            let runtime_transaction = RuntimeTransaction::<SanitizedTransactionView<_>>::try_new(
                 transaction_view,
                 MessageHash::Compute,
                 None,
             )
             .unwrap();
-            let runtime_transaction = RuntimeTransaction::<ResolvedTransactionView<_>>::try_from(
+            let runtime_transaction = RuntimeTransaction::<ResolvedTransactionView<_>>::try_new(
                 runtime_transaction,
                 loaded_addresses,
                 reserved_account_keys,