3xcalibur

1From Etherscan:
2
3contract Router {
4
5    struct route {
6        address from;
7        address to;
8        bool stable;
9    }
10
11    address public immutable factory;
12    IWETH public immutable weth;
13    uint internal constant MINIMUM_LIQUIDITY = 10**3;
14    bytes32 immutable pairCodeHash;
15
16    modifier ensure(uint deadline) {
17        require(deadline >= block.timestamp, 'BaseV1Router: EXPIRED');
18        _;
19    }
20
21    constructor(address _factory, address _weth) {
22        require(
23            _factory != address(0) &&
24            _weth != address(0),
25            "Router: zero address provided in constructor"
26        );
27        factory = _factory;
28        pairCodeHash = ISwapFactory(_factory).pairCodeHash();
29        weth = IWETH(_weth);
30    }
31
32    receive() external payable {
33        assert(msg.sender == address(weth)); // only accept ETH via fallback from the WETH contract
34    }
35
36    function sortTokens(address tokenA, address tokenB) public pure returns (address token0, address token1) {
37        require(tokenA != tokenB, 'BaseV1Router: IDENTICAL_ADDRESSES');
38        (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
39        require(token0 != address(0), 'BaseV1Router: ZERO_ADDRESS');
40    }
41
42    // calculates the CREATE2 address for a pair without making any external calls
43    function pairFor(address tokenA, address tokenB, bool stable) public view returns (address pair) {
44        (address token0, address token1) = sortTokens(tokenA, tokenB);
45        pair = address(uint160(uint256(keccak256(abi.encodePacked(
46            hex'ff',
47            factory,
48            keccak256(abi.encodePacked(token0, token1, stable)),
49            pairCodeHash // init code hash
50        )))));
51    }
52
53    // given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
54    function quoteLiquidity(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
55        require(amountA > 0, 'BaseV1Router: INSUFFICIENT_AMOUNT');
56        require(reserveA > 0 && reserveB > 0, 'BaseV1Router: INSUFFICIENT_LIQUIDITY');
57        amountB = amountA * reserveB / reserveA;
58    }
59
60    // fetches and sorts the reserves for a pair
61    function getReserves(address tokenA, address tokenB, bool stable) public view returns (uint reserveA, uint reserveB) {
62        (address token0,) = sortTokens(tokenA, tokenB);
63        (uint reserve0, uint reserve1,) = ISwapPair(pairFor(tokenA, tokenB, stable)).getReserves();
64        (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
65    }
66
67    // performs chained getAmountOut calculations on any number of pairs
68    function getAmountOut(uint amountIn, address tokenIn, address tokenOut) external view returns (uint amount, bool stable) {
69        address pair = pairFor(tokenIn, tokenOut, true);
70        uint amountStable;
71        uint amountVolatile;
72        if (ISwapFactory(factory).isPair(pair)) {
73            amountStable = ISwapPair(pair).getAmountOut(amountIn, tokenIn);
74        }
75        pair = pairFor(tokenIn, tokenOut, false);
76        if (ISwapFactory(factory).isPair(pair)) {
77            amountVolatile = ISwapPair(pair).getAmountOut(amountIn, tokenIn);
78        }
79        return amountStable > amountVolatile ? (amountStable, true) : (amountVolatile, false);
80    }
81
82    // performs chained getAmountOut calculations on any number of pairs
83    function getAmountsOut(uint amountIn, route[] memory routes) public view returns (uint[] memory amounts) {
84        require(routes.length >= 1, 'BaseV1Router: INVALID_PATH');
85        amounts = new uint[](routes.length+1);
86        amounts[0] = amountIn;
87        for (uint i = 0; i < routes.length; i++) {
88            address pair = pairFor(routes[i].from, routes[i].to, routes[i].stable);
89            if (ISwapFactory(factory).isPair(pair)) {
90                amounts[i+1] = ISwapPair(pair).getAmountOut(amounts[i], routes[i].from);
91            }
92        }
93    }
94
95    function isPair(address pair) external view returns (bool) {
96        return ISwapFactory(factory).isPair(pair);
97    }
98
99    function quoteAddLiquidity(
100        address tokenA,
101        address tokenB,
102        bool stable,
103        uint amountADesired,
104        uint amountBDesired
105    ) external view returns (uint amountA, uint amountB, uint liquidity) {
106        // create the pair if it doesn't exist yet
107        address _pair = ISwapFactory(factory).getPair(tokenA, tokenB, stable);
108        (uint reserveA, uint reserveB) = (0,0);
109        uint _totalSupply = 0;
110        if (_pair != address(0)) {
111            _totalSupply = IERC20(_pair).totalSupply();
112            (reserveA, reserveB) = getReserves(tokenA, tokenB, stable);
113        }
114        if (reserveA == 0 && reserveB == 0) {
115            (amountA, amountB) = (amountADesired, amountBDesired);
116            liquidity = Math.sqrt(amountA * amountB) - MINIMUM_LIQUIDITY;
117        } else {
118
119            uint amountBOptimal = quoteLiquidity(amountADesired, reserveA, reserveB);
120            if (amountBOptimal <= amountBDesired) {
121                (amountA, amountB) = (amountADesired, amountBOptimal);
122                liquidity = Math.min(amountA * _totalSupply / reserveA, amountB * _totalSupply / reserveB);
123            } else {
124                uint amountAOptimal = quoteLiquidity(amountBDesired, reserveB, reserveA);
125                (amountA, amountB) = (amountAOptimal, amountBDesired);
126                liquidity = Math.min(amountA * _totalSupply / reserveA, amountB * _totalSupply / reserveB);
127            }
128        }
129    }
130
131    function quoteRemoveLiquidity(
132        address tokenA,
133        address tokenB,
134        bool stable,
135        uint liquidity
136    ) external view returns (uint amountA, uint amountB) {
137        // create the pair if it doesn't exist yet
138        address _pair = ISwapFactory(factory).getPair(tokenA, tokenB, stable);
139
140        if (_pair == address(0)) {
141            return (0,0);
142        }
143
144        (uint reserveA, uint reserveB) = getReserves(tokenA, tokenB, stable);
145        uint _totalSupply = IERC20(_pair).totalSupply();
146
147        amountA = liquidity * reserveA / _totalSupply; // using balances ensures pro-rata distribution
148        amountB = liquidity * reserveB / _totalSupply; // using balances ensures pro-rata distribution
149
150    }
151