tycho-execution 0.379.2

Provides tools for encoding and executing swaps against Tycho router and protocol executors.
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

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.26;

/// @title IPropAMM
/// @notice Standard interface proprietary AMMs (pAMMs) implement to be
/// routable, as pushed by Titan Builder.
/// @dev Callers use a push-payment model: before calling `swap` they transfer
/// `amountIn` of `tokenIn` to the propAMM, then `swap` is expected to consume
/// that balance.
interface IPropAMM {
    /// @notice Emitted once per successful swap after `tokenOut` is delivered
    /// to `recipient`.
    /// @param sender The address that invoked the swap entrypoint and supplied
    /// `amountIn` of `tokenIn`. Indexed so consumers can fetch a given
    /// account's recent swaps.
    /// @param tokenIn The token sold.
    /// @param tokenOut The token bought.
    /// @param amountIn The exact amount of `tokenIn` pulled from `sender`.
    /// @param amountOut The amount of `tokenOut` delivered to `recipient`,
    /// measured as a balance delta.
    /// @param recipient The address that received `tokenOut`.
    event Swapped(
        address indexed sender,
        address indexed tokenIn,
        address indexed tokenOut,
        uint256 amountIn,
        uint256 amountOut,
        address recipient
    );

    /// @notice A token pair a propAMM supports.
    struct TokenPair {
        address token0;
        address token1;
    }

    /// @notice Returns true if the propAMM can swap `tokenIn` for `tokenOut`
    /// in the current block.
    /// @dev A `view` fast-path a router can use to skip inactive propAMMs
    /// before paying for a full `quote`. Reported per-pair so a propAMM can be
    /// live for some pairs and not others.
    /// @param tokenIn The address of the token being sold.
    /// @param tokenOut The address of the token being bought.
    /// @return active True if a swap for the pair would succeed right now.
    function isActive(address tokenIn, address tokenOut)
        external
        view
        returns (bool active);

    /// @notice Returns all token pairs the propAMM supports, both active and
    /// inactive.
    /// @dev Advisory, for off-chain discovery; routers do not call this on
    /// their swap path.
    /// @return pairs The supported pairs.
    function getPairs() external view returns (TokenPair[] memory pairs);

    /// @notice Quotes `amountIn` of `tokenIn` and returns the `tokenOut`
    /// amount a swap would deliver.
    /// @dev MUST revert if the propAMM is inactive for the pair.
    /// MUST NOT require a `tokenIn` balance or allowance from the caller.
    /// @param tokenIn The address of the token being sold.
    /// @param tokenOut The address of the token being bought.
    /// @param amountIn The exact amount of `tokenIn` to quote against.
    /// @return amountOut The amount of `tokenOut` the swap would deliver.
    function quote(address tokenIn, address tokenOut, uint256 amountIn)
        external
        returns (uint256 amountOut);

    /// @notice Swaps an exact `amountIn` of `tokenIn` for as much `tokenOut`
    /// as possible, delivering it to `recipient`.
    /// @dev Expects `amountIn` of `tokenIn` to have ALREADY been transferred
    /// to the propAMM by the caller (push-payment).
    /// SHALL revert if it cannot deliver at least `minAmountOut` of `tokenOut`
    /// to `recipient`.
    /// @param tokenIn The address of the token being sold.
    /// @param tokenOut The address of the token being bought.
    /// @param amountIn The exact amount of `tokenIn` to sell.
    /// @param minAmountOut The minimum acceptable amount of `tokenOut`.
    /// @param recipient The address that will receive `tokenOut`.
    /// @param deadline Unix timestamp after which the swap is no longer valid.
    /// @return amountOut The amount of `tokenOut` received by `recipient`.
    function swap(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 minAmountOut,
        address recipient,
        uint256 deadline
    ) external returns (uint256 amountOut);
}