use solana_sdk::{
instruction::{AccountMeta, Instruction},
pubkey::Pubkey,
};
use crate::{
accounts::{
fetch_asset_config, fetch_global_config, fetch_user_vault_info_used, resolve_swap_pair,
},
constants::{
ASSOCIATED_TOKEN_PROGRAM_ADDRESS, SYSTEM_PROGRAM_ADDRESS, TREASURY_PROGRAM_ADDRESS_DEVNET,
},
error::{Result, SdkError},
generated::swap::{
ClosePairAccounts, ClosePairArgs, InitPairAccounts, InitPairArgs, UpdatePairAccounts,
UpdatePairArgs,
},
pda::{
canonicalize_pair_mints, derive_asset_config, derive_associated_token_account,
derive_global_config, derive_lp_fee_vault, derive_lp_fee_vault_authority,
derive_lp_protocol_fee_config, derive_lp_stable_config, derive_pair,
derive_treasury_user_position, derive_user_vault_info, derive_vault,
derive_vault_authority,
},
rpc::Rpc,
token::{
ensure_ata_instructions, fetch_mint_account_contexts, merge_account_metas,
read_token_account_amount, resolve_transfer_hook_accounts_for_program, MintAccountContext,
TransferHookTransfer,
},
transaction::build_unsigned_transaction,
types::{
AssetType, BuildClosePairInstructionResult, BuildClosePairTransactionResult,
BuildInitPairInstructionResult, BuildInitPairTransactionResult,
BuildUpdatePairInstructionResult, BuildUpdatePairTransactionResult, ClosePairAccountKeys,
ClosePairParams, InitPairAccountKeys, InitPairParams, UpdatePairAccountKeys,
UpdatePairParams,
},
validation::assert_bps,
};
pub use crate::liquidity::{
build_add_liquidity_instruction, build_add_liquidity_transaction,
build_remove_liquidity_instruction, build_remove_liquidity_transaction,
};
fn assert_pair_fees(redemption_fee_bps: u16, discount_rate_bps: u16) -> Result<()> {
let redemption_fee = assert_bps(redemption_fee_bps, "redemption_fee_bps", None)?;
let discount_rate = assert_bps(discount_rate_bps, "discount_rate_bps", None)?;
if u32::from(redemption_fee) + u32::from(discount_rate) >= 10_000 {
return Err(SdkError::InvalidInput(
"redemption_fee_bps + discount_rate_bps must be less than 10000 bps".into(),
));
}
Ok(())
}
pub async fn build_init_pair_instruction<R: Rpc + ?Sized>(
rpc: &R,
params: &InitPairParams,
program_id: &Pubkey,
) -> Result<BuildInitPairInstructionResult> {
assert_pair_fees(params.redemption_fee_bps, params.discount_rate_bps)?;
let (quote_mint, base_mint) = canonicalize_pair_mints(¶ms.mint_a, ¶ms.mint_b)?;
let contexts = fetch_mint_account_contexts(rpc, &[quote_mint, base_mint]).await?;
let [quote_context, base_context] = contexts.as_slice() else {
return Err(SdkError::InvalidAccount(
"Missing pair mint account context".into(),
));
};
let global_config = derive_global_config(program_id).0;
let global = fetch_global_config(rpc, program_id, Some(&global_config)).await?;
let fee_contexts = fetch_mint_account_contexts(rpc, &[global.fee_token_mint]).await?;
let fee_context = fee_contexts
.first()
.ok_or_else(|| SdkError::InvalidAccount("Missing fee mint account context".into()))?;
let quote_asset_config = derive_asset_config("e_mint, program_id).0;
let base_asset_config = derive_asset_config(&base_mint, program_id).0;
let quote_config = fetch_asset_config(rpc, "e_asset_config).await?;
let base_config = fetch_asset_config(rpc, &base_asset_config).await?;
if quote_config.mint_address != quote_mint || base_config.mint_address != base_mint {
return Err(SdkError::InvalidAccount(
"Pair asset config mint does not match its canonical mint".into(),
));
}
let lp = ¶ms.liquidity_provider;
let lp_stable_config_quote = (quote_config.asset_type == AssetType::Stable)
.then(|| derive_lp_stable_config("e_mint, lp, program_id).0);
let lp_stable_config_base = (base_config.asset_type == AssetType::Stable)
.then(|| derive_lp_stable_config(&base_mint, lp, program_id).0);
let accounts = InitPairAccountKeys {
liquidity_provider: *lp,
pair: derive_pair(lp, "e_mint, &base_mint, program_id).0,
quote_token_mint_address: quote_mint,
base_token_mint_address: base_mint,
lp_vault_authority: derive_vault_authority(lp, program_id).0,
lp_fee_vault_authority: derive_lp_fee_vault_authority(lp, program_id).0,
quote_token_vault_token_account: derive_vault(
lp,
"e_mint,
"e_context.token_program,
program_id,
)
.0,
base_token_vault_token_account: derive_vault(
lp,
&base_mint,
&base_context.token_program,
program_id,
)
.0,
lp_vault_quote_pda: derive_user_vault_info("e_mint, lp, program_id).0,
lp_vault_base_pda: derive_user_vault_info(&base_mint, lp, program_id).0,
global_config,
fee_token_mint_address: global.fee_token_mint,
lp_fee_token_account: derive_lp_fee_vault(
&global.fee_token_mint,
lp,
&fee_context.token_program,
program_id,
)
.0,
lp_stable_config_quote: lp_stable_config_quote.unwrap_or(*program_id),
lp_stable_config_base: lp_stable_config_base.unwrap_or(*program_id),
quote_asset_config,
base_asset_config,
token_program_quote: quote_context.token_program,
token_program_base: base_context.token_program,
token_program_fee: fee_context.token_program,
associated_token_program: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
system_program: SYSTEM_PROGRAM_ADDRESS,
};
let instruction = InitPairAccounts {
liquidity_provider: accounts.liquidity_provider,
pair: accounts.pair,
quote_token_mint_address: accounts.quote_token_mint_address,
base_token_mint_address: accounts.base_token_mint_address,
lp_vault_authority: accounts.lp_vault_authority,
lp_fee_vault_authority: accounts.lp_fee_vault_authority,
quote_token_vault_token_account: accounts.quote_token_vault_token_account,
base_token_vault_token_account: accounts.base_token_vault_token_account,
lp_vault_quote_pda: accounts.lp_vault_quote_pda,
lp_vault_base_pda: accounts.lp_vault_base_pda,
global_config: accounts.global_config,
fee_token_mint_address: accounts.fee_token_mint_address,
lp_fee_token_account: accounts.lp_fee_token_account,
lp_stable_config_quote,
lp_stable_config_base,
quote_asset_config: accounts.quote_asset_config,
base_asset_config: accounts.base_asset_config,
token_program_quote: accounts.token_program_quote,
token_program_base: accounts.token_program_base,
token_program_fee: accounts.token_program_fee,
associated_token_program: accounts.associated_token_program,
system_program: accounts.system_program,
}
.instruction(
*program_id,
&InitPairArgs {
redemption_fee_bps: params.redemption_fee_bps,
discount_rate_bps: params.discount_rate_bps,
},
&[],
)?;
Ok(BuildInitPairInstructionResult {
instruction,
accounts,
})
}
pub async fn build_init_pair_transaction<R: Rpc + ?Sized>(
rpc: &R,
params: &InitPairParams,
program_id: &Pubkey,
) -> Result<BuildInitPairTransactionResult> {
let result = build_init_pair_instruction(rpc, params, program_id).await?;
let transaction =
build_unsigned_transaction(rpc, ¶ms.liquidity_provider, &[result.instruction]).await?;
Ok(BuildInitPairTransactionResult {
transaction,
accounts: result.accounts,
})
}
pub async fn build_update_pair_instruction<R: Rpc + ?Sized>(
rpc: &R,
params: &UpdatePairParams,
program_id: &Pubkey,
) -> Result<BuildUpdatePairInstructionResult> {
assert_pair_fees(params.redemption_fee_bps, params.discount_rate_bps)?;
let resolved = resolve_swap_pair(
rpc,
¶ms.mint_a,
¶ms.mint_b,
¶ms.liquidity_provider,
program_id,
params.pair_address.as_ref(),
)
.await?;
let accounts = UpdatePairAccountKeys {
liquidity_provider: params.liquidity_provider,
pair: resolved.pair_address,
quote_token_mint_address: resolved.quote_mint,
base_token_mint_address: resolved.base_mint,
global_config: derive_global_config(program_id).0,
};
let instruction = UpdatePairAccounts {
liquidity_provider: accounts.liquidity_provider,
pair: accounts.pair,
quote_token_mint_address: accounts.quote_token_mint_address,
base_token_mint_address: accounts.base_token_mint_address,
global_config: accounts.global_config,
}
.instruction(
*program_id,
&UpdatePairArgs {
redemption_fee_bps: params.redemption_fee_bps,
discount_rate_bps: params.discount_rate_bps,
paused: params.paused,
},
&[],
)?;
Ok(BuildUpdatePairInstructionResult {
instruction,
accounts,
})
}
pub async fn build_update_pair_transaction<R: Rpc + ?Sized>(
rpc: &R,
params: &UpdatePairParams,
program_id: &Pubkey,
) -> Result<BuildUpdatePairTransactionResult> {
let result = build_update_pair_instruction(rpc, params, program_id).await?;
let transaction =
build_unsigned_transaction(rpc, ¶ms.liquidity_provider, &[result.instruction]).await?;
Ok(BuildUpdatePairTransactionResult {
transaction,
accounts: result.accounts,
})
}
async fn resolve_owned_token_account<R: Rpc + ?Sized>(
rpc: &R,
owner: &Pubkey,
context: &MintAccountContext,
token_account: Option<Pubkey>,
auto_create_ata: bool,
) -> Result<(Pubkey, Option<Instruction>)> {
if let Some(token_account) = token_account {
return Ok((token_account, None));
}
if auto_create_ata {
ensure_ata_instructions(rpc, owner, &context.mint, &context.token_program, owner).await
} else {
Ok((
derive_associated_token_account(owner, &context.mint, &context.token_program).0,
None,
))
}
}
async fn resolve_close_pair_transfer_hook_accounts<R: Rpc + ?Sized>(
rpc: &R,
context: &MintAccountContext,
vault: &Pubkey,
recipient: &Pubkey,
authority: &Pubkey,
used: u16,
recipient_requires_setup: bool,
) -> Result<Vec<AccountMeta>> {
if used != 1 || context.transfer_hook_program.is_none() {
return Ok(Vec::new());
}
if recipient_requires_setup {
return Err(SdkError::InvalidAccount(format!(
"Unable to resolve close_pair transfer-hook accounts for mint {}. The LP recipient token account is missing on-chain and would be created by setup instructions, but transfer-hook account resolution can only inspect current on-chain account data. Pre-create the LP recipient token account or pass an existing token account override.",
context.mint,
)));
}
let amount = read_token_account_amount(rpc, vault, &context.token_program).await?;
resolve_transfer_hook_accounts_for_program(
rpc,
&context.mint,
context.transfer_hook_program.as_ref(),
&[TransferHookTransfer {
source: *vault,
destination: *recipient,
authority: *authority,
amount,
}],
)
.await
}
pub async fn build_close_pair_instruction<R: Rpc + ?Sized>(
rpc: &R,
params: &ClosePairParams,
program_id: &Pubkey,
) -> Result<BuildClosePairInstructionResult> {
let resolved = resolve_swap_pair(
rpc,
¶ms.mint_a,
¶ms.mint_b,
¶ms.liquidity_provider,
program_id,
params.pair_address.as_ref(),
)
.await?;
let contexts =
fetch_mint_account_contexts(rpc, &[resolved.quote_mint, resolved.base_mint]).await?;
let [quote_context, base_context] = contexts.as_slice() else {
return Err(SdkError::InvalidAccount(
"Missing pair mint account context".into(),
));
};
let lp = ¶ms.liquidity_provider;
let global_config = derive_global_config(program_id).0;
let admin = match params.admin {
Some(admin) => admin,
None => {
fetch_global_config(rpc, program_id, Some(&global_config))
.await?
.admin
}
};
let lp_vault_authority = derive_vault_authority(lp, program_id).0;
let quote_vault = derive_vault(
lp,
&resolved.quote_mint,
"e_context.token_program,
program_id,
)
.0;
let base_vault = derive_vault(
lp,
&resolved.base_mint,
&base_context.token_program,
program_id,
)
.0;
let lp_vault_quote_pda = derive_user_vault_info(&resolved.quote_mint, lp, program_id).0;
let lp_vault_base_pda = derive_user_vault_info(&resolved.base_mint, lp, program_id).0;
let quote_used = fetch_user_vault_info_used(rpc, &lp_vault_quote_pda).await?;
let base_used = fetch_user_vault_info_used(rpc, &lp_vault_base_pda).await?;
if quote_used == 0 || base_used == 0 {
return Err(SdkError::InvalidAccount(
"Invalid UserVaultInfo.used: close_pair would underflow".into(),
));
}
let (quote_override, base_override) = if resolved.quote_mint == params.mint_a {
(
params.lp_mint_a_token_account,
params.lp_mint_b_token_account,
)
} else {
(
params.lp_mint_b_token_account,
params.lp_mint_a_token_account,
)
};
let auto_create_ata = params.auto_create_ata.unwrap_or(true);
let (quote_recipient, quote_setup) =
resolve_owned_token_account(rpc, lp, quote_context, quote_override, auto_create_ata)
.await?;
let (base_recipient, base_setup) =
resolve_owned_token_account(rpc, lp, base_context, base_override, auto_create_ata).await?;
let mut hook_accounts = resolve_close_pair_transfer_hook_accounts(
rpc,
quote_context,
"e_vault,
"e_recipient,
&lp_vault_authority,
quote_used,
quote_setup.is_some(),
)
.await?;
hook_accounts.extend(
resolve_close_pair_transfer_hook_accounts(
rpc,
base_context,
&base_vault,
&base_recipient,
&lp_vault_authority,
base_used,
base_setup.is_some(),
)
.await?,
);
hook_accounts.extend_from_slice(params.remaining_accounts.as_deref().unwrap_or_default());
let accounts = ClosePairAccountKeys {
admin,
liquidity_provider: *lp,
pair: resolved.pair_address,
quote_token_mint_address: resolved.quote_mint,
base_token_mint_address: resolved.base_mint,
lp_vault_authority,
quote_token_vault_token_account: quote_vault,
base_token_vault_token_account: base_vault,
lp_quote_token_account: quote_recipient,
lp_base_token_account: base_recipient,
lp_vault_quote_pda,
lp_vault_base_pda,
quote_asset_config: derive_asset_config(&resolved.quote_mint, program_id).0,
base_asset_config: derive_asset_config(&resolved.base_mint, program_id).0,
global_config,
lp_protocol_fee_config: derive_lp_protocol_fee_config(lp, program_id).0,
treasury_user_position: derive_treasury_user_position(
&lp_vault_authority,
&TREASURY_PROGRAM_ADDRESS_DEVNET,
)
.0,
token_program_quote: quote_context.token_program,
token_program_base: base_context.token_program,
remaining_accounts: merge_account_metas(&hook_accounts),
};
let instruction = ClosePairAccounts {
admin: accounts.admin,
liquidity_provider: accounts.liquidity_provider,
pair: accounts.pair,
quote_token_mint_address: accounts.quote_token_mint_address,
base_token_mint_address: accounts.base_token_mint_address,
lp_vault_authority: accounts.lp_vault_authority,
quote_token_vault_token_account: accounts.quote_token_vault_token_account,
base_token_vault_token_account: accounts.base_token_vault_token_account,
lp_quote_token_account: accounts.lp_quote_token_account,
lp_base_token_account: accounts.lp_base_token_account,
lp_vault_quote_pda: accounts.lp_vault_quote_pda,
lp_vault_base_pda: accounts.lp_vault_base_pda,
quote_asset_config: accounts.quote_asset_config,
base_asset_config: accounts.base_asset_config,
global_config: accounts.global_config,
lp_protocol_fee_config: accounts.lp_protocol_fee_config,
treasury_user_position: accounts.treasury_user_position,
token_program_quote: accounts.token_program_quote,
token_program_base: accounts.token_program_base,
}
.instruction(*program_id, &ClosePairArgs {}, &accounts.remaining_accounts)?;
let setup_instructions = quote_setup.into_iter().chain(base_setup).collect();
Ok(BuildClosePairInstructionResult {
instruction,
setup_instructions,
accounts,
})
}
pub async fn build_close_pair_transaction<R: Rpc + ?Sized>(
rpc: &R,
params: &ClosePairParams,
program_id: &Pubkey,
) -> Result<BuildClosePairTransactionResult> {
let result = build_close_pair_instruction(rpc, params, program_id).await?;
let mut instructions = result.setup_instructions;
instructions.push(result.instruction);
let transaction =
build_unsigned_transaction(rpc, ¶ms.liquidity_provider, &instructions).await?;
Ok(BuildClosePairTransactionResult {
transaction,
accounts: result.accounts,
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{
constants::{SPL_TOKEN_PROGRAM_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS},
generated::swap::{AssetConfig, GlobalConfig, Pair, UserVaultInfo},
rpc::{RpcFilter, SimulationResult},
};
use async_trait::async_trait;
use solana_sdk::{
account::Account, hash::Hash, message::VersionedMessage, signature::Signature,
transaction::VersionedTransaction,
};
use std::{
collections::HashMap,
sync::atomic::{AtomicUsize, Ordering},
};
const PROGRAM: Pubkey = Pubkey::new_from_array([90; 32]);
const LP: Pubkey = Pubkey::new_from_array([40; 32]);
const LOW: Pubkey = Pubkey::new_from_array([1; 32]);
const HIGH: Pubkey = Pubkey::new_from_array([16; 32]);
const FEE: Pubkey = Pubkey::new_from_array([27; 32]);
const ADMIN: Pubkey = Pubkey::new_from_array([41; 32]);
const HOOK: Pubkey = Pubkey::new_from_array([42; 32]);
#[derive(Default)]
struct MemoryRpc {
accounts: HashMap<Pubkey, Account>,
reads: AtomicUsize,
fail_on: Option<Pubkey>,
}
#[async_trait]
impl Rpc for MemoryRpc {
async fn get_account(&self, address: &Pubkey) -> Result<Option<Account>> {
self.reads.fetch_add(1, Ordering::Relaxed);
if self.fail_on.as_ref() == Some(address) {
return Err(SdkError::Rpc("test transport failure".into()));
}
Ok(self.accounts.get(address).cloned())
}
async fn get_program_accounts(
&self,
_: &Pubkey,
_: &[RpcFilter],
) -> Result<Vec<(Pubkey, Account)>> {
panic!("unexpected program accounts 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([43; 32]))
}
async fn get_transaction_logs(&self, _: &str) -> Result<Option<Vec<String>>> {
panic!("unexpected transaction 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(owner: Pubkey, hook: Option<Pubkey>) -> Account {
let mut data = vec![0; 82];
data[44] = 6;
data[45] = 1;
if let Some(hook) = hook {
data.resize(166, 0);
data[165] = 1;
data.extend(14_u16.to_le_bytes());
data.extend(64_u16.to_le_bytes());
data.extend([0; 32]);
data.extend(hook.to_bytes());
}
account(owner, data)
}
fn asset(mint_address: Pubkey, asset_type: AssetType) -> Account {
account(
PROGRAM,
AssetConfig {
mint_address,
asset_type,
nav_data: Vec::new(),
price_difference_bps: 100,
paused: false,
version: 1,
used_in_pairs_count: 1,
bump: 0,
padding: Vec::new(),
}
.encode()
.unwrap(),
)
}
fn init_fixture() -> (MemoryRpc, InitPairParams) {
let mut rpc = MemoryRpc::default();
rpc.accounts
.insert(LOW, mint(SPL_TOKEN_PROGRAM_ADDRESS, None));
rpc.accounts
.insert(HIGH, mint(TOKEN_2022_PROGRAM_ADDRESS, None));
rpc.accounts
.insert(FEE, mint(TOKEN_2022_PROGRAM_ADDRESS, None));
rpc.accounts.insert(
derive_global_config(&PROGRAM).0,
account(
PROGRAM,
GlobalConfig {
admin: ADMIN,
fee_wallet: ADMIN,
protocol_fees_bps: 100,
paused: false,
pending_new_admin: None,
bump: 0,
fee_token_mint: FEE,
spread_protocol_fees_bps: 50,
padding: [0; 94],
}
.encode()
.unwrap(),
),
);
rpc.accounts.insert(
derive_asset_config(&LOW, &PROGRAM).0,
asset(LOW, AssetType::Rwa),
);
rpc.accounts.insert(
derive_asset_config(&HIGH, &PROGRAM).0,
asset(HIGH, AssetType::Stable),
);
(
rpc,
InitPairParams {
liquidity_provider: LP,
mint_a: HIGH,
mint_b: LOW,
redemption_fee_bps: 25,
discount_rate_bps: 50,
},
)
}
fn put_pair(rpc: &mut MemoryRpc, quote: Pubkey, base: Pubkey) -> Pubkey {
let (address, bump) = derive_pair(&LP, "e, &base, &PROGRAM);
rpc.accounts.insert(
address,
account(
PROGRAM,
Pair {
redemption_fee_bps: 25,
discount_rate_bps: 50,
quote_token_mint_address: quote,
base_token_mint_address: base,
liquidity_provider: LP,
paused: false,
bump,
padding: [0; 128],
}
.encode()
.unwrap(),
),
);
address
}
fn put_usage(rpc: &mut MemoryRpc, mint: Pubkey, used: u16) {
let (address, bump) = derive_user_vault_info(&mint, &LP, &PROGRAM);
rpc.accounts.insert(
address,
account(
PROGRAM,
UserVaultInfo {
user: LP,
mint_address: mint,
used,
bump,
padding: [0; 128],
}
.encode()
.unwrap(),
),
);
}
fn close_fixture(quote_used: u16, base_used: u16) -> (MemoryRpc, ClosePairParams) {
let (mut rpc, _) = init_fixture();
put_pair(&mut rpc, HIGH, LOW);
put_usage(&mut rpc, HIGH, quote_used);
put_usage(&mut rpc, LOW, base_used);
rpc.accounts
.insert(HIGH, mint(TOKEN_2022_PROGRAM_ADDRESS, Some(HOOK)));
(
rpc,
ClosePairParams {
liquidity_provider: LP,
mint_a: LOW,
mint_b: HIGH,
pair_address: None,
admin: None,
lp_mint_a_token_account: None,
lp_mint_b_token_account: None,
auto_create_ata: Some(false),
remaining_accounts: None,
},
)
}
fn token_account(amount: u64) -> Account {
let mut data = vec![0; 165];
data[..32].copy_from_slice(HIGH.as_ref());
data[32..64].copy_from_slice(LP.as_ref());
data[64..72].copy_from_slice(&amount.to_le_bytes());
data[108] = 1;
account(TOKEN_2022_PROGRAM_ADDRESS, data)
}
fn put_hook_validation(rpc: &mut MemoryRpc, seeds: &[u8]) -> Pubkey {
let validation =
Pubkey::find_program_address(&[b"extra-account-metas", HIGH.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 config = [0; 32];
config[..seeds.len()].copy_from_slice(seeds);
data.extend(config);
data.extend([0, 1]); rpc.accounts.insert(validation, account(HOOK, data));
validation
}
#[tokio::test]
async fn initialization_uses_byte_order_and_the_actual_stable_side_and_token_programs() {
let (rpc, params) = init_fixture();
assert!(LOW.to_bytes() < HIGH.to_bytes());
assert!(LOW.to_string() > HIGH.to_string());
let result = build_init_pair_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap();
let accounts = result.accounts;
assert_eq!(accounts.pair, derive_pair(&LP, &LOW, &HIGH, &PROGRAM).0);
assert_eq!(accounts.token_program_quote, SPL_TOKEN_PROGRAM_ADDRESS);
assert_eq!(accounts.token_program_base, TOKEN_2022_PROGRAM_ADDRESS);
assert_eq!(
accounts.quote_token_vault_token_account,
derive_vault(&LP, &LOW, &SPL_TOKEN_PROGRAM_ADDRESS, &PROGRAM).0
);
assert_eq!(
accounts.base_token_vault_token_account,
derive_vault(&LP, &HIGH, &TOKEN_2022_PROGRAM_ADDRESS, &PROGRAM).0
);
assert_eq!(
accounts.lp_fee_token_account,
derive_lp_fee_vault(&FEE, &LP, &TOKEN_2022_PROGRAM_ADDRESS, &PROGRAM).0
);
assert_eq!(result.instruction.accounts[0], AccountMeta::new(LP, true));
assert_eq!(
result.instruction.accounts[13],
AccountMeta::new_readonly(PROGRAM, false)
);
assert_eq!(
result.instruction.accounts[14],
AccountMeta::new(derive_lp_stable_config(&HIGH, &LP, &PROGRAM).0, false)
);
}
#[tokio::test]
async fn initialization_rejects_asset_configs_for_a_different_mint() {
let (mut rpc, params) = init_fixture();
rpc.accounts.insert(
derive_asset_config(&HIGH, &PROGRAM).0,
asset(LOW, AssetType::Stable),
);
assert!(matches!(
build_init_pair_instruction(&rpc, ¶ms, &PROGRAM).await,
Err(SdkError::InvalidAccount(_))
));
}
#[tokio::test]
async fn pair_fee_boundary_is_enforced_before_rpc_and_encodes_the_valid_limit() {
let (rpc, mut params) = init_fixture();
params.redemption_fee_bps = 9_900;
params.discount_rate_bps = 100;
assert!(matches!(
build_init_pair_instruction(&rpc, ¶ms, &PROGRAM).await,
Err(SdkError::InvalidInput(_))
));
let update = UpdatePairParams {
liquidity_provider: LP,
mint_a: LOW,
mint_b: HIGH,
pair_address: None,
redemption_fee_bps: 9_900,
discount_rate_bps: 100,
paused: false,
};
assert!(matches!(
build_update_pair_instruction(&rpc, &update, &PROGRAM).await,
Err(SdkError::InvalidInput(_))
));
assert_eq!(rpc.reads.load(Ordering::Relaxed), 0);
params.discount_rate_bps = 99;
let result = build_init_pair_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap();
assert_eq!(
InitPairArgs::decode(&result.instruction.data).unwrap(),
InitPairArgs {
redemption_fee_bps: 9_900,
discount_rate_bps: 99,
}
);
}
#[tokio::test]
async fn legacy_pair_order_and_recipient_overrides_survive_explicit_disambiguation() {
let (mut rpc, mut close) = close_fixture(2, 2);
put_pair(&mut rpc, LOW, HIGH);
let mut update = UpdatePairParams {
liquidity_provider: LP,
mint_a: LOW,
mint_b: HIGH,
pair_address: None,
redemption_fee_bps: 10,
discount_rate_bps: 20,
paused: true,
};
assert!(build_update_pair_instruction(&rpc, &update, &PROGRAM)
.await
.is_err());
assert!(build_close_pair_instruction(&rpc, &close, &PROGRAM)
.await
.is_err());
let pair = derive_pair(&LP, &HIGH, &LOW, &PROGRAM).0;
update.pair_address = Some(pair);
close.pair_address = Some(pair);
close.lp_mint_a_token_account = Some(Pubkey::new_from_array([60; 32]));
close.lp_mint_b_token_account = Some(Pubkey::new_from_array([61; 32]));
let updated = build_update_pair_instruction(&rpc, &update, &PROGRAM)
.await
.unwrap();
let closed = build_close_pair_instruction(&rpc, &close, &PROGRAM)
.await
.unwrap();
assert_eq!(
updated.instruction.accounts[0],
AccountMeta::new_readonly(LP, true)
);
assert_eq!(
updated.instruction.accounts[1],
AccountMeta::new(pair, false)
);
assert_eq!(updated.instruction.accounts[2].pubkey, HIGH);
assert_eq!(updated.instruction.accounts[3].pubkey, LOW);
assert_eq!(
UpdatePairArgs::decode(&updated.instruction.data).unwrap(),
UpdatePairArgs {
redemption_fee_bps: 10,
discount_rate_bps: 20,
paused: true,
}
);
assert_eq!(
closed.instruction.accounts[0],
AccountMeta::new_readonly(ADMIN, false)
);
assert_eq!(closed.instruction.accounts[1], AccountMeta::new(LP, true));
assert_eq!(closed.instruction.accounts[2].pubkey, pair);
assert_eq!(
closed.instruction.accounts[8].pubkey,
close.lp_mint_b_token_account.unwrap()
);
assert_eq!(
closed.instruction.accounts[9].pubkey,
close.lp_mint_a_token_account.unwrap()
);
assert_eq!(
closed.accounts.token_program_quote,
TOKEN_2022_PROGRAM_ADDRESS
);
assert_eq!(
closed.accounts.token_program_base,
SPL_TOKEN_PROGRAM_ADDRESS
);
assert_eq!(
closed.instruction.accounts[16].pubkey,
derive_treasury_user_position(
&derive_vault_authority(&LP, &PROGRAM).0,
&TREASURY_PROGRAM_ADDRESS_DEVNET
)
.0
);
}
#[tokio::test]
async fn shared_vault_counts_above_u8_skip_hooks_and_missing_vault_balances() {
let (mut rpc, mut params) = close_fixture(257, u16::MAX);
rpc.accounts
.insert(LOW, mint(TOKEN_2022_PROGRAM_ADDRESS, Some(HOOK)));
params.auto_create_ata = None;
let caller = Pubkey::new_from_array([62; 32]);
params.remaining_accounts = Some(vec![
AccountMeta::new_readonly(caller, true),
AccountMeta::new(caller, false),
]);
let result = build_close_pair_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap();
assert_eq!(result.setup_instructions.len(), 2);
assert_eq!(
&result.instruction.accounts[19..],
&[AccountMeta::new(caller, true)]
);
}
#[tokio::test]
async fn close_rejects_usage_underflow_on_either_side() {
for (quote_used, base_used) in [(0, 1), (1, 0)] {
let (rpc, params) = close_fixture(quote_used, base_used);
assert!(matches!(
build_close_pair_instruction(&rpc, ¶ms, &PROGRAM).await,
Err(SdkError::InvalidAccount(_))
));
}
}
#[tokio::test]
async fn hook_recipient_cannot_be_created_during_resolution_or_missing_seed_reads() {
let (mut rpc, mut params) = close_fixture(1, 2);
params.auto_create_ata = None;
let vault = derive_vault(&LP, &HIGH, &TOKEN_2022_PROGRAM_ADDRESS, &PROGRAM).0;
rpc.accounts.insert(vault, token_account(73));
put_hook_validation(&mut rpc, &[4, 2, 0, 1]);
assert!(matches!(
build_close_pair_instruction(&rpc, ¶ms, &PROGRAM).await,
Err(SdkError::InvalidAccount(_))
));
params.auto_create_ata = Some(false);
params.lp_mint_b_token_account = Some(Pubkey::new_from_array([63; 32]));
assert!(matches!(
build_close_pair_instruction(&rpc, ¶ms, &PROGRAM).await,
Err(SdkError::InvalidAccount(_))
));
rpc.accounts
.insert(params.lp_mint_b_token_account.unwrap(), token_account(0));
let result = build_close_pair_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap();
let expected = Pubkey::find_program_address(&[&HIGH.to_bytes()[..1]], &HOOK).0;
assert_eq!(
result.instruction.accounts[19],
AccountMeta::new(expected, false)
);
}
#[tokio::test]
async fn hook_balance_snapshot_and_caller_privileges_are_preserved_including_zero() {
for amount in [0, 0x1234] {
let (mut rpc, mut params) = close_fixture(1, 2);
let vault = derive_vault(&LP, &HIGH, &TOKEN_2022_PROGRAM_ADDRESS, &PROGRAM).0;
rpc.accounts.insert(vault, token_account(amount));
let validation = put_hook_validation(&mut rpc, &[2, 8, 8]);
let extra = Pubkey::find_program_address(&[&amount.to_le_bytes()], &HOOK).0;
let caller = Pubkey::new_from_array([64; 32]);
params.remaining_accounts = Some(vec![
AccountMeta::new_readonly(extra, true),
AccountMeta::new(caller, true),
]);
let result = build_close_pair_instruction(&rpc, ¶ms, &PROGRAM)
.await
.unwrap();
assert_eq!(
&result.instruction.accounts[19..],
&[
AccountMeta::new(extra, true),
AccountMeta::new_readonly(HOOK, false),
AccountMeta::new_readonly(validation, false),
AccountMeta::new(caller, true),
]
);
}
}
#[tokio::test]
async fn close_never_substitutes_zero_for_missing_or_failed_balance_reads() {
let (mut rpc, params) = close_fixture(1, 2);
let vault = derive_vault(&LP, &HIGH, &TOKEN_2022_PROGRAM_ADDRESS, &PROGRAM).0;
assert!(
matches!(build_close_pair_instruction(&rpc, ¶ms, &PROGRAM).await,
Err(SdkError::AccountNotFound(address)) if address == vault)
);
rpc.fail_on = Some(vault);
assert!(matches!(
build_close_pair_instruction(&rpc, ¶ms, &PROGRAM).await,
Err(SdkError::Rpc(_))
));
}
#[tokio::test]
async fn transactions_include_setup_in_order_and_remain_unsigned() {
let (rpc, init_params) = init_fixture();
let initialized = build_init_pair_transaction(&rpc, &init_params, &PROGRAM)
.await
.unwrap();
let VersionedMessage::V0(init_message) = initialized.transaction.message else {
panic!("expected v0 initialization message")
};
assert_eq!(
init_message.instructions[0].data,
InitPairArgs {
redemption_fee_bps: 25,
discount_rate_bps: 50
}
.encode()
.unwrap()
);
let (rpc, mut close_params) = close_fixture(2, 2);
let update_params = UpdatePairParams {
liquidity_provider: LP,
mint_a: LOW,
mint_b: HIGH,
pair_address: None,
redemption_fee_bps: 10,
discount_rate_bps: 20,
paused: true,
};
let updated = build_update_pair_transaction(&rpc, &update_params, &PROGRAM)
.await
.unwrap();
let VersionedMessage::V0(update_message) = updated.transaction.message else {
panic!("expected v0 update message")
};
assert_eq!(
update_message.instructions[0].data,
UpdatePairArgs {
redemption_fee_bps: 10,
discount_rate_bps: 20,
paused: true,
}
.encode()
.unwrap()
);
close_params.auto_create_ata = None;
let extra_signer = Pubkey::new_from_array([65; 32]);
close_params.remaining_accounts = Some(vec![AccountMeta::new_readonly(extra_signer, true)]);
let closed = build_close_pair_transaction(&rpc, &close_params, &PROGRAM)
.await
.unwrap();
assert_eq!(closed.transaction.signatures, vec![Signature::default(); 2]);
let VersionedMessage::V0(message) = closed.transaction.message else {
panic!("expected v0 closure message")
};
assert_eq!(message.account_keys[0], LP);
assert_eq!(message.recent_blockhash, Hash::new_from_array([43; 32]));
assert_eq!(message.instructions.len(), 3);
assert_eq!(
message.account_keys[message.instructions[0].program_id_index as usize],
ASSOCIATED_TOKEN_PROGRAM_ADDRESS
);
assert_eq!(
message.account_keys[message.instructions[1].program_id_index as usize],
ASSOCIATED_TOKEN_PROGRAM_ADDRESS
);
let close = &message.instructions[2];
assert_eq!(
message.account_keys[close.program_id_index as usize],
PROGRAM
);
assert_eq!(close.data, ClosePairArgs {}.encode().unwrap());
assert_eq!(
message.account_keys[close.accounts[8] as usize],
derive_associated_token_account(&LP, &HIGH, &TOKEN_2022_PROGRAM_ADDRESS).0
);
assert_eq!(
message.account_keys[close.accounts[9] as usize],
derive_associated_token_account(&LP, &LOW, &SPL_TOKEN_PROGRAM_ADDRESS).0
);
}
}