use solana_sdk::{
instruction::{AccountMeta, Instruction},
pubkey::Pubkey,
};
use crate::{
accounts::{
decode_lp_protocol_fee_config, fetch_asset_config, fetch_global_config, resolve_swap_pair,
},
constants::TREASURY_PROGRAM_ADDRESS_DEVNET,
error::{Result, SdkError},
generated::swap::{SwapAccounts, SwapArgs},
oracle::{resolve_oracle_accounts, resolve_pyth_oracle_accounts},
pda::{
derive_asset_config, derive_associated_token_account, derive_fee_vault,
derive_global_config, derive_lp_fee_vault, derive_lp_fee_vault_authority,
derive_lp_protocol_fee_config, derive_lp_stable_config, derive_program_authority,
derive_vault, derive_vault_authority,
},
quote_core::{
compute_swap_quote_from_resolved_inputs, fetch_cluster_unix_timestamp,
fetch_oracle_account_data_map, quote_requires_cluster_timestamp, SwapQuoteResolvedInputs,
},
rpc::Rpc,
token::{
ensure_ata_instructions, fetch_mint_account_contexts, merge_account_metas,
resolve_transfer_hook_accounts_for_program, TransferHookTransfer,
},
transaction::build_unsigned_transaction,
treasury_planner::{
resolve_treasury_swap_plan, ResolveTreasurySwapPlanInput, TreasurySwapPlan,
TreasurySweepOracleSnapshot,
},
types::{
AssetType, BuildSwapInstructionResult, BuildSwapTransactionResult, SwapAccountKeys,
SwapDirection, SwapParams,
},
validation::{assert_no_remaining_signers, assert_positive_amount},
};
pub async fn build_swap_instruction<R: Rpc + ?Sized>(
rpc: &R,
params: &SwapParams,
program_id: &Pubkey,
) -> Result<BuildSwapInstructionResult> {
let amount = assert_positive_amount(params.amount, "amount")?;
let resolved_pair = resolve_swap_pair(
rpc,
¶ms.input_mint,
¶ms.output_mint,
¶ms.liquidity_provider,
program_id,
params.pair_address.as_ref(),
)
.await?;
let program_authority = derive_program_authority(program_id).0;
let lp_vault_authority = derive_vault_authority(¶ms.liquidity_provider, program_id).0;
let lp_fee_vault_authority =
derive_lp_fee_vault_authority(¶ms.liquidity_provider, program_id).0;
let global_config = derive_global_config(program_id).0;
let input_config = derive_asset_config(¶ms.input_mint, program_id).0;
let output_config = derive_asset_config(¶ms.output_mint, program_id).0;
let mint_contexts =
fetch_mint_account_contexts(rpc, &[params.input_mint, params.output_mint]).await?;
let [input_context, output_context] = mint_contexts.as_slice() else {
return Err(SdkError::InvalidAccount(
"Missing input or output mint account context".into(),
));
};
let global = fetch_global_config(rpc, program_id, Some(&global_config)).await?;
let fee_contexts = fetch_mint_account_contexts(rpc, &[global.fee_token_mint]).await?;
let [fee_context] = fee_contexts.as_slice() else {
return Err(SdkError::InvalidAccount(
"Missing fee mint account context".into(),
));
};
let input_vault = derive_vault(
¶ms.liquidity_provider,
¶ms.input_mint,
&input_context.token_program,
program_id,
)
.0;
let output_vault = derive_vault(
¶ms.liquidity_provider,
¶ms.output_mint,
&output_context.token_program,
program_id,
)
.0;
let fee_vault = derive_fee_vault(
&global.fee_token_mint,
&fee_context.token_program,
program_id,
)
.0;
let lp_fee_vault = derive_lp_fee_vault(
&global.fee_token_mint,
¶ms.liquidity_provider,
&fee_context.token_program,
program_id,
)
.0;
let fee_config = derive_asset_config(&global.fee_token_mint, program_id).0;
let lp_protocol_fee_config =
derive_lp_protocol_fee_config(¶ms.liquidity_provider, program_id).0;
let mut setup_instructions = Vec::new();
let auto_create_ata = params.auto_create_ata.unwrap_or(true);
let input_user_account = match params.user_input_token_account {
Some(address) => address,
None if auto_create_ata => {
let (address, instruction) = ensure_ata_instructions(
rpc,
¶ms.user,
¶ms.input_mint,
&input_context.token_program,
¶ms.user,
)
.await?;
setup_instructions.extend(instruction);
address
}
None => {
derive_associated_token_account(
¶ms.user,
¶ms.input_mint,
&input_context.token_program,
)
.0
}
};
let output_user_account = match params.user_output_token_account {
Some(address) => address,
None if auto_create_ata => {
let (address, instruction) = ensure_ata_instructions(
rpc,
¶ms.user,
¶ms.output_mint,
&output_context.token_program,
¶ms.user,
)
.await?;
setup_instructions.extend(instruction);
address
}
None => {
derive_associated_token_account(
¶ms.user,
¶ms.output_mint,
&output_context.token_program,
)
.0
}
};
let input = fetch_asset_config(rpc, &input_config).await?;
let output = fetch_asset_config(rpc, &output_config).await?;
let fee = fetch_asset_config(rpc, &fee_config).await?;
if input.mint_address != params.input_mint
|| output.mint_address != params.output_mint
|| fee.mint_address != global.fee_token_mint
{
return Err(SdkError::InvalidAccount(
"Asset config mint does not match its derived mint".into(),
));
}
let lp_fee_override = match rpc.get_account(&lp_protocol_fee_config).await? {
None => None,
Some(account) => {
if account.owner != *program_id {
return Err(SdkError::InvalidAccount(format!(
"LP protocol fee config has unexpected owner {}; expected {program_id}",
account.owner,
)));
}
Some(decode_lp_protocol_fee_config(&account.data)?)
}
};
let treasury_enabled = lp_fee_override
.as_ref()
.is_some_and(|config| config.treasury_enabled);
let (protocol_fees_bps, spread_protocol_fees_bps) = lp_fee_override.as_ref().map_or(
(global.protocol_fees_bps, global.spread_protocol_fees_bps),
|config| (config.protocol_fees_bps, config.spread_protocol_fees_bps),
);
let has_protocol_fee_transfer = protocol_fees_bps > 0 || spread_protocol_fees_bps > 0;
let configs = [&input, &output, &fee];
let oracle_accounts = resolve_oracle_accounts(&configs);
let has_transfer_hook = input_context.transfer_hook_program.is_some()
|| output_context.transfer_hook_program.is_some()
|| fee_context.transfer_hook_program.is_some();
let (swap_quote, oracle_snapshot) = if treasury_enabled || has_transfer_hook {
let oracle_addresses: Vec<_> = oracle_accounts.iter().map(|meta| meta.pubkey).collect();
let pyth_addresses = resolve_pyth_oracle_accounts(&configs);
let oracle_account_data_map =
fetch_oracle_account_data_map(rpc, &oracle_addresses, &pyth_addresses).await?;
let current_unix_timestamp = if quote_requires_cluster_timestamp(&configs) {
Some(fetch_cluster_unix_timestamp(rpc).await?)
} else {
None
};
let quote = compute_swap_quote_from_resolved_inputs(
params,
&SwapQuoteResolvedInputs {
global_config: &global,
lp_protocol_fee_config: lp_fee_override.as_ref(),
pair: &resolved_pair.pair,
onchain_direction: resolved_pair.swap_direction,
input_config: &input,
output_config: &output,
fee_config: &fee,
input_decimals: input_context.decimals,
output_decimals: output_context.decimals,
fee_token_decimals: fee_context.decimals,
oracle_account_data_map: &oracle_account_data_map,
current_unix_timestamp,
},
amount,
)?;
(
Some(quote),
Some(TreasurySweepOracleSnapshot {
account_data: oracle_account_data_map,
pyth_addresses,
current_unix_timestamp,
}),
)
} else {
(None, None)
};
let input_is_quote = resolved_pair.swap_direction == SwapDirection::QuoteToBase;
let mut treasury_plan = if treasury_enabled {
let quote = swap_quote
.as_ref()
.expect("Treasury requires a computed quote");
Some(
resolve_treasury_swap_plan(
rpc,
&ResolveTreasurySwapPlanInput {
owner: lp_vault_authority,
quote_mint: if input_is_quote {
params.input_mint
} else {
params.output_mint
},
base_mint: if input_is_quote {
params.output_mint
} else {
params.input_mint
},
quote_token_program: if input_is_quote {
input_context.token_program
} else {
output_context.token_program
},
base_token_program: if input_is_quote {
output_context.token_program
} else {
input_context.token_program
},
direction: resolved_pair.swap_direction,
amount_out: quote.amount_out,
amount_in_for_vault: quote.amount_in_for_vault,
input_decimals: input_context.decimals,
input_is_stable: input.asset_type == AssetType::Stable,
output_is_stable: output.asset_type == AssetType::Stable,
oracle_snapshot,
quote_vault: if input_is_quote {
input_vault
} else {
output_vault
},
base_vault: if input_is_quote {
output_vault
} else {
input_vault
},
},
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await?,
)
} else {
None
};
if let Some(plan) = &mut treasury_plan {
let mut nav_accounts = oracle_accounts.clone();
nav_accounts.append(&mut plan.nav_accounts);
plan.nav_accounts = merge_account_metas(&nav_accounts);
plan.nav_account_count = u8::try_from(plan.nav_accounts.len()).map_err(|_| {
SdkError::InvalidInput("Treasury NAV account count exceeds the V2 u8 limit".into())
})?;
plan.remaining_accounts = plan.nav_accounts.clone();
plan.remaining_accounts
.extend_from_slice(&plan.apy_accounts);
let (input_treasury_enabled, output_treasury_enabled) = if input_is_quote {
(plan.quote_asset_enabled, plan.base_asset_enabled)
} else {
(plan.base_asset_enabled, plan.quote_asset_enabled)
};
let input_sweepable = input.asset_type == AssetType::Stable && input_treasury_enabled;
let output_redeemable = output.asset_type == AssetType::Stable && output_treasury_enabled;
if (input_sweepable && input_context.transfer_hook_program.is_some())
|| (output_redeemable && output_context.transfer_hook_program.is_some())
{
return Err(SdkError::InvalidInput(
"Treasury-backed transfer-hook swap cannot safely resolve amount-seeded hook accounts; use the raw builder with explicit remaining accounts".into(),
));
}
}
let mut trailing_accounts = Vec::new();
if has_transfer_hook {
let quote = swap_quote
.as_ref()
.expect("Transfer hooks require a computed quote");
let input_transfers = vec![TransferHookTransfer {
source: input_user_account,
destination: input_vault,
authority: params.user,
amount: quote.amount_in_for_vault,
}];
let output_transfers = vec![TransferHookTransfer {
source: output_vault,
destination: output_user_account,
authority: lp_vault_authority,
amount: quote.amount_out,
}];
trailing_accounts.extend(
resolve_transfer_hook_accounts_for_program(
rpc,
¶ms.input_mint,
input_context.transfer_hook_program.as_ref(),
&input_transfers,
)
.await?,
);
trailing_accounts.extend(
resolve_transfer_hook_accounts_for_program(
rpc,
¶ms.output_mint,
output_context.transfer_hook_program.as_ref(),
&output_transfers,
)
.await?,
);
let fee_transfers = if quote.protocol_fees > 0 {
vec![TransferHookTransfer {
source: lp_fee_vault,
destination: fee_vault,
authority: lp_fee_vault_authority,
amount: quote.protocol_fees,
}]
} else {
Vec::new()
};
trailing_accounts.extend(
resolve_transfer_hook_accounts_for_program(
rpc,
&global.fee_token_mint,
fee_context.transfer_hook_program.as_ref(),
&fee_transfers,
)
.await?,
);
}
if let Some(accounts) = ¶ms.remaining_accounts {
trailing_accounts.extend_from_slice(accounts);
}
let trailing_accounts = merge_account_metas(&trailing_accounts);
assert_no_remaining_signers(&trailing_accounts, &[params.user])?;
let remaining_accounts = if let Some(plan) = &treasury_plan {
let mut remaining = plan.remaining_accounts.clone();
remaining.extend(trailing_accounts);
remaining
} else {
let mut remaining = oracle_accounts;
remaining.extend(trailing_accounts);
assert_no_remaining_signers(&remaining, &[params.user])?;
merge_account_metas(&remaining)
};
let mut instruction_extras = treasury_plan
.as_ref()
.map_or_else(Vec::new, treasury_swap_account_metas);
instruction_extras.extend(remaining_accounts);
let accounts = SwapAccountKeys {
user: params.user,
pair: resolved_pair.pair_address,
program_authority,
liquidity_provider: params.liquidity_provider,
lp_vault_authority,
lp_fee_vault_authority,
input_token_mint_address: params.input_mint,
output_token_mint_address: params.output_mint,
input_token_user_token_account: input_user_account,
output_token_user_token_account: output_user_account,
input_token_vault_token_account: input_vault,
output_token_vault_token_account: output_vault,
global_config,
fee_token_mint_address: global.fee_token_mint,
lp_fee_token_account: lp_fee_vault,
fee_token_account: fee_vault,
input_config,
output_config,
fee_config,
input_lp_stable_config: if input.asset_type == AssetType::Stable {
derive_lp_stable_config(¶ms.input_mint, ¶ms.liquidity_provider, program_id).0
} else {
*program_id
},
output_lp_stable_config: if output.asset_type == AssetType::Stable {
derive_lp_stable_config(¶ms.output_mint, ¶ms.liquidity_provider, program_id).0
} else {
*program_id
},
lp_protocol_fee_config,
token_program_input: input_context.token_program,
token_program_output: output_context.token_program,
token_program_fee: fee_context.token_program,
remaining_accounts: instruction_extras.iter().map(|meta| meta.pubkey).collect(),
};
let args = SwapArgs {
amount,
min_amount_out: params.min_amount_out,
max_amount_in: params.max_amount_in,
swap_direction: resolved_pair.swap_direction,
swap_type: params.swap_type,
treasury_nav_account_count: treasury_plan
.as_ref()
.map_or(0, |plan| plan.nav_account_count),
treasury_apy_account_count: treasury_plan
.as_ref()
.map_or(0, |plan| plan.apy_account_count),
};
let instruction = create_swap_instruction(program_id, &accounts, &args, &instruction_extras)?;
Ok(BuildSwapInstructionResult {
instruction,
setup_instructions,
accounts,
onchain_direction: resolved_pair.swap_direction,
treasury_program_address: treasury_plan.map(|plan| plan.accounts.treasury_program),
has_protocol_fee_transfer,
})
}
pub async fn build_swap_transaction<R: Rpc + ?Sized>(
rpc: &R,
params: &SwapParams,
program_id: &Pubkey,
) -> Result<BuildSwapTransactionResult> {
let built = build_swap_instruction(rpc, params, program_id).await?;
let mut instructions = built.setup_instructions;
instructions.push(built.instruction);
let transaction = build_unsigned_transaction(rpc, ¶ms.user, &instructions).await?;
Ok(BuildSwapTransactionResult {
transaction,
accounts: built.accounts,
onchain_direction: built.onchain_direction,
})
}
fn treasury_swap_account_metas(plan: &TreasurySwapPlan) -> Vec<AccountMeta> {
let accounts = &plan.accounts;
vec![
AccountMeta::new_readonly(accounts.treasury_program, false),
AccountMeta::new_readonly(accounts.treasury_global_config, false),
AccountMeta::new_readonly(accounts.treasury_quote_asset_config, false),
AccountMeta::new_readonly(accounts.treasury_base_asset_config, false),
AccountMeta::new(accounts.treasury_user_position, false),
AccountMeta::new_readonly(accounts.treasury_vault_authority, false),
AccountMeta::new(accounts.treasury_mint, false),
AccountMeta::new(accounts.treasury_user_treasury_token_account, false),
AccountMeta::new(accounts.treasury_quote_asset_vault, false),
AccountMeta::new(accounts.treasury_base_asset_vault, false),
AccountMeta::new_readonly(accounts.treasury_latest_apy_entry, false),
AccountMeta::new_readonly(accounts.treasury_token_program, false),
AccountMeta::new_readonly(accounts.treasury_associated_token_program, false),
AccountMeta::new_readonly(accounts.treasury_system_program, false),
]
}
fn create_swap_instruction(
program_id: &Pubkey,
accounts: &SwapAccountKeys,
args: &SwapArgs,
remaining_accounts: &[AccountMeta],
) -> Result<Instruction> {
let input_is_quote = args.swap_direction == SwapDirection::QuoteToBase;
let orient = |input, output| {
if input_is_quote {
(input, output)
} else {
(output, input)
}
};
let (quote_mint, base_mint) = orient(
accounts.input_token_mint_address,
accounts.output_token_mint_address,
);
let (quote_user, base_user) = orient(
accounts.input_token_user_token_account,
accounts.output_token_user_token_account,
);
let (quote_vault, base_vault) = orient(
accounts.input_token_vault_token_account,
accounts.output_token_vault_token_account,
);
let (quote_config, base_config) = orient(accounts.input_config, accounts.output_config);
let (quote_stable, base_stable) = orient(
accounts.input_lp_stable_config,
accounts.output_lp_stable_config,
);
let (quote_program, base_program) =
orient(accounts.token_program_input, accounts.token_program_output);
Ok(SwapAccounts {
user: accounts.user,
pair: accounts.pair,
program_authority: accounts.program_authority,
liquidity_provider: accounts.liquidity_provider,
lp_vault_authority: accounts.lp_vault_authority,
lp_fee_vault_authority: accounts.lp_fee_vault_authority,
quote_token_mint_address: quote_mint,
base_token_mint_address: base_mint,
base_token_user_token_account: base_user,
quote_token_user_token_account: quote_user,
quote_token_vault_token_account: quote_vault,
base_token_vault_token_account: base_vault,
global_config: accounts.global_config,
fee_token_mint_address: accounts.fee_token_mint_address,
lp_fee_token_account: accounts.lp_fee_token_account,
fee_token_account: accounts.fee_token_account,
base_config,
quote_config,
fee_config: accounts.fee_config,
lp_stable_config_quote: (quote_stable != *program_id).then_some(quote_stable),
lp_stable_config_base: (base_stable != *program_id).then_some(base_stable),
lp_protocol_fee_config: accounts.lp_protocol_fee_config,
token_program_quote: quote_program,
token_program_base: base_program,
token_program_fee: accounts.token_program_fee,
}
.instruction(*program_id, args, remaining_accounts)?)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{
constants::{
ASSOCIATED_TOKEN_PROGRAM_ADDRESS, SPL_TOKEN_PROGRAM_ADDRESS, SYSTEM_PROGRAM_ADDRESS,
TOKEN_2022_PROGRAM_ADDRESS,
},
generated::{
swap::{AssetConfig, GlobalConfig, LpProtocolFeeConfig, Pair},
treasury,
},
pda::{
derive_pair, derive_treasury_apy_entry, derive_treasury_asset_config,
derive_treasury_global_config, derive_treasury_user_position, derive_treasury_vault,
derive_treasury_vault_authority,
},
rpc::{RpcFilter, SimulationResult},
types::{NavData, SwapType},
};
use async_trait::async_trait;
use solana_sdk::{account::Account, hash::Hash, transaction::VersionedTransaction};
use std::collections::HashMap;
const PROGRAM: Pubkey = Pubkey::new_from_array([200; 32]);
const USER: Pubkey = Pubkey::new_from_array([1; 32]);
const LP: Pubkey = Pubkey::new_from_array([2; 32]);
const QUOTE: Pubkey = Pubkey::new_from_array([3; 32]);
const BASE: Pubkey = Pubkey::new_from_array([4; 32]);
const FEE: Pubkey = Pubkey::new_from_array([5; 32]);
#[derive(Default)]
struct MemoryRpc {
accounts: HashMap<Pubkey, Account>,
forbidden_reads: Vec<Pubkey>,
}
#[async_trait]
impl Rpc for MemoryRpc {
async fn get_account(&self, address: &Pubkey) -> Result<Option<Account>> {
assert!(
!self.forbidden_reads.contains(address),
"unexpected ATA/vault probe: {address}"
);
Ok(self.accounts.get(address).cloned())
}
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!("hardcoded NAV must not query cluster time")
}
async fn get_block_time(&self, _: u64) -> Result<Option<i64>> {
panic!("hardcoded NAV must not query block time")
}
async fn get_latest_blockhash(&self) -> Result<Hash> {
Ok(Hash::new_from_array([70; 32]))
}
async fn get_transaction_logs(&self, _: &str) -> Result<Option<Vec<String>>> {
panic!("unexpected transaction query")
}
async fn simulate_transaction(&self, _: &VersionedTransaction) -> Result<SimulationResult> {
panic!("builder must not simulate")
}
}
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 mint(hook: Option<Pubkey>) -> Vec<u8> {
let mut data = vec![0; 82];
data[44] = 6;
data[45] = 1;
if let Some(hook) = hook {
data.resize(166, 0);
data[165] = 1;
data.extend(14_u16.to_le_bytes());
data.extend(64_u16.to_le_bytes());
data.extend([0; 32]);
data.extend(hook.to_bytes());
}
data
}
fn config(mint_address: Pubkey, asset_type: AssetType) -> AssetConfig {
AssetConfig {
mint_address,
nav_data: vec![NavData::Hardcoded {
hardcoded_price: 1_000_000_000,
price_decimals: 9,
}],
price_difference_bps: 100,
paused: false,
version: 1,
asset_type,
used_in_pairs_count: 1,
bump: 255,
padding: vec![],
}
}
fn fixture() -> (MemoryRpc, SwapParams) {
let pair = Pair {
redemption_fee_bps: 0,
discount_rate_bps: 0,
quote_token_mint_address: QUOTE,
base_token_mint_address: BASE,
liquidity_provider: LP,
paused: false,
bump: 255,
padding: [0; 128],
};
let global = GlobalConfig {
admin: pk(6),
fee_wallet: pk(7),
protocol_fees_bps: 100,
paused: false,
pending_new_admin: None,
bump: 255,
fee_token_mint: FEE,
spread_protocol_fees_bps: 0,
padding: [0; 94],
};
let mut rpc = MemoryRpc::default();
rpc.accounts.insert(
derive_pair(&LP, "E, &BASE, &PROGRAM).0,
account(PROGRAM, pair.encode().unwrap()),
);
rpc.accounts.insert(
derive_global_config(&PROGRAM).0,
account(PROGRAM, global.encode().unwrap()),
);
for (mint_address, asset_type, token_program) in [
(QUOTE, AssetType::Stable, SPL_TOKEN_PROGRAM_ADDRESS),
(BASE, AssetType::Rwa, TOKEN_2022_PROGRAM_ADDRESS),
(FEE, AssetType::Stable, SPL_TOKEN_PROGRAM_ADDRESS),
] {
rpc.accounts
.insert(mint_address, account(token_program, mint(None)));
rpc.accounts.insert(
derive_asset_config(&mint_address, &PROGRAM).0,
account(PROGRAM, config(mint_address, asset_type).encode().unwrap()),
);
rpc.forbidden_reads
.push(derive_associated_token_account(&USER, &mint_address, &token_program).0);
rpc.forbidden_reads
.push(derive_vault(&LP, &mint_address, &token_program, &PROGRAM).0);
}
(
rpc,
SwapParams {
user: USER,
liquidity_provider: LP,
input_mint: QUOTE,
output_mint: BASE,
pair_address: None,
amount: 100_000_000,
swap_type: SwapType::ExactIn,
min_amount_out: None,
max_amount_in: None,
user_input_token_account: None,
user_output_token_account: None,
auto_create_ata: Some(false),
remaining_accounts: None,
},
)
}
#[tokio::test]
async fn swaps_reject_explicit_and_runtime_elevated_remaining_signers() {
let (rpc, mut params) = fixture();
for extra in [
AccountMeta::new_readonly(pk(80), true),
AccountMeta::new_readonly(USER, false),
] {
params.remaining_accounts = Some(vec![extra]);
assert!(matches!(
build_swap_instruction(&rpc, ¶ms, &PROGRAM).await,
Err(SdkError::InvalidInput(_))
));
}
}
fn set_fee_override(rpc: &mut MemoryRpc, issuer: u16, spread: u16, treasury_enabled: bool) {
let config = LpProtocolFeeConfig {
liquidity_provider: LP,
protocol_fees_bps: issuer,
spread_protocol_fees_bps: spread,
bump: 255,
treasury_enabled,
padding: [0; 128],
};
rpc.accounts.insert(
derive_lp_protocol_fee_config(&LP, &PROGRAM).0,
account(PROGRAM, config.encode().unwrap()),
);
}
#[tokio::test]
async fn reverse_pair_uses_stored_order_optional_stables_and_native_token_domains() {
let (rpc, mut params) = fixture();
params.input_mint = BASE;
params.output_mint = QUOTE;
params.swap_type = SwapType::ExactOut;
params.min_amount_out = Some(0);
params.max_amount_in = Some(200_000_000);
let result = build_swap_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap();
let keys = &result.accounts;
assert_eq!(result.onchain_direction, SwapDirection::BaseToQuote);
assert_eq!(keys.input_lp_stable_config, PROGRAM);
assert_eq!(
keys.output_lp_stable_config,
derive_lp_stable_config("E, &LP, &PROGRAM).0
);
let expected = [
USER,
derive_pair(&LP, "E, &BASE, &PROGRAM).0,
derive_program_authority(&PROGRAM).0,
LP,
derive_vault_authority(&LP, &PROGRAM).0,
derive_lp_fee_vault_authority(&LP, &PROGRAM).0,
QUOTE,
BASE,
derive_associated_token_account(&USER, &BASE, &TOKEN_2022_PROGRAM_ADDRESS).0,
derive_associated_token_account(&USER, "E, &SPL_TOKEN_PROGRAM_ADDRESS).0,
derive_vault(&LP, "E, &SPL_TOKEN_PROGRAM_ADDRESS, &PROGRAM).0,
derive_vault(&LP, &BASE, &TOKEN_2022_PROGRAM_ADDRESS, &PROGRAM).0,
derive_global_config(&PROGRAM).0,
FEE,
derive_lp_fee_vault(&FEE, &LP, &SPL_TOKEN_PROGRAM_ADDRESS, &PROGRAM).0,
derive_fee_vault(&FEE, &SPL_TOKEN_PROGRAM_ADDRESS, &PROGRAM).0,
derive_asset_config(&BASE, &PROGRAM).0,
derive_asset_config("E, &PROGRAM).0,
derive_asset_config(&FEE, &PROGRAM).0,
derive_lp_stable_config("E, &LP, &PROGRAM).0,
PROGRAM,
derive_lp_protocol_fee_config(&LP, &PROGRAM).0,
SPL_TOKEN_PROGRAM_ADDRESS,
TOKEN_2022_PROGRAM_ADDRESS,
SPL_TOKEN_PROGRAM_ADDRESS,
];
let expected_metas: Vec<_> = expected
.into_iter()
.enumerate()
.map(|(index, address)| AccountMeta {
pubkey: address,
is_signer: index == 0,
is_writable: [0, 4, 8, 9, 10, 11, 14, 15].contains(&index),
})
.collect();
assert_eq!(result.instruction.accounts, expected_metas);
let mut data = vec![248, 198, 158, 145, 225, 117, 135, 200];
data.extend(100_000_000_u64.to_le_bytes());
data.push(1);
data.extend(0_u64.to_le_bytes());
data.push(1);
data.extend(200_000_000_u64.to_le_bytes());
data.extend([1, 1, 0, 0]);
assert_eq!(result.instruction.data, data);
assert!(result.setup_instructions.is_empty());
assert!(result.has_protocol_fee_transfer);
assert_eq!(result.treasury_program_address, None);
}
#[tokio::test]
async fn ata_defaults_create_input_then_output_and_overrides_never_probe() {
let (mut rpc, mut params) = fixture();
rpc.forbidden_reads.clear();
params.auto_create_ata = None;
let result = build_swap_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap();
assert_eq!(result.setup_instructions.len(), 2);
for (instruction, address) in result.setup_instructions.iter().zip([
result.accounts.input_token_user_token_account,
result.accounts.output_token_user_token_account,
]) {
assert_eq!(instruction.program_id, ASSOCIATED_TOKEN_PROGRAM_ADDRESS);
assert_eq!(instruction.accounts[1].pubkey, address);
assert_eq!(instruction.data, vec![1]);
}
rpc.forbidden_reads = vec![
pk(60),
pk(61),
result.accounts.input_token_user_token_account,
result.accounts.output_token_user_token_account,
];
params.user_input_token_account = Some(pk(60));
params.user_output_token_account = Some(pk(61));
let overridden = build_swap_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap();
assert!(overridden.setup_instructions.is_empty());
assert_eq!(overridden.instruction.accounts[9].pubkey, pk(60));
assert_eq!(overridden.instruction.accounts[8].pubkey, pk(61));
}
#[tokio::test]
async fn lp_fee_override_preserves_zero_spread_presence_and_owner_failures() {
let (mut rpc, params) = fixture();
set_fee_override(&mut rpc, 0, 0, false);
assert!(
!build_swap_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap()
.has_protocol_fee_transfer
);
set_fee_override(&mut rpc, 0, 1, false);
assert!(
build_swap_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap()
.has_protocol_fee_transfer
);
let address = derive_lp_protocol_fee_config(&LP, &PROGRAM).0;
rpc.accounts.get_mut(&address).unwrap().owner = pk(99);
assert!(matches!(
build_swap_instruction(&rpc, ¶ms, &PROGRAM).await,
Err(SdkError::InvalidAccount(_))
));
rpc.accounts.insert(address, account(PROGRAM, vec![0; 8]));
assert!(build_swap_instruction(&rpc, ¶ms, &PROGRAM)
.await
.is_err());
}
fn enable_hook(rpc: &mut MemoryRpc, mint_address: Pubkey, hook: Pubkey) -> Pubkey {
rpc.accounts.insert(
mint_address,
account(TOKEN_2022_PROGRAM_ADDRESS, mint(Some(hook))),
);
let mut packed_seeds = [0; 32];
packed_seeds[..9].copy_from_slice(&[3, 0, 3, 2, 3, 3, 2, 8, 8]);
let mut data = vec![105, 37, 101, 197, 75, 251, 102, 26];
data.extend(39_u32.to_le_bytes());
data.extend(1_u32.to_le_bytes());
data.push(1);
data.extend(packed_seeds);
data.extend([0, 1]);
let validation =
Pubkey::find_program_address(&[b"extra-account-metas", mint_address.as_ref()], &hook).0;
rpc.accounts.insert(validation, account(hook, data));
validation
}
fn transfer_pda(
hook: &Pubkey,
source: &Pubkey,
destination: &Pubkey,
authority: &Pubkey,
amount: u64,
) -> Pubkey {
Pubkey::find_program_address(
&[
source.as_ref(),
destination.as_ref(),
authority.as_ref(),
&amount.to_le_bytes(),
],
hook,
)
.0
}
#[tokio::test]
async fn hooks_use_input_output_and_fee_transfers_in_order_and_merge_privileges() {
let (mut rpc, mut params) = fixture();
let input_validation = enable_hook(&mut rpc, QUOTE, pk(90));
let output_validation = enable_hook(&mut rpc, BASE, pk(91));
let fee_validation = enable_hook(&mut rpc, FEE, pk(92));
let input_vault = derive_vault(&LP, "E, &TOKEN_2022_PROGRAM_ADDRESS, &PROGRAM).0;
let input_user =
derive_associated_token_account(&USER, "E, &TOKEN_2022_PROGRAM_ADDRESS).0;
let input_hook = transfer_pda(&pk(90), &input_user, &input_vault, &USER, 100_000_000);
params.remaining_accounts = Some(vec![
AccountMeta::new_readonly(input_hook, false),
AccountMeta::new_readonly(pk(93), false),
]);
let built = build_swap_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap();
let keys = &built.accounts;
let output_hook = transfer_pda(
&pk(91),
&keys.output_token_vault_token_account,
&keys.output_token_user_token_account,
&keys.lp_vault_authority,
100_000_000,
);
let fee_hook = transfer_pda(
&pk(92),
&keys.lp_fee_token_account,
&keys.fee_token_account,
&keys.lp_fee_vault_authority,
1_000_000,
);
assert_eq!(
&built.instruction.accounts[25..],
&[
AccountMeta::new(input_hook, false),
AccountMeta::new_readonly(pk(90), false),
AccountMeta::new_readonly(input_validation, false),
AccountMeta::new(output_hook, false),
AccountMeta::new_readonly(pk(91), false),
AccountMeta::new_readonly(output_validation, false),
AccountMeta::new(fee_hook, false),
AccountMeta::new_readonly(pk(92), false),
AccountMeta::new_readonly(fee_validation, false),
AccountMeta::new_readonly(pk(93), false),
]
);
set_fee_override(&mut rpc, 0, 0, false);
rpc.accounts.remove(&fee_validation);
let no_fee = build_swap_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap();
assert!(!no_fee.accounts.remaining_accounts.contains(&pk(92)));
assert!(!no_fee.has_protocol_fee_transfer);
}
#[tokio::test]
async fn treasury_keeps_fixed_nav_apy_slices_and_rejects_treasury_hook_transfers() {
let (mut rpc, mut params) = fixture();
rpc.forbidden_reads.clear();
params.amount = 100;
set_fee_override(&mut rpc, 0, 0, true);
for mint_address in [QUOTE, BASE] {
rpc.accounts.insert(
mint_address,
account(TOKEN_2022_PROGRAM_ADDRESS, mint(None)),
);
}
let shared_nav = pk(80);
let treasury_nav = pk(81);
let fixed_nav = |address| NavData::U64FixedAddress {
nav_account_address: address,
nav_price_offset: 0,
price_decimals: 9,
};
let mut quote_config = config(QUOTE, AssetType::Stable);
quote_config.nav_data = vec![fixed_nav(shared_nav)];
rpc.accounts.insert(
derive_asset_config("E, &PROGRAM).0,
account(PROGRAM, quote_config.encode().unwrap()),
);
rpc.accounts.insert(
derive_asset_config(&BASE, &PROGRAM).0,
account(PROGRAM, config(BASE, AssetType::Stable).encode().unwrap()),
);
rpc.accounts.insert(
shared_nav,
account(pk(82), 1_000_000_000_u64.to_le_bytes().to_vec()),
);
rpc.accounts.insert(
treasury_nav,
account(pk(82), 1_000_000_000_u64.to_le_bytes().to_vec()),
);
let treasury_program = TREASURY_PROGRAM_ADDRESS_DEVNET;
let owner = derive_vault_authority(&LP, &PROGRAM).0;
let treasury_authority = derive_treasury_vault_authority(&treasury_program).0;
let latest_apy = derive_treasury_apy_entry(172_800, &treasury_program).0;
let historical_apy = derive_treasury_apy_entry(86_400, &treasury_program).0;
let treasury_mint = pk(83);
let treasury_global = treasury::GlobalConfig {
manager: pk(84),
pending_manager: None,
treasury_mint,
oracle_authority: pk(85),
global_yield_index_fp: 1_000_000_000_000_000_000,
last_yield_update_ts: 259_200,
latest_apy_entry: latest_apy,
apy_history_retention_duration: 691_200,
management_fee_bps: 100,
max_apy_bps: 10_000,
max_unposted_yield_seconds: 604_800,
supported_asset_count: 2,
max_pending_deposit_slots: 1,
paused: false,
bump: 255,
};
rpc.accounts.insert(
derive_treasury_global_config(&treasury_program).0,
account(treasury_program, treasury_global.encode().unwrap()),
);
rpc.accounts.insert(
treasury_mint,
account(SPL_TOKEN_PROGRAM_ADDRESS, mint(None)),
);
for mint_address in [QUOTE, BASE] {
let config = treasury::AssetConfig {
asset_mint: mint_address,
asset_type: AssetType::Stable,
paused: false,
nav_data: vec![fixed_nav(shared_nav), fixed_nav(treasury_nav)],
price_difference_bps: 100,
bump: 255,
};
rpc.accounts.insert(
derive_treasury_asset_config(&mint_address, &treasury_program).0,
account(treasury_program, config.encode().unwrap()),
);
}
for day_start_ts in [86_400, 172_800] {
let entry = treasury::ApyEntry {
day_start_ts,
apy_bps: 1_000,
global_yield_index_before: 1_000_000_000_000_000_000,
bump: 255,
};
rpc.accounts.insert(
derive_treasury_apy_entry(day_start_ts, &treasury_program).0,
account(treasury_program, entry.encode().unwrap()),
);
}
let position = treasury::UserPosition {
owner,
principal_amount: 0,
accumulated_yield: 0,
global_yield_index_on_last_update: 1_000_000_000_000_000_000,
pending_deposit_count: 1,
max_pending_deposits: 50,
bump: 255,
_padding: [0; 3],
pending_deposits: std::array::from_fn(|_| treasury::PendingDeposit {
amount_deposited_fp: 1_000_000_000_000_000_000,
deposit_ts: 0,
asset_type: AssetType::Stable,
}),
};
rpc.accounts.insert(
derive_treasury_user_position(&owner, &treasury_program).0,
account(treasury_program, position.encode().unwrap()),
);
let input_vault = derive_vault(&LP, "E, &TOKEN_2022_PROGRAM_ADDRESS, &PROGRAM).0;
let output_vault = derive_vault(&LP, &BASE, &TOKEN_2022_PROGRAM_ADDRESS, &PROGRAM).0;
for (vault, amount) in [(input_vault, 999_900_u64), (output_vault, 11)] {
let mut data = vec![0; 165];
data[64..72].copy_from_slice(&amount.to_le_bytes());
data[108] = 1;
rpc.accounts
.insert(vault, account(TOKEN_2022_PROGRAM_ADDRESS, data));
}
let treasury_quote_vault =
derive_treasury_vault("E, &TOKEN_2022_PROGRAM_ADDRESS, &treasury_program).0;
let treasury_base_vault =
derive_treasury_vault(&BASE, &TOKEN_2022_PROGRAM_ADDRESS, &treasury_program).0;
params.remaining_accounts = Some(vec![
AccountMeta::new(shared_nav, false),
AccountMeta::new_readonly(pk(93), false),
]);
let built = build_swap_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap();
let keys = &built.accounts;
let fixed_addresses = [
treasury_program,
derive_treasury_global_config(&treasury_program).0,
derive_treasury_asset_config("E, &treasury_program).0,
derive_treasury_asset_config(&BASE, &treasury_program).0,
derive_treasury_user_position(&owner, &treasury_program).0,
treasury_authority,
treasury_mint,
derive_associated_token_account(&owner, &treasury_mint, &SPL_TOKEN_PROGRAM_ADDRESS).0,
treasury_quote_vault,
treasury_base_vault,
latest_apy,
SPL_TOKEN_PROGRAM_ADDRESS,
ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
SYSTEM_PROGRAM_ADDRESS,
];
let mut expected: Vec<_> = fixed_addresses
.into_iter()
.enumerate()
.map(|(index, pubkey)| AccountMeta {
pubkey,
is_signer: false,
is_writable: [4, 6, 7, 8, 9].contains(&index),
})
.collect();
expected.extend([
AccountMeta::new_readonly(shared_nav, false),
AccountMeta::new_readonly(treasury_nav, false),
AccountMeta::new_readonly(historical_apy, false),
AccountMeta::new(shared_nav, false),
AccountMeta::new_readonly(pk(93), false),
]);
assert_eq!(&built.instruction.accounts[25..], expected.as_slice());
assert_eq!(
keys.remaining_accounts,
expected.iter().map(|meta| meta.pubkey).collect::<Vec<_>>()
);
let args = SwapArgs::decode(&built.instruction.data).unwrap();
assert_eq!(
(
args.treasury_nav_account_count,
args.treasury_apy_account_count
),
(2, 1)
);
assert_eq!(built.treasury_program_address, Some(treasury_program));
assert!(!built.has_protocol_fee_transfer);
rpc.accounts.get_mut(&output_vault).unwrap().data[64..72]
.copy_from_slice(&100_u64.to_le_bytes());
rpc.accounts.remove(&historical_apy);
rpc.accounts.remove(&latest_apy);
let idle = build_swap_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap();
let args = SwapArgs::decode(&idle.instruction.data).unwrap();
assert_eq!(args.treasury_apy_account_count, 0);
let input_validation = enable_hook(&mut rpc, QUOTE, pk(90));
assert!(matches!(
build_swap_instruction(&rpc, ¶ms, &PROGRAM).await,
Err(SdkError::InvalidInput(message)) if message.contains("Treasury-backed transfer-hook swap"),
));
rpc.accounts.remove(&input_validation);
rpc.accounts
.insert(QUOTE, account(TOKEN_2022_PROGRAM_ADDRESS, mint(None)));
let output_validation = enable_hook(&mut rpc, BASE, pk(91));
assert!(matches!(
build_swap_instruction(&rpc, ¶ms, &PROGRAM).await,
Err(SdkError::InvalidInput(message)) if message.contains("Treasury-backed transfer-hook swap"),
));
let paused_base = treasury::AssetConfig {
asset_mint: BASE,
asset_type: AssetType::Stable,
paused: true,
nav_data: vec![fixed_nav(shared_nav), fixed_nav(treasury_nav)],
price_difference_bps: 100,
bump: 255,
};
rpc.accounts.insert(
derive_treasury_asset_config(&BASE, &treasury_program).0,
account(treasury_program, paused_base.encode().unwrap()),
);
let hooked = build_swap_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap();
let keys = &hooked.accounts;
assert!(keys.remaining_accounts.contains(&transfer_pda(
&pk(91),
&output_vault,
&keys.output_token_user_token_account,
&owner,
100,
)));
assert!(keys.remaining_accounts.contains(&output_validation));
}
#[tokio::test]
async fn non_treasury_merges_oracle_privileges_without_fetching_unneeded_prices() {
let (mut rpc, mut params) = fixture();
let oracle = pk(80);
let mut quote = config(QUOTE, AssetType::Stable);
quote.nav_data = vec![NavData::U64FixedAddress {
nav_account_address: oracle,
nav_price_offset: 0,
price_decimals: 9,
}];
rpc.accounts.insert(
derive_asset_config("E, &PROGRAM).0,
account(PROGRAM, quote.encode().unwrap()),
);
rpc.forbidden_reads.push(oracle);
params.remaining_accounts = Some(vec![
AccountMeta::new(oracle, false),
AccountMeta::new_readonly(pk(81), false),
]);
let built = build_swap_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap();
assert_eq!(
&built.instruction.accounts[25..],
&[
AccountMeta::new(oracle, false),
AccountMeta::new_readonly(pk(81), false),
]
);
}
#[tokio::test]
async fn ata_setup_cannot_supply_missing_hook_seed_data_but_existing_override_can() {
let (mut rpc, mut params) = fixture();
rpc.forbidden_reads.clear();
params.auto_create_ata = Some(true);
let hook = pk(91);
let validation = enable_hook(&mut rpc, BASE, hook);
let data = &mut rpc.accounts.get_mut(&validation).unwrap().data;
data[17..49].fill(0);
data[17..21].copy_from_slice(&[4, 2, 0, 1]);
let destination =
derive_associated_token_account(&USER, &BASE, &TOKEN_2022_PROGRAM_ADDRESS).0;
let error = build_swap_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap_err();
match error {
SdkError::InvalidAccount(message) => {
assert!(message.contains(&destination.to_string()))
}
other => panic!("expected missing transfer-hook account data, received {other}"),
}
params.user_output_token_account = Some(pk(63));
let mut recipient_data = vec![0; 165];
recipient_data[0] = 7;
rpc.accounts
.insert(pk(63), account(TOKEN_2022_PROGRAM_ADDRESS, recipient_data));
let built = build_swap_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap();
assert_eq!(built.instruction.accounts[8].pubkey, pk(63));
assert_eq!(
&built.instruction.accounts[25..],
&[
AccountMeta::new(Pubkey::find_program_address(&[&[7]], &hook).0, false),
AccountMeta::new_readonly(hook, false),
AccountMeta::new_readonly(validation, false),
]
);
}
}