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

//! ISwapRouter Interface
//!
//! Router token swapping functionality for Uniswap V3
//! Based on: https://github.com/Uniswap/v3-periphery/blob/main/contracts/interfaces/ISwapRouter.sol
//!
//! This interface defines the functions for swapping tokens via Uniswap V3.

use alloy::sol;

sol! {
    /// @title Router token swapping functionality
    /// @notice Functions for swapping tokens via Uniswap V3
    #[sol(rpc)]
    #[allow(missing_docs)]
    interface IUniswapV3SwapCallback {
        /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap.
        /// @dev In the implementation you must pay the pool tokens owed for the swap.
        /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
        /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped.
        /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by
        /// the end of the swap. If positive, the callback must send that amount of token0 to the pool.
        /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by
        /// the end of the swap. If positive, the callback must send that amount of token1 to the pool.
        /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call
        function uniswapV3SwapCallback(
            int256 amount0Delta,
            int256 amount1Delta,
            bytes calldata data
        ) external;
    }

    /// @title Router token swapping functionality
    /// @notice Functions for swapping tokens via Uniswap V3
    #[sol(rpc)]
    #[allow(missing_docs)]
    interface ISwapRouter is IUniswapV3SwapCallback {
        struct ExactInputSingleParams {
            address tokenIn;
            address tokenOut;
            uint24 fee;
            address recipient;
            uint256 deadline;
            uint256 amountIn;
            uint256 amountOutMinimum;
            uint160 sqrtPriceLimitX96;
        }

        /// @notice Swaps `amountIn` of one token for as much as possible of another token
        /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
        /// @return amountOut The amount of the received token
        function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);

        struct ExactInputParams {
            bytes path;
            address recipient;
            uint256 deadline;
            uint256 amountIn;
            uint256 amountOutMinimum;
        }

        /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
        /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
        /// @return amountOut The amount of the received token
        function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);

        struct ExactOutputSingleParams {
            address tokenIn;
            address tokenOut;
            uint24 fee;
            address recipient;
            uint256 deadline;
            uint256 amountOut;
            uint256 amountInMaximum;
            uint160 sqrtPriceLimitX96;
        }

        /// @notice Swaps as little as possible of one token for `amountOut` of another token
        /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
        /// @return amountIn The amount of the input token
        function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);

        struct ExactOutputParams {
            bytes path;
            address recipient;
            uint256 deadline;
            uint256 amountOut;
            uint256 amountInMaximum;
        }

        /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)
        /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata
        /// @return amountIn The amount of the input token
        function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
    }
}

// Re-export for convenience
pub use ISwapRouter::*;