use solana_sdk::pubkey::Pubkey;
#[cfg(feature = "http")]
use crate::types::PairRegistryFetchOptions;
use crate::{
accounts,
constants::{
PROGRAM_ADDRESS_DEVNET, PROGRAM_ADDRESS_MAINNET, SPL_TOKEN_PROGRAM_ADDRESS,
TREASURY_PROGRAM_ADDRESS_DEVNET, TREASURY_PROGRAM_ADDRESS_MAINNET,
},
error::Result,
errors::{self, ParsedSimulationProgramError},
events, format, lp, pda, quote, registry, swap,
types::{
AssetConfigAccount, BuildAddLiquidityInstructionResult, BuildAddLiquidityTransactionParams,
BuildAddLiquidityTransactionResult, BuildClosePairInstructionResult,
BuildClosePairTransactionParams, BuildClosePairTransactionResult,
BuildInitPairInstructionResult, BuildInitPairTransactionParams,
BuildInitPairTransactionResult, BuildRemoveLiquidityInstructionResult,
BuildRemoveLiquidityTransactionParams, BuildRemoveLiquidityTransactionResult,
BuildSwapInstructionResult, BuildSwapTransactionParams, BuildSwapTransactionResult,
BuildUpdatePairInstructionResult, BuildUpdatePairTransactionParams,
BuildUpdatePairTransactionResult, ClosePairParams, Cluster, GlobalConfigAccount,
InitPairParams, LpLiquidityParams, LpStableConfigAccount, MultiliquidRpc, PairAccount,
PairFilters, PairRegistryEntry, PairRegistryErrorHandler, PauseStatus, SimulationQuote,
SwapExecutedEvent, SwapParams, SwapQuote, SwapState, UpdatePairParams,
},
};
#[derive(Clone)]
pub struct MultiliquidClientConfig {
pub rpc: MultiliquidRpc,
pub program_address: Option<Pubkey>,
pub cluster: Option<Cluster>,
pub registry_api_url: Option<String>,
pub registry_fetch_timeout_ms: Option<u64>,
pub on_registry_error: Option<PairRegistryErrorHandler>,
}
impl MultiliquidClientConfig {
pub fn new(rpc: MultiliquidRpc) -> Self {
Self {
rpc,
program_address: None,
cluster: None,
registry_api_url: None,
registry_fetch_timeout_ms: None,
on_registry_error: None,
}
}
}
#[derive(Clone)]
pub struct MultiliquidClient {
pub rpc: MultiliquidRpc,
pub program_address: Pubkey,
pub treasury_program_address: Pubkey,
pub cluster: Cluster,
pub registry_api_url: String,
pub registry_fetch_timeout_ms: Option<u64>,
pub on_registry_error: Option<PairRegistryErrorHandler>,
}
impl MultiliquidClient {
pub fn new(config: MultiliquidClientConfig) -> Self {
let cluster = config.cluster.unwrap_or(Cluster::Devnet);
let (program_address, treasury_program_address) = match cluster {
Cluster::Devnet => (PROGRAM_ADDRESS_DEVNET, TREASURY_PROGRAM_ADDRESS_DEVNET),
Cluster::MainnetBeta => (PROGRAM_ADDRESS_MAINNET, TREASURY_PROGRAM_ADDRESS_MAINNET),
};
Self {
rpc: config.rpc,
program_address: config.program_address.unwrap_or(program_address),
treasury_program_address,
cluster,
registry_api_url: config
.registry_api_url
.unwrap_or_else(|| registry::DEFAULT_REGISTRY_API_URL.to_owned()),
registry_fetch_timeout_ms: config.registry_fetch_timeout_ms,
on_registry_error: config.on_registry_error,
}
}
#[cfg(feature = "http")]
pub async fn get_pairs(
&self,
filters: Option<&PairFilters>,
options: Option<&PairRegistryFetchOptions>,
) -> Result<Vec<PairRegistryEntry>> {
let options = PairRegistryFetchOptions {
registry_api_url: Some(
options
.and_then(|options| options.registry_api_url.as_ref())
.unwrap_or(&self.registry_api_url)
.clone(),
),
rpc: Some(
options
.and_then(|options| options.rpc.as_ref())
.unwrap_or(&self.rpc)
.clone(),
),
timeout_ms: options
.and_then(|options| options.timeout_ms)
.or(self.registry_fetch_timeout_ms),
on_error: options
.and_then(|options| options.on_error.as_ref())
.or(self.on_registry_error.as_ref())
.cloned(),
};
registry::get_pairs(self.cluster, filters, &options).await
}
pub fn get_offline_pairs(&self, filters: Option<&PairFilters>) -> Vec<PairRegistryEntry> {
registry::get_offline_pairs(self.cluster, filters)
}
pub async fn discover_pairs(
&self,
filters: Option<&PairFilters>,
) -> Result<Vec<PairRegistryEntry>> {
registry::discover_pairs(self.rpc.as_ref(), &self.program_address, filters).await
}
pub async fn fetch_global_config(&self) -> Result<GlobalConfigAccount> {
accounts::fetch_global_config(self.rpc.as_ref(), &self.program_address, None).await
}
pub async fn fetch_pair(&self, account_address: &Pubkey) -> Result<PairAccount> {
accounts::fetch_pair(self.rpc.as_ref(), account_address).await
}
pub async fn fetch_asset_config(&self, account_address: &Pubkey) -> Result<AssetConfigAccount> {
accounts::fetch_asset_config(self.rpc.as_ref(), account_address).await
}
pub async fn fetch_lp_stable_config(
&self,
account_address: &Pubkey,
) -> Result<LpStableConfigAccount> {
accounts::fetch_lp_stable_config(self.rpc.as_ref(), account_address).await
}
pub async fn fetch_swap_state(
&self,
input_mint: &Pubkey,
output_mint: &Pubkey,
liquidity_provider: &Pubkey,
pair_address: Option<&Pubkey>,
) -> Result<SwapState> {
accounts::fetch_swap_state(
self.rpc.as_ref(),
input_mint,
output_mint,
liquidity_provider,
&self.program_address,
pair_address,
)
.await
}
pub async fn check_pause_status(
&self,
input_mint: &Pubkey,
output_mint: &Pubkey,
liquidity_provider: &Pubkey,
pair_address: Option<&Pubkey>,
) -> Result<PauseStatus> {
accounts::check_pause_status(
self.rpc.as_ref(),
input_mint,
output_mint,
liquidity_provider,
&self.program_address,
pair_address,
)
.await
}
pub fn derive_global_config(&self) -> (Pubkey, u8) {
pda::derive_global_config(&self.program_address)
}
pub fn derive_asset_config(&self, mint: &Pubkey) -> (Pubkey, u8) {
pda::derive_asset_config(mint, &self.program_address)
}
pub fn derive_pair(
&self,
liquidity_provider: &Pubkey,
first_mint: &Pubkey,
second_mint: &Pubkey,
) -> (Pubkey, u8) {
pda::derive_pair(
liquidity_provider,
first_mint,
second_mint,
&self.program_address,
)
}
pub fn derive_vault(
&self,
mint: &Pubkey,
liquidity_provider: &Pubkey,
token_program: Option<&Pubkey>,
) -> (Pubkey, u8) {
pda::derive_vault(
liquidity_provider,
mint,
token_program.unwrap_or(&SPL_TOKEN_PROGRAM_ADDRESS),
&self.program_address,
)
}
pub fn derive_vault_authority(&self, liquidity_provider: &Pubkey) -> (Pubkey, u8) {
pda::derive_vault_authority(liquidity_provider, &self.program_address)
}
pub fn derive_program_authority(&self) -> (Pubkey, u8) {
pda::derive_program_authority(&self.program_address)
}
pub fn derive_fee_vault(
&self,
fee_mint: &Pubkey,
token_program: Option<&Pubkey>,
) -> (Pubkey, u8) {
pda::derive_fee_vault(
fee_mint,
token_program.unwrap_or(&SPL_TOKEN_PROGRAM_ADDRESS),
&self.program_address,
)
}
pub fn derive_lp_stable_config(
&self,
stable_mint: &Pubkey,
liquidity_provider: &Pubkey,
) -> (Pubkey, u8) {
pda::derive_lp_stable_config(stable_mint, liquidity_provider, &self.program_address)
}
pub fn derive_user_vault_info(&self, mint: &Pubkey, user: &Pubkey) -> (Pubkey, u8) {
pda::derive_user_vault_info(mint, user, &self.program_address)
}
pub async fn get_quote(&self, params: &SwapParams) -> Result<SwapQuote> {
quote::get_quote(self.rpc.as_ref(), params, &self.program_address).await
}
pub async fn get_quote_via_simulation(&self, params: &SwapParams) -> Result<SimulationQuote> {
quote::get_quote_via_simulation(self.rpc.as_ref(), params, &self.program_address).await
}
pub async fn build_swap_instruction(
&self,
params: &SwapParams,
) -> Result<BuildSwapInstructionResult> {
swap::build_swap_instruction(self.rpc.as_ref(), params, &self.program_address).await
}
pub async fn build_swap_transaction(
&self,
params: &BuildSwapTransactionParams,
) -> Result<BuildSwapTransactionResult> {
swap::build_swap_transaction(self.rpc.as_ref(), params, &self.program_address).await
}
pub async fn build_update_pair_instruction(
&self,
params: &UpdatePairParams,
) -> Result<BuildUpdatePairInstructionResult> {
lp::build_update_pair_instruction(self.rpc.as_ref(), params, &self.program_address).await
}
pub async fn build_update_pair_transaction(
&self,
params: &BuildUpdatePairTransactionParams,
) -> Result<BuildUpdatePairTransactionResult> {
lp::build_update_pair_transaction(self.rpc.as_ref(), params, &self.program_address).await
}
pub async fn build_init_pair_instruction(
&self,
params: &InitPairParams,
) -> Result<BuildInitPairInstructionResult> {
lp::build_init_pair_instruction(self.rpc.as_ref(), params, &self.program_address).await
}
pub async fn build_init_pair_transaction(
&self,
params: &BuildInitPairTransactionParams,
) -> Result<BuildInitPairTransactionResult> {
lp::build_init_pair_transaction(self.rpc.as_ref(), params, &self.program_address).await
}
pub async fn build_add_liquidity_instruction(
&self,
params: &LpLiquidityParams,
) -> Result<BuildAddLiquidityInstructionResult> {
lp::build_add_liquidity_instruction(self.rpc.as_ref(), params, &self.program_address).await
}
pub async fn build_add_liquidity_transaction(
&self,
params: &BuildAddLiquidityTransactionParams,
) -> Result<BuildAddLiquidityTransactionResult> {
lp::build_add_liquidity_transaction(self.rpc.as_ref(), params, &self.program_address).await
}
pub async fn build_remove_liquidity_instruction(
&self,
params: &LpLiquidityParams,
) -> Result<BuildRemoveLiquidityInstructionResult> {
lp::build_remove_liquidity_instruction(self.rpc.as_ref(), params, &self.program_address)
.await
}
pub async fn build_remove_liquidity_transaction(
&self,
params: &BuildRemoveLiquidityTransactionParams,
) -> Result<BuildRemoveLiquidityTransactionResult> {
lp::build_remove_liquidity_transaction(self.rpc.as_ref(), params, &self.program_address)
.await
}
pub async fn build_close_pair_instruction(
&self,
params: &ClosePairParams,
) -> Result<BuildClosePairInstructionResult> {
lp::build_close_pair_instruction(self.rpc.as_ref(), params, &self.program_address).await
}
pub async fn build_close_pair_transaction(
&self,
params: &BuildClosePairTransactionParams,
) -> Result<BuildClosePairTransactionResult> {
lp::build_close_pair_transaction(self.rpc.as_ref(), params, &self.program_address).await
}
pub fn parse_swap_events_from_logs(&self, logs: &[String]) -> Vec<SwapExecutedEvent> {
events::parse_swap_events_from_logs(logs, &self.program_address)
}
pub async fn parse_swap_events_from_transaction(
&self,
signature: &str,
) -> Result<Vec<SwapExecutedEvent>> {
events::parse_swap_events_from_transaction(
self.rpc.as_ref(),
signature,
&self.program_address,
)
.await
}
pub fn parse_swap_error(
&self,
error: &serde_json::Value,
) -> Option<ParsedSimulationProgramError> {
errors::parse_simulation_program_error(
error,
&self.program_address,
Some(&self.treasury_program_address),
)
.or_else(|| {
errors::parse_swap_error(error, Some(&self.program_address))
.map(ParsedSimulationProgramError::Swap)
})
}
pub fn to_human_readable(amount: u128, decimals: u8) -> String {
format::to_human_readable(amount, decimals)
}
pub fn to_native_amount(human: &str, decimals: u8) -> Result<u128> {
format::to_native_amount(human, decimals)
}
}