use solana_sdk::{
instruction::{AccountMeta, Instruction},
pubkey::Pubkey,
};
use crate::{
accounts::{decode_lp_protocol_fee_config, fetch_asset_config},
constants::TREASURY_PROGRAM_ADDRESS_DEVNET,
error::{Result, SdkError},
generated::swap::{
AddLiquidityAccounts, AddLiquidityArgs, RemoveLiquidityAccounts, RemoveLiquidityArgs,
},
pda::{
derive_asset_config, derive_associated_token_account, derive_global_config,
derive_lp_protocol_fee_config, derive_lp_stable_config, derive_vault,
derive_vault_authority,
},
rpc::Rpc,
token::{
ensure_ata_instructions, fetch_mint_account_contexts, merge_account_metas,
resolve_transfer_hook_accounts_for_program, MintAccountContext, TransferHookTransfer,
},
transaction::build_unsigned_transaction,
treasury_planner::{
resolve_treasury_liquidity_plan, ResolveTreasuryLiquidityPlanInput, TreasuryLiquidityPlan,
TreasuryOperation,
},
types::{
AssetType, BuildAddLiquidityInstructionResult, BuildAddLiquidityTransactionResult,
BuildRemoveLiquidityInstructionResult, BuildRemoveLiquidityTransactionResult, ExactMode,
LiquidityAccountKeys, LpLiquidityParams,
},
validation::{assert_no_remaining_signers, assert_positive_amount},
};
struct LiquidityContext {
mint: MintAccountContext,
accounts: LiquidityAccountKeys,
setup: Vec<Instruction>,
treasury: Option<TreasuryLiquidityPlan>,
}
async fn resolve_liquidity_context<R: Rpc + ?Sized>(
rpc: &R,
params: &LpLiquidityParams,
program_id: &Pubkey,
adding: bool,
) -> Result<LiquidityContext> {
let mint = fetch_mint_account_contexts(rpc, &[params.mint])
.await?
.pop()
.ok_or_else(|| SdkError::InvalidAccount("Missing mint account context".into()))?;
let auto_create = params.auto_create_ata.unwrap_or(true);
let mut setup = Vec::new();
let lp_token_account = if let Some(account) = params.lp_token_account {
account
} else if auto_create {
let (account, instruction) = ensure_ata_instructions(
rpc,
¶ms.liquidity_provider,
¶ms.mint,
&mint.token_program,
¶ms.liquidity_provider,
)
.await?;
setup.extend(instruction);
account
} else {
derive_associated_token_account(
¶ms.liquidity_provider,
¶ms.mint,
&mint.token_program,
)
.0
};
let lp_vault_authority = derive_vault_authority(¶ms.liquidity_provider, program_id).0;
let vault_token_account = if adding && auto_create {
let (account, instruction) = ensure_ata_instructions(
rpc,
&lp_vault_authority,
¶ms.mint,
&mint.token_program,
¶ms.liquidity_provider,
)
.await?;
setup.extend(instruction);
account
} else {
derive_vault(
¶ms.liquidity_provider,
¶ms.mint,
&mint.token_program,
program_id,
)
.0
};
let asset_config = derive_asset_config(¶ms.mint, program_id).0;
let asset = fetch_asset_config(rpc, &asset_config).await?;
let lp_protocol_fee_config =
derive_lp_protocol_fee_config(¶ms.liquidity_provider, program_id).0;
let treasury_enabled = match rpc.get_account(&lp_protocol_fee_config).await? {
None => false,
Some(account) => {
if account.owner != *program_id {
return Err(SdkError::InvalidAccount(format!(
"LP protocol fee config has unexpected owner {}; expected {program_id}",
account.owner,
)));
}
decode_lp_protocol_fee_config(&account.data)?.treasury_enabled
}
};
let treasury = if treasury_enabled {
Some(
resolve_treasury_liquidity_plan(
rpc,
&ResolveTreasuryLiquidityPlanInput {
owner: lp_vault_authority,
asset_mint: params.mint,
asset_token_program: mint.token_program,
operation: if adding {
TreasuryOperation::Deposit
} else {
TreasuryOperation::Redeem
},
amount: params.amount,
exact_mode: params.exact_mode,
},
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.await?,
)
} else {
None
};
if treasury.as_ref().is_some_and(|plan| plan.asset_enabled)
&& mint.transfer_hook_program.is_some()
{
let operation = if adding {
"add-liquidity"
} else {
"remove-liquidity"
};
return Err(SdkError::InvalidInput(format!(
"Treasury-backed transfer-hook {operation} cannot safely resolve amount-seeded hook accounts; use the raw builder with explicit remaining accounts",
)));
}
Ok(LiquidityContext {
accounts: LiquidityAccountKeys {
liquidity_provider: params.liquidity_provider,
mint_address: params.mint,
lp_token_account,
vault_token_account,
lp_vault_authority,
global_config: derive_global_config(program_id).0,
lp_protocol_fee_config,
asset_config,
lp_stable_config: if asset.asset_type == AssetType::Stable {
derive_lp_stable_config(¶ms.mint, ¶ms.liquidity_provider, program_id).0
} else {
*program_id
},
token_program: mint.token_program,
remaining_accounts: Vec::new(),
},
mint,
setup,
treasury,
})
}
async fn resolve_remaining_accounts<R: Rpc + ?Sized>(
rpc: &R,
params: &LpLiquidityParams,
context: &LiquidityContext,
transfers: &[TransferHookTransfer],
) -> Result<Vec<AccountMeta>> {
let mut trailing = resolve_transfer_hook_accounts_for_program(
rpc,
¶ms.mint,
context.mint.transfer_hook_program.as_ref(),
transfers,
)
.await?;
trailing.extend_from_slice(params.remaining_accounts.as_deref().unwrap_or_default());
assert_no_remaining_signers(&trailing, &[params.liquidity_provider])?;
let mut remaining = context
.treasury
.as_ref()
.map(|plan| plan.remaining_accounts.clone())
.unwrap_or_default();
remaining.extend(merge_account_metas(&trailing));
Ok(remaining)
}
pub async fn build_add_liquidity_instruction<R: Rpc + ?Sized>(
rpc: &R,
params: &LpLiquidityParams,
program_id: &Pubkey,
) -> Result<BuildAddLiquidityInstructionResult> {
let amount = assert_positive_amount(params.amount, "amount")?;
let mut context = resolve_liquidity_context(rpc, params, program_id, true).await?;
let accounts = &context.accounts;
let plan = context.treasury.as_ref().filter(|plan| plan.asset_enabled);
let transfers = [TransferHookTransfer {
source: accounts.lp_token_account,
destination: accounts.vault_token_account,
authority: params.liquidity_provider,
amount,
}];
let remaining = resolve_remaining_accounts(rpc, params, &context, &transfers).await?;
let treasury = plan.map(|plan| &plan.accounts);
let instruction = AddLiquidityAccounts {
liquidity_provider: accounts.liquidity_provider,
mint_address: accounts.mint_address,
lp_token_account: accounts.lp_token_account,
vault_token_account: accounts.vault_token_account,
lp_vault_authority: accounts.lp_vault_authority,
global_config: accounts.global_config,
lp_protocol_fee_config: accounts.lp_protocol_fee_config,
asset_config: accounts.asset_config,
lp_stable_config: (accounts.lp_stable_config != *program_id)
.then_some(accounts.lp_stable_config),
treasury_program: treasury.map(|accounts| accounts.treasury_program),
treasury_global_config: treasury.map(|accounts| accounts.treasury_global_config),
treasury_asset_config: treasury.map(|accounts| accounts.treasury_asset_config),
treasury_user_position: treasury.map(|accounts| accounts.treasury_user_position),
treasury_vault_authority: treasury.map(|accounts| accounts.treasury_vault_authority),
treasury_mint: treasury.map(|accounts| accounts.treasury_mint),
treasury_asset_vault: treasury.map(|accounts| accounts.treasury_asset_vault),
treasury_user_treasury_token_account: treasury
.map(|accounts| accounts.treasury_user_treasury_token_account),
treasury_token_program: treasury.map(|accounts| accounts.treasury_token_program),
treasury_associated_token_program: treasury
.map(|accounts| accounts.treasury_associated_token_program),
treasury_system_program: treasury.map(|accounts| accounts.treasury_system_program),
token_program: accounts.token_program,
}
.instruction(
*program_id,
&AddLiquidityArgs {
amount,
treasury_nav_account_count: plan.map_or(0, |plan| plan.nav_account_count),
treasury_apy_account_count: plan.map_or(0, |plan| plan.apy_account_count),
amount_threshold: params.amount_threshold,
},
&remaining,
)?;
context.accounts.remaining_accounts = remaining.iter().map(|meta| meta.pubkey).collect();
Ok(BuildAddLiquidityInstructionResult {
instruction,
setup_instructions: context.setup,
accounts: context.accounts,
})
}
pub async fn build_add_liquidity_transaction<R: Rpc + ?Sized>(
rpc: &R,
params: &LpLiquidityParams,
program_id: &Pubkey,
) -> Result<BuildAddLiquidityTransactionResult> {
let result = build_add_liquidity_instruction(rpc, params, program_id).await?;
let mut instructions = result.setup_instructions;
instructions.push(result.instruction);
Ok(BuildAddLiquidityTransactionResult {
transaction: build_unsigned_transaction(rpc, ¶ms.liquidity_provider, &instructions)
.await?,
accounts: result.accounts,
})
}
pub async fn build_remove_liquidity_instruction<R: Rpc + ?Sized>(
rpc: &R,
params: &LpLiquidityParams,
program_id: &Pubkey,
) -> Result<BuildRemoveLiquidityInstructionResult> {
let amount = assert_positive_amount(params.amount, "amount")?;
let exact_mode = params.exact_mode.unwrap_or(ExactMode::ExactIn);
let mut context = resolve_liquidity_context(rpc, params, program_id, false).await?;
let accounts = &context.accounts;
let plan = context.treasury.as_ref().filter(|plan| plan.asset_enabled);
let transfers = [TransferHookTransfer {
source: accounts.vault_token_account,
destination: accounts.lp_token_account,
authority: accounts.lp_vault_authority,
amount,
}];
let remaining = resolve_remaining_accounts(rpc, params, &context, &transfers).await?;
let treasury = plan.map(|plan| &plan.accounts);
let instruction = RemoveLiquidityAccounts {
liquidity_provider: accounts.liquidity_provider,
mint_address: accounts.mint_address,
lp_token_account: accounts.lp_token_account,
vault_token_account: accounts.vault_token_account,
lp_vault_authority: accounts.lp_vault_authority,
global_config: accounts.global_config,
lp_protocol_fee_config: accounts.lp_protocol_fee_config,
treasury_program: treasury.map(|accounts| accounts.treasury_program),
treasury_global_config: treasury.map(|accounts| accounts.treasury_global_config),
treasury_asset_config: treasury.map(|accounts| accounts.treasury_asset_config),
treasury_user_position: treasury.map(|accounts| accounts.treasury_user_position),
treasury_vault_authority: treasury.map(|accounts| accounts.treasury_vault_authority),
treasury_mint: treasury.map(|accounts| accounts.treasury_mint),
treasury_user_treasury_token_account: treasury
.map(|accounts| accounts.treasury_user_treasury_token_account),
treasury_asset_vault: treasury.map(|accounts| accounts.treasury_asset_vault),
treasury_latest_apy_entry: treasury.map(|accounts| accounts.treasury_latest_apy_entry),
treasury_token_program: treasury.map(|accounts| accounts.treasury_token_program),
treasury_associated_token_program: treasury
.map(|accounts| accounts.treasury_associated_token_program),
token_program: accounts.token_program,
}
.instruction(
*program_id,
&RemoveLiquidityArgs {
amount,
treasury_nav_account_count: plan.map_or(0, |plan| plan.nav_account_count),
treasury_apy_account_count: plan.map_or(0, |plan| plan.apy_account_count),
exact_mode,
amount_threshold: params.amount_threshold,
},
&remaining,
)?;
context.accounts.remaining_accounts = remaining.iter().map(|meta| meta.pubkey).collect();
Ok(BuildRemoveLiquidityInstructionResult {
instruction,
setup_instructions: context.setup,
accounts: context.accounts,
})
}
pub async fn build_remove_liquidity_transaction<R: Rpc + ?Sized>(
rpc: &R,
params: &LpLiquidityParams,
program_id: &Pubkey,
) -> Result<BuildRemoveLiquidityTransactionResult> {
let result = build_remove_liquidity_instruction(rpc, params, program_id).await?;
let mut instructions = result.setup_instructions;
instructions.push(result.instruction);
Ok(BuildRemoveLiquidityTransactionResult {
transaction: build_unsigned_transaction(rpc, ¶ms.liquidity_provider, &instructions)
.await?,
accounts: result.accounts,
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{
constants::{
ASSOCIATED_TOKEN_PROGRAM_ADDRESS, SPL_TOKEN_PROGRAM_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS,
},
generated::{
swap::{AssetConfig, LpProtocolFeeConfig, NavData},
treasury,
},
pda::{
derive_treasury_apy_entry, derive_treasury_asset_config, derive_treasury_global_config,
derive_treasury_user_position,
},
rpc::{RpcFilter, SimulationResult},
};
use async_trait::async_trait;
use parking_lot::Mutex;
use solana_sdk::{
account::Account, hash::Hash, message::VersionedMessage, signature::Signature,
transaction::VersionedTransaction,
};
use std::collections::HashMap;
const PROGRAM: Pubkey = Pubkey::new_from_array([101; 32]);
const LP: Pubkey = Pubkey::new_from_array([102; 32]);
const MINT: Pubkey = Pubkey::new_from_array([103; 32]);
const HOOK: Pubkey = Pubkey::new_from_array([104; 32]);
const NAV: Pubkey = Pubkey::new_from_array([105; 32]);
#[derive(Default)]
struct MemoryRpc {
accounts: HashMap<Pubkey, Account>,
reads: Mutex<Vec<Pubkey>>,
}
#[async_trait]
impl Rpc for MemoryRpc {
async fn get_account(&self, address: &Pubkey) -> Result<Option<Account>> {
self.reads.lock().push(*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!("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> {
Ok(Hash::new_from_array([9; 32]))
}
async fn get_transaction_logs(&self, _: &str) -> Result<Option<Vec<String>>> {
panic!("unexpected logs query")
}
async fn simulate_transaction(&self, _: &VersionedTransaction) -> Result<SimulationResult> {
panic!("unexpected simulation")
}
}
fn account(owner: Pubkey, data: Vec<u8>) -> Account {
Account {
owner,
data,
..Account::default()
}
}
fn mint_data(hook: bool) -> Vec<u8> {
let mut data = vec![0; 82];
data[44] = 6;
data[45] = 1;
if 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 params() -> LpLiquidityParams {
LpLiquidityParams {
liquidity_provider: LP,
mint: MINT,
amount: 100,
amount_threshold: None,
exact_mode: None,
lp_token_account: None,
auto_create_ata: None,
remaining_accounts: None,
}
}
fn fixture(asset_type: AssetType, hook: bool) -> MemoryRpc {
let mut rpc = MemoryRpc::default();
let token_program = if hook {
TOKEN_2022_PROGRAM_ADDRESS
} else {
SPL_TOKEN_PROGRAM_ADDRESS
};
rpc.accounts
.insert(MINT, account(token_program, mint_data(hook)));
rpc.accounts.insert(
derive_asset_config(&MINT, &PROGRAM).0,
account(
PROGRAM,
AssetConfig {
mint_address: MINT,
nav_data: vec![],
price_difference_bps: 100,
paused: false,
version: 1,
asset_type,
used_in_pairs_count: 1,
bump: 255,
padding: vec![],
}
.encode()
.unwrap(),
),
);
rpc
}
fn set_treasury_toggle(rpc: &mut MemoryRpc, enabled: bool) {
rpc.accounts.insert(
derive_lp_protocol_fee_config(&LP, &PROGRAM).0,
account(
PROGRAM,
LpProtocolFeeConfig {
liquidity_provider: LP,
protocol_fees_bps: 1,
spread_protocol_fees_bps: 2,
bump: 255,
treasury_enabled: enabled,
padding: [0; 128],
}
.encode()
.unwrap(),
),
);
}
fn install_treasury(rpc: &mut MemoryRpc, enabled: bool) {
set_treasury_toggle(rpc, true);
let id = TREASURY_PROGRAM_ADDRESS_DEVNET;
let treasury_mint = Pubkey::new_from_array([106; 32]);
let latest = derive_treasury_apy_entry(86_400, &id).0;
let old = derive_treasury_apy_entry(0, &id).0;
rpc.accounts.insert(
treasury_mint,
account(SPL_TOKEN_PROGRAM_ADDRESS, mint_data(false)),
);
rpc.accounts.insert(
derive_treasury_global_config(&id).0,
account(
id,
treasury::GlobalConfig {
manager: LP,
pending_manager: None,
treasury_mint,
oracle_authority: LP,
global_yield_index_fp: 1_000_000_000_000_000_000,
last_yield_update_ts: 172_800,
latest_apy_entry: latest,
apy_history_retention_duration: 864_000,
management_fee_bps: 0,
max_apy_bps: 10_000,
max_unposted_yield_seconds: 864_000,
supported_asset_count: 1,
max_pending_deposit_slots: 50,
paused: false,
bump: 255,
}
.encode()
.unwrap(),
),
);
rpc.accounts.insert(
derive_treasury_asset_config(&MINT, &id).0,
account(
id,
treasury::AssetConfig {
asset_mint: MINT,
asset_type: AssetType::Stable,
paused: !enabled,
nav_data: vec![NavData::U64FixedAddress {
nav_account_address: NAV,
nav_price_offset: 0,
price_decimals: 9,
}],
price_difference_bps: 100,
bump: 255,
}
.encode()
.unwrap(),
),
);
let owner = derive_vault_authority(&LP, &PROGRAM).0;
let mut pending_deposits = std::array::from_fn(|_| treasury::PendingDeposit {
amount_deposited_fp: 0,
deposit_ts: 0,
asset_type: AssetType::Stable,
});
pending_deposits[0].amount_deposited_fp = 1_000;
pending_deposits[0].deposit_ts = 1;
pending_deposits[0].asset_type = AssetType::Rwa;
pending_deposits[1].amount_deposited_fp = 1_000;
pending_deposits[1].deposit_ts = 86_401;
pending_deposits[1].asset_type = AssetType::Rwa;
rpc.accounts.insert(
derive_treasury_user_position(&owner, &id).0,
account(
id,
treasury::UserPosition {
owner,
principal_amount: 1_000,
accumulated_yield: 0,
global_yield_index_on_last_update: 1_000_000_000_000_000_000,
pending_deposit_count: 2,
max_pending_deposits: 50,
bump: 255,
_padding: [0; 3],
pending_deposits,
}
.encode()
.unwrap(),
),
);
for address in [old, latest] {
rpc.accounts.insert(address, account(id, vec![]));
}
let token_program = rpc.accounts[&MINT].owner;
let mut token_data = vec![0; 165];
token_data[64..72].copy_from_slice(&40_u64.to_le_bytes());
token_data[108] = 1;
rpc.accounts.insert(
derive_vault(&LP, &MINT, &token_program, &PROGRAM).0,
account(token_program, token_data),
);
}
fn install_hook(rpc: &mut MemoryRpc) -> Pubkey {
let validation =
Pubkey::find_program_address(&[b"extra-account-metas", MINT.as_ref()], &HOOK).0;
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);
let mut seeds = [0; 32];
seeds[..9].copy_from_slice(&[3, 0, 3, 2, 3, 3, 2, 8, 8]);
data.extend(seeds);
data.extend([0, 1]);
rpc.accounts.insert(validation, account(HOOK, data));
validation
}
#[tokio::test]
async fn setup_roles_and_unsigned_transaction_order_match_each_operation() {
let rpc = fixture(AssetType::Stable, false);
let add = build_add_liquidity_transaction(&rpc, ¶ms(), &PROGRAM)
.await
.unwrap();
let VersionedMessage::V0(message) = add.transaction.message else {
panic!("expected v0")
};
assert_eq!(message.account_keys[0], LP);
assert_eq!(add.transaction.signatures, vec![Signature::default()]);
assert_eq!(message.instructions.len(), 3);
for (index, owner, target) in [
(0, LP, add.accounts.lp_token_account),
(
1,
add.accounts.lp_vault_authority,
add.accounts.vault_token_account,
),
] {
let instruction = &message.instructions[index];
assert_eq!(
message.account_keys[usize::from(instruction.program_id_index)],
ASSOCIATED_TOKEN_PROGRAM_ADDRESS
);
assert_eq!(
message.account_keys[usize::from(instruction.accounts[0])],
LP
);
assert_eq!(
message.account_keys[usize::from(instruction.accounts[1])],
target
);
assert_eq!(
message.account_keys[usize::from(instruction.accounts[2])],
owner
);
}
assert_eq!(
message.account_keys[usize::from(message.instructions[2].program_id_index)],
PROGRAM
);
let removal = build_remove_liquidity_instruction(&rpc, ¶ms(), &PROGRAM)
.await
.unwrap();
assert_eq!(removal.setup_instructions.len(), 1);
assert_eq!(removal.setup_instructions[0].accounts[2].pubkey, LP);
assert_eq!(
removal.setup_instructions[0].accounts[0],
AccountMeta::new(LP, true)
);
assert_eq!(
removal.instruction.accounts[0],
AccountMeta::new_readonly(LP, true)
);
let transaction = build_remove_liquidity_transaction(&rpc, ¶ms(), &PROGRAM)
.await
.unwrap()
.transaction;
assert_eq!(transaction.signatures, vec![Signature::default()]);
let VersionedMessage::V0(message) = transaction.message else {
panic!("expected v0")
};
assert_eq!(message.account_keys[0], LP);
assert_eq!(message.instructions.len(), 2);
assert_eq!(message.instructions[1].data, removal.instruction.data);
}
#[tokio::test]
async fn caller_bounds_survive_facade_instructions_and_transactions_at_idle_balance_boundary() {
let mut rpc = fixture(AssetType::Stable, false);
install_treasury(&mut rpc, true); let mut config = crate::MultiliquidClientConfig::new(std::sync::Arc::new(rpc));
config.program_address = Some(PROGRAM);
let client = crate::MultiliquidClient::new(config);
let mut input = params();
input.auto_create_ata = Some(false);
for (amount, amount_threshold) in [(39, None), (40, Some(0)), (41, Some(u64::MAX))] {
input.amount = amount;
input.amount_threshold = amount_threshold;
input.exact_mode = Some(ExactMode::ExactOut);
let add = client
.build_add_liquidity_instruction(&input)
.await
.unwrap();
let mut expected = AddLiquidityArgs::DISCRIMINATOR.to_vec();
expected.extend_from_slice(&amount.to_le_bytes());
expected.extend_from_slice(&[1, 2, u8::from(amount_threshold.is_some())]);
if let Some(bound) = amount_threshold {
expected.extend_from_slice(&bound.to_le_bytes());
}
assert_eq!(add.instruction.data, expected);
let added = client
.build_add_liquidity_transaction(&input)
.await
.unwrap();
let VersionedMessage::V0(message) = added.transaction.message else {
panic!("expected v0")
};
assert_eq!(message.instructions.last().unwrap().data, expected);
for (mode, mode_byte) in [(ExactMode::ExactIn, 0), (ExactMode::ExactOut, 1)] {
input.exact_mode = Some(mode);
let removed = client
.build_remove_liquidity_instruction(&input)
.await
.unwrap();
let mut expected = RemoveLiquidityArgs::DISCRIMINATOR.to_vec();
expected.extend_from_slice(&amount.to_le_bytes());
expected.extend_from_slice(&[
1,
u8::from(mode == ExactMode::ExactIn || amount > 40),
mode_byte,
u8::from(amount_threshold.is_some()),
]);
if let Some(bound) = amount_threshold {
expected.extend_from_slice(&bound.to_le_bytes());
}
assert_eq!(removed.instruction.data, expected);
let removed = client
.build_remove_liquidity_transaction(&input)
.await
.unwrap();
let VersionedMessage::V0(message) = removed.transaction.message else {
panic!("expected v0")
};
assert_eq!(message.instructions.last().unwrap().data, expected);
}
}
}
#[tokio::test]
async fn liquidity_rejects_explicit_and_runtime_elevated_remaining_signers() {
let mut rpc = fixture(AssetType::Stable, false);
install_treasury(&mut rpc, true);
let mut input = params();
input.auto_create_ata = Some(false);
for extra in [
AccountMeta::new_readonly(NAV, true),
AccountMeta::new_readonly(LP, false),
] {
input.remaining_accounts = Some(vec![extra]);
assert!(matches!(
build_add_liquidity_instruction(&rpc, &input, &PROGRAM).await,
Err(SdkError::InvalidInput(_))
));
for mode in [ExactMode::ExactIn, ExactMode::ExactOut] {
input.exact_mode = Some(mode);
assert!(matches!(
build_remove_liquidity_instruction(&rpc, &input, &PROGRAM).await,
Err(SdkError::InvalidInput(_))
));
}
}
}
#[tokio::test]
async fn disabled_creation_and_lp_override_avoid_token_existence_probes() {
let rpc = fixture(AssetType::Rwa, false);
let mut input = params();
input.auto_create_ata = Some(false);
let add = build_add_liquidity_instruction(&rpc, &input, &PROGRAM)
.await
.unwrap();
let remove = build_remove_liquidity_instruction(&rpc, &input, &PROGRAM)
.await
.unwrap();
assert!(add.setup_instructions.is_empty());
assert!(remove.setup_instructions.is_empty());
assert!(rpc.reads.lock().iter().all(|address| [
MINT,
add.accounts.asset_config,
add.accounts.lp_protocol_fee_config,
]
.contains(address)));
assert_eq!(
add.instruction.accounts[8],
AccountMeta::new_readonly(PROGRAM, false)
);
assert!(add.instruction.accounts[9..20]
.iter()
.all(|meta| *meta == AccountMeta::new_readonly(PROGRAM, false)));
assert!(remove.instruction.accounts[7..18]
.iter()
.all(|meta| *meta == AccountMeta::new_readonly(PROGRAM, false)));
let override_account = Pubkey::new_from_array([107; 32]);
input.lp_token_account = Some(override_account);
input.auto_create_ata = Some(true);
let add = build_add_liquidity_instruction(&rpc, &input, &PROGRAM)
.await
.unwrap();
assert_eq!(add.accounts.lp_token_account, override_account);
assert_eq!(add.setup_instructions.len(), 1);
assert_eq!(
add.setup_instructions[0].accounts[2].pubkey,
add.accounts.lp_vault_authority
);
assert!(!rpc.reads.lock().contains(&override_account));
}
#[tokio::test]
async fn treasury_add_allows_caller_created_vault_with_auto_creation_disabled() {
let mut rpc = fixture(AssetType::Stable, false);
install_treasury(&mut rpc, true);
let vault = derive_vault(&LP, &MINT, &SPL_TOKEN_PROGRAM_ADDRESS, &PROGRAM).0;
rpc.accounts.remove(&vault);
let mut input = params();
input.auto_create_ata = Some(false);
let add = build_add_liquidity_instruction(&rpc, &input, &PROGRAM)
.await
.unwrap();
assert!(add.setup_instructions.is_empty());
assert_eq!(add.instruction.accounts[3], AccountMeta::new(vault, false));
assert_eq!(
add.instruction.accounts[9].pubkey,
TREASURY_PROGRAM_ADDRESS_DEVNET
);
assert!(!rpc.reads.lock().contains(&vault));
}
#[tokio::test]
async fn malformed_or_wrong_owner_fee_config_never_disables_treasury_silently() {
let mut rpc = fixture(AssetType::Stable, false);
let mut input = params();
input.auto_create_ata = Some(false);
let address = derive_lp_protocol_fee_config(&LP, &PROGRAM).0;
set_treasury_toggle(&mut rpc, false);
rpc.accounts.get_mut(&address).unwrap().owner = LP;
assert!(matches!(
build_add_liquidity_instruction(&rpc, &input, &PROGRAM).await,
Err(SdkError::InvalidAccount(_))
));
rpc.accounts.insert(address, account(PROGRAM, vec![0; 8]));
assert!(build_remove_liquidity_instruction(&rpc, &input, &PROGRAM)
.await
.is_err());
set_treasury_toggle(&mut rpc, false);
let add = build_add_liquidity_instruction(&rpc, &input, &PROGRAM)
.await
.unwrap();
assert_eq!(add.instruction.accounts[9].pubkey, PROGRAM);
assert!(!rpc
.reads
.lock()
.contains(&derive_treasury_global_config(&TREASURY_PROGRAM_ADDRESS_DEVNET).0));
}
#[tokio::test]
async fn enabled_treasury_preserves_nav_apy_boundaries_and_compiled_program() {
let mut rpc = fixture(AssetType::Stable, false);
install_treasury(&mut rpc, true);
let mut input = params();
input.auto_create_ata = Some(false);
input.remaining_accounts = Some(vec![
AccountMeta::new(NAV, false),
AccountMeta::new_readonly(NAV, false),
]);
let add = build_add_liquidity_instruction(&rpc, &input, &PROGRAM)
.await
.unwrap();
let id = TREASURY_PROGRAM_ADDRESS_DEVNET;
let old = derive_treasury_apy_entry(0, &id).0;
let latest = derive_treasury_apy_entry(86_400, &id).0;
assert_eq!(add.instruction.accounts[9].pubkey, id);
assert_eq!(
add.instruction.accounts[8].pubkey,
derive_lp_stable_config(&MINT, &LP, &PROGRAM).0
);
assert_eq!(
&add.instruction.accounts[21..],
&[
AccountMeta::new_readonly(NAV, false),
AccountMeta::new_readonly(old, false),
AccountMeta::new_readonly(latest, false),
AccountMeta::new(NAV, false),
]
);
let args = AddLiquidityArgs::decode(&add.instruction.data).unwrap();
assert_eq!(
(
args.treasury_nav_account_count,
args.treasury_apy_account_count
),
(1, 2)
);
input.exact_mode = Some(ExactMode::ExactOut);
let remove = build_remove_liquidity_instruction(&rpc, &input, &PROGRAM)
.await
.unwrap();
assert_eq!(remove.instruction.accounts[7].pubkey, id);
assert_eq!(remove.instruction.accounts[15].pubkey, latest);
assert_eq!(
&remove.instruction.accounts[19..],
&[
AccountMeta::new_readonly(NAV, false),
AccountMeta::new_readonly(old, false),
AccountMeta::new(NAV, false),
]
);
let args = RemoveLiquidityArgs::decode(&remove.instruction.data).unwrap();
assert_eq!(
(
args.treasury_nav_account_count,
args.treasury_apy_account_count,
args.exact_mode
),
(1, 1, ExactMode::ExactOut)
);
}
#[tokio::test]
async fn disabled_treasury_asset_stays_idle_and_keeps_hook_support() {
let mut rpc = fixture(AssetType::Stable, true);
install_treasury(&mut rpc, false);
install_hook(&mut rpc);
let mut input = params();
input.auto_create_ata = Some(false);
let result = build_add_liquidity_instruction(&rpc, &input, &PROGRAM)
.await
.unwrap();
assert_eq!(result.instruction.accounts[9].pubkey, PROGRAM);
assert_eq!(result.instruction.accounts[22].pubkey, HOOK);
assert_eq!(
AddLiquidityArgs::decode(&result.instruction.data)
.unwrap()
.treasury_nav_account_count,
0
);
assert!(!rpc
.reads
.lock()
.contains(&result.accounts.vault_token_account));
}
#[tokio::test]
async fn idle_hooks_use_actual_transfer_endpoints_authority_and_exact_out_amount() {
let mut rpc = fixture(AssetType::Rwa, true);
let validation = install_hook(&mut rpc);
let mut input = params();
input.auto_create_ata = Some(false);
input.exact_mode = Some(ExactMode::ExactOut);
input.remaining_accounts = Some(vec![AccountMeta::new(HOOK, false)]);
let add = build_add_liquidity_instruction(&rpc, &input, &PROGRAM)
.await
.unwrap();
let remove = build_remove_liquidity_instruction(&rpc, &input, &PROGRAM)
.await
.unwrap();
for (instruction, offset, source, destination, authority) in [
(
&add.instruction,
21,
add.accounts.lp_token_account,
add.accounts.vault_token_account,
LP,
),
(
&remove.instruction,
19,
remove.accounts.vault_token_account,
remove.accounts.lp_token_account,
remove.accounts.lp_vault_authority,
),
] {
let expected = Pubkey::find_program_address(
&[
source.as_ref(),
destination.as_ref(),
authority.as_ref(),
&input.amount.to_le_bytes(),
],
&HOOK,
)
.0;
assert_eq!(
&instruction.accounts[offset..],
&[
AccountMeta::new(expected, false),
AccountMeta::new(HOOK, false),
AccountMeta::new_readonly(validation, false),
]
);
}
assert_eq!(
RemoveLiquidityArgs::decode(&remove.instruction.data)
.unwrap()
.exact_mode,
ExactMode::ExactOut
);
}
#[tokio::test]
async fn treasury_hooks_reject_both_exact_modes_before_hook_resolution() {
let mut rpc = fixture(AssetType::Stable, true);
install_treasury(&mut rpc, true);
let validation = install_hook(&mut rpc);
let mut input = params();
input.auto_create_ata = Some(false);
for mode in [ExactMode::ExactIn, ExactMode::ExactOut] {
input.exact_mode = Some(mode);
assert!(matches!(
build_add_liquidity_instruction(&rpc, &input, &PROGRAM).await,
Err(SdkError::InvalidInput(_))
));
assert!(matches!(
build_remove_liquidity_instruction(&rpc, &input, &PROGRAM).await,
Err(SdkError::InvalidInput(_))
));
}
assert!(!rpc.reads.lock().contains(&validation));
}
#[tokio::test]
async fn zero_amount_rejects_before_rpc() {
let rpc = MemoryRpc::default();
let mut input = params();
input.amount = 0;
assert!(matches!(
build_add_liquidity_instruction(&rpc, &input, &PROGRAM).await,
Err(SdkError::InvalidInput(_))
));
assert!(matches!(
build_remove_liquidity_instruction(&rpc, &input, &PROGRAM).await,
Err(SdkError::InvalidInput(_))
));
assert!(rpc.reads.lock().is_empty());
}
}