use std::ops::{Mul, Sub};
use borsh::{BorshDeserialize, BorshSerialize};
use solana_client::rpc_client::RpcClient;
use solana_program::instruction::{AccountMeta, Instruction};
use solana_program::pubkey::Pubkey;
use spl_associated_token_account::get_associated_token_address;
use spl_token::{amount_to_ui_amount, ui_amount_to_amount};
use crate::client::get_decimals;
use crate::command::{CliConfig};
use crate::contract::state::{Clmmpool, TickArray};
use crate::contract::state::position::Position;
use crate::math::{get_amount_from_liquidity, get_liquidity_from_amount};
use crate::program::{SWAP_PROGRAM_ID};
use crate::utils::sighash;
#[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug, Clone)]
pub struct DecreaseLiquidityArgs {
pub delta_liquidity: u128,
pub token_a_min: u64,
pub token_b_min: u64,
}
#[allow(clippy::too_many_arguments)]
pub fn new_decrease_liquidity(
clmmpool: &Pubkey,
position: &Pubkey,
position_ata: &Pubkey,
token_a_ata: &Pubkey,
token_b_ata: &Pubkey,
token_a_value: &Pubkey,
token_b_value: &Pubkey,
tick_array_lower: &Pubkey,
tick_array_upper: &Pubkey,
tick_array_map: &Pubkey,
delta_liquidity: &u128,
token_a_min: &u64,
token_b_min: &u64,
payer: Pubkey,
) -> Instruction {
let data = &DecreaseLiquidityArgs {
delta_liquidity: *delta_liquidity,
token_a_min: *token_a_min,
token_b_min: *token_b_min,
};
let mut dsa = data.try_to_vec().unwrap();
let mut distor = sighash::sighash("global", "decrease_liquidity").to_vec();
distor.append(&mut dsa);
Instruction {
program_id: SWAP_PROGRAM_ID,
accounts: vec![
AccountMeta::new(payer, true),
AccountMeta::new(*clmmpool, false),
AccountMeta::new(*position, false),
AccountMeta::new_readonly(*position_ata, false),
AccountMeta::new(*token_a_ata, false),
AccountMeta::new(*token_b_ata, false),
AccountMeta::new(*token_a_value, false),
AccountMeta::new(*token_b_value, false),
AccountMeta::new(*tick_array_lower, false),
AccountMeta::new(*tick_array_upper, false),
AccountMeta::new(*tick_array_map, false),
AccountMeta::new_readonly(spl_token::id(), false),
],
data: distor,
}
}
#[allow(unused_assignments)]
pub fn new_decrease_liquidity_tx(
rpc_client: &RpcClient,
config: &CliConfig,
mint: &Pubkey,
amount_a: &f64,
amount_b: &f64,
liquidity: &u128,
slid: &f64,
) -> Option<Instruction> {
let (position, _) = Pubkey::find_program_address(
&[b"position", mint.as_ref()],
&SWAP_PROGRAM_ID,
);
let position_info = Position::get_info(rpc_client, &position);
if position_info.liquidity == 0 {
return None;
}
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, _) = Pubkey::find_program_address(
&[b"tick_array_map", position_info.clmmpool.as_ref()],
&SWAP_PROGRAM_ID,
);
let array_lower_index =
TickArray::array_index(position_info.tick_lower_index, clmmpool_info.tick_spacing).unwrap();
let (tick_array_lower_pubkey, _) = TickArray::calculate_tick_array_key(
position_info.clmmpool.as_ref(),
array_lower_index.to_le_bytes().as_ref(),
);
let array_upper_index =
TickArray::array_index(position_info.tick_upper_index, clmmpool_info.tick_spacing).unwrap();
let (tick_array_upper_pubkey, _) = TickArray::calculate_tick_array_key(
position_info.clmmpool.as_ref(),
array_upper_index.to_le_bytes().as_ref(),
);
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);
let (mut delta_liquidity, mut token_a_amount, mut token_b_amount) = (0u128, 0u64, 0u64);
if *liquidity == 0 {
(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_tick_index,
clmmpool_info.current_sqrt_price,
amount_a_lamport,
amount_b_lamport,
).unwrap();
} else {
delta_liquidity = *liquidity;
(token_a_amount, token_b_amount) = get_amount_from_liquidity(
position_info.tick_lower_index,
position_info.tick_upper_index,
*liquidity,
clmmpool_info.current_tick_index,
clmmpool_info.current_sqrt_price
).unwrap();
}
if delta_liquidity > position_info.liquidity {
delta_liquidity = position_info.liquidity;
(token_a_amount, token_b_amount) = get_amount_from_liquidity(
position_info.tick_lower_index,
position_info.tick_upper_index,
*liquidity,
clmmpool_info.current_tick_index,
clmmpool_info.current_sqrt_price
).unwrap();
}
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_min = ui_amount_to_amount(ui_amount_a.mul(slid.sub(1_f64)), token_a_decimals);
let token_b_min = ui_amount_to_amount(ui_amount_b.mul(slid.sub(1_f64)), token_b_decimals);
Some(new_decrease_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_min,
&token_b_min,
config.pubkey().unwrap(),
))
}