use std::cmp::Ordering;
use solana_sdk::pubkey::Pubkey;
use crate::constants::{
ASSET_CONFIG_PREFIX, ASSOCIATED_TOKEN_PROGRAM_ADDRESS, BPF_UPGRADEABLE_LOADER_ADDRESS,
GLOBAL_CONFIG_PREFIX, LP_FEE_VAULT_AUTHORITY_PREFIX, LP_PROTOCOL_FEE_CONFIG_PREFIX,
LP_STABLE_CONFIG_PREFIX, PAIR_PREFIX, PROGRAM_AUTHORITY_PREFIX, TREASURY_APY_ENTRY_PREFIX,
TREASURY_ASSET_CONFIG_PREFIX, TREASURY_GLOBAL_CONFIG_PREFIX, TREASURY_USER_POSITION_PREFIX,
TREASURY_VAULT_AUTHORITY_PREFIX, USER_VAULT_PREFIX, VAULT_AUTHORITY_PREFIX,
};
use crate::error::{Result, SdkError};
pub fn canonicalize_pair_mints(mint_a: &Pubkey, mint_b: &Pubkey) -> Result<(Pubkey, Pubkey)> {
match mint_a.as_ref().cmp(mint_b.as_ref()) {
Ordering::Less => Ok((*mint_a, *mint_b)),
Ordering::Greater => Ok((*mint_b, *mint_a)),
Ordering::Equal => Err(SdkError::InvalidInput(
"Pair mints must be different".into(),
)),
}
}
pub fn derive_global_config(program_id: &Pubkey) -> (Pubkey, u8) {
Pubkey::find_program_address(&[GLOBAL_CONFIG_PREFIX], program_id)
}
pub fn derive_asset_config(mint: &Pubkey, program_id: &Pubkey) -> (Pubkey, u8) {
Pubkey::find_program_address(&[ASSET_CONFIG_PREFIX, mint.as_ref()], program_id)
}
pub fn derive_pair(
liquidity_provider: &Pubkey,
quote_mint: &Pubkey,
base_mint: &Pubkey,
program_id: &Pubkey,
) -> (Pubkey, u8) {
Pubkey::find_program_address(
&[
PAIR_PREFIX,
liquidity_provider.as_ref(),
quote_mint.as_ref(),
base_mint.as_ref(),
],
program_id,
)
}
pub fn derive_associated_token_account(
owner: &Pubkey,
mint: &Pubkey,
token_program: &Pubkey,
) -> (Pubkey, u8) {
Pubkey::find_program_address(
&[owner.as_ref(), token_program.as_ref(), mint.as_ref()],
&ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
)
}
pub fn derive_vault_authority(liquidity_provider: &Pubkey, program_id: &Pubkey) -> (Pubkey, u8) {
Pubkey::find_program_address(
&[VAULT_AUTHORITY_PREFIX, liquidity_provider.as_ref()],
program_id,
)
}
pub fn derive_vault(
liquidity_provider: &Pubkey,
mint: &Pubkey,
token_program: &Pubkey,
program_id: &Pubkey,
) -> (Pubkey, u8) {
let (vault_authority, _) = derive_vault_authority(liquidity_provider, program_id);
derive_associated_token_account(&vault_authority, mint, token_program)
}
pub fn derive_program_authority(program_id: &Pubkey) -> (Pubkey, u8) {
Pubkey::find_program_address(&[PROGRAM_AUTHORITY_PREFIX], program_id)
}
pub fn derive_lp_fee_vault_authority(
liquidity_provider: &Pubkey,
program_id: &Pubkey,
) -> (Pubkey, u8) {
Pubkey::find_program_address(
&[LP_FEE_VAULT_AUTHORITY_PREFIX, liquidity_provider.as_ref()],
program_id,
)
}
pub fn derive_lp_fee_vault(
fee_mint: &Pubkey,
liquidity_provider: &Pubkey,
token_program: &Pubkey,
program_id: &Pubkey,
) -> (Pubkey, u8) {
let (authority, _) = derive_lp_fee_vault_authority(liquidity_provider, program_id);
derive_associated_token_account(&authority, fee_mint, token_program)
}
pub fn derive_lp_protocol_fee_config(
liquidity_provider: &Pubkey,
program_id: &Pubkey,
) -> (Pubkey, u8) {
Pubkey::find_program_address(
&[LP_PROTOCOL_FEE_CONFIG_PREFIX, liquidity_provider.as_ref()],
program_id,
)
}
pub fn derive_fee_vault(
stable_mint: &Pubkey,
token_program: &Pubkey,
program_id: &Pubkey,
) -> (Pubkey, u8) {
let (program_authority, _) = derive_program_authority(program_id);
derive_associated_token_account(&program_authority, stable_mint, token_program)
}
pub fn derive_lp_stable_config(
stable_mint: &Pubkey,
liquidity_provider: &Pubkey,
program_id: &Pubkey,
) -> (Pubkey, u8) {
Pubkey::find_program_address(
&[
LP_STABLE_CONFIG_PREFIX,
stable_mint.as_ref(),
liquidity_provider.as_ref(),
],
program_id,
)
}
pub fn derive_user_vault_info(mint: &Pubkey, user: &Pubkey, program_id: &Pubkey) -> (Pubkey, u8) {
Pubkey::find_program_address(
&[USER_VAULT_PREFIX, mint.as_ref(), user.as_ref()],
program_id,
)
}
pub fn derive_program_data(program_id: &Pubkey) -> (Pubkey, u8) {
Pubkey::find_program_address(&[program_id.as_ref()], &BPF_UPGRADEABLE_LOADER_ADDRESS)
}
pub fn derive_treasury_global_config(program_id: &Pubkey) -> (Pubkey, u8) {
Pubkey::find_program_address(&[TREASURY_GLOBAL_CONFIG_PREFIX], program_id)
}
pub fn derive_treasury_asset_config(asset_mint: &Pubkey, program_id: &Pubkey) -> (Pubkey, u8) {
Pubkey::find_program_address(
&[TREASURY_ASSET_CONFIG_PREFIX, asset_mint.as_ref()],
program_id,
)
}
pub fn derive_treasury_apy_entry(day_start_ts: i64, program_id: &Pubkey) -> (Pubkey, u8) {
Pubkey::find_program_address(
&[TREASURY_APY_ENTRY_PREFIX, &day_start_ts.to_le_bytes()],
program_id,
)
}
pub fn derive_treasury_user_position(owner: &Pubkey, program_id: &Pubkey) -> (Pubkey, u8) {
Pubkey::find_program_address(&[TREASURY_USER_POSITION_PREFIX, owner.as_ref()], program_id)
}
pub fn derive_treasury_vault_authority(program_id: &Pubkey) -> (Pubkey, u8) {
Pubkey::find_program_address(&[TREASURY_VAULT_AUTHORITY_PREFIX], program_id)
}
pub fn derive_treasury_vault(
asset_mint: &Pubkey,
token_program: &Pubkey,
program_id: &Pubkey,
) -> (Pubkey, u8) {
let (vault_authority, _) = derive_treasury_vault_authority(program_id);
derive_associated_token_account(&vault_authority, asset_mint, token_program)
}
#[cfg(test)]
mod tests {
use solana_sdk::pubkey;
use super::*;
use crate::constants::{
PROGRAM_ADDRESS_DEVNET, PROGRAM_ADDRESS_MAINNET, SPL_TOKEN_PROGRAM_ADDRESS,
TOKEN_2022_PROGRAM_ADDRESS, TREASURY_PROGRAM_ADDRESS_DEVNET,
};
const DEVNET_PRIMARY_LP: Pubkey = pubkey!("8nxkQVjEjmd4Vv51BDnHbBALg3n9SSgNJDNEoZDGBzsR");
const DEVNET_USDC: Pubkey = pubkey!("AeQz4qPhAFxZshmv9gE3dbxyph2uaqyM4JnWk4DeH8Jo");
const DEVNET_RWA: Pubkey = pubkey!("9fBsNQ3rL2FdAYKXptwJ9nbarCDh57Xqzbsr68p9Te6j");
fn assert_pda(actual: (Pubkey, u8), expected: Pubkey, seeds: &[&[u8]], program_id: &Pubkey) {
assert_eq!(actual.0, expected);
let bump = [actual.1];
let mut signer_seeds = seeds.to_vec();
signer_seeds.push(&bump);
assert_eq!(
Pubkey::create_program_address(&signer_seeds, program_id).unwrap(),
expected,
);
}
#[test]
fn canonical_order_uses_decoded_bytes_and_rejects_identical_mints() {
let stable = pubkey!("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
let asset = pubkey!("CCz3SGVziFeLYk2xfEstkiqJfYkjaSWb2GCABYsVcjo2");
assert_eq!(
canonicalize_pair_mints(&stable, &asset).unwrap(),
(asset, stable)
);
assert_eq!(
canonicalize_pair_mints(&asset, &stable).unwrap(),
(asset, stable)
);
assert!(matches!(
canonicalize_pair_mints(&stable, &stable),
Err(SdkError::InvalidInput(_)),
));
}
#[test]
fn deployed_devnet_swap_addresses_and_signer_bumps_match() {
let program = &PROGRAM_ADDRESS_DEVNET;
let lp = &DEVNET_PRIMARY_LP;
let quote = &DEVNET_USDC;
let base = &DEVNET_RWA;
let token = &SPL_TOKEN_PROGRAM_ADDRESS;
assert_pda(
derive_global_config(program),
pubkey!("5aENbrcLXt586S2CMzSkp7rvrLWUbyaAZJ6UgCRRCDiC"),
&[b"global_config"],
program,
);
assert_pda(
derive_pair(lp, quote, base, program),
pubkey!("CFdG1zintcNbQjGwUJ4ZJb86Ais7NucmGuXjGniZsNCV"),
&[b"pair", lp.as_ref(), quote.as_ref(), base.as_ref()],
program,
);
assert_pda(
derive_lp_stable_config(quote, lp, program),
pubkey!("HbsfWxhU6hTzdmLjCsn12vD8ozU27jkHo41wcjc7zMxt"),
&[b"lp_stable_config", quote.as_ref(), lp.as_ref()],
program,
);
assert_pda(
derive_asset_config(quote, program),
pubkey!("P8PjTbQZ9xBUNMSskKuu86S3tVPCzdMZkrHtgXKYDD8"),
&[b"asset", quote.as_ref()],
program,
);
assert_pda(
derive_asset_config(base, program),
pubkey!("6JsJwfXHiDRGSGdZVD6DAkqpTxJcmQWMpViH69RoadTC"),
&[b"asset", base.as_ref()],
program,
);
let (authority, _) = derive_vault_authority(lp, program);
assert_pda(
derive_vault(lp, quote, token, program),
pubkey!("GCEgrHYMoiKwHurnafkijx9GjXSJkpwxH1b1eiixFdqx"),
&[authority.as_ref(), token.as_ref(), quote.as_ref()],
&ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
);
assert_pda(
derive_vault(lp, base, token, program),
pubkey!("8ZuL9gik6vjab5S1cFshxWDpm2SMJ8mo6ZpfpL8WZ6xN"),
&[authority.as_ref(), token.as_ref(), base.as_ref()],
&ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
);
let (program_authority, _) = derive_program_authority(program);
assert_pda(
derive_fee_vault(quote, token, program),
pubkey!("FHCUwtbTjCDjSJwUvAK9yKoWX6RgVv6JEgF23pkXfH72"),
&[program_authority.as_ref(), token.as_ref(), quote.as_ref()],
&ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
);
}
#[test]
fn token_2022_vaults_use_the_token_program_seed() {
let program = &PROGRAM_ADDRESS_DEVNET;
let lp = &DEVNET_PRIMARY_LP;
let quote = pubkey!("6KkK2kC2y93tUWoWAsN1DNiuiVrrRyuX1VsKdJqKRnhg");
let base = pubkey!("CKY7KPNrJH35CTbJYmAVKhffwA11drLESTKJ6HiPfaD2");
let token = &TOKEN_2022_PROGRAM_ADDRESS;
let (authority, _) = derive_vault_authority(lp, program);
assert_pda(
derive_vault(lp, "e, token, program),
pubkey!("5jCWFQCXd7jyV4JARMVLsTLMe1G7VHS6Qp9NUjh3KESJ"),
&[authority.as_ref(), token.as_ref(), quote.as_ref()],
&ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
);
assert_pda(
derive_vault(lp, &base, token, program),
pubkey!("BANA8YKbknt9m7KjjexokHFEn1Uwx77qF4N1vHvuQSAd"),
&[authority.as_ref(), token.as_ref(), base.as_ref()],
&ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
);
let (program_authority, _) = derive_program_authority(program);
assert_pda(
derive_fee_vault("e, token, program),
pubkey!("48nfgxTa4mPvdAJa4QGuACKDTDqRX9FMUEGSco8EQGzJ"),
&[program_authority.as_ref(), token.as_ref(), quote.as_ref()],
&ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
);
}
#[test]
fn liquidity_provider_is_part_of_pair_and_vault_domains() {
let program = &PROGRAM_ADDRESS_DEVNET;
let lp = pubkey!("Ek8hY6H1HzDWv9RsyeyhjgRrdeZCnRdvDJzdBh73c3TY");
let quote = &DEVNET_USDC;
let base = &DEVNET_RWA;
let token = &SPL_TOKEN_PROGRAM_ADDRESS;
assert_pda(
derive_pair(&lp, quote, base, program),
pubkey!("HYeKWhRBKEPP1xPKNtFyYGysbwNv6bZv1Eg92Kou7ztc"),
&[b"pair", lp.as_ref(), quote.as_ref(), base.as_ref()],
program,
);
let (authority, _) = derive_vault_authority(&lp, program);
assert_pda(
derive_vault(&lp, quote, token, program),
pubkey!("21p4sJn1vPj1Adxx9JwUFuDRHVvyWEy6V4VmRb236acz"),
&[authority.as_ref(), token.as_ref(), quote.as_ref()],
&ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
);
assert_pda(
derive_lp_stable_config(quote, &lp, program),
pubkey!("5d7KCaMxXRaooxHgzcPhF2722toLFsqMko3B7FenfrJ2"),
&[b"lp_stable_config", quote.as_ref(), lp.as_ref()],
program,
);
}
#[test]
fn deployed_mainnet_pair_preserves_quote_order_and_mixed_token_programs() {
let program = &PROGRAM_ADDRESS_MAINNET;
let lp = pubkey!("C8Mi6kn7ajFWuNe4ZmsR9A6fdqRYhzXFoqVBGMsdJ2Uf");
let quote = pubkey!("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
let base = pubkey!("CCz3SGVziFeLYk2xfEstkiqJfYkjaSWb2GCABYsVcjo2");
assert_pda(
derive_pair(&lp, "e, &base, program),
pubkey!("HTzC1qsVU4FdVC6LFty454TBYvDUUjs98QJLb7DVQAjH"),
&[b"pair", lp.as_ref(), quote.as_ref(), base.as_ref()],
program,
);
let (authority, _) = derive_vault_authority(&lp, program);
assert_pda(
derive_vault(&lp, "e, &SPL_TOKEN_PROGRAM_ADDRESS, program),
pubkey!("7W2UTuTaFw3LdffidYaPPU2u9ciqvZ3ziCphK7hbbX2S"),
&[
authority.as_ref(),
SPL_TOKEN_PROGRAM_ADDRESS.as_ref(),
quote.as_ref(),
],
&ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
);
assert_pda(
derive_vault(&lp, &base, &TOKEN_2022_PROGRAM_ADDRESS, program),
pubkey!("72XAEAAQeCFwfcKLYMgcVpt3nEBhcwJkofFzhn96JZiG"),
&[
authority.as_ref(),
TOKEN_2022_PROGRAM_ADDRESS.as_ref(),
base.as_ref(),
],
&ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
);
assert_pda(
derive_lp_stable_config("e, &lp, program),
pubkey!("6c7SUU7ahUbuPLvJutQqVH5x78oiJYtrsgrpka4Z9oMz"),
&[b"lp_stable_config", quote.as_ref(), lp.as_ref()],
program,
);
}
#[test]
fn treasury_day_seed_preserves_signed_little_endian_boundaries() {
let program = &TREASURY_PROGRAM_ADDRESS_DEVNET;
for (timestamp, bytes) in [
(i64::MIN, [0, 0, 0, 0, 0, 0, 0, 128]),
(-1, [255; 8]),
(1, [1, 0, 0, 0, 0, 0, 0, 0]),
(i64::MAX, [255, 255, 255, 255, 255, 255, 255, 127]),
] {
assert_eq!(
derive_treasury_apy_entry(timestamp, program),
Pubkey::find_program_address(&[b"APY_ENTRY", &bytes], program),
);
}
}
}