use std::collections::HashMap;
use solana_sdk::pubkey::Pubkey;
use crate::{
accounts::{decode_asset_config, decode_lp_protocol_fee_config, fetch_swap_state},
constants::PYTH_RECEIVER_PROGRAM_ADDRESS,
error::{Result, SdkError},
math::{
calculate_protocol_fee_amount, calculate_spread_protocol_fee_rate, calculate_swap_results,
},
oracle::{calculate_nav, resolve_oracle_accounts, resolve_pyth_oracle_accounts},
pda::{derive_asset_config, derive_lp_protocol_fee_config},
rpc::Rpc,
token::read_mint_decimals,
types::{
AssetConfigAccount, AssetType, GlobalConfigAccount, LpProtocolFeeConfigAccount, NavData,
PairAccount, SwapDirection, SwapParams, SwapQuote,
},
validation::assert_positive_amount,
};
pub const CLUSTER_TIMESTAMP_LOOKBACK_SLOTS: u64 = 25;
#[derive(Debug)]
pub struct SwapQuoteResolvedInputs<'a> {
pub global_config: &'a GlobalConfigAccount,
pub lp_protocol_fee_config: Option<&'a LpProtocolFeeConfigAccount>,
pub pair: &'a PairAccount,
pub onchain_direction: SwapDirection,
pub input_config: &'a AssetConfigAccount,
pub output_config: &'a AssetConfigAccount,
pub fee_config: &'a AssetConfigAccount,
pub input_decimals: u8,
pub output_decimals: u8,
pub fee_token_decimals: u8,
pub oracle_account_data_map: &'a HashMap<Pubkey, Vec<u8>>,
pub current_unix_timestamp: Option<i64>,
}
pub fn quote_requires_cluster_timestamp(configs: &[&AssetConfigAccount]) -> bool {
configs
.iter()
.any(|config| nav_data_requires_timestamp(&config.nav_data))
}
pub(crate) fn nav_data_requires_timestamp(nav_data: &[NavData]) -> bool {
nav_data
.iter()
.any(|nav| matches!(nav, NavData::PythPush { .. } | NavData::RedstonePush { .. }))
}
pub async fn fetch_cluster_unix_timestamp<R: Rpc + ?Sized>(rpc: &R) -> Result<i64> {
let slot = rpc.get_slot().await?;
let min_slot = slot.saturating_sub(CLUSTER_TIMESTAMP_LOOKBACK_SLOTS);
for candidate in (min_slot..=slot).rev() {
if let Some(timestamp) = rpc.get_block_time(candidate).await? {
return Ok(timestamp);
}
}
Err(SdkError::Rpc(format!(
"Unable to fetch cluster block time for slots {slot} through {min_slot}"
)))
}
pub async fn fetch_oracle_account_data_map<R: Rpc + ?Sized>(
rpc: &R,
addresses: &[Pubkey],
pyth_addresses: &[Pubkey],
) -> Result<HashMap<Pubkey, Vec<u8>>> {
if addresses.is_empty() {
return Ok(HashMap::new());
}
let accounts = rpc.get_multiple_accounts(addresses).await?;
let mut data = HashMap::with_capacity(accounts.len());
for (address, account) in addresses.iter().zip(accounts) {
let Some(account) = account else {
continue;
};
if pyth_addresses.contains(address) && account.owner != PYTH_RECEIVER_PROGRAM_ADDRESS {
return Err(SdkError::Oracle(format!(
"Invalid Pyth account owner for {address}: expected {PYTH_RECEIVER_PROGRAM_ADDRESS}"
)));
}
data.insert(*address, account.data);
}
Ok(data)
}
pub fn compute_swap_quote_from_resolved_inputs(
params: &SwapParams,
inputs: &SwapQuoteResolvedInputs<'_>,
amount: u64,
) -> Result<SwapQuote> {
let input_is_quote = inputs.onchain_direction == SwapDirection::QuoteToBase;
let pair_fee_bps = if inputs.input_config.asset_type == AssetType::Rwa
&& inputs.output_config.asset_type == AssetType::Rwa
{
inputs
.pair
.redemption_fee_bps
.checked_add(inputs.pair.discount_rate_bps)
.ok_or(SdkError::MathOverflow)?
} else if input_is_quote {
inputs.pair.redemption_fee_bps
} else {
inputs.pair.discount_rate_bps
};
let input_nav = calculate_nav(
&inputs.input_config.nav_data,
inputs.oracle_account_data_map,
inputs.input_config.price_difference_bps,
inputs.current_unix_timestamp,
)?;
let output_nav = calculate_nav(
&inputs.output_config.nav_data,
inputs.oracle_account_data_map,
inputs.output_config.price_difference_bps,
inputs.current_unix_timestamp,
)?;
let fee_token_nav = calculate_nav(
&inputs.fee_config.nav_data,
inputs.oracle_account_data_map,
inputs.fee_config.price_difference_bps,
inputs.current_unix_timestamp,
)?;
if input_nav == 0 || output_nav == 0 || fee_token_nav == 0 {
return Err(SdkError::Oracle("Invalid NAV".into()));
}
let (base_nav, quote_nav, quote_decimals) = if input_is_quote {
(output_nav, input_nav, inputs.input_decimals)
} else {
(input_nav, output_nav, inputs.output_decimals)
};
let (protocol_fees_bps, spread_protocol_fees_bps) = inputs
.lp_protocol_fee_config
.map(|config| (config.protocol_fees_bps, config.spread_protocol_fees_bps))
.unwrap_or((
inputs.global_config.protocol_fees_bps,
inputs.global_config.spread_protocol_fees_bps,
));
let result = calculate_swap_results(
amount,
inputs.input_decimals,
inputs.output_decimals,
inputs.onchain_direction,
params.swap_type,
base_nav,
quote_nav,
pair_fee_bps,
calculate_spread_protocol_fee_rate(
inputs.pair.redemption_fee_bps,
inputs.pair.discount_rate_bps,
spread_protocol_fees_bps,
)?,
)?;
let issuer_protocol_fees = calculate_protocol_fee_amount(
result.protocol_fee_basis,
quote_decimals,
inputs.fee_token_decimals,
quote_nav,
fee_token_nav,
protocol_fees_bps,
)?;
let spread_protocol_fees = calculate_protocol_fee_amount(
result.protocol_fees,
quote_decimals,
inputs.fee_token_decimals,
quote_nav,
fee_token_nav,
10_000,
)?;
let protocol_fees = issuer_protocol_fees
.checked_add(spread_protocol_fees)
.ok_or(SdkError::MathOverflow)?;
Ok(SwapQuote {
amount_in: result.amount_in_for_vault,
amount_out: result.amount_out,
protocol_fees,
issuer_protocol_fees,
spread_protocol_fees,
discount_amount: result.discount_amount,
amount_in_for_vault: result.amount_in_for_vault,
input_nav,
output_nav,
fee_token_mint: inputs.global_config.fee_token_mint,
fee_token_nav,
})
}
pub async fn compute_swap_quote<R: Rpc + ?Sized>(
rpc: &R,
params: &SwapParams,
program_id: &Pubkey,
) -> Result<SwapQuote> {
let amount = assert_positive_amount(params.amount, "amount")?;
let state = fetch_swap_state(
rpc,
¶ms.input_mint,
¶ms.output_mint,
¶ms.liquidity_provider,
program_id,
params.pair_address.as_ref(),
)
.await?;
let fee_config_address = derive_asset_config(&state.global_config.fee_token_mint, program_id).0;
let lp_fee_config_address =
derive_lp_protocol_fee_config(¶ms.liquidity_provider, program_id).0;
let addresses = [
params.input_mint,
params.output_mint,
state.global_config.fee_token_mint,
fee_config_address,
lp_fee_config_address,
];
let accounts = rpc.get_multiple_accounts(&addresses).await?;
let required = |index: usize| {
accounts
.get(index)
.and_then(Option::as_ref)
.ok_or(SdkError::AccountNotFound(addresses[index]))
};
let input_decimals = read_mint_decimals(&required(0)?.data)?;
let output_decimals = read_mint_decimals(&required(1)?.data)?;
let fee_token_decimals = read_mint_decimals(&required(2)?.data)?;
let fee_config_info = required(3)?;
if fee_config_info.owner != *program_id {
return Err(SdkError::InvalidAccount(format!(
"Account {fee_config_address} is not owned by {program_id}"
)));
}
let fee_config = decode_asset_config(&fee_config_info.data)?;
let lp_protocol_fee_config = accounts
.get(4)
.and_then(Option::as_ref)
.map(|account| {
if account.owner != *program_id {
return Err(SdkError::InvalidAccount(format!(
"Account {lp_fee_config_address} is not owned by {program_id}"
)));
}
decode_lp_protocol_fee_config(&account.data)
})
.transpose()?;
let configs = [&state.input_config, &state.output_config, &fee_config];
let oracle_addresses: Vec<Pubkey> = resolve_oracle_accounts(&configs)
.into_iter()
.map(|account| account.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
};
compute_swap_quote_from_resolved_inputs(
params,
&SwapQuoteResolvedInputs {
global_config: &state.global_config,
lp_protocol_fee_config: lp_protocol_fee_config.as_ref(),
pair: &state.pair,
onchain_direction: state.onchain_direction,
input_config: &state.input_config,
output_config: &state.output_config,
fee_config: &fee_config,
input_decimals,
output_decimals,
fee_token_decimals,
oracle_account_data_map: &oracle_account_data_map,
current_unix_timestamp,
},
amount,
)
}
#[cfg(test)]
pub(crate) mod test_support {
use parking_lot::Mutex;
use async_trait::async_trait;
use solana_sdk::{account::Account, hash::Hash, transaction::VersionedTransaction};
use super::*;
use crate::{
constants::SPL_TOKEN_PROGRAM_ADDRESS,
pda::{derive_global_config, derive_lp_stable_config, derive_pair},
rpc::{RpcFilter, SimulationResult},
types::{LpStableConfigAccount, SwapType},
};
pub(crate) struct Fixture {
pub program: Pubkey,
pub params: SwapParams,
pub global: GlobalConfigAccount,
pub pair: PairAccount,
pub input: AssetConfigAccount,
pub output: AssetConfigAccount,
pub fee: AssetConfigAccount,
pub lp_fee: Option<LpProtocolFeeConfigAccount>,
pub decimals: [u8; 3],
pub oracles: HashMap<Pubkey, Vec<u8>>,
}
pub(crate) fn asset(mint: Pubkey, nav: u64, asset_type: AssetType) -> AssetConfigAccount {
AssetConfigAccount {
mint_address: mint,
nav_data: vec![NavData::Hardcoded {
hardcoded_price: nav,
price_decimals: 9,
}],
price_difference_bps: 100,
paused: false,
version: 1,
asset_type,
used_in_pairs_count: 1,
bump: 255,
padding: vec![],
}
}
impl Fixture {
pub(crate) fn new() -> Self {
let input_mint = Pubkey::new_from_array([3; 32]);
let output_mint = Pubkey::new_from_array([4; 32]);
let fee_token_mint = Pubkey::new_from_array([5; 32]);
let liquidity_provider = Pubkey::new_from_array([2; 32]);
Self {
program: Pubkey::new_from_array([9; 32]),
params: SwapParams {
user: Pubkey::new_from_array([1; 32]),
liquidity_provider,
input_mint,
output_mint,
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: None,
remaining_accounts: None,
},
global: GlobalConfigAccount {
admin: Pubkey::default(),
fee_wallet: Pubkey::default(),
protocol_fees_bps: 0,
spread_protocol_fees_bps: 0,
paused: false,
pending_new_admin: None,
bump: 255,
fee_token_mint,
padding: [0; 94],
},
pair: PairAccount {
redemption_fee_bps: 0,
discount_rate_bps: 0,
quote_token_mint_address: input_mint,
base_token_mint_address: output_mint,
liquidity_provider,
paused: false,
bump: 255,
padding: [0; 128],
},
input: asset(input_mint, 1_000_000_000, AssetType::Stable),
output: asset(output_mint, 1_000_000_000, AssetType::Rwa),
fee: asset(fee_token_mint, 1_000_000_000, AssetType::Stable),
lp_fee: None,
decimals: [6; 3],
oracles: HashMap::new(),
}
}
pub(crate) fn direction(&self) -> SwapDirection {
if self.params.input_mint == self.pair.quote_token_mint_address {
SwapDirection::QuoteToBase
} else {
SwapDirection::BaseToQuote
}
}
pub(crate) fn reverse(&mut self) {
std::mem::swap(&mut self.params.input_mint, &mut self.params.output_mint);
std::mem::swap(&mut self.input, &mut self.output);
self.decimals.swap(0, 1);
}
pub(crate) fn inputs(&self) -> SwapQuoteResolvedInputs<'_> {
SwapQuoteResolvedInputs {
global_config: &self.global,
lp_protocol_fee_config: self.lp_fee.as_ref(),
pair: &self.pair,
onchain_direction: self.direction(),
input_config: &self.input,
output_config: &self.output,
fee_config: &self.fee,
input_decimals: self.decimals[0],
output_decimals: self.decimals[1],
fee_token_decimals: self.decimals[2],
oracle_account_data_map: &self.oracles,
current_unix_timestamp: None,
}
}
pub(crate) fn quote(&self) -> Result<SwapQuote> {
compute_swap_quote_from_resolved_inputs(
&self.params,
&self.inputs(),
self.params.amount,
)
}
pub(crate) fn rpc(&self) -> TestRpc {
let mut accounts = HashMap::new();
let account = |data| Account {
lamports: 1,
data,
owner: self.program,
executable: false,
rent_epoch: 0,
};
accounts.insert(
derive_global_config(&self.program).0,
account(self.global.encode().unwrap()),
);
accounts.insert(
derive_pair(
&self.params.liquidity_provider,
&self.pair.quote_token_mint_address,
&self.pair.base_token_mint_address,
&self.program,
)
.0,
account(self.pair.encode().unwrap()),
);
for (config, decimals) in [&self.input, &self.output, &self.fee]
.into_iter()
.zip(self.decimals)
{
accounts.insert(
derive_asset_config(&config.mint_address, &self.program).0,
account(config.encode().unwrap()),
);
let mut mint = vec![0; 82];
mint[44] = decimals;
mint[45] = 1;
accounts.insert(
config.mint_address,
Account {
owner: SPL_TOKEN_PROGRAM_ADDRESS,
..account(mint)
},
);
if config.asset_type == AssetType::Stable {
let stable = LpStableConfigAccount {
quote_token_mint_address: config.mint_address,
liquidity_provider: self.params.liquidity_provider,
paused: false,
bump: 255,
padding: [0; 128],
};
accounts.insert(
derive_lp_stable_config(
&config.mint_address,
&self.params.liquidity_provider,
&self.program,
)
.0,
account(stable.encode().unwrap()),
);
}
}
if let Some(lp_fee) = &self.lp_fee {
accounts.insert(
derive_lp_protocol_fee_config(&self.params.liquidity_provider, &self.program).0,
account(lp_fee.encode().unwrap()),
);
}
let pyth_addresses =
resolve_pyth_oracle_accounts(&[&self.input, &self.output, &self.fee]);
accounts.extend(self.oracles.iter().map(|(address, data)| {
let mut oracle = account(data.clone());
if pyth_addresses.contains(address) {
oracle.owner = PYTH_RECEIVER_PROGRAM_ADDRESS;
}
(*address, oracle)
}));
TestRpc {
accounts,
slot: 50,
block_times: HashMap::new(),
block_time_error: None,
requested_slots: Mutex::new(vec![]),
forbidden_accounts: vec![],
simulation: Ok(SimulationResult {
logs: vec![],
error: None,
units_consumed: None,
}),
transactions: Mutex::new(vec![]),
}
}
}
pub(crate) struct TestRpc {
pub accounts: HashMap<Pubkey, Account>,
pub slot: u64,
pub block_times: HashMap<u64, i64>,
pub block_time_error: Option<u64>,
pub requested_slots: Mutex<Vec<u64>>,
pub forbidden_accounts: Vec<Pubkey>,
pub simulation: std::result::Result<SimulationResult, &'static str>,
pub transactions: Mutex<Vec<VersionedTransaction>>,
}
#[async_trait]
impl Rpc for TestRpc {
async fn get_account(&self, address: &Pubkey) -> Result<Option<Account>> {
if self.forbidden_accounts.contains(address) {
return Err(SdkError::Rpc("unexpected ATA probe".into()));
}
Ok(self.accounts.get(address).cloned())
}
async fn get_program_accounts(
&self,
_: &Pubkey,
_: &[RpcFilter],
) -> Result<Vec<(Pubkey, Account)>> {
panic!("unexpected get_program_accounts")
}
async fn get_slot(&self) -> Result<u64> {
Ok(self.slot)
}
async fn get_block_time(&self, slot: u64) -> Result<Option<i64>> {
self.requested_slots.lock().push(slot);
if self.block_time_error == Some(slot) {
return Err(SdkError::Rpc("block time unavailable".into()));
}
Ok(self.block_times.get(&slot).copied())
}
async fn get_latest_blockhash(&self) -> Result<Hash> {
Ok(Hash::new_from_array([8; 32]))
}
async fn get_transaction_logs(&self, _: &str) -> Result<Option<Vec<String>>> {
panic!("unexpected get_transaction_logs")
}
async fn simulate_transaction(
&self,
transaction: &VersionedTransaction,
) -> Result<SimulationResult> {
self.transactions.lock().push(transaction.clone());
self.simulation
.clone()
.map_err(|message| SdkError::Rpc(message.into()))
}
}
}
#[cfg(test)]
mod tests {
use super::{test_support::*, *};
use crate::{pda::derive_global_config, types::SwapType};
#[test]
fn protocol_fees_are_not_subtracted_from_trader_input() {
let mut fixture = Fixture::new();
fixture.global.protocol_fees_bps = 500;
let quote = fixture.quote().unwrap();
assert_eq!(quote.amount_in, 100_000_000);
assert_eq!(quote.amount_in_for_vault, 100_000_000);
assert_eq!(quote.amount_out, 100_000_000);
assert_eq!(quote.issuer_protocol_fees, 5_000_000);
assert_eq!(quote.spread_protocol_fees, 0);
assert_eq!(quote.protocol_fees, 5_000_000);
}
#[test]
fn direction_and_exact_mode_use_quote_decimals_for_fee_conversion() {
let mut fixture = Fixture::new();
fixture.output = asset(fixture.output.mint_address, 2_000_000_000, AssetType::Rwa);
fixture.fee = asset(fixture.fee.mint_address, 4_000_000_000, AssetType::Stable);
fixture.global.protocol_fees_bps = 500;
fixture.decimals = [6, 9, 2];
for (direction, input, output, issuer_fee) in [
(SwapDirection::QuoteToBase, 100_000_000, 50_000_000_000, 125),
(SwapDirection::BaseToQuote, 50_000_000_000, 100_000_000, 125),
] {
if direction != fixture.direction() {
fixture.reverse();
}
for swap_type in [SwapType::ExactIn, SwapType::ExactOut] {
fixture.params.swap_type = swap_type;
fixture.params.amount = if swap_type == SwapType::ExactIn {
input
} else {
output
};
let quote = fixture.quote().unwrap();
assert_eq!((quote.amount_in, quote.amount_out), (input, output));
assert_eq!(quote.issuer_protocol_fees, issuer_fee);
assert_eq!(
(quote.input_nav, quote.output_nav),
if direction == SwapDirection::QuoteToBase {
(1_000_000_000, 2_000_000_000)
} else {
(2_000_000_000, 1_000_000_000)
}
);
assert_eq!(quote.fee_token_nav, 4_000_000_000);
}
}
}
#[test]
fn lp_override_zero_disables_both_global_fee_rates() {
let mut fixture = Fixture::new();
fixture.global.protocol_fees_bps = 500;
fixture.global.spread_protocol_fees_bps = 500;
fixture.pair.redemption_fee_bps = 100;
fixture.lp_fee = Some(LpProtocolFeeConfigAccount {
liquidity_provider: fixture.params.liquidity_provider,
protocol_fees_bps: 0,
spread_protocol_fees_bps: 0,
treasury_enabled: false,
bump: 255,
padding: [0; 128],
});
let quote = fixture.quote().unwrap();
assert_eq!(quote.protocol_fees, 0);
assert_eq!(quote.amount_out, 99_000_000);
fixture.lp_fee.as_mut().unwrap().protocol_fees_bps = 100;
assert_eq!(fixture.quote().unwrap().protocol_fees, 1_000_000);
}
#[test]
fn issuer_and_spread_are_rounded_in_fee_token_units_independently() {
let mut fixture = Fixture::new();
fixture.params.amount = 1_000;
fixture.decimals = [0; 3];
fixture.global.protocol_fees_bps = 1;
fixture.global.spread_protocol_fees_bps = 1;
fixture.fee = asset(fixture.fee.mint_address, 3_000_000_000, AssetType::Stable);
let quote = fixture.quote().unwrap();
assert_eq!(quote.amount_out, 999);
assert_eq!(quote.issuer_protocol_fees, 1);
assert_eq!(quote.spread_protocol_fees, 1);
assert_eq!(quote.protocol_fees, 2);
}
#[test]
fn combined_fee_overflow_is_rejected_after_valid_individual_conversions() {
let mut fixture = Fixture::new();
fixture.params.amount = u64::MAX;
fixture.decimals = [0; 3];
fixture.pair.redemption_fee_bps = 1;
fixture.global.protocol_fees_bps = 10_000;
assert_eq!(fixture.quote().unwrap().protocol_fees, u64::MAX);
fixture.global.protocol_fees_bps = 0;
fixture.global.spread_protocol_fees_bps = 10_000;
assert_eq!(
fixture.quote().unwrap().protocol_fees,
1_844_858_893_260_300
);
fixture.global.protocol_fees_bps = 10_000;
assert!(matches!(fixture.quote(), Err(SdkError::MathOverflow)));
}
#[test]
fn rwa_pair_combines_fees_but_mixed_pair_selects_directional_fee() {
let mut fixture = Fixture::new();
fixture.pair.redemption_fee_bps = 100;
fixture.pair.discount_rate_bps = 200;
assert_eq!(fixture.quote().unwrap().amount_out, 99_000_000);
fixture.reverse();
assert_eq!(fixture.quote().unwrap().amount_out, 98_000_000);
fixture.output.asset_type = AssetType::Rwa;
for _ in 0..2 {
let quote = fixture.quote().unwrap();
assert_eq!(quote.discount_amount, 3_000_000);
assert_eq!(quote.amount_out, 97_000_000);
fixture.reverse();
}
fixture.pair.redemption_fee_bps = u16::MAX;
fixture.pair.discount_rate_bps = 1;
assert!(matches!(fixture.quote(), Err(SdkError::MathOverflow)));
}
#[test]
fn every_asset_nav_is_required_even_when_fees_are_disabled() {
for index in 0..3 {
for nav_data in [
vec![],
vec![NavData::Hardcoded {
hardcoded_price: 0,
price_decimals: 9,
}],
] {
let mut fixture = Fixture::new();
let config = match index {
0 => &mut fixture.input,
1 => &mut fixture.output,
_ => &mut fixture.fee,
};
config.nav_data = nav_data;
assert!(matches!(fixture.quote(), Err(SdkError::Oracle(_))));
}
}
}
#[test]
fn timestamp_requirement_includes_fee_only_pyth_sources() {
let mut fixture = Fixture::new();
assert!(!quote_requires_cluster_timestamp(&[
&fixture.input,
&fixture.output,
&fixture.fee
]));
fixture.fee.nav_data.push(NavData::PythPush {
pyth_push_account_address: Pubkey::new_from_array([7; 32]),
feed_id: [0; 32],
max_age_secs: 10,
max_conf_bps: 100,
});
assert!(quote_requires_cluster_timestamp(&[
&fixture.input,
&fixture.output,
&fixture.fee
]));
}
#[tokio::test]
async fn oracle_data_map_preserves_present_accounts_and_omits_missing_ones() {
let fixture = Fixture::new();
let rpc = fixture.rpc();
let present = fixture.input.mint_address;
let missing = Pubkey::new_from_array([13; 32]);
let data = fetch_oracle_account_data_map(&rpc, &[missing, present], &[])
.await
.unwrap();
assert_eq!(data[&present], rpc.accounts[&present].data);
assert!(!data.contains_key(&missing));
assert!(fetch_oracle_account_data_map(&rpc, &[], &[])
.await
.unwrap()
.is_empty());
}
#[tokio::test]
async fn cluster_clock_uses_newest_available_slot_and_inclusive_lookback() {
let mut rpc = Fixture::new().rpc();
rpc.block_times.insert(48, 1_700_000_000);
assert_eq!(
fetch_cluster_unix_timestamp(&rpc).await.unwrap(),
1_700_000_000
);
assert_eq!(*rpc.requested_slots.lock(), vec![50, 49, 48]);
rpc.block_times.clear();
rpc.block_times.insert(25, 1_699_999_990);
rpc.requested_slots.lock().clear();
assert_eq!(
fetch_cluster_unix_timestamp(&rpc).await.unwrap(),
1_699_999_990
);
assert_eq!(
*rpc.requested_slots.lock(),
(25..=50).rev().collect::<Vec<_>>()
);
rpc.block_times.clear();
rpc.block_times.insert(24, 1_699_999_980);
assert!(matches!(
fetch_cluster_unix_timestamp(&rpc).await,
Err(SdkError::Rpc(_))
));
}
#[tokio::test]
async fn cluster_clock_stops_at_genesis_and_propagates_rpc_failure() {
let mut rpc = Fixture::new().rpc();
rpc.slot = 2;
assert!(fetch_cluster_unix_timestamp(&rpc).await.is_err());
assert_eq!(*rpc.requested_slots.lock(), vec![2, 1, 0]);
rpc.requested_slots.lock().clear();
rpc.block_time_error = Some(1);
rpc.block_times.insert(0, 42);
assert!(matches!(
fetch_cluster_unix_timestamp(&rpc).await,
Err(SdkError::Rpc(_))
));
assert_eq!(*rpc.requested_slots.lock(), vec![2, 1]);
}
#[tokio::test]
async fn rpc_quote_fetches_fee_only_oracle_and_uses_cluster_freshness() {
let mut fixture = Fixture::new();
fixture.global.protocol_fees_bps = 500;
fixture.decimals = [6, 9, 2];
let oracle = Pubkey::new_from_array([7; 32]);
fixture.fee.nav_data = vec![NavData::RedstonePush {
price_feed_account: oracle,
feed_id: [6; 32],
max_age_secs: 10,
}];
let mut data = vec![0; 90];
data[8..40].copy_from_slice(&[6; 32]);
data[64..72].copy_from_slice(&4_000_000_000_u64.to_be_bytes());
data[72..80].copy_from_slice(&1_700_000_u64.to_le_bytes());
data[89] = 9;
fixture.oracles.insert(oracle, data);
let mut rpc = fixture.rpc();
rpc.block_times.insert(48, 1_700);
let quote = compute_swap_quote(&rpc, &fixture.params, &fixture.program)
.await
.unwrap();
assert_eq!(quote.amount_out, 100_000_000_000);
assert_eq!(quote.fee_token_nav, 4_000_000_000);
assert_eq!(quote.protocol_fees, 125);
rpc.block_times.insert(48, 1_711);
assert!(matches!(
compute_swap_quote(&rpc, &fixture.params, &fixture.program).await,
Err(SdkError::Oracle(_))
));
rpc.accounts.remove(&oracle);
assert!(matches!(
compute_swap_quote(&rpc, &fixture.params, &fixture.program).await,
Err(SdkError::Oracle(_))
));
}
#[tokio::test]
async fn hardcoded_quote_needs_no_clock_and_rejects_invalid_lp_override() {
let fixture = Fixture::new();
let mut rpc = fixture.rpc();
assert_eq!(
compute_swap_quote(&rpc, &fixture.params, &fixture.program)
.await
.unwrap()
.amount_out,
100_000_000
);
assert!(rpc.requested_slots.lock().is_empty());
let address =
derive_lp_protocol_fee_config(&fixture.params.liquidity_provider, &fixture.program).0;
let mut account = rpc.accounts[&derive_global_config(&fixture.program).0].clone();
account.data = vec![0; 8];
rpc.accounts.insert(address, account.clone());
assert!(compute_swap_quote(&rpc, &fixture.params, &fixture.program)
.await
.is_err());
account.owner = Pubkey::default();
rpc.accounts.insert(address, account);
assert!(matches!(
compute_swap_quote(&rpc, &fixture.params, &fixture.program).await,
Err(SdkError::InvalidAccount(_))
));
}
}