use std::ops::{Add, Mul};
use std::str::FromStr;
use std::sync::Arc;
use clap::ArgMatches;
use solana_clap_utils::keypair::DefaultSigner;
use solana_client::rpc_client::RpcClient;
use solana_program::instruction::Instruction;
use solana_program::pubkey::Pubkey;
use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use spl_associated_token_account::get_associated_token_address;
use spl_token::{amount_to_ui_amount, ui_amount_to_amount};
use crate::check_and_update_err;
use crate::client::get_decimals;
use crate::clmmpool::pair::create_tick_array::{calculate_tick_array_key, TickArrayTemplate};
use crate::command::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult};
use crate::command::process_result_from_str;
use crate::contract::instructions::create_tick_array::new_create_tick_array;
use crate::contract::instructions::increase_liquidity::new_increase_liquidity;
use crate::contract::state::clmmpools::Clmmpool;
use crate::contract::state::position::Position;
use crate::contract::state::tick_array::TickArray;
use crate::math::get_liquidity_from_amount;
use crate::program::get_pubkey_for_program_with_seeds;
use crate::utils::send::send_tx;
pub fn parse_increase_liquidity<'a>(
matches: &'a ArgMatches,
default_signer: &DefaultSigner,
wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo<'a>, CliError> {
let slid = matches.value_of("slid");
let mint = matches.value_of("mint");
let amount_a = matches.value_of("amount_a");
let amount_b = matches.value_of("amount_b");
Ok(CliCommandInfo {
command: CliCommand::PositionIncrease {
mint: Pubkey::from_str(mint.unwrap()).unwrap(),
amount_a: amount_a.unwrap().parse::<f64>().unwrap(),
amount_b: amount_b.unwrap().parse::<f64>().unwrap(),
slid: slid.unwrap().parse::<f64>().unwrap(),
},
signers: vec![check_and_update_err!(
default_signer.signer_from_path(matches, wallet_manager),
CliError::RpcRequestError("owner key is invalid".to_string())
)?],
})
}
pub fn process_increase_liquidity(
rpc_client: &RpcClient,
config: &CliConfig,
mint: &Pubkey,
amount_a: &f64,
amount_b: &f64,
slid: &f64,
) -> ProcessResult {
let (position, _) = get_pubkey_for_program_with_seeds(&[b"position", mint.as_ref()]);
let position_info = Position::get_info(rpc_client, &position);
let clmmpool_info = Clmmpool::get_info(rpc_client, &position_info.clmmpool);
let token_a_decimals = get_decimals(rpc_client, &clmmpool_info.token_a);
let token_b_decimals = get_decimals(rpc_client, &clmmpool_info.token_b);
let token_a_ata =
get_associated_token_address(&config.pubkey().unwrap(), &clmmpool_info.token_a);
let token_b_ata =
get_associated_token_address(&config.pubkey().unwrap(), &clmmpool_info.token_b);
let position_ata =
get_associated_token_address(&config.pubkey().unwrap(), &position_info.position_nft_mint);
let (tick_array_map_pubkey, _) =
get_pubkey_for_program_with_seeds(&[b"tick_array_map", position_info.clmmpool.as_ref()]);
let mut ixs: Vec<Instruction> = Vec::new();
let array_lower_index =
TickArray::array_index(position_info.tick_lower_index, clmmpool_info.tick_spacing).unwrap();
let (tick_array_lower_pubkey, _) = calculate_tick_array_key(
position_info.clmmpool.as_ref(),
array_lower_index.to_le_bytes().as_ref(),
);
if rpc_client.get_account(&tick_array_lower_pubkey).is_err() {
ixs.push(new_create_tick_array(
&TickArrayTemplate {
clmmpool: position_info.clmmpool.to_string(),
array_index: array_lower_index,
},
tick_array_lower_pubkey,
config.pubkey().unwrap(),
));
}
let array_upper_index =
TickArray::array_index(position_info.tick_upper_index, clmmpool_info.tick_spacing).unwrap();
let (tick_array_upper_pubkey, _) = calculate_tick_array_key(
position_info.clmmpool.as_ref(),
array_upper_index.to_le_bytes().as_ref(),
);
if rpc_client.get_account(&tick_array_upper_pubkey).is_err()
&& array_upper_index != array_lower_index
{
ixs.push(new_create_tick_array(
&TickArrayTemplate {
clmmpool: position_info.clmmpool.to_string(),
array_index: array_upper_index,
},
tick_array_upper_pubkey,
config.pubkey().unwrap(),
));
}
let amount_a_lamport = ui_amount_to_amount(*amount_a, token_a_decimals);
let amount_b_lamport = ui_amount_to_amount(*amount_b, token_b_decimals);
if clmmpool_info.current_tick_index < position_info.tick_lower_index && amount_a_lamport == 0 {
return process_result_from_str("amount a cannot be zero");
}
if clmmpool_info.current_tick_index > position_info.tick_upper_index && amount_b_lamport == 0 {
return process_result_from_str("amount b cannot be zero");
}
if clmmpool_info.current_tick_index >= position_info.tick_lower_index
&& clmmpool_info.current_tick_index < position_info.tick_upper_index
{
if amount_a_lamport == 0 && amount_b_lamport == 0 {
return process_result_from_str("only amount a or amount b cannot be zero");
}
if amount_a_lamport != 0 && amount_b_lamport != 0 {
return process_result_from_str("only amount a or amount b cannot be zero");
}
}
let amount_a_input = if amount_a_lamport == 0 {
None
} else {
Some(amount_a_lamport)
};
let amount_b_input = if amount_b_lamport == 0 {
None
} else {
Some(amount_b_lamport)
};
let (delta_liquidity, token_a_amount, token_b_amount) = get_liquidity_from_amount(
position_info.tick_lower_index,
position_info.tick_upper_index,
clmmpool_info.current_sqrt_price,
amount_a_input,
amount_b_input,
)?;
println!(
"delta_liquidity:{}| a: {}|b: {}",
delta_liquidity, token_a_amount, token_b_amount
);
let ui_amount_a = amount_to_ui_amount(token_a_amount, token_a_decimals);
let ui_amount_b = amount_to_ui_amount(token_b_amount, token_b_decimals);
let token_a_max = ui_amount_to_amount(ui_amount_a.mul(slid.add(1 as f64)), token_a_decimals);
let token_b_max = ui_amount_to_amount(ui_amount_b.mul(slid.add(1 as f64)), token_b_decimals);
ixs.push(new_increase_liquidity(
&position_info.clmmpool,
&position,
&position_ata,
&token_a_ata,
&token_b_ata,
&clmmpool_info.token_a_vault,
&clmmpool_info.token_b_vault,
&tick_array_lower_pubkey,
&tick_array_upper_pubkey,
&tick_array_map_pubkey,
&delta_liquidity,
&token_a_max,
&token_b_max,
config.pubkey().unwrap(),
));
let res = send_tx(rpc_client, config, &ixs)?;
Ok("signers : ".to_owned() + res.to_string().as_str())
}