crema-cli 0.1.0

use std::ops::{Mul, Sub};
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::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;
use crate::command::{CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult};
use crate::contract::instructions::decrease_liquidity::new_decrease_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_decrease_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");
    if amount_a.unwrap() == "0" && amount_b.unwrap() == "0"
        || amount_a.unwrap() != "0" && amount_b.unwrap() != "0"
    {
        return Err(CliError::LiquidityRequestParamError());
    }
    Ok(CliCommandInfo {
        command: CliCommand::PositionDecrease {
            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_decrease_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 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(),
    );

    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(),
    );

    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 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,
    )?;
    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);

    let ixs = [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(),
    )];

    let res = send_tx(rpc_client, config, &ixs)?;

    Ok("signers : ".to_owned() + res.to_string().as_str())
}