1122 lines
46 KiB
Rust
1122 lines
46 KiB
Rust
// file: kb-lib/src/decoder/metadata/solana_program_metadata/account.rs
|
|
// version: 2
|
|
|
|
//! Bounded account decoding for the Solana Program Metadata program.
|
|
|
|
/// Error returned while decoding a Solana Program Metadata account.
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
pub enum DcMetadataSpmAccountDecodeError {
|
|
/// The account address is not a valid Solana public key.
|
|
InvalidAccountKey,
|
|
/// The account owner is not a valid Solana public key.
|
|
InvalidOwner,
|
|
/// The account is owned by another program.
|
|
ForeignOwner,
|
|
/// The account data is empty.
|
|
EmptyAccountData,
|
|
/// The account carries the published uninitialized discriminator.
|
|
UninitializedAccount,
|
|
/// The account exceeds the explicit Solana account-data bound.
|
|
AccountDataTooLarge {
|
|
/// Observed byte length.
|
|
actual_bytes: usize,
|
|
/// Maximum accepted byte length.
|
|
max_bytes: usize,
|
|
},
|
|
/// The account is shorter than the fixed header required by its discriminator.
|
|
TruncatedHeader {
|
|
/// Observed byte length.
|
|
actual_bytes: usize,
|
|
/// Minimum required byte length.
|
|
minimum_bytes: usize,
|
|
},
|
|
/// A type-specific decoder received another supported account discriminator.
|
|
UnexpectedAccountDiscriminator {
|
|
/// Discriminator required by the decoder.
|
|
expected: crate::DcMetadataSpmAccountDiscriminator,
|
|
/// Discriminator found on wire.
|
|
actual: crate::DcMetadataSpmAccountDiscriminator,
|
|
},
|
|
/// The metadata header declares more logical data than the allocated account can hold.
|
|
LogicalDataOutOfBounds {
|
|
/// Logical data length declared by the header.
|
|
declared_bytes: usize,
|
|
/// Bytes allocated after the fixed header.
|
|
available_bytes: usize,
|
|
},
|
|
/// The target architecture cannot represent the published `u32` logical length as `usize`.
|
|
LogicalDataLengthUnsupported {
|
|
/// Logical data length declared by the header.
|
|
declared_bytes: u32,
|
|
},
|
|
/// A non-canonical metadata account does not retain its required authority.
|
|
MissingNonCanonicalAuthority,
|
|
/// The account address does not match the canonical or non-canonical PDA declared by its header.
|
|
InvalidMetadataPda,
|
|
/// URL data is not valid UTF-8.
|
|
InvalidUrlUtf8,
|
|
/// A bounded public model conversion failed.
|
|
Model(crate::DcMetadataSpmModelError),
|
|
}
|
|
|
|
impl std::fmt::Display for DcMetadataSpmAccountDecodeError {
|
|
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
Self::InvalidAccountKey => {
|
|
return formatter.write_str("program metadata account key is invalid");
|
|
},
|
|
Self::InvalidOwner => {
|
|
return formatter.write_str("program metadata account owner is invalid");
|
|
},
|
|
Self::ForeignOwner => {
|
|
return formatter.write_str("program metadata account is owned by another program");
|
|
},
|
|
Self::EmptyAccountData => {
|
|
return formatter.write_str("program metadata account data is empty");
|
|
},
|
|
Self::UninitializedAccount => {
|
|
return formatter.write_str("program metadata account is uninitialized");
|
|
},
|
|
Self::AccountDataTooLarge { actual_bytes, max_bytes } => {
|
|
return write!(
|
|
formatter,
|
|
"program metadata account data length {actual_bytes} exceeds {max_bytes} bytes",
|
|
);
|
|
},
|
|
Self::TruncatedHeader { actual_bytes, minimum_bytes } => {
|
|
return write!(
|
|
formatter,
|
|
"program metadata account header length {actual_bytes} is below {minimum_bytes} bytes",
|
|
);
|
|
},
|
|
Self::UnexpectedAccountDiscriminator { expected, actual } => {
|
|
return write!(
|
|
formatter,
|
|
"program metadata account discriminator {actual:?} does not match {expected:?}",
|
|
);
|
|
},
|
|
Self::LogicalDataOutOfBounds { declared_bytes, available_bytes } => {
|
|
return write!(
|
|
formatter,
|
|
"program metadata logical data length {declared_bytes} exceeds {available_bytes} allocated bytes",
|
|
);
|
|
},
|
|
Self::LogicalDataLengthUnsupported { declared_bytes } => {
|
|
return write!(
|
|
formatter,
|
|
"program metadata logical data length {declared_bytes} cannot be represented on this architecture",
|
|
);
|
|
},
|
|
Self::MissingNonCanonicalAuthority => {
|
|
return formatter
|
|
.write_str("non-canonical program metadata account has no authority");
|
|
},
|
|
Self::InvalidMetadataPda => {
|
|
return formatter.write_str("program metadata account PDA is invalid");
|
|
},
|
|
Self::InvalidUrlUtf8 => {
|
|
return formatter.write_str("program metadata URL data is not valid UTF-8");
|
|
},
|
|
Self::Model(error) => {
|
|
return write!(formatter, "program metadata model conversion failed: {error}");
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
impl std::error::Error for DcMetadataSpmAccountDecodeError {}
|
|
|
|
/// Bounded projection of one Solana Program Metadata Buffer account.
|
|
#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
|
|
pub struct DcMetadataSpmBufferAccountSnapshot {
|
|
/// Account address supplied by the caller.
|
|
pub account: String,
|
|
/// Optional program retained by the zeroable Buffer header.
|
|
pub program: std::option::Option<String>,
|
|
/// Optional current Buffer authority.
|
|
pub authority: std::option::Option<String>,
|
|
/// Whether the Buffer was declared canonical.
|
|
pub canonical: bool,
|
|
/// Exact fixed-size derivation seed retained by the Buffer header.
|
|
pub seed: crate::DcMetadataSpmSeed,
|
|
/// Complete bytes allocated after the fixed Buffer header.
|
|
pub data: std::vec::Vec<u8>,
|
|
/// Number of bytes allocated after the fixed Buffer header.
|
|
pub allocated_data_bytes: usize,
|
|
}
|
|
|
|
/// Bounded projection of one initialized Solana Program Metadata account.
|
|
#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
|
|
pub struct DcMetadataSpmMetadataAccountSnapshot {
|
|
/// Validated metadata PDA address.
|
|
pub account: String,
|
|
/// PDA bump derived from the header contract.
|
|
pub bump: u8,
|
|
/// Program to which the metadata belongs.
|
|
pub program: String,
|
|
/// Optional current metadata authority.
|
|
pub authority: std::option::Option<String>,
|
|
/// Whether the metadata account accepts mutations.
|
|
pub mutable: bool,
|
|
/// Whether the metadata PDA is derived without a third-party authority seed.
|
|
pub canonical: bool,
|
|
/// Exact fixed-size metadata derivation seed.
|
|
pub seed: crate::DcMetadataSpmSeed,
|
|
/// Encoding declared for the logical metadata content.
|
|
pub encoding: crate::DcMetadataSpmEncoding,
|
|
/// Compression declared for the logical metadata content.
|
|
pub compression: crate::DcMetadataSpmCompression,
|
|
/// Format declared for the logical metadata content.
|
|
pub format: crate::DcMetadataSpmFormat,
|
|
/// Source declared for the logical metadata content.
|
|
pub data_source: crate::DcMetadataSpmDataSource,
|
|
/// Logical data byte length declared by the account header.
|
|
pub data_length: u32,
|
|
/// Complete typed on-chain metadata content without off-chain resolution.
|
|
pub data: crate::DcMetadataSpmData,
|
|
/// Number of bytes allocated after the fixed Metadata header.
|
|
pub allocated_data_bytes: usize,
|
|
/// Allocated capacity remaining after the declared logical content.
|
|
pub trailing_capacity_bytes: usize,
|
|
}
|
|
|
|
/// Supported bounded Solana Program Metadata account projection.
|
|
#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
|
|
#[serde(tag = "account_kind", content = "snapshot", rename_all = "snake_case")]
|
|
pub enum DcMetadataSpmAccountSnapshot {
|
|
/// Writable staging Buffer account.
|
|
Buffer(crate::DcMetadataSpmBufferAccountSnapshot),
|
|
/// Initialized Metadata account.
|
|
Metadata(crate::DcMetadataSpmMetadataAccountSnapshot),
|
|
}
|
|
|
|
/// Decodes one supported Solana Program Metadata account by its exact discriminator.
|
|
pub fn decoder_metadata_solana_program_metadata_decode_account(
|
|
account: &str,
|
|
owner: &str,
|
|
data: &[u8],
|
|
) -> std::result::Result<crate::DcMetadataSpmAccountSnapshot, crate::DcMetadataSpmAccountDecodeError>
|
|
{
|
|
match decoder_metadata_solana_program_metadata_validate_account_context(account, owner, data) {
|
|
std::result::Result::Ok(_) => {},
|
|
std::result::Result::Err(error) => return std::result::Result::Err(error),
|
|
}
|
|
let discriminator = match crate::DcMetadataSpmAccountDiscriminator::from_wire_value(data[0]) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::Model(error));
|
|
},
|
|
};
|
|
match discriminator {
|
|
crate::DcMetadataSpmAccountDiscriminator::Buffer => {
|
|
let snapshot =
|
|
match crate::decoder_metadata_solana_program_metadata_decode_buffer_account(
|
|
account, owner, data,
|
|
) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => return std::result::Result::Err(error),
|
|
};
|
|
return std::result::Result::Ok(crate::DcMetadataSpmAccountSnapshot::Buffer(snapshot));
|
|
},
|
|
crate::DcMetadataSpmAccountDiscriminator::Metadata => {
|
|
let snapshot =
|
|
match crate::decoder_metadata_solana_program_metadata_decode_metadata_account(
|
|
account, owner, data,
|
|
) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => return std::result::Result::Err(error),
|
|
};
|
|
return std::result::Result::Ok(crate::DcMetadataSpmAccountSnapshot::Metadata(
|
|
snapshot,
|
|
));
|
|
},
|
|
crate::DcMetadataSpmAccountDiscriminator::Empty => {
|
|
return std::result::Result::Err(
|
|
crate::DcMetadataSpmAccountDecodeError::UninitializedAccount,
|
|
);
|
|
},
|
|
}
|
|
}
|
|
|
|
/// Decodes one Solana Program Metadata Buffer account without claiming a stable PDA after authority changes.
|
|
pub fn decoder_metadata_solana_program_metadata_decode_buffer_account(
|
|
account: &str,
|
|
owner: &str,
|
|
data: &[u8],
|
|
) -> std::result::Result<
|
|
crate::DcMetadataSpmBufferAccountSnapshot,
|
|
crate::DcMetadataSpmAccountDecodeError,
|
|
> {
|
|
let (account_key, _) = match decoder_metadata_solana_program_metadata_validate_account_context(
|
|
account, owner, data,
|
|
) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => return std::result::Result::Err(error),
|
|
};
|
|
if data.len() < crate::DC_METADATA_SPM_BUFFER_HEADER_BYTES {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::TruncatedHeader {
|
|
actual_bytes: data.len(),
|
|
minimum_bytes: crate::DC_METADATA_SPM_BUFFER_HEADER_BYTES,
|
|
});
|
|
}
|
|
let discriminator = match crate::DcMetadataSpmAccountDiscriminator::from_wire_value(data[0]) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::Model(error));
|
|
},
|
|
};
|
|
if discriminator != crate::DcMetadataSpmAccountDiscriminator::Buffer {
|
|
return std::result::Result::Err(
|
|
crate::DcMetadataSpmAccountDecodeError::UnexpectedAccountDiscriminator {
|
|
expected: crate::DcMetadataSpmAccountDiscriminator::Buffer,
|
|
actual: discriminator,
|
|
},
|
|
);
|
|
}
|
|
let program = decoder_metadata_solana_program_metadata_parse_zeroable_pubkey(&data[1..33]);
|
|
let authority = decoder_metadata_solana_program_metadata_parse_zeroable_pubkey(&data[33..65]);
|
|
let seed = match crate::DcMetadataSpmSeed::from_wire_bytes(&data[66..82]) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::Model(error));
|
|
},
|
|
};
|
|
let program_string = match program {
|
|
std::option::Option::Some(value) => std::option::Option::Some(value.to_string()),
|
|
std::option::Option::None => std::option::Option::None,
|
|
};
|
|
let authority_string = match authority {
|
|
std::option::Option::Some(value) => std::option::Option::Some(value.to_string()),
|
|
std::option::Option::None => std::option::Option::None,
|
|
};
|
|
let buffer_data = data[crate::DC_METADATA_SPM_BUFFER_HEADER_BYTES..].to_vec();
|
|
return std::result::Result::Ok(crate::DcMetadataSpmBufferAccountSnapshot {
|
|
account: account_key.to_string(),
|
|
program: program_string,
|
|
authority: authority_string,
|
|
canonical: data[65] != 0,
|
|
seed,
|
|
allocated_data_bytes: buffer_data.len(),
|
|
data: buffer_data,
|
|
});
|
|
}
|
|
|
|
/// Decodes one Solana Program Metadata account with exact owner, PDA and logical-data validation.
|
|
pub fn decoder_metadata_solana_program_metadata_decode_metadata_account(
|
|
account: &str,
|
|
owner: &str,
|
|
data: &[u8],
|
|
) -> std::result::Result<
|
|
crate::DcMetadataSpmMetadataAccountSnapshot,
|
|
crate::DcMetadataSpmAccountDecodeError,
|
|
> {
|
|
let (account_key, metadata_program) =
|
|
match decoder_metadata_solana_program_metadata_validate_account_context(
|
|
account, owner, data,
|
|
) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => return std::result::Result::Err(error),
|
|
};
|
|
if data.len() < crate::DC_METADATA_SPM_METADATA_HEADER_BYTES {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::TruncatedHeader {
|
|
actual_bytes: data.len(),
|
|
minimum_bytes: crate::DC_METADATA_SPM_METADATA_HEADER_BYTES,
|
|
});
|
|
}
|
|
let discriminator = match crate::DcMetadataSpmAccountDiscriminator::from_wire_value(data[0]) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::Model(error));
|
|
},
|
|
};
|
|
if discriminator != crate::DcMetadataSpmAccountDiscriminator::Metadata {
|
|
return std::result::Result::Err(
|
|
crate::DcMetadataSpmAccountDecodeError::UnexpectedAccountDiscriminator {
|
|
expected: crate::DcMetadataSpmAccountDiscriminator::Metadata,
|
|
actual: discriminator,
|
|
},
|
|
);
|
|
}
|
|
let program = decoder_metadata_solana_program_metadata_parse_required_pubkey(&data[1..33]);
|
|
let authority = decoder_metadata_solana_program_metadata_parse_zeroable_pubkey(&data[33..65]);
|
|
let mutable = data[65] != 0;
|
|
let canonical = data[66] != 0;
|
|
let seed = match crate::DcMetadataSpmSeed::from_wire_bytes(&data[67..83]) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::Model(error));
|
|
},
|
|
};
|
|
let encoding = match crate::DcMetadataSpmEncoding::from_wire_value(data[83]) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::Model(error));
|
|
},
|
|
};
|
|
let compression = match crate::DcMetadataSpmCompression::from_wire_value(data[84]) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::Model(error));
|
|
},
|
|
};
|
|
let format = match crate::DcMetadataSpmFormat::from_wire_value(data[85]) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::Model(error));
|
|
},
|
|
};
|
|
let data_source = match crate::DcMetadataSpmDataSource::from_wire_value(data[86]) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::Model(error));
|
|
},
|
|
};
|
|
let mut data_length_wire = [0_u8; 4];
|
|
data_length_wire.copy_from_slice(&data[87..91]);
|
|
let data_length = u32::from_le_bytes(data_length_wire);
|
|
let declared_bytes = match usize::try_from(data_length) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => {
|
|
return std::result::Result::Err(
|
|
crate::DcMetadataSpmAccountDecodeError::LogicalDataLengthUnsupported {
|
|
declared_bytes: data_length,
|
|
},
|
|
);
|
|
},
|
|
};
|
|
let allocated_data_bytes = data.len() - crate::DC_METADATA_SPM_METADATA_HEADER_BYTES;
|
|
if declared_bytes > allocated_data_bytes {
|
|
return std::result::Result::Err(
|
|
crate::DcMetadataSpmAccountDecodeError::LogicalDataOutOfBounds {
|
|
declared_bytes,
|
|
available_bytes: allocated_data_bytes,
|
|
},
|
|
);
|
|
}
|
|
let logical_data = &data[crate::DC_METADATA_SPM_METADATA_HEADER_BYTES
|
|
..crate::DC_METADATA_SPM_METADATA_HEADER_BYTES + declared_bytes];
|
|
let typed_data =
|
|
match decoder_metadata_solana_program_metadata_decode_typed_data(data_source, logical_data)
|
|
{
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => return std::result::Result::Err(error),
|
|
};
|
|
let bump = match decoder_metadata_solana_program_metadata_validate_metadata_pda(
|
|
&account_key,
|
|
&metadata_program,
|
|
&program,
|
|
authority.as_ref(),
|
|
canonical,
|
|
&seed,
|
|
) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => return std::result::Result::Err(error),
|
|
};
|
|
let authority_string = match authority {
|
|
std::option::Option::Some(value) => std::option::Option::Some(value.to_string()),
|
|
std::option::Option::None => std::option::Option::None,
|
|
};
|
|
return std::result::Result::Ok(crate::DcMetadataSpmMetadataAccountSnapshot {
|
|
account: account_key.to_string(),
|
|
bump,
|
|
program: program.to_string(),
|
|
authority: authority_string,
|
|
mutable,
|
|
canonical,
|
|
seed,
|
|
encoding,
|
|
compression,
|
|
format,
|
|
data_source,
|
|
data_length,
|
|
data: typed_data,
|
|
allocated_data_bytes,
|
|
trailing_capacity_bytes: allocated_data_bytes - declared_bytes,
|
|
});
|
|
}
|
|
|
|
fn decoder_metadata_solana_program_metadata_validate_account_context(
|
|
account: &str,
|
|
owner: &str,
|
|
data: &[u8],
|
|
) -> std::result::Result<
|
|
(solana_pubkey::Pubkey, solana_pubkey::Pubkey),
|
|
crate::DcMetadataSpmAccountDecodeError,
|
|
> {
|
|
let account_key = match <solana_pubkey::Pubkey as std::str::FromStr>::from_str(account) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => {
|
|
return std::result::Result::Err(
|
|
crate::DcMetadataSpmAccountDecodeError::InvalidAccountKey,
|
|
);
|
|
},
|
|
};
|
|
let owner_key = match <solana_pubkey::Pubkey as std::str::FromStr>::from_str(owner) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::InvalidOwner);
|
|
},
|
|
};
|
|
let expected_owner = match <solana_pubkey::Pubkey as std::str::FromStr>::from_str(
|
|
kb_program_ids::METADATA_SOLANA_PROGRAM_METADATA_PROGRAM_ID,
|
|
) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::InvalidOwner);
|
|
},
|
|
};
|
|
if owner_key != expected_owner {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::ForeignOwner);
|
|
}
|
|
if data.is_empty() {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::EmptyAccountData);
|
|
}
|
|
if data.len() > crate::DC_METADATA_SPM_MAX_ACCOUNT_BYTES {
|
|
return std::result::Result::Err(
|
|
crate::DcMetadataSpmAccountDecodeError::AccountDataTooLarge {
|
|
actual_bytes: data.len(),
|
|
max_bytes: crate::DC_METADATA_SPM_MAX_ACCOUNT_BYTES,
|
|
},
|
|
);
|
|
}
|
|
return std::result::Result::Ok((account_key, expected_owner));
|
|
}
|
|
|
|
fn decoder_metadata_solana_program_metadata_parse_zeroable_pubkey(
|
|
data: &[u8],
|
|
) -> std::option::Option<solana_pubkey::Pubkey> {
|
|
let mut bytes = [0_u8; 32];
|
|
bytes.copy_from_slice(data);
|
|
if bytes == [0_u8; 32] {
|
|
return std::option::Option::None;
|
|
}
|
|
return std::option::Option::Some(solana_pubkey::Pubkey::new_from_array(bytes));
|
|
}
|
|
|
|
fn decoder_metadata_solana_program_metadata_parse_required_pubkey(
|
|
data: &[u8],
|
|
) -> solana_pubkey::Pubkey {
|
|
let mut bytes = [0_u8; 32];
|
|
bytes.copy_from_slice(data);
|
|
return solana_pubkey::Pubkey::new_from_array(bytes);
|
|
}
|
|
|
|
fn decoder_metadata_solana_program_metadata_decode_typed_data(
|
|
source: crate::DcMetadataSpmDataSource,
|
|
data: &[u8],
|
|
) -> std::result::Result<crate::DcMetadataSpmData, crate::DcMetadataSpmAccountDecodeError> {
|
|
let model = match source {
|
|
crate::DcMetadataSpmDataSource::Direct => crate::DcMetadataSpmData::Direct(data.to_vec()),
|
|
crate::DcMetadataSpmDataSource::Url => {
|
|
let url = match std::str::from_utf8(data) {
|
|
std::result::Result::Ok(value) => value.to_string(),
|
|
std::result::Result::Err(_) => {
|
|
return std::result::Result::Err(
|
|
crate::DcMetadataSpmAccountDecodeError::InvalidUrlUtf8,
|
|
);
|
|
},
|
|
};
|
|
crate::DcMetadataSpmData::Url(url)
|
|
},
|
|
crate::DcMetadataSpmDataSource::External => {
|
|
let external = match crate::DcMetadataSpmExternalData::from_wire_bytes(data) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(error) => {
|
|
return std::result::Result::Err(
|
|
crate::DcMetadataSpmAccountDecodeError::Model(error),
|
|
);
|
|
},
|
|
};
|
|
crate::DcMetadataSpmData::External(external)
|
|
},
|
|
};
|
|
match model.validate() {
|
|
std::result::Result::Ok(()) => return std::result::Result::Ok(model),
|
|
std::result::Result::Err(error) => {
|
|
return std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::Model(error));
|
|
},
|
|
}
|
|
}
|
|
|
|
fn decoder_metadata_solana_program_metadata_validate_metadata_pda(
|
|
account: &solana_pubkey::Pubkey,
|
|
metadata_program: &solana_pubkey::Pubkey,
|
|
program: &solana_pubkey::Pubkey,
|
|
authority: std::option::Option<&solana_pubkey::Pubkey>,
|
|
canonical: bool,
|
|
seed: &crate::DcMetadataSpmSeed,
|
|
) -> std::result::Result<u8, crate::DcMetadataSpmAccountDecodeError> {
|
|
let (expected, bump) = if canonical {
|
|
solana_pubkey::Pubkey::find_program_address(
|
|
&[program.as_ref(), seed.as_bytes()],
|
|
metadata_program,
|
|
)
|
|
} else {
|
|
let authority_key = match authority {
|
|
std::option::Option::Some(value) => value,
|
|
std::option::Option::None => {
|
|
return std::result::Result::Err(
|
|
crate::DcMetadataSpmAccountDecodeError::MissingNonCanonicalAuthority,
|
|
);
|
|
},
|
|
};
|
|
solana_pubkey::Pubkey::find_program_address(
|
|
&[program.as_ref(), authority_key.as_ref(), seed.as_bytes()],
|
|
metadata_program,
|
|
)
|
|
};
|
|
if account != &expected {
|
|
return std::result::Result::Err(
|
|
crate::DcMetadataSpmAccountDecodeError::InvalidMetadataPda,
|
|
);
|
|
}
|
|
return std::result::Result::Ok(bump);
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
fn metadata_program_id() -> std::option::Option<solana_pubkey::Pubkey> {
|
|
match <solana_pubkey::Pubkey as std::str::FromStr>::from_str(
|
|
kb_program_ids::METADATA_SOLANA_PROGRAM_METADATA_PROGRAM_ID,
|
|
) {
|
|
std::result::Result::Ok(value) => return std::option::Option::Some(value),
|
|
std::result::Result::Err(_) => return std::option::Option::None,
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy)]
|
|
struct MetadataWireSettings {
|
|
mutable: u8,
|
|
canonical: u8,
|
|
encoding: crate::DcMetadataSpmEncoding,
|
|
compression: crate::DcMetadataSpmCompression,
|
|
format: crate::DcMetadataSpmFormat,
|
|
source: crate::DcMetadataSpmDataSource,
|
|
}
|
|
|
|
fn metadata_wire(
|
|
program: solana_pubkey::Pubkey,
|
|
authority: std::option::Option<solana_pubkey::Pubkey>,
|
|
seed: crate::DcMetadataSpmSeed,
|
|
settings: MetadataWireSettings,
|
|
logical_data: &[u8],
|
|
trailing_capacity: usize,
|
|
) -> std::vec::Vec<u8> {
|
|
let mut data = vec![0_u8; crate::DC_METADATA_SPM_METADATA_HEADER_BYTES];
|
|
data[0] = crate::DcMetadataSpmAccountDiscriminator::Metadata.wire_value();
|
|
data[1..33].copy_from_slice(&program.to_bytes());
|
|
if let std::option::Option::Some(value) = authority {
|
|
data[33..65].copy_from_slice(&value.to_bytes());
|
|
}
|
|
data[65] = settings.mutable;
|
|
data[66] = settings.canonical;
|
|
data[67..83].copy_from_slice(seed.as_bytes());
|
|
data[83] = settings.encoding.wire_value();
|
|
data[84] = settings.compression.wire_value();
|
|
data[85] = settings.format.wire_value();
|
|
data[86] = settings.source.wire_value();
|
|
let logical_length = match u32::try_from(logical_data.len()) {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return data,
|
|
};
|
|
data[87..91].copy_from_slice(&logical_length.to_le_bytes());
|
|
data[91..96].fill(0xf3);
|
|
data.extend_from_slice(logical_data);
|
|
data.resize(data.len() + trailing_capacity, 0xa5);
|
|
return data;
|
|
}
|
|
|
|
fn metadata_pda(
|
|
program: &solana_pubkey::Pubkey,
|
|
authority: std::option::Option<&solana_pubkey::Pubkey>,
|
|
canonical: bool,
|
|
seed: &crate::DcMetadataSpmSeed,
|
|
metadata_program: &solana_pubkey::Pubkey,
|
|
) -> (solana_pubkey::Pubkey, u8) {
|
|
if canonical {
|
|
return solana_pubkey::Pubkey::find_program_address(
|
|
&[program.as_ref(), seed.as_bytes()],
|
|
metadata_program,
|
|
);
|
|
}
|
|
if let std::option::Option::Some(value) = authority {
|
|
return solana_pubkey::Pubkey::find_program_address(
|
|
&[program.as_ref(), value.as_ref(), seed.as_bytes()],
|
|
metadata_program,
|
|
);
|
|
}
|
|
return solana_pubkey::Pubkey::find_program_address(
|
|
&[program.as_ref(), seed.as_bytes()],
|
|
metadata_program,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn account_matrix_is_machine_readable_and_matches_compiled_bounds() {
|
|
let source = include_str!(
|
|
"../../../../../test-fixtures/contract-matrices/SOLANA_PROGRAM_METADATA_ACCOUNT_MATRIX.json"
|
|
);
|
|
let matrix_result = serde_json::from_str::<serde_json::Value>(source);
|
|
assert!(matrix_result.is_ok());
|
|
if let std::result::Result::Ok(matrix) = matrix_result {
|
|
assert_eq!(
|
|
matrix["program_id"],
|
|
serde_json::Value::String(
|
|
kb_program_ids::METADATA_SOLANA_PROGRAM_METADATA_PROGRAM_ID.to_string(),
|
|
),
|
|
);
|
|
assert_eq!(
|
|
matrix["official_contract"]["account_data_max_bytes"],
|
|
serde_json::Value::from(crate::DC_METADATA_SPM_MAX_ACCOUNT_BYTES),
|
|
);
|
|
assert_eq!(
|
|
matrix["accounts"][1]["header_bytes"],
|
|
serde_json::Value::from(crate::DC_METADATA_SPM_BUFFER_HEADER_BYTES),
|
|
);
|
|
assert_eq!(
|
|
matrix["accounts"][2]["header_bytes"],
|
|
serde_json::Value::from(crate::DC_METADATA_SPM_METADATA_HEADER_BYTES),
|
|
);
|
|
assert_eq!(
|
|
matrix["data_sources"][2]["length"],
|
|
serde_json::Value::String("exactly_40_bytes".to_string()),
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn buffer_decodes_zeroable_fields_nonzero_bool_and_all_allocated_bytes() {
|
|
let account = solana_pubkey::Pubkey::new_from_array([3_u8; 32]);
|
|
let program = solana_pubkey::Pubkey::new_from_array([4_u8; 32]);
|
|
let authority = solana_pubkey::Pubkey::new_from_array([5_u8; 32]);
|
|
let seed = crate::DcMetadataSpmSeed::from_bytes([6_u8; 16]);
|
|
let mut data = vec![0_u8; crate::DC_METADATA_SPM_BUFFER_HEADER_BYTES];
|
|
data[0] = crate::DcMetadataSpmAccountDiscriminator::Buffer.wire_value();
|
|
data[1..33].copy_from_slice(&program.to_bytes());
|
|
data[33..65].copy_from_slice(&authority.to_bytes());
|
|
data[65] = 7;
|
|
data[66..82].copy_from_slice(seed.as_bytes());
|
|
data[82..96].fill(0xff);
|
|
data.extend_from_slice(&[8_u8, 9_u8]);
|
|
let result = crate::decoder_metadata_solana_program_metadata_decode_buffer_account(
|
|
account.to_string().as_str(),
|
|
kb_program_ids::METADATA_SOLANA_PROGRAM_METADATA_PROGRAM_ID,
|
|
&data,
|
|
);
|
|
assert!(result.is_ok());
|
|
if let std::result::Result::Ok(snapshot) = result {
|
|
assert_eq!(snapshot.account, account.to_string());
|
|
assert_eq!(snapshot.program, std::option::Option::Some(program.to_string()));
|
|
assert_eq!(snapshot.authority, std::option::Option::Some(authority.to_string()));
|
|
assert!(snapshot.canonical);
|
|
assert_eq!(snapshot.seed, seed);
|
|
assert_eq!(snapshot.data, vec![8_u8, 9_u8]);
|
|
assert_eq!(snapshot.allocated_data_bytes, 2);
|
|
}
|
|
let mut zeroable = data;
|
|
zeroable[1..65].fill(0);
|
|
let zeroable_result = crate::decoder_metadata_solana_program_metadata_decode_buffer_account(
|
|
account.to_string().as_str(),
|
|
kb_program_ids::METADATA_SOLANA_PROGRAM_METADATA_PROGRAM_ID,
|
|
&zeroable,
|
|
);
|
|
assert!(zeroable_result.is_ok());
|
|
if let std::result::Result::Ok(snapshot) = zeroable_result {
|
|
assert_eq!(snapshot.program, std::option::Option::None);
|
|
assert_eq!(snapshot.authority, std::option::Option::None);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn canonical_direct_metadata_validates_pda_and_preserves_trailing_capacity() {
|
|
let metadata_program_option: std::option::Option<solana_pubkey::Pubkey> =
|
|
metadata_program_id();
|
|
assert!(metadata_program_option.is_some());
|
|
let metadata_program: solana_pubkey::Pubkey;
|
|
if let std::option::Option::Some(value) = metadata_program_option {
|
|
metadata_program = value;
|
|
} else {
|
|
return;
|
|
}
|
|
let program = solana_pubkey::Pubkey::new_from_array([11_u8; 32]);
|
|
let authority = solana_pubkey::Pubkey::new_from_array([12_u8; 32]);
|
|
let seed = crate::DcMetadataSpmSeed::from_bytes([13_u8; 16]);
|
|
let (account, expected_bump) = metadata_pda(
|
|
&program,
|
|
std::option::Option::Some(&authority),
|
|
true,
|
|
&seed,
|
|
&metadata_program,
|
|
);
|
|
let data = metadata_wire(
|
|
program,
|
|
std::option::Option::Some(authority),
|
|
seed,
|
|
MetadataWireSettings {
|
|
mutable: 9,
|
|
canonical: 4,
|
|
encoding: crate::DcMetadataSpmEncoding::Utf8,
|
|
compression: crate::DcMetadataSpmCompression::Gzip,
|
|
format: crate::DcMetadataSpmFormat::Json,
|
|
source: crate::DcMetadataSpmDataSource::Direct,
|
|
},
|
|
b"{}",
|
|
7,
|
|
);
|
|
let result = crate::decoder_metadata_solana_program_metadata_decode_metadata_account(
|
|
account.to_string().as_str(),
|
|
metadata_program.to_string().as_str(),
|
|
&data,
|
|
);
|
|
assert!(result.is_ok());
|
|
if let std::result::Result::Ok(snapshot) = result {
|
|
assert_eq!(snapshot.bump, expected_bump);
|
|
assert_eq!(snapshot.program, program.to_string());
|
|
assert_eq!(snapshot.authority, std::option::Option::Some(authority.to_string()));
|
|
assert!(snapshot.mutable);
|
|
assert!(snapshot.canonical);
|
|
assert_eq!(snapshot.data_length, 2);
|
|
assert_eq!(snapshot.data, crate::DcMetadataSpmData::Direct(b"{}".to_vec()));
|
|
assert_eq!(snapshot.allocated_data_bytes, 9);
|
|
assert_eq!(snapshot.trailing_capacity_bytes, 7);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn noncanonical_url_and_external_metadata_decode_exact_sources() {
|
|
let metadata_program_option: std::option::Option<solana_pubkey::Pubkey> =
|
|
metadata_program_id();
|
|
assert!(metadata_program_option.is_some());
|
|
let metadata_program: solana_pubkey::Pubkey;
|
|
if let std::option::Option::Some(value) = metadata_program_option {
|
|
metadata_program = value;
|
|
} else {
|
|
return;
|
|
}
|
|
let program = solana_pubkey::Pubkey::new_from_array([21_u8; 32]);
|
|
let authority = solana_pubkey::Pubkey::new_from_array([22_u8; 32]);
|
|
let seed = crate::DcMetadataSpmSeed::from_bytes([23_u8; 16]);
|
|
let (url_account, _) = metadata_pda(
|
|
&program,
|
|
std::option::Option::Some(&authority),
|
|
false,
|
|
&seed,
|
|
&metadata_program,
|
|
);
|
|
let url_data = metadata_wire(
|
|
program,
|
|
std::option::Option::Some(authority),
|
|
seed,
|
|
MetadataWireSettings {
|
|
mutable: 1,
|
|
canonical: 0,
|
|
encoding: crate::DcMetadataSpmEncoding::Utf8,
|
|
compression: crate::DcMetadataSpmCompression::None,
|
|
format: crate::DcMetadataSpmFormat::Json,
|
|
source: crate::DcMetadataSpmDataSource::Url,
|
|
},
|
|
b"https://example.invalid/idl.json",
|
|
0,
|
|
);
|
|
let url_result = crate::decoder_metadata_solana_program_metadata_decode_account(
|
|
url_account.to_string().as_str(),
|
|
metadata_program.to_string().as_str(),
|
|
&url_data,
|
|
);
|
|
assert!(url_result.is_ok());
|
|
if let std::result::Result::Ok(crate::DcMetadataSpmAccountSnapshot::Metadata(snapshot)) =
|
|
url_result
|
|
{
|
|
assert_eq!(
|
|
snapshot.data,
|
|
crate::DcMetadataSpmData::Url("https://example.invalid/idl.json".to_string()),
|
|
);
|
|
assert!(!snapshot.canonical);
|
|
} else {
|
|
return;
|
|
}
|
|
let external = crate::DcMetadataSpmExternalData::from_zeroable_length(
|
|
solana_pubkey::Pubkey::new_from_array([24_u8; 32]),
|
|
128,
|
|
4096,
|
|
);
|
|
let external_wire = external.to_wire_bytes();
|
|
let external_data = metadata_wire(
|
|
program,
|
|
std::option::Option::Some(authority),
|
|
seed,
|
|
MetadataWireSettings {
|
|
mutable: 1,
|
|
canonical: 0,
|
|
encoding: crate::DcMetadataSpmEncoding::None,
|
|
compression: crate::DcMetadataSpmCompression::None,
|
|
format: crate::DcMetadataSpmFormat::None,
|
|
source: crate::DcMetadataSpmDataSource::External,
|
|
},
|
|
&external_wire,
|
|
3,
|
|
);
|
|
let external_result =
|
|
crate::decoder_metadata_solana_program_metadata_decode_metadata_account(
|
|
url_account.to_string().as_str(),
|
|
metadata_program.to_string().as_str(),
|
|
&external_data,
|
|
);
|
|
assert!(external_result.is_ok());
|
|
if let std::result::Result::Ok(snapshot) = external_result {
|
|
assert_eq!(snapshot.data, crate::DcMetadataSpmData::External(external));
|
|
assert_eq!(snapshot.trailing_capacity_bytes, 3);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn malformed_owner_discriminator_headers_and_logical_lengths_fail_closed() {
|
|
let account = solana_pubkey::Pubkey::new_from_array([31_u8; 32]);
|
|
assert_eq!(
|
|
crate::decoder_metadata_solana_program_metadata_decode_account(
|
|
account.to_string().as_str(),
|
|
kb_program_ids::METADATA_SOLANA_PROGRAM_METADATA_PROGRAM_ID,
|
|
&[],
|
|
),
|
|
std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::EmptyAccountData),
|
|
);
|
|
let oversized = vec![1_u8; crate::DC_METADATA_SPM_MAX_ACCOUNT_BYTES + 1];
|
|
assert_eq!(
|
|
crate::decoder_metadata_solana_program_metadata_decode_account(
|
|
account.to_string().as_str(),
|
|
kb_program_ids::METADATA_SOLANA_PROGRAM_METADATA_PROGRAM_ID,
|
|
&oversized,
|
|
),
|
|
std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::AccountDataTooLarge {
|
|
actual_bytes: crate::DC_METADATA_SPM_MAX_ACCOUNT_BYTES + 1,
|
|
max_bytes: crate::DC_METADATA_SPM_MAX_ACCOUNT_BYTES,
|
|
}),
|
|
);
|
|
assert_eq!(
|
|
crate::decoder_metadata_solana_program_metadata_decode_account(
|
|
"invalid",
|
|
kb_program_ids::METADATA_SOLANA_PROGRAM_METADATA_PROGRAM_ID,
|
|
&[1_u8],
|
|
),
|
|
std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::InvalidAccountKey),
|
|
);
|
|
assert_eq!(
|
|
crate::decoder_metadata_solana_program_metadata_decode_account(
|
|
account.to_string().as_str(),
|
|
solana_pubkey::Pubkey::new_from_array([32_u8; 32]).to_string().as_str(),
|
|
&[1_u8],
|
|
),
|
|
std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::ForeignOwner),
|
|
);
|
|
assert_eq!(
|
|
crate::decoder_metadata_solana_program_metadata_decode_account(
|
|
account.to_string().as_str(),
|
|
kb_program_ids::METADATA_SOLANA_PROGRAM_METADATA_PROGRAM_ID,
|
|
&[0_u8],
|
|
),
|
|
std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::UninitializedAccount),
|
|
);
|
|
assert_eq!(
|
|
crate::decoder_metadata_solana_program_metadata_decode_account(
|
|
account.to_string().as_str(),
|
|
kb_program_ids::METADATA_SOLANA_PROGRAM_METADATA_PROGRAM_ID,
|
|
&[9_u8],
|
|
),
|
|
std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::Model(
|
|
crate::DcMetadataSpmModelError::UnknownAccountDiscriminator { value: 9 },
|
|
)),
|
|
);
|
|
assert_eq!(
|
|
crate::decoder_metadata_solana_program_metadata_decode_buffer_account(
|
|
account.to_string().as_str(),
|
|
kb_program_ids::METADATA_SOLANA_PROGRAM_METADATA_PROGRAM_ID,
|
|
&[1_u8],
|
|
),
|
|
std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::TruncatedHeader {
|
|
actual_bytes: 1,
|
|
minimum_bytes: crate::DC_METADATA_SPM_BUFFER_HEADER_BYTES,
|
|
}),
|
|
);
|
|
let mut metadata = vec![0_u8; crate::DC_METADATA_SPM_METADATA_HEADER_BYTES];
|
|
metadata[0] = crate::DcMetadataSpmAccountDiscriminator::Metadata.wire_value();
|
|
metadata[86] = crate::DcMetadataSpmDataSource::Direct.wire_value();
|
|
metadata[87..91].copy_from_slice(&4_u32.to_le_bytes());
|
|
assert_eq!(
|
|
crate::decoder_metadata_solana_program_metadata_decode_metadata_account(
|
|
account.to_string().as_str(),
|
|
kb_program_ids::METADATA_SOLANA_PROGRAM_METADATA_PROGRAM_ID,
|
|
&metadata,
|
|
),
|
|
std::result::Result::Err(
|
|
crate::DcMetadataSpmAccountDecodeError::LogicalDataOutOfBounds {
|
|
declared_bytes: 4,
|
|
available_bytes: 0,
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn source_specific_bounds_and_metadata_pda_fail_closed() {
|
|
let metadata_program_option: std::option::Option<solana_pubkey::Pubkey> =
|
|
metadata_program_id();
|
|
assert!(metadata_program_option.is_some());
|
|
let metadata_program: solana_pubkey::Pubkey;
|
|
if let std::option::Option::Some(value) = metadata_program_option {
|
|
metadata_program = value;
|
|
} else {
|
|
return;
|
|
}
|
|
let program = solana_pubkey::Pubkey::new_from_array([41_u8; 32]);
|
|
let authority = solana_pubkey::Pubkey::new_from_array([42_u8; 32]);
|
|
let seed = crate::DcMetadataSpmSeed::from_bytes([43_u8; 16]);
|
|
let (account, _) = metadata_pda(
|
|
&program,
|
|
std::option::Option::Some(&authority),
|
|
true,
|
|
&seed,
|
|
&metadata_program,
|
|
);
|
|
let empty = metadata_wire(
|
|
program,
|
|
std::option::Option::Some(authority),
|
|
seed,
|
|
MetadataWireSettings {
|
|
mutable: 1,
|
|
canonical: 1,
|
|
encoding: crate::DcMetadataSpmEncoding::None,
|
|
compression: crate::DcMetadataSpmCompression::None,
|
|
format: crate::DcMetadataSpmFormat::None,
|
|
source: crate::DcMetadataSpmDataSource::Direct,
|
|
},
|
|
&[],
|
|
0,
|
|
);
|
|
assert_eq!(
|
|
crate::decoder_metadata_solana_program_metadata_decode_metadata_account(
|
|
account.to_string().as_str(),
|
|
metadata_program.to_string().as_str(),
|
|
&empty,
|
|
),
|
|
std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::Model(
|
|
crate::DcMetadataSpmModelError::EmptyData {
|
|
source: crate::DcMetadataSpmDataSource::Direct,
|
|
},
|
|
)),
|
|
);
|
|
let invalid_url = metadata_wire(
|
|
program,
|
|
std::option::Option::Some(authority),
|
|
seed,
|
|
MetadataWireSettings {
|
|
mutable: 1,
|
|
canonical: 1,
|
|
encoding: crate::DcMetadataSpmEncoding::Utf8,
|
|
compression: crate::DcMetadataSpmCompression::None,
|
|
format: crate::DcMetadataSpmFormat::None,
|
|
source: crate::DcMetadataSpmDataSource::Url,
|
|
},
|
|
&[0xff],
|
|
0,
|
|
);
|
|
assert_eq!(
|
|
crate::decoder_metadata_solana_program_metadata_decode_metadata_account(
|
|
account.to_string().as_str(),
|
|
metadata_program.to_string().as_str(),
|
|
&invalid_url,
|
|
),
|
|
std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::InvalidUrlUtf8),
|
|
);
|
|
let invalid_external = metadata_wire(
|
|
program,
|
|
std::option::Option::Some(authority),
|
|
seed,
|
|
MetadataWireSettings {
|
|
mutable: 1,
|
|
canonical: 1,
|
|
encoding: crate::DcMetadataSpmEncoding::None,
|
|
compression: crate::DcMetadataSpmCompression::None,
|
|
format: crate::DcMetadataSpmFormat::None,
|
|
source: crate::DcMetadataSpmDataSource::External,
|
|
},
|
|
&[0_u8; 39],
|
|
0,
|
|
);
|
|
assert_eq!(
|
|
crate::decoder_metadata_solana_program_metadata_decode_metadata_account(
|
|
account.to_string().as_str(),
|
|
metadata_program.to_string().as_str(),
|
|
&invalid_external,
|
|
),
|
|
std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::Model(
|
|
crate::DcMetadataSpmModelError::InvalidExternalDataLength {
|
|
actual_bytes: 39,
|
|
expected_bytes: crate::DC_METADATA_SPM_EXTERNAL_DATA_BYTES,
|
|
},
|
|
)),
|
|
);
|
|
let wrong_account = solana_pubkey::Pubkey::new_from_array([44_u8; 32]);
|
|
assert_eq!(
|
|
crate::decoder_metadata_solana_program_metadata_decode_metadata_account(
|
|
wrong_account.to_string().as_str(),
|
|
metadata_program.to_string().as_str(),
|
|
&invalid_external,
|
|
),
|
|
std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::Model(
|
|
crate::DcMetadataSpmModelError::InvalidExternalDataLength {
|
|
actual_bytes: 39,
|
|
expected_bytes: crate::DC_METADATA_SPM_EXTERNAL_DATA_BYTES,
|
|
},
|
|
)),
|
|
);
|
|
let valid = metadata_wire(
|
|
program,
|
|
std::option::Option::Some(authority),
|
|
seed,
|
|
MetadataWireSettings {
|
|
mutable: 1,
|
|
canonical: 1,
|
|
encoding: crate::DcMetadataSpmEncoding::None,
|
|
compression: crate::DcMetadataSpmCompression::None,
|
|
format: crate::DcMetadataSpmFormat::None,
|
|
source: crate::DcMetadataSpmDataSource::Direct,
|
|
},
|
|
&[1_u8],
|
|
0,
|
|
);
|
|
assert_eq!(
|
|
crate::decoder_metadata_solana_program_metadata_decode_metadata_account(
|
|
wrong_account.to_string().as_str(),
|
|
metadata_program.to_string().as_str(),
|
|
&valid,
|
|
),
|
|
std::result::Result::Err(crate::DcMetadataSpmAccountDecodeError::InvalidMetadataPda),
|
|
);
|
|
let missing_authority = metadata_wire(
|
|
program,
|
|
std::option::Option::None,
|
|
seed,
|
|
MetadataWireSettings {
|
|
mutable: 1,
|
|
canonical: 0,
|
|
encoding: crate::DcMetadataSpmEncoding::None,
|
|
compression: crate::DcMetadataSpmCompression::None,
|
|
format: crate::DcMetadataSpmFormat::None,
|
|
source: crate::DcMetadataSpmDataSource::Direct,
|
|
},
|
|
&[1_u8],
|
|
0,
|
|
);
|
|
assert_eq!(
|
|
crate::decoder_metadata_solana_program_metadata_decode_metadata_account(
|
|
wrong_account.to_string().as_str(),
|
|
metadata_program.to_string().as_str(),
|
|
&missing_authority,
|
|
),
|
|
std::result::Result::Err(
|
|
crate::DcMetadataSpmAccountDecodeError::MissingNonCanonicalAuthority,
|
|
),
|
|
);
|
|
}
|
|
}
|