wip

Cargo.toml

@@ -42,6 +42,7 @@ members = [
     "poh",
     "poh-bench",
     "program-test",
+    "programs/address_map",
     "programs/bpf_loader",
     "programs/compute-budget",
     "programs/config",

cli-output/src/cli_output.rs

@@ -2262,7 +2262,7 @@ impl fmt::Display for CliBlock {
             writeln!(f, "Transaction {}:", index)?;
             writeln_transaction(
                 f,
-                &transaction_with_meta.transaction.decode().unwrap(),
+                transaction_with_meta.transaction.decode().unwrap(),
                 &transaction_with_meta.meta,
                 "  ",
                 None,
@@ -2296,7 +2296,7 @@ impl fmt::Display for CliTransaction {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         writeln_transaction(
             f,
-            &self.decoded_transaction,
+            self.decoded_transaction.clone(),
             &self.meta,
             &self.prefix,
             if !self.sigverify_status.is_empty() {

cli-output/src/display.rs

@@ -4,13 +4,19 @@ use {
     console::style,
     indicatif::{ProgressBar, ProgressStyle},
     solana_sdk::{
-        clock::UnixTimestamp, hash::Hash, message::Message, native_token::lamports_to_sol,
-        program_utils::limited_deserialize, pubkey::Pubkey, stake, transaction::Transaction,
+        clock::UnixTimestamp,
+        hash::Hash,
+        message::SanitizedMessage,
+        native_token::lamports_to_sol,
+        program_utils::limited_deserialize,
+        pubkey::Pubkey,
+        stake,
+        transaction::{SanitizedTransaction, Transaction},
     },
     solana_transaction_status::UiTransactionStatusMeta,
     spl_memo::id as spl_memo_id,
     spl_memo::v1::id as spl_memo_v1_id,
-    std::{collections::HashMap, fmt, io},
+    std::{collections::HashMap, convert::TryFrom, fmt, io},
 };
 
 #[derive(Clone, Debug)]
@@ -132,7 +138,7 @@ pub fn println_signers(
     println!();
 }
 
-fn format_account_mode(message: &Message, index: usize) -> String {
+fn format_account_mode(message: &SanitizedMessage, index: usize) -> String {
     format!(
         "{}r{}{}", // accounts are always readable...
         if message.is_signer(index) {
@@ -147,7 +153,7 @@ fn format_account_mode(message: &Message, index: usize) -> String {
         },
         // account may be executable on-chain while not being
         // designated as a program-id in the message
-        if message.maybe_executable(index) {
+        if message.is_invoked(index) {
             "x"
         } else {
             // programs to be executed via CPI cannot be identified as
@@ -159,13 +165,13 @@ fn format_account_mode(message: &Message, index: usize) -> String {
 
 pub fn write_transaction<W: io::Write>(
     w: &mut W,
-    transaction: &Transaction,
+    transaction: &SanitizedTransaction,
     transaction_status: &Option<UiTransactionStatusMeta>,
     prefix: &str,
     sigverify_status: Option<&[CliSignatureVerificationStatus]>,
     block_time: Option<UnixTimestamp>,
 ) -> io::Result<()> {
-    let message = &transaction.message;
+    let message = transaction.message();
     if let Some(block_time) = block_time {
         writeln!(
             w,
@@ -177,18 +183,19 @@ pub fn write_transaction<W: io::Write>(
     writeln!(
         w,
         "{}Recent Blockhash: {:?}",
-        prefix, message.recent_blockhash
+        prefix,
+        message.recent_blockhash()
     )?;
     let sigverify_statuses = if let Some(sigverify_status) = sigverify_status {
         sigverify_status
             .iter()
             .map(|s| format!(" ({})", s))
             .collect()
     } else {
-        vec!["".to_string(); transaction.signatures.len()]
+        vec!["".to_string(); transaction.signatures().len()]
     };
     for (signature_index, (signature, sigverify_status)) in transaction
-        .signatures
+        .signatures()
         .iter()
         .zip(&sigverify_statuses)
         .enumerate()
@@ -200,7 +207,7 @@ pub fn write_transaction<W: io::Write>(
         )?;
     }
     let mut fee_payer_index = None;
-    for (account_index, account) in message.account_keys.iter().enumerate() {
+    for (account_index, account) in message.account_keys_iter().enumerate() {
         if fee_payer_index.is_none() && message.is_non_loader_key(account_index) {
             fee_payer_index = Some(account_index)
         }
@@ -218,16 +225,19 @@ pub fn write_transaction<W: io::Write>(
             },
         )?;
     }
-    for (instruction_index, instruction) in message.instructions.iter().enumerate() {
-        let program_pubkey = message.account_keys[instruction.program_id_index as usize];
+    for (instruction_index, (program_pubkey, instruction)) in
+        message.program_instructions_iter().enumerate()
+    {
         writeln!(w, "{}Instruction {}", prefix, instruction_index)?;
         writeln!(
             w,
             "{}  Program:   {} ({})",
             prefix, program_pubkey, instruction.program_id_index
         )?;
         for (account_index, account) in instruction.accounts.iter().enumerate() {
-            let account_pubkey = message.account_keys[*account as usize];
+            let account_pubkey = message
+                .get_account_key(*account as usize)
+                .expect("account index is sanitized");
             writeln!(
                 w,
                 "{}  Account {}: {} ({})",
@@ -236,30 +246,30 @@ pub fn write_transaction<W: io::Write>(
         }
 
         let mut raw = true;
-        if program_pubkey == solana_vote_program::id() {
+        if program_pubkey == &solana_vote_program::id() {
             if let Ok(vote_instruction) = limited_deserialize::<
                 solana_vote_program::vote_instruction::VoteInstruction,
             >(&instruction.data)
             {
                 writeln!(w, "{}  {:?}", prefix, vote_instruction)?;
                 raw = false;
             }
-        } else if program_pubkey == stake::program::id() {
+        } else if program_pubkey == &stake::program::id() {
             if let Ok(stake_instruction) =
                 limited_deserialize::<stake::instruction::StakeInstruction>(&instruction.data)
             {
                 writeln!(w, "{}  {:?}", prefix, stake_instruction)?;
                 raw = false;
             }
-        } else if program_pubkey == solana_sdk::system_program::id() {
+        } else if program_pubkey == &solana_sdk::system_program::id() {
             if let Ok(system_instruction) = limited_deserialize::<
                 solana_sdk::system_instruction::SystemInstruction,
             >(&instruction.data)
             {
                 writeln!(w, "{}  {:?}", prefix, system_instruction)?;
                 raw = false;
             }
-        } else if is_memo_program(&program_pubkey) {
+        } else if is_memo_program(program_pubkey) {
             if let Ok(s) = std::str::from_utf8(&instruction.data) {
                 writeln!(w, "{}  Data: \"{}\"", prefix, s)?;
                 raw = false;
@@ -364,7 +374,7 @@ pub fn write_transaction<W: io::Write>(
 }
 
 pub fn println_transaction(
-    transaction: &Transaction,
+    transaction: &SanitizedTransaction,
     transaction_status: &Option<UiTransactionStatusMeta>,
     prefix: &str,
     sigverify_status: Option<&[CliSignatureVerificationStatus]>,
@@ -389,25 +399,27 @@ pub fn println_transaction(
 
 pub fn writeln_transaction(
     f: &mut dyn fmt::Write,
-    transaction: &Transaction,
+    transaction: Transaction,
     transaction_status: &Option<UiTransactionStatusMeta>,
     prefix: &str,
     sigverify_status: Option<&[CliSignatureVerificationStatus]>,
     block_time: Option<UnixTimestamp>,
 ) -> fmt::Result {
     let mut w = Vec::new();
-    if write_transaction(
-        &mut w,
-        transaction,
-        transaction_status,
-        prefix,
-        sigverify_status,
-        block_time,
-    )
-    .is_ok()
-    {
-        if let Ok(s) = String::from_utf8(w) {
-            write!(f, "{}", s)?;
+    if let Ok(transaction) = SanitizedTransaction::try_from(transaction) {
+        if write_transaction(
+            &mut w,
+            &transaction,
+            transaction_status,
+            prefix,
+            sigverify_status,
+            block_time,
+        )
+        .is_ok()
+        {
+            if let Ok(s) = String::from_utf8(w) {
+                write!(f, "{}", s)?;
+            }
         }
     }
     Ok(())

cli/src/cluster_query.rs

@@ -56,12 +56,13 @@ use solana_sdk::{
         stake_history::{self},
     },
     timing,
-    transaction::Transaction,
+    transaction::{SanitizedTransaction, Transaction},
 };
 use solana_transaction_status::UiTransactionEncoding;
 use solana_vote_program::vote_state::VoteState;
 use std::{
     collections::{BTreeMap, HashMap, VecDeque},
+    convert::TryFrom,
     fmt,
     str::FromStr,
     sync::{
@@ -2022,17 +2023,26 @@ pub fn process_transaction_history(
                     },
                 ) {
                     Ok(confirmed_transaction) => {
-                        println_transaction(
-                            &confirmed_transaction
-                                .transaction
-                                .transaction
-                                .decode()
-                                .expect("Successful decode"),
-                            &confirmed_transaction.transaction.meta,
-                            "  ",
-                            None,
-                            None,
-                        );
+                        let transaction = confirmed_transaction
+                            .transaction
+                            .transaction
+                            .decode()
+                            .expect("Successful decode");
+
+                        match SanitizedTransaction::try_from(transaction) {
+                            Ok(transaction) => {
+                                println_transaction(
+                                    &transaction,
+                                    &confirmed_transaction.transaction.meta,
+                                    "  ",
+                                    None,
+                                    None,
+                                );
+                            }
+                            Err(err) => {
+                                println!("  Unable to construct sanitized transaction: {}", err)
+                            }
+                        }
                     }
                     Err(err) => println!("  Unable to get confirmed transaction details: {}", err),
                 }

core/src/banking_stage.rs

@@ -1043,23 +1043,26 @@ impl BankingStage {
     // Also returned is packet indexes for transaction should be retried due to cost limits.
     #[allow(clippy::needless_collect)]
     fn transactions_from_packets(
+        bank: &Arc<Bank>,
         msgs: &Packets,
         transaction_indexes: &[usize],
-        libsecp256k1_0_5_upgrade_enabled: bool,
         cost_tracker: &Arc<RwLock<CostTracker>>,
         banking_stage_stats: &BankingStageStats,
     ) -> (Vec<SanitizedTransaction>, Vec<usize>, Vec<usize>) {
         let mut retryable_transaction_packet_indexes: Vec<usize> = vec![];
 
+        let libsecp256k1_0_5_upgrade_enabled = bank.libsecp256k1_0_5_upgrade_enabled();
         let verified_transactions_with_packet_indexes: Vec<_> = transaction_indexes
             .iter()
             .filter_map(|tx_index| {
                 let p = &msgs.packets[*tx_index];
                 let tx: VersionedTransaction = limited_deserialize(&p.data[0..p.meta.size]).ok()?;
                 let message_bytes = Self::packet_message(p)?;
                 let message_hash = Message::hash_raw_message(message_bytes);
-                let tx = SanitizedTransaction::try_create(tx, message_hash, |_| {
-                    Err(TransactionError::UnsupportedVersion)
+                let tx = SanitizedTransaction::try_create(tx, message_hash, |message| {
+                    bank.address_map_cache()
+                        .map_message_addresses(message)
+                        .ok_or(TransactionError::AccountNotFound)
                 })
                 .ok()?;
                 tx.verify_precompiles(libsecp256k1_0_5_upgrade_enabled)
@@ -1155,9 +1158,9 @@ impl BankingStage {
         let mut packet_conversion_time = Measure::start("packet_conversion");
         let (transactions, transaction_to_packet_indexes, retryable_packet_indexes) =
             Self::transactions_from_packets(
+                bank,
                 msgs,
                 &packet_indexes,
-                bank.libsecp256k1_0_5_upgrade_enabled(),
                 cost_tracker,
                 banking_stage_stats,
             );
@@ -1257,9 +1260,9 @@ impl BankingStage {
             Measure::start("unprocessed_packet_conversion");
         let (transactions, transaction_to_packet_indexes, retry_packet_indexes) =
             Self::transactions_from_packets(
+                bank,
                 msgs,
                 transaction_indexes,
-                bank.libsecp256k1_0_5_upgrade_enabled(),
                 cost_tracker,
                 banking_stage_stats,
             );

ledger-tool/src/bigtable.rs

@@ -9,9 +9,12 @@ use solana_cli_output::{
     OutputFormat,
 };
 use solana_ledger::{blockstore::Blockstore, blockstore_db::AccessType};
-use solana_sdk::{clock::Slot, pubkey::Pubkey, signature::Signature};
+use solana_sdk::{
+    clock::Slot, pubkey::Pubkey, signature::Signature, transaction::SanitizedTransaction,
+};
 use solana_transaction_status::{ConfirmedBlock, EncodedTransaction, UiTransactionEncoding};
 use std::{
+    convert::TryFrom,
     path::Path,
     process::exit,
     result::Result,
@@ -183,13 +186,19 @@ pub async fn transaction_history(
                                     );
                                 }
                                 Some(transaction_with_meta) => {
-                                    println_transaction(
-                                        &transaction_with_meta.transaction,
-                                        &transaction_with_meta.meta.clone().map(|m| m.into()),
-                                        "  ",
-                                        None,
-                                        None,
-                                    );
+                                    let transaction = transaction_with_meta.transaction.clone();
+                                    match SanitizedTransaction::try_from(transaction) {
+                                        Ok(transaction) => println_transaction(
+                                            &transaction,
+                                            &transaction_with_meta.meta.clone().map(|m| m.into()),
+                                            "  ",
+                                            None,
+                                            None,
+                                        ),
+                                        Err(err) => {
+                                            println!("  Unable to construct sanitized transaction for {}: {}", result.signature, err)
+                                        }
+                                    }
                                 }
                             }
                             break;