p-ata

[rustopian]

This is a draft pending testing of the latest optimizations, especially custom entrypoint.

p-ata (pinocchio-ata) is a drop-in replacement for SPL ATA. Following in the footsteps of p-token, it uses pinocchio instead of solana-program to reduce compute usage. Plus, it includes a number of additional improvements.

See README for

• descriptions of new features and improvements
• instructions for running the various test suites
• benchmark numbers
• byte-for-byte SPL ATA vs. p-ATA comparisons

Optimal bump circumstances as of 2025-08-11, ecde2ca

Test	SPL ATA	p-ata	bump arg	all optimizations	notes
create_idempotent	3669	1732	590	590
create	12364	4842	3323	3216
create_token2022	14692	7642	6123	5987
create_topup	15817	4710	3191	3083	CreateAccountPrefunded
create_topup_nocap	15817	7476	5959	5851	no CreateAccountPrefunded
create_extended	17620	9771	8251	7997
recover_nested	12851	8100	N/A	8100	rare instruction
recover_multisig	N/A	8412	N/A	8412	rare instruction
worst_case_create	19864	15187	3323	3216	hard-to-find bump

Average of 10,000 random wallets as of 2025-08-11, ecde2ca

Test	SPL ATA	p-ata	bump arg	all optimizations	notes
create_idempotent	4914	3234	948	948
create	14194	6343	3692	3589
create_token2022	16057	9140	6491	6362
create_topup	17317	6183	3561	3449	CreateAccountPrefunded
create_topup_no_cap	17287	8987	6324	6209	no CreateAccountPrefunded
create_extended	19420	11289	8618	8366
recover_nested	17066	12576	N/A	12576	rare instruction
recover_multisig	N/A	12875	N/A	12875	rare instruction

[febo]

Same pattern here:

Suggested change

	if accounts.len() < 7 {
	return Err(ProgramError::NotEnoughAccountKeys);
	}
	// SAFETY: account len already checked
	unsafe {
	Ok(RecoverNestedAccounts {
	nested_associated_token_account: accounts.get_unchecked(0),
	nested_mint: accounts.get_unchecked(1),
	destination_associated_token_account: accounts.get_unchecked(2),
	owner_associated_token_account: accounts.get_unchecked(3),
	owner_mint: accounts.get_unchecked(4),
	wallet: accounts.get_unchecked(5),
	token_program: accounts.get_unchecked(6),
	})
	}
	let [nested_associated_token_account, nested_mint, destination_associated_token_account, owner_associated_token_account, owner_associated_token_account, owner_mint, wallet, token_program @ ..] =
	accounts
	else {
	return Err(ProgramError::NotEnoughAccountKeys);
	};
	Ok(RecoverNestedAccounts {
	nested_associated_token_account,
	nested_mint,
	destination_associated_token_account,
	owner_associated_token_account,
	owner_mint,
	wallet,
	token_program,
	})
	}

[febo]

Getting the raw pointer (line 164) from the Ref (line 159) is problematic. The Ref keeps track of borrows, but when this method finished, it will be drop and reset the borrow state. At the same time, the pointer will be live and can lead to UB if there is a mutable borrow after calling this method.

The safe way to implement this is to map the Ref's data reference to a TokenAccount reference, so the Ref stays alive while the reference is alive.

Suggested change

	pub(crate) fn load_token_account(account: &AccountInfo) -> Result<&TokenAccount, ProgramError> {
	let account_data = account.try_borrow_data()?;
	if !valid_token_account_data(&account_data) {
	return Err(ProgramError::InvalidAccountData);
	}
	// SAFETY: We've validated the account data structure above
	unsafe { Ok(&*(account_data.as_ptr() as *const TokenAccount)) }
	}
	pub(crate) fn load_token_account(account: &AccountInfo) -> Result<Ref<TokenAccount>, ProgramError> {
	let account_data = account.try_borrow_data()?;
	if !valid_token_account_data(&account_data) {
	return Err(ProgramError::InvalidAccountData);
	}
	// SAFETY: We've validated the account data structure above
	Ok(Ref::map(account_data, |data| unsafe {
	&*(data.as_ptr() as *const TokenAccount)
	})
	}

[febo]

Can use the constructors:

Suggested change

	AccountMeta {
	pubkey: recover_accounts.nested_associated_token_account.key(),
	is_writable: true,
	is_signer: false,
	},
	AccountMeta {
	pubkey: recover_accounts.nested_mint.key(),
	is_writable: false,
	is_signer: false,
	},
	AccountMeta {
	pubkey: recover_accounts.destination_associated_token_account.key(),
	is_writable: true,
	is_signer: false,
	},
	AccountMeta {
	pubkey: recover_accounts.owner_associated_token_account.key(),
	is_writable: false,
	is_signer: true,
	},
	AccountMeta::writable(
	recover_accounts.nested_associated_token_account.key()
	),
	AccountMeta::readonly(
	recover_accounts.nested_mint.key()
	),
	AccountMeta::writable(
	recover_accounts.destination_associated_token_account.key()
	),
	AccountMeta::readonly_signer(
	recover_accounts.owner_associated_token_account.key()
	),

[febo]

nit:

Suggested change

	invoke_signed(
	&ix_close,
	&[
	recover_accounts.nested_associated_token_account,
	recover_accounts.wallet,
	recover_accounts.owner_associated_token_account,
	],
	&[pda_signer],
	)?;
	Ok(())
	invoke_signed(
	&ix_close,
	&[
	recover_accounts.nested_associated_token_account,
	recover_accounts.wallet,
	recover_accounts.owner_associated_token_account,
	],
	&[pda_signer],
	)

[febo]

Suggested change

	AccountMeta {
	pubkey: recover_accounts.nested_associated_token_account.key(),
	is_writable: true,
	is_signer: false,
	},
	AccountMeta {
	pubkey: recover_accounts.wallet.key(),
	is_writable: true,
	is_signer: false,
	},
	AccountMeta {
	pubkey: recover_accounts.owner_associated_token_account.key(),
	is_writable: false,
	is_signer: true,
	},
	AccountMeta::writable(
	recover_accounts.nested_associated_token_account.key()
	),
	AccountMeta::writable(
	recover_accounts.wallet.key()
	),
	AccountMeta::readonly_signer(
	recover_accounts.owner_associated_token_account.key()
	),

[febo]

Suggested change

	let get_size_metas = &[AccountMeta {
	pubkey: mint_account.key(),
	is_writable: false,
	is_signer: false,
	}];
	let get_size_metas = &[AccountMeta::readonly(
	mint_account.key()
	)];

[febo]

general comment: wonder if you tried to "prioritize" a potential common path? For example, keep it like the original ATA and encapsulating the logic to parse the instruction data (if needed) inside process_create_associated_token_account. Sometimes it helps CU-wise to have simpler match statements.

[febo]

The rent_sysvar seems to be used only to compute the minimal rent but at this point you already have the space. You could calculate the rent requirement here and replace the match statement with something like:

let minimum_balance = if let Some(rent_sysvar_info) = create_accounts.rent_sysvar {
        let rent = unsafe { Rent::from_account_info_unchecked(rent_sysvar_info)? };
        rent.minimum_balance(space)
} else {
        Rent::get()?.minimum_balance(space)
};
create_and_initialize_ata(...)

[febo]

Not sure if you are expecting the log! to print the pubkey in base58 – as it is it will print the bytes.