use borsh::BorshDeserialize;
use solana_sdk::{account::Account, pubkey::Pubkey};
use crate::{
error::{Result, SdkError},
generated::swap::UserVaultInfo,
pda::{derive_asset_config, derive_global_config, derive_lp_stable_config, derive_pair},
rpc::Rpc,
types::{
AssetConfigAccount, AssetType, GlobalConfigAccount, LpProtocolFeeConfigAccount,
LpStableConfigAccount, PairAccount, PauseStatus, ResolvedSwapPair, SwapDirection,
SwapState,
},
};
pub fn decode_global_config(data: &[u8]) -> Result<GlobalConfigAccount> {
Ok(GlobalConfigAccount::decode(data)?)
}
pub fn decode_pair(data: &[u8]) -> Result<PairAccount> {
Ok(PairAccount::decode(data)?)
}
pub fn decode_asset_config(data: &[u8]) -> Result<AssetConfigAccount> {
Ok(AssetConfigAccount::decode(data)?)
}
pub fn decode_lp_stable_config(data: &[u8]) -> Result<LpStableConfigAccount> {
Ok(LpStableConfigAccount::decode(data)?)
}
pub fn decode_lp_protocol_fee_config(data: &[u8]) -> Result<LpProtocolFeeConfigAccount> {
Ok(LpProtocolFeeConfigAccount::decode(data)?)
}
pub fn decode_user_vault_info_used(mut data: &[u8]) -> Result<u16> {
if <[u8; 8]>::deserialize(&mut data)? != UserVaultInfo::DISCRIMINATOR {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"Invalid UserVaultInfo discriminator",
)
.into());
}
let (_, _, used) = <(Pubkey, Pubkey, u16)>::deserialize(&mut data)?;
Ok(used)
}
pub async fn fetch_global_config<R: Rpc + ?Sized>(
rpc: &R,
program_id: &Pubkey,
account_address: Option<&Pubkey>,
) -> Result<GlobalConfigAccount> {
let address = account_address
.copied()
.unwrap_or_else(|| derive_global_config(program_id).0);
GlobalConfigAccount::fetch(rpc, &address).await
}
pub async fn fetch_pair<R: Rpc + ?Sized>(rpc: &R, account_address: &Pubkey) -> Result<PairAccount> {
PairAccount::fetch(rpc, account_address).await
}
pub async fn fetch_global_config_and_pair<R: Rpc + ?Sized>(
rpc: &R,
global_config_address: &Pubkey,
pair_address: &Pubkey,
) -> Result<(GlobalConfigAccount, PairAccount)> {
let [global, pair] = fetch_account_batch(rpc, &[*global_config_address, *pair_address]).await?;
let global = required_account(global.as_ref(), global_config_address)?;
let pair = required_account(pair.as_ref(), pair_address)?;
Ok((
decode_global_config(&global.data)?,
decode_pair(&pair.data)?,
))
}
pub async fn fetch_asset_config<R: Rpc + ?Sized>(
rpc: &R,
account_address: &Pubkey,
) -> Result<AssetConfigAccount> {
AssetConfigAccount::fetch(rpc, account_address).await
}
pub async fn fetch_lp_stable_config<R: Rpc + ?Sized>(
rpc: &R,
account_address: &Pubkey,
) -> Result<LpStableConfigAccount> {
LpStableConfigAccount::fetch(rpc, account_address).await
}
pub async fn fetch_lp_protocol_fee_config<R: Rpc + ?Sized>(
rpc: &R,
account_address: &Pubkey,
) -> Result<LpProtocolFeeConfigAccount> {
LpProtocolFeeConfigAccount::fetch(rpc, account_address).await
}
pub async fn fetch_user_vault_info_used<R: Rpc + ?Sized>(
rpc: &R,
account_address: &Pubkey,
) -> Result<u16> {
let account = rpc
.get_account(account_address)
.await?
.ok_or(SdkError::AccountNotFound(*account_address))?;
decode_user_vault_info_used(&account.data)
}
async fn fetch_account_batch<R: Rpc + ?Sized, const N: usize>(
rpc: &R,
addresses: &[Pubkey; N],
) -> Result<[Option<Account>; N]> {
rpc.get_multiple_accounts(addresses)
.await?
.try_into()
.map_err(|_| {
SdkError::Rpc("get_multiple_accounts returned an unexpected account count".into())
})
}
fn required_account<'a>(account: Option<&'a Account>, address: &Pubkey) -> Result<&'a Account> {
account.ok_or(SdkError::AccountNotFound(*address))
}
fn assert_program_owner(account: &Account, address: &Pubkey, program_id: &Pubkey) -> Result<()> {
if account.owner != *program_id {
return Err(SdkError::InvalidAccount(format!(
"Account {address} has unexpected owner {}; expected {program_id}",
account.owner
)));
}
Ok(())
}
fn decode_resolved_pair(
account: &Account,
candidate: (Pubkey, SwapDirection),
input_mint: &Pubkey,
output_mint: &Pubkey,
liquidity_provider: &Pubkey,
program_id: &Pubkey,
) -> Result<ResolvedSwapPair> {
let (pair_address, swap_direction) = candidate;
assert_program_owner(account, &pair_address, program_id)?;
let pair = decode_pair(&account.data)?;
let (quote_mint, base_mint) = match swap_direction {
SwapDirection::QuoteToBase => (*input_mint, *output_mint),
SwapDirection::BaseToQuote => (*output_mint, *input_mint),
};
if pair.liquidity_provider != *liquidity_provider
|| pair.quote_token_mint_address != quote_mint
|| pair.base_token_mint_address != base_mint
{
return Err(SdkError::InvalidAccount(format!(
"Pair account {pair_address} does not match the requested LP and mint order"
)));
}
Ok(ResolvedSwapPair {
pair_address,
pair,
input_mint: *input_mint,
output_mint: *output_mint,
quote_mint,
base_mint,
swap_direction,
})
}
pub async fn resolve_swap_pair<R: Rpc + ?Sized>(
rpc: &R,
input_mint: &Pubkey,
output_mint: &Pubkey,
liquidity_provider: &Pubkey,
program_id: &Pubkey,
pair_address: Option<&Pubkey>,
) -> Result<ResolvedSwapPair> {
if input_mint == output_mint {
return Err(SdkError::InvalidInput(
"input_mint and output_mint must be different".into(),
));
}
let candidates = [
(
derive_pair(liquidity_provider, input_mint, output_mint, program_id).0,
SwapDirection::QuoteToBase,
),
(
derive_pair(liquidity_provider, output_mint, input_mint, program_id).0,
SwapDirection::BaseToQuote,
),
];
if let Some(address) = pair_address {
let candidate = candidates
.iter()
.find(|(candidate_address, _)| candidate_address == address)
.ok_or_else(|| {
SdkError::InvalidInput(
"pair_address does not match either PDA mint ordering of input_mint and output_mint"
.into(),
)
})?;
let account = rpc
.get_account(address)
.await?
.ok_or(SdkError::AccountNotFound(*address))?;
return decode_resolved_pair(
&account,
*candidate,
input_mint,
output_mint,
liquidity_provider,
program_id,
);
}
let accounts = fetch_account_batch(rpc, &[candidates[0].0, candidates[1].0]).await?;
let mut resolved = None;
for (candidate, account) in candidates.into_iter().zip(accounts) {
let Some(account) = account else {
continue;
};
let pair = decode_resolved_pair(
&account,
candidate,
input_mint,
output_mint,
liquidity_provider,
program_id,
)?;
if resolved.is_some() {
return Err(SdkError::InvalidInput(
"Both pair orderings exist; pass pair_address to select one".into(),
));
}
resolved = Some(pair);
}
resolved.ok_or(SdkError::AccountNotFound(candidates[0].0))
}
fn decode_lp_stable_if_required(
config: &AssetConfigAccount,
account: Option<&Account>,
address: &Pubkey,
program_id: &Pubkey,
) -> Result<Option<LpStableConfigAccount>> {
if config.asset_type != AssetType::Stable {
return Ok(None);
}
let account = required_account(account, address)?;
assert_program_owner(account, address, program_id)?;
Ok(Some(decode_lp_stable_config(&account.data)?))
}
pub async fn fetch_swap_state<R: Rpc + ?Sized>(
rpc: &R,
input_mint: &Pubkey,
output_mint: &Pubkey,
liquidity_provider: &Pubkey,
program_id: &Pubkey,
pair_address: Option<&Pubkey>,
) -> Result<SwapState> {
let resolved = resolve_swap_pair(
rpc,
input_mint,
output_mint,
liquidity_provider,
program_id,
pair_address,
)
.await?;
let addresses = [
derive_global_config(program_id).0,
derive_asset_config(input_mint, program_id).0,
derive_asset_config(output_mint, program_id).0,
derive_lp_stable_config(input_mint, liquidity_provider, program_id).0,
derive_lp_stable_config(output_mint, liquidity_provider, program_id).0,
];
let [global, input, output, input_lp, output_lp] = fetch_account_batch(rpc, &addresses).await?;
let global = required_account(global.as_ref(), &addresses[0])?;
let input = required_account(input.as_ref(), &addresses[1])?;
let output = required_account(output.as_ref(), &addresses[2])?;
assert_program_owner(global, &addresses[0], program_id)?;
assert_program_owner(input, &addresses[1], program_id)?;
assert_program_owner(output, &addresses[2], program_id)?;
let input_config = decode_asset_config(&input.data)?;
let output_config = decode_asset_config(&output.data)?;
if input_config.mint_address != *input_mint || output_config.mint_address != *output_mint {
return Err(SdkError::InvalidAccount(
"Swap asset config mint does not match the requested input or output mint".into(),
));
}
let input_lp_stable_config =
decode_lp_stable_if_required(&input_config, input_lp.as_ref(), &addresses[3], program_id)?;
let output_lp_stable_config = decode_lp_stable_if_required(
&output_config,
output_lp.as_ref(),
&addresses[4],
program_id,
)?;
Ok(SwapState {
global_config: decode_global_config(&global.data)?,
pair_address: resolved.pair_address,
pair: resolved.pair,
onchain_direction: resolved.swap_direction,
input_config,
output_config,
input_lp_stable_config,
output_lp_stable_config,
})
}
pub async fn check_pause_status<R: Rpc + ?Sized>(
rpc: &R,
input_mint: &Pubkey,
output_mint: &Pubkey,
liquidity_provider: &Pubkey,
program_id: &Pubkey,
pair_address: Option<&Pubkey>,
) -> Result<PauseStatus> {
let state = fetch_swap_state(
rpc,
input_mint,
output_mint,
liquidity_provider,
program_id,
pair_address,
)
.await?;
let global_paused = state.global_config.paused;
let pair_paused = state.pair.paused;
let input_paused = state.input_config.paused;
let output_paused = state.output_config.paused;
let fee_mint = state.global_config.fee_token_mint;
let fee_paused = if fee_mint == *input_mint {
input_paused
} else if fee_mint == *output_mint {
output_paused
} else {
let address = derive_asset_config(&fee_mint, program_id).0;
let account = rpc
.get_account(&address)
.await?
.ok_or(SdkError::AccountNotFound(address))?;
assert_program_owner(&account, &address, program_id)?;
let config = decode_asset_config(&account.data)?;
if config.mint_address != fee_mint {
return Err(SdkError::InvalidAccount(
"Fee asset config mint does not match the global fee token mint".into(),
));
}
config.paused
};
let input_lp_paused = state
.input_lp_stable_config
.is_some_and(|config| config.paused);
let output_lp_paused = state
.output_lp_stable_config
.is_some_and(|config| config.paused);
let mut pause_reasons = Vec::new();
if global_paused {
pause_reasons.push("ProgramPaused".into());
}
if pair_paused {
pause_reasons.push("PairPaused".into());
}
if input_paused || input_lp_paused {
pause_reasons.push("InputPaused".into());
}
if output_paused || output_lp_paused {
pause_reasons.push("OutputPaused".into());
}
if fee_paused {
pause_reasons.push("FeeAssetPaused".into());
}
Ok(PauseStatus {
global_paused,
pair_paused,
input_paused,
output_paused,
fee_paused,
input_lp_paused,
output_lp_paused,
any_paused: !pause_reasons.is_empty(),
pause_reasons,
})
}
#[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::collections::HashMap;
#[derive(Default)]
struct MemoryRpc {
accounts: HashMap<Pubkey, Account>,
}
#[async_trait]
impl Rpc for MemoryRpc {
async fn get_account(&self, address: &Pubkey) -> Result<Option<Account>> {
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!("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(value: u8) -> Pubkey {
Pubkey::new_from_array([value; 32])
}
fn account(data: Vec<u8>) -> Account {
Account {
owner: pk(99),
data,
..Account::default()
}
}
fn global() -> GlobalConfigAccount {
GlobalConfigAccount {
admin: pk(10),
fee_wallet: pk(11),
protocol_fees_bps: 25,
paused: false,
pending_new_admin: None,
bump: 254,
fee_token_mint: pk(12),
spread_protocol_fees_bps: 15,
padding: [0; 94],
}
}
fn pair(quote: Pubkey, base: Pubkey) -> PairAccount {
PairAccount {
redemption_fee_bps: 10,
discount_rate_bps: 20,
quote_token_mint_address: quote,
base_token_mint_address: base,
liquidity_provider: pk(3),
paused: false,
bump: 253,
padding: [0; 128],
}
}
fn asset(mint_address: Pubkey, asset_type: AssetType) -> AssetConfigAccount {
AssetConfigAccount {
mint_address,
nav_data: Vec::new(),
price_difference_bps: 100,
paused: false,
version: 1,
asset_type,
used_in_pairs_count: 0,
bump: 255,
padding: Vec::new(),
}
}
fn stable(mint: Pubkey) -> LpStableConfigAccount {
LpStableConfigAccount {
quote_token_mint_address: mint,
paused: false,
liquidity_provider: pk(3),
bump: 252,
padding: [0; 128],
}
}
fn store_pair(rpc: &mut MemoryRpc, pair: &PairAccount) -> Pubkey {
let address = derive_pair(
&pk(3),
&pair.quote_token_mint_address,
&pair.base_token_mint_address,
&pk(99),
)
.0;
rpc.accounts
.insert(address, account(pair.encode().unwrap()));
address
}
fn state_fixture(input_type: AssetType, output_type: AssetType) -> MemoryRpc {
let mut rpc = MemoryRpc::default();
store_pair(&mut rpc, &pair(pk(2), pk(1)));
rpc.accounts.insert(
derive_global_config(&pk(99)).0,
account(global().encode().unwrap()),
);
for (mint, asset_type) in [(pk(1), input_type), (pk(2), output_type)] {
rpc.accounts.insert(
derive_asset_config(&mint, &pk(99)).0,
account(asset(mint, asset_type).encode().unwrap()),
);
if asset_type == AssetType::Stable {
rpc.accounts.insert(
derive_lp_stable_config(&mint, &pk(3), &pk(99)).0,
account(stable(mint).encode().unwrap()),
);
}
}
rpc.accounts.insert(
derive_asset_config(&pk(12), &pk(99)).0,
account(asset(pk(12), AssetType::Stable).encode().unwrap()),
);
rpc
}
#[test]
fn raw_decoders_allow_allocation_padding_but_reject_malformed_data() {
let pair = pair(pk(2), pk(1));
let data = pair.encode().unwrap();
let mut padded = data.clone();
padded.extend([0xab; 64]);
assert_eq!(decode_pair(&padded).unwrap(), pair);
assert!(matches!(
decode_pair(&data[..data.len() - 1]),
Err(SdkError::Io(_))
));
let mut wrong_discriminator = data.clone();
wrong_discriminator[0] ^= 0xff;
assert!(matches!(
decode_pair(&wrong_discriminator),
Err(SdkError::Io(_))
));
let mut invalid_boolean = data;
invalid_boolean[108] = 2;
assert!(matches!(
decode_pair(&invalid_boolean),
Err(SdkError::Io(_))
));
let mut config = asset(pk(1), AssetType::Rwa).encode().unwrap();
config[48] = 2;
assert!(matches!(decode_asset_config(&config), Err(SdkError::Io(_))));
config[40..44].copy_from_slice(&u32::MAX.to_le_bytes());
assert!(matches!(decode_asset_config(&config), Err(SdkError::Io(_))));
}
#[test]
fn user_vault_usage_retains_full_u16_and_only_requires_the_prefix() {
let mut data = UserVaultInfo {
user: pk(3),
mint_address: pk(1),
used: u16::MAX,
bump: 250,
padding: [0; 128],
}
.encode()
.unwrap();
data.extend([0xab; 16]);
assert_eq!(decode_user_vault_info_used(&data).unwrap(), u16::MAX);
assert_eq!(decode_user_vault_info_used(&data[..74]).unwrap(), u16::MAX);
assert!(matches!(
decode_user_vault_info_used(&data[..73]),
Err(SdkError::Io(_))
));
data[0] ^= 0xff;
assert!(matches!(
decode_user_vault_info_used(&data),
Err(SdkError::Io(_))
));
}
#[tokio::test]
async fn fetchers_distinguish_missing_from_malformed_accounts() {
let mut rpc = MemoryRpc::default();
let address = pk(42);
assert!(
matches!(fetch_pair(&rpc, &address).await, Err(SdkError::AccountNotFound(found)) if found == address)
);
rpc.accounts.insert(address, account(vec![0; 238]));
assert!(matches!(
fetch_pair(&rpc, &address).await,
Err(SdkError::Io(_))
));
let config_address = derive_global_config(&pk(99)).0;
rpc.accounts
.insert(config_address, account(global().encode().unwrap()));
rpc.accounts.remove(&address);
assert!(
matches!(fetch_global_config_and_pair(&rpc, &config_address, &address).await, Err(SdkError::AccountNotFound(found)) if found == address)
);
rpc.accounts
.insert(address, account(pair(pk(1), pk(2)).encode().unwrap()));
rpc.accounts.remove(&config_address);
assert!(
matches!(fetch_global_config_and_pair(&rpc, &config_address, &address).await, Err(SdkError::AccountNotFound(found)) if found == config_address)
);
rpc.accounts.insert(config_address, account(vec![0; 203]));
assert!(matches!(
fetch_global_config_and_pair(&rpc, &config_address, &address).await,
Err(SdkError::Io(_))
));
}
#[tokio::test]
async fn pair_resolution_preserves_each_stored_order_and_requires_disambiguation() {
let mut rpc = MemoryRpc::default();
let reverse = store_pair(&mut rpc, &pair(pk(2), pk(1)));
let resolved = resolve_swap_pair(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), None)
.await
.unwrap();
assert_eq!(resolved.pair_address, reverse);
assert_eq!((resolved.quote_mint, resolved.base_mint), (pk(2), pk(1)));
assert_eq!(resolved.swap_direction, SwapDirection::BaseToQuote);
let forward = store_pair(&mut rpc, &pair(pk(1), pk(2)));
assert!(matches!(
resolve_swap_pair(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), None).await,
Err(SdkError::InvalidInput(_))
));
for (address, direction) in [
(forward, SwapDirection::QuoteToBase),
(reverse, SwapDirection::BaseToQuote),
] {
let selected = resolve_swap_pair(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), Some(&address))
.await
.unwrap();
assert_eq!(selected.pair_address, address);
assert_eq!(selected.swap_direction, direction);
}
rpc.accounts.remove(&reverse);
let resolved = resolve_swap_pair(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), None)
.await
.unwrap();
assert_eq!(resolved.swap_direction, SwapDirection::QuoteToBase);
}
#[tokio::test]
async fn pair_resolution_rejects_unrelated_explicit_address_and_equal_mints() {
let mut rpc = MemoryRpc::default();
rpc.accounts
.insert(pk(42), account(pair(pk(1), pk(2)).encode().unwrap()));
assert!(matches!(
resolve_swap_pair(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), Some(&pk(42))).await,
Err(SdkError::InvalidInput(_))
));
assert!(matches!(
resolve_swap_pair(&rpc, &pk(1), &pk(1), &pk(3), &pk(99), None).await,
Err(SdkError::InvalidInput(_))
));
assert!(matches!(
resolve_swap_pair(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), None).await,
Err(SdkError::AccountNotFound(_))
));
}
#[tokio::test]
async fn pair_resolution_rejects_owner_lp_and_mint_mismatches_in_both_paths() {
let valid_pair = pair(pk(1), pk(2));
let address = derive_pair(&pk(3), &pk(1), &pk(2), &pk(99)).0;
let mut wrong_owner = account(valid_pair.encode().unwrap());
wrong_owner.owner = pk(98);
let mut wrong_lp = valid_pair.clone();
wrong_lp.liquidity_provider = pk(4);
let mut wrong_mint = valid_pair.clone();
wrong_mint.base_token_mint_address = pk(4);
let wrong_order = pair(pk(2), pk(1));
for invalid in [
wrong_owner,
account(wrong_lp.encode().unwrap()),
account(wrong_mint.encode().unwrap()),
account(wrong_order.encode().unwrap()),
] {
let rpc = MemoryRpc {
accounts: HashMap::from([(address, invalid)]),
};
for explicit in [None, Some(&address)] {
assert!(matches!(
resolve_swap_pair(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), explicit).await,
Err(SdkError::InvalidAccount(_))
));
}
}
}
#[tokio::test]
async fn stable_configs_are_required_on_either_side_and_ignored_for_rwa() {
for (input_type, output_type) in [
(AssetType::Stable, AssetType::Rwa),
(AssetType::Rwa, AssetType::Stable),
(AssetType::Stable, AssetType::Stable),
(AssetType::Rwa, AssetType::Rwa),
] {
let mut rpc = state_fixture(input_type, output_type);
let state = fetch_swap_state(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), None)
.await
.unwrap();
assert_eq!(state.onchain_direction, SwapDirection::BaseToQuote);
assert_eq!(
state.input_lp_stable_config.is_some(),
input_type == AssetType::Stable
);
assert_eq!(
state.output_lp_stable_config.is_some(),
output_type == AssetType::Stable
);
for (mint, asset_type) in [(pk(1), input_type), (pk(2), output_type)] {
let address = derive_lp_stable_config(&mint, &pk(3), &pk(99)).0;
if asset_type == AssetType::Stable {
let saved = rpc.accounts.remove(&address).unwrap();
assert!(matches!(
fetch_swap_state(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), None).await,
Err(SdkError::AccountNotFound(found)) if found == address
));
rpc.accounts.insert(address, account(Vec::new()));
assert!(matches!(
fetch_swap_state(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), None).await,
Err(SdkError::Io(_))
));
rpc.accounts.insert(address, saved);
} else {
let mut unrelated = account(Vec::new());
unrelated.owner = pk(98);
rpc.accounts.insert(address, unrelated);
let unchanged = fetch_swap_state(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), None)
.await
.unwrap();
assert_eq!(unchanged, state);
}
}
}
}
#[tokio::test]
async fn swap_state_rejects_missing_required_accounts_and_wrong_owners() {
let mut rpc = state_fixture(AssetType::Stable, AssetType::Stable);
let addresses = [
derive_global_config(&pk(99)).0,
derive_asset_config(&pk(1), &pk(99)).0,
derive_asset_config(&pk(2), &pk(99)).0,
derive_lp_stable_config(&pk(1), &pk(3), &pk(99)).0,
derive_lp_stable_config(&pk(2), &pk(3), &pk(99)).0,
];
for address in addresses {
let saved = rpc.accounts.remove(&address).unwrap();
assert!(matches!(
fetch_swap_state(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), None).await,
Err(SdkError::AccountNotFound(found)) if found == address
));
let mut wrong_owner = saved.clone();
wrong_owner.owner = pk(98);
rpc.accounts.insert(address, wrong_owner);
assert!(matches!(
fetch_swap_state(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), None).await,
Err(SdkError::InvalidAccount(_))
));
rpc.accounts.insert(address, saved);
}
}
#[tokio::test]
async fn swap_state_rejects_mismatched_input_or_output_asset_identity() {
let mut rpc = state_fixture(AssetType::Rwa, AssetType::Rwa);
for mint in [pk(1), pk(2)] {
let address = derive_asset_config(&mint, &pk(99)).0;
let saved = rpc
.accounts
.insert(
address,
account(asset(pk(4), AssetType::Rwa).encode().unwrap()),
)
.unwrap();
assert!(matches!(
fetch_swap_state(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), None).await,
Err(SdkError::InvalidAccount(_))
));
rpc.accounts.insert(address, saved);
}
}
#[tokio::test]
async fn pause_status_aggregates_each_source_without_duplicate_reasons() {
let mut rpc = state_fixture(AssetType::Stable, AssetType::Stable);
let global_address = derive_global_config(&pk(99)).0;
let pair_address = derive_pair(&pk(3), &pk(2), &pk(1), &pk(99)).0;
let input_address = derive_asset_config(&pk(1), &pk(99)).0;
let output_address = derive_asset_config(&pk(2), &pk(99)).0;
let input_lp_address = derive_lp_stable_config(&pk(1), &pk(3), &pk(99)).0;
let output_lp_address = derive_lp_stable_config(&pk(2), &pk(3), &pk(99)).0;
let mut paused_global = global();
paused_global.paused = true;
let mut paused_pair = pair(pk(2), pk(1));
paused_pair.paused = true;
let mut paused_input = asset(pk(1), AssetType::Stable);
paused_input.paused = true;
let mut paused_output = asset(pk(2), AssetType::Stable);
paused_output.paused = true;
let mut paused_input_lp = stable(pk(1));
paused_input_lp.paused = true;
let mut paused_output_lp = stable(pk(2));
paused_output_lp.paused = true;
let fee_address = derive_asset_config(&pk(12), &pk(99)).0;
let mut paused_fee = asset(pk(12), AssetType::Stable);
paused_fee.paused = true;
let changes = [
(
global_address,
paused_global.encode().unwrap(),
"ProgramPaused",
),
(pair_address, paused_pair.encode().unwrap(), "PairPaused"),
(input_address, paused_input.encode().unwrap(), "InputPaused"),
(
output_address,
paused_output.encode().unwrap(),
"OutputPaused",
),
(
input_lp_address,
paused_input_lp.encode().unwrap(),
"InputPaused",
),
(
output_lp_address,
paused_output_lp.encode().unwrap(),
"OutputPaused",
),
(fee_address, paused_fee.encode().unwrap(), "FeeAssetPaused"),
];
let clear = check_pause_status(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), None)
.await
.unwrap();
assert!(!clear.any_paused);
assert!(clear.pause_reasons.is_empty());
for (index, (address, data, reason)) in changes.iter().enumerate() {
let saved = rpc
.accounts
.insert(*address, account(data.clone()))
.unwrap();
let status = check_pause_status(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), None)
.await
.unwrap();
assert!(status.any_paused);
assert_eq!(status.pause_reasons, [*reason]);
let flags = [
status.global_paused,
status.pair_paused,
status.input_paused,
status.output_paused,
status.input_lp_paused,
status.output_lp_paused,
status.fee_paused,
];
assert_eq!(flags, std::array::from_fn(|position| position == index));
rpc.accounts.insert(*address, saved);
}
for (address, data, _) in changes {
rpc.accounts.insert(address, account(data));
}
let all = check_pause_status(&rpc, &pk(1), &pk(2), &pk(3), &pk(99), None)
.await
.unwrap();
assert_eq!(
all.pause_reasons,
[
"ProgramPaused",
"PairPaused",
"InputPaused",
"OutputPaused",
"FeeAssetPaused"
]
);
}
}