From 82733a61f329c22e5e31b755c8a30c51884a5afd Mon Sep 17 00:00:00 2001 From: Skye Date: Tue, 3 Jun 2025 10:27:10 +0800 Subject: [PATCH] update routeproxy with positive slippage --- .../SmartRoute/proxies/DODOFeeRouteProxy.sol | 1676 +++++++++++++++++ 1 file changed, 1676 insertions(+) create mode 100644 contracts/SmartRoute/proxies/DODOFeeRouteProxy.sol diff --git a/contracts/SmartRoute/proxies/DODOFeeRouteProxy.sol b/contracts/SmartRoute/proxies/DODOFeeRouteProxy.sol new file mode 100644 index 0000000..5f71571 --- /dev/null +++ b/contracts/SmartRoute/proxies/DODOFeeRouteProxy.sol @@ -0,0 +1,1676 @@ +// Sources flattened with hardhat v2.11.2 https://hardhat.org + +// File contracts/lib/InitializableOwnable.sol + + + +/** + * @title Ownable + * @author DODO Breeder + * + * @notice Ownership related functions + */ +contract InitializableOwnable { + address public _OWNER_; + address public _NEW_OWNER_; + bool internal _INITIALIZED_; + + // ============ Events ============ + + event OwnershipTransferPrepared(address indexed previousOwner, address indexed newOwner); + + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + + // ============ Modifiers ============ + + modifier notInitialized() { + require(!_INITIALIZED_, "DODO_INITIALIZED"); + _; + } + + modifier onlyOwner() { + require(msg.sender == _OWNER_, "NOT_OWNER"); + _; + } + + // ============ Functions ============ + + function initOwner(address newOwner) public notInitialized { + _INITIALIZED_ = true; + _OWNER_ = newOwner; + } + + function transferOwnership(address newOwner) public onlyOwner { + emit OwnershipTransferPrepared(_OWNER_, newOwner); + _NEW_OWNER_ = newOwner; + } + + function claimOwnership() public { + require(msg.sender == _NEW_OWNER_, "INVALID_CLAIM"); + emit OwnershipTransferred(_OWNER_, _NEW_OWNER_); + _OWNER_ = _NEW_OWNER_; + _NEW_OWNER_ = address(0); + } +} + + +// File contracts/intf/IDODOApprove.sol + + +interface IDODOApprove { + function claimTokens(address token,address who,address dest,uint256 amount) external; + function getDODOProxy() external view returns (address); +} + + +// File contracts/DODOApproveProxy.sol + + + + +interface IDODOApproveProxy { + function isAllowedProxy(address _proxy) external view returns (bool); + function claimTokens(address token,address who,address dest,uint256 amount) external; +} + +/** + * @title DODOApproveProxy + * @author DODO Breeder + * + * @notice Allow different version dodoproxy to claim from DODOApprove + */ +contract DODOApproveProxy is InitializableOwnable { + + // ============ Storage ============ + uint256 private constant _TIMELOCK_DURATION_ = 3 days; + mapping (address => bool) public _IS_ALLOWED_PROXY_; + uint256 public _TIMELOCK_; + address public _PENDING_ADD_DODO_PROXY_; + address public immutable _DODO_APPROVE_; + + // ============ Modifiers ============ + modifier notLocked() { + require( + _TIMELOCK_ <= block.timestamp, + "SetProxy is timelocked" + ); + _; + } + + constructor(address dodoApporve) { + _DODO_APPROVE_ = dodoApporve; + } + + function init(address owner, address[] memory proxies) external { + initOwner(owner); + for(uint i = 0; i < proxies.length; i++) + _IS_ALLOWED_PROXY_[proxies[i]] = true; + } + + function unlockAddProxy(address newDodoProxy) public onlyOwner { + _TIMELOCK_ = block.timestamp + _TIMELOCK_DURATION_; + _PENDING_ADD_DODO_PROXY_ = newDodoProxy; + } + + function lockAddProxy() public onlyOwner { + _PENDING_ADD_DODO_PROXY_ = address(0); + _TIMELOCK_ = 0; + } + + + function addDODOProxy() external onlyOwner notLocked() { + _IS_ALLOWED_PROXY_[_PENDING_ADD_DODO_PROXY_] = true; + lockAddProxy(); + } + + function removeDODOProxy (address oldDodoProxy) public onlyOwner { + _IS_ALLOWED_PROXY_[oldDodoProxy] = false; + } + + function claimTokens( + address token, + address who, + address dest, + uint256 amount + ) external { + require(_IS_ALLOWED_PROXY_[msg.sender], "DODOApproveProxy:Access restricted"); + IDODOApprove(_DODO_APPROVE_).claimTokens( + token, + who, + dest, + amount + ); + } + + function isAllowedProxy(address _proxy) external view returns (bool) { + return _IS_ALLOWED_PROXY_[_proxy]; + } +} + + +// File contracts/intf/IWETH.sol + + + + +interface IWETH { + function totalSupply() external view returns (uint256); + + function balanceOf(address account) external view returns (uint256); + + function transfer(address recipient, uint256 amount) external returns (bool); + + function allowance(address owner, address spender) external view returns (uint256); + + function approve(address spender, uint256 amount) external returns (bool); + + function transferFrom( + address src, + address dst, + uint256 wad + ) external returns (bool); + + function deposit() external payable; + + function withdraw(uint256 wad) external; +} + + +// File @openzeppelin/contracts/utils/math/Math.sol@v4.7.3 + + + +/** + * @dev Standard math utilities missing in the Solidity language. + */ +library Math { + enum Rounding { + Down, // Toward negative infinity + Up, // Toward infinity + Zero // Toward zero + } + + /** + * @dev Returns the largest of two numbers. + */ + function max(uint256 a, uint256 b) internal pure returns (uint256) { + return a >= b ? a : b; + } + + /** + * @dev Returns the smallest of two numbers. + */ + function min(uint256 a, uint256 b) internal pure returns (uint256) { + return a < b ? a : b; + } + + /** + * @dev Returns the average of two numbers. The result is rounded towards + * zero. + */ + function average(uint256 a, uint256 b) internal pure returns (uint256) { + // (a + b) / 2 can overflow. + return (a & b) + (a ^ b) / 2; + } + + /** + * @dev Returns the ceiling of the division of two numbers. + * + * This differs from standard division with `/` in that it rounds up instead + * of rounding down. + */ + function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { + // (a + b - 1) / b can overflow on addition, so we distribute. + return a == 0 ? 0 : (a - 1) / b + 1; + } + + /** + * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 + * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) + * with further edits by Uniswap Labs also under MIT license. + */ + function mulDiv( + uint256 x, + uint256 y, + uint256 denominator + ) internal pure returns (uint256 result) { + unchecked { + // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use + // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 + // variables such that product = prod1 * 2^256 + prod0. + uint256 prod0; // Least significant 256 bits of the product + uint256 prod1; // Most significant 256 bits of the product + assembly { + let mm := mulmod(x, y, not(0)) + prod0 := mul(x, y) + prod1 := sub(sub(mm, prod0), lt(mm, prod0)) + } + + // Handle non-overflow cases, 256 by 256 division. + if (prod1 == 0) { + return prod0 / denominator; + } + + // Make sure the result is less than 2^256. Also prevents denominator == 0. + require(denominator > prod1); + + /////////////////////////////////////////////// + // 512 by 256 division. + /////////////////////////////////////////////// + + // Make division exact by subtracting the remainder from [prod1 prod0]. + uint256 remainder; + assembly { + // Compute remainder using mulmod. + remainder := mulmod(x, y, denominator) + + // Subtract 256 bit number from 512 bit number. + prod1 := sub(prod1, gt(remainder, prod0)) + prod0 := sub(prod0, remainder) + } + + // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. + // See https://cs.stackexchange.com/q/138556/92363. + + // Does not overflow because the denominator cannot be zero at this stage in the function. + uint256 twos = denominator & (~denominator + 1); + assembly { + // Divide denominator by twos. + denominator := div(denominator, twos) + + // Divide [prod1 prod0] by twos. + prod0 := div(prod0, twos) + + // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. + twos := add(div(sub(0, twos), twos), 1) + } + + // Shift in bits from prod1 into prod0. + prod0 |= prod1 * twos; + + // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such + // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for + // four bits. That is, denominator * inv = 1 mod 2^4. + uint256 inverse = (3 * denominator) ^ 2; + + // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works + // in modular arithmetic, doubling the correct bits in each step. + inverse *= 2 - denominator * inverse; // inverse mod 2^8 + inverse *= 2 - denominator * inverse; // inverse mod 2^16 + inverse *= 2 - denominator * inverse; // inverse mod 2^32 + inverse *= 2 - denominator * inverse; // inverse mod 2^64 + inverse *= 2 - denominator * inverse; // inverse mod 2^128 + inverse *= 2 - denominator * inverse; // inverse mod 2^256 + + // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. + // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is + // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 + // is no longer required. + result = prod0 * inverse; + return result; + } + } + + /** + * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. + */ + function mulDiv( + uint256 x, + uint256 y, + uint256 denominator, + Rounding rounding + ) internal pure returns (uint256) { + uint256 result = mulDiv(x, y, denominator); + if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { + result += 1; + } + return result; + } + + /** + * @dev Returns the square root of a number. It the number is not a perfect square, the value is rounded down. + * + * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). + */ + function sqrt(uint256 a) internal pure returns (uint256) { + if (a == 0) { + return 0; + } + + // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. + // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have + // `msb(a) <= a < 2*msb(a)`. + // We also know that `k`, the position of the most significant bit, is such that `msb(a) = 2**k`. + // This gives `2**k < a <= 2**(k+1)` → `2**(k/2) <= sqrt(a) < 2 ** (k/2+1)`. + // Using an algorithm similar to the msb conmputation, we are able to compute `result = 2**(k/2)` which is a + // good first aproximation of `sqrt(a)` with at least 1 correct bit. + uint256 result = 1; + uint256 x = a; + if (x >> 128 > 0) { + x >>= 128; + result <<= 64; + } + if (x >> 64 > 0) { + x >>= 64; + result <<= 32; + } + if (x >> 32 > 0) { + x >>= 32; + result <<= 16; + } + if (x >> 16 > 0) { + x >>= 16; + result <<= 8; + } + if (x >> 8 > 0) { + x >>= 8; + result <<= 4; + } + if (x >> 4 > 0) { + x >>= 4; + result <<= 2; + } + if (x >> 2 > 0) { + result <<= 1; + } + + // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, + // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at + // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision + // into the expected uint128 result. + unchecked { + result = (result + a / result) >> 1; + result = (result + a / result) >> 1; + result = (result + a / result) >> 1; + result = (result + a / result) >> 1; + result = (result + a / result) >> 1; + result = (result + a / result) >> 1; + result = (result + a / result) >> 1; + return min(result, a / result); + } + } + + /** + * @notice Calculates sqrt(a), following the selected rounding direction. + */ + function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { + uint256 result = sqrt(a); + if (rounding == Rounding.Up && result * result < a) { + result += 1; + } + return result; + } +} + + +// File contracts/lib/DecimalMath.sol + + +/** + * @title DecimalMath + * @author DODO Breeder + * + * @notice Functions for fixed point number with 18 decimals + */ + +library DecimalMath { + + uint256 internal constant ONE = 10**18; + uint256 internal constant ONE2 = 10**36; + + function mul(uint256 target, uint256 d) internal pure returns (uint256) { + return target * d / (10**18); + } + + function mulFloor(uint256 target, uint256 d) internal pure returns (uint256) { + return target * d / (10**18); + } + + function mulCeil(uint256 target, uint256 d) internal pure returns (uint256) { + return _divCeil(target * d, 10**18); + } + + function div(uint256 target, uint256 d) internal pure returns (uint256) { + return target * (10**18) / d; + } + + function divFloor(uint256 target, uint256 d) internal pure returns (uint256) { + return target * (10**18) / d; + } + + function divCeil(uint256 target, uint256 d) internal pure returns (uint256) { + return _divCeil(target * (10**18), d); + } + + function reciprocalFloor(uint256 target) internal pure returns (uint256) { + return uint256(10**36) / target; + } + + function reciprocalCeil(uint256 target) internal pure returns (uint256) { + return _divCeil(uint256(10**36), target); + } + + function sqrt(uint256 target) internal pure returns (uint256) { + return Math.sqrt(target * ONE); + } + + function powFloor(uint256 target, uint256 e) internal pure returns (uint256) { + if (e == 0) { + return 10 ** 18; + } else if (e == 1) { + return target; + } else { + uint p = powFloor(target, e / 2); + p = p * p / (10**18); + if (e % 2 == 1) { + p = p * target / (10**18); + } + return p; + } + } + + function _divCeil(uint256 a, uint256 b) internal pure returns (uint256) { + uint256 quotient = a / b; + uint256 remainder = a - quotient * b; + if (remainder > 0) { + return quotient + 1; + } else { + return quotient; + } + } +} + + +// File contracts/SmartRoute/intf/IDODOAdapter.sol + + + +interface IDODOAdapter { + + function sellBase(address to, address pool, bytes memory data) external; + + function sellQuote(address to, address pool, bytes memory data) external; +} + + +// File @openzeppelin/contracts/token/ERC20/IERC20.sol@v4.7.3 + + + +/** + * @dev Interface of the ERC20 standard as defined in the EIP. + */ +interface IERC20 { + /** + * @dev Emitted when `value` tokens are moved from one account (`from`) to + * another (`to`). + * + * Note that `value` may be zero. + */ + event Transfer(address indexed from, address indexed to, uint256 value); + + /** + * @dev Emitted when the allowance of a `spender` for an `owner` is set by + * a call to {approve}. `value` is the new allowance. + */ + event Approval(address indexed owner, address indexed spender, uint256 value); + + /** + * @dev Returns the amount of tokens in existence. + */ + function totalSupply() external view returns (uint256); + + /** + * @dev Returns the amount of tokens owned by `account`. + */ + function balanceOf(address account) external view returns (uint256); + + /** + * @dev Moves `amount` tokens from the caller's account to `to`. + * + * Returns a boolean value indicating whether the operation succeeded. + * + * Emits a {Transfer} event. + */ + function transfer(address to, uint256 amount) external returns (bool); + + /** + * @dev Returns the remaining number of tokens that `spender` will be + * allowed to spend on behalf of `owner` through {transferFrom}. This is + * zero by default. + * + * This value changes when {approve} or {transferFrom} are called. + */ + function allowance(address owner, address spender) external view returns (uint256); + + /** + * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. + * + * Returns a boolean value indicating whether the operation succeeded. + * + * IMPORTANT: Beware that changing an allowance with this method brings the risk + * that someone may use both the old and the new allowance by unfortunate + * transaction ordering. One possible solution to mitigate this race + * condition is to first reduce the spender's allowance to 0 and set the + * desired value afterwards: + * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 + * + * Emits an {Approval} event. + */ + function approve(address spender, uint256 amount) external returns (bool); + + /** + * @dev Moves `amount` tokens from `from` to `to` using the + * allowance mechanism. `amount` is then deducted from the caller's + * allowance. + * + * Returns a boolean value indicating whether the operation succeeded. + * + * Emits a {Transfer} event. + */ + function transferFrom( + address from, + address to, + uint256 amount + ) external returns (bool); +} + + +// File @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol@v4.7.3 + + + +/** + * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in + * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. + * + * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by + * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't + * need to send a transaction, and thus is not required to hold Ether at all. + */ +interface IERC20Permit { + /** + * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, + * given ``owner``'s signed approval. + * + * IMPORTANT: The same issues {IERC20-approve} has related to transaction + * ordering also apply here. + * + * Emits an {Approval} event. + * + * Requirements: + * + * - `spender` cannot be the zero address. + * - `deadline` must be a timestamp in the future. + * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` + * over the EIP712-formatted function arguments. + * - the signature must use ``owner``'s current nonce (see {nonces}). + * + * For more information on the signature format, see the + * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP + * section]. + */ + function permit( + address owner, + address spender, + uint256 value, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) external; + + /** + * @dev Returns the current nonce for `owner`. This value must be + * included whenever a signature is generated for {permit}. + * + * Every successful call to {permit} increases ``owner``'s nonce by one. This + * prevents a signature from being used multiple times. + */ + function nonces(address owner) external view returns (uint256); + + /** + * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. + */ + // solhint-disable-next-line func-name-mixedcase + function DOMAIN_SEPARATOR() external view returns (bytes32); +} + + +// File @openzeppelin/contracts/utils/Address.sol@v4.7.3 + + + +/** + * @dev Collection of functions related to the address type + */ +library Address { + /** + * @dev Returns true if `account` is a contract. + * + * [IMPORTANT] + * ==== + * It is unsafe to assume that an address for which this function returns + * false is an externally-owned account (EOA) and not a contract. + * + * Among others, `isContract` will return false for the following + * types of addresses: + * + * - an externally-owned account + * - a contract in construction + * - an address where a contract will be created + * - an address where a contract lived, but was destroyed + * ==== + * + * [IMPORTANT] + * ==== + * You shouldn't rely on `isContract` to protect against flash loan attacks! + * + * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets + * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract + * constructor. + * ==== + */ + function isContract(address account) internal view returns (bool) { + // This method relies on extcodesize/address.code.length, which returns 0 + // for contracts in construction, since the code is only stored at the end + // of the constructor execution. + + return account.code.length > 0; + } + + /** + * @dev Replacement for Solidity's `transfer`: sends `amount` wei to + * `recipient`, forwarding all available gas and reverting on errors. + * + * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost + * of certain opcodes, possibly making contracts go over the 2300 gas limit + * imposed by `transfer`, making them unable to receive funds via + * `transfer`. {sendValue} removes this limitation. + * + * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. + * + * IMPORTANT: because control is transferred to `recipient`, care must be + * taken to not create reentrancy vulnerabilities. Consider using + * {ReentrancyGuard} or the + * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. + */ + function sendValue(address payable recipient, uint256 amount) internal { + require(address(this).balance >= amount, "Address: insufficient balance"); + + (bool success, ) = recipient.call{value: amount}(""); + require(success, "Address: unable to send value, recipient may have reverted"); + } + + /** + * @dev Performs a Solidity function call using a low level `call`. A + * plain `call` is an unsafe replacement for a function call: use this + * function instead. + * + * If `target` reverts with a revert reason, it is bubbled up by this + * function (like regular Solidity function calls). + * + * Returns the raw returned data. To convert to the expected return value, + * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. + * + * Requirements: + * + * - `target` must be a contract. + * - calling `target` with `data` must not revert. + * + * _Available since v3.1._ + */ + function functionCall(address target, bytes memory data) internal returns (bytes memory) { + return functionCall(target, data, "Address: low-level call failed"); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with + * `errorMessage` as a fallback revert reason when `target` reverts. + * + * _Available since v3.1._ + */ + function functionCall( + address target, + bytes memory data, + string memory errorMessage + ) internal returns (bytes memory) { + return functionCallWithValue(target, data, 0, errorMessage); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but also transferring `value` wei to `target`. + * + * Requirements: + * + * - the calling contract must have an ETH balance of at least `value`. + * - the called Solidity function must be `payable`. + * + * _Available since v3.1._ + */ + function functionCallWithValue( + address target, + bytes memory data, + uint256 value + ) internal returns (bytes memory) { + return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); + } + + /** + * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but + * with `errorMessage` as a fallback revert reason when `target` reverts. + * + * _Available since v3.1._ + */ + function functionCallWithValue( + address target, + bytes memory data, + uint256 value, + string memory errorMessage + ) internal returns (bytes memory) { + require(address(this).balance >= value, "Address: insufficient balance for call"); + require(isContract(target), "Address: call to non-contract"); + + (bool success, bytes memory returndata) = target.call{value: value}(data); + return verifyCallResult(success, returndata, errorMessage); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but performing a static call. + * + * _Available since v3.3._ + */ + function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { + return functionStaticCall(target, data, "Address: low-level static call failed"); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], + * but performing a static call. + * + * _Available since v3.3._ + */ + function functionStaticCall( + address target, + bytes memory data, + string memory errorMessage + ) internal view returns (bytes memory) { + require(isContract(target), "Address: static call to non-contract"); + + (bool success, bytes memory returndata) = target.staticcall(data); + return verifyCallResult(success, returndata, errorMessage); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but performing a delegate call. + * + * _Available since v3.4._ + */ + function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { + return functionDelegateCall(target, data, "Address: low-level delegate call failed"); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], + * but performing a delegate call. + * + * _Available since v3.4._ + */ + function functionDelegateCall( + address target, + bytes memory data, + string memory errorMessage + ) internal returns (bytes memory) { + require(isContract(target), "Address: delegate call to non-contract"); + + (bool success, bytes memory returndata) = target.delegatecall(data); + return verifyCallResult(success, returndata, errorMessage); + } + + /** + * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the + * revert reason using the provided one. + * + * _Available since v4.3._ + */ + function verifyCallResult( + bool success, + bytes memory returndata, + string memory errorMessage + ) internal pure returns (bytes memory) { + if (success) { + return returndata; + } else { + // Look for revert reason and bubble it up if present + if (returndata.length > 0) { + // The easiest way to bubble the revert reason is using memory via assembly + /// @solidity memory-safe-assembly + assembly { + let returndata_size := mload(returndata) + revert(add(32, returndata), returndata_size) + } + } else { + revert(errorMessage); + } + } + } +} + + +// File @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol@v4.7.3 + + + + + +/** + * @title SafeERC20 + * @dev Wrappers around ERC20 operations that throw on failure (when the token + * contract returns false). Tokens that return no value (and instead revert or + * throw on failure) are also supported, non-reverting calls are assumed to be + * successful. + * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, + * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. + */ +library SafeERC20 { + using Address for address; + + function safeTransfer( + IERC20 token, + address to, + uint256 value + ) internal { + _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); + } + + function safeTransferFrom( + IERC20 token, + address from, + address to, + uint256 value + ) internal { + _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); + } + + /** + * @dev Deprecated. This function has issues similar to the ones found in + * {IERC20-approve}, and its usage is discouraged. + * + * Whenever possible, use {safeIncreaseAllowance} and + * {safeDecreaseAllowance} instead. + */ + function safeApprove( + IERC20 token, + address spender, + uint256 value + ) internal { + // safeApprove should only be called when setting an initial allowance, + // or when resetting it to zero. To increase and decrease it, use + // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' + require( + (value == 0) || (token.allowance(address(this), spender) == 0), + "SafeERC20: approve from non-zero to non-zero allowance" + ); + _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); + } + + function safeIncreaseAllowance( + IERC20 token, + address spender, + uint256 value + ) internal { + uint256 newAllowance = token.allowance(address(this), spender) + value; + _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); + } + + function safeDecreaseAllowance( + IERC20 token, + address spender, + uint256 value + ) internal { + unchecked { + uint256 oldAllowance = token.allowance(address(this), spender); + require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); + uint256 newAllowance = oldAllowance - value; + _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); + } + } + + function safePermit( + IERC20Permit token, + address owner, + address spender, + uint256 value, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) internal { + uint256 nonceBefore = token.nonces(owner); + token.permit(owner, spender, value, deadline, v, r, s); + uint256 nonceAfter = token.nonces(owner); + require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed"); + } + + /** + * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement + * on the return value: the return value is optional (but if data is returned, it must not be false). + * @param token The token targeted by the call. + * @param data The call data (encoded using abi.encode or one of its variants). + */ + function _callOptionalReturn(IERC20 token, bytes memory data) private { + // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since + // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that + // the target address contains contract code and also asserts for success in the low-level call. + + bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); + if (returndata.length > 0) { + // Return data is optional + require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); + } + } +} + + +// File contracts/SmartRoute/lib/UniversalERC20.sol + + + + +library UniversalERC20 { + using SafeERC20 for IERC20; + + IERC20 private constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE); + + // 1. skip 0 amount + // 2. handle ETH transfer + function universalTransfer( + IERC20 token, + address payable to, + uint256 amount + ) internal { + if (amount > 0) { + if (isETH(token)) { + to.transfer(amount); + } else { + token.safeTransfer(to, amount); + } + } + } + + function universalApproveMax( + IERC20 token, + address to, + uint256 amount + ) internal { + uint256 allowance = token.allowance(address(this), to); + if (allowance < amount) { + if (allowance > 0) { + token.safeApprove(to, 0); + } + token.safeApprove(to, type(uint256).max); + } + } + + function universalBalanceOf(IERC20 token, address who) internal view returns (uint256) { + if (isETH(token)) { + return who.balance; + } else { + return token.balanceOf(who); + } + } + + function tokenBalanceOf(IERC20 token, address who) internal view returns (uint256) { + return token.balanceOf(who); + } + + function isETH(IERC20 token) internal pure returns (bool) { + return token == ETH_ADDRESS; + } +} + + +// File @openzeppelin/contracts/utils/Context.sol@v4.7.3 + + + +/** + * @dev Provides information about the current execution context, including the + * sender of the transaction and its data. While these are generally available + * via msg.sender and msg.data, they should not be accessed in such a direct + * manner, since when dealing with meta-transactions the account sending and + * paying for execution may not be the actual sender (as far as an application + * is concerned). + * + * This contract is only required for intermediate, library-like contracts. + */ +abstract contract Context { + function _msgSender() internal view virtual returns (address) { + return msg.sender; + } + + function _msgData() internal view virtual returns (bytes calldata) { + return msg.data; + } +} + + +// File @openzeppelin/contracts/access/Ownable.sol@v4.7.3 + + + +/** + * @dev Contract module which provides a basic access control mechanism, where + * there is an account (an owner) that can be granted exclusive access to + * specific functions. + * + * By default, the owner account will be the one that deploys the contract. This + * can later be changed with {transferOwnership}. + * + * This module is used through inheritance. It will make available the modifier + * `onlyOwner`, which can be applied to your functions to restrict their use to + * the owner. + */ +abstract contract Ownable is Context { + address private _owner; + + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + + /** + * @dev Initializes the contract setting the deployer as the initial owner. + */ + constructor() { + _transferOwnership(_msgSender()); + } + + /** + * @dev Throws if called by any account other than the owner. + */ + modifier onlyOwner() { + _checkOwner(); + _; + } + + /** + * @dev Returns the address of the current owner. + */ + function owner() public view virtual returns (address) { + return _owner; + } + + /** + * @dev Throws if the sender is not the owner. + */ + function _checkOwner() internal view virtual { + require(owner() == _msgSender(), "Ownable: caller is not the owner"); + } + + /** + * @dev Leaves the contract without owner. It will not be possible to call + * `onlyOwner` functions anymore. Can only be called by the current owner. + * + * NOTE: Renouncing ownership will leave the contract without an owner, + * thereby removing any functionality that is only available to the owner. + */ + function renounceOwnership() public virtual onlyOwner { + _transferOwnership(address(0)); + } + + /** + * @dev Transfers ownership of the contract to a new account (`newOwner`). + * Can only be called by the current owner. + */ + function transferOwnership(address newOwner) public virtual onlyOwner { + require(newOwner != address(0), "Ownable: new owner is the zero address"); + _transferOwnership(newOwner); + } + + /** + * @dev Transfers ownership of the contract to a new account (`newOwner`). + * Internal function without access restriction. + */ + function _transferOwnership(address newOwner) internal virtual { + address oldOwner = _owner; + _owner = newOwner; + emit OwnershipTransferred(oldOwner, newOwner); + } +} + + +// File contracts/SmartRoute/DODORouteProxy.sol + +/* + + Copyright 2022 DODO ZOO. + SPDX-License-Identifier: Apache-2.0 + +*/ + +pragma solidity 0.8.16; +pragma experimental ABIEncoderV2; + + + + + + + + + +/// @title DODORouteProxy +/// @author DODO Breeder +/// @notice new routeProxy contract with fee rebate to manage all route. It provides three methods to swap, +/// including mixSwap, multiSwap and externalSwap. Mixswap is for linear swap, which describes one token path +/// with one pool each time. Multiswap is a simplified version about 1inch, which describes one token path +/// with several pools each time. ExternalSwap is for other routers like 0x, 1inch and paraswap. Dodo and +/// front-end users could take certain route fee rebate from each swap. Wherein dodo will get a fixed percentage, +/// and front-end users could assign any proportion through function parameters. +/// @dev dependence: DODOApprove.sol / DODOApproveProxy.sol / IDODOAdapter.sol +/// In dodo's contract system, there is only one approve entrance DODOApprove.sol. DODOApprove manages DODOApproveProxy, +/// Any contract which needs claim user's tokens must be registered in DODOApproveProxy. They used in DODORouteProxy are +/// to manage user's token, all user's token must be claimed through DODOApproveProxy and DODOApprove +/// IDODOAdapter determine the interface of adapter, in which swap happened. There are different adapters for different +/// pools. Adapter addresses are parameters contructed off chain so they are loose coupling with routeProxy. +/// adapters have two interface functions. func sellBase(address to, address pool, bytes memory moreInfo) and func sellQuote(address to, address pool, bytes memory moreInfo) + +contract DODOFeeRouteProxy is Ownable { + + using UniversalERC20 for IERC20; + + // ============ Storage ============ + + address constant _ETH_ADDRESS_ = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + address public immutable _WETH_; + // dodo appprove proxy address, the only entrance to get user's token + address public immutable _DODO_APPROVE_PROXY_; + // used in multiSwap for split, sum of pool weight must equal totalWeight + // in PoolInfo, pool weight has 8 bit, so totalWeight < 2**8 + uint256 public totalWeight = 100; + // check safe safe for external call, add trusted external swap contract, 0x,1inch, paraswap + // only owner could manage + mapping(address => bool) public isWhiteListedContract; + // check safe for external approve, add trusted external swap approve contract, 0x, 1inch, paraswap + // only owner could manage + // Specially for 0x swap from eth, add zero address + mapping(address => bool) public isApproveWhiteListedContract; + + // dodo route fee rate, unit is 10**18, default fee rate is 1.5 * 1e16 / 1e18 = 0.015 = 0.15% + uint256 public routeFeeRate = 1500000000000000; + // dodo route fee receiver + address public routeFeeReceiver; + + struct PoolInfo { + // pool swap direciton, 0 is for sellBase, 1 is for sellQuote + uint256 direction; + // distinct transferFrom pool(like dodoV1) and transfer pool + // 1 is for transferFrom pool, pool call transferFrom function to get tokens from adapter + // 2 is for transfer pool, pool determine swapAmount through balanceOf(Token) - reserve + uint256 poolEdition; + // pool weight, actualWeight = weight/totalWeight, totalAmount * actualWeight = amount through this pool swap + uint256 weight; + // pool address + address pool; + // pool adapter, making actual swap call in corresponding adapter + address adapter; + // pool adapter's Info, record addtional infos(could be zero-bytes) needed by each pool adapter + bytes moreInfo; + } + + // ============ Events ============ + + event OrderHistory( + address fromToken, + address toToken, + address sender, + uint256 fromAmount, + uint256 returnAmount + ); + + event PositiveSlippage( + address token, + uint256 amount + ); + + // ============ Modifiers ============ + + modifier judgeExpired(uint256 deadLine) { + require(deadLine >= block.timestamp, "DODORouteProxy: EXPIRED"); + _; + } + + fallback() external payable {} + + receive() external payable {} + + // ============ Constructor ============ + + constructor(address payable weth, address dodoApproveProxy, address feeReceiver) { + require(feeReceiver != address(0), "DODORouteProxy: feeReceiver invalid"); + require(dodoApproveProxy != address(0), "DODORouteProxy: dodoApproveProxy invalid"); + require(weth != address(0), "DODORouteProxy: weth address invalid"); + + _WETH_ = weth; + _DODO_APPROVE_PROXY_ = dodoApproveProxy; + routeFeeReceiver = feeReceiver; + } + + // ============ Owner only ============ + + function addWhiteList(address contractAddr) public onlyOwner { + isWhiteListedContract[contractAddr] = true; + } + + function removeWhiteList(address contractAddr) public onlyOwner { + isWhiteListedContract[contractAddr] = false; + } + + function addApproveWhiteList(address contractAddr) public onlyOwner { + isApproveWhiteListedContract[contractAddr] = true; + } + + function removeApproveWhiteList(address contractAddr) public onlyOwner { + isApproveWhiteListedContract[contractAddr] = false; + } + + function changeRouteFeeRate(uint256 newFeeRate) public onlyOwner { + require(newFeeRate < 10**18, "DODORouteProxy: newFeeRate overflowed"); + routeFeeRate = newFeeRate; + } + + function changeRouteFeeReceiver(address newFeeReceiver) public onlyOwner { + require(newFeeReceiver != address(0), "DODORouteProxy: feeReceiver invalid"); + routeFeeReceiver = newFeeReceiver; + } + + function changeTotalWeight(uint256 newTotalWeight) public onlyOwner { + require(newTotalWeight < 2 ** 8, "DODORouteProxy: totalWeight overflowed"); + totalWeight = newTotalWeight; + } + + /// @notice used for emergency, generally there wouldn't be tokens left + function superWithdraw(address token) public onlyOwner { + if(token != _ETH_ADDRESS_) { + uint256 restAmount = IERC20(token).universalBalanceOf(address(this)); + IERC20(token).universalTransfer(payable(routeFeeReceiver), restAmount); + } else { + uint256 restAmount = address(this).balance; + payable(routeFeeReceiver).transfer(restAmount); + } + } + + // ============ Swap ============ + + + /// @notice Call external black box contracts to finish a swap + /// @param approveTarget external swap approve address + /// @param swapTarget external swap address + /// @param feeData route fee info + /// @param callDataConcat external swap data, toAddress need to be routeProxy + /// specially when toToken is ETH, use WETH as external calldata's toToken + function externalSwap( + address fromToken, + address toToken, + address approveTarget, + address swapTarget, + uint256 fromTokenAmount, + uint256 expReturnAmount, + uint256 minReturnAmount, + bytes memory feeData, + bytes memory callDataConcat, + uint256 deadLine + ) external payable judgeExpired(deadLine) returns (uint256 receiveAmount) { + require(isWhiteListedContract[swapTarget], "DODORouteProxy: Not Whitelist Contract"); + require(isApproveWhiteListedContract[approveTarget], "DODORouteProxy: Not Whitelist Appprove Contract"); + + // transfer in fromToken + if (fromToken != _ETH_ADDRESS_) { + // approve if needed + if (approveTarget != address(0)) { + IERC20(fromToken).universalApproveMax(approveTarget, fromTokenAmount); + } + + IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens( + fromToken, + msg.sender, + address(this), + fromTokenAmount + ); + } else { + // value check + require(msg.value == fromTokenAmount, "DODORouteProxy: invalid ETH amount"); + } + + // swap + uint256 toTokenOriginBalance; + if(toToken != _ETH_ADDRESS_) { + toTokenOriginBalance = IERC20(toToken).universalBalanceOf(address(this)); + } else { + toTokenOriginBalance = IERC20(_WETH_).universalBalanceOf(address(this)); + } + + { + uint256 valueToSend = fromToken == _ETH_ADDRESS_ ? fromTokenAmount : 0; + require(swapTarget != _DODO_APPROVE_PROXY_, "DODORouteProxy: Risk Target"); + (bool success, bytes memory result) = swapTarget.call{ + value: valueToSend + }(callDataConcat); + // revert with lowlevel info + if (success == false) { + assembly { + revert(add(result,32),mload(result)) + } + } + } + + // calculate toToken amount + if(toToken != _ETH_ADDRESS_) { + receiveAmount = IERC20(toToken).universalBalanceOf(address(this)) - ( + toTokenOriginBalance + ); + } else { + receiveAmount = IERC20(_WETH_).universalBalanceOf(address(this)) - ( + toTokenOriginBalance + ); + } + + // distribute toToken + receiveAmount = _routeWithdraw(toToken, receiveAmount, feeData, expReturnAmount, minReturnAmount); + + emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, receiveAmount); + } + + /// @notice linear version, describes one token path with one pool each time + /// @param mixAdapters adapter address array, record each pool's interrelated adapter in order + /// @param mixPairs pool address array, record pool address of the whole route in order + /// @param assetTo asset Address（pool or proxy）, describe pool adapter's receiver address. Specially assetTo[0] is deposit receiver before all + /// @param directions pool directions aggregation, one bit represent one pool direction, 0 means sellBase, 1 means sellQuote + /// @param moreInfos pool adapter's Info set, record addtional infos(could be zero-bytes) needed by each pool adapter, keeping order with adapters + /// @param feeData route fee info, bytes decode into broker and brokerFee, determine rebate proportion, brokerFee in [0, 1e18] + function mixSwap( + address fromToken, + address toToken, + uint256 fromTokenAmount, + uint256 expReturnAmount, + uint256 minReturnAmount, + address[] memory mixAdapters, + address[] memory mixPairs, + address[] memory assetTo, + uint256 directions, + bytes[] memory moreInfos, + bytes memory feeData, + uint256 deadLine + ) external payable judgeExpired(deadLine) returns (uint256) { + require(mixPairs.length > 0, "DODORouteProxy: PAIRS_EMPTY"); + require(mixPairs.length == mixAdapters.length, "DODORouteProxy: PAIR_ADAPTER_NOT_MATCH"); + require(mixPairs.length == assetTo.length - 1, "DODORouteProxy: PAIR_ASSETTO_NOT_MATCH"); + require(minReturnAmount > 0, "DODORouteProxy: RETURN_AMOUNT_ZERO"); + + address _fromToken = fromToken; + address _toToken = toToken; + uint256 _fromTokenAmount = fromTokenAmount; + uint256 _expReturnAmount = expReturnAmount; + uint256 _minReturnAmount = minReturnAmount; + address[] memory _mixAdapters = mixAdapters; + address[] memory _mixPairs = mixPairs; + address[] memory _assetTo = assetTo; + uint256 _directions = directions; + bytes[] memory _moreInfos = moreInfos; + bytes memory _feeData = feeData; + + uint256 toTokenOriginBalance; + if(_toToken != _ETH_ADDRESS_) { + toTokenOriginBalance = IERC20(_toToken).universalBalanceOf(address(this)); + } else { + toTokenOriginBalance = IERC20(_WETH_).universalBalanceOf(address(this)); + } + + // transfer in fromToken + bool isETH = _fromToken == _ETH_ADDRESS_; + _deposit( + msg.sender, + _assetTo[0], + _fromToken, + _fromTokenAmount, + isETH + ); + + // swap + for (uint256 i = 0; i < _mixPairs.length; i++) { + if (_directions & 1 == 0) { + IDODOAdapter(_mixAdapters[i]).sellBase( + _assetTo[i + 1], + _mixPairs[i], + _moreInfos[i] + ); + } else { + IDODOAdapter(_mixAdapters[i]).sellQuote( + _assetTo[i + 1], + _mixPairs[i], + _moreInfos[i] + ); + } + _directions = _directions >> 1; + } + + // calculate toToken amount + uint256 receiveAmount; + if(_toToken != _ETH_ADDRESS_) { + receiveAmount = IERC20(_toToken).universalBalanceOf(address(this)) - ( + toTokenOriginBalance + ); + } else { + receiveAmount = IERC20(_WETH_).universalBalanceOf(address(this)) - ( + toTokenOriginBalance + ); + } + + // distribute toToken + receiveAmount = _routeWithdraw(_toToken, receiveAmount, _feeData, _expReturnAmount, _minReturnAmount); + + emit OrderHistory(_fromToken, _toToken, msg.sender, _fromTokenAmount, receiveAmount); + + return receiveAmount; + } + + /// @notice split version, describes one token path with several pools each time. Called one token pair with several pools "one split" + /// @param splitNumber record pool number in one split, determine sequence(poolInfo) array subscript in transverse. Begin with 0 + /// for example, [0,1, 3], mean the first split has one(1 - 0) pool, the second split has 2 (3 - 1) pool + /// @param midToken middle token set, record token path in order. + /// Specially midToken[1] is WETH addresss when fromToken is ETH. Besides midToken[1] is also fromToken + /// Specially midToken[length - 2] is WETH address and midToken[length -1 ] is ETH address when toToken is ETH. Besides midToken[length -1] + /// is the last toToken and midToken[length - 2] is common second last middle token. + /// @param assetFrom asset Address（pool or proxy）describe pool adapter's receiver address. Specially assetFrom[0] is deposit receiver before all + /// @param sequence PoolInfo sequence, describe each pool's attributions, ordered by spiltNumber + /// @param feeData route fee info, bytes decode into broker and brokerFee, determine rebate proportion, brokerFee in [0, 1e18] + function dodoMutliSwap( + uint256 fromTokenAmount, + uint256 expReturnAmount, + uint256 minReturnAmount, + uint256[] memory splitNumber, + address[] memory midToken, + address[] memory assetFrom, + bytes[] memory sequence, + bytes memory feeData, + uint256 deadLine + ) external payable judgeExpired(deadLine) returns (uint256 receiveAmount) { + address toToken = midToken[midToken.length - 1]; + { + require( + assetFrom.length == splitNumber.length, + "DODORouteProxy: PAIR_ASSETTO_NOT_MATCH" + ); + require(minReturnAmount > 0, "DODORouteProxy: RETURN_AMOUNT_ZERO"); + uint256 _fromTokenAmount = fromTokenAmount; + address fromToken = midToken[0]; + + uint256 toTokenOriginBalance; + if(toToken != _ETH_ADDRESS_) { + toTokenOriginBalance = IERC20(toToken).universalBalanceOf(address(this)); + } else { + toTokenOriginBalance = IERC20(_WETH_).universalBalanceOf(address(this)); + } + + // transfer in fromToken + _deposit( + msg.sender, + assetFrom[0], + fromToken, + _fromTokenAmount, + fromToken == _ETH_ADDRESS_ + ); + + // swap + _multiSwap(midToken, splitNumber, sequence, assetFrom); + + // calculate toToken amount + if(toToken != _ETH_ADDRESS_) { + receiveAmount = IERC20(toToken).universalBalanceOf(address(this)) - ( + toTokenOriginBalance + ); + } else { + receiveAmount = IERC20(_WETH_).universalBalanceOf(address(this)) - ( + toTokenOriginBalance + ); + } + } + // distribute toToken + receiveAmount = _routeWithdraw(toToken, receiveAmount, feeData, expReturnAmount, minReturnAmount); + + emit OrderHistory( + midToken[0], //fromToken + midToken[midToken.length - 1], //toToken + msg.sender, + fromTokenAmount, + receiveAmount + ); + } + + //====================== internal ======================= + /// @notice multiSwap process + function _multiSwap( + address[] memory midToken, + uint256[] memory splitNumber, + bytes[] memory swapSequence, + address[] memory assetFrom + ) internal { + for (uint256 i = 1; i < splitNumber.length; i++) { + // begin one split(one token pair with one or more pools) + // define midtoken address, ETH -> WETH address + uint256 curTotalAmount = IERC20(midToken[i]).tokenBalanceOf(assetFrom[i - 1]); + uint256 curTotalWeight = totalWeight; + + // split amount into all pools if needed, transverse all pool in this split + for (uint256 j = splitNumber[i - 1]; j < splitNumber[i]; j++) { + PoolInfo memory curPoolInfo; + { + (address pool, address adapter, uint256 mixPara, bytes memory moreInfo) = abi + .decode(swapSequence[j], (address, address, uint256, bytes)); + + curPoolInfo.direction = mixPara >> 17; + curPoolInfo.weight = (0xffff & mixPara) >> 9; + curPoolInfo.poolEdition = (0xff & mixPara); + curPoolInfo.pool = pool; + curPoolInfo.adapter = adapter; + curPoolInfo.moreInfo = moreInfo; + } + + // assetFrom[i - 1] is routeProxy when there are more than one pools in this split + if (assetFrom[i - 1] == address(this)) { + uint256 curAmount = curTotalAmount * curPoolInfo.weight / curTotalWeight; + // last spilt check + if(j == splitNumber[i] - 1) { + curAmount = IERC20(midToken[i]).tokenBalanceOf(address(this)); + } + + if (curPoolInfo.poolEdition == 1) { + //For using transferFrom pool (like dodoV1, Curve), pool call transferFrom function to get tokens from adapter + SafeERC20.safeTransfer(IERC20(midToken[i]), curPoolInfo.adapter, curAmount); + } else { + //For using transfer pool (like dodoV2), pool determine swapAmount through balanceOf(Token) - reserve + SafeERC20.safeTransfer(IERC20(midToken[i]), curPoolInfo.pool, curAmount); + } + } + + if (curPoolInfo.direction == 0) { + IDODOAdapter(curPoolInfo.adapter).sellBase( + assetFrom[i], + curPoolInfo.pool, + curPoolInfo.moreInfo + ); + } else { + IDODOAdapter(curPoolInfo.adapter).sellQuote( + assetFrom[i], + curPoolInfo.pool, + curPoolInfo.moreInfo + ); + } + } + } + } + + /// @notice before the first pool swap, contract call _deposit to get ERC20 token through DODOApprove/transfer ETH to WETH + function _deposit( + address from, + address to, + address token, + uint256 amount, + bool isETH + ) internal { + if (isETH) { + if (amount > 0) { + require(msg.value == amount, "ETH_VALUE_WRONG"); + IWETH(_WETH_).deposit{value: amount}(); + if (to != address(this)) SafeERC20.safeTransfer(IERC20(_WETH_), to, amount); + } + } else { + IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens(token, from, to, amount); + } + } + + /// @notice after all swaps, transfer tokens to original receiver(user) and distribute fees to DODO and broker + /// Specially when toToken is ETH, distribute WETH + function _routeWithdraw( + address toToken, + uint256 receiveAmount, + bytes memory feeData, + uint256 expReturnAmount, + uint256 minReturnAmount + ) internal returns(uint256 userReceiveAmount) { + address originToToken = toToken; + if(toToken == _ETH_ADDRESS_) { + toToken = _WETH_; + } + (address broker, uint256 brokerFeeRate) = abi.decode(feeData, (address, uint256)); + require(brokerFeeRate < 10**18, "DODORouteProxy: brokerFeeRate overflowed"); + + uint256 routeFee = DecimalMath.mulFloor(receiveAmount, routeFeeRate); + + uint256 brokerFee = DecimalMath.mulFloor(receiveAmount, brokerFeeRate); + IERC20(toToken).universalTransfer(payable(broker), brokerFee); + + receiveAmount = receiveAmount - routeFee - brokerFee; + require(receiveAmount >= minReturnAmount, "DODORouteProxy: Return amount is not enough"); + + if (receiveAmount > expReturnAmount) { + uint256 amount = receiveAmount - expReturnAmount; + IERC20(toToken).universalTransfer(payable(routeFeeReceiver), amount + routeFee); + receiveAmount = expReturnAmount; + + emit PositiveSlippage(toToken, amount); + } else { + IERC20(toToken).universalTransfer(payable(routeFeeReceiver), routeFee); + } + + if (originToToken == _ETH_ADDRESS_) { + IWETH(_WETH_).withdraw(receiveAmount); + payable(msg.sender).transfer(receiveAmount); + } else { + IERC20(toToken).universalTransfer(payable(msg.sender), receiveAmount); + } + + userReceiveAmount = receiveAmount; + } +}