1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use std::error;
use std::sync::Arc;
use clap::{ArgMatches};
use common::command::CliCommandInfo;
use common::math::price::{parse_sqrt_price_to_tick, parse_tick_to_sqrt_price};
use solana_clap_utils::keypair::DefaultSigner;
use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use crate::command::fee_tier::fee_tier::parse_fee_tier_info;
use crate::command::pair::accept_protocol_fee_authority::parse_accept_protocol_fee_authority;
use crate::command::pair::collect_partner_fee::parse_collect_partner_fee;
use crate::command::pair::collect_protocol_fee::parse_collect_protocol_fee;
use crate::command::pair::config::parse_config_info;
use crate::command::pair::init_config::{parse_init_config, parse_init_config_template};
use crate::command::pair::create_fee_tier::{parse_create_fee_tier, parse_create_fee_tier_template};
use crate::command::pair::create_partner::{parse_create_partner, parse_create_partner_template};
use crate::command::pair::create_pool::{parse_create_pool, parse_create_pool_template};
use crate::command::pair::create_tick_array::{parse_create_tick_array, parse_create_tick_array_template};
use crate::command::pair::initialize_rewarder::parse_initialize_rewarder;
use crate::command::pair::pair::parse_pair_info;
use crate::command::pair::pair_list::parse_pair_list;
use crate::command::pair::partner::parse_partner_info;
use crate::command::pair::swap::parse_swap;
use crate::command::pair::transfer_protocol_fee_authority::parse_transfer_protocol_fee_authority;
use crate::command::pair::update_config_protocol_fee_rate::parse_update_config_protocol_fee_rate;
use crate::command::pair::update_fee_rate::parse_update_fee_rate;
use crate::command::pair::update_partner::parse_update_partner;
use crate::command::pair::update_protocol_fee_rate::parse_update_protocol_fee_rate;
use crate::command::pair::update_rewarder_emission::parse_update_rewarder_emission;
use crate::command::position::collect_fee::parse_collect_fee;
use crate::command::position::collect_rewarder::parse_collect_rewarder;
use crate::command::position::decrease_liquidity::parse_decrease_liquidity;
use crate::command::position::increase_liquidity::parse_increase_liquidity;
use crate::command::position::increase_liquidity_with_fixed_token::parse_increase_liquidity_with_fixed_token;
use crate::command::position::open_position::parse_open_position;
use crate::command::position::parse_position_info;
use crate::command::position::position_list::parse_position_list;
use crate::command::position::remove_position::parse_remove_position;
use crate::command::ticks::array_index::parse_array_index_info;
use crate::command::ticks::price::parse_tick_price_info;
use crate::command::ticks::tick::parse_tick_info;
use crate::command::ticks::tick_array::parse_tick_array_info;
use crate::command::ticks::tick_map::parse_tick_map_info;

pub fn parse_command<'a>(
    matches: &'a ArgMatches,
    default_signer: &DefaultSigner,
    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo<'a>, Box<dyn error::Error>> {
    let response = match matches.subcommand() {
        ("pair", Some(matches)) => match matches.subcommand() {
            ("accept-protocol-fee-authority", Some(matches)) => {
                parse_accept_protocol_fee_authority(matches, default_signer, wallet_manager)
            }

            ("collect-partner-fee", Some(matches)) => {
                parse_collect_partner_fee(matches, default_signer, wallet_manager)
            }
            ("collect-protocol-fee", Some(matches)) => {
                parse_collect_protocol_fee(matches, default_signer, wallet_manager)
            }
            ("create-pool-template", Some(matches)) => parse_create_pool_template(matches),
            ("create-pool", Some(matches)) => {
                parse_create_pool(matches, default_signer, wallet_manager)
            }
            ("info", Some(matches)) => parse_pair_info(matches, default_signer, wallet_manager),
            ("list", Some(matches)) => parse_pair_list(matches, default_signer, wallet_manager),
            ("ticks", Some(matches)) => parse_create_pool_template(matches),
            ("init-config-template", Some(matches)) => parse_init_config_template(matches),
            ("init-config", Some(matches)) => {
                parse_init_config(matches, default_signer, wallet_manager)
            }
            ("config-info", Some(matches)) => parse_config_info(matches),
            ("create-fee-tier-template", Some(matches)) => parse_create_fee_tier_template(matches),
            ("create-fee-tier", Some(matches)) => {
                parse_create_fee_tier(matches, default_signer, wallet_manager)
            }
            ("fee-tier-info", Some(matches)) => parse_fee_tier_info(matches),
            ("create-partner-template", Some(matches)) => parse_create_partner_template(matches),
            ("create-partner", Some(matches)) => {
                parse_create_partner(matches, default_signer, wallet_manager)
            }
            ("partner-info", Some(matches)) => parse_partner_info(matches),
            ("create-tick-array-template", Some(matches)) => {
                parse_create_tick_array_template(matches)
            }
            ("create-tick-array", Some(matches)) => {
                parse_create_tick_array(matches, default_signer, wallet_manager)
            }
            ("transfer-protocol-fee-authority", Some(matches)) => {
                parse_transfer_protocol_fee_authority(matches, default_signer, wallet_manager)
            }
            ("update-config-protocol-fee-rate", Some(matches)) => {
                parse_update_config_protocol_fee_rate(matches, default_signer, wallet_manager)
            }
            ("update-fee-rate", Some(matches)) => {
                parse_update_fee_rate(matches, default_signer, wallet_manager)
            }
            ("update-partner", Some(matches)) => {
                parse_update_partner(matches, default_signer, wallet_manager)
            }
            ("update-protocol-fee-rate", Some(matches)) => {
                parse_update_protocol_fee_rate(matches, default_signer, wallet_manager)
            }
            ("swap", Some(matches)) => parse_swap(matches, default_signer, wallet_manager),

            ("init-rewarder", Some(matches)) =>
                parse_initialize_rewarder(matches, default_signer, wallet_manager),
            ("update-rewarder-emission", Some(matches)) =>
                parse_update_rewarder_emission(matches, default_signer, wallet_manager),

            _ => unreachable!("command not found"),
        },

        ("pos", Some(matches)) => match matches.subcommand() {
            ("collect-fee", Some(matches)) => {
                parse_collect_fee(matches, default_signer, wallet_manager)
            }
            ("incr", Some(matches)) => {
                parse_increase_liquidity(matches, default_signer, wallet_manager)
            }
            ("incr-fixed", Some(matches)) => {
                parse_increase_liquidity_with_fixed_token(matches, default_signer, wallet_manager)
            }
            ("decr", Some(matches)) => {
                parse_decrease_liquidity(matches, default_signer, wallet_manager)
            }
            ("open", Some(matches)) => parse_open_position(matches, default_signer, wallet_manager),
            ("remove", Some(matches)) => {
                parse_remove_position(matches, default_signer, wallet_manager)
            }
            ("list", Some(matches)) => parse_position_list(matches, default_signer, wallet_manager),
            ("info", Some(matches)) => parse_position_info(matches, default_signer, wallet_manager),
            ("collect-rewarder", Some(matches)) =>
                parse_collect_rewarder(matches, default_signer, wallet_manager),
            _ => unreachable!("command not found"),
        },
        ("ticks", Some(matches)) => match matches.subcommand() {
            ("tick", Some(matches)) => parse_tick_info(matches, default_signer, wallet_manager),
            ("array", Some(matches)) => {
                parse_tick_array_info(matches, default_signer, wallet_manager)
            }
            ("map", Some(matches)) => parse_tick_map_info(matches, default_signer, wallet_manager),
            ("price", Some(matches)) => {
                parse_tick_price_info(matches, default_signer, wallet_manager)
            },
            ("index", Some(matches)) => parse_array_index_info(matches, default_signer, wallet_manager),
            _ => unreachable!("command not found"),
        },
        ("math", Some(matches)) => match matches.subcommand() {
            ("tick-to-sqrt-price", Some(matches)) => parse_tick_to_sqrt_price(matches),
            ("sqrt-price-to-tick", Some(matches)) => parse_sqrt_price_to_tick(matches),
            ("token-amount", Some(matches)) => parse_create_pool_template(matches),
            ("liquity", Some(matches)) => parse_create_pool_template(matches),
            ("decode-deposit-fix-token", Some(matches)) => parse_create_pool_template(matches),
            _ => unreachable!("command not found"),
        },

        _ => unreachable!("command not found"),
    }?;
    Ok(response)
}