use std::collections::{HashMap, HashSet};
use solana_sdk::{instruction::AccountMeta, pubkey::Pubkey};
use crate::{
constants::{ASSOCIATED_TOKEN_PROGRAM_ADDRESS, SYSTEM_PROGRAM_ADDRESS},
error::{Result, SdkError},
generated::treasury::{AssetConfig, AssetType, GlobalConfig, NavData, PendingDeposit},
oracle::{calculate_nav, pyth_oracle_addresses},
pda::{
derive_associated_token_account, derive_treasury_apy_entry, derive_treasury_asset_config,
derive_treasury_global_config, derive_treasury_user_position, derive_treasury_vault,
derive_treasury_vault_authority,
},
quote_core::{
fetch_cluster_unix_timestamp, fetch_oracle_account_data_map, nav_data_requires_timestamp,
},
rpc::Rpc,
token::{fetch_mint_account_contexts, read_token_account_amount},
treasury::TreasuryUserPositionWithPendingDeposits,
types::{ExactMode, SwapDirection},
};
const SECONDS_PER_DAY: i128 = 86_400;
const MAX_RPC_ACCOUNT_BATCH_SIZE: usize = 100;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TreasuryOperation {
Deposit,
Redeem,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TreasuryLiquidityPlanAccounts {
pub treasury_program: Pubkey,
pub treasury_global_config: Pubkey,
pub treasury_asset_config: Pubkey,
pub treasury_user_position: Pubkey,
pub treasury_vault_authority: Pubkey,
pub treasury_mint: Pubkey,
pub treasury_asset_vault: Pubkey,
pub treasury_user_treasury_token_account: Pubkey,
pub treasury_latest_apy_entry: Pubkey,
pub treasury_token_program: Pubkey,
pub treasury_associated_token_program: Pubkey,
pub treasury_system_program: Pubkey,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TreasuryLiquidityPlan {
pub asset_enabled: bool,
pub accounts: TreasuryLiquidityPlanAccounts,
pub nav_accounts: Vec<AccountMeta>,
pub apy_accounts: Vec<AccountMeta>,
pub remaining_accounts: Vec<AccountMeta>,
pub nav_account_count: u8,
pub apy_account_count: u8,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ResolveTreasuryLiquidityPlanInput {
pub owner: Pubkey,
pub asset_mint: Pubkey,
pub asset_token_program: Pubkey,
pub operation: TreasuryOperation,
pub amount: u64,
pub exact_mode: Option<ExactMode>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TreasurySwapPlanAccounts {
pub treasury_program: Pubkey,
pub treasury_global_config: Pubkey,
pub treasury_quote_asset_config: Pubkey,
pub treasury_base_asset_config: Pubkey,
pub treasury_user_position: Pubkey,
pub treasury_vault_authority: Pubkey,
pub treasury_mint: Pubkey,
pub treasury_user_treasury_token_account: Pubkey,
pub treasury_quote_asset_vault: Pubkey,
pub treasury_base_asset_vault: Pubkey,
pub treasury_latest_apy_entry: Pubkey,
pub treasury_token_program: Pubkey,
pub treasury_associated_token_program: Pubkey,
pub treasury_system_program: Pubkey,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TreasurySwapPlan {
pub quote_asset_enabled: bool,
pub base_asset_enabled: bool,
pub accounts: TreasurySwapPlanAccounts,
pub nav_accounts: Vec<AccountMeta>,
pub will_redeem_output: bool,
pub redeem_amount: u64,
pub may_deposit_input: bool,
pub deposit_amount: u64,
pub apy_accounts: Vec<AccountMeta>,
pub remaining_accounts: Vec<AccountMeta>,
pub nav_account_count: u8,
pub apy_account_count: u8,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TreasurySweepOracleSnapshot {
pub account_data: HashMap<Pubkey, Vec<u8>>,
pub pyth_addresses: Vec<Pubkey>,
pub current_unix_timestamp: Option<i64>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ResolveTreasurySwapPlanInput {
pub owner: Pubkey,
pub quote_mint: Pubkey,
pub base_mint: Pubkey,
pub quote_token_program: Pubkey,
pub base_token_program: Pubkey,
pub direction: SwapDirection,
pub amount_out: u64,
pub amount_in_for_vault: u64,
pub input_decimals: u8,
pub input_is_stable: bool,
pub output_is_stable: bool,
pub oracle_snapshot: Option<TreasurySweepOracleSnapshot>,
pub quote_vault: Pubkey,
pub base_vault: Pubkey,
}
struct TreasuryBaseContext {
global_config_address: Pubkey,
global_config: GlobalConfig,
vault_authority: Pubkey,
user_position: Pubkey,
user_treasury_token_account: Pubkey,
treasury_token_program: Pubkey,
}
fn account_count(count: usize, label: &str) -> Result<u8> {
u8::try_from(count).map_err(|_| {
SdkError::InvalidInput(format!("{label} account count exceeds the V2 u8 limit"))
})
}
fn assert_owned_by(address: &Pubkey, owner: &Pubkey, expected_owner: &Pubkey) -> Result<()> {
if owner != expected_owner {
return Err(SdkError::InvalidAccount(format!(
"Treasury account {address} has unexpected owner {owner}; expected {expected_owner}"
)));
}
Ok(())
}
async fn fetch_global_config<R: Rpc + ?Sized>(
rpc: &R,
address: &Pubkey,
program_id: &Pubkey,
) -> Result<GlobalConfig> {
let account = rpc
.get_account(address)
.await?
.ok_or(SdkError::AccountNotFound(*address))?;
assert_owned_by(address, &account.owner, program_id)?;
Ok(GlobalConfig::decode(&account.data)?)
}
async fn fetch_asset_config<R: Rpc + ?Sized>(
rpc: &R,
address: &Pubkey,
mint: &Pubkey,
program_id: &Pubkey,
) -> Result<Option<AssetConfig>> {
let Some(account) = rpc.get_account(address).await? else {
return Ok(None);
};
assert_owned_by(address, &account.owner, program_id)?;
let config = AssetConfig::decode(&account.data)?;
if config.asset_mint != *mint {
return Err(SdkError::InvalidAccount(format!(
"Treasury asset config mint mismatch: expected {mint}, found {}",
config.asset_mint
)));
}
Ok(Some(config))
}
async fn fetch_position<R: Rpc + ?Sized>(
rpc: &R,
address: &Pubkey,
owner: &Pubkey,
program_id: &Pubkey,
) -> Result<Option<TreasuryUserPositionWithPendingDeposits>> {
let Some(account) = rpc.get_account(address).await? else {
return Ok(None);
};
if account.data.is_empty() {
return Ok(None);
}
assert_owned_by(address, &account.owner, program_id)?;
let position = TreasuryUserPositionWithPendingDeposits::decode(&account.data)?;
if position.owner != *owner {
return Err(SdkError::InvalidAccount(format!(
"Treasury user position owner mismatch: expected {owner}, found {}",
position.owner
)));
}
Ok(Some(position))
}
fn asset_enabled(global_config: &GlobalConfig, asset_config: Option<&AssetConfig>) -> bool {
asset_config.is_some_and(|config| {
!global_config.paused && !config.paused && config.asset_type == AssetType::Stable
})
}
fn position_has_capacity(
position: Option<&TreasuryUserPositionWithPendingDeposits>,
global_config: &GlobalConfig,
) -> bool {
position.is_none_or(|position| {
position.pending_deposit_count < global_config.max_pending_deposit_slots
})
}
async fn sweep_meets_minimum<R: Rpc + ?Sized>(
rpc: &R,
config: &AssetConfig,
amount: u64,
decimals: u8,
snapshot: Option<&TreasurySweepOracleSnapshot>,
) -> Result<bool> {
let Some(scale) = 10_u128.checked_pow(u32::from(decimals)) else {
return Ok(false);
};
if u128::from(amount) < scale {
return Ok(false);
}
let addresses: Vec<_> = collect_nav_accounts(&[Some(config)])
.iter()
.map(|meta| meta.pubkey)
.collect();
let pyth_addresses: HashSet<_> = pyth_oracle_addresses(&[&config.nav_data])
.into_iter()
.collect();
let mut data = HashMap::new();
if let Some(snapshot) = snapshot {
for address in &addresses {
if let Some(bytes) = snapshot.account_data.get(address) {
if !pyth_addresses.contains(address) || snapshot.pyth_addresses.contains(address) {
data.insert(*address, bytes.clone());
}
}
}
}
let missing: Vec<_> = addresses
.iter()
.filter(|address| !data.contains_key(*address))
.copied()
.collect();
let missing_pyth: Vec<_> = missing
.iter()
.filter(|address| pyth_addresses.contains(*address))
.copied()
.collect();
data.extend(fetch_oracle_account_data_map(rpc, &missing, &missing_pyth).await?);
let timestamp = if nav_data_requires_timestamp(&config.nav_data) {
match snapshot.and_then(|snapshot| snapshot.current_unix_timestamp) {
Some(timestamp) => Some(timestamp),
None => Some(fetch_cluster_unix_timestamp(rpc).await?),
}
} else {
None
};
let nav = calculate_nav(
&config.nav_data,
&data,
config.price_difference_bps,
timestamp,
)?;
if nav == 0 {
return Err(SdkError::Oracle("Treasury NAV must be positive".into()));
}
let product = u128::from(amount) * u128::from(nav);
let value = (product / scale)
.checked_mul(1_000_000_000)
.and_then(|whole| whole.checked_add((product % scale) * 1_000_000_000 / scale))
.ok_or(SdkError::MathOverflow)?;
Ok(value >= 1_000_000_000_000_000_000)
}
fn collect_nav_accounts(configs: &[Option<&AssetConfig>]) -> Vec<AccountMeta> {
let mut addresses = HashSet::new();
let mut accounts = Vec::new();
for config in configs.iter().flatten() {
for nav in &config.nav_data {
let address = match nav {
NavData::U64FixedAddress {
nav_account_address,
..
} => *nav_account_address,
NavData::PythPush {
pyth_push_account_address,
..
} => *pyth_push_account_address,
NavData::RedstonePush {
price_feed_account, ..
} => *price_feed_account,
NavData::Hardcoded { .. } => continue,
};
if addresses.insert(address) {
accounts.push(AccountMeta::new_readonly(address, false));
}
}
}
accounts
}
fn pending_deposit_day_start(deposit: &PendingDeposit) -> i128 {
let timestamp = i128::from(deposit.deposit_ts)
+ if deposit.asset_type == AssetType::Stable {
SECONDS_PER_DAY
} else {
0
};
timestamp.div_euclid(SECONDS_PER_DAY) * SECONDS_PER_DAY
}
async fn resolve_apy_accounts<R: Rpc + ?Sized>(
rpc: &R,
position: Option<&TreasuryUserPositionWithPendingDeposits>,
global_config: &GlobalConfig,
exclude_latest: bool,
program_id: &Pubkey,
) -> Result<Vec<AccountMeta>> {
if global_config.latest_apy_entry == SYSTEM_PROGRAM_ADDRESS {
return Err(SdkError::InvalidAccount(
"Treasury has no posted APY entry; V2 deposits and redemptions are unavailable".into(),
));
}
let Some(position) = position else {
return Ok(Vec::new());
};
let mut days = HashSet::new();
let mut addresses = Vec::new();
for deposit in &position.pending_deposits {
if deposit.amount_deposited_fp == 0 && deposit.deposit_ts == 0 {
break;
}
let day = pending_deposit_day_start(deposit);
if day >= i128::from(global_config.last_yield_update_ts) || !days.insert(day) {
continue;
}
let day = i64::try_from(day).map_err(|_| SdkError::MathOverflow)?;
let (address, _) = derive_treasury_apy_entry(day, program_id);
if !exclude_latest || address != global_config.latest_apy_entry {
addresses.push(address);
}
}
for batch in addresses.chunks(MAX_RPC_ACCOUNT_BATCH_SIZE) {
let accounts = rpc.get_multiple_accounts(batch).await?;
if accounts.len() != batch.len() {
return Err(SdkError::Rpc(
"get_multiple_accounts returned an unexpected account count".into(),
));
}
for (address, account) in batch.iter().zip(accounts) {
let account = account.ok_or(SdkError::AccountNotFound(*address))?;
assert_owned_by(address, &account.owner, program_id)?;
}
}
Ok(addresses
.into_iter()
.map(|address| AccountMeta::new_readonly(address, false))
.collect())
}
async fn assert_latest_apy_account<R: Rpc + ?Sized>(
rpc: &R,
global_config: &GlobalConfig,
program_id: &Pubkey,
) -> Result<()> {
let address = global_config.latest_apy_entry;
let account = rpc
.get_account(&address)
.await?
.ok_or(SdkError::AccountNotFound(address))?;
assert_owned_by(&address, &account.owner, program_id)
}
async fn resolve_base_context<R: Rpc + ?Sized>(
rpc: &R,
owner: &Pubkey,
program_id: &Pubkey,
) -> Result<TreasuryBaseContext> {
let (global_config_address, _) = derive_treasury_global_config(program_id);
let (vault_authority, _) = derive_treasury_vault_authority(program_id);
let (user_position, _) = derive_treasury_user_position(owner, program_id);
let global_config = fetch_global_config(rpc, &global_config_address, program_id).await?;
let mint_contexts = fetch_mint_account_contexts(rpc, &[global_config.treasury_mint]).await?;
let mint_context = mint_contexts
.first()
.ok_or(SdkError::AccountNotFound(global_config.treasury_mint))?;
let (user_treasury_token_account, _) = derive_associated_token_account(
owner,
&global_config.treasury_mint,
&mint_context.token_program,
);
Ok(TreasuryBaseContext {
global_config_address,
global_config,
vault_authority,
user_position,
user_treasury_token_account,
treasury_token_program: mint_context.token_program,
})
}
pub async fn resolve_treasury_liquidity_plan<R: Rpc + ?Sized>(
rpc: &R,
input: &ResolveTreasuryLiquidityPlanInput,
program_id: &Pubkey,
) -> Result<TreasuryLiquidityPlan> {
let base = resolve_base_context(rpc, &input.owner, program_id).await?;
let (asset_config_address, _) = derive_treasury_asset_config(&input.asset_mint, program_id);
let (asset_vault, _) =
derive_treasury_vault(&input.asset_mint, &input.asset_token_program, program_id);
let asset_config =
fetch_asset_config(rpc, &asset_config_address, &input.asset_mint, program_id).await?;
let asset_enabled = asset_enabled(&base.global_config, asset_config.as_ref());
let nav_accounts = if asset_enabled {
collect_nav_accounts(&[asset_config.as_ref()])
} else {
Vec::new()
};
let needs_redeem = if asset_enabled && input.operation == TreasuryOperation::Redeem {
if input.exact_mode == Some(ExactMode::ExactOut) {
let (idle_vault, _) = derive_associated_token_account(
&input.owner,
&input.asset_mint,
&input.asset_token_program,
);
input.amount
> read_token_account_amount(rpc, &idle_vault, &input.asset_token_program).await?
} else {
input.amount > 0
}
} else {
false
};
let position =
if asset_enabled && (input.operation == TreasuryOperation::Deposit || needs_redeem) {
fetch_position(rpc, &base.user_position, &input.owner, program_id).await?
} else {
None
};
let needs_deposit = asset_enabled
&& input.operation == TreasuryOperation::Deposit
&& position_has_capacity(position.as_ref(), &base.global_config);
let apy_accounts = if needs_deposit || needs_redeem {
let accounts = resolve_apy_accounts(
rpc,
position.as_ref(),
&base.global_config,
needs_redeem,
program_id,
)
.await?;
if needs_redeem {
assert_latest_apy_account(rpc, &base.global_config, program_id).await?;
}
accounts
} else {
Vec::new()
};
let nav_account_count = account_count(nav_accounts.len(), "Treasury NAV")?;
let apy_account_count = account_count(apy_accounts.len(), "Treasury APY")?;
let remaining_accounts = nav_accounts.iter().chain(&apy_accounts).cloned().collect();
Ok(TreasuryLiquidityPlan {
asset_enabled,
accounts: TreasuryLiquidityPlanAccounts {
treasury_program: *program_id,
treasury_global_config: base.global_config_address,
treasury_asset_config: asset_config_address,
treasury_user_position: base.user_position,
treasury_vault_authority: base.vault_authority,
treasury_mint: base.global_config.treasury_mint,
treasury_asset_vault: asset_vault,
treasury_user_treasury_token_account: base.user_treasury_token_account,
treasury_latest_apy_entry: base.global_config.latest_apy_entry,
treasury_token_program: base.treasury_token_program,
treasury_associated_token_program: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
treasury_system_program: SYSTEM_PROGRAM_ADDRESS,
},
nav_accounts,
apy_accounts,
remaining_accounts,
nav_account_count,
apy_account_count,
})
}
pub async fn resolve_treasury_swap_plan<R: Rpc + ?Sized>(
rpc: &R,
input: &ResolveTreasurySwapPlanInput,
program_id: &Pubkey,
) -> Result<TreasurySwapPlan> {
let base = resolve_base_context(rpc, &input.owner, program_id).await?;
let (quote_config_address, _) = derive_treasury_asset_config(&input.quote_mint, program_id);
let (base_config_address, _) = derive_treasury_asset_config(&input.base_mint, program_id);
let (quote_vault, _) =
derive_treasury_vault(&input.quote_mint, &input.quote_token_program, program_id);
let (base_vault, _) =
derive_treasury_vault(&input.base_mint, &input.base_token_program, program_id);
let quote_config =
fetch_asset_config(rpc, "e_config_address, &input.quote_mint, program_id).await?;
let base_config =
fetch_asset_config(rpc, &base_config_address, &input.base_mint, program_id).await?;
let quote_asset_enabled = asset_enabled(&base.global_config, quote_config.as_ref());
let base_asset_enabled = asset_enabled(&base.global_config, base_config.as_ref());
let nav_accounts = collect_nav_accounts(&[
quote_config.as_ref().filter(|_| quote_asset_enabled),
base_config.as_ref().filter(|_| base_asset_enabled),
]);
let (
input_config,
input_enabled,
input_vault,
input_token_program,
output_enabled,
output_vault,
output_token_program,
) = match input.direction {
SwapDirection::QuoteToBase => (
quote_config.as_ref(),
quote_asset_enabled,
input.quote_vault,
input.quote_token_program,
base_asset_enabled,
input.base_vault,
input.base_token_program,
),
SwapDirection::BaseToQuote => (
base_config.as_ref(),
base_asset_enabled,
input.base_vault,
input.base_token_program,
quote_asset_enabled,
input.quote_vault,
input.quote_token_program,
),
};
let output_enabled = input.output_is_stable && output_enabled;
let output_idle_balance = if output_enabled {
read_token_account_amount(rpc, &output_vault, &output_token_program).await?
} else {
input.amount_out
};
let redeem_amount = input.amount_out.saturating_sub(output_idle_balance);
let will_redeem_output = output_enabled && redeem_amount > 0;
let sweep_amount = if input.input_is_stable && input_enabled {
read_token_account_amount(rpc, &input_vault, &input_token_program)
.await?
.checked_add(input.amount_in_for_vault)
.ok_or(SdkError::MathOverflow)?
} else {
0
};
let minimums_pass = if input.input_is_stable && input_enabled {
sweep_meets_minimum(
rpc,
input_config.expect("Enabled treasury input has a config"),
sweep_amount,
input.input_decimals,
input.oracle_snapshot.as_ref(),
)
.await?
} else {
false
};
let position = if minimums_pass || will_redeem_output {
fetch_position(rpc, &base.user_position, &input.owner, program_id).await?
} else {
None
};
let may_deposit_input = minimums_pass
&& (will_redeem_output || position_has_capacity(position.as_ref(), &base.global_config));
let deposit_amount = if may_deposit_input { sweep_amount } else { 0 };
let apy_accounts = if may_deposit_input || will_redeem_output {
resolve_apy_accounts(
rpc,
position.as_ref(),
&base.global_config,
will_redeem_output,
program_id,
)
.await?
} else {
Vec::new()
};
if will_redeem_output {
assert_latest_apy_account(rpc, &base.global_config, program_id).await?;
}
let nav_account_count = account_count(nav_accounts.len(), "Treasury NAV")?;
let apy_account_count = account_count(apy_accounts.len(), "Treasury APY")?;
let remaining_accounts = nav_accounts.iter().chain(&apy_accounts).cloned().collect();
Ok(TreasurySwapPlan {
quote_asset_enabled,
base_asset_enabled,
accounts: TreasurySwapPlanAccounts {
treasury_program: *program_id,
treasury_global_config: base.global_config_address,
treasury_quote_asset_config: quote_config_address,
treasury_base_asset_config: base_config_address,
treasury_user_position: base.user_position,
treasury_vault_authority: base.vault_authority,
treasury_mint: base.global_config.treasury_mint,
treasury_user_treasury_token_account: base.user_treasury_token_account,
treasury_quote_asset_vault: quote_vault,
treasury_base_asset_vault: base_vault,
treasury_latest_apy_entry: base.global_config.latest_apy_entry,
treasury_token_program: base.treasury_token_program,
treasury_associated_token_program: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
treasury_system_program: SYSTEM_PROGRAM_ADDRESS,
},
nav_accounts,
will_redeem_output,
redeem_amount,
may_deposit_input,
deposit_amount,
apy_accounts,
remaining_accounts,
nav_account_count,
apy_account_count,
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{
constants::{
SPL_TOKEN_PROGRAM_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS, TREASURY_PROGRAM_ADDRESS_DEVNET,
},
rpc::{RpcFilter, SimulationResult},
treasury::{
fetch_treasury_user_position_with_pending_deposits,
TreasuryUserPositionWithPendingDeposits,
},
treasury_program_client as facade,
};
use async_trait::async_trait;
use solana_sdk::{account::Account, hash::Hash, transaction::VersionedTransaction};
use std::{
collections::HashMap,
sync::atomic::{AtomicUsize, Ordering},
};
#[derive(Default)]
struct MemoryRpc {
accounts: HashMap<Pubkey, Account>,
batch_count: AtomicUsize,
largest_batch: AtomicUsize,
requested_accounts: AtomicUsize,
}
#[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_multiple_accounts(
&self,
addresses: &[Pubkey],
) -> Result<Vec<Option<Account>>> {
if addresses.len() > 100 {
return Err(SdkError::Rpc("RPC account batch exceeds 100".into()));
}
self.batch_count.fetch_add(1, Ordering::Relaxed);
self.largest_batch
.fetch_max(addresses.len(), Ordering::Relaxed);
self.requested_accounts
.fetch_add(addresses.len(), Ordering::Relaxed);
Ok(addresses
.iter()
.map(|address| self.accounts.get(address).cloned())
.collect())
}
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 simulation")
}
}
fn pk(byte: u8) -> Pubkey {
Pubkey::new_from_array([byte; 32])
}
fn account(owner: Pubkey, data: Vec<u8>) -> Account {
Account {
owner,
data,
..Account::default()
}
}
fn deposit(day: i64, asset_type: AssetType) -> PendingDeposit {
PendingDeposit {
amount_deposited_fp: 1_000_000_000_000_000_000,
deposit_ts: day * 86_400,
asset_type,
}
}
fn apy_address(day: i64) -> Pubkey {
derive_treasury_apy_entry(day * 86_400, &TREASURY_PROGRAM_ADDRESS_DEVNET).0
}
fn addresses(accounts: &[AccountMeta]) -> Vec<Pubkey> {
accounts.iter().map(|account| account.pubkey).collect()
}
struct Fixture {
rpc: MemoryRpc,
input: ResolveTreasurySwapPlanInput,
global: GlobalConfig,
}
impl Fixture {
fn new() -> Self {
let input = ResolveTreasurySwapPlanInput {
owner: pk(1),
quote_mint: pk(2),
base_mint: pk(3),
quote_token_program: TOKEN_2022_PROGRAM_ADDRESS,
base_token_program: SPL_TOKEN_PROGRAM_ADDRESS,
direction: SwapDirection::QuoteToBase,
amount_out: 100,
amount_in_for_vault: 1_000_000,
input_decimals: 6,
input_is_stable: true,
output_is_stable: true,
oracle_snapshot: None,
quote_vault: pk(5),
base_vault: pk(6),
};
let global = GlobalConfig {
manager: pk(11),
pending_manager: None,
treasury_mint: pk(7),
oracle_authority: pk(12),
global_yield_index_fp: 1_000_000_000_000_000_000,
last_yield_update_ts: 4 * 86_400,
latest_apy_entry: apy_address(3),
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: 300,
paused: false,
bump: 255,
};
let mut fixture = Self {
rpc: MemoryRpc::default(),
input,
global,
};
fixture.store_global();
let mut mint = vec![0; 82];
mint[44] = 6;
mint[45] = 1;
fixture
.rpc
.accounts
.insert(pk(7), account(TOKEN_2022_PROGRAM_ADDRESS, mint));
let nav = vec![NavData::Hardcoded {
hardcoded_price: 1_000_000_000,
price_decimals: 9,
}];
fixture.store_asset(fixture.input.quote_mint, nav.clone());
fixture.store_asset(fixture.input.base_mint, nav);
fixture.store_position(vec![deposit(3, AssetType::Rwa)]);
fixture.set_idle_balances(100, 100);
fixture
}
fn global_address(&self) -> Pubkey {
derive_treasury_global_config(&TREASURY_PROGRAM_ADDRESS_DEVNET).0
}
fn position_address(&self) -> Pubkey {
derive_treasury_user_position(&self.input.owner, &TREASURY_PROGRAM_ADDRESS_DEVNET).0
}
fn store_global(&mut self) {
self.rpc.accounts.insert(
self.global_address(),
account(
TREASURY_PROGRAM_ADDRESS_DEVNET,
self.global.encode().unwrap(),
),
);
}
fn store_asset(&mut self, mint: Pubkey, nav_data: Vec<NavData>) {
let config = AssetConfig {
asset_mint: mint,
asset_type: AssetType::Stable,
paused: false,
nav_data,
price_difference_bps: 100,
bump: 254,
};
self.rpc.accounts.insert(
derive_treasury_asset_config(&mint, &TREASURY_PROGRAM_ADDRESS_DEVNET).0,
account(TREASURY_PROGRAM_ADDRESS_DEVNET, config.encode().unwrap()),
);
}
fn store_position(&mut self, deposits: Vec<PendingDeposit>) {
for pending in &deposits {
let day = i64::try_from(pending_deposit_day_start(pending)).unwrap();
let address = derive_treasury_apy_entry(day, &TREASURY_PROGRAM_ADDRESS_DEVNET).0;
self.rpc.accounts.insert(
address,
account(TREASURY_PROGRAM_ADDRESS_DEVNET, Vec::new()),
);
}
let count = u16::try_from(deposits.len()).unwrap();
let position = TreasuryUserPositionWithPendingDeposits {
owner: self.input.owner,
principal_amount: 10,
accumulated_yield: 20,
global_yield_index_on_last_update: 1_000_000_000_000_000_000,
pending_deposit_count: count,
max_pending_deposits: count.max(50),
bump: 253,
_padding: [3, 2, 1],
pending_deposits: deposits,
};
self.rpc.accounts.insert(
self.position_address(),
account(TREASURY_PROGRAM_ADDRESS_DEVNET, position.encode().unwrap()),
);
}
fn set_idle_balances(&mut self, quote: u64, base: u64) {
for (address, token_program, amount) in [
(
self.input.quote_vault,
self.input.quote_token_program,
quote,
),
(self.input.base_vault, self.input.base_token_program, base),
] {
let mut data = vec![0; 165];
data[64..72].copy_from_slice(&amount.to_le_bytes());
data[108] = 1;
self.rpc
.accounts
.insert(address, account(token_program, data));
}
}
fn liquidity_input(
&self,
operation: TreasuryOperation,
) -> ResolveTreasuryLiquidityPlanInput {
ResolveTreasuryLiquidityPlanInput {
owner: self.input.owner,
asset_mint: self.input.base_mint,
asset_token_program: self.input.base_token_program,
operation,
amount: 100,
exact_mode: None,
}
}
}
#[tokio::test]
async fn full_position_skips_deposit_apy_but_redeem_can_free_capacity() {
let mut fixture = Fixture::new();
fixture.global.max_pending_deposit_slots = 1;
fixture.store_global();
fixture
.rpc
.accounts
.remove(&fixture.global.latest_apy_entry);
let add = resolve_treasury_liquidity_plan(
&fixture.rpc,
&fixture.liquidity_input(TreasuryOperation::Deposit),
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert!(add.asset_enabled);
assert!(add.apy_accounts.is_empty());
let skipped = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert!(!skipped.may_deposit_input);
assert_eq!(skipped.deposit_amount, 0);
assert!(skipped.apy_accounts.is_empty());
fixture.store_position(vec![deposit(3, AssetType::Rwa)]);
fixture.input.amount_out = 101;
let redeem = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert!(redeem.will_redeem_output);
assert!(redeem.may_deposit_input);
assert_eq!(redeem.deposit_amount, 1_000_100);
assert!(redeem.apy_accounts.is_empty());
}
#[tokio::test]
async fn idle_covered_exact_out_remove_needs_no_apy_but_shortfall_does() {
let mut fixture = Fixture::new();
fixture.global.latest_apy_entry = SYSTEM_PROGRAM_ADDRESS;
fixture.store_global();
let mut input = fixture.liquidity_input(TreasuryOperation::Redeem);
input.exact_mode = Some(ExactMode::ExactOut);
let idle_vault = derive_associated_token_account(
&input.owner,
&input.asset_mint,
&input.asset_token_program,
)
.0;
fixture.rpc.accounts.insert(
idle_vault,
fixture.rpc.accounts[&fixture.input.base_vault].clone(),
);
let idle =
resolve_treasury_liquidity_plan(&fixture.rpc, &input, &TREASURY_PROGRAM_ADDRESS_DEVNET)
.await
.unwrap();
assert!(idle.asset_enabled);
assert!(idle.apy_accounts.is_empty());
input.amount = 101;
assert!(matches!(
resolve_treasury_liquidity_plan(
&fixture.rpc, &input, &TREASURY_PROGRAM_ADDRESS_DEVNET,
).await,
Err(SdkError::InvalidAccount(_)),
));
input.amount = 100;
input.exact_mode = Some(ExactMode::ExactIn);
assert!(matches!(
resolve_treasury_liquidity_plan(
&fixture.rpc, &input, &TREASURY_PROGRAM_ADDRESS_DEVNET,
).await,
Err(SdkError::InvalidAccount(_)),
));
}
#[tokio::test]
async fn sweep_uses_whole_balance_and_treasury_nav_minima_before_apy() {
let mut fixture = Fixture::new();
fixture.set_idle_balances(100, 100);
fixture.input.amount_in_for_vault = 999_899;
fixture
.rpc
.accounts
.remove(&fixture.global.latest_apy_entry);
let below_token = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert!(!below_token.may_deposit_input);
assert_eq!(below_token.deposit_amount, 0);
fixture.store_asset(
fixture.input.quote_mint,
vec![NavData::Hardcoded {
hardcoded_price: 500_000_000,
price_decimals: 9,
}],
);
fixture.input.amount_in_for_vault = 1_999_899;
let below_value = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert!(!below_value.may_deposit_input);
assert_eq!(below_value.deposit_amount, 0);
fixture.input.amount_in_for_vault += 1;
assert!(matches!(
resolve_treasury_swap_plan(
&fixture.rpc, &fixture.input, &TREASURY_PROGRAM_ADDRESS_DEVNET,
).await,
Err(SdkError::AccountNotFound(address)) if address == fixture.global.latest_apy_entry,
));
fixture.store_position(vec![deposit(3, AssetType::Rwa)]);
let minimum = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert!(minimum.may_deposit_input);
assert_eq!(minimum.deposit_amount, 2_000_000);
fixture.input.input_is_stable = false;
fixture
.rpc
.accounts
.remove(&fixture.global.latest_apy_entry);
let rwa = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert!(!rwa.may_deposit_input);
assert!(rwa.apy_accounts.is_empty());
}
#[tokio::test]
async fn empty_position_is_available_and_allocated_slots_are_not_the_ceiling() {
let mut fixture = Fixture::new();
fixture.global.max_pending_deposit_slots = 51;
fixture.store_global();
fixture.store_position(vec![deposit(3, AssetType::Rwa); 50]);
let allocated_full = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert!(allocated_full.may_deposit_input);
fixture.rpc.accounts.insert(
fixture.position_address(),
account(SYSTEM_PROGRAM_ADDRESS, Vec::new()),
);
let empty = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert!(empty.may_deposit_input);
fixture.rpc.accounts.remove(&fixture.position_address());
let missing = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert!(missing.may_deposit_input);
}
#[tokio::test]
async fn apy_stops_at_empty_slot_and_floors_negative_days() {
let mut fixture = Fixture::new();
let mut zero_amount = deposit(1, AssetType::Rwa);
zero_amount.amount_deposited_fp = 0;
let mut empty = deposit(0, AssetType::Rwa);
empty.amount_deposited_fp = 0;
fixture.store_position(vec![
PendingDeposit {
deposit_ts: -1,
..deposit(0, AssetType::Rwa)
},
PendingDeposit {
deposit_ts: -86_401,
..deposit(0, AssetType::Stable)
},
zero_amount,
empty,
deposit(2, AssetType::Rwa),
]);
fixture.rpc.accounts.remove(&apy_address(2));
let plan = resolve_treasury_liquidity_plan(
&fixture.rpc,
&fixture.liquidity_input(TreasuryOperation::Deposit),
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert_eq!(
addresses(&plan.apy_accounts),
[apy_address(-1), apy_address(1)]
);
}
#[tokio::test]
async fn liquidity_preserves_day_order_dedupes_nav_and_separates_latest_for_redeem() {
let mut fixture = Fixture::new();
fixture.store_position(vec![
deposit(3, AssetType::Rwa),
deposit(1, AssetType::Stable),
deposit(2, AssetType::Rwa),
deposit(1, AssetType::Rwa),
deposit(4, AssetType::Rwa),
]);
fixture.store_asset(
fixture.input.base_mint,
vec![
NavData::U64FixedAddress {
nav_account_address: pk(8),
nav_price_offset: 8,
price_decimals: 9,
},
NavData::PythPush {
pyth_push_account_address: pk(9),
feed_id: [0; 32],
max_age_secs: 60,
max_conf_bps: 100,
},
NavData::U64FixedAddress {
nav_account_address: pk(8),
nav_price_offset: 0,
price_decimals: 9,
},
NavData::Hardcoded {
hardcoded_price: 1_000_000_000,
price_decimals: 9,
},
NavData::RedstonePush {
price_feed_account: pk(10),
feed_id: [0; 32],
max_age_secs: 60,
},
],
);
let deposit_plan = resolve_treasury_liquidity_plan(
&fixture.rpc,
&fixture.liquidity_input(TreasuryOperation::Deposit),
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert_eq!(
deposit_plan.remaining_accounts,
[
pk(8),
pk(9),
pk(10),
apy_address(3),
apy_address(2),
apy_address(1)
]
.map(|address| AccountMeta::new_readonly(address, false)),
);
assert_eq!(
(
deposit_plan.nav_account_count,
deposit_plan.apy_account_count
),
(3, 3)
);
assert_eq!(
deposit_plan.accounts.treasury_user_treasury_token_account,
derive_associated_token_account(
&fixture.input.owner,
&fixture.global.treasury_mint,
&TOKEN_2022_PROGRAM_ADDRESS
)
.0,
);
assert_eq!(
deposit_plan.accounts.treasury_token_program,
TOKEN_2022_PROGRAM_ADDRESS
);
let redeem_plan = resolve_treasury_liquidity_plan(
&fixture.rpc,
&fixture.liquidity_input(TreasuryOperation::Redeem),
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert_eq!(
addresses(&redeem_plan.remaining_accounts),
[pk(8), pk(9), pk(10), apy_address(2), apy_address(1)]
);
assert_eq!(
(redeem_plan.nav_account_count, redeem_plan.apy_account_count),
(3, 2)
);
}
#[tokio::test]
async fn swap_redeems_only_above_idle_boundary_in_each_direction() {
let mut fixture = Fixture::new();
let idle = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert!(!idle.will_redeem_output);
assert_eq!(idle.redeem_amount, 0);
assert_eq!(addresses(&idle.apy_accounts), [apy_address(3)]);
fixture.set_idle_balances(0, 99);
let redeem = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert!(redeem.will_redeem_output);
assert_eq!(redeem.redeem_amount, 1);
assert!(redeem.apy_accounts.is_empty());
assert_eq!(redeem.apy_account_count, 0);
fixture.input.direction = SwapDirection::BaseToQuote;
let reverse = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert_eq!(reverse.redeem_amount, 100);
assert!(reverse.will_redeem_output);
}
#[tokio::test]
async fn swap_skips_redeem_when_output_is_not_stable_in_swap_config() {
let mut fixture = Fixture::new();
fixture.set_idle_balances(0, 99);
fixture.input.output_is_stable = false;
let plan = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert!(plan.base_asset_enabled);
assert!(!plan.will_redeem_output);
assert_eq!(plan.redeem_amount, 0);
assert!(plan.may_deposit_input);
assert_eq!(addresses(&plan.apy_accounts), [apy_address(3)]);
}
#[tokio::test]
async fn idle_output_only_does_not_require_apy_but_shortfall_fails_closed() {
let mut fixture = Fixture::new();
fixture.rpc.accounts.remove(
&derive_treasury_asset_config(
&fixture.input.quote_mint,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.0,
);
fixture.global.latest_apy_entry = SYSTEM_PROGRAM_ADDRESS;
fixture.store_global();
let idle = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert!(!idle.quote_asset_enabled);
assert!(idle.base_asset_enabled);
assert!(!idle.will_redeem_output);
assert!(idle.apy_accounts.is_empty());
fixture.input.amount_out = 101;
assert!(matches!(
resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET
)
.await,
Err(SdkError::InvalidAccount(_)),
));
}
#[tokio::test]
async fn missing_duplicate_latest_fails_for_deposit_and_fixed_redeem_account() {
let mut fixture = Fixture::new();
fixture
.rpc
.accounts
.remove(&fixture.global.latest_apy_entry);
for operation in [TreasuryOperation::Deposit, TreasuryOperation::Redeem] {
assert!(matches!(
resolve_treasury_liquidity_plan(
&fixture.rpc, &fixture.liquidity_input(operation), &TREASURY_PROGRAM_ADDRESS_DEVNET,
).await,
Err(SdkError::AccountNotFound(address)) if address == fixture.global.latest_apy_entry,
));
}
}
#[tokio::test]
async fn grown_pending_history_is_complete_and_rpc_reads_are_bounded() {
let mut fixture = Fixture::new();
fixture.global.last_yield_update_ts = 102 * 86_400;
fixture.global.latest_apy_entry = apy_address(101);
fixture.store_global();
fixture.store_position((1..=101).map(|day| deposit(day, AssetType::Rwa)).collect());
let plan = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
let expected: Vec<_> = (1..=101).map(apy_address).collect();
assert_eq!(addresses(&plan.remaining_accounts), expected);
assert_eq!(plan.apy_account_count, 101);
assert_eq!(fixture.rpc.batch_count.load(Ordering::Relaxed), 3);
assert_eq!(fixture.rpc.largest_batch.load(Ordering::Relaxed), 100);
assert_eq!(fixture.rpc.requested_accounts.load(Ordering::Relaxed), 102);
fixture.rpc.accounts.remove(&apy_address(101));
assert!(matches!(
resolve_treasury_swap_plan(&fixture.rpc, &fixture.input, &TREASURY_PROGRAM_ADDRESS_DEVNET).await,
Err(SdkError::AccountNotFound(address)) if address == apy_address(101),
));
}
async fn plan_deposit_and_reads(fixture: &Fixture) -> (bool, usize) {
fixture.rpc.requested_accounts.store(0, Ordering::Relaxed);
let plan = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
(
plan.may_deposit_input,
fixture.rpc.requested_accounts.load(Ordering::Relaxed),
)
}
#[tokio::test]
async fn sweep_nav_reuses_owner_checked_snapshot_bytes() {
let mut fixture = Fixture::new();
let nav = pk(40);
fixture.store_asset(
fixture.input.quote_mint,
vec![NavData::U64FixedAddress {
nav_account_address: nav,
nav_price_offset: 0,
price_decimals: 9,
}],
);
fixture.rpc.accounts.insert(
nav,
account(pk(42), 1_000_000_000_u64.to_le_bytes().to_vec()),
);
fixture.set_idle_balances(0, 100);
let snapshot = |price: u64| TreasurySweepOracleSnapshot {
account_data: HashMap::from([(nav, price.to_le_bytes().to_vec())]),
pyth_addresses: Vec::new(),
current_unix_timestamp: None,
};
let (fetched_deposit, fetched_reads) = plan_deposit_and_reads(&fixture).await;
assert!(fetched_deposit);
fixture.input.oracle_snapshot = Some(snapshot(1_000_000_000));
let (reused_deposit, reused_reads) = plan_deposit_and_reads(&fixture).await;
assert!(reused_deposit);
assert_eq!(reused_reads + 1, fetched_reads);
fixture.input.oracle_snapshot = Some(snapshot(999_999_999));
assert!(!plan_deposit_and_reads(&fixture).await.0);
}
#[tokio::test]
async fn sweep_nav_refetches_pyth_feeds_the_snapshot_did_not_owner_check() {
let mut fixture = Fixture::new();
let feed = pk(40);
fixture.store_asset(
fixture.input.quote_mint,
vec![NavData::PythPush {
pyth_push_account_address: feed,
feed_id: [7; 32],
max_age_secs: 60,
max_conf_bps: 100,
}],
);
fixture
.rpc
.accounts
.insert(feed, account(pk(42), vec![0; 8]));
fixture.set_idle_balances(0, 100);
fixture.input.oracle_snapshot = Some(TreasurySweepOracleSnapshot {
account_data: HashMap::from([(feed, vec![0; 8])]),
pyth_addresses: Vec::new(),
current_unix_timestamp: Some(0),
});
assert!(matches!(
resolve_treasury_swap_plan(&fixture.rpc, &fixture.input, &TREASURY_PROGRAM_ADDRESS_DEVNET).await,
Err(SdkError::Oracle(message)) if message.contains("Invalid Pyth account owner"),
));
}
#[tokio::test]
async fn apy_count_does_not_wrap_at_u8_boundary() {
let mut fixture = Fixture::new();
fixture.global.last_yield_update_ts = 257 * 86_400;
fixture.global.latest_apy_entry = apy_address(256);
fixture.store_global();
fixture.store_position((1..=255).map(|day| deposit(day, AssetType::Rwa)).collect());
let plan = resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await
.unwrap();
assert_eq!(plan.apy_account_count, 255);
fixture.store_position((1..=256).map(|day| deposit(day, AssetType::Rwa)).collect());
assert!(matches!(
resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET
)
.await,
Err(SdkError::InvalidInput(_)),
));
}
#[tokio::test]
async fn rejects_missing_global_receipt_mint_and_wrong_program_owners() {
let fixture = Fixture::new();
let asset_address = derive_treasury_asset_config(
&fixture.input.base_mint,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.0;
for address in [
fixture.global_address(),
fixture.global.treasury_mint,
asset_address,
fixture.position_address(),
fixture.global.latest_apy_entry,
] {
let mut fixture = Fixture::new();
fixture.rpc.accounts.get_mut(&address).unwrap().owner = pk(99);
assert!(matches!(
resolve_treasury_liquidity_plan(
&fixture.rpc,
&fixture.liquidity_input(TreasuryOperation::Deposit),
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await,
Err(SdkError::InvalidAccount(_)),
));
}
for address in [fixture.global_address(), fixture.global.treasury_mint] {
let mut fixture = Fixture::new();
fixture.rpc.accounts.remove(&address);
assert!(matches!(
resolve_treasury_liquidity_plan(
&fixture.rpc, &fixture.liquidity_input(TreasuryOperation::Deposit), &TREASURY_PROGRAM_ADDRESS_DEVNET,
).await,
Err(SdkError::AccountNotFound(missing)) if missing == address,
));
}
}
#[tokio::test]
async fn rejects_position_identity_and_asset_identity_even_if_disabled() {
let mut fixture = Fixture::new();
let position_address = fixture.position_address();
fixture
.rpc
.accounts
.get_mut(&position_address)
.unwrap()
.data[8..40]
.fill(99);
assert!(matches!(
resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET
)
.await,
Err(SdkError::InvalidAccount(_)),
));
let mut fixture = Fixture::new();
fixture.global.paused = true;
fixture.store_global();
let asset_address = derive_treasury_asset_config(
&fixture.input.base_mint,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.0;
fixture.rpc.accounts.get_mut(&asset_address).unwrap().data[8..40].fill(99);
assert!(matches!(
resolve_treasury_swap_plan(
&fixture.rpc,
&fixture.input,
&TREASURY_PROGRAM_ADDRESS_DEVNET
)
.await,
Err(SdkError::InvalidAccount(_)),
));
}
#[tokio::test]
async fn facade_fetches_and_account_dispatch_never_drop_grown_deposits() {
let mut fixture = Fixture::new();
fixture.store_position((1..=51).map(|day| deposit(day, AssetType::Rwa)).collect());
let position_address = fixture.position_address();
let direct = facade::fetch_user_position(&fixture.rpc, &position_address)
.await
.unwrap();
assert_eq!(direct.pending_deposits[50].deposit_ts, 51 * 86_400);
assert_eq!(direct.pending_deposits.len(), 51);
let typed = facade::UserPosition::fetch(&fixture.rpc, &position_address)
.await
.unwrap();
assert_eq!(typed, direct);
let account = &fixture.rpc.accounts[&position_address];
let decoded = facade::Account::decode(&account.data).unwrap();
assert!(matches!(&decoded, facade::Account::UserPosition(position) if position == &direct));
assert_eq!(decoded.encode().unwrap(), account.data);
let maybe =
facade::fetch_all_maybe_user_position(&fixture.rpc, &[pk(99), position_address])
.await
.unwrap();
assert_eq!(maybe, [None, Some(direct.clone())]);
assert_eq!(
facade::fetch_all_user_position(&fixture.rpc, &[position_address])
.await
.unwrap(),
[direct],
);
assert!(matches!(
facade::fetch_all_user_position(&fixture.rpc, &[position_address, pk(99)]).await,
Err(SdkError::AccountNotFound(missing)) if missing == pk(99),
));
fixture
.rpc
.accounts
.get_mut(&position_address)
.unwrap()
.owner = pk(99);
assert!(matches!(
fetch_treasury_user_position_with_pending_deposits(
&fixture.rpc,
&position_address,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await,
Err(SdkError::InvalidAccount(_)),
));
}
}