文件 1 的 1：WardenRouterV2.sol
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
pragma solidity ^0.8.0;
interface IERC20 {
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 sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.8.0;
interface IERC20NoReturn {
function transfer(address recipient, uint256 amount) external;
function transferFrom(
address sender,
address recipient,
uint256 amount
) external;
}
library TransferHelper {
function safeTransfer(IERC20 token, address to, uint value) internal {
try IERC20NoReturn(address(token)).transfer(to, value) {
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("TransferHelper: transfer failed");
}
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
try IERC20NoReturn(address(token)).transferFrom(from, to, value) {
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("TransferHelper: transferFrom failed");
}
}
}
pragma solidity ^0.8.0;
interface IWETH {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
pragma solidity ^0.8.0;
interface IWardenPreTrade2 {
function preTradeAndFee(
IERC20 _src,
IERC20 _dest,
uint256 _srcAmount,
address _trader,
address _receiver,
uint256 _partnerId,
uint256 _metaData
)
external
returns (
uint256[] memory _fees,
address[] memory _collectors
);
}
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
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");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
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");
}
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);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
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);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
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);
}
function _verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity ^0.8.0;
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));
}
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
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 _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
pragma solidity ^0.8.0;
interface IWardenSwap2 {
function trade(
bytes calldata _data,
IERC20 _src,
uint256 _srcAmount,
uint256 _originalSrcAmount,
IERC20 _dest,
address _receiver,
address _trader,
uint256 _partnerId,
uint256 _metaData
)
external;
function tradeSplit(
bytes calldata _data,
uint256[] calldata _volumes,
IERC20 _src,
uint256 _totalSrcAmount,
uint256 _originalSrcAmount,
IERC20 _dest,
address _receiver,
address _trader,
uint256 _partnerId,
uint256 _metaData
)
external;
}
pragma solidity ^0.8.0;
contract WardenRouterV2 is Ownable {
using TransferHelper for IERC20;
IWardenPreTrade2 public preTrade;
IWETH public immutable weth;
IERC20 private constant ETHER_ERC20 = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
event UpdatedWardenPreTrade(
IWardenPreTrade2 indexed preTrade
);
event ProtocolFee(
IERC20 indexed token,
address indexed wallet,
uint256 amount
);
event PartnerFee(
uint256 indexed partnerId,
IERC20 indexed token,
address indexed wallet,
uint256 amount
);
event Trade(
address indexed srcAsset,
uint256 srcAmount,
address indexed destAsset,
uint256 destAmount,
address indexed trader,
address receiver,
bool hasSplitted
);
constructor(
IWardenPreTrade2 _preTrade,
IWETH _weth
) {
preTrade = _preTrade;
weth = _weth;
emit UpdatedWardenPreTrade(_preTrade);
}
function updateWardenPreTrade(
IWardenPreTrade2 _preTrade
)
external
onlyOwner
{
preTrade = _preTrade;
emit UpdatedWardenPreTrade(_preTrade);
}
function swap(
IWardenSwap2 _swap,
bytes calldata _data,
address _deposits,
IERC20 _src,
uint256 _srcAmount,
IERC20 _dest,
uint256 _minDestAmount,
address _receiver,
uint256 _partnerId,
uint256 _metaData
)
external
payable
returns(uint256 _destAmount)
{
if (_receiver == address(0)) {
_receiver = msg.sender;
}
uint256 newSrcAmount = _preTradeAndCollectFee(
_src,
_dest,
_srcAmount,
msg.sender,
_receiver,
_partnerId,
_metaData
);
if (ETHER_ERC20 == _src) {
require(msg.value == _srcAmount, "WardenRouter::swap: Ether source amount mismatched");
weth.deposit{value: newSrcAmount}();
IERC20(address(weth)).safeTransfer(_deposits, newSrcAmount);
} else {
_src.safeTransferFrom(msg.sender, _deposits, newSrcAmount);
}
bytes memory payload = abi.encodeWithSelector(IWardenSwap2.trade.selector,
_data,
_src,
newSrcAmount,
_srcAmount,
_dest,
_receiver,
msg.sender,
_partnerId,
_metaData
);
_destAmount = _internalSwap(
_swap,
payload,
_dest,
_minDestAmount,
_receiver
);
emit Trade(address(_src), _srcAmount, address(_dest), _destAmount, msg.sender, _receiver, false);
}
function swapSplit(
IWardenSwap2 _swap,
bytes calldata _data,
address[] memory _deposits,
uint256[] memory _volumes,
IERC20 _src,
uint256 _totalSrcAmount,
IERC20 _dest,
uint256 _minDestAmount,
address _receiver,
uint256 _partnerId,
uint256 _metaData
)
external
payable
returns(uint256 _destAmount)
{
if (_receiver == address(0)) {
_receiver = msg.sender;
}
uint256 newTotalSrcAmount = _preTradeAndCollectFee(
_src,
_dest,
_totalSrcAmount,
msg.sender,
_receiver,
_partnerId,
_metaData
);
if (ETHER_ERC20 == _src) {
require(msg.value == _totalSrcAmount, "WardenRouter::swapSplit: Ether source amount mismatched");
weth.deposit{value: newTotalSrcAmount}();
}
_depositVolumes(
newTotalSrcAmount,
_deposits,
_volumes,
_src
);
bytes memory payload = abi.encodeWithSelector(IWardenSwap2.tradeSplit.selector,
_data,
_volumes,
_src,
newTotalSrcAmount,
_totalSrcAmount,
_dest,
_receiver,
msg.sender,
_partnerId,
_metaData
);
_destAmount = _internalSwap(
_swap,
payload,
_dest,
_minDestAmount,
_receiver
);
emit Trade(address(_src), _totalSrcAmount, address(_dest), _destAmount, msg.sender, _receiver, true);
}
function _depositVolumes(
uint256 newTotalSrcAmount,
address[] memory _deposits,
uint256[] memory _volumes,
IERC20 _src
)
private
{
{
uint256 amountRemain = newTotalSrcAmount;
for (uint i = 0; i < _deposits.length; i++) {
uint256 amountForThisRound;
if (i == _deposits.length - 1) {
amountForThisRound = amountRemain;
} else {
amountForThisRound = newTotalSrcAmount * _volumes[i] / 100;
amountRemain = amountRemain - amountForThisRound;
}
if (ETHER_ERC20 == _src) {
IERC20(address(weth)).safeTransfer(_deposits[i], amountForThisRound);
} else {
_src.safeTransferFrom(msg.sender, _deposits[i], amountForThisRound);
}
}
}
}
function _internalSwap(
IWardenSwap2 _swap,
bytes memory _payload,
IERC20 _dest,
uint256 _minDestAmount,
address _receiver
)
private
returns (uint256 _destAmount)
{
uint256 destAmountBefore = ETHER_ERC20 == _dest ? _receiver.balance : _dest.balanceOf(_receiver);
{
(bool success, bytes memory result) = address(_swap).call(_payload);
if (!success) {
if (result.length < 68) revert();
assembly {
result := add(result, 0x04)
}
revert(abi.decode(result, (string)));
}
}
_destAmount = ETHER_ERC20 == _dest ? _receiver.balance - destAmountBefore : _dest.balanceOf(_receiver) - destAmountBefore;
require(_destAmount >= _minDestAmount, "WardenRouter::_internalSwap: destination amount is too low.");
}
function _preTradeAndCollectFee(
IERC20 _src,
IERC20 _dest,
uint256 _srcAmount,
address _trader,
address _receiver,
uint256 _partnerId,
uint256 _metaData
)
private
returns (uint256 _newSrcAmount)
{
(uint256[] memory fees, address[] memory feeWallets) = preTrade.preTradeAndFee(
_src,
_dest,
_srcAmount,
_trader,
_receiver,
_partnerId,
_metaData
);
_newSrcAmount = _srcAmount;
if (fees.length > 0) {
if (fees[0] > 0) {
_collectFee(
_trader,
_src,
fees[0],
feeWallets[0]
);
_newSrcAmount -= fees[0];
}
if (fees.length == 2 && fees[1] > 0) {
_partnerFee(
_trader,
_partnerId,
_src,
fees[1],
feeWallets[1]
);
_newSrcAmount -= fees[1];
}
}
}
function _collectFee(
address _trader,
IERC20 _token,
uint256 _fee,
address _feeWallet
)
private
{
if (ETHER_ERC20 == _token) {
(bool success, ) = payable(_feeWallet).call{value: _fee}("");
require(success, "WardenRouter::_collectFee: Transfer fee of ether failed.");
} else {
_token.safeTransferFrom(_trader, _feeWallet, _fee);
}
emit ProtocolFee(_token, _feeWallet, _fee);
}
function _partnerFee(
address _trader,
uint256 _partnerId,
IERC20 _token,
uint256 _fee,
address _feeWallet
)
private
{
if (ETHER_ERC20 == _token) {
(bool success, ) = payable(_feeWallet).call{value: _fee}("");
require(success, "WardenRouter::_partnerFee: Transfer fee of ether failed.");
} else {
_token.safeTransferFrom(_trader, _feeWallet, _fee);
}
emit PartnerFee(_partnerId, _token, _feeWallet, _fee);
}
function tradeEthToWeth(
address _receiver
)
external
payable
returns(uint256 _destAmount)
{
if (_receiver == address(0)) {
_receiver = msg.sender;
}
weth.deposit{value: msg.value}();
IERC20(address(weth)).safeTransfer(_receiver, msg.value);
_destAmount = msg.value;
emit Trade(address(ETHER_ERC20), msg.value, address(weth), _destAmount, msg.sender, _receiver, false);
}
function tradeWethToEth(
uint256 _srcAmount,
address _receiver
)
external
returns(uint256 _destAmount)
{
if (_receiver == address(0)) {
_receiver = msg.sender;
}
IERC20(address(weth)).safeTransferFrom(msg.sender, address(this), _srcAmount);
weth.withdraw(_srcAmount);
(bool success, ) = _receiver.call{value: _srcAmount}("");
require(success, "WardenRouter::tradeWethToEth: Transfer ether back to receiver failed.");
_destAmount = _srcAmount;
emit Trade(address(weth), _srcAmount, address(ETHER_ERC20), _destAmount, msg.sender, _receiver, false);
}
receive() external payable {
require(msg.sender == address(weth), "WardenRouter: Receive Ether only from WETH");
}
function collectRemainingToken(
IERC20 _token,
uint256 _amount
)
external
onlyOwner
{
_token.safeTransfer(msg.sender, _amount);
}
function collectRemainingEther(
uint256 _amount
)
external
onlyOwner
{
(bool success, ) = msg.sender.call{value: _amount}("");
require(success, "WardenRouter::collectRemainingEther: Transfer ether back to caller failed.");
}
}
