tycho-execution 0.300.3

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

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

import {IExecutor} from "@interfaces/IExecutor.sol";
import {TransferManager} from "../TransferManager.sol";

interface IAerodromeV1Pool {
    function getAmountOut(uint256 amountIn, address tokenIn)
        external
        view
        returns (uint256);
    function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;
}

error AerodromeV1Executor__InvalidDataLength();

contract AerodromeV1Executor is IExecutor {
    function fundsExpectedAddress(bytes calldata data)
        external
        pure
        returns (address receiver)
    {
        return address(bytes20(data[0:20]));
    }

    // slither-disable-next-line locked-ether
    function swap(uint256 amountIn, bytes calldata data, address receiver)
        external
        payable
    {
        address target;
        address tokenIn;
        bool zeroForOne;

        (target, tokenIn,, zeroForOne) = _decodeData(data);

        IAerodromeV1Pool pool = IAerodromeV1Pool(target);
        _swap(pool, amountIn, tokenIn, zeroForOne, receiver);
    }

    function _swap(
        IAerodromeV1Pool pool,
        uint256 amountIn,
        address tokenIn,
        bool zeroForOne,
        address receiver
    ) internal {
        uint256 amountOut = pool.getAmountOut(amountIn, tokenIn);
        if (zeroForOne) {
            pool.swap(0, amountOut, receiver, "");
        } else {
            pool.swap(amountOut, 0, receiver, "");
        }
    }

    function _decodeData(bytes calldata data)
        internal
        pure
        returns (
            address target,
            address tokenIn,
            address tokenOut,
            bool zeroForOne
        )
    {
        if (data.length != 61) {
            revert AerodromeV1Executor__InvalidDataLength();
        }
        target = address(bytes20(data[0:20]));
        tokenIn = address(bytes20(data[20:40]));
        tokenOut = address(bytes20(data[40:60]));
        zeroForOne = uint8(data[60]) > 0;
    }

    function getTransferData(bytes calldata data)
        external
        pure
        returns (
            TransferManager.TransferType transferType,
            address receiver,
            address tokenIn,
            address tokenOut,
            bool outputToRouter
        )
    {
        address target;
        address decodedTokenIn;
        address decodedTokenOut;
        bool ignoredZeroForOne;
        (target, decodedTokenIn, decodedTokenOut, ignoredZeroForOne) =
            _decodeData(data);
        return (
            TransferManager.TransferType.Transfer,
            target,
            decodedTokenIn,
            decodedTokenOut,
            false
        );
    }
}