gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add runtime support for address table lookups (#22223)

Browse Source 
* Add support for address table lookups in runtime

* feedback

* feedback
This commit is contained in:
Justin Starry
2022-01-07 11:59:09 +08:00
committed by GitHub
parent 08e64c88ed
commit 52d12cc802
16 changed files with 568 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
runtime/src/accounts.rs
View File

@@ -22,6 +22,7 @@ use {
},
log::*,
rand::{thread_rng, Rng},
solana_address_lookup_table_program::state::AddressLookupTable,
solana_sdk::{
account::{Account, AccountSharedData, ReadableAccount, WritableAccount},
account_utils::StateMut,
@@ -30,13 +31,20 @@ use {
feature_set::{self, FeatureSet},
genesis_config::ClusterType,
hash::Hash,
message::SanitizedMessage,
message::{
v0::{LoadedAddresses, MessageAddressTableLookup},
SanitizedMessage,
},
native_loader,
nonce::{state::Versions as NonceVersions, State as NonceState},
pubkey::Pubkey,
slot_hashes::SlotHashes,
system_program,
sysvar::{self, instructions::construct_instructions_data},
transaction::{Result, SanitizedTransaction, TransactionAccountLocks, TransactionError},
transaction::{
AddressLookupError, Result, SanitizedTransaction, TransactionAccountLocks,
TransactionError,
},
transaction_context::TransactionAccount,
},
std::{
@@ -514,6 +522,40 @@ impl Accounts {
.collect()
}
pub fn load_lookup_table_addresses(
&self,
ancestors: &Ancestors,
address_table_lookup: &MessageAddressTableLookup,
slot_hashes: &SlotHashes,
) -> std::result::Result<LoadedAddresses, AddressLookupError> {
let table_account = self
.accounts_db
.load_with_fixed_root(ancestors, &address_table_lookup.account_key)
.map(|(account, _rent)| account)
.ok_or(AddressLookupError::LookupTableAccountNotFound)?;
if table_account.owner() == &solana_address_lookup_table_program::id() {
let current_slot = ancestors.max_slot();
let lookup_table = AddressLookupTable::deserialize(table_account.data())
.map_err(|_ix_err| AddressLookupError::InvalidAccountData)?;
Ok(LoadedAddresses {
writable: lookup_table.lookup(
current_slot,
&address_table_lookup.writable_indexes,
slot_hashes,
)?,
readonly: lookup_table.lookup(
current_slot,
&address_table_lookup.readonly_indexes,
slot_hashes,
)?,
})
} else {
Err(AddressLookupError::InvalidAccountOwner)
}
}
fn filter_zero_lamport_account(
account: AccountSharedData,
slot: Slot,
@@ -1268,6 +1310,7 @@ mod tests {
bank::{DurableNonceFee, TransactionExecutionDetails},
rent_collector::RentCollector,
},
solana_address_lookup_table_program::state::LookupTableMeta,
solana_sdk::{
account::{AccountSharedData, WritableAccount},
epoch_schedule::EpochSchedule,
@@ -1282,6 +1325,7 @@ mod tests {
transaction::{Transaction, MAX_TX_ACCOUNT_LOCKS},
},
std::{
borrow::Cow,
convert::TryFrom,
sync::atomic::{AtomicBool, AtomicU64, Ordering},
thread, time,
@@ -1866,6 +1910,149 @@ mod tests {
}
}
#[test]
fn test_load_lookup_table_addresses_account_not_found() {
let ancestors = vec![(0, 0)].into_iter().collect();
let accounts = Accounts::new_with_config_for_tests(
Vec::new(),
&ClusterType::Development,
AccountSecondaryIndexes::default(),
false,
AccountShrinkThreshold::default(),
);
let invalid_table_key = Pubkey::new_unique();
let address_table_lookup = MessageAddressTableLookup {
account_key: invalid_table_key,
writable_indexes: vec![],
readonly_indexes: vec![],
};
assert_eq!(
accounts.load_lookup_table_addresses(
&ancestors,
&address_table_lookup,
&SlotHashes::default(),
),
Err(AddressLookupError::LookupTableAccountNotFound),
);
}
#[test]
fn test_load_lookup_table_addresses_invalid_account_owner() {
let ancestors = vec![(0, 0)].into_iter().collect();
let accounts = Accounts::new_with_config_for_tests(
Vec::new(),
&ClusterType::Development,
AccountSecondaryIndexes::default(),
false,
AccountShrinkThreshold::default(),
);
let invalid_table_key = Pubkey::new_unique();
let invalid_table_account = AccountSharedData::default();
accounts.store_slow_uncached(0, &invalid_table_key, &invalid_table_account);
let address_table_lookup = MessageAddressTableLookup {
account_key: invalid_table_key,
writable_indexes: vec![],
readonly_indexes: vec![],
};
assert_eq!(
accounts.load_lookup_table_addresses(
&ancestors,
&address_table_lookup,
&SlotHashes::default(),
),
Err(AddressLookupError::InvalidAccountOwner),
);
}
#[test]
fn test_load_lookup_table_addresses_invalid_account_data() {
let ancestors = vec![(0, 0)].into_iter().collect();
let accounts = Accounts::new_with_config_for_tests(
Vec::new(),
&ClusterType::Development,
AccountSecondaryIndexes::default(),
false,
AccountShrinkThreshold::default(),
);
let invalid_table_key = Pubkey::new_unique();
let invalid_table_account =
AccountSharedData::new(1, 0, &solana_address_lookup_table_program::id());
accounts.store_slow_uncached(0, &invalid_table_key, &invalid_table_account);
let address_table_lookup = MessageAddressTableLookup {
account_key: invalid_table_key,
writable_indexes: vec![],
readonly_indexes: vec![],
};
assert_eq!(
accounts.load_lookup_table_addresses(
&ancestors,
&address_table_lookup,
&SlotHashes::default(),
),
Err(AddressLookupError::InvalidAccountData),
);
}
#[test]
fn test_load_lookup_table_addresses() {
let ancestors = vec![(1, 1), (0, 0)].into_iter().collect();
let accounts = Accounts::new_with_config_for_tests(
Vec::new(),
&ClusterType::Development,
AccountSecondaryIndexes::default(),
false,
AccountShrinkThreshold::default(),
);
let table_key = Pubkey::new_unique();
let table_addresses = vec![Pubkey::new_unique(), Pubkey::new_unique()];
let table_account = {
let table_state = AddressLookupTable {
meta: LookupTableMeta::default(),
addresses: Cow::Owned(table_addresses.clone()),
};
let table_data = {
let mut data = vec![];
table_state.serialize_for_tests(&mut data).unwrap();
data
};
AccountSharedData::create(
1,
table_data,
solana_address_lookup_table_program::id(),
false,
0,
)
};
accounts.store_slow_uncached(0, &table_key, &table_account);
let address_table_lookup = MessageAddressTableLookup {
account_key: table_key,
writable_indexes: vec![0],
readonly_indexes: vec![1],
};
assert_eq!(
accounts.load_lookup_table_addresses(
&ancestors,
&address_table_lookup,
&SlotHashes::default(),
),
Ok(LoadedAddresses {
writable: vec![table_addresses[0]],
readonly: vec![table_addresses[1]],
}),
);
}
#[test]
fn test_load_by_program_slot() {
let accounts = Accounts::new_with_config_for_tests(

63
runtime/src/bank.rs
View File

@@ -107,7 +107,10 @@ use {
inflation::Inflation,
instruction::CompiledInstruction,
lamports::LamportsError,
message::SanitizedMessage,
message::{
v0::{LoadedAddresses, MessageAddressTableLookup},
SanitizedMessage,
},
native_loader,
native_token::sol_to_lamports,
nonce, nonce_account,
@@ -123,7 +126,7 @@ use {
sysvar::{self, Sysvar, SysvarId},
timing::years_as_slots,
transaction::{
Result, SanitizedTransaction, Transaction, TransactionError,
AddressLookupError, Result, SanitizedTransaction, Transaction, TransactionError,
TransactionVerificationMode, VersionedTransaction,
},
transaction_context::{TransactionAccount, TransactionContext},
@@ -210,7 +213,7 @@ impl RentDebits {
}
type BankStatusCache = StatusCache<Result<()>>;
#[frozen_abi(digest = "6XG6H1FChrDdY39K62KFWj5XfDao4dd24WZgcJkdMu1E")]
#[frozen_abi(digest = "2r36f5cfgP7ABq7D3kRkRfQZWdggGFUnnhwTrVEWhoTC")]
pub type BankSlotDelta = SlotDelta<Result<()>>;
// Eager rent collection repeats in cyclic manner.
@@ -3537,6 +3540,44 @@ impl Bank {
cache.remove(pubkey);
}
/// Get the value of a cached sysvar by its id
pub fn get_cached_sysvar<T: Sysvar>(&self, id: &Pubkey) -> Option<T> {
self.sysvar_cache
.read()
.unwrap()
.iter()
.find_map(|(key, data)| {
if id == key {
bincode::deserialize(data).ok()
} else {
None
}
})
}
pub fn load_lookup_table_addresses(
&self,
address_table_lookups: &[MessageAddressTableLookup],
) -> Result<LoadedAddresses> {
if !self.versioned_tx_message_enabled() {
return Err(TransactionError::UnsupportedVersion);
}
let slot_hashes: SlotHashes = self
.get_cached_sysvar(&sysvar::slot_hashes::id())
.ok_or(TransactionError::AccountNotFound)?;
Ok(address_table_lookups
.iter()
.map(|address_table_lookup| {
self.rc.accounts.load_lookup_table_addresses(
&self.ancestors,
address_table_lookup,
&slot_hashes,
)
})
.collect::<std::result::Result<_, AddressLookupError>>()?)
}
/// Execute a transaction using the provided loaded accounts and update
/// the executors cache if the transaction was successful.
fn execute_loaded_transaction(
@@ -3550,16 +3591,6 @@ impl Bank {
timings: &mut ExecuteTimings,
error_counters: &mut ErrorCounters,
) -> TransactionExecutionResult {
let legacy_message = match tx.message().legacy_message() {
Some(message) => message,
None => {
// TODO: support versioned messages
return TransactionExecutionResult::NotExecuted(
TransactionError::UnsupportedVersion,
);
}
};
let mut get_executors_time = Measure::start("get_executors_time");
let executors = self.get_executors(
tx.message(),
@@ -3598,7 +3629,7 @@ impl Bank {
let mut process_message_time = Measure::start("process_message_time");
let process_result = MessageProcessor::process_message(
&self.builtin_programs.vec,
legacy_message,
tx.message(),
&loaded_transaction.program_indices,
&mut transaction_context,
self.rent_collector.rent,
@@ -5348,8 +5379,8 @@ impl Bank {
tx.message.hash()
};
SanitizedTransaction::try_create(tx, message_hash, None, |_| {
Err(TransactionError::UnsupportedVersion)
SanitizedTransaction::try_create(tx, message_hash, None, |lookups| {
self.load_lookup_table_addresses(lookups)
})
}?;

42
runtime/src/message_processor.rs
View File

@@ -12,7 +12,7 @@ use {
compute_budget::ComputeBudget,
feature_set::{prevent_calling_precompiles_as_programs, FeatureSet},
hash::Hash,
message::Message,
message::SanitizedMessage,
precompiles::is_precompile,
pubkey::Pubkey,
rent::Rent,
@@ -52,7 +52,7 @@ impl MessageProcessor {
#[allow(clippy::too_many_arguments)]
pub fn process_message(
builtin_programs: &[BuiltinProgram],
message: &Message,
message: &SanitizedMessage,
program_indices: &[Vec<usize>],
transaction_context: &mut TransactionContext,
rent: Rent,
@@ -82,14 +82,12 @@ impl MessageProcessor {
current_accounts_data_len,
);
debug_assert_eq!(program_indices.len(), message.instructions.len());
for (instruction_index, (instruction, program_indices)) in message
.instructions
.iter()
debug_assert_eq!(program_indices.len(), message.instructions().len());
for (instruction_index, ((program_id, instruction), program_indices)) in message
.program_instructions_iter()
.zip(program_indices.iter())
.enumerate()
{
let program_id = instruction.program_id(&message.account_keys);
if invoke_context
.feature_set
.is_active(&prevent_calling_precompiles_as_programs::id())
@@ -139,7 +137,7 @@ impl MessageProcessor {
);
time.stop();
timings.details.accumulate_program(
instruction.program_id(&message.account_keys),
program_id,
time.as_us(),
compute_units_consumed,
result.is_err(),
@@ -251,14 +249,14 @@ mod tests {
AccountMeta::new_readonly(*transaction_context.get_key_of_account_at_index(1), false),
];
let message = Message::new(
let message = SanitizedMessage::Legacy(Message::new(
&[Instruction::new_with_bincode(
mock_system_program_id,
&MockSystemInstruction::Correct,
account_metas.clone(),
)],
Some(transaction_context.get_key_of_account_at_index(0)),
);
));
let result = MessageProcessor::process_message(
builtin_programs,
&message,
@@ -292,14 +290,14 @@ mod tests {
0
);
let message = Message::new(
let message = SanitizedMessage::Legacy(Message::new(
&[Instruction::new_with_bincode(
mock_system_program_id,
&MockSystemInstruction::TransferLamports { lamports: 50 },
account_metas.clone(),
)],
Some(transaction_context.get_key_of_account_at_index(0)),
);
));
let result = MessageProcessor::process_message(
builtin_programs,
&message,
@@ -325,14 +323,14 @@ mod tests {
))
);
let message = Message::new(
let message = SanitizedMessage::Legacy(Message::new(
&[Instruction::new_with_bincode(
mock_system_program_id,
&MockSystemInstruction::ChangeData { data: 50 },
account_metas,
)],
Some(transaction_context.get_key_of_account_at_index(0)),
);
));
let result = MessageProcessor::process_message(
builtin_programs,
&message,
@@ -451,14 +449,14 @@ mod tests {
];
// Try to borrow mut the same account
let message = Message::new(
let message = SanitizedMessage::Legacy(Message::new(
&[Instruction::new_with_bincode(
mock_program_id,
&MockSystemInstruction::BorrowFail,
account_metas.clone(),
)],
Some(transaction_context.get_key_of_account_at_index(0)),
);
));
let result = MessageProcessor::process_message(
builtin_programs,
&message,
@@ -485,14 +483,14 @@ mod tests {
);
// Try to borrow mut the same account in a safe way
let message = Message::new(
let message = SanitizedMessage::Legacy(Message::new(
&[Instruction::new_with_bincode(
mock_program_id,
&MockSystemInstruction::MultiBorrowMut,
account_metas.clone(),
)],
Some(transaction_context.get_key_of_account_at_index(0)),
);
));
let result = MessageProcessor::process_message(
builtin_programs,
&message,
@@ -513,7 +511,7 @@ mod tests {
assert!(result.is_ok());
// Do work on the same transaction account but at different instruction accounts
let message = Message::new(
let message = SanitizedMessage::Legacy(Message::new(
&[Instruction::new_with_bincode(
mock_program_id,
&MockSystemInstruction::DoWork {
@@ -523,7 +521,7 @@ mod tests {
account_metas,
)],
Some(transaction_context.get_key_of_account_at_index(0)),
);
));
let result = MessageProcessor::process_message(
builtin_programs,
&message,
@@ -587,7 +585,7 @@ mod tests {
];
let mut transaction_context = TransactionContext::new(accounts, 1);
let message = Message::new(
let message = SanitizedMessage::Legacy(Message::new(
&[
new_secp256k1_instruction(
&libsecp256k1::SecretKey::random(&mut rand::thread_rng()),
@@ -596,7 +594,7 @@ mod tests {
Instruction::new_with_bytes(mock_program_id, &[], vec![]),
],
None,
);
));
let result = MessageProcessor::process_message(
builtin_programs,
&message,