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

Refactor - Renames loader-v3 to loader-v4. (#31570) 

Renames loader-v3 to loader-v4.
This commit is contained in:
Alexander Meißner 2023-05-11 08:29:06 +02:00 committed by GitHub
parent f985f73d52
commit bbd8be6cbe
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 109 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Cargo.lock generated
View File

@ -6037,7 +6037,7 @@ dependencies = [
]
[[package]]
name = "solana-loader-v3-program"
name = "solana-loader-v4-program"
version = "1.16.0"
dependencies = [
"bincode",
@ -6716,7 +6716,7 @@ dependencies = [
"solana-config-program",
"solana-frozen-abi 1.16.0",
"solana-frozen-abi-macro 1.16.0",
"solana-loader-v3-program",
"solana-loader-v4-program",
"solana-logger 1.16.0",
"solana-measure",
"solana-metrics",

4
Cargo.toml
View File

@ -59,7 +59,7 @@ members = [
"programs/compute-budget",
"programs/config",
"programs/ed25519-tests",
"programs/loader-v3",
"programs/loader-v4",
"programs/stake",
"programs/system",
"programs/vote",
@ -319,7 +319,7 @@ solana-genesis-utils = { path = "genesis-utils", version = "=1.16.0" }
solana-geyser-plugin-interface = { path = "geyser-plugin-interface", version = "=1.16.0" }
solana-geyser-plugin-manager = { path = "geyser-plugin-manager", version = "=1.16.0" }
solana-gossip = { path = "gossip", version = "=1.16.0" }
solana-loader-v3-program = { path = "programs/loader-v3", version = "=1.16.0" }
solana-loader-v4-program = { path = "programs/loader-v4", version = "=1.16.0" }
solana-ledger = { path = "ledger", version = "=1.16.0" }
solana-local-cluster = { path = "local-cluster", version = "=1.16.0" }
solana-logger = { path = "logger", version = "=1.16.0" }

4
program-runtime/src/loaded_programs.rs
View File

@ -12,7 +12,7 @@ use {
vm::{BuiltInProgram, VerifiedExecutable},
},
solana_sdk::{
bpf_loader, bpf_loader_deprecated, bpf_loader_upgradeable, clock::Slot, loader_v3,
bpf_loader, bpf_loader_deprecated, bpf_loader_upgradeable, clock::Slot, loader_v4,
pubkey::Pubkey, saturating_add_assign,
},
std::{
@ -228,7 +228,7 @@ impl LoadedProgram {
LoadedProgramType::LegacyV0(VerifiedExecutable::from_executable(executable)?)
} else if bpf_loader::check_id(loader_key) || bpf_loader_upgradeable::check_id(loader_key) {
LoadedProgramType::LegacyV1(VerifiedExecutable::from_executable(executable)?)
} else if loader_v3::check_id(loader_key) {
} else if loader_v4::check_id(loader_key) {
LoadedProgramType::Typed(VerifiedExecutable::from_executable(executable)?)
} else {
panic!();

4
programs/loader-v3/Cargo.toml → programs/loader-v4/Cargo.toml
View File

@ -1,5 +1,5 @@
[package]
name = "solana-loader-v3-program"
name = "solana-loader-v4-program"
description = "Solana Loader v3"
publish = false
version = { workspace = true }
@ -22,7 +22,7 @@ bincode = { workspace = true }
[lib]
crate-type = ["lib"]
name = "solana_loader_v3_program"
name = "solana_loader_v4_program"
[package.metadata.docs.rs]
targets = ["x86_64-unknown-linux-gnu"]

172
programs/loader-v3/src/lib.rs → programs/loader-v4/src/lib.rs
View File

@ -23,8 +23,8 @@ use {
entrypoint::{HEAP_LENGTH, SUCCESS},
feature_set::{self, FeatureSet},
instruction::InstructionError,
loader_v3::{self, LoaderV3State, DEPLOYMENT_COOLDOWN_IN_SLOTS},
loader_v3_instruction::LoaderV3Instruction,
loader_v4::{self, LoaderV4State, DEPLOYMENT_COOLDOWN_IN_SLOTS},
loader_v4_instruction::LoaderV4Instruction,
program_utils::limited_deserialize,
pubkey::Pubkey,
saturating_add_assign,
@ -37,30 +37,30 @@ use {
},
};
pub fn get_state(data: &[u8]) -> Result<&LoaderV3State, InstructionError> {
pub fn get_state(data: &[u8]) -> Result<&LoaderV4State, InstructionError> {
unsafe {
let data = data
.get(0..LoaderV3State::program_data_offset())
.get(0..LoaderV4State::program_data_offset())
.ok_or(InstructionError::AccountDataTooSmall)?
.try_into()
.unwrap();
Ok(std::mem::transmute::<
&[u8; LoaderV3State::program_data_offset()],
&LoaderV3State,
&[u8; LoaderV4State::program_data_offset()],
&LoaderV4State,
>(data))
}
}
fn get_state_mut(data: &mut [u8]) -> Result<&mut LoaderV3State, InstructionError> {
fn get_state_mut(data: &mut [u8]) -> Result<&mut LoaderV4State, InstructionError> {
unsafe {
let data = data
.get_mut(0..LoaderV3State::program_data_offset())
.get_mut(0..LoaderV4State::program_data_offset())
.ok_or(InstructionError::AccountDataTooSmall)?
.try_into()
.unwrap();
Ok(std::mem::transmute::<
&mut [u8; LoaderV3State::program_data_offset()],
&mut LoaderV3State,
&mut [u8; LoaderV4State::program_data_offset()],
&mut LoaderV4State,
>(data))
}
}
@ -107,10 +107,10 @@ pub fn load_program_from_account(
let state = get_state(program.get_data())?;
let programdata = program
.get_data()
.get(LoaderV3State::program_data_offset()..)
.get(LoaderV4State::program_data_offset()..)
.ok_or(InstructionError::AccountDataTooSmall)?;
let loaded_program = LoadedProgram::new(
&loader_v3::id(),
&loader_v4::id(),
Arc::new(loader),
state.slot,
state.slot.saturating_add(1),
@ -227,8 +227,8 @@ fn check_program_account(
instruction_context: &InstructionContext,
program: &BorrowedAccount,
authority_address: &Pubkey,
) -> Result<LoaderV3State, InstructionError> {
if !loader_v3::check_id(program.get_owner()) {
) -> Result<LoaderV4State, InstructionError> {
if !loader_v4::check_id(program.get_owner()) {
ic_logger_msg!(log_collector, "Program not owned by loader");
return Err(InstructionError::InvalidAccountOwner);
}
@ -273,7 +273,7 @@ pub fn process_instruction_write(
.ok();
let is_initialization = offset == 0 && program.get_data().is_empty();
if is_initialization {
if !loader_v3::check_id(program.get_owner()) {
if !loader_v4::check_id(program.get_owner()) {
ic_logger_msg!(log_collector, "Program not owned by loader");
return Err(InstructionError::InvalidAccountOwner);
}
@ -308,7 +308,7 @@ pub fn process_instruction_write(
let program_size = program
.get_data()
.len()
.saturating_sub(LoaderV3State::program_data_offset());
.saturating_sub(LoaderV4State::program_data_offset());
if offset as usize > program_size {
ic_logger_msg!(log_collector, "Write out of bounds");
return Err(InstructionError::AccountDataTooSmall);
@ -316,7 +316,7 @@ pub fn process_instruction_write(
let end_offset = (offset as usize).saturating_add(bytes.len());
let rent = invoke_context.get_sysvar_cache().get_rent()?;
let required_lamports =
rent.minimum_balance(LoaderV3State::program_data_offset().saturating_add(end_offset));
rent.minimum_balance(LoaderV4State::program_data_offset().saturating_add(end_offset));
let transfer_lamports = required_lamports.saturating_sub(program.get_lamports());
if transfer_lamports > 0 {
payer = payer.filter(|payer| payer.get_lamports() >= transfer_lamports);
@ -330,7 +330,7 @@ pub fn process_instruction_write(
}
}
if end_offset > program_size {
program.set_data_length(LoaderV3State::program_data_offset().saturating_add(end_offset))?;
program.set_data_length(LoaderV4State::program_data_offset().saturating_add(end_offset))?;
}
if let Some(mut payer) = payer {
payer.checked_sub_lamports(transfer_lamports)?;
@ -345,8 +345,8 @@ pub fn process_instruction_write(
program
.get_data_mut()?
.get_mut(
LoaderV3State::program_data_offset().saturating_add(offset as usize)
..LoaderV3State::program_data_offset().saturating_add(end_offset),
LoaderV4State::program_data_offset().saturating_add(offset as usize)
..LoaderV4State::program_data_offset().saturating_add(end_offset),
)
.ok_or(InstructionError::AccountDataTooSmall)?
.copy_from_slice(&bytes);
@ -379,7 +379,7 @@ pub fn process_instruction_truncate(
let program_size = program
.get_data()
.len()
.saturating_sub(LoaderV3State::program_data_offset());
.saturating_sub(LoaderV4State::program_data_offset());
if offset as usize > program_size {
ic_logger_msg!(log_collector, "Truncate out of bounds");
return Err(InstructionError::AccountDataTooSmall);
@ -389,7 +389,7 @@ pub fn process_instruction_truncate(
0
} else {
program.set_data_length(
LoaderV3State::program_data_offset().saturating_add(offset as usize),
LoaderV4State::program_data_offset().saturating_add(offset as usize),
)?;
let rent = invoke_context.get_sysvar_cache().get_rent()?;
rent.minimum_balance(program.get_data().len())
@ -553,7 +553,7 @@ pub fn process_instruction_inner(
let instruction_context = transaction_context.get_current_instruction_context()?;
let instruction_data = instruction_context.get_instruction_data();
let program_id = instruction_context.get_last_program_key(transaction_context)?;
if loader_v3::check_id(program_id) {
if loader_v4::check_id(program_id) {
if invoke_context
.feature_set
.is_active(&feature_set::native_programs_consume_cu::id())
@ -561,22 +561,22 @@ pub fn process_instruction_inner(
invoke_context.consume_checked(2000)?;
}
match limited_deserialize(instruction_data)? {
LoaderV3Instruction::Write { offset, bytes } => {
LoaderV4Instruction::Write { offset, bytes } => {
process_instruction_write(invoke_context, offset, bytes)
}
LoaderV3Instruction::Truncate { offset } => {
LoaderV4Instruction::Truncate { offset } => {
process_instruction_truncate(invoke_context, offset)
}
LoaderV3Instruction::Deploy => process_instruction_deploy(invoke_context),
LoaderV3Instruction::Retract => process_instruction_retract(invoke_context),
LoaderV3Instruction::TransferAuthority => {
LoaderV4Instruction::Deploy => process_instruction_deploy(invoke_context),
LoaderV4Instruction::Retract => process_instruction_retract(invoke_context),
LoaderV4Instruction::TransferAuthority => {
process_instruction_transfer_authority(invoke_context)
}
}
.map_err(|err| Box::new(err) as Box<dyn std::error::Error>)
} else {
let program = instruction_context.try_borrow_last_program_account(transaction_context)?;
if !loader_v3::check_id(program.get_owner()) {
if !loader_v4::check_id(program.get_owner()) {
ic_logger_msg!(log_collector, "Program not owned by loader");
return Err(Box::new(InstructionError::InvalidAccountOwner));
}
@ -655,7 +655,7 @@ mod tests {
)
.collect::<Vec<_>>();
mock_process_instruction(
&loader_v3::id(),
&loader_v4::id(),
program_indices,
instruction_data,
transaction_accounts,
@ -678,20 +678,20 @@ mod tests {
file.read_to_end(&mut elf_bytes).unwrap();
let rent = rent::Rent::default();
let account_size =
loader_v3::LoaderV3State::program_data_offset().saturating_add(elf_bytes.len());
loader_v4::LoaderV4State::program_data_offset().saturating_add(elf_bytes.len());
let mut program_account = AccountSharedData::new(
rent.minimum_balance(account_size),
account_size,
&loader_v3::id(),
&loader_v4::id(),
);
program_account
.set_state(&loader_v3::LoaderV3State {
.set_state(&loader_v4::LoaderV4State {
slot: 0,
is_deployed,
authority_address,
})
.unwrap();
program_account.data_as_mut_slice()[loader_v3::LoaderV3State::program_data_offset()..]
program_account.data_as_mut_slice()[loader_v4::LoaderV4State::program_data_offset()..]
.copy_from_slice(&elf_bytes);
program_account
}
@ -704,7 +704,7 @@ mod tests {
create_account_shared_data_for_test(&clock)
}
fn test_loader_instruction_general_errors(instruction: LoaderV3Instruction) {
fn test_loader_instruction_general_errors(instruction: LoaderV4Instruction) {
let instruction = bincode::serialize(&instruction).unwrap();
let authority_address = Pubkey::new_unique();
let transaction_accounts = vec![
@ -800,7 +800,7 @@ mod tests {
let mut transaction_accounts = vec![
(
Pubkey::new_unique(),
AccountSharedData::new(0, 0, &loader_v3::id()),
AccountSharedData::new(0, 0, &loader_v4::id()),
),
(
authority_address,
@ -808,7 +808,7 @@ mod tests {
),
(
Pubkey::new_unique(),
AccountSharedData::new(10000000, 0, &loader_v3::id()),
AccountSharedData::new(10000000, 0, &loader_v4::id()),
),
(
Pubkey::new_unique(),
@ -827,7 +827,7 @@ mod tests {
// Initialize account by first write
let accounts = process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Write {
&bincode::serialize(&LoaderV4Instruction::Write {
offset: 0,
bytes: vec![0, 1, 2, 3],
})
@ -838,7 +838,7 @@ mod tests {
);
assert_eq!(
accounts[0].data().len(),
loader_v3::LoaderV3State::program_data_offset().saturating_add(4),
loader_v4::LoaderV4State::program_data_offset().saturating_add(4),
);
assert_eq!(accounts[0].lamports(), 1252800);
assert_eq!(
@ -852,7 +852,7 @@ mod tests {
// Error: Program is not writeable
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Write {
&bincode::serialize(&LoaderV4Instruction::Write {
offset: 0,
bytes: vec![0, 1, 2, 3],
})
@ -865,7 +865,7 @@ mod tests {
// Error: Authority did not sign
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Write {
&bincode::serialize(&LoaderV4Instruction::Write {
offset: 0,
bytes: vec![0, 1, 2, 3],
})
@ -879,7 +879,7 @@ mod tests {
transaction_accounts[0].1 = accounts[0].clone();
let accounts = process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Write {
&bincode::serialize(&LoaderV4Instruction::Write {
offset: 4,
bytes: vec![4, 5, 6, 7],
})
@ -890,7 +890,7 @@ mod tests {
);
assert_eq!(
accounts[0].data().len(),
loader_v3::LoaderV3State::program_data_offset().saturating_add(8),
loader_v4::LoaderV4State::program_data_offset().saturating_add(8),
);
assert_eq!(
accounts[0].lamports(),
@ -909,7 +909,7 @@ mod tests {
transaction_accounts[0].1 = accounts[0].clone();
let accounts = process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Write {
&bincode::serialize(&LoaderV4Instruction::Write {
offset: 2,
bytes: vec![8, 8, 8, 8],
})
@ -920,7 +920,7 @@ mod tests {
);
assert_eq!(
accounts[0].data().len(),
loader_v3::LoaderV3State::program_data_offset().saturating_add(8),
loader_v4::LoaderV4State::program_data_offset().saturating_add(8),
);
assert_eq!(accounts[0].lamports(), transaction_accounts[0].1.lamports());
@ -928,7 +928,7 @@ mod tests {
transaction_accounts[0].1 = accounts[0].clone();
let accounts = process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Write {
&bincode::serialize(&LoaderV4Instruction::Write {
offset: 2,
bytes: Vec::new(),
})
@ -939,14 +939,14 @@ mod tests {
);
assert_eq!(
accounts[0].data().len(),
loader_v3::LoaderV3State::program_data_offset().saturating_add(8),
loader_v4::LoaderV4State::program_data_offset().saturating_add(8),
);
assert_eq!(accounts[0].lamports(), transaction_accounts[0].1.lamports());
// Error: Program is not retracted
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Write {
&bincode::serialize(&LoaderV4Instruction::Write {
offset: 8,
bytes: vec![8, 8, 8, 8],
})
@ -959,7 +959,7 @@ mod tests {
// Error: Payer did not sign
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Write {
&bincode::serialize(&LoaderV4Instruction::Write {
offset: 8,
bytes: vec![8, 8, 8, 8],
})
@ -972,7 +972,7 @@ mod tests {
// Error: Payer is not writeable
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Write {
&bincode::serialize(&LoaderV4Instruction::Write {
offset: 8,
bytes: vec![8, 8, 8, 8],
})
@ -985,7 +985,7 @@ mod tests {
// Error: Write out of bounds
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Write {
&bincode::serialize(&LoaderV4Instruction::Write {
offset: 9,
bytes: vec![8, 8, 8, 8],
})
@ -998,7 +998,7 @@ mod tests {
// Error: Insufficient funds (Bankrupt payer account)
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Write {
&bincode::serialize(&LoaderV4Instruction::Write {
offset: 8,
bytes: vec![8, 8, 8, 8],
})
@ -1011,7 +1011,7 @@ mod tests {
// Error: Insufficient funds (No payer account)
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Write {
&bincode::serialize(&LoaderV4Instruction::Write {
offset: 8,
bytes: vec![8, 8, 8, 8],
})
@ -1021,7 +1021,7 @@ mod tests {
Err(InstructionError::InsufficientFunds),
);
test_loader_instruction_general_errors(LoaderV3Instruction::Write {
test_loader_instruction_general_errors(LoaderV4Instruction::Write {
offset: 0,
bytes: Vec::new(),
});
@ -1041,7 +1041,7 @@ mod tests {
),
(
Pubkey::new_unique(),
AccountSharedData::new(0, 0, &loader_v3::id()),
AccountSharedData::new(0, 0, &loader_v4::id()),
),
(
Pubkey::new_unique(),
@ -1060,14 +1060,14 @@ mod tests {
// Cut the end off
let accounts = process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Truncate { offset: 4 }).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Truncate { offset: 4 }).unwrap(),
transaction_accounts.clone(),
&[(0, false, true), (1, true, false), (2, false, true)],
Ok(()),
);
assert_eq!(
accounts[0].data().len(),
loader_v3::LoaderV3State::program_data_offset().saturating_add(4),
loader_v4::LoaderV4State::program_data_offset().saturating_add(4),
);
assert_eq!(accounts[0].lamports(), 1252800);
assert_eq!(
@ -1081,7 +1081,7 @@ mod tests {
// Close program account
let accounts = process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Truncate { offset: 0 }).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Truncate { offset: 0 }).unwrap(),
transaction_accounts.clone(),
&[(0, false, true), (1, true, false), (2, false, true)],
Ok(()),
@ -1098,7 +1098,7 @@ mod tests {
// Error: Program is uninitialized
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Truncate { offset: 0 }).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Truncate { offset: 0 }).unwrap(),
transaction_accounts.clone(),
&[(2, false, true), (1, true, false), (0, false, true)],
Err(InstructionError::InvalidAccountData),
@ -1107,7 +1107,7 @@ mod tests {
// Error: Program is not retracted
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Truncate { offset: 0 }).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Truncate { offset: 0 }).unwrap(),
transaction_accounts.clone(),
&[(3, false, true), (1, true, false), (2, false, true)],
Err(InstructionError::InvalidArgument),
@ -1116,13 +1116,13 @@ mod tests {
// Error: Truncate out of bounds
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Truncate { offset: 10000 }).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Truncate { offset: 10000 }).unwrap(),
transaction_accounts,
&[(0, false, true), (1, true, false), (2, false, true)],
Err(InstructionError::AccountDataTooSmall),
);
test_loader_instruction_general_errors(LoaderV3Instruction::Truncate { offset: 0 });
test_loader_instruction_general_errors(LoaderV4Instruction::Truncate { offset: 0 });
}
#[test]
@ -1143,7 +1143,7 @@ mod tests {
),
(
Pubkey::new_unique(),
AccountSharedData::new(0, 0, &loader_v3::id()),
AccountSharedData::new(0, 0, &loader_v4::id()),
),
(
Pubkey::new_unique(),
@ -1159,7 +1159,7 @@ mod tests {
// Deploy from its own data
let accounts = process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Deploy).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Deploy).unwrap(),
transaction_accounts.clone(),
&[(0, false, true), (1, true, false)],
Ok(()),
@ -1175,7 +1175,7 @@ mod tests {
// Error: Source program is not writable
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Deploy).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Deploy).unwrap(),
transaction_accounts.clone(),
&[(0, false, true), (1, true, false), (2, false, false)],
Err(InstructionError::InvalidArgument),
@ -1184,7 +1184,7 @@ mod tests {
// Error: Source program is not retracted
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Deploy).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Deploy).unwrap(),
transaction_accounts.clone(),
&[(2, false, true), (1, true, false), (0, false, true)],
Err(InstructionError::InvalidArgument),
@ -1193,7 +1193,7 @@ mod tests {
// Redeploy: Retract, then replace data by other source
let accounts = process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Retract).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Retract).unwrap(),
transaction_accounts.clone(),
&[(0, false, true), (1, true, false)],
Ok(()),
@ -1201,7 +1201,7 @@ mod tests {
transaction_accounts[0].1 = accounts[0].clone();
let accounts = process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Deploy).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Deploy).unwrap(),
transaction_accounts.clone(),
&[(0, false, true), (1, true, false), (2, false, true)],
Ok(()),
@ -1224,7 +1224,7 @@ mod tests {
// Error: Program was deployed recently, cooldown still in effect
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Deploy).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Deploy).unwrap(),
transaction_accounts.clone(),
&[(0, false, true), (1, true, false)],
Err(InstructionError::InvalidArgument),
@ -1234,7 +1234,7 @@ mod tests {
// Error: Program is uninitialized
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Deploy).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Deploy).unwrap(),
transaction_accounts.clone(),
&[(3, false, true), (1, true, false)],
Err(InstructionError::InvalidAccountData),
@ -1243,7 +1243,7 @@ mod tests {
// Error: Program fails verification
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Deploy).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Deploy).unwrap(),
transaction_accounts.clone(),
&[(4, false, true), (1, true, false)],
Err(InstructionError::InvalidAccountData),
@ -1252,13 +1252,13 @@ mod tests {
// Error: Program is deployed already
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Deploy).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Deploy).unwrap(),
transaction_accounts.clone(),
&[(0, false, true), (1, true, false)],
Err(InstructionError::InvalidArgument),
);
test_loader_instruction_general_errors(LoaderV3Instruction::Deploy);
test_loader_instruction_general_errors(LoaderV4Instruction::Deploy);
}
#[test]
@ -1275,7 +1275,7 @@ mod tests {
),
(
Pubkey::new_unique(),
AccountSharedData::new(0, 0, &loader_v3::id()),
AccountSharedData::new(0, 0, &loader_v4::id()),
),
(
Pubkey::new_unique(),
@ -1291,7 +1291,7 @@ mod tests {
// Retract program
let accounts = process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Retract).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Retract).unwrap(),
transaction_accounts.clone(),
&[(0, false, true), (1, true, false)],
Ok(()),
@ -1305,7 +1305,7 @@ mod tests {
// Error: Program is uninitialized
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Retract).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Retract).unwrap(),
transaction_accounts.clone(),
&[(2, false, true), (1, true, false)],
Err(InstructionError::InvalidAccountData),
@ -1314,7 +1314,7 @@ mod tests {
// Error: Program is not deployed
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Retract).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Retract).unwrap(),
transaction_accounts.clone(),
&[(3, false, true), (1, true, false)],
Err(InstructionError::InvalidArgument),
@ -1324,13 +1324,13 @@ mod tests {
transaction_accounts[4].1 = clock(0);
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::Retract).unwrap(),
&bincode::serialize(&LoaderV4Instruction::Retract).unwrap(),
transaction_accounts.clone(),
&[(0, false, true), (1, true, false)],
Err(InstructionError::InvalidArgument),
);
test_loader_instruction_general_errors(LoaderV3Instruction::Retract);
test_loader_instruction_general_errors(LoaderV4Instruction::Retract);
}
#[test]
@ -1351,7 +1351,7 @@ mod tests {
),
(
Pubkey::new_unique(),
AccountSharedData::new(0, 0, &loader_v3::id()),
AccountSharedData::new(0, 0, &loader_v4::id()),
),
(
clock::id(),
@ -1366,7 +1366,7 @@ mod tests {
// Transfer authority
let accounts = process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::TransferAuthority).unwrap(),
&bincode::serialize(&LoaderV4Instruction::TransferAuthority).unwrap(),
transaction_accounts.clone(),
&[(0, false, true), (1, true, false), (2, true, false)],
Ok(()),
@ -1380,7 +1380,7 @@ mod tests {
// Finalize program
let accounts = process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::TransferAuthority).unwrap(),
&bincode::serialize(&LoaderV4Instruction::TransferAuthority).unwrap(),
transaction_accounts.clone(),
&[(0, false, true), (1, true, false)],
Ok(()),
@ -1394,7 +1394,7 @@ mod tests {
// Error: Program is uninitialized
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::TransferAuthority).unwrap(),
&bincode::serialize(&LoaderV4Instruction::TransferAuthority).unwrap(),
transaction_accounts.clone(),
&[(3, false, true), (1, true, false), (2, true, false)],
Err(InstructionError::InvalidAccountData),
@ -1403,13 +1403,13 @@ mod tests {
// Error: New authority did not sign
process_instruction(
vec![],
&bincode::serialize(&LoaderV3Instruction::TransferAuthority).unwrap(),
&bincode::serialize(&LoaderV4Instruction::TransferAuthority).unwrap(),
transaction_accounts,
&[(0, false, true), (1, true, false), (2, false, false)],
Err(InstructionError::MissingRequiredSignature),
);
test_loader_instruction_general_errors(LoaderV3Instruction::TransferAuthority);
test_loader_instruction_general_errors(LoaderV4Instruction::TransferAuthority);
}
#[test]
@ -1426,7 +1426,7 @@ mod tests {
),
(
Pubkey::new_unique(),
AccountSharedData::new(0, 0, &loader_v3::id()),
AccountSharedData::new(0, 0, &loader_v4::id()),
),
(
Pubkey::new_unique(),

0
programs/loader-v3/test_elfs/out/invalid.so → programs/loader-v4/test_elfs/out/invalid.so
View File

0
programs/loader-v3/test_elfs/out/noop.so → programs/loader-v4/test_elfs/out/noop.so
View File

0
programs/loader-v3/test_elfs/out/rodata.so → programs/loader-v4/test_elfs/out/rodata.so
View File

4
programs/sbf/Cargo.lock generated
View File

@ -5125,7 +5125,7 @@ dependencies = [
]
[[package]]
name = "solana-loader-v3-program"
name = "solana-loader-v4-program"
version = "1.16.0"
dependencies = [
"log",
@ -5632,7 +5632,7 @@ dependencies = [
"solana-config-program",
"solana-frozen-abi 1.16.0",
"solana-frozen-abi-macro 1.16.0",
"solana-loader-v3-program",
"solana-loader-v4-program",
"solana-measure",
"solana-metrics",
"solana-perf",

2
runtime/Cargo.toml
View File

@ -50,7 +50,7 @@ solana-compute-budget-program = { workspace = true }
solana-config-program = { workspace = true }
solana-frozen-abi = { workspace = true }
solana-frozen-abi-macro = { workspace = true }
solana-loader-v3-program = { workspace = true }
solana-loader-v4-program = { workspace = true }
solana-measure = { workspace = true }
solana-metrics = { workspace = true }
solana-perf = { workspace = true }

6
runtime/src/bank.rs
View File

@ -137,7 +137,7 @@ use {
inflation::Inflation,
instruction::{CompiledInstruction, TRANSACTION_LEVEL_STACK_HEIGHT},
lamports::LamportsError,
loader_v3,
loader_v4,
message::{AccountKeys, SanitizedMessage},
native_loader,
native_token::{sol_to_lamports, LAMPORTS_PER_SOL},
@ -4088,8 +4088,8 @@ impl Bank {
}
}
Err(TransactionError::ProgramAccountNotFound)
} else if loader_v3::check_id(program.owner()) {
let state = solana_loader_v3_program::get_state(program.data())
} else if loader_v4::check_id(program.owner()) {
let state = solana_loader_v4_program::get_state(program.data())
.map_err(|_| TransactionError::ProgramAccountNotFound)?;
Ok(state.slot)
} else {

4
sdk/program/src/lib.rs
View File

@ -500,8 +500,8 @@ pub mod keccak;
pub mod lamports;
pub mod loader_instruction;
pub mod loader_upgradeable_instruction;
pub mod loader_v3;
pub mod loader_v3_instruction;
pub mod loader_v4;
pub mod loader_v4_instruction;
pub mod log;
pub mod message;
pub mod native_token;

8
sdk/program/src/loader_v3.rs → sdk/program/src/loader_v4.rs
View File

@ -4,15 +4,15 @@
use crate::pubkey::Pubkey;
crate::declare_id!("LoaderV311111111111111111111111111111111111");
crate::declare_id!("LoaderV411111111111111111111111111111111111");
/// Cooldown before a program can be un-/redeployed again
pub const DEPLOYMENT_COOLDOWN_IN_SLOTS: u64 = 750;
/// LoaderV3 account states
/// LoaderV4 account states
#[repr(C)]
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Copy, AbiExample)]
pub struct LoaderV3State {
pub struct LoaderV4State {
/// Slot that the program was last initialized, deployed or retracted in.
pub slot: u64,
/// True if the program is ready to be executed, false if it is retracted for maintainance.
@ -23,7 +23,7 @@ pub struct LoaderV3State {
// account's data.
}
impl LoaderV3State {
impl LoaderV4State {
/// Size of a serialized program account.
pub const fn program_data_offset() -> usize {
std::mem::size_of::<Self>()

2
sdk/program/src/loader_v3_instruction.rs → sdk/program/src/loader_v4_instruction.rs
View File

@ -2,7 +2,7 @@
#[repr(u8)]
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
pub enum LoaderV3Instruction {
pub enum LoaderV4Instruction {
/// Write ELF data into an undeployed program account.
///
/// Writing at the end (offset is length) increases the size of the program account and

4
sdk/src/lib.rs
View File

@ -47,8 +47,8 @@ pub use solana_program::{
bpf_loader_deprecated, bpf_loader_upgradeable, clock, config, custom_heap_default,
custom_panic_default, debug_account_data, declare_deprecated_sysvar_id, declare_sysvar_id,
decode_error, ed25519_program, epoch_schedule, fee_calculator, impl_sysvar_get, incinerator,
instruction, keccak, lamports, loader_instruction, loader_upgradeable_instruction, loader_v3,
loader_v3_instruction, message, msg, native_token, nonce, program, program_error,
instruction, keccak, lamports, loader_instruction, loader_upgradeable_instruction, loader_v4,
loader_v4_instruction, message, msg, native_token, nonce, program, program_error,
program_memory, program_option, program_pack, rent, sanitize, sdk_ids, secp256k1_program,
secp256k1_recover, serde_varint, serialize_utils, short_vec, slot_hashes, slot_history,
stable_layout, stake, stake_history, syscalls, system_instruction, system_program, sysvar,