waterpump-evm-pool-sdk 0.1.0

EVM pool SDK — viewers, infusers, harvesters, swappers for Uniswap V3/V4, PancakeSwap, Slipstream, Shadow, Algebra
Documentation 
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

//! Type conversion functions between evm-pool-lib and uniswap-v3-lib types

use crate::traits::pool_infuser::{
    AddBatchLiquidityParams, AddLiquidityOptions, AddLiquidityParams, AddLiquiditySpecificOptions,
    CollectOptions, CollectParams, RemoveBatchLiquidityParams, RemoveLiquidityOptions,
    RemoveLiquidityParams,
};

/// Convert AddLiquidityParams from evm-pool-lib to uniswap-v3-lib
pub fn convert_add_liquidity_params(
    params: AddLiquidityParams,
) -> waterpump_evm_uniswap_v3_client::AddLiquidityParams {
    waterpump_evm_uniswap_v3_client::AddLiquidityParams {
        amount0: params.amount0,
        amount1: params.amount1,
        tick_upper: params.tick_upper,
        tick_lower: params.tick_lower,
        token0_price: params.token0_price,
        specific_opts: convert_add_liquidity_specific_options(params.specific_opts),
    }
}

/// Convert AddLiquidityOptions from evm-pool-lib to uniswap-v3-lib
pub fn convert_add_liquidity_options(
    options: AddLiquidityOptions,
) -> waterpump_evm_uniswap_v3_client::AddLiquidityOptions {
    waterpump_evm_uniswap_v3_client::AddLiquidityOptions {
        slippage_tolerance: options.slippage_tolerance,
        deadline: options.deadline,
        use_native: options.use_native,
        token0_permit: options.token0_permit,
        token1_permit: options.token1_permit,
    }
}

/// Convert AddLiquiditySpecificOptions from evm-pool-lib to uniswap-v3-lib
pub fn convert_add_liquidity_specific_options(
    opts: AddLiquiditySpecificOptions,
) -> waterpump_evm_uniswap_v3_client::AddLiquiditySpecificOptions {
    match opts {
        AddLiquiditySpecificOptions::Mint(mint_opts) => {
            waterpump_evm_uniswap_v3_client::AddLiquiditySpecificOptions::Mint(
                waterpump_evm_uniswap_v3_client::MintSpecificOptions {
                    recipient: mint_opts.recipient,
                    create_pool: mint_opts.create_pool,
                },
            )
        }
        AddLiquiditySpecificOptions::Increase(inc_opts) => {
            waterpump_evm_uniswap_v3_client::AddLiquiditySpecificOptions::Increase(
                waterpump_evm_uniswap_v3_client::IncreaseSpecificOptions {
                    token_id: inc_opts.token_id,
                },
            )
        }
    }
}

/// Convert AddBatchLiquidityParams from evm-pool-lib to uniswap-v3-lib
pub fn convert_add_batch_liquidity_params(
    params: AddBatchLiquidityParams,
) -> waterpump_evm_uniswap_v3_client::AddBatchLiquidityParams {
    waterpump_evm_uniswap_v3_client::AddBatchLiquidityParams {
        token0_price: params.token0_price,
        items: params
            .items
            .into_iter()
            .map(|item| waterpump_evm_uniswap_v3_client::AddBatchLiquidityItem {
                amount0: item.amount0,
                amount1: item.amount1,
                tick_upper: item.tick_upper,
                tick_lower: item.tick_lower,
                specific_opts: convert_add_liquidity_specific_options(item.specific_opts),
            })
            .collect(),
    }
}

/// Convert RemoveLiquidityParams from evm-pool-lib to uniswap-v3-lib
pub fn convert_remove_liquidity_params(
    params: RemoveLiquidityParams,
) -> waterpump_evm_uniswap_v3_client::RemoveLiquidityParams {
    waterpump_evm_uniswap_v3_client::RemoveLiquidityParams {
        token_id: params.token_id,
        liquidity: params.liquidity,
        recipient: params.recipient,
        deadline: params.deadline,
        token0_price: params.token0_price,
        tick_lower: params.tick_lower,
        tick_upper: params.tick_upper,
    }
}

/// Convert RemoveLiquidityOptions from evm-pool-lib to uniswap-v3-lib
pub fn convert_remove_liquidity_options(
    options: RemoveLiquidityOptions,
) -> waterpump_evm_uniswap_v3_client::RemoveLiquidityOptions {
    waterpump_evm_uniswap_v3_client::RemoveLiquidityOptions {
        slippage_tolerance: options.slippage_tolerance,
        burn_token: options.burn_token,
        permit: options.permit.map(|p| waterpump_evm_uniswap_v3_client::NFTPermitOptions {
            signature: p.signature,
            deadline: p.deadline,
            spender: p.spender,
            nonce: p.nonce,
        }),
        collect_options: convert_collect_options(options.collect_options),
    }
}

/// Convert RemoveBatchLiquidityParams from evm-pool-lib to uniswap-v3-lib
pub fn convert_remove_batch_liquidity_params(
    params: RemoveBatchLiquidityParams,
) -> waterpump_evm_uniswap_v3_client::RemoveBatchLiquidityParams {
    waterpump_evm_uniswap_v3_client::RemoveBatchLiquidityParams {
        token0_price: params.token0_price,
        recipient: params.recipient,
        deadline: params.deadline,
        items: params
            .items
            .into_iter()
            .map(|item| waterpump_evm_uniswap_v3_client::RemoveBatchLiquidityItem {
                token_id: item.token_id,
                liquidity: item.liquidity,
                tick_lower: item.tick_lower,
                tick_upper: item.tick_upper,
                burn_token: item.burn_token,
            })
            .collect(),
    }
}

/// Convert CollectParams from evm-pool-lib to uniswap-v3-lib
pub fn convert_collect_params(
    params: CollectParams,
) -> waterpump_evm_uniswap_v3_client::CollectParams {
    waterpump_evm_uniswap_v3_client::CollectParams {
        token_id: params.token_id,
        recipient: params.recipient,
    }
}

/// Convert CollectOptions from evm-pool-lib to uniswap-v3-lib
pub fn convert_collect_options(
    options: CollectOptions,
) -> waterpump_evm_uniswap_v3_client::CollectOptions {
    waterpump_evm_uniswap_v3_client::CollectOptions {
        expected_currency_owed0: options.expected_currency_owed0,
        expected_currency_owed1: options.expected_currency_owed1,
    }
}

/// Convert MethodParameters from uniswap-v3-lib to evm-pool-lib
pub fn convert_method_parameters(
    params: waterpump_evm_uniswap_v3_client::MethodParameters,
) -> crate::pool_swappers::common::MethodParameters {
    crate::pool_swappers::common::MethodParameters {
        calldata: params.calldata,
        value: params.value,
    }
}