blockworks-foundation
/
solana
mirror of https://github.com/blockworks-foundation/solana.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Adds `IndexOfAccount` type (#27599) 

Adds the type `IndexOfAccount`.
This commit is contained in:
Alexander Meißner 2022-09-06 11:31:40 +02:00 committed by GitHub
parent 6f2e556b16
commit 12d2147efa
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
26 changed files with 295 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
program-runtime/src/invoke_context.rs
View File

@ -20,7 +20,9 @@ use {
pubkey::Pubkey,
rent::Rent,
saturating_add_assign,
transaction_context::{InstructionAccount, TransactionAccount, TransactionContext},
transaction_context::{
IndexOfAccount, InstructionAccount, TransactionAccount, TransactionContext,
},
},
std::{
alloc::Layout,
@ -34,7 +36,7 @@ use {
};
pub type ProcessInstructionWithContext =
fn(usize, &mut InvokeContext) -> Result<(), InstructionError>;
fn(IndexOfAccount, &mut InvokeContext) -> Result<(), InstructionError>;
#[derive(Clone)]
pub struct BuiltinProgram {
@ -46,7 +48,7 @@ impl std::fmt::Debug for BuiltinProgram {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
// These are just type aliases for work around of Debug-ing above pointers
type ErasedProcessInstructionWithContext =
fn(usize, &'static mut InvokeContext<'static>) -> Result<(), InstructionError>;
fn(IndexOfAccount, &'static mut InvokeContext<'static>) -> Result<(), InstructionError>;
// rustc doesn't compile due to bug without this work around
// https://github.com/rust-lang/rust/issues/50280
@ -61,7 +63,7 @@ pub trait Executor: Debug + Send + Sync {
/// Execute the program
fn execute(
&self,
first_instruction_account: usize,
first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError>;
}
@ -292,8 +294,9 @@ impl<'a> InvokeContext<'a> {
.feature_set
.is_active(&enable_early_verification_of_account_modifications::id())
{
self.pre_accounts =
Vec::with_capacity(instruction_context.get_number_of_instruction_accounts());
self.pre_accounts = Vec::with_capacity(
instruction_context.get_number_of_instruction_accounts() as usize,
);
for instruction_account_index in
0..instruction_context.get_number_of_instruction_accounts()
{
@ -374,7 +377,7 @@ impl<'a> InvokeContext<'a> {
fn verify(
&mut self,
instruction_accounts: &[InstructionAccount],
program_indices: &[usize],
program_indices: &[IndexOfAccount],
) -> Result<(), InstructionError> {
let instruction_context = self
.transaction_context
@ -398,7 +401,7 @@ impl<'a> InvokeContext<'a> {
for (instruction_account_index, instruction_account) in
instruction_accounts.iter().enumerate()
{
if instruction_account_index != instruction_account.index_in_callee {
if instruction_account_index as IndexOfAccount != instruction_account.index_in_callee {
continue; // Skip duplicate account
}
{
@ -477,7 +480,7 @@ impl<'a> InvokeContext<'a> {
for (instruction_account_index, instruction_account) in
instruction_accounts.iter().enumerate()
{
if instruction_account_index != instruction_account.index_in_callee {
if instruction_account_index as IndexOfAccount != instruction_account.index_in_callee {
continue; // Skip duplicate account
}
if instruction_account.index_in_transaction
@ -575,7 +578,7 @@ impl<'a> InvokeContext<'a> {
&mut self,
instruction: &Instruction,
signers: &[Pubkey],
) -> Result<(Vec<InstructionAccount>, Vec<usize>), InstructionError> {
) -> Result<(Vec<InstructionAccount>, Vec<IndexOfAccount>), InstructionError> {
// Finds the index of each account in the instruction by its pubkey.
// Then normalizes / unifies the privileges of duplicate accounts.
// Note: This is an O(n^2) algorithm,
@ -626,7 +629,7 @@ impl<'a> InvokeContext<'a> {
deduplicated_instruction_accounts.push(InstructionAccount {
index_in_transaction,
index_in_caller,
index_in_callee: instruction_account_index,
index_in_callee: instruction_account_index as IndexOfAccount,
is_signer: account_meta.is_signer,
is_writable: account_meta.is_writable,
});
@ -723,7 +726,7 @@ impl<'a> InvokeContext<'a> {
&mut self,
instruction_data: &[u8],
instruction_accounts: &[InstructionAccount],
program_indices: &[usize],
program_indices: &[IndexOfAccount],
compute_units_consumed: &mut u64,
timings: &mut ExecuteTimings,
) -> Result<(), InstructionError> {
@ -960,7 +963,7 @@ pub struct MockInvokeContextPreparation {
pub fn prepare_mock_invoke_context(
transaction_accounts: Vec<TransactionAccount>,
instruction_account_metas: Vec<AccountMeta>,
_program_indices: &[usize],
_program_indices: &[IndexOfAccount],
) -> MockInvokeContextPreparation {
let mut instruction_accounts: Vec<InstructionAccount> =
Vec::with_capacity(instruction_account_metas.len());
@ -968,7 +971,8 @@ pub fn prepare_mock_invoke_context(
let index_in_transaction = transaction_accounts
.iter()
.position(|(key, _account)| *key == account_meta.pubkey)
.unwrap_or(transaction_accounts.len());
.unwrap_or(transaction_accounts.len())
as IndexOfAccount;
let index_in_callee = instruction_accounts
.get(0..instruction_account_index)
.unwrap()
@ -976,7 +980,7 @@ pub fn prepare_mock_invoke_context(
.position(|instruction_account| {
instruction_account.index_in_transaction == index_in_transaction
})
.unwrap_or(instruction_account_index);
.unwrap_or(instruction_account_index) as IndexOfAccount;
instruction_accounts.push(InstructionAccount {
index_in_transaction,
index_in_caller: index_in_transaction,
@ -1037,7 +1041,7 @@ pub fn with_mock_invoke_context<R, F: FnMut(&mut InvokeContext) -> R>(
pub fn mock_process_instruction(
loader_id: &Pubkey,
mut program_indices: Vec<usize>,
mut program_indices: Vec<IndexOfAccount>,
instruction_data: &[u8],
transaction_accounts: Vec<TransactionAccount>,
instruction_accounts: Vec<AccountMeta>,
@ -1046,7 +1050,7 @@ pub fn mock_process_instruction(
expected_result: Result<(), InstructionError>,
process_instruction: ProcessInstructionWithContext,
) -> Vec<AccountSharedData> {
program_indices.insert(0, transaction_accounts.len());
program_indices.insert(0, transaction_accounts.len() as IndexOfAccount);
let mut preparation =
prepare_mock_invoke_context(transaction_accounts, instruction_accounts, &program_indices);
let processor_account = AccountSharedData::new(0, 0, &native_loader::id());
@ -1117,14 +1121,14 @@ mod tests {
fn test_program_entry_debug() {
#[allow(clippy::unnecessary_wraps)]
fn mock_process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
_invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn mock_ix_processor(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
_invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
Ok(())
@ -1144,7 +1148,7 @@ mod tests {
#[allow(clippy::integer_arithmetic)]
fn mock_process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
let transaction_context = &invoke_context.transaction_context;
@ -1256,9 +1260,9 @@ mod tests {
AccountSharedData::new(index as u64, 1, invoke_stack.get(index).unwrap()),
));
instruction_accounts.push(InstructionAccount {
index_in_transaction: index,
index_in_caller: index,
index_in_callee: instruction_accounts.len(),
index_in_transaction: index as IndexOfAccount,
index_in_caller: index as IndexOfAccount,
index_in_callee: instruction_accounts.len() as IndexOfAccount,
is_signer: false,
is_writable: true,
});
@ -1269,9 +1273,9 @@ mod tests {
AccountSharedData::new(1, 1, &solana_sdk::pubkey::Pubkey::default()),
));
instruction_accounts.push(InstructionAccount {
index_in_transaction: index,
index_in_caller: index,
index_in_callee: index,
index_in_transaction: index as IndexOfAccount,
index_in_caller: index as IndexOfAccount,
index_in_callee: index as IndexOfAccount,
is_signer: false,
is_writable: false,
});
@ -1291,7 +1295,11 @@ mod tests {
.transaction_context
.get_next_instruction_context()
.unwrap()
.configure(&[MAX_DEPTH + depth_reached], &instruction_accounts, &[]);
.configure(
&[(MAX_DEPTH + depth_reached) as IndexOfAccount],
&instruction_accounts,
&[],
);
if Err(InstructionError::CallDepth) == invoke_context.push() {
break;
}

14
program-runtime/src/sysvar_cache.rs
View File

@ -9,7 +9,7 @@ use {
clock::Clock, epoch_schedule::EpochSchedule, rent::Rent, slot_hashes::SlotHashes,
stake_history::StakeHistory, Sysvar, SysvarId,
},
transaction_context::{InstructionContext, TransactionContext},
transaction_context::{IndexOfAccount, InstructionContext, TransactionContext},
},
std::sync::Arc,
};
@ -183,7 +183,7 @@ pub mod get_sysvar_with_account_check {
fn check_sysvar_account<S: Sysvar>(
transaction_context: &TransactionContext,
instruction_context: &InstructionContext,
instruction_account_index: usize,
instruction_account_index: IndexOfAccount,
) -> Result<(), InstructionError> {
let index_in_transaction = instruction_context
.get_index_of_instruction_account_in_transaction(instruction_account_index)?;
@ -196,7 +196,7 @@ pub mod get_sysvar_with_account_check {
pub fn clock(
invoke_context: &InvokeContext,
instruction_context: &InstructionContext,
instruction_account_index: usize,
instruction_account_index: IndexOfAccount,
) -> Result<Arc<Clock>, InstructionError> {
check_sysvar_account::<Clock>(
invoke_context.transaction_context,
@ -209,7 +209,7 @@ pub mod get_sysvar_with_account_check {
pub fn rent(
invoke_context: &InvokeContext,
instruction_context: &InstructionContext,
instruction_account_index: usize,
instruction_account_index: IndexOfAccount,
) -> Result<Arc<Rent>, InstructionError> {
check_sysvar_account::<Rent>(
invoke_context.transaction_context,
@ -222,7 +222,7 @@ pub mod get_sysvar_with_account_check {
pub fn slot_hashes(
invoke_context: &InvokeContext,
instruction_context: &InstructionContext,
instruction_account_index: usize,
instruction_account_index: IndexOfAccount,
) -> Result<Arc<SlotHashes>, InstructionError> {
check_sysvar_account::<SlotHashes>(
invoke_context.transaction_context,
@ -236,7 +236,7 @@ pub mod get_sysvar_with_account_check {
pub fn recent_blockhashes(
invoke_context: &InvokeContext,
instruction_context: &InstructionContext,
instruction_account_index: usize,
instruction_account_index: IndexOfAccount,
) -> Result<Arc<RecentBlockhashes>, InstructionError> {
check_sysvar_account::<RecentBlockhashes>(
invoke_context.transaction_context,
@ -249,7 +249,7 @@ pub mod get_sysvar_with_account_check {
pub fn stake_history(
invoke_context: &InvokeContext,
instruction_context: &InstructionContext,
instruction_account_index: usize,
instruction_account_index: IndexOfAccount,
) -> Result<Arc<StakeHistory>, InstructionError> {
check_sysvar_account::<StakeHistory>(
invoke_context.transaction_context,

7
program-test/src/lib.rs
View File

@ -62,6 +62,7 @@ use {
pub use {
solana_banks_client::{BanksClient, BanksClientError},
solana_program_runtime::invoke_context::InvokeContext,
solana_sdk::transaction_context::IndexOfAccount,
};
pub mod programs;
@ -94,7 +95,7 @@ fn get_invoke_context<'a, 'b>() -> &'a mut InvokeContext<'b> {
pub fn builtin_process_instruction(
process_instruction: solana_sdk::entrypoint::ProcessInstruction,
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
set_invoke_context(invoke_context);
@ -113,7 +114,7 @@ pub fn builtin_process_instruction(
);
// Copy indices_in_instruction into a HashSet to ensure there are no duplicates
let deduplicated_indices: HashSet<usize> = instruction_account_indices.collect();
let deduplicated_indices: HashSet<IndexOfAccount> = instruction_account_indices.collect();
// Serialize entrypoint parameters with BPF ABI
let (mut parameter_bytes, _account_lengths) = serialize_parameters(
@ -177,7 +178,7 @@ pub fn builtin_process_instruction(
macro_rules! processor {
($process_instruction:expr) => {
Some(
|first_instruction_account: usize,
|first_instruction_account: $crate::IndexOfAccount,
invoke_context: &mut solana_program_test::InvokeContext| {
$crate::builtin_process_instruction(
$process_instruction,

3
programs/address-lookup-table/src/processor.rs
View File

@ -14,12 +14,13 @@ use {
program_utils::limited_deserialize,
pubkey::{Pubkey, PUBKEY_BYTES},
system_instruction,
transaction_context::IndexOfAccount,
},
std::convert::TryFrom,
};
pub fn process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
let transaction_context = &invoke_context.transaction_context;

6
programs/bpf_loader/benches/serialization.rs
View File

@ -10,7 +10,7 @@ use {
account::{Account, AccountSharedData},
bpf_loader,
sysvar::rent::Rent,
transaction_context::{InstructionAccount, TransactionContext},
transaction_context::{IndexOfAccount, InstructionAccount, TransactionContext},
},
test::Bencher,
};
@ -94,9 +94,9 @@ fn create_inputs() -> TransactionContext {
.enumerate()
.map(
|(instruction_account_index, index_in_transaction)| InstructionAccount {
index_in_caller: instruction_account_index,
index_in_caller: instruction_account_index as IndexOfAccount,
index_in_transaction,
index_in_callee: instruction_account_index,
index_in_callee: instruction_account_index as IndexOfAccount,
is_signer: false,
is_writable: instruction_account_index >= 4,
},

36
programs/bpf_loader/src/lib.rs
View File

@ -54,7 +54,9 @@ use {
pubkey::Pubkey,
saturating_add_assign,
system_instruction::{self, MAX_PERMITTED_DATA_LENGTH},
transaction_context::{BorrowedAccount, InstructionContext, TransactionContext},
transaction_context::{
BorrowedAccount, IndexOfAccount, InstructionContext, TransactionContext,
},
},
std::{cell::RefCell, fmt::Debug, rc::Rc, sync::Arc},
thiserror::Error,
@ -109,8 +111,8 @@ mod executor_metrics {
fn get_index_in_transaction(
instruction_context: &InstructionContext,
index_in_instruction: usize,
) -> Result<usize, InstructionError> {
index_in_instruction: IndexOfAccount,
) -> Result<IndexOfAccount, InstructionError> {
if index_in_instruction < instruction_context.get_number_of_program_accounts() {
instruction_context.get_index_of_program_account_in_transaction(index_in_instruction)
} else {
@ -124,7 +126,7 @@ fn get_index_in_transaction(
fn try_borrow_account<'a>(
transaction_context: &'a TransactionContext,
instruction_context: &'a InstructionContext,
index_in_instruction: usize,
index_in_instruction: IndexOfAccount,
) -> Result<BorrowedAccount<'a>, InstructionError> {
if index_in_instruction < instruction_context.get_number_of_program_accounts() {
instruction_context.try_borrow_program_account(transaction_context, index_in_instruction)
@ -138,7 +140,7 @@ fn try_borrow_account<'a>(
}
pub fn create_executor(
programdata_account_index: usize,
programdata_account_index: IndexOfAccount,
programdata_offset: usize,
invoke_context: &mut InvokeContext,
use_jit: bool,
@ -247,7 +249,7 @@ pub fn create_executor(
}
fn write_program_data(
program_account_index: usize,
program_account_index: IndexOfAccount,
program_data_offset: usize,
bytes: &[u8],
invoke_context: &mut InvokeContext,
@ -305,21 +307,21 @@ pub fn create_vm<'a, 'b>(
}
pub fn process_instruction(
first_instruction_account: usize,
first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
process_instruction_common(first_instruction_account, invoke_context, false)
}
pub fn process_instruction_jit(
first_instruction_account: usize,
first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
process_instruction_common(first_instruction_account, invoke_context, true)
}
fn process_instruction_common(
first_instruction_account: usize,
first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
use_jit: bool,
) -> Result<(), InstructionError> {
@ -467,7 +469,7 @@ fn process_instruction_common(
}
fn process_loader_upgradeable_instruction(
first_instruction_account: usize,
first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
use_jit: bool,
) -> Result<(), InstructionError> {
@ -1052,11 +1054,11 @@ fn process_loader_upgradeable_instruction(
return Err(InstructionError::InvalidInstructionData);
}
const PROGRAM_DATA_ACCOUNT_INDEX: usize = 0;
const PROGRAM_DATA_ACCOUNT_INDEX: IndexOfAccount = 0;
#[allow(dead_code)]
// System program is only required when a CPI is performed
const OPTIONAL_SYSTEM_PROGRAM_ACCOUNT_INDEX: usize = 1;
const OPTIONAL_PAYER_ACCOUNT_INDEX: usize = 2;
const OPTIONAL_SYSTEM_PROGRAM_ACCOUNT_INDEX: IndexOfAccount = 1;
const OPTIONAL_PAYER_ACCOUNT_INDEX: IndexOfAccount = 2;
let programdata_account = instruction_context
.try_borrow_instruction_account(transaction_context, PROGRAM_DATA_ACCOUNT_INDEX)?;
@ -1174,7 +1176,7 @@ fn common_close_account(
}
fn process_loader_instruction(
first_instruction_account: usize,
first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
use_jit: bool,
) -> Result<(), InstructionError> {
@ -1269,7 +1271,7 @@ impl Debug for BpfExecutor {
impl Executor for BpfExecutor {
fn execute(
&self,
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
let log_collector = invoke_context.get_log_collector();
@ -1445,7 +1447,7 @@ mod tests {
fn process_instruction(
loader_id: &Pubkey,
program_indices: &[usize],
program_indices: &[IndexOfAccount],
instruction_data: &[u8],
transaction_accounts: Vec<(Pubkey, AccountSharedData)>,
instruction_accounts: Vec<AccountMeta>,
@ -1734,7 +1736,7 @@ mod tests {
None,
None,
Err(InstructionError::ProgramFailedToComplete),
|first_instruction_account: usize, invoke_context: &mut InvokeContext| {
|first_instruction_account: IndexOfAccount, invoke_context: &mut InvokeContext| {
invoke_context
.get_compute_meter()
.borrow_mut()

8
programs/bpf_loader/src/serialization.rs
View File

@ -9,7 +9,7 @@ use {
instruction::InstructionError,
pubkey::Pubkey,
system_instruction::MAX_PERMITTED_DATA_LENGTH,
transaction_context::{InstructionContext, TransactionContext},
transaction_context::{IndexOfAccount, InstructionContext, TransactionContext},
},
std::{io::prelude::*, mem::size_of},
};
@ -24,7 +24,7 @@ pub fn serialize_parameters(
should_cap_ix_accounts: bool,
) -> Result<(AlignedMemory<HOST_ALIGN>, Vec<usize>), InstructionError> {
let num_ix_accounts = instruction_context.get_number_of_instruction_accounts();
if should_cap_ix_accounts && num_ix_accounts > usize::from(MAX_INSTRUCTION_ACCOUNTS) {
if should_cap_ix_accounts && num_ix_accounts > MAX_INSTRUCTION_ACCOUNTS as IndexOfAccount {
return Err(InstructionError::MaxAccountsExceeded);
}
@ -722,7 +722,7 @@ mod tests {
{
let account = invoke_context
.transaction_context
.get_account_at_index(index_in_transaction)
.get_account_at_index(index_in_transaction as IndexOfAccount)
.unwrap()
.borrow();
assert_eq!(&*account, original_account);
@ -781,7 +781,7 @@ mod tests {
{
let account = invoke_context
.transaction_context
.get_account_at_index(index_in_transaction)
.get_account_at_index(index_in_transaction as IndexOfAccount)
.unwrap()
.borrow();
assert_eq!(&*account, original_account);

14
programs/bpf_loader/src/syscalls/cpi.rs
View File

@ -16,7 +16,7 @@ struct CallerAccount<'a> {
executable: bool,
rent_epoch: u64,
}
type TranslatedAccounts<'a> = Vec<(usize, Option<CallerAccount<'a>>)>;
type TranslatedAccounts<'a> = Vec<(IndexOfAccount, Option<CallerAccount<'a>>)>;
/// Implemented by language specific data structure translators
trait SyscallInvokeSigned<'a, 'b> {
@ -30,7 +30,7 @@ trait SyscallInvokeSigned<'a, 'b> {
fn translate_accounts<'c>(
&'c self,
instruction_accounts: &[InstructionAccount],
program_indices: &[usize],
program_indices: &[IndexOfAccount],
account_infos_addr: u64,
account_infos_len: u64,
memory_mapping: &mut MemoryMapping,
@ -130,7 +130,7 @@ impl<'a, 'b> SyscallInvokeSigned<'a, 'b> for SyscallInvokeSignedRust<'a, 'b> {
fn translate_accounts<'c>(
&'c self,
instruction_accounts: &[InstructionAccount],
program_indices: &[usize],
program_indices: &[IndexOfAccount],
account_infos_addr: u64,
account_infos_len: u64,
memory_mapping: &mut MemoryMapping,
@ -447,7 +447,7 @@ impl<'a, 'b> SyscallInvokeSigned<'a, 'b> for SyscallInvokeSignedC<'a, 'b> {
fn translate_accounts<'c>(
&'c self,
instruction_accounts: &[InstructionAccount],
program_indices: &[usize],
program_indices: &[IndexOfAccount],
account_infos_addr: u64,
account_infos_len: u64,
memory_mapping: &mut MemoryMapping,
@ -605,7 +605,7 @@ impl<'a, 'b> SyscallInvokeSigned<'a, 'b> for SyscallInvokeSignedC<'a, 'b> {
fn get_translated_accounts<'a, T, F>(
instruction_accounts: &[InstructionAccount],
program_indices: &[usize],
program_indices: &[IndexOfAccount],
account_info_keys: &[&Pubkey],
account_infos: &[T],
invoke_context: &mut InvokeContext,
@ -632,7 +632,7 @@ where
for (instruction_account_index, instruction_account) in instruction_accounts.iter().enumerate()
{
if instruction_account_index != instruction_account.index_in_callee {
if instruction_account_index as IndexOfAccount != instruction_account.index_in_callee {
continue; // Skip duplicate account
}
let mut callee_account = instruction_context
@ -724,7 +724,7 @@ where
.get_orig_account_lengths()
.map_err(SyscallError::InstructionError)?;
caller_account.original_data_len = *orig_data_lens
.get(instruction_account.index_in_caller)
.get(instruction_account.index_in_caller as usize)
.ok_or_else(|| {
ic_msg!(
invoke_context,

6
programs/bpf_loader/src/syscalls/mod.rs
View File

@ -53,7 +53,7 @@ use {
Secp256k1RecoverError, SECP256K1_PUBLIC_KEY_LENGTH, SECP256K1_SIGNATURE_LENGTH,
},
sysvar::{Sysvar, SysvarId},
transaction_context::{InstructionAccount, TransactionContextAttribute},
transaction_context::{IndexOfAccount, InstructionAccount, TransactionContextAttribute},
},
std::{
alloc::Layout,
@ -1925,7 +1925,7 @@ declare_syscall!(
instruction_context
.try_borrow_instruction_account(
transaction_context,
update.instruction_account_index as usize,
update.instruction_account_index,
)
.map_err(SyscallError::InstructionError),
result
@ -3253,7 +3253,7 @@ mod tests {
}
if stack_height > transaction_context.get_instruction_context_stack_height() {
let instruction_accounts = [InstructionAccount {
index_in_transaction: index_in_trace.saturating_add(1),
index_in_transaction: index_in_trace.saturating_add(1) as IndexOfAccount,
index_in_caller: 0, // This is incorrect / inconsistent but not required
index_in_callee: 0,
is_signer: false,

4
programs/compute-budget/src/lib.rs
View File

@ -1,10 +1,10 @@
use {
solana_program_runtime::invoke_context::InvokeContext,
solana_sdk::instruction::InstructionError,
solana_sdk::{instruction::InstructionError, transaction_context::IndexOfAccount},
};
pub fn process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
_invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
// Do nothing, compute budget instructions handled by the runtime

6
programs/config/src/config_processor.rs
View File

@ -6,13 +6,13 @@ use {
solana_program_runtime::{ic_msg, invoke_context::InvokeContext},
solana_sdk::{
feature_set, instruction::InstructionError, program_utils::limited_deserialize,
pubkey::Pubkey,
pubkey::Pubkey, transaction_context::IndexOfAccount,
},
std::collections::BTreeSet,
};
pub fn process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
let transaction_context = &invoke_context.transaction_context;
@ -61,7 +61,7 @@ pub fn process_instruction(
counter += 1;
if signer != config_account_key {
let signer_account = instruction_context
.try_borrow_instruction_account(transaction_context, counter)
.try_borrow_instruction_account(transaction_context, counter as IndexOfAccount)
.map_err(|_| {
ic_msg!(
invoke_context,

6
programs/stake/src/stake_instruction.rs
View File

@ -21,14 +21,14 @@ use {
state::{Authorized, Lockup},
},
sysvar::clock::Clock,
transaction_context::{InstructionContext, TransactionContext},
transaction_context::{IndexOfAccount, InstructionContext, TransactionContext},
},
};
fn get_optional_pubkey<'a>(
transaction_context: &'a TransactionContext,
instruction_context: &'a InstructionContext,
instruction_account_index: usize,
instruction_account_index: IndexOfAccount,
should_be_signer: bool,
) -> Result<Option<&'a Pubkey>, InstructionError> {
Ok(
@ -52,7 +52,7 @@ fn get_optional_pubkey<'a>(
}
pub fn process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
let transaction_context = &invoke_context.transaction_context;

38
programs/stake/src/stake_state.rs
View File

@ -28,7 +28,9 @@ use {
tools::{acceptable_reference_epoch_credits, eligible_for_deactivate_delinquent},
},
stake_history::{StakeHistory, StakeHistoryEntry},
transaction_context::{BorrowedAccount, InstructionContext, TransactionContext},
transaction_context::{
BorrowedAccount, IndexOfAccount, InstructionContext, TransactionContext,
},
},
solana_vote_program::vote_state::{self, VoteState, VoteStateVersions},
std::{collections::HashSet, convert::TryFrom},
@ -539,7 +541,7 @@ pub fn authorize_with_seed(
transaction_context: &TransactionContext,
instruction_context: &InstructionContext,
stake_account: &mut BorrowedAccount,
authority_base_index: usize,
authority_base_index: IndexOfAccount,
authority_seed: &str,
authority_owner: &Pubkey,
new_authority: &Pubkey,
@ -576,8 +578,8 @@ pub fn delegate(
invoke_context: &InvokeContext,
transaction_context: &TransactionContext,
instruction_context: &InstructionContext,
stake_account_index: usize,
vote_account_index: usize,
stake_account_index: IndexOfAccount,
vote_account_index: IndexOfAccount,
clock: &Clock,
stake_history: &StakeHistory,
config: &Config,
@ -667,9 +669,9 @@ pub fn split(
invoke_context: &InvokeContext,
transaction_context: &TransactionContext,
instruction_context: &InstructionContext,
stake_account_index: usize,
stake_account_index: IndexOfAccount,
lamports: u64,
split_index: usize,
split_index: IndexOfAccount,
signers: &HashSet<Pubkey>,
) -> Result<(), InstructionError> {
let split =
@ -813,8 +815,8 @@ pub fn merge(
invoke_context: &InvokeContext,
transaction_context: &TransactionContext,
instruction_context: &InstructionContext,
stake_account_index: usize,
source_account_index: usize,
stake_account_index: IndexOfAccount,
source_account_index: IndexOfAccount,
clock: &Clock,
stake_history: &StakeHistory,
signers: &HashSet<Pubkey>,
@ -879,8 +881,8 @@ pub fn redelegate(
transaction_context: &TransactionContext,
instruction_context: &InstructionContext,
stake_account: &mut BorrowedAccount,
uninitialized_stake_account_index: usize,
vote_account_index: usize,
uninitialized_stake_account_index: IndexOfAccount,
vote_account_index: IndexOfAccount,
config: &Config,
signers: &HashSet<Pubkey>,
) -> Result<(), InstructionError> {
@ -999,13 +1001,13 @@ pub fn redelegate(
pub fn withdraw(
transaction_context: &TransactionContext,
instruction_context: &InstructionContext,
stake_account_index: usize,
stake_account_index: IndexOfAccount,
lamports: u64,
to_index: usize,
to_index: IndexOfAccount,
clock: &Clock,
stake_history: &StakeHistory,
withdraw_authority_index: usize,
custodian_index: Option<usize>,
withdraw_authority_index: IndexOfAccount,
custodian_index: Option<IndexOfAccount>,
feature_set: &FeatureSet,
) -> Result<(), InstructionError> {
let withdraw_authority_pubkey = transaction_context.get_key_of_account_at_index(
@ -1113,8 +1115,8 @@ pub(crate) fn deactivate_delinquent(
transaction_context: &TransactionContext,
instruction_context: &InstructionContext,
stake_account: &mut BorrowedAccount,
delinquent_vote_account_index: usize,
reference_vote_account_index: usize,
delinquent_vote_account_index: IndexOfAccount,
reference_vote_account_index: IndexOfAccount,
current_epoch: Epoch,
) -> Result<(), InstructionError> {
let delinquent_vote_account_pubkey = transaction_context.get_key_of_account_at_index(
@ -1205,8 +1207,8 @@ fn validate_split_amount(
invoke_context: &InvokeContext,
transaction_context: &TransactionContext,
instruction_context: &InstructionContext,
source_account_index: usize,
destination_account_index: usize,
source_account_index: IndexOfAccount,
destination_account_index: IndexOfAccount,
lamports: u64,
source_meta: &Meta,
source_stake: Option<&Stake>,

6
programs/vote/benches/process_vote.rs
View File

@ -11,7 +11,9 @@ use {
pubkey::Pubkey,
slot_hashes::{SlotHashes, MAX_ENTRIES},
sysvar,
transaction_context::{InstructionAccount, TransactionAccount, TransactionContext},
transaction_context::{
IndexOfAccount, InstructionAccount, TransactionAccount, TransactionContext,
},
},
solana_vote_program::{
vote_instruction::VoteInstruction,
@ -82,7 +84,7 @@ fn create_accounts() -> (
];
let mut instruction_accounts = (0..4)
.map(|index_in_callee| InstructionAccount {
index_in_transaction: 1usize.saturating_add(index_in_callee),
index_in_transaction: (1 as IndexOfAccount).saturating_add(index_in_callee),
index_in_caller: index_in_callee,
index_in_callee,
is_signer: false,

6
programs/vote/src/vote_processor.rs
View File

@ -12,7 +12,9 @@ use {
instruction::InstructionError,
program_utils::limited_deserialize,
pubkey::Pubkey,
transaction_context::{BorrowedAccount, InstructionContext, TransactionContext},
transaction_context::{
BorrowedAccount, IndexOfAccount, InstructionContext, TransactionContext,
},
},
std::collections::HashSet,
};
@ -56,7 +58,7 @@ fn process_authorize_with_seed_instruction(
}
pub fn process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
let transaction_context = &invoke_context.transaction_context;

8
programs/vote/src/vote_state/mod.rs
View File

@ -16,7 +16,9 @@ use {
rent::Rent,
slot_hashes::SlotHash,
sysvar::clock::Clock,
transaction_context::{BorrowedAccount, InstructionContext, TransactionContext},
transaction_context::{
BorrowedAccount, IndexOfAccount, InstructionContext, TransactionContext,
},
},
std::{
cmp::Ordering,
@ -825,9 +827,9 @@ fn verify_authorized_signer<S: std::hash::BuildHasher>(
pub fn withdraw<S: std::hash::BuildHasher>(
transaction_context: &TransactionContext,
instruction_context: &InstructionContext,
vote_account_index: usize,
vote_account_index: IndexOfAccount,
lamports: u64,
to_account_index: usize,
to_account_index: IndexOfAccount,
signers: &HashSet<Pubkey, S>,
rent_sysvar: &Rent,
clock: Option<&Clock>,

7
programs/zk-token-proof/src/lib.rs
View File

@ -3,7 +3,10 @@
use {
bytemuck::Pod,
solana_program_runtime::{ic_msg, invoke_context::InvokeContext},
solana_sdk::instruction::{InstructionError, TRANSACTION_LEVEL_STACK_HEIGHT},
solana_sdk::{
instruction::{InstructionError, TRANSACTION_LEVEL_STACK_HEIGHT},
transaction_context::IndexOfAccount,
},
solana_zk_token_sdk::zk_token_proof_instruction::*,
std::result::Result,
};
@ -26,7 +29,7 @@ fn verify<T: Pod + Verifiable>(invoke_context: &mut InvokeContext) -> Result<(),
}
pub fn process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
if invoke_context.get_stack_height() != TRANSACTION_LEVEL_STACK_HEIGHT {

3
runtime/benches/bank.rs
View File

@ -20,6 +20,7 @@ use {
pubkey::Pubkey,
signature::{Keypair, Signer},
transaction::Transaction,
transaction_context::IndexOfAccount,
},
std::{sync::Arc, thread::sleep, time::Duration},
test::Bencher,
@ -37,7 +38,7 @@ const NOOP_PROGRAM_ID: [u8; 32] = [
#[allow(clippy::unnecessary_wraps)]
fn process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
_invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
Ok(())

6
runtime/src/account_rent_state.rs
View File

@ -5,7 +5,7 @@ use {
pubkey::Pubkey,
rent::Rent,
transaction::{Result, TransactionError},
transaction_context::TransactionContext,
transaction_context::{IndexOfAccount, TransactionContext},
},
};
@ -88,7 +88,7 @@ pub(crate) fn check_rent_state(
pre_rent_state: Option<&RentState>,
post_rent_state: Option<&RentState>,
transaction_context: &TransactionContext,
index: usize,
index: IndexOfAccount,
include_account_index_in_err: bool,
prevent_crediting_accounts_that_end_rent_paying: bool,
) -> Result<()> {
@ -116,7 +116,7 @@ pub(crate) fn check_rent_state_with_account(
post_rent_state: &RentState,
address: &Pubkey,
account_state: &AccountSharedData,
account_index: Option<usize>,
account_index: Option<IndexOfAccount>,
prevent_crediting_accounts_that_end_rent_paying: bool,
) -> Result<()> {
submit_rent_state_metrics(pre_rent_state, post_rent_state);

60
runtime/src/accounts.rs
View File

@ -53,7 +53,7 @@ use {
system_program,
sysvar::{self, epoch_schedule::EpochSchedule, instructions::construct_instructions_data},
transaction::{Result, SanitizedTransaction, TransactionAccountLocks, TransactionError},
transaction_context::TransactionAccount,
transaction_context::{IndexOfAccount, TransactionAccount},
},
std::{
cmp::Reverse,
@ -125,7 +125,7 @@ pub struct Accounts {
// for the load instructions
pub type TransactionRent = u64;
pub type TransactionProgramIndices = Vec<Vec<usize>>;
pub type TransactionProgramIndices = Vec<Vec<IndexOfAccount>>;
#[derive(PartialEq, Eq, Debug, Clone)]
pub struct LoadedTransaction {
pub accounts: Vec<TransactionAccount>,
@ -313,7 +313,7 @@ impl Accounts {
Self::validate_fee_payer(
key,
&mut account,
i,
i as IndexOfAccount,
error_counters,
rent_collector,
feature_set,
@ -379,11 +379,11 @@ impl Accounts {
self.load_executable_accounts(
ancestors,
&mut accounts,
instruction.program_id_index as usize,
instruction.program_id_index as IndexOfAccount,
error_counters,
)
})
.collect::<Result<Vec<Vec<usize>>>>()?;
.collect::<Result<Vec<Vec<IndexOfAccount>>>>()?;
Ok(LoadedTransaction {
accounts,
@ -401,7 +401,7 @@ impl Accounts {
fn validate_fee_payer(
payer_address: &Pubkey,
payer_account: &mut AccountSharedData,
payer_index: usize,
payer_index: IndexOfAccount,
error_counters: &mut TransactionErrorMetrics,
rent_collector: &RentCollector,
feature_set: &FeatureSet,
@ -450,11 +450,11 @@ impl Accounts {
&self,
ancestors: &Ancestors,
accounts: &mut Vec<TransactionAccount>,
mut program_account_index: usize,
mut program_account_index: IndexOfAccount,
error_counters: &mut TransactionErrorMetrics,
) -> Result<Vec<usize>> {
) -> Result<Vec<IndexOfAccount>> {
let mut account_indices = Vec::new();
let mut program_id = match accounts.get(program_account_index) {
let mut program_id = match accounts.get(program_account_index as usize) {
Some(program_account) => program_account.0,
None => {
error_counters.account_not_found += 1;
@ -474,7 +474,7 @@ impl Accounts {
.load_with_fixed_root(ancestors, &program_id)
{
Some((program_account, _)) => {
let account_index = accounts.len();
let account_index = accounts.len() as IndexOfAccount;
accounts.push((program_id, program_account));
account_index
}
@ -483,7 +483,7 @@ impl Accounts {
return Err(TransactionError::ProgramAccountNotFound);
}
};
let program = &accounts[program_account_index].1;
let program = &accounts[program_account_index as usize].1;
if !program.executable() {
error_counters.invalid_program_for_execution += 1;
return Err(TransactionError::InvalidProgramForExecution);
@ -503,7 +503,7 @@ impl Accounts {
.load_with_fixed_root(ancestors, &programdata_address)
{
Some((programdata_account, _)) => {
let account_index = accounts.len();
let account_index = accounts.len() as IndexOfAccount;
accounts.push((programdata_address, programdata_account));
account_index
}
@ -2028,11 +2028,11 @@ mod tests {
for (i, program_index) in program_indices.iter().enumerate() {
// +1 to skip first not loader account
assert_eq!(
loaded_transaction.accounts[*program_index].0,
loaded_transaction.accounts[*program_index as usize].0,
accounts[i + 1].0
);
assert_eq!(
loaded_transaction.accounts[*program_index].1,
loaded_transaction.accounts[*program_index as usize].1,
accounts[i + 1].1
);
}
@ -2262,7 +2262,10 @@ mod tests {
assert_eq!(loaded_accounts.len(), 1);
let result = loaded_accounts[0].0.as_ref().unwrap();
assert_eq!(result.accounts[..2], accounts[..2]);
assert_eq!(result.accounts[result.program_indices[0][0]], accounts[2]);
assert_eq!(
result.accounts[result.program_indices[0][0] as usize],
accounts[2]
);
}
#[test]
@ -2345,7 +2348,10 @@ mod tests {
assert_eq!(loaded_accounts.len(), 1);
let result = loaded_accounts[0].0.as_ref().unwrap();
assert_eq!(result.accounts[..2], accounts[..2]);
assert_eq!(result.accounts[result.program_indices[0][0]], accounts[5]);
assert_eq!(
result.accounts[result.program_indices[0][0] as usize],
accounts[5]
);
// Solution 2: mark programdata as readonly
message.account_keys = vec![key0, key1, key2]; // revert key change
@ -2357,9 +2363,18 @@ mod tests {
assert_eq!(loaded_accounts.len(), 1);
let result = loaded_accounts[0].0.as_ref().unwrap();
assert_eq!(result.accounts[..2], accounts[..2]);
assert_eq!(result.accounts[result.program_indices[0][0]], accounts[5]);
assert_eq!(result.accounts[result.program_indices[0][1]], accounts[4]);
assert_eq!(result.accounts[result.program_indices[0][2]], accounts[3]);
assert_eq!(
result.accounts[result.program_indices[0][0] as usize],
accounts[5]
);
assert_eq!(
result.accounts[result.program_indices[0][1] as usize],
accounts[4]
);
assert_eq!(
result.accounts[result.program_indices[0][2] as usize],
accounts[3]
);
}
#[test]
@ -2428,7 +2443,7 @@ mod tests {
let result = loaded_accounts[0].0.as_ref().unwrap();
assert_eq!(result.accounts[..2], accounts_with_upgradeable_loader[..2]);
assert_eq!(
result.accounts[result.program_indices[0][0]],
result.accounts[result.program_indices[0][0] as usize],
accounts_with_upgradeable_loader[2]
);
@ -2442,7 +2457,10 @@ mod tests {
assert_eq!(loaded_accounts.len(), 1);
let result = loaded_accounts[0].0.as_ref().unwrap();
assert_eq!(result.accounts[..2], accounts[..2]);
assert_eq!(result.accounts[result.program_indices[0][0]], accounts[2]);
assert_eq!(
result.accounts[result.program_indices[0][0] as usize],
accounts[2]
);
}
#[test]

37
runtime/src/bank.rs
View File

@ -8052,6 +8052,7 @@ pub(crate) mod tests {
system_program,
timing::duration_as_s,
transaction::MAX_TX_ACCOUNT_LOCKS,
transaction_context::IndexOfAccount,
},
solana_vote_program::{
vote_instruction,
@ -9061,7 +9062,7 @@ pub(crate) mod tests {
}
fn mock_process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> result::Result<(), InstructionError> {
let transaction_context = &invoke_context.transaction_context;
@ -12670,7 +12671,7 @@ pub(crate) mod tests {
Pubkey::new(&[42u8; 32])
}
fn mock_vote_processor(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> std::result::Result<(), InstructionError> {
let transaction_context = &invoke_context.transaction_context;
@ -12729,7 +12730,7 @@ pub(crate) mod tests {
let mut bank = Bank::new_for_tests(&genesis_config);
fn mock_vote_processor(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
_invoke_context: &mut InvokeContext,
) -> std::result::Result<(), InstructionError> {
Err(InstructionError::Custom(42))
@ -12777,7 +12778,7 @@ pub(crate) mod tests {
let mut bank = create_simple_test_bank(500);
fn mock_ix_processor(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
_invoke_context: &mut InvokeContext,
) -> std::result::Result<(), InstructionError> {
Err(InstructionError::Custom(42))
@ -14051,7 +14052,7 @@ pub(crate) mod tests {
let mut bank = Bank::new_for_tests(&genesis_config);
fn mock_process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> result::Result<(), InstructionError> {
let transaction_context = &invoke_context.transaction_context;
@ -14111,7 +14112,7 @@ pub(crate) mod tests {
#[allow(clippy::unnecessary_wraps)]
fn mock_process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
_invoke_context: &mut InvokeContext,
) -> result::Result<(), InstructionError> {
Ok(())
@ -14333,7 +14334,7 @@ pub(crate) mod tests {
#[allow(clippy::unnecessary_wraps)]
fn mock_ok_vote_processor(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
_invoke_context: &mut InvokeContext,
) -> std::result::Result<(), InstructionError> {
Ok(())
@ -14581,7 +14582,7 @@ pub(crate) mod tests {
#[test]
fn test_same_program_id_uses_unqiue_executable_accounts() {
fn nested_processor(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> result::Result<(), InstructionError> {
let transaction_context = &invoke_context.transaction_context;
@ -14851,7 +14852,7 @@ pub(crate) mod tests {
fn test_add_builtin_no_overwrite() {
#[allow(clippy::unnecessary_wraps)]
fn mock_ix_processor(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
_invoke_context: &mut InvokeContext,
) -> std::result::Result<(), InstructionError> {
Ok(())
@ -14887,7 +14888,7 @@ pub(crate) mod tests {
fn test_add_builtin_loader_no_overwrite() {
#[allow(clippy::unnecessary_wraps)]
fn mock_ix_processor(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
_context: &mut InvokeContext,
) -> std::result::Result<(), InstructionError> {
Ok(())
@ -15207,7 +15208,7 @@ pub(crate) mod tests {
impl Executor for TestExecutor {
fn execute(
&self,
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
_invoke_context: &mut InvokeContext,
) -> std::result::Result<(), InstructionError> {
Ok(())
@ -17016,7 +17017,7 @@ pub(crate) mod tests {
let mock_program_id = Pubkey::new(&[2u8; 32]);
fn mock_process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> result::Result<(), InstructionError> {
let mock_program_id = Pubkey::new(&[2u8; 32]);
@ -17214,7 +17215,7 @@ pub(crate) mod tests {
let mut bank = Bank::new_for_tests(&genesis_config);
fn mock_ix_processor(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> std::result::Result<(), InstructionError> {
let transaction_context = &invoke_context.transaction_context;
@ -17424,7 +17425,7 @@ pub(crate) mod tests {
let mut bank = Bank::new_for_tests(&genesis_config);
fn mock_ix_processor(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> std::result::Result<(), InstructionError> {
let compute_budget = invoke_context.get_compute_budget();
@ -17468,7 +17469,7 @@ pub(crate) mod tests {
let mut bank = Bank::new_for_tests(&genesis_config);
fn mock_ix_processor(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> std::result::Result<(), InstructionError> {
let compute_budget = invoke_context.get_compute_budget();
@ -17519,7 +17520,7 @@ pub(crate) mod tests {
.unwrap();
fn mock_ix_processor(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> std::result::Result<(), InstructionError> {
let compute_budget = invoke_context.get_compute_budget();
@ -18023,7 +18024,7 @@ pub(crate) mod tests {
}
fn mock_transfer_process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> result::Result<(), InstructionError> {
let transaction_context = &invoke_context.transaction_context;
@ -18878,7 +18879,7 @@ pub(crate) mod tests {
}
fn mock_realloc_process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> result::Result<(), InstructionError> {
let transaction_context = &invoke_context.transaction_context;

14
runtime/src/bank/transaction_account_state_info.rs
View File

@ -4,8 +4,12 @@ use {
bank::Bank,
},
solana_sdk::{
account::ReadableAccount, feature_set, message::SanitizedMessage, native_loader,
transaction::Result, transaction_context::TransactionContext,
account::ReadableAccount,
feature_set,
message::SanitizedMessage,
native_loader,
transaction::Result,
transaction_context::{IndexOfAccount, TransactionContext},
},
};
@ -22,7 +26,9 @@ impl Bank {
(0..message.account_keys().len())
.map(|i| {
let rent_state = if message.is_writable(i) {
let state = if let Ok(account) = transaction_context.get_account_at_index(i) {
let state = if let Ok(account) =
transaction_context.get_account_at_index(i as IndexOfAccount)
{
let account = account.borrow();
// Native programs appear to be RentPaying because they carry low lamport
@ -68,7 +74,7 @@ impl Bank {
pre_state_info.rent_state.as_ref(),
post_state_info.rent_state.as_ref(),
transaction_context,
i,
i as IndexOfAccount,
include_account_index_in_err,
prevent_crediting_accounts_that_end_rent_paying,
)?;

17
runtime/src/message_processor.rs
View File

@ -18,7 +18,7 @@ use {
saturating_add_assign,
sysvar::instructions,
transaction::TransactionError,
transaction_context::{InstructionAccount, TransactionContext},
transaction_context::{IndexOfAccount, InstructionAccount, TransactionContext},
},
std::{borrow::Cow, cell::RefCell, rc::Rc, sync::Arc},
};
@ -52,7 +52,7 @@ impl MessageProcessor {
pub fn process_message(
builtin_programs: &[BuiltinProgram],
message: &SanitizedMessage,
program_indices: &[Vec<usize>],
program_indices: &[Vec<IndexOfAccount>],
transaction_context: &mut TransactionContext,
rent: Rent,
log_collector: Option<Rc<RefCell<LogCollector>>>,
@ -116,11 +116,12 @@ impl MessageProcessor {
.ok_or(TransactionError::InvalidAccountIndex)?
.iter()
.position(|account_index| account_index == index_in_transaction)
.unwrap_or(instruction_account_index);
.unwrap_or(instruction_account_index)
as IndexOfAccount;
let index_in_transaction = *index_in_transaction as usize;
instruction_accounts.push(InstructionAccount {
index_in_transaction,
index_in_caller: index_in_transaction,
index_in_transaction: index_in_transaction as IndexOfAccount,
index_in_caller: index_in_transaction as IndexOfAccount,
index_in_callee,
is_signer: message.is_signer(index_in_transaction),
is_writable: message.is_writable(index_in_transaction),
@ -216,7 +217,7 @@ mod tests {
}
fn mock_system_process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
let transaction_context = &invoke_context.transaction_context;
@ -428,7 +429,7 @@ mod tests {
}
fn mock_system_process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
let transaction_context = &invoke_context.transaction_context;
@ -642,7 +643,7 @@ mod tests {
fn test_precompile() {
let mock_program_id = Pubkey::new_unique();
fn mock_process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
_invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
Err(InstructionError::Custom(0xbabb1e))

12
runtime/src/nonce_keyed_account.rs
View File

@ -11,7 +11,9 @@ use {
pubkey::Pubkey,
system_instruction::{nonce_to_instruction_error, NonceError},
sysvar::rent::Rent,
transaction_context::{BorrowedAccount, InstructionContext, TransactionContext},
transaction_context::{
BorrowedAccount, IndexOfAccount, InstructionContext, TransactionContext,
},
},
std::collections::HashSet,
};
@ -79,9 +81,9 @@ pub fn advance_nonce_account(
}
pub fn withdraw_nonce_account(
from_account_index: usize,
from_account_index: IndexOfAccount,
lamports: u64,
to_account_index: usize,
to_account_index: IndexOfAccount,
rent: &Rent,
signers: &HashSet<Pubkey>,
invoke_context: &InvokeContext,
@ -282,8 +284,8 @@ mod test {
},
};
pub const NONCE_ACCOUNT_INDEX: usize = 0;
pub const WITHDRAW_TO_ACCOUNT_INDEX: usize = 1;
pub const NONCE_ACCOUNT_INDEX: IndexOfAccount = 0;
pub const WITHDRAW_TO_ACCOUNT_INDEX: IndexOfAccount = 1;
macro_rules! push_instruction_context {
($invoke_context:expr, $transaction_context:ident, $instruction_context:ident, $instruction_accounts:ident) => {

28
runtime/src/system_instruction_processor.rs
View File

@ -19,7 +19,9 @@ use {
NonceError, SystemError, SystemInstruction, MAX_PERMITTED_DATA_LENGTH,
},
system_program,
transaction_context::{BorrowedAccount, InstructionContext, TransactionContext},
transaction_context::{
BorrowedAccount, IndexOfAccount, InstructionContext, TransactionContext,
},
},
std::collections::HashSet,
};
@ -145,8 +147,8 @@ fn allocate_and_assign(
#[allow(clippy::too_many_arguments)]
fn create_account(
from_account_index: usize,
to_account_index: usize,
from_account_index: IndexOfAccount,
to_account_index: IndexOfAccount,
to_address: &Address,
lamports: u64,
space: u64,
@ -182,8 +184,8 @@ fn create_account(
}
fn transfer_verified(
from_account_index: usize,
to_account_index: usize,
from_account_index: IndexOfAccount,
to_account_index: IndexOfAccount,
lamports: u64,
invoke_context: &InvokeContext,
transaction_context: &TransactionContext,
@ -214,8 +216,8 @@ fn transfer_verified(
}
fn transfer(
from_account_index: usize,
to_account_index: usize,
from_account_index: IndexOfAccount,
to_account_index: IndexOfAccount,
lamports: u64,
invoke_context: &InvokeContext,
transaction_context: &TransactionContext,
@ -252,11 +254,11 @@ fn transfer(
}
fn transfer_with_seed(
from_account_index: usize,
from_base_account_index: usize,
from_account_index: IndexOfAccount,
from_base_account_index: IndexOfAccount,
from_seed: &str,
from_owner: &Pubkey,
to_account_index: usize,
to_account_index: IndexOfAccount,
lamports: u64,
invoke_context: &InvokeContext,
transaction_context: &TransactionContext,
@ -314,7 +316,7 @@ fn transfer_with_seed(
}
pub fn process_instruction(
_first_instruction_account: usize,
_first_instruction_account: IndexOfAccount,
invoke_context: &mut InvokeContext,
) -> Result<(), InstructionError> {
let transaction_context = &invoke_context.transaction_context;
@ -1865,7 +1867,7 @@ mod tests {
},
],
Ok(()),
|first_instruction_account: usize, invoke_context: &mut InvokeContext| {
|first_instruction_account: IndexOfAccount, invoke_context: &mut InvokeContext| {
invoke_context.blockhash = hash(&serialize(&0).unwrap());
super::process_instruction(first_instruction_account, invoke_context)
},
@ -2223,7 +2225,7 @@ mod tests {
},
],
Err(NonceError::NoRecentBlockhashes.into()),
|first_instruction_account: usize, invoke_context: &mut InvokeContext| {
|first_instruction_account: IndexOfAccount, invoke_context: &mut InvokeContext| {
invoke_context.blockhash = hash(&serialize(&0).unwrap());
super::process_instruction(first_instruction_account, invoke_context)
},

108
sdk/src/transaction_context.rs
View File

@ -77,21 +77,24 @@ pub enum TransactionContextAttribute {
InstructionAccountIsWritable,
}
/// Index of an account inside of the TransactionContext or an InstructionContext.
pub type IndexOfAccount = u16;
/// Contains account meta data which varies between instruction.
///
/// It also contains indices to other structures for faster lookup.
#[derive(Clone, Debug)]
pub struct InstructionAccount {
/// Points to the account and its key in the `TransactionContext`
pub index_in_transaction: usize,
pub index_in_transaction: IndexOfAccount,
/// Points to the first occurrence in the parent `InstructionContext`
///
/// This excludes the program accounts.
pub index_in_caller: usize,
pub index_in_caller: IndexOfAccount,
/// Points to the first occurrence in the current `InstructionContext`
///
/// This excludes the program accounts.
pub index_in_callee: usize,
pub index_in_callee: IndexOfAccount,
/// Is this account supposed to sign
pub is_signer: bool,
/// Is this account allowed to become writable
@ -169,17 +172,17 @@ impl TransactionContext {
}
/// Returns the total number of accounts loaded in this Transaction
pub fn get_number_of_accounts(&self) -> usize {
self.accounts.len()
pub fn get_number_of_accounts(&self) -> IndexOfAccount {
self.accounts.len() as IndexOfAccount
}
/// Searches for an account by its key
pub fn get_key_of_account_at_index(
&self,
index_in_transaction: usize,
index_in_transaction: IndexOfAccount,
) -> Result<&Pubkey, InstructionError> {
self.account_keys
.get(index_in_transaction)
.get(index_in_transaction as usize)
.ok_or(InstructionError::NotEnoughAccountKeys)
}
@ -187,21 +190,27 @@ impl TransactionContext {
#[cfg(not(target_os = "solana"))]
pub fn get_account_at_index(
&self,
index_in_transaction: usize,
index_in_transaction: IndexOfAccount,
) -> Result<&RefCell<AccountSharedData>, InstructionError> {
self.accounts
.get(index_in_transaction)
.get(index_in_transaction as usize)
.ok_or(InstructionError::NotEnoughAccountKeys)
}
/// Searches for an account by its key
pub fn find_index_of_account(&self, pubkey: &Pubkey) -> Option<usize> {
self.account_keys.iter().position(|key| key == pubkey)
pub fn find_index_of_account(&self, pubkey: &Pubkey) -> Option<IndexOfAccount> {
self.account_keys
.iter()
.position(|key| key == pubkey)
.map(|index| index as IndexOfAccount)
}
/// Searches for a program account by its key
pub fn find_index_of_program_account(&self, pubkey: &Pubkey) -> Option<usize> {
self.account_keys.iter().rposition(|key| key == pubkey)
pub fn find_index_of_program_account(&self, pubkey: &Pubkey) -> Option<IndexOfAccount> {
self.account_keys
.iter()
.rposition(|key| key == pubkey)
.map(|index| index as IndexOfAccount)
}
/// Returns the instruction trace length.
@ -416,7 +425,7 @@ pub struct TransactionReturnData {
pub struct InstructionContext {
nesting_level: usize,
instruction_accounts_lamport_sum: u128,
program_accounts: Vec<usize>,
program_accounts: Vec<IndexOfAccount>,
instruction_accounts: Vec<InstructionAccount>,
instruction_data: Vec<u8>,
}
@ -426,7 +435,7 @@ impl InstructionContext {
#[cfg(not(target_os = "solana"))]
pub fn configure(
&mut self,
program_accounts: &[usize],
program_accounts: &[IndexOfAccount],
instruction_accounts: &[InstructionAccount],
instruction_data: &[u8],
) {
@ -448,19 +457,19 @@ impl InstructionContext {
}
/// Number of program accounts
pub fn get_number_of_program_accounts(&self) -> usize {
self.program_accounts.len()
pub fn get_number_of_program_accounts(&self) -> IndexOfAccount {
self.program_accounts.len() as IndexOfAccount
}
/// Number of accounts in this Instruction (without program accounts)
pub fn get_number_of_instruction_accounts(&self) -> usize {
self.instruction_accounts.len()
pub fn get_number_of_instruction_accounts(&self) -> IndexOfAccount {
self.instruction_accounts.len() as IndexOfAccount
}
/// Assert that enough account were supplied to this Instruction
pub fn check_number_of_instruction_accounts(
&self,
expected_at_least: usize,
expected_at_least: IndexOfAccount,
) -> Result<(), InstructionError> {
if self.get_number_of_instruction_accounts() < expected_at_least {
Err(InstructionError::NotEnoughAccountKeys)
@ -479,12 +488,16 @@ impl InstructionContext {
&self,
transaction_context: &TransactionContext,
pubkey: &Pubkey,
) -> Option<usize> {
) -> Option<IndexOfAccount> {
self.program_accounts
.iter()
.position(|index_in_transaction| {
transaction_context.account_keys.get(*index_in_transaction) == Some(pubkey)
transaction_context
.account_keys
.get(*index_in_transaction as usize)
== Some(pubkey)
})
.map(|index| index as IndexOfAccount)
}
/// Searches for an instruction account by its key
@ -492,49 +505,50 @@ impl InstructionContext {
&self,
transaction_context: &TransactionContext,
pubkey: &Pubkey,
) -> Option<usize> {
) -> Option<IndexOfAccount> {
self.instruction_accounts
.iter()
.position(|instruction_account| {
transaction_context
.account_keys
.get(instruction_account.index_in_transaction)
.get(instruction_account.index_in_transaction as usize)
== Some(pubkey)
})
.map(|index| index as IndexOfAccount)
}
/// Translates the given instruction wide program_account_index into a transaction wide index
pub fn get_index_of_program_account_in_transaction(
&self,
program_account_index: usize,
) -> Result<usize, InstructionError> {
program_account_index: IndexOfAccount,
) -> Result<IndexOfAccount, InstructionError> {
Ok(*self
.program_accounts
.get(program_account_index)
.get(program_account_index as usize)
.ok_or(InstructionError::NotEnoughAccountKeys)?)
}
/// Translates the given instruction wide instruction_account_index into a transaction wide index
pub fn get_index_of_instruction_account_in_transaction(
&self,
instruction_account_index: usize,
) -> Result<usize, InstructionError> {
instruction_account_index: IndexOfAccount,
) -> Result<IndexOfAccount, InstructionError> {
Ok(self
.instruction_accounts
.get(instruction_account_index)
.get(instruction_account_index as usize)
.ok_or(InstructionError::NotEnoughAccountKeys)?
.index_in_transaction)
.index_in_transaction as IndexOfAccount)
}
/// Returns `Some(instruction_account_index)` if this is a duplicate
/// and `None` if it is the first account with this key
pub fn is_instruction_account_duplicate(
&self,
instruction_account_index: usize,
) -> Result<Option<usize>, InstructionError> {
instruction_account_index: IndexOfAccount,
) -> Result<Option<IndexOfAccount>, InstructionError> {
let index_in_callee = self
.instruction_accounts
.get(instruction_account_index)
.get(instruction_account_index as usize)
.ok_or(InstructionError::NotEnoughAccountKeys)?
.index_in_callee;
Ok(if index_in_callee == instruction_account_index {
@ -560,12 +574,12 @@ impl InstructionContext {
fn try_borrow_account<'a, 'b: 'a>(
&'a self,
transaction_context: &'b TransactionContext,
index_in_transaction: usize,
index_in_instruction: usize,
index_in_transaction: IndexOfAccount,
index_in_instruction: IndexOfAccount,
) -> Result<BorrowedAccount<'a>, InstructionError> {
let account = transaction_context
.accounts
.get(index_in_transaction)
.get(index_in_transaction as usize)
.ok_or(InstructionError::MissingAccount)?
.try_borrow_mut()
.map_err(|_| InstructionError::AccountBorrowFailed)?;
@ -595,7 +609,7 @@ impl InstructionContext {
pub fn try_borrow_program_account<'a, 'b: 'a>(
&'a self,
transaction_context: &'b TransactionContext,
program_account_index: usize,
program_account_index: IndexOfAccount,
) -> Result<BorrowedAccount<'a>, InstructionError> {
let index_in_transaction =
self.get_index_of_program_account_in_transaction(program_account_index)?;
@ -610,7 +624,7 @@ impl InstructionContext {
pub fn try_borrow_instruction_account<'a, 'b: 'a>(
&'a self,
transaction_context: &'b TransactionContext,
instruction_account_index: usize,
instruction_account_index: IndexOfAccount,
) -> Result<BorrowedAccount<'a>, InstructionError> {
let index_in_transaction =
self.get_index_of_instruction_account_in_transaction(instruction_account_index)?;
@ -625,11 +639,11 @@ impl InstructionContext {
/// Returns whether an instruction account is a signer
pub fn is_instruction_account_signer(
&self,
instruction_account_index: usize,
instruction_account_index: IndexOfAccount,
) -> Result<bool, InstructionError> {
Ok(self
.instruction_accounts
.get(instruction_account_index)
.get(instruction_account_index as usize)
.ok_or(InstructionError::MissingAccount)?
.is_signer)
}
@ -637,11 +651,11 @@ impl InstructionContext {
/// Returns whether an instruction account is writable
pub fn is_instruction_account_writable(
&self,
instruction_account_index: usize,
instruction_account_index: IndexOfAccount,
) -> Result<bool, InstructionError> {
Ok(self
.instruction_accounts
.get(instruction_account_index)
.get(instruction_account_index as usize)
.ok_or(InstructionError::MissingAccount)?
.is_writable)
}
@ -669,14 +683,14 @@ impl InstructionContext {
pub struct BorrowedAccount<'a> {
transaction_context: &'a TransactionContext,
instruction_context: &'a InstructionContext,
index_in_transaction: usize,
index_in_instruction: usize,
index_in_transaction: IndexOfAccount,
index_in_instruction: IndexOfAccount,
account: RefMut<'a, AccountSharedData>,
}
impl<'a> BorrowedAccount<'a> {
/// Returns the index of this account (transaction wide)
pub fn get_index_in_transaction(&self) -> usize {
pub fn get_index_in_transaction(&self) -> IndexOfAccount {
self.index_in_transaction
}
@ -1043,7 +1057,7 @@ impl<'a> BorrowedAccount<'a> {
.account_touched_flags
.try_borrow_mut()
.map_err(|_| InstructionError::GenericError)?
.get_mut(self.index_in_transaction)
.get_mut(self.index_in_transaction as usize)
.ok_or(InstructionError::NotEnoughAccountKeys)? = true;
}
Ok(())