use std::collections::HashMap;
use solana_sdk::{
account::Account,
instruction::{AccountMeta, Instruction},
pubkey::Pubkey,
};
use crate::{
constants::{
ASSOCIATED_TOKEN_PROGRAM_ADDRESS, SPL_TOKEN_PROGRAM_ADDRESS, SYSTEM_PROGRAM_ADDRESS,
TOKEN_2022_PROGRAM_ADDRESS,
},
error::{Result, SdkError},
pda::derive_associated_token_account,
rpc::Rpc,
};
const EXECUTE_DISCRIMINATOR: [u8; 8] = [105, 37, 101, 197, 75, 251, 102, 26];
const MINT_SIZE: usize = 82;
const TOKEN_SIZE: usize = 165;
const EXTRA_META_SIZE: usize = 35;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MintAccountContext {
pub mint: Pubkey,
pub token_program: Pubkey,
pub decimals: u8,
pub transfer_hook_program: Option<Pubkey>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TransferHookTransfer {
pub source: Pubkey,
pub destination: Pubkey,
pub authority: Pubkey,
pub amount: u64,
}
pub fn merge_account_metas(account_metas: &[AccountMeta]) -> Vec<AccountMeta> {
let mut merged: Vec<AccountMeta> = Vec::with_capacity(account_metas.len());
let mut positions = HashMap::with_capacity(account_metas.len());
for meta in account_metas {
if let Some(&index) = positions.get(&meta.pubkey) {
let existing: &mut AccountMeta = &mut merged[index];
existing.is_signer |= meta.is_signer;
existing.is_writable |= meta.is_writable;
} else {
positions.insert(meta.pubkey, merged.len());
merged.push(meta.clone());
}
}
merged
}
fn invalid(message: impl Into<String>) -> SdkError {
SdkError::InvalidAccount(message.into())
}
fn bytes<const N: usize>(data: &[u8], offset: usize) -> Result<[u8; N]> {
data.get(
offset
..offset
.checked_add(N)
.ok_or_else(|| invalid("Account offset overflow"))?,
)
.and_then(|slice| slice.try_into().ok())
.ok_or_else(|| invalid("Account data is truncated"))
}
fn read_u32(data: &[u8], offset: usize) -> Result<u32> {
Ok(u32::from_le_bytes(bytes(data, offset)?))
}
fn validate_option(data: &[u8], offset: usize) -> Result<()> {
if read_u32(data, offset)? > 1 {
return Err(invalid("Invalid token account option discriminator"));
}
Ok(())
}
pub fn read_mint_decimals(data: &[u8]) -> Result<u8> {
data.get(44)
.copied()
.ok_or_else(|| invalid("Mint account data too short to read decimals"))
}
pub fn detect_token_program_from_account_info(
mint: &Pubkey,
account_info: Option<&Account>,
) -> Result<Pubkey> {
let account = account_info.ok_or(SdkError::AccountNotFound(*mint))?;
if account.owner == SPL_TOKEN_PROGRAM_ADDRESS || account.owner == TOKEN_2022_PROGRAM_ADDRESS {
Ok(account.owner)
} else {
Err(invalid(format!(
"Unsupported token program for mint {mint}: {}",
account.owner
)))
}
}
fn parse_extensions(data: &[u8], base_size: usize, account_type: u8) -> Result<Option<Pubkey>> {
if data.len() == base_size {
return Ok(None);
}
if data.len() < 166 || data[165] != account_type {
return Err(invalid(
"Invalid Token-2022 account type or truncated extension header",
));
}
if base_size == MINT_SIZE && data[MINT_SIZE..TOKEN_SIZE].iter().any(|byte| *byte != 0) {
return Err(invalid("Invalid Token-2022 mint padding"));
}
let mut hook = None;
let mut offset = 166;
while offset < data.len() {
let kind = u16::from_le_bytes(bytes(data, offset)?);
offset += 2;
if kind == 0 {
break;
}
let length = usize::from(u16::from_le_bytes(bytes(data, offset)?));
offset += 2;
let payload = data
.get(offset..offset + length)
.ok_or_else(|| invalid("Truncated Token-2022 extension"))?;
let minimum = match kind {
1 => 108,
2 => 8,
3 => 32,
4 => 65,
5 => 295,
6 => 1,
7 | 9 | 13 | 27 => 0,
8 | 11 | 15 => 1,
10 => 52,
12 | 28 => 32,
14 | 17 | 18 | 20 | 22 => 64,
16 => 129,
19 => 80,
21 => 80,
23 => 72,
24 => 196,
25 => 56,
26 => 33,
_ => return Err(invalid(format!("Unknown Token-2022 extension type {kind}"))),
};
if payload.len() < minimum {
return Err(invalid("Truncated Token-2022 extension payload"));
}
if kind == 6 && payload[0] > 2 {
return Err(invalid("Invalid default token account state"));
}
if kind == 19 {
validate_metadata_extension(payload)?;
}
if kind == 14 && hook.is_none() {
hook = Some(Pubkey::new_from_array(bytes(payload, 32)?));
}
offset += length;
}
Ok(hook.filter(|program| *program != Pubkey::default()))
}
fn validate_metadata_extension(data: &[u8]) -> Result<()> {
fn skip_string(data: &[u8], offset: &mut usize) -> Result<()> {
let length = usize::try_from(read_u32(data, *offset)?)
.map_err(|_| invalid("Metadata length overflow"))?;
*offset = offset
.checked_add(4)
.and_then(|value| value.checked_add(length))
.filter(|end| *end <= data.len())
.ok_or_else(|| invalid("Truncated token metadata"))?;
Ok(())
}
let mut offset = 64;
for _ in 0..3 {
skip_string(data, &mut offset)?;
}
let count = read_u32(data, offset)?;
offset += 4;
if u64::from(count) > ((data.len() - offset) / 8) as u64 {
return Err(invalid("Truncated token metadata entries"));
}
for _ in 0..count {
skip_string(data, &mut offset)?;
skip_string(data, &mut offset)?;
}
Ok(())
}
pub fn parse_mint_account_context(
mint: &Pubkey,
account_info: Option<&Account>,
) -> Result<MintAccountContext> {
let token_program = detect_token_program_from_account_info(mint, account_info)?;
let account = account_info.ok_or(SdkError::AccountNotFound(*mint))?;
if account.data.len() < MINT_SIZE {
return Err(invalid("Mint account data is truncated"));
}
validate_option(&account.data, 0)?;
validate_option(&account.data, 46)?;
if account.data[45] > 1 {
return Err(invalid("Invalid mint initialization flag"));
}
Ok(MintAccountContext {
mint: *mint,
token_program,
decimals: read_mint_decimals(&account.data)?,
transfer_hook_program: parse_extensions(&account.data, MINT_SIZE, 1)?,
})
}
pub async fn fetch_mint_account_contexts<R: Rpc + ?Sized>(
rpc: &R,
mints: &[Pubkey],
) -> Result<Vec<MintAccountContext>> {
let accounts = rpc.get_multiple_accounts(mints).await?;
mints
.iter()
.enumerate()
.map(|(index, mint)| {
parse_mint_account_context(mint, accounts.get(index).and_then(Option::as_ref))
})
.collect()
}
pub async fn detect_token_program<R: Rpc + ?Sized>(rpc: &R, mint: &Pubkey) -> Result<Pubkey> {
detect_token_program_from_account_info(mint, rpc.get_account(mint).await?.as_ref())
}
pub async fn read_token_account_amount<R: Rpc + ?Sized>(
rpc: &R,
token_account: &Pubkey,
token_program: &Pubkey,
) -> Result<u64> {
let account = rpc
.get_account(token_account)
.await?
.ok_or(SdkError::AccountNotFound(*token_account))?;
if account.owner != *token_program {
return Err(invalid(format!(
"Token account {token_account} has unexpected owner {}",
account.owner
)));
}
if *token_program != SPL_TOKEN_PROGRAM_ADDRESS && *token_program != TOKEN_2022_PROGRAM_ADDRESS {
return Err(invalid(format!(
"Unsupported token program: {token_program}"
)));
}
if account.data.len() < TOKEN_SIZE {
return Err(invalid("Token account data is truncated"));
}
for offset in [72, 109, 129] {
validate_option(&account.data, offset)?;
}
if account.data[108] > 2 {
return Err(invalid("Invalid token account state"));
}
parse_extensions(&account.data, TOKEN_SIZE, 2)?;
Ok(u64::from_le_bytes(bytes(&account.data, 64)?))
}
pub fn create_associated_token_account_idempotent_instruction(
payer: &Pubkey,
associated_token_account: &Pubkey,
owner: &Pubkey,
mint: &Pubkey,
token_program: &Pubkey,
) -> Instruction {
Instruction {
program_id: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
accounts: vec![
AccountMeta::new(*payer, true),
AccountMeta::new(*associated_token_account, false),
AccountMeta::new_readonly(*owner, false),
AccountMeta::new_readonly(*mint, false),
AccountMeta::new_readonly(SYSTEM_PROGRAM_ADDRESS, false),
AccountMeta::new_readonly(*token_program, false),
],
data: vec![1],
}
}
pub async fn ensure_ata_instructions<R: Rpc + ?Sized>(
rpc: &R,
owner: &Pubkey,
mint: &Pubkey,
token_program: &Pubkey,
payer: &Pubkey,
) -> Result<(Pubkey, Option<Instruction>)> {
let (ata, _) = derive_associated_token_account(owner, mint, token_program);
if let Some(account) = rpc.get_account(&ata).await? {
if account.owner == *token_program {
return Ok((ata, None));
}
if account.owner != SYSTEM_PROGRAM_ADDRESS {
return Err(invalid(format!(
"Associated token account exists with unexpected owner: {ata} ({})",
account.owner
)));
}
if !account.data.is_empty() {
return Err(invalid(format!(
"System-owned associated token account has nonempty data: {ata}"
)));
}
}
Ok((
ata,
Some(create_associated_token_account_idempotent_instruction(
payer,
&ata,
owner,
mint,
token_program,
)),
))
}
#[derive(Debug, Clone)]
struct ExtraAccountMeta {
discriminator: u8,
address_config: [u8; 32],
is_signer: bool,
is_writable: bool,
}
fn parse_extra_account_metas(data: &[u8]) -> Result<Vec<ExtraAccountMeta>> {
let mut offset = 0usize;
let mut execute_payload = None;
while offset < data.len() {
let remaining = &data[offset..];
if remaining.len() < 8 {
if remaining.iter().all(|byte| *byte == 0) {
break;
}
return Err(invalid("Transfer-hook TLV entry has a truncated header"));
}
let discriminator = bytes::<8>(data, offset)?;
if discriminator == [0; 8] {
break;
}
let header_end = offset
.checked_add(12)
.filter(|end| *end <= data.len())
.ok_or_else(|| invalid("Transfer-hook TLV entry has a truncated header"))?;
let payload_length = usize::try_from(read_u32(data, header_end - 4)?)
.map_err(|_| invalid("Transfer-hook TLV payload length overflow"))?;
let payload_end = header_end
.checked_add(payload_length)
.filter(|end| *end <= data.len())
.ok_or_else(|| invalid("Transfer-hook TLV entry has a truncated payload"))?;
if discriminator == EXECUTE_DISCRIMINATOR && execute_payload.is_none() {
execute_payload = Some(&data[header_end..payload_end]);
}
offset = payload_end;
}
let payload = execute_payload.ok_or_else(|| {
invalid("Transfer-hook extra-account-meta list is missing an Execute entry")
})?;
let count = usize::try_from(read_u32(payload, 0)?)
.map_err(|_| invalid("Transfer-hook extra-account-meta count overflow"))?;
let available = payload
.len()
.checked_sub(4)
.ok_or_else(|| invalid("Transfer-hook extra-account-meta list is truncated"))?;
if available % EXTRA_META_SIZE != 0 {
return Err(invalid(
"Transfer-hook extra-account-meta list has an invalid PodSlice length",
));
}
let records_length = count
.checked_mul(EXTRA_META_SIZE)
.ok_or_else(|| invalid("Transfer-hook extra-account-meta list length overflow"))?;
let records_end = 4usize
.checked_add(records_length)
.ok_or_else(|| invalid("Transfer-hook extra-account-meta list length overflow"))?;
let records = payload
.get(4..records_end)
.ok_or_else(|| invalid("Transfer-hook extra-account-meta list is truncated"))?;
let mut metas = Vec::with_capacity(count);
for record in records.as_chunks::<EXTRA_META_SIZE>().0 {
if record[33] > 1 || record[34] > 1 {
return Err(invalid(
"Transfer-hook extra-account-meta list contains an invalid boolean",
));
}
metas.push(ExtraAccountMeta {
discriminator: record[0],
address_config: bytes(record, 1)?,
is_signer: record[33] == 1,
is_writable: record[34] == 1,
});
}
Ok(metas)
}
fn seed_error() -> SdkError {
invalid("Invalid transfer-hook PDA seed")
}
fn missing_seed_data(address: &Pubkey) -> SdkError {
invalid(format!("Unable to resolve transfer-hook account data for {address}. Pre-create the relevant token account or pass an existing token account override."))
}
async fn required_seed_data<R: Rpc + ?Sized>(rpc: &R, address: &Pubkey) -> Result<Vec<u8>> {
Ok(rpc
.get_account(address)
.await?
.ok_or_else(|| missing_seed_data(address))?
.data)
}
struct Seed {
data: [u8; 32],
length: usize,
}
impl Seed {
fn new(data: &[u8]) -> Result<Self> {
if data.len() > 32 {
return Err(seed_error());
}
let mut seed = Self {
data: [0; 32],
length: data.len(),
};
seed.data[..data.len()].copy_from_slice(data);
Ok(seed)
}
fn as_slice(&self) -> &[u8] {
&self.data[..self.length]
}
}
async fn unpack_seeds<R: Rpc + ?Sized>(
rpc: &R,
packed: &[u8; 32],
previous: &[AccountMeta],
instruction_data: &[u8],
) -> Result<Vec<Seed>> {
let mut seeds = Vec::new();
let mut offset = 0;
while offset < packed.len() && packed[offset] != 0 {
let parameter = |index: usize| {
packed
.get(offset + index)
.copied()
.map(usize::from)
.ok_or_else(seed_error)
};
let (seed, consumed) = match packed[offset] {
1 => {
let length = parameter(1)?;
let data = packed
.get(offset + 2..offset + 2 + length)
.ok_or_else(seed_error)?;
(Seed::new(data)?, 2 + length)
}
2 => {
let start = parameter(1)?;
let length = parameter(2)?;
(
Seed::new(
instruction_data
.get(start..start + length)
.ok_or_else(seed_error)?,
)?,
3,
)
}
3 => {
let meta = previous.get(parameter(1)?).ok_or_else(seed_error)?;
(Seed::new(meta.pubkey.as_ref())?, 2)
}
4 => {
let meta = previous.get(parameter(1)?).ok_or_else(seed_error)?;
let start = parameter(2)?;
let length = parameter(3)?;
if length > 32 {
return Err(seed_error());
}
let data = required_seed_data(rpc, &meta.pubkey).await?;
(
Seed::new(data.get(start..start + length).ok_or_else(seed_error)?)?,
4,
)
}
_ => return Err(seed_error()),
};
if seeds.len() == 15 {
return Err(seed_error());
}
seeds.push(seed);
offset += consumed;
}
Ok(seeds)
}
async fn unpack_pubkey_data<R: Rpc + ?Sized>(
rpc: &R,
config: &[u8; 32],
previous: &[AccountMeta],
instruction_data: &[u8],
) -> Result<Pubkey> {
let key = match config[0] {
1 => bytes(instruction_data, usize::from(config[1]))?,
2 => {
let meta = previous.get(usize::from(config[1])).ok_or_else(|| {
invalid("Transfer-hook pubkey-data account index is out of range")
})?;
let data = required_seed_data(rpc, &meta.pubkey).await?;
bytes(&data, usize::from(config[2]))?
}
_ => return Err(invalid("Invalid transfer-hook pubkey-data discriminator")),
};
Ok(Pubkey::new_from_array(key))
}
async fn resolve_extra_account_meta<R: Rpc + ?Sized>(
rpc: &R,
extra: &ExtraAccountMeta,
previous: &[AccountMeta],
instruction_data: &[u8],
hook_program: &Pubkey,
) -> Result<AccountMeta> {
let pubkey = match extra.discriminator {
0 => Pubkey::new_from_array(extra.address_config),
2 => unpack_pubkey_data(rpc, &extra.address_config, previous, instruction_data).await?,
discriminator => {
let program = match discriminator {
1 => hook_program,
128..=255 => {
&previous
.get(usize::from(discriminator - 128))
.ok_or_else(|| {
invalid("Transfer-hook external program account index is out of range")
})?
.pubkey
}
_ => return Err(seed_error()),
};
let seeds =
unpack_seeds(rpc, &extra.address_config, previous, instruction_data).await?;
let seed_refs: Vec<&[u8]> = seeds.iter().map(Seed::as_slice).collect();
Pubkey::try_find_program_address(&seed_refs, program)
.ok_or_else(seed_error)?
.0
}
};
Ok(AccountMeta {
pubkey,
is_signer: extra.is_signer,
is_writable: extra.is_writable,
})
}
fn deescalate_account_meta(mut meta: AccountMeta, previous: &[AccountMeta]) -> AccountMeta {
let mut found = false;
let mut signer = false;
let mut writable = false;
for existing in previous
.iter()
.filter(|existing| existing.pubkey == meta.pubkey)
{
found = true;
signer |= existing.is_signer;
writable |= existing.is_writable;
}
if found {
meta.is_signer &= signer;
meta.is_writable &= writable;
}
meta
}
pub async fn resolve_transfer_hook_accounts_for_program<R: Rpc + ?Sized>(
rpc: &R,
mint: &Pubkey,
hook_program: Option<&Pubkey>,
transfers: &[TransferHookTransfer],
) -> Result<Vec<AccountMeta>> {
let Some(hook_program) =
hook_program.filter(|program| **program != Pubkey::default() && !transfers.is_empty())
else {
return Ok(Vec::new());
};
let (validation_address, _) =
Pubkey::find_program_address(&[b"extra-account-metas", mint.as_ref()], hook_program);
let validation = rpc.get_account(&validation_address).await?.ok_or_else(|| invalid(format!(
"Transfer-hook validation account {validation_address} not found for mint {mint} (hook program {hook_program})"
)))?;
if validation.owner != *hook_program {
return Err(invalid(format!(
"Transfer-hook validation account {validation_address} has unexpected owner {}",
validation.owner
)));
}
let extra_metas = parse_extra_account_metas(&validation.data)?;
let mut hook_accounts = Vec::new();
let mut execute_accounts = Vec::with_capacity(5 + extra_metas.len());
for transfer in transfers {
let mut instruction_data = [0; 16];
instruction_data[..8].copy_from_slice(&EXECUTE_DISCRIMINATOR);
instruction_data[8..].copy_from_slice(&transfer.amount.to_le_bytes());
execute_accounts.clear();
execute_accounts.extend([
AccountMeta::new_readonly(transfer.source, false),
AccountMeta::new_readonly(*mint, false),
AccountMeta::new_readonly(transfer.destination, false),
AccountMeta::new_readonly(transfer.authority, false),
AccountMeta::new_readonly(validation_address, false),
]);
for extra in &extra_metas {
let resolved = resolve_extra_account_meta(
rpc,
extra,
&execute_accounts,
&instruction_data,
hook_program,
)
.await?;
execute_accounts.push(deescalate_account_meta(resolved, &execute_accounts));
}
hook_accounts.extend(execute_accounts.drain(5..));
hook_accounts.push(AccountMeta::new_readonly(*hook_program, false));
hook_accounts.push(AccountMeta::new_readonly(validation_address, false));
}
Ok(merge_account_metas(&hook_accounts))
}
pub async fn resolve_transfer_hook_accounts<R: Rpc + ?Sized>(
rpc: &R,
mint: &Pubkey,
token_program: &Pubkey,
transfers: &[TransferHookTransfer],
) -> Result<Vec<AccountMeta>> {
if transfers.is_empty() || *token_program != TOKEN_2022_PROGRAM_ADDRESS {
return Ok(Vec::new());
}
let account = rpc.get_account(mint).await?;
let context = parse_mint_account_context(mint, account.as_ref())?;
if context.token_program != *token_program {
return Err(invalid(format!(
"Mint {mint} has unexpected owner {}",
context.token_program
)));
}
resolve_transfer_hook_accounts_for_program(
rpc,
mint,
context.transfer_hook_program.as_ref(),
transfers,
)
.await
}
#[cfg(test)]
mod tests {
use super::*;
use crate::rpc::{RpcFilter, SimulationResult};
use async_trait::async_trait;
use solana_sdk::{hash::Hash, transaction::VersionedTransaction};
use std::sync::atomic::{AtomicUsize, Ordering};
#[derive(Default)]
struct MemoryRpc {
accounts: HashMap<Pubkey, Account>,
reads: AtomicUsize,
}
#[async_trait]
impl Rpc for MemoryRpc {
async fn get_account(&self, address: &Pubkey) -> Result<Option<Account>> {
self.reads.fetch_add(1, Ordering::Relaxed);
Ok(self.accounts.get(address).cloned())
}
async fn get_multiple_accounts(
&self,
addresses: &[Pubkey],
) -> Result<Vec<Option<Account>>> {
let mut accounts = Vec::new();
for address in addresses {
accounts.push(self.get_account(address).await?);
}
Ok(accounts)
}
async fn get_program_accounts(
&self,
_: &Pubkey,
_: &[RpcFilter],
) -> Result<Vec<(Pubkey, Account)>> {
panic!("unexpected program account query")
}
async fn get_slot(&self) -> Result<u64> {
panic!("unexpected slot query")
}
async fn get_block_time(&self, _: u64) -> Result<Option<i64>> {
panic!("unexpected block time query")
}
async fn get_latest_blockhash(&self) -> Result<Hash> {
panic!("unexpected blockhash query")
}
async fn get_transaction_logs(&self, _: &str) -> Result<Option<Vec<String>>> {
panic!("unexpected transaction query")
}
async fn simulate_transaction(&self, _: &VersionedTransaction) -> Result<SimulationResult> {
panic!("unexpected transaction simulation")
}
}
fn pk(byte: u8) -> Pubkey {
Pubkey::new_from_array([byte; 32])
}
fn account(owner: Pubkey, data: Vec<u8>) -> Account {
Account {
owner,
data,
..Account::default()
}
}
fn transfer() -> TransferHookTransfer {
TransferHookTransfer {
source: pk(10),
destination: pk(11),
authority: pk(12),
amount: 0x1234,
}
}
fn packed(data: &[u8]) -> [u8; 32] {
let mut config = [0; 32];
config[..data.len()].copy_from_slice(data);
config
}
fn record(
discriminator: u8,
address_config: [u8; 32],
is_signer: bool,
is_writable: bool,
) -> ExtraAccountMeta {
ExtraAccountMeta {
discriminator,
address_config,
is_signer,
is_writable,
}
}
fn tlv_entry(discriminator: [u8; 8], payload: &[u8]) -> Vec<u8> {
let mut data = Vec::with_capacity(12 + payload.len());
data.extend(discriminator);
data.extend((payload.len() as u32).to_le_bytes());
data.extend(payload);
data
}
fn meta_list(records: &[ExtraAccountMeta]) -> Vec<u8> {
let mut data = Vec::new();
data.extend(EXECUTE_DISCRIMINATOR);
data.extend((4 + records.len() as u32 * 35).to_le_bytes());
data.extend((records.len() as u32).to_le_bytes());
for record in records {
data.push(record.discriminator);
data.extend(record.address_config);
data.extend([u8::from(record.is_signer), u8::from(record.is_writable)]);
}
data
}
fn hook_rpc(records: &[ExtraAccountMeta]) -> (MemoryRpc, Pubkey) {
let validation =
Pubkey::find_program_address(&[b"extra-account-metas", pk(1).as_ref()], &pk(2)).0;
let mut rpc = MemoryRpc::default();
rpc.accounts
.insert(validation, account(pk(2), meta_list(records)));
(rpc, validation)
}
fn mint_data(hook: Option<Pubkey>) -> Vec<u8> {
let mut data = vec![0; MINT_SIZE];
data[44] = 9;
data[45] = 1;
if let Some(hook) = hook {
data.resize(166, 0);
data[165] = 1;
data.extend(14u16.to_le_bytes());
data.extend(64u16.to_le_bytes());
data.extend([0; 32]);
data.extend(hook.to_bytes());
}
data
}
#[tokio::test]
async fn mixed_hook_seeds_resolve_against_execute_instruction_and_account_data() {
let current = transfer();
let config = packed(&[1, 3, 1, 2, 3, 2, 8, 2, 3, 0, 4, 2, 1, 3]);
let (mut rpc, validation) = hook_rpc(&[record(1, config, false, true)]);
rpc.accounts.insert(
current.destination,
account(TOKEN_2022_PROGRAM_ADDRESS, vec![9, 8, 7, 6, 5]),
);
let expected = Pubkey::find_program_address(
&[
&[1, 2, 3],
&[0x34, 0x12],
current.source.as_ref(),
&[8, 7, 6],
],
&pk(2),
)
.0;
assert_eq!(
resolve_transfer_hook_accounts_for_program(&rpc, &pk(1), Some(&pk(2)), &[current])
.await
.unwrap(),
vec![
AccountMeta::new(expected, false),
AccountMeta::new_readonly(pk(2), false),
AccountMeta::new_readonly(validation, false)
],
);
}
#[tokio::test]
async fn account_pubkey_data_can_supply_external_program_for_following_pda() {
let current = transfer();
let external = pk(33);
let (mut rpc, validation) = hook_rpc(&[
record(2, packed(&[2, 2, 1]), false, false),
record(128 + 5, packed(&[1, 3, 4, 5, 6, 3, 5]), false, true),
]);
let mut data = vec![99];
data.extend(external.to_bytes());
rpc.accounts.insert(
current.destination,
account(TOKEN_2022_PROGRAM_ADDRESS, data),
);
let expected = Pubkey::find_program_address(&[&[4, 5, 6], external.as_ref()], &external).0;
assert_eq!(
resolve_transfer_hook_accounts_for_program(&rpc, &pk(1), Some(&pk(2)), &[current])
.await
.unwrap(),
vec![
AccountMeta::new_readonly(external, false),
AccountMeta::new(expected, false),
AccountMeta::new_readonly(pk(2), false),
AccountMeta::new_readonly(validation, false)
],
);
}
#[tokio::test]
async fn pubkey_instruction_data_obeys_32_byte_boundary() {
let rpc = MemoryRpc::default();
let mut data = vec![99];
data.extend(pk(33).to_bytes());
assert_eq!(
unpack_pubkey_data(&rpc, &packed(&[1, 1]), &[], &data)
.await
.unwrap(),
pk(33)
);
assert!(unpack_pubkey_data(&rpc, &packed(&[1, 2]), &[], &data)
.await
.is_err());
let (rpc, _) = hook_rpc(&[record(2, packed(&[1, 0]), false, false)]);
assert!(resolve_transfer_hook_accounts_for_program(
&rpc,
&pk(1),
Some(&pk(2)),
&[transfer()]
)
.await
.is_err());
}
#[tokio::test]
async fn repeated_transfers_merge_after_interface_accounts_and_deescalate_duplicates() {
let first = transfer();
let second = TransferHookTransfer { amount: 2, ..first };
let (rpc, validation) = hook_rpc(&[
record(0, first.source.to_bytes(), true, true),
record(1, packed(&[2, 8, 8]), false, true),
record(0, pk(20).to_bytes(), true, false),
record(0, pk(20).to_bytes(), false, true),
]);
let first_pda = Pubkey::find_program_address(&[&first.amount.to_le_bytes()], &pk(2)).0;
let second_pda = Pubkey::find_program_address(&[&second.amount.to_le_bytes()], &pk(2)).0;
assert_eq!(
resolve_transfer_hook_accounts_for_program(
&rpc,
&pk(1),
Some(&pk(2)),
&[first, second]
)
.await
.unwrap(),
vec![
AccountMeta::new_readonly(first.source, false),
AccountMeta::new(first_pda, false),
AccountMeta::new_readonly(pk(20), true),
AccountMeta::new_readonly(pk(2), false),
AccountMeta::new_readonly(validation, false),
AccountMeta::new(second_pda, false),
],
);
assert_eq!(
merge_account_metas(&[
AccountMeta::new_readonly(pk(9), true),
AccountMeta::new(pk(9), false)
]),
vec![AccountMeta::new(pk(9), true)]
);
}
#[tokio::test]
async fn hook_resolver_finds_execute_list_after_unrelated_tlv_entry() {
let required = pk(30);
let validation =
Pubkey::find_program_address(&[b"extra-account-metas", pk(1).as_ref()], &pk(2)).0;
let mut validation_data = tlv_entry([7; 8], &[9, 8, 7]);
validation_data.extend(meta_list(&[record(0, required.to_bytes(), false, true)]));
let mut rpc = MemoryRpc::default();
rpc.accounts
.insert(validation, account(pk(2), validation_data));
assert_eq!(
resolve_transfer_hook_accounts_for_program(&rpc, &pk(1), Some(&pk(2)), &[transfer()])
.await
.unwrap(),
vec![
AccountMeta::new(required, false),
AccountMeta::new_readonly(pk(2), false),
AccountMeta::new_readonly(validation, false),
],
);
}
#[tokio::test]
async fn advertised_hook_requires_validation_and_valid_owner() {
let mut rpc = MemoryRpc::default();
rpc.accounts.insert(
pk(1),
account(TOKEN_2022_PROGRAM_ADDRESS, mint_data(Some(pk(2)))),
);
assert!(resolve_transfer_hook_accounts(
&rpc,
&pk(1),
&TOKEN_2022_PROGRAM_ADDRESS,
&[transfer()]
)
.await
.is_err());
let (mut rpc, validation) = hook_rpc(&[]);
rpc.accounts.get_mut(&validation).unwrap().owner = pk(3);
assert!(resolve_transfer_hook_accounts_for_program(
&rpc,
&pk(1),
Some(&pk(2)),
&[transfer()]
)
.await
.is_err());
}
#[tokio::test]
async fn absent_hook_and_legacy_tokens_do_not_query_rpc() {
let rpc = MemoryRpc::default();
assert_eq!(
resolve_transfer_hook_accounts_for_program(&rpc, &pk(1), None, &[transfer()])
.await
.unwrap(),
vec![]
);
assert!(resolve_transfer_hook_accounts_for_program(
&rpc,
&pk(1),
Some(&Pubkey::default()),
&[transfer()]
)
.await
.unwrap()
.is_empty());
assert_eq!(
resolve_transfer_hook_accounts_for_program(&rpc, &pk(1), Some(&pk(2)), &[])
.await
.unwrap(),
vec![]
);
assert_eq!(
resolve_transfer_hook_accounts(&rpc, &pk(1), &SPL_TOKEN_PROGRAM_ADDRESS, &[transfer()])
.await
.unwrap(),
vec![]
);
assert_eq!(rpc.reads.load(Ordering::Relaxed), 0);
}
#[tokio::test]
async fn malformed_seed_modes_and_missing_seed_accounts_fail_closed() {
let mut truncated_header = packed(&[1, 29]);
truncated_header[31] = 2;
for config in [
packed(&[1, 31]),
packed(&[2, 15, 2]),
packed(&[3, 99]),
packed(&[4, 99, 0, 1]),
packed(&[4, 2, 4, 1]),
packed(&[9]),
truncated_header,
] {
let (mut rpc, _) = hook_rpc(&[record(1, config, false, false)]);
rpc.accounts.insert(
transfer().destination,
account(TOKEN_2022_PROGRAM_ADDRESS, vec![0; 4]),
);
assert!(resolve_transfer_hook_accounts_for_program(
&rpc,
&pk(1),
Some(&pk(2)),
&[transfer()]
)
.await
.is_err());
}
for extra in [
record(3, [0; 32], false, false),
record(255, [0; 32], false, false),
record(2, packed(&[9]), false, false),
record(2, packed(&[2, 99, 0]), false, false),
record(2, packed(&[2, 2, 0]), false, false),
record(1, packed(&[4, 2, 0, 1]), false, false),
] {
let (rpc, _) = hook_rpc(&[extra]);
assert!(resolve_transfer_hook_accounts_for_program(
&rpc,
&pk(1),
Some(&pk(2)),
&[transfer()]
)
.await
.is_err());
}
}
#[test]
fn validation_tlv_rejects_truncation_invalid_booleans_and_discriminators() {
let valid = meta_list(&[record(0, pk(3).to_bytes(), false, false)]);
let mut cases = vec![vec![0; 15], valid[..valid.len() - 1].to_vec()];
let mut invalid_boolean = valid.clone();
invalid_boolean[49] = 2;
cases.push(invalid_boolean);
let mut malformed_after_execute = valid.clone();
malformed_after_execute.extend([1; 7]);
cases.push(malformed_after_execute);
let mut invalid_discriminator = valid.clone();
invalid_discriminator[0] ^= 255;
cases.push(invalid_discriminator);
let mut oversized_payload = valid;
oversized_payload[8..12].copy_from_slice(&u32::MAX.to_le_bytes());
cases.push(oversized_payload);
for data in cases {
assert!(parse_extra_account_metas(&data).is_err());
}
}
#[test]
fn validation_tlv_rejects_missing_execute_and_malformed_skipped_entries() {
let valid_skip = tlv_entry([7; 8], &[1, 2, 3]);
let mut truncated_header = valid_skip.clone();
truncated_header.extend([1; 7]);
let mut truncated_payload = Vec::from([7; 8]);
truncated_payload.extend(4u32.to_le_bytes());
truncated_payload.extend([1, 2, 3]);
let mut oversized_payload = Vec::from([7; 8]);
oversized_payload.extend(u32::MAX.to_le_bytes());
for data in [
valid_skip,
truncated_header,
truncated_payload,
oversized_payload,
] {
assert!(parse_extra_account_metas(&data).is_err());
}
}
#[tokio::test]
async fn mint_parsing_preserves_order_missing_mints_and_hook_program() {
let mut rpc = MemoryRpc::default();
rpc.accounts
.insert(pk(1), account(SPL_TOKEN_PROGRAM_ADDRESS, mint_data(None)));
rpc.accounts.insert(
pk(2),
account(TOKEN_2022_PROGRAM_ADDRESS, mint_data(Some(pk(3)))),
);
let contexts = fetch_mint_account_contexts(&rpc, &[pk(2), pk(1)])
.await
.unwrap();
assert_eq!(
contexts,
vec![
MintAccountContext {
mint: pk(2),
token_program: TOKEN_2022_PROGRAM_ADDRESS,
decimals: 9,
transfer_hook_program: Some(pk(3))
},
MintAccountContext {
mint: pk(1),
token_program: SPL_TOKEN_PROGRAM_ADDRESS,
decimals: 9,
transfer_hook_program: None
},
]
);
assert!(
matches!(fetch_mint_account_contexts(&rpc, &[pk(1), pk(4)]).await, Err(SdkError::AccountNotFound(address)) if address == pk(4))
);
let mut truncated = mint_data(Some(pk(2)));
truncated.pop();
assert!(parse_mint_account_context(
&pk(1),
Some(&account(TOKEN_2022_PROGRAM_ADDRESS, truncated))
)
.is_err());
assert!(
parse_mint_account_context(&pk(1), Some(&account(pk(20), mint_data(None)))).is_err()
);
}
#[tokio::test]
async fn disabled_hook_requires_only_the_mint_account() {
let mut rpc = MemoryRpc::default();
let mint = pk(1);
let mint_account = account(
TOKEN_2022_PROGRAM_ADDRESS,
mint_data(Some(Pubkey::default())),
);
assert_eq!(
parse_mint_account_context(&mint, Some(&mint_account))
.unwrap()
.transfer_hook_program,
None
);
rpc.accounts.insert(mint, mint_account);
assert!(resolve_transfer_hook_accounts(
&rpc,
&mint,
&TOKEN_2022_PROGRAM_ADDRESS,
&[transfer()]
)
.await
.unwrap()
.is_empty());
assert_eq!(rpc.reads.load(Ordering::Relaxed), 1);
}
#[test]
fn mint_hook_parsing_stops_at_uninitialized_reserved_space() {
let mut data = mint_data(Some(pk(2)));
data.extend([0; 5]);
assert_eq!(
parse_mint_account_context(&pk(1), Some(&account(TOKEN_2022_PROGRAM_ADDRESS, data)))
.unwrap()
.transfer_hook_program,
Some(pk(2))
);
}
#[test]
fn default_account_state_rejects_unknown_discriminants_and_preserves_hooks() {
let mut data = vec![0; 166];
data[45] = 1;
data[165] = 1;
data.extend([6, 0, 1, 0, 3]);
let mut mint = account(TOKEN_2022_PROGRAM_ADDRESS, data);
assert!(matches!(
parse_mint_account_context(&pk(1), Some(&mint)),
Err(SdkError::InvalidAccount(_))
));
mint.data.extend_from_slice(&mint_data(Some(pk(2)))[166..]);
for state in 0..=u8::MAX {
mint.data[170] = state;
let result = parse_mint_account_context(&pk(1), Some(&mint));
if state <= 2 {
assert_eq!(result.unwrap().transfer_hook_program, Some(pk(2)));
} else {
assert!(
matches!(result, Err(SdkError::InvalidAccount(_))),
"accepted unknown AccountState discriminant {state}"
);
}
}
}
#[tokio::test]
async fn token_amount_reads_full_u64_and_rejects_truncated_or_wrong_owner() {
let mut rpc = MemoryRpc::default();
let mut data = vec![0; TOKEN_SIZE];
data[64..72].copy_from_slice(&u64::MAX.to_le_bytes());
data[108] = 1;
data.extend([2, 15, 0, 1, 0, 0]);
rpc.accounts
.insert(pk(1), account(TOKEN_2022_PROGRAM_ADDRESS, data.clone()));
assert_eq!(
read_token_account_amount(&rpc, &pk(1), &TOKEN_2022_PROGRAM_ADDRESS)
.await
.unwrap(),
u64::MAX
);
assert!(
read_token_account_amount(&rpc, &pk(1), &SPL_TOKEN_PROGRAM_ADDRESS)
.await
.is_err()
);
data.pop();
rpc.accounts
.insert(pk(1), account(TOKEN_2022_PROGRAM_ADDRESS, data));
assert!(
read_token_account_amount(&rpc, &pk(1), &TOKEN_2022_PROGRAM_ADDRESS)
.await
.is_err()
);
assert!(
read_token_account_amount(&rpc, &pk(2), &TOKEN_2022_PROGRAM_ADDRESS)
.await
.is_err()
);
}
#[tokio::test]
async fn token_amount_accepts_uninitialized_reserved_extension_space() {
let expected: u64 = 0x0102_0304_0506_0708;
let mut data = vec![0; 171];
data[64..72].copy_from_slice(&expected.to_le_bytes());
data[108] = 1;
data[165] = 2;
let mut rpc = MemoryRpc::default();
rpc.accounts
.insert(pk(1), account(TOKEN_2022_PROGRAM_ADDRESS, data));
assert_eq!(
read_token_account_amount(&rpc, &pk(1), &TOKEN_2022_PROGRAM_ADDRESS)
.await
.unwrap(),
expected
);
}
#[tokio::test]
async fn ata_setup_is_idempotent_supports_distinct_payer_and_checks_existing_owner() {
let mut rpc = MemoryRpc::default();
let owner = pk(1);
let mint = pk(2);
let payer = pk(3);
let (ata, instruction) =
ensure_ata_instructions(&rpc, &owner, &mint, &TOKEN_2022_PROGRAM_ADDRESS, &payer)
.await
.unwrap();
let instruction = instruction.unwrap();
assert_eq!(
instruction,
Instruction {
program_id: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
accounts: vec![
AccountMeta::new(payer, true),
AccountMeta::new(ata, false),
AccountMeta::new_readonly(owner, false),
AccountMeta::new_readonly(mint, false),
AccountMeta::new_readonly(SYSTEM_PROGRAM_ADDRESS, false),
AccountMeta::new_readonly(TOKEN_2022_PROGRAM_ADDRESS, false)
],
data: vec![1],
}
);
let mut initialized = vec![0; TOKEN_SIZE];
initialized[..32].copy_from_slice(mint.as_ref());
initialized[32..64].copy_from_slice(owner.as_ref());
initialized[108] = 1;
rpc.accounts
.insert(ata, account(TOKEN_2022_PROGRAM_ADDRESS, initialized));
assert_eq!(
ensure_ata_instructions(&rpc, &owner, &mint, &TOKEN_2022_PROGRAM_ADDRESS, &payer)
.await
.unwrap(),
(ata, None)
);
rpc.accounts.get_mut(&ata).unwrap().owner = SPL_TOKEN_PROGRAM_ADDRESS;
assert!(
ensure_ata_instructions(&rpc, &owner, &mint, &TOKEN_2022_PROGRAM_ADDRESS, &payer)
.await
.is_err()
);
}
#[tokio::test]
async fn prefunded_system_owned_ata_emits_idempotent_creation_and_rejects_data() {
let mut rpc = MemoryRpc::default();
let owner = pk(1);
let mint = pk(2);
let payer = pk(3);
let (ata, _) = derive_associated_token_account(&owner, &mint, &TOKEN_2022_PROGRAM_ADDRESS);
let mut prefunded = account(SYSTEM_PROGRAM_ADDRESS, vec![]);
prefunded.lamports = 10_000_000;
rpc.accounts.insert(ata, prefunded);
assert_eq!(
ensure_ata_instructions(&rpc, &owner, &mint, &TOKEN_2022_PROGRAM_ADDRESS, &payer)
.await
.unwrap(),
(
ata,
Some(Instruction {
program_id: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
accounts: vec![
AccountMeta::new(payer, true),
AccountMeta::new(ata, false),
AccountMeta::new_readonly(owner, false),
AccountMeta::new_readonly(mint, false),
AccountMeta::new_readonly(SYSTEM_PROGRAM_ADDRESS, false),
AccountMeta::new_readonly(TOKEN_2022_PROGRAM_ADDRESS, false),
],
data: vec![1],
})
)
);
rpc.accounts.get_mut(&ata).unwrap().data.push(1);
assert!(
ensure_ata_instructions(&rpc, &owner, &mint, &TOKEN_2022_PROGRAM_ADDRESS, &payer)
.await
.is_err()
);
}
}