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

Migrate from address maps to address lookup tables (#21634)

Browse Source 
* Migrate from address maps to address lookup tables

* update sanitize error

* cargo fmt

* update abi
This commit is contained in:
Justin Starry
2021-12-10 11:04:04 -05:00
committed by GitHub
parent fd175c1ea9
commit 6c108c8fc3
11 changed files with 610 additions and 610 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
sdk/program/src/message/mod.rs
View File

@ -5,12 +5,10 @@ pub mod legacy;
#[cfg(not(target_arch = "bpf"))]
#[path = ""]
mod non_bpf_modules {
mod mapped;
mod sanitized;
pub mod v0;
mod versions;
pub use {mapped::*, sanitized::*, versions::*};
pub use {sanitized::*, versions::*};
}
pub use legacy::Message;

66
sdk/program/src/message/sanitized.rs
View File

@ -2,7 +2,7 @@ use {
crate::{
hash::Hash,
instruction::{CompiledInstruction, Instruction},
message::{MappedAddresses, MappedMessage, Message, MessageHeader},
message::{v0::{self, LoadedAddresses}, legacy::Message as LegacyMessage, MessageHeader},
pubkey::Pubkey,
sanitize::{Sanitize, SanitizeError},
serialize_utils::{append_slice, append_u16, append_u8},
@ -17,9 +17,9 @@ use {
#[derive(Debug, Clone)]
pub enum SanitizedMessage {
/// Sanitized legacy message
Legacy(Message),
Legacy(LegacyMessage),
/// Sanitized version #0 message with mapped addresses
V0(MappedMessage),
V0(v0::LoadedMessage),
}
#[derive(PartialEq, Debug, Error, Eq, Clone)]
@ -44,9 +44,9 @@ impl From<SanitizeError> for SanitizeMessageError {
}
}
impl TryFrom<Message> for SanitizedMessage {
impl TryFrom<LegacyMessage> for SanitizedMessage {
type Error = SanitizeMessageError;
fn try_from(message: Message) -> Result<Self, Self::Error> {
fn try_from(message: LegacyMessage) -> Result<Self, Self::Error> {
message.sanitize()?;
let sanitized_msg = Self::Legacy(message);
@ -80,12 +80,12 @@ impl SanitizedMessage {
pub fn header(&self) -> &MessageHeader {
match self {
Self::Legacy(message) => &message.header,
Self::V0(mapped_msg) => &mapped_msg.message.header,
Self::V0(message) => &message.header,
}
}
/// Returns a legacy message if this sanitized message wraps one
pub fn legacy_message(&self) -> Option<&Message> {
pub fn legacy_message(&self) -> Option<&LegacyMessage> {
if let Self::Legacy(message) = &self {
Some(message)
} else {
@ -103,7 +103,7 @@ impl SanitizedMessage {
pub fn recent_blockhash(&self) -> &Hash {
match self {
Self::Legacy(message) => &message.recent_blockhash,
Self::V0(mapped_msg) => &mapped_msg.message.recent_blockhash,
Self::V0(message) => &message.recent_blockhash,
}
}
@ -112,7 +112,7 @@ impl SanitizedMessage {
pub fn instructions(&self) -> &[CompiledInstruction] {
match self {
Self::Legacy(message) => &message.instructions,
Self::V0(mapped_msg) => &mapped_msg.message.instructions,
Self::V0(message) => &message.instructions,
}
}
@ -123,7 +123,7 @@ impl SanitizedMessage {
) -> impl Iterator<Item = (&Pubkey, &CompiledInstruction)> {
match self {
Self::Legacy(message) => message.instructions.iter(),
Self::V0(mapped_msg) => mapped_msg.message.instructions.iter(),
Self::V0(message) => message.instructions.iter(),
}
.map(move |ix| {
(
@ -138,7 +138,7 @@ impl SanitizedMessage {
pub fn account_keys_iter(&self) -> Box<dyn Iterator<Item = &Pubkey> + '_> {
match self {
Self::Legacy(message) => Box::new(message.account_keys.iter()),
Self::V0(mapped_msg) => Box::new(mapped_msg.account_keys_iter()),
Self::V0(message) => Box::new(message.account_keys_iter()),
}
}
@ -146,7 +146,7 @@ impl SanitizedMessage {
pub fn account_keys_len(&self) -> usize {
match self {
Self::Legacy(message) => message.account_keys.len(),
Self::V0(mapped_msg) => mapped_msg.account_keys_len(),
Self::V0(message) => message.account_keys_len(),
}
}
@ -251,10 +251,10 @@ impl SanitizedMessage {
data
}
/// Return the mapped addresses for this message if it has any.
fn mapped_addresses(&self) -> Option<&MappedAddresses> {
/// Return the resolved addresses for this message if it has any.
fn loaded_lookup_table_addresses(&self) -> Option<&LoadedAddresses> {
match &self {
SanitizedMessage::V0(message) => Some(&message.mapped_addresses),
SanitizedMessage::V0(message) => Some(&message.loaded_addresses),
_ => None,
}
}
@ -262,7 +262,7 @@ impl SanitizedMessage {
/// Return the number of readonly accounts loaded by this message.
pub fn num_readonly_accounts(&self) -> usize {
let mapped_readonly_addresses = self
.mapped_addresses()
.loaded_lookup_table_addresses()
.map(|keys| keys.readonly.len())
.unwrap_or_default();
mapped_readonly_addresses
@ -311,13 +311,13 @@ mod tests {
#[test]
fn test_try_from_message() {
let dupe_key = Pubkey::new_unique();
let legacy_message_with_dupes = Message {
let legacy_message_with_dupes = LegacyMessage {
header: MessageHeader {
num_required_signatures: 1,
..MessageHeader::default()
},
account_keys: vec![dupe_key, dupe_key],
..Message::default()
..LegacyMessage::default()
};
assert_eq!(
@ -325,9 +325,9 @@ mod tests {
Some(SanitizeMessageError::DuplicateAccountKey),
);
let legacy_message_with_no_signers = Message {
let legacy_message_with_no_signers = LegacyMessage {
account_keys: vec![Pubkey::new_unique()],
..Message::default()
..LegacyMessage::default()
};
assert_eq!(
@ -346,7 +346,7 @@ mod tests {
CompiledInstruction::new(2, &(), vec![0, 1]),
];
let message = SanitizedMessage::try_from(Message::new_with_compiled_instructions(
let message = SanitizedMessage::try_from(LegacyMessage::new_with_compiled_instructions(
1,
0,
2,
@ -370,20 +370,20 @@ mod tests {
let key4 = Pubkey::new_unique();
let key5 = Pubkey::new_unique();
let legacy_message = SanitizedMessage::try_from(Message {
let legacy_message = SanitizedMessage::try_from(LegacyMessage {
header: MessageHeader {
num_required_signatures: 2,
num_readonly_signed_accounts: 1,
num_readonly_unsigned_accounts: 1,
},
account_keys: vec![key0, key1, key2, key3],
..Message::default()
..LegacyMessage::default()
})
.unwrap();
assert_eq!(legacy_message.num_readonly_accounts(), 2);
let mapped_message = SanitizedMessage::V0(MappedMessage {
let v0_message = SanitizedMessage::V0(v0::LoadedMessage {
message: v0::Message {
header: MessageHeader {
num_required_signatures: 2,
@ -393,13 +393,13 @@ mod tests {
account_keys: vec![key0, key1, key2, key3],
..v0::Message::default()
},
mapped_addresses: MappedAddresses {
loaded_addresses: LoadedAddresses {
writable: vec![key4],
readonly: vec![key5],
},
});
assert_eq!(mapped_message.num_readonly_accounts(), 3);
assert_eq!(v0_message.num_readonly_accounts(), 3);
}
#[test]
@ -427,7 +427,7 @@ mod tests {
];
let demote_program_write_locks = true;
let message = Message::new(&instructions, Some(&id1));
let message = LegacyMessage::new(&instructions, Some(&id1));
let sanitized_message = SanitizedMessage::try_from(message.clone()).unwrap();
let serialized = sanitized_message.serialize_instructions(demote_program_write_locks);
@ -438,7 +438,7 @@ mod tests {
// assert that Message::deserialize_instruction is compatible with SanitizedMessage::serialize_instructions
for (i, instruction) in instructions.iter().enumerate() {
assert_eq!(
Message::deserialize_instruction(i, &serialized).unwrap(),
LegacyMessage::deserialize_instruction(i, &serialized).unwrap(),
*instruction
);
}
@ -481,18 +481,18 @@ mod tests {
data: vec![],
};
let legacy_message = SanitizedMessage::try_from(Message {
let legacy_message = SanitizedMessage::try_from(LegacyMessage {
header: MessageHeader {
num_required_signatures: 1,
num_readonly_signed_accounts: 0,
num_readonly_unsigned_accounts: 0,
},
account_keys: vec![key0, key1, key2, program_id],
..Message::default()
..LegacyMessage::default()
})
.unwrap();
let mapped_message = SanitizedMessage::V0(MappedMessage {
let v0_message = SanitizedMessage::V0(v0::LoadedMessage {
message: v0::Message {
header: MessageHeader {
num_required_signatures: 1,
@ -502,13 +502,13 @@ mod tests {
account_keys: vec![key0, key1],
..v0::Message::default()
},
mapped_addresses: MappedAddresses {
loaded_addresses: LoadedAddresses {
writable: vec![key2],
readonly: vec![program_id],
},
});
for message in vec![legacy_message, mapped_message] {
for message in vec![legacy_message, v0_message] {
assert_eq!(
message.try_compile_instruction(&valid_instruction),
Some(CompiledInstruction {

396
sdk/program/src/message/v0.rs
View File

@ -1,396 +0,0 @@
use crate::{
hash::Hash,
instruction::CompiledInstruction,
message::{MessageHeader, MESSAGE_VERSION_PREFIX},
pubkey::Pubkey,
sanitize::{Sanitize, SanitizeError},
short_vec,
};
/// Indexes that are mapped to addresses using an on-chain address map for
/// succinctly loading readonly and writable accounts.
#[derive(Serialize, Deserialize, Default, Debug, PartialEq, Eq, Clone, AbiExample)]
#[serde(rename_all = "camelCase")]
pub struct AddressMapIndexes {
#[serde(with = "short_vec")]
pub writable: Vec<u8>,
#[serde(with = "short_vec")]
pub readonly: Vec<u8>,
}
/// Transaction message format which supports succinct account loading with
/// indexes for on-chain address maps.
#[derive(Serialize, Deserialize, Default, Debug, PartialEq, Eq, Clone, AbiExample)]
#[serde(rename_all = "camelCase")]
pub struct Message {
/// The message header, identifying signed and read-only `account_keys`
pub header: MessageHeader,
/// List of accounts loaded by this transaction.
#[serde(with = "short_vec")]
pub account_keys: Vec<Pubkey>,
/// The blockhash of a recent block.
pub recent_blockhash: Hash,
/// Instructions that invoke a designated program, are executed in sequence,
/// and committed in one atomic transaction if all succeed.
///
/// # Notes
///
/// Account and program indexes will index into the list of addresses
/// constructed from the concatenation of `account_keys`, flattened list of
/// `writable` address map indexes, and the flattened `readonly` address
/// map indexes.
#[serde(with = "short_vec")]
pub instructions: Vec<CompiledInstruction>,
/// List of address map indexes used to succinctly load additional accounts
/// for this transaction.
///
/// # Notes
///
/// The last `address_map_indexes.len()` accounts of the read-only unsigned
/// accounts are loaded as address maps.
#[serde(with = "short_vec")]
pub address_map_indexes: Vec<AddressMapIndexes>,
}
impl Sanitize for Message {
fn sanitize(&self) -> Result<(), SanitizeError> {
// signing area and read-only non-signing area should not
// overlap
if usize::from(self.header.num_required_signatures)
.saturating_add(usize::from(self.header.num_readonly_unsigned_accounts))
> self.account_keys.len()
{
return Err(SanitizeError::IndexOutOfBounds);
}
// there should be at least 1 RW fee-payer account.
if self.header.num_readonly_signed_accounts >= self.header.num_required_signatures {
return Err(SanitizeError::IndexOutOfBounds);
}
// there cannot be more address maps than read-only unsigned accounts.
let num_address_map_indexes = self.address_map_indexes.len();
if num_address_map_indexes > usize::from(self.header.num_readonly_unsigned_accounts) {
return Err(SanitizeError::IndexOutOfBounds);
}
// each map must load at least one entry
let mut num_loaded_accounts = self.account_keys.len();
for indexes in &self.address_map_indexes {
let num_loaded_map_entries = indexes
.writable
.len()
.saturating_add(indexes.readonly.len());
if num_loaded_map_entries == 0 {
return Err(SanitizeError::InvalidValue);
}
num_loaded_accounts = num_loaded_accounts.saturating_add(num_loaded_map_entries);
}
// the number of loaded accounts must be <= 256 since account indices are
// encoded as `u8`
if num_loaded_accounts > 256 {
return Err(SanitizeError::IndexOutOfBounds);
}
for ci in &self.instructions {
if usize::from(ci.program_id_index) >= num_loaded_accounts {
return Err(SanitizeError::IndexOutOfBounds);
}
// A program cannot be a payer.
if ci.program_id_index == 0 {
return Err(SanitizeError::IndexOutOfBounds);
}
for ai in &ci.accounts {
if usize::from(*ai) >= num_loaded_accounts {
return Err(SanitizeError::IndexOutOfBounds);
}
}
}
Ok(())
}
}
impl Message {
/// Serialize this message with a version #0 prefix using bincode encoding.
pub fn serialize(&self) -> Vec<u8> {
bincode::serialize(&(MESSAGE_VERSION_PREFIX, self)).unwrap()
}
}
#[cfg(test)]
mod tests {
use {super::*, crate::message::VersionedMessage};
fn simple_message() -> Message {
Message {
header: MessageHeader {
num_required_signatures: 1,
num_readonly_signed_accounts: 0,
num_readonly_unsigned_accounts: 1,
},
account_keys: vec![Pubkey::new_unique(), Pubkey::new_unique()],
address_map_indexes: vec![AddressMapIndexes {
writable: vec![],
readonly: vec![0],
}],
..Message::default()
}
}
fn two_map_message() -> Message {
Message {
header: MessageHeader {
num_required_signatures: 1,
num_readonly_signed_accounts: 0,
num_readonly_unsigned_accounts: 2,
},
account_keys: vec![
Pubkey::new_unique(),
Pubkey::new_unique(),
Pubkey::new_unique(),
],
address_map_indexes: vec![
AddressMapIndexes {
writable: vec![1],
readonly: vec![0],
},
AddressMapIndexes {
writable: vec![0],
readonly: vec![1],
},
],
..Message::default()
}
}
#[test]
fn test_sanitize_account_indices() {
assert!(Message {
account_keys: (0..=u8::MAX).map(|_| Pubkey::new_unique()).collect(),
address_map_indexes: vec![],
instructions: vec![CompiledInstruction {
program_id_index: 1,
accounts: vec![u8::MAX],
data: vec![],
}],
..simple_message()
}
.sanitize()
.is_ok());
assert!(Message {
account_keys: (0..u8::MAX).map(|_| Pubkey::new_unique()).collect(),
address_map_indexes: vec![],
instructions: vec![CompiledInstruction {
program_id_index: 1,
accounts: vec![u8::MAX],
data: vec![],
}],
..simple_message()
}
.sanitize()
.is_err());
assert!(Message {
account_keys: (0..u8::MAX).map(|_| Pubkey::new_unique()).collect(),
instructions: vec![CompiledInstruction {
program_id_index: 1,
accounts: vec![u8::MAX],
data: vec![],
}],
..simple_message()
}
.sanitize()
.is_ok());
assert!(Message {
account_keys: (0..u8::MAX - 1).map(|_| Pubkey::new_unique()).collect(),
instructions: vec![CompiledInstruction {
program_id_index: 1,
accounts: vec![u8::MAX],
data: vec![],
}],
..simple_message()
}
.sanitize()
.is_err());
assert!(Message {
address_map_indexes: vec![
AddressMapIndexes {
writable: (0..200).step_by(2).collect(),
readonly: (1..200).step_by(2).collect(),
},
AddressMapIndexes {
writable: (0..53).step_by(2).collect(),
readonly: (1..53).step_by(2).collect(),
},
],
instructions: vec![CompiledInstruction {
program_id_index: 1,
accounts: vec![u8::MAX],
data: vec![],
}],
..two_map_message()
}
.sanitize()
.is_ok());
assert!(Message {
address_map_indexes: vec![
AddressMapIndexes {
writable: (0..200).step_by(2).collect(),
readonly: (1..200).step_by(2).collect(),
},
AddressMapIndexes {
writable: (0..52).step_by(2).collect(),
readonly: (1..52).step_by(2).collect(),
},
],
instructions: vec![CompiledInstruction {
program_id_index: 1,
accounts: vec![u8::MAX],
data: vec![],
}],
..two_map_message()
}
.sanitize()
.is_err());
}
#[test]
fn test_sanitize_excessive_loaded_accounts() {
assert!(Message {
account_keys: (0..=u8::MAX).map(|_| Pubkey::new_unique()).collect(),
address_map_indexes: vec![],
..simple_message()
}
.sanitize()
.is_ok());
assert!(Message {
account_keys: (0..257).map(|_| Pubkey::new_unique()).collect(),
address_map_indexes: vec![],
..simple_message()
}
.sanitize()
.is_err());
assert!(Message {
account_keys: (0..u8::MAX).map(|_| Pubkey::new_unique()).collect(),
..simple_message()
}
.sanitize()
.is_ok());
assert!(Message {
account_keys: (0..256).map(|_| Pubkey::new_unique()).collect(),
..simple_message()
}
.sanitize()
.is_err());
assert!(Message {
address_map_indexes: vec![
AddressMapIndexes {
writable: (0..200).step_by(2).collect(),
readonly: (1..200).step_by(2).collect(),
},
AddressMapIndexes {
writable: (0..53).step_by(2).collect(),
readonly: (1..53).step_by(2).collect(),
}
],
..two_map_message()
}
.sanitize()
.is_ok());
assert!(Message {
address_map_indexes: vec![
AddressMapIndexes {
writable: (0..200).step_by(2).collect(),
readonly: (1..200).step_by(2).collect(),
},
AddressMapIndexes {
writable: (0..200).step_by(2).collect(),
readonly: (1..200).step_by(2).collect(),
}
],
..two_map_message()
}
.sanitize()
.is_err());
}
#[test]
fn test_sanitize_excessive_maps() {
assert!(Message {
header: MessageHeader {
num_readonly_unsigned_accounts: 1,
..simple_message().header
},
..simple_message()
}
.sanitize()
.is_ok());
assert!(Message {
header: MessageHeader {
num_readonly_unsigned_accounts: 0,
..simple_message().header
},
..simple_message()
}
.sanitize()
.is_err());
}
#[test]
fn test_sanitize_address_map() {
assert!(Message {
address_map_indexes: vec![AddressMapIndexes {
writable: vec![0],
readonly: vec![],
}],
..simple_message()
}
.sanitize()
.is_ok());
assert!(Message {
address_map_indexes: vec![AddressMapIndexes {
writable: vec![],
readonly: vec![0],
}],
..simple_message()
}
.sanitize()
.is_ok());
assert!(Message {
address_map_indexes: vec![AddressMapIndexes {
writable: vec![],
readonly: vec![],
}],
..simple_message()
}
.sanitize()
.is_err());
}
#[test]
fn test_serialize() {
let message = simple_message();
let versioned_msg = VersionedMessage::V0(message.clone());
assert_eq!(message.serialize(), versioned_msg.serialize());
}
}

40
sdk/program/src/message/versions.rs → sdk/program/src/message/versions/mod.rs
View File

@ -2,7 +2,7 @@ use {
crate::{
hash::Hash,
instruction::CompiledInstruction,
message::{v0, Message, MessageHeader},
message::{legacy::Message as LegacyMessage, MessageHeader},
pubkey::Pubkey,
sanitize::{Sanitize, SanitizeError},
short_vec,
@ -15,6 +15,8 @@ use {
std::fmt,
};
pub mod v0;
/// Bit mask that indicates whether a serialized message is versioned.
pub const MESSAGE_VERSION_PREFIX: u8 = 0x80;
@ -26,10 +28,10 @@ pub const MESSAGE_VERSION_PREFIX: u8 = 0x80;
/// which message version is serialized starting from version `0`. If the first
/// is bit is not set, all bytes are used to encode the legacy `Message`
/// format.
#[frozen_abi(digest = "x2F3RG2RhJQWN6L2N3jebvcAvNYFrhE3sKTPJ4sENvL")]
#[frozen_abi(digest = "G4EAiqmGgBprgf5ePYemLJcoFfx4R7rhC1Weo2FVJ7fn")]
#[derive(Debug, PartialEq, Eq, Clone, AbiEnumVisitor, AbiExample)]
pub enum VersionedMessage {
Legacy(Message),
Legacy(LegacyMessage),
V0(v0::Message),
}
@ -98,7 +100,7 @@ impl VersionedMessage {
impl Default for VersionedMessage {
fn default() -> Self {
Self::Legacy(Message::default())
Self::Legacy(LegacyMessage::default())
}
}
@ -206,7 +208,7 @@ impl<'de> Deserialize<'de> for VersionedMessage {
de::Error::invalid_length(1, &self)
})?;
Ok(VersionedMessage::Legacy(Message {
Ok(VersionedMessage::Legacy(LegacyMessage {
header: MessageHeader {
num_required_signatures,
num_readonly_signed_accounts: message.num_readonly_signed_accounts,
@ -247,7 +249,7 @@ mod tests {
super::*,
crate::{
instruction::{AccountMeta, Instruction},
message::v0::AddressMapIndexes,
message::v0::MessageAddressTableLookup,
},
};
@ -274,7 +276,7 @@ mod tests {
),
];
let mut message = Message::new(&instructions, Some(&id1));
let mut message = LegacyMessage::new(&instructions, Some(&id1));
message.recent_blockhash = Hash::new_unique();
let bytes1 = bincode::serialize(&message).unwrap();
@ -282,7 +284,7 @@ mod tests {
assert_eq!(bytes1, bytes2);
let message1: Message = bincode::deserialize(&bytes1).unwrap();
let message1: LegacyMessage = bincode::deserialize(&bytes1).unwrap();
let message2: VersionedMessage = bincode::deserialize(&bytes2).unwrap();
if let VersionedMessage::Legacy(message2) = message2 {
@ -299,27 +301,27 @@ mod tests {
header: MessageHeader {
num_required_signatures: 1,
num_readonly_signed_accounts: 0,
num_readonly_unsigned_accounts: 2,
num_readonly_unsigned_accounts: 0,
},
recent_blockhash: Hash::new_unique(),
account_keys: vec![
Pubkey::new_unique(),
Pubkey::new_unique(),
Pubkey::new_unique(),
],
address_map_indexes: vec![
AddressMapIndexes {
writable: vec![1],
readonly: vec![0],
address_table_lookups: vec![
MessageAddressTableLookup {
account_key: Pubkey::new_unique(),
writable_indexes: vec![1],
readonly_indexes: vec![0],
},
AddressMapIndexes {
writable: vec![0],
readonly: vec![1],
MessageAddressTableLookup {
account_key: Pubkey::new_unique(),
writable_indexes: vec![0],
readonly_indexes: vec![1],
},
],
instructions: vec![CompiledInstruction {
program_id_index: 1,
accounts: vec![0],
accounts: vec![0, 2, 3, 4],
data: vec![],
}],
};

77
sdk/program/src/message/mapped.rs → sdk/program/src/message/versions/v0/loaded.rs
View File

@ -5,37 +5,44 @@ use {
pubkey::Pubkey,
sysvar,
},
std::{collections::HashSet, convert::TryFrom},
std::{collections::HashSet, ops::Deref, convert::TryFrom},
};
/// Combination of a version #0 message and its mapped addresses
/// Combination of a version #0 message and its loaded addresses
#[derive(Debug, Clone)]
pub struct MappedMessage {
/// Message which loaded a collection of mapped addresses
pub struct LoadedMessage {
/// Message which loaded a collection of lookup table addresses
pub message: v0::Message,
/// Collection of mapped addresses loaded by this message
pub mapped_addresses: MappedAddresses,
/// Addresses loaded with on-chain address lookup tables
pub loaded_addresses: LoadedAddresses,
}
/// Collection of mapped addresses loaded succinctly by a transaction using
/// on-chain address map accounts.
impl Deref for LoadedMessage {
type Target = v0::Message;
fn deref(&self) -> &Self::Target {
&self.message
}
}
/// Collection of addresses loaded from on-chain lookup tables, split
/// by readonly and writable.
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct MappedAddresses {
pub struct LoadedAddresses {
/// List of addresses for writable loaded accounts
pub writable: Vec<Pubkey>,
/// List of addresses for read-only loaded accounts
pub readonly: Vec<Pubkey>,
}
impl MappedMessage {
impl LoadedMessage {
/// Returns an iterator of account key segments. The ordering of segments
/// affects how account indexes from compiled instructions are resolved and
/// so should not be changed.
fn account_keys_segment_iter(&self) -> impl Iterator<Item = &Vec<Pubkey>> {
vec![
&self.message.account_keys,
&self.mapped_addresses.writable,
&self.mapped_addresses.readonly,
&self.loaded_addresses.writable,
&self.loaded_addresses.readonly,
]
.into_iter()
}
@ -82,7 +89,7 @@ impl MappedMessage {
let num_signed_accounts = usize::from(header.num_required_signatures);
if key_index >= num_account_keys {
let mapped_addresses_index = key_index.saturating_sub(num_account_keys);
mapped_addresses_index < self.mapped_addresses.writable.len()
mapped_addresses_index < self.loaded_addresses.writable.len()
} else if key_index >= num_signed_accounts {
let num_unsigned_accounts = num_account_keys.saturating_sub(num_signed_accounts);
let num_writable_unsigned_accounts = num_unsigned_accounts
@ -138,7 +145,7 @@ mod tests {
itertools::Itertools,
};
fn create_test_mapped_message() -> (MappedMessage, [Pubkey; 6]) {
fn check_test_loaded_message() -> (LoadedMessage, [Pubkey; 6]) {
let key0 = Pubkey::new_unique();
let key1 = Pubkey::new_unique();
let key2 = Pubkey::new_unique();
@ -146,7 +153,7 @@ mod tests {
let key4 = Pubkey::new_unique();
let key5 = Pubkey::new_unique();
let message = MappedMessage {
let message = LoadedMessage {
message: v0::Message {
header: MessageHeader {
num_required_signatures: 2,
@ -156,7 +163,7 @@ mod tests {
account_keys: vec![key0, key1, key2, key3],
..v0::Message::default()
},
mapped_addresses: MappedAddresses {
loaded_addresses: LoadedAddresses {
writable: vec![key4],
readonly: vec![key5],
},
@ -167,7 +174,7 @@ mod tests {
#[test]
fn test_account_keys_segment_iter() {
let (message, keys) = create_test_mapped_message();
let (message, keys) = check_test_loaded_message();
let expected_segments = vec![
vec![keys[0], keys[1], keys[2], keys[3]],
@ -183,14 +190,14 @@ mod tests {
#[test]
fn test_account_keys_len() {
let (message, keys) = create_test_mapped_message();
let (message, keys) = check_test_loaded_message();
assert_eq!(message.account_keys_len(), keys.len());
}
#[test]
fn test_account_keys_iter() {
let (message, keys) = create_test_mapped_message();
let (message, keys) = check_test_loaded_message();
let mut iter = message.account_keys_iter();
for expected_key in keys {
@ -200,19 +207,19 @@ mod tests {
#[test]
fn test_has_duplicates() {
let message = create_test_mapped_message().0;
let message = check_test_loaded_message().0;
assert!(!message.has_duplicates());
}
#[test]
fn test_has_duplicates_with_dupe_keys() {
let create_message_with_dupe_keys = |mut keys: Vec<Pubkey>| MappedMessage {
let create_message_with_dupe_keys = |mut keys: Vec<Pubkey>| LoadedMessage {
message: v0::Message {
account_keys: keys.split_off(2),
..v0::Message::default()
},
mapped_addresses: MappedAddresses {
loaded_addresses: LoadedAddresses {
writable: keys.split_off(2),
readonly: keys,
},
@ -234,7 +241,7 @@ mod tests {
#[test]
fn test_get_account_key() {
let (message, keys) = create_test_mapped_message();
let (message, keys) = check_test_loaded_message();
assert_eq!(message.get_account_key(0), Some(&keys[0]));
assert_eq!(message.get_account_key(1), Some(&keys[1]));
@ -246,7 +253,7 @@ mod tests {
#[test]
fn test_is_writable_index() {
let message = create_test_mapped_message().0;
let message = check_test_loaded_message().0;
assert!(message.is_writable_index(0));
assert!(!message.is_writable_index(1));
@ -258,15 +265,15 @@ mod tests {
#[test]
fn test_is_writable() {
let mut mapped_msg = create_test_mapped_message().0;
let mut message = check_test_loaded_message().0;
mapped_msg.message.account_keys[0] = sysvar::clock::id();
assert!(mapped_msg.is_writable_index(0));
assert!(!mapped_msg.is_writable(0, /*demote_program_write_locks=*/ true));
message.message.account_keys[0] = sysvar::clock::id();
assert!(message.is_writable_index(0));
assert!(!message.is_writable(0, /*demote_program_write_locks=*/ true));
mapped_msg.message.account_keys[0] = system_program::id();
assert!(mapped_msg.is_writable_index(0));
assert!(!mapped_msg.is_writable(0, /*demote_program_write_locks=*/ true));
message.message.account_keys[0] = system_program::id();
assert!(message.is_writable_index(0));
assert!(!message.is_writable(0, /*demote_program_write_locks=*/ true));
}
#[test]
@ -274,7 +281,7 @@ mod tests {
let key0 = Pubkey::new_unique();
let key1 = Pubkey::new_unique();
let key2 = Pubkey::new_unique();
let mapped_msg = MappedMessage {
let message = LoadedMessage {
message: v0::Message {
header: MessageHeader {
num_required_signatures: 1,
@ -289,13 +296,13 @@ mod tests {
}],
..v0::Message::default()
},
mapped_addresses: MappedAddresses {
loaded_addresses: LoadedAddresses {
writable: vec![key1, key2],
readonly: vec![],
},
};
assert!(mapped_msg.is_writable_index(2));
assert!(!mapped_msg.is_writable(2, /*demote_program_write_locks=*/ true));
assert!(message.is_writable_index(2));
assert!(!message.is_writable(2, /*demote_program_write_locks=*/ true));
}
}

374
sdk/program/src/message/versions/v0/mod.rs Normal file
View File

@ -0,0 +1,374 @@
use crate::{
hash::Hash,
instruction::CompiledInstruction,
message::{MessageHeader, MESSAGE_VERSION_PREFIX},
pubkey::Pubkey,
sanitize::{Sanitize, SanitizeError},
short_vec,
};
mod loaded;
pub use loaded::*;
/// Address table lookups describe an on-chain address lookup table to use
/// for loading more readonly and writable accounts in a single tx.
#[derive(Serialize, Deserialize, Default, Debug, PartialEq, Eq, Clone, AbiExample)]
#[serde(rename_all = "camelCase")]
pub struct MessageAddressTableLookup {
/// Address lookup table account key
pub account_key: Pubkey,
/// List of indexes used to load writable account addresses
#[serde(with = "short_vec")]
pub writable_indexes: Vec<u8>,
/// List of indexes used to load readonly account addresses
#[serde(with = "short_vec")]
pub readonly_indexes: Vec<u8>,
}
/// Transaction message format which supports succinct account loading with
/// on-chain address lookup tables.
#[derive(Serialize, Deserialize, Default, Debug, PartialEq, Eq, Clone, AbiExample)]
#[serde(rename_all = "camelCase")]
pub struct Message {
/// The message header, identifying signed and read-only `account_keys`
pub header: MessageHeader,
/// List of accounts loaded by this transaction.
#[serde(with = "short_vec")]
pub account_keys: Vec<Pubkey>,
/// The blockhash of a recent block.
pub recent_blockhash: Hash,
/// Instructions that invoke a designated program, are executed in sequence,
/// and committed in one atomic transaction if all succeed.
///
/// # Notes
///
/// Account and program indexes will index into the list of addresses
/// constructed from the concatenation of three key lists:
/// 1) message `account_keys`
/// 2) ordered list of keys loaded from `writable` lookup table indexes
/// 3) ordered list of keys loaded from `readable` lookup table indexes
#[serde(with = "short_vec")]
pub instructions: Vec<CompiledInstruction>,
/// List of address table lookups used to load additional accounts
/// for this transaction.
#[serde(with = "short_vec")]
pub address_table_lookups: Vec<MessageAddressTableLookup>,
}
impl Sanitize for Message {
fn sanitize(&self) -> Result<(), SanitizeError> {
// signing area and read-only non-signing area should not
// overlap
if usize::from(self.header.num_required_signatures)
.saturating_add(usize::from(self.header.num_readonly_unsigned_accounts))
> self.account_keys.len()
{
return Err(SanitizeError::IndexOutOfBounds);
}
// there should be at least 1 RW fee-payer account.
if self.header.num_readonly_signed_accounts >= self.header.num_required_signatures {
return Err(SanitizeError::InvalidValue);
}
let mut num_loaded_accounts = self.account_keys.len();
for lookup in &self.address_table_lookups {
let num_table_loaded_accounts = lookup
.writable_indexes
.len()
.saturating_add(lookup.readonly_indexes.len());
// each lookup table must be used to load at least one account
if num_table_loaded_accounts == 0 {
return Err(SanitizeError::InvalidValue);
}
num_loaded_accounts = num_loaded_accounts.saturating_add(num_table_loaded_accounts);
}
// the number of loaded accounts must be <= 256 since account indices are
// encoded as `u8`
if num_loaded_accounts > 256 {
return Err(SanitizeError::IndexOutOfBounds);
}
for ci in &self.instructions {
if usize::from(ci.program_id_index) >= num_loaded_accounts {
return Err(SanitizeError::IndexOutOfBounds);
}
// A program cannot be a payer.
if ci.program_id_index == 0 {
return Err(SanitizeError::IndexOutOfBounds);
}
for ai in &ci.accounts {
if usize::from(*ai) >= num_loaded_accounts {
return Err(SanitizeError::IndexOutOfBounds);
}
}
}
Ok(())
}
}
impl Message {
/// Serialize this message with a version #0 prefix using bincode encoding.
pub fn serialize(&self) -> Vec<u8> {
bincode::serialize(&(MESSAGE_VERSION_PREFIX, self)).unwrap()
}
}
#[cfg(test)]
mod tests {
use {
super::*,
crate::message::VersionedMessage,
};
#[test]
fn test_sanitize() {
assert!(Message {
header: MessageHeader {
num_required_signatures: 1,
..MessageHeader::default()
},
account_keys: vec![Pubkey::new_unique()],
..Message::default()
}
.sanitize()
.is_ok());
}
#[test]
fn test_sanitize_with_instruction() {
assert!(Message {
header: MessageHeader {
num_required_signatures: 1,
..MessageHeader::default()
},
account_keys: vec![Pubkey::new_unique(), Pubkey::new_unique()],
instructions: vec![CompiledInstruction {
program_id_index: 1,
accounts: vec![0],
data: vec![]
}],
..Message::default()
}
.sanitize()
.is_ok());
}
#[test]
fn test_sanitize_with_table_lookup() {
assert!(Message {
header: MessageHeader {
num_required_signatures: 1,
..MessageHeader::default()
},
account_keys: vec![Pubkey::new_unique()],
address_table_lookups: vec![MessageAddressTableLookup {
account_key: Pubkey::new_unique(),
writable_indexes: vec![1, 2, 3],
readonly_indexes: vec![0],
}],
..Message::default()
}
.sanitize()
.is_ok());
}
#[test]
fn test_sanitize_with_table_lookup_and_ix() {
assert!(Message {
header: MessageHeader {
num_required_signatures: 1,
..MessageHeader::default()
},
account_keys: vec![Pubkey::new_unique()],
address_table_lookups: vec![MessageAddressTableLookup {
account_key: Pubkey::new_unique(),
writable_indexes: vec![1, 2, 3],
readonly_indexes: vec![0],
}],
instructions: vec![CompiledInstruction {
program_id_index: 4,
accounts: vec![0, 1, 2, 3],
data: vec![]
}],
..Message::default()
}
.sanitize()
.is_ok());
}
#[test]
fn test_sanitize_without_signer() {
assert!(Message {
header: MessageHeader::default(),
account_keys: vec![Pubkey::new_unique()],
..Message::default()
}
.sanitize()
.is_err());
}
#[test]
fn test_sanitize_without_writable_signer() {
assert!(Message {
header: MessageHeader {
num_required_signatures: 1,
num_readonly_signed_accounts: 1,
..MessageHeader::default()
},
account_keys: vec![Pubkey::new_unique()],
..Message::default()
}
.sanitize()
.is_err());
}
#[test]
fn test_sanitize_with_empty_table_lookup() {
assert!(Message {
header: MessageHeader {
num_required_signatures: 1,
..MessageHeader::default()
},
account_keys: vec![Pubkey::new_unique()],
address_table_lookups: vec![MessageAddressTableLookup {
account_key: Pubkey::new_unique(),
writable_indexes: vec![],
readonly_indexes: vec![],
}],
..Message::default()
}
.sanitize()
.is_err());
}
#[test]
fn test_sanitize_with_max_account_keys() {
assert!(Message {
header: MessageHeader {
num_required_signatures: 1,
..MessageHeader::default()
},
account_keys: (0..=u8::MAX).map(|_| Pubkey::new_unique()).collect(),
..Message::default()
}
.sanitize()
.is_ok());
}
#[test]
fn test_sanitize_with_too_many_account_keys() {
assert!(Message {
header: MessageHeader {
num_required_signatures: 1,
..MessageHeader::default()
},
account_keys: (0..=256).map(|_| Pubkey::new_unique()).collect(),
..Message::default()
}
.sanitize()
.is_err());
}
#[test]
fn test_sanitize_with_max_table_loaded_keys() {
assert!(Message {
header: MessageHeader {
num_required_signatures: 1,
..MessageHeader::default()
},
account_keys: vec![Pubkey::new_unique()],
address_table_lookups: vec![MessageAddressTableLookup {
account_key: Pubkey::new_unique(),
writable_indexes: (0..=254).step_by(2).collect(),
readonly_indexes: (1..=254).step_by(2).collect(),
}],
..Message::default()
}
.sanitize()
.is_ok());
}
#[test]
fn test_sanitize_with_too_many_table_loaded_keys() {
assert!(Message {
header: MessageHeader {
num_required_signatures: 1,
..MessageHeader::default()
},
account_keys: vec![Pubkey::new_unique()],
address_table_lookups: vec![MessageAddressTableLookup {
account_key: Pubkey::new_unique(),
writable_indexes: (0..=255).step_by(2).collect(),
readonly_indexes: (1..=255).step_by(2).collect(),
}],
..Message::default()
}
.sanitize()
.is_err());
}
#[test]
fn test_sanitize_with_invalid_ix_program_id() {
assert!(Message {
header: MessageHeader {
num_required_signatures: 1,
..MessageHeader::default()
},
account_keys: vec![Pubkey::new_unique()],
address_table_lookups: vec![MessageAddressTableLookup {
account_key: Pubkey::new_unique(),
writable_indexes: vec![0],
readonly_indexes: vec![],
}],
instructions: vec![CompiledInstruction {
program_id_index: 2,
accounts: vec![],
data: vec![]
}],
..Message::default()
}
.sanitize()
.is_err());
}
#[test]
fn test_sanitize_with_invalid_ix_account() {
assert!(Message {
header: MessageHeader {
num_required_signatures: 1,
..MessageHeader::default()
},
account_keys: vec![Pubkey::new_unique()],
address_table_lookups: vec![MessageAddressTableLookup {
account_key: Pubkey::new_unique(),
writable_indexes: vec![],
readonly_indexes: vec![0],
}],
instructions: vec![CompiledInstruction {
program_id_index: 1,
accounts: vec![2],
data: vec![]
}],
..Message::default()
}
.sanitize()
.is_err());
}
#[test]
fn test_serialize() {
let message = Message::default();
let versioned_msg = VersionedMessage::V0(message.clone());
assert_eq!(message.serialize(), versioned_msg.serialize());
}
}