More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 177,658 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Swap | 14971596 | 20 days ago | IN | 0.00123 ETH | 0.00004169 | ||||
Swap | 13039037 | 67 days ago | IN | 0.026 ETH | 0.00000862 | ||||
Swap | 11904526 | 94 days ago | IN | 0.018 ETH | 0.00001464 | ||||
Swap | 11366259 | 106 days ago | IN | 0 ETH | 0.00001941 | ||||
Swap | 9924399 | 140 days ago | IN | 0 ETH | 0.00000306 | ||||
Swap | 9924399 | 140 days ago | IN | 0 ETH | 0.00000311 | ||||
Swap | 9924399 | 140 days ago | IN | 0 ETH | 0.00000297 | ||||
Swap | 9924399 | 140 days ago | IN | 0 ETH | 0.00000297 | ||||
Swap | 9924399 | 140 days ago | IN | 0 ETH | 0.00001398 | ||||
Swap | 9920746 | 140 days ago | IN | 0.00331726 ETH | 0.00002039 | ||||
Swap | 9505150 | 150 days ago | IN | 0.0036 ETH | 0.00001267 | ||||
Swap | 9499135 | 150 days ago | IN | 0 ETH | 0.00002108 | ||||
Swap | 9449304 | 151 days ago | IN | 0 ETH | 0.00005031 | ||||
Swap | 9445840 | 151 days ago | IN | 0.0038 ETH | 0.0000129 | ||||
Swap | 9443563 | 151 days ago | IN | 0.011 ETH | 0.00001949 | ||||
Swap | 9442517 | 151 days ago | IN | 0.0158989 ETH | 0.00002031 | ||||
Swap | 9431244 | 152 days ago | IN | 0.00335 ETH | 0.0000109 | ||||
Swap | 9431233 | 152 days ago | IN | 0.0041 ETH | 0.00001202 | ||||
Swap | 9431181 | 152 days ago | IN | 0.00337 ETH | 0.00001274 | ||||
Swap | 9417986 | 152 days ago | IN | 0.00399 ETH | 0.00001335 | ||||
Swap | 9417668 | 152 days ago | IN | 0.0038 ETH | 0.00001438 | ||||
Swap | 9417504 | 152 days ago | IN | 0.0041 ETH | 0.00001439 | ||||
Swap | 9417426 | 152 days ago | IN | 0.0038 ETH | 0.00001478 | ||||
Swap | 9416660 | 152 days ago | IN | 0.0033 ETH | 0.00001315 | ||||
Swap | 9415870 | 152 days ago | IN | 0.0034 ETH | 0.00001133 |
Latest 25 internal transactions (View All)
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
14971596 | 20 days ago | 0 ETH | ||||
14971596 | 20 days ago | 0 ETH | ||||
14971596 | 20 days ago | 0 ETH | ||||
14971596 | 20 days ago | 0 ETH | ||||
14971596 | 20 days ago | 0 ETH | ||||
14971596 | 20 days ago | 0 ETH | ||||
14971596 | 20 days ago | 0 ETH | ||||
14971596 | 20 days ago | 0.00123 ETH | ||||
13039037 | 67 days ago | 0 ETH | ||||
13039037 | 67 days ago | 0 ETH | ||||
13039037 | 67 days ago | 0 ETH | ||||
13039037 | 67 days ago | 0 ETH | ||||
13039037 | 67 days ago | 0 ETH | ||||
13039037 | 67 days ago | 0 ETH | ||||
13039037 | 67 days ago | 0 ETH | ||||
13039037 | 67 days ago | 0.026 ETH | ||||
11904526 | 94 days ago | 0 ETH | ||||
11904526 | 94 days ago | 0 ETH | ||||
11904526 | 94 days ago | 0 ETH | ||||
11904526 | 94 days ago | 0 ETH | ||||
11904526 | 94 days ago | 0 ETH | ||||
11904526 | 94 days ago | 0 ETH | ||||
11904526 | 94 days ago | 0 ETH | ||||
11904526 | 94 days ago | 0.018 ETH | ||||
11366259 | 106 days ago | 0.11774511 ETH |
Loading...
Loading
Contract Name:
WowmaxEventRouter
Compiler Version
v0.8.7+commit.e28d00a7
Optimization Enabled:
Yes with 800 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "./WowmaxRouter.sol"; import "./interfaces/IWowmaxEvent.sol"; import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; contract WowmaxEventRouter is WowmaxRouter { EnumerableSet.AddressSet private events; using EnumerableSet for EnumerableSet.AddressSet; constructor(address _weth, address _treasury) WowmaxRouter(_weth, _treasury) {} function addEvent(address eventManager) external onlyOwner { events.add(eventManager); } function removeEvent(address eventManager) external onlyOwner { events.remove(eventManager); } function swap( ExchangeRequest calldata request ) public payable override reentrancyProtectedSwap returns (uint256[] memory amountsOut) { return _swapWithReward(request, address(0)); } function swapWithReferral( ExchangeRequest calldata request, address referral ) public payable reentrancyProtectedSwap returns (uint256[] memory amountsOut) { return _swapWithReward(request, referral); } function _swapWithReward( ExchangeRequest calldata request, address referral ) internal returns (uint256[] memory amountsOut) { amountsOut = _swap(request); address tokenIn = request.from == address(0) ? address(WETH) : request.from; uint256 amountIn = request.from == address(0) ? msg.value : request.amountIn; uint256 eventsCount = events.length(); for (uint256 i = 0; i < eventsCount; i++) { IWowmaxEvent(events.at(i)).rewardSwap(_msgSender(), tokenIn, amountIn, request.to, amountsOut, referral); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @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); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) pragma solidity ^0.8.0; /** * @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); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @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); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; import "../extensions/draft-IERC20Permit.sol"; import "../../../utils/Address.sol"; /** * @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"); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @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 functionCallWithValue(target, data, 0, "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"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, 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) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, 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) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or 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 { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // 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); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @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; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol) // This file was procedurally generated from scripts/generate/templates/EnumerableSet.js. pragma solidity ^0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. * * [WARNING] * ==== * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure * unusable. * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info. * * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an * array of EnumerableSet. * ==== */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; if (lastIndex != toDeleteIndex) { bytes32 lastValue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastValue; // Update the index for the moved value set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex } // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { return set._values[index]; } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function _values(Set storage set) private view returns (bytes32[] memory) { return set._values; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(Bytes32Set storage set) internal view returns (bytes32[] memory) { bytes32[] memory store = _values(set._inner); bytes32[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(AddressSet storage set) internal view returns (address[] memory) { bytes32[] memory store = _values(set._inner); address[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values in the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(UintSet storage set) internal view returns (uint256[] memory) { bytes32[] memory store = _values(set._inner); uint256[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; /** * @title Wrapped Ether contract interface */ interface IWETH is IERC20 { /** * @dev `msg.value` of ETH sent to this contract grants caller account a matching increase in WETH token balance. */ function deposit() external payable; /** * @dev Burn WETH token from caller account and withdraw matching ETH to the same. * @param wad Amount of WETH token to burn. */ function withdraw(uint wad) external; }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; /** * @title IWowmaxEvent * @notice Interface for the Wowmax event, describes the functions that can be called to process event rewards */ interface IWowmaxEvent { function rewardSwap( address account, address tokenIn, uint256 amountIn, address[] calldata tokensOut, uint256[] calldata amountsOut, address referral ) external; function eventDates() external view returns (uint256 start, uint256 end); }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "./IWowmaxRouterBase.sol"; /** * @title IWowmaxRouter * @notice Interface for the Wowmax Router, describes the functions that can be called from the router * and corresponding data structures */ interface IWowmaxRouter is IWowmaxRouterBase { /** * @notice Executes a token swap * @dev if from token is address(0) and amountIn is 0, * then chain native token is used as a source token, and value is used as an input amount * @param request Exchange request to be executed * @return amountsOut Array of output amounts that were received for each target token */ function swap(ExchangeRequest calldata request) external payable returns (uint256[] memory amountsOut); }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; /** * @title IWowmaxRouterBase * @notice Interface for the Wowmax Router Base, describes data structures */ interface IWowmaxRouterBase { /** * @notice Swap operation details structure * @param to Target token address * @param part Part of the currently owned tokens to be swapped. Total number of parts * is defined in the ExchangeRoute structure * @param addr Contract address that performs the swap * @param family Contract DEX family * @param data Additional data that is required for a specific DEX protocol */ struct Swap { address to; uint256 part; address addr; bytes32 family; bytes data; } /** * @notice Exchange route details structure * @param from Source token address * @param parts Total number of parts of the currently owned tokens * @param swaps Array of swaps for a specified token */ struct ExchangeRoute { address from; uint256 parts; Swap[] swaps; } /** * @notice Exchange request details structure * @param from Source token address * @param amountIn Source token amount to swap * @param to Array of target token addresses * @param exchangeRoutes Array of exchange routes * @param slippage Array of slippage tolerance values for each target token * @param amountOutExpected Array fo expected output amounts for each target token */ struct ExchangeRequest { address from; uint256 amountIn; address[] to; ExchangeRoute[] exchangeRoutes; uint256[] slippage; uint256[] amountOutExpected; } /** * @notice Emitted when a swap is executed * @param account Account that initiated the swap * @param from Source token address * @param amountIn Source token amount that was swapped * @param to Array of target token addresses * @param amountOut Array of amounts that were received for each target token */ event SwapExecuted( address indexed account, address indexed from, uint256 amountIn, address[] to, uint256[] amountOut ); }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title Algebra V1 pool interface */ interface IAlgebraV1Pool { /** * @notice Swap token0 for token1, or token1 for token0 * @dev The caller of this method receives a callback in the form of IAlgebraSwapCallback# AlgebraSwapCallback * @param recipient The address to receive the output of the swap * @param zeroToOne The direction of the swap, true for token0 to token1, false for token1 to token0 * @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative) * @param limitSqrtPrice The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this * value after the swap. If one for zero, the price cannot be greater than this value after the swap * @param data Any data to be passed through to the callback. If using the Router it should contain * SwapRouter#SwapCallbackData * @return amount0 The delta of the balance of token0 of the pool, exact when negative, minimum when positive * @return amount1 The delta of the balance of token1 of the pool, exact when negative, minimum when positive */ function swap( address recipient, bool zeroToOne, int256 amountSpecified, uint160 limitSqrtPrice, bytes calldata data ) external returns (int256 amount0, int256 amount1); /** * @dev Returns the address of the first token of the Uniswap v3 based pair * @return Address of the first token of the pair */ function token0() external view returns (address); /** * @dev Returns the address of the second token of the Uniswap v3 based pair * @return Address of the second token of the pair */ function token1() external view returns (address); } /** * @title Algebra V1 library * @notice Functions to swap tokens on Algebra V1 based protocols */ library AlgebraV1 { using SafeERC20 for IERC20; /** * @dev Swaps tokens on a Algebra V1 based protocol contract * @param from Address of token to swap from * @param amountIn Amount of token to swap * @param swapData Swap operation details. The `data` field should contain two int128 values, * which are the indices of the tokens to swap from and to * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { bool zeroToOne = from == IAlgebraV1Pool(swapData.addr).token0(); uint160 sqrtPriceLimitX96 = zeroToOne ? 4295128740 : 1461446703485210103287273052203988822378723970341; (int256 amount0, int256 amount1) = IAlgebraV1Pool(swapData.addr).swap( address(this), zeroToOne, int256(amountIn), sqrtPriceLimitX96, new bytes(0) ); amountOut = uint(zeroToOne ? -amount1 : -amount0); } /** * @dev Performs Algebra V1 callback, sends required amounts of tokens to the pair * @param amount0Delta Amount of the first token to send * @param amount1Delta Amount of the second token to send */ function invokeCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata /*_data*/) internal { if (amount0Delta > 0 && amount1Delta < 0) { IERC20(IAlgebraV1Pool(msg.sender).token0()).safeTransfer(msg.sender, uint256(amount0Delta)); } else if (amount0Delta < 0 && amount1Delta > 0) { IERC20(IAlgebraV1Pool(msg.sender).token1()).safeTransfer(msg.sender, uint256(amount1Delta)); } else { revert("WOWMAX: Algebra V1 invariant violation"); } } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title Balancer Asset interface */ interface IBalancerAsset { // solhint-disable-previous-line no-empty-blocks } /** * @title Balancer vault interface */ interface IBalancerVault { enum SwapKind { GIVEN_IN, GIVEN_OUT } /** * @dev Data for a single swap executed by `swap`. `amount` is either `amountIn` or `amountOut` depending on * the `kind` value. * * `assetIn` and `assetOut` are either token addresses, or the IAsset sentinel value for ETH (the zero address). * Note that Pools never interact with ETH directly: it will be wrapped to or unwrapped from WETH by the Vault. * * The `userData` field is ignored by the Vault, but forwarded to the Pool in the `onSwap` hook, and may be * used to extend swap behavior. */ struct SingleSwap { bytes32 poolId; SwapKind kind; IBalancerAsset assetIn; IBalancerAsset assetOut; uint256 amount; bytes userData; } /** * @dev All tokens in a swap are either sent from the `sender` account to the Vault, or from the Vault to the * `recipient` account. * * If the caller is not `sender`, it must be an authorized relayer for them. * * If `fromInternalBalance` is true, the `sender`'s Internal Balance will be preferred, performing an ERC20 * transfer for the difference between the requested amount and the User's Internal Balance (if any). The `sender` * must have allowed the Vault to use their tokens via `IERC20.approve()`. This matches the behavior of * `joinPool`. * * If `toInternalBalance` is true, tokens will be deposited to `recipient`'s internal balance instead of * transferred. This matches the behavior of `exitPool`. * * Note that ETH cannot be deposited to or withdrawn from Internal Balance: attempting to do so will trigger a * revert. */ struct FundManagement { address sender; bool fromInternalBalance; address payable recipient; bool toInternalBalance; } /** * @dev Performs a swap with a single Pool. * * If the swap is 'given in' (the number of tokens to send to the Pool is known), it returns the amount of tokens * taken from the Pool, which must be greater than or equal to `limit`. * * If the swap is 'given out' (the number of tokens to take from the Pool is known), it returns the amount of tokens * sent to the Pool, which must be less than or equal to `limit`. * * Internal Balance usage and the recipient are determined by the `funds` struct. * * Emits a `Swap` event. */ function swap( SingleSwap memory singleSwap, FundManagement memory funds, uint256 limit, uint256 deadline ) external payable returns (uint256); } /** * @title Balancer library * @notice Functions to swap tokens on Balancer and compatible protocols */ library BalancerV2 { using SafeERC20 for IERC20; /** * @dev Performs a swap through a Balancer based vault * @param from Address of a token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details. The `data` field should contain poolId and vault address * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { (bytes32 poolId, address vaultAddress) = abi.decode(swapData.data, (bytes32, address)); IBalancerVault.SingleSwap memory singleSwap = IBalancerVault.SingleSwap({ poolId: poolId, kind: IBalancerVault.SwapKind.GIVEN_IN, assetIn: IBalancerAsset(from), assetOut: IBalancerAsset(swapData.to), amount: amountIn, userData: new bytes(0) }); IBalancerVault.FundManagement memory funds = IBalancerVault.FundManagement({ sender: address(this), fromInternalBalance: false, recipient: payable(address(this)), toInternalBalance: false }); IERC20(from).safeIncreaseAllowance(vaultAddress, amountIn); amountOut = IBalancerVault(vaultAddress).swap(singleSwap, funds, 0, type(uint256).max); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title Curve pool interface */ interface ICurvePool { /** * @dev Swaps tokens on a Curve based protocol contract * @param i Index of token to swap from * @param j Index of token to swap to * @param dx Amount of token to swap * @param min_dy Minimum amount of tokens to receive */ function exchange(int128 i, int128 j, uint256 dx, uint256 min_dy) external; } /** * @title Curve library * @notice Functions to swap tokens on Curve based protocols */ library Curve { using SafeERC20 for IERC20; /** * @dev Swaps tokens on a Curve based protocol contract * @param from Address of token to swap from * @param amountIn Amount of token to swap * @param swapData Swap operation details. The `data` field should contain two int128 values, * which are the indices of the tokens to swap from and to * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { (int128 i, int128 j) = abi.decode(swapData.data, (int128, int128)); uint256 balanceBefore = IERC20(swapData.to).balanceOf(address(this)); //slither-disable-next-line unused-return //it's safe to ignore IERC20(from).safeIncreaseAllowance(swapData.addr, amountIn); ICurvePool(swapData.addr).exchange(i, j, amountIn, 0); amountOut = IERC20(swapData.to).balanceOf(address(this)) - balanceBefore; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title DODO v1 pool interface */ interface IDODOV1Pool { /** * @dev Sells base token for quote token * @param amount Amount of base token to sell * @param minReceiveQuote Minimum amount of quote token to receive * @param data Additional data to be used in callback hook * @return amountOut Amount of quote token received */ function sellBaseToken(uint256 amount, uint256 minReceiveQuote, bytes calldata data) external returns (uint256); /** * @dev Buys base token with quote token * @param amount Amount of base token to buy * @param maxPayQuote Maximum amount of quote token to pay * @param data Additional data to be used in callback hook * @return amountOut Amount of base token received */ function buyBaseToken(uint256 amount, uint256 maxPayQuote, bytes calldata data) external returns (uint256); } /** * @title DODO v1 library * @notice Functions to swap tokens on DODO v1 protocol */ library DODOV1 { using SafeERC20 for IERC20; /** * @dev Swaps tokens on a Curve based protocol contract * @param from Address of token to swap from * @param amountIn Amount of token to swap * @param swapData Swap operation details. The `data` field should contain two int128 values, i and j, * which are the indexes of the tokens to swap * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { //slither-disable-next-line unused-return //it's safe to ignore IERC20(from).safeIncreaseAllowance(swapData.addr, amountIn); amountOut = IDODOV1Pool(swapData.addr).sellBaseToken(amountIn, 0, ""); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title DODO v2 pool interface */ interface IDODOV2Pool { /** * @dev Swaps tokens on a DODO v2 based protocol contract * @param to Address of token to swap to * @return amountOut Amount of tokens received */ function sellBase(address to) external returns (uint256); /** * @dev Swaps tokens on a DODO v2 based protocol contract * @param to Address of token to swap to * @return amountOut Amount of tokens received */ function sellQuote(address to) external returns (uint256); } /** * @title DODO v2 library * @notice Functions to swap tokens on DODO v2 protocol */ library DODOV2 { uint8 internal constant BASE_TO_QUOTE = 0; using SafeERC20 for IERC20; /** * @dev Swaps tokens on a DODO v2 pool contract * @param from Address of token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details. The `data` field should contain one uint8 value, * which is the direction of the swap * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { IERC20(from).safeTransfer(swapData.addr, amountIn); uint8 direction = abi.decode(swapData.data, (uint8)); if (direction == BASE_TO_QUOTE) { amountOut = IDODOV2Pool(swapData.addr).sellBase(address(this)); } else { amountOut = IDODOV2Pool(swapData.addr).sellQuote(address(this)); } } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title DODO v3 pool interface */ interface IDODOV3Pool { /** * @dev Swaps tokens on a DODO v3 based protocol contract * @param to Address to send swapped tokens to * @param fromToken Address of a token to swap from * @param toToken Address of a token to swap to * @param fromAmount Amount of tokens to swap * @param minReceiveAmount Minimal amount of tokens to receive * @param data Data to be passed to the Dodo V3 Swap Callback contract * @return Amount of tokens received */ function sellToken( address to, address fromToken, address toToken, uint256 fromAmount, uint256 minReceiveAmount, bytes calldata data ) external returns (uint256); } /** * @title DODO v3 library * @notice Functions to swap tokens on DODO v3 protocol */ library DODOV3 { uint8 internal constant BASE_TO_QUOTE = 0; using SafeERC20 for IERC20; /** * @dev Swaps tokens on a DODO v3 pool contract * @param from Address of token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details. The `data` field should be empty * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { return IDODOV3Pool(swapData.addr).sellToken(address(this), from, swapData.to, amountIn, 0, ""); } /** * @dev Callback function to receive tokens from DODO v3 pool contract * @param token Address of token to receive * @param amount Amount of tokens to receive */ function invokeCallback(address token, uint256 amount, bytes calldata /*data*/) internal { IERC20(token).safeTransfer(msg.sender, amount); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title Elastic pool interface */ interface IElasticPool { /** * @notice Swap token0 -> token1, or vice versa * @dev This method's caller receives a callback in the form of ISwapCallback#swapCallback * @dev swaps will execute up to limitSqrtP or swapQty is fully used * @param recipient The address to receive the swap output * @param swapQty The swap quantity, which implicitly configures the swap as exact input (>0), or exact output (<0) * @param isToken0 Whether the swapQty is specified in token0 (true) or token1 (false) * @param limitSqrtP the limit of sqrt price after swapping * could be MAX_SQRT_RATIO-1 when swapping 1 -> 0 and MIN_SQRT_RATIO+1 when swapping 0 -> 1 for no limit swap * @param data Any data to be passed through to the callback * @return qty0 Exact token0 qty sent to recipient if < 0. Minimally received quantity if > 0. * @return qty1 Exact token1 qty sent to recipient if < 0. Minimally received quantity if > 0. */ function swap( address recipient, int256 swapQty, bool isToken0, uint160 limitSqrtP, bytes calldata data ) external returns (int256 qty0, int256 qty1); /** * @dev Returns the address of the first token of the Uniswap v3 based pair * @return Address of the first token of the pair */ function token0() external view returns (address); /** * @dev Returns the address of the second token of the Uniswap v3 based pair * @return Address of the second token of the pair */ function token1() external view returns (address); } /** * @title Elastic library * @notice Functions to swap tokens on Elastic based protocols */ library Elastic { using SafeERC20 for IERC20; /** * @dev Swaps tokens on Elastic based protocol contract * @param from Address of token to swap from * @param amountIn Amount of token to swap * @param swapData Swap operation details. The `data` field should contain two int128 values, * which are the indices of the tokens to swap from and to * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { bool isToken0 = from == IElasticPool(swapData.addr).token0(); uint160 sqrtPriceLimitX96 = isToken0 ? 4295128740 : 1461446703485210103287273052203988822378723970341; (int256 amount0, int256 amount1) = IElasticPool(swapData.addr).swap( address(this), int256(amountIn), isToken0, sqrtPriceLimitX96, new bytes(0) ); amountOut = uint(isToken0 ? -amount1 : -amount0); } /** * @dev Performs Elastic callback, sends required amounts of tokens to the pair * @param deltaQty0 Amount of the first token to send * @param deltaQty1 Amount of the second token to send */ function invokeCallback(int256 deltaQty0, int256 deltaQty1, bytes calldata /*_data*/) internal { if (deltaQty0 > 0 && deltaQty1 < 0) { IERC20(IElasticPool(msg.sender).token0()).safeTransfer(msg.sender, uint256(deltaQty0)); } else if (deltaQty0 < 0 && deltaQty1 > 0) { IERC20(IElasticPool(msg.sender).token1()).safeTransfer(msg.sender, uint256(deltaQty1)); } else { revert("WOWMAX: Elastic invariant violation"); } } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title Fulcrom pool interface */ interface IFulcromPool { /** * @dev Swaps tokens on a Fulcrom based protocol contract * @param _tokenIn Address of a token to swap from * @param _tokenOut Address of a token to swap to * @param _receiver Address to send swapped tokens to * @return amountOut Amount of tokens received */ function swap(address _tokenIn, address _tokenOut, address _receiver) external returns (uint256); } /** * @title Fulcrom library * @notice Functions to swap tokens on Fulcrom protocol */ library Fulcrom { using SafeERC20 for IERC20; /** * @dev Swaps tokens on a Fulcrom pool contract * @param from Address of a token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details. The `data` field should be empty * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { IERC20(from).safeTransfer(swapData.addr, amountIn); amountOut = IFulcromPool(swapData.addr).swap(from, swapData.to, address(this)); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title Hashflow Router interface */ interface IHashflowRouter { struct RFQTQuote { /// @notice The address of the HashflowPool to trade against. address pool; /** * @notice The external account linked to the HashflowPool. * If the HashflowPool holds funds, this should be address(0). */ address externalAccount; /// @notice The recipient of the quoteToken at the end of the trade. address trader; /** * @notice The account "effectively" making the trade (ultimately receiving the funds). * This is commonly used by aggregators, where a proxy contract (the 'trader') * receives the quoteToken, and the effective trader is the user initiating the call. * * This field DOES NOT influence movement of funds. However, it is used to check against * quote replay. */ address effectiveTrader; /// @notice The token that the trader sells. address baseToken; /// @notice The token that the trader buys. address quoteToken; /** * @notice The amount of baseToken sold in this trade. The exchange rate * is going to be preserved as the quoteTokenAmount / baseTokenAmount ratio. * * Most commonly, effectiveBaseTokenAmount will == baseTokenAmount. */ uint256 effectiveBaseTokenAmount; /// @notice The max amount of baseToken sold. uint256 baseTokenAmount; /// @notice The amount of quoteToken bought when baseTokenAmount is sold. uint256 quoteTokenAmount; /// @notice The Unix timestamp (in seconds) when the quote expires. /// @dev This gets checked against block.timestamp. uint256 quoteExpiry; /// @notice The nonce used by this effectiveTrader. Nonces are used to protect against replay. uint256 nonce; /// @notice Unique identifier for the quote. /// @dev Generated off-chain via a distributed UUID generator. bytes32 txid; /// @notice Signature provided by the market maker (EIP-191). bytes signature; } /** * @notice Executes an intra-chain RFQ-T trade. * @param quote The quote data to be executed. */ function tradeRFQT(RFQTQuote memory quote) external payable; } // @title Hashflow library // @notice Functions to swap tokens on Hashflow protocol library Hashflow { using SafeERC20 for IERC20; /** * @dev Swaps tokens on a Hashflow router contract * @param from Address of a token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details. The `data` field should contain encoded RFQTQuote structure * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { IHashflowRouter.RFQTQuote memory quote = abi.decode(swapData.data, (IHashflowRouter.RFQTQuote)); //slither-disable-next-line unused-return //it's safe to ignore IERC20(from).safeIncreaseAllowance(swapData.addr, amountIn); if (amountIn < quote.baseTokenAmount) { quote.effectiveBaseTokenAmount = amountIn; } uint256 balanceBefore = IERC20(swapData.to).balanceOf(address(this)); IHashflowRouter(swapData.addr).tradeRFQT(quote); amountOut = IERC20(swapData.to).balanceOf(address(this)) - balanceBefore; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title Iziswap pool interface */ interface IIziswapPool { /** * @notice Swap tokenX for tokenY, given max amount of tokenX user willing to pay. * @param recipient the address to receive tokenY * @param amount the max amount of tokenX user willing to pay * @param lowPt the lowest point(price) of x/y during swap * @param data any data to be passed through to the callback * @return amountX amount of tokenX acquired * @return amountY amount of tokenY payed */ function swapX2Y( address recipient, uint128 amount, int24 lowPt, bytes calldata data ) external returns (uint256 amountX, uint256 amountY); /** * @notice Swap tokenY for tokenX, given max amount of tokenY user willing to pay. * @param recipient the address to receive tokenX * @param amount the max amount of tokenY user willing to pay * @param highPt the highest point(price) of x/y during swap * @param data any data to be passed through to the callback * @return amountX amount of tokenX payed * @return amountY amount of tokenY acquired */ function swapY2X( address recipient, uint128 amount, int24 highPt, bytes calldata data ) external returns (uint256 amountX, uint256 amountY); } /** * @title Iziswap library * @notice Functions to swap tokens on Iziswap based protocols */ library Iziswap { uint256 constant X2Y = 0; using SafeERC20 for IERC20; /** * @dev Swaps tokens on a Iziswap based protocol contract * @param from Address of token to swap from * @param amountIn Amount of token to swap * @param swapData Swap operation details. The `data` field should contain two int128 values, * which are the indices of the tokens to swap from and to * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { int24 pt = abi.decode(swapData.data, (int24)); //slither-disable-next-line unused-return //it's safe to ignore bytes memory data = abi.encode(from); if (from < swapData.to) { (, amountOut) = IIziswapPool(swapData.addr).swapX2Y(address(this), uint128(amountIn), pt, data); } else { (amountOut, ) = IIziswapPool(swapData.addr).swapY2X(address(this), uint128(amountIn), pt, data); } } function transferTokens(uint256 amount, bytes calldata data) internal { address token = abi.decode(data, (address)); IERC20(token).safeTransfer(msg.sender, amount); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title Level pool interface */ interface ILevelPool { /** * @dev Swaps tokens on a Level based protocol contract * @param _tokenIn Address of a token to swap from * @param _tokenOut Address of a token to swap to * @param _minOut Minimal amount of tokens to receive * @param _to Address to send swapped tokens to * @param extradata Data to be used in callback */ function swap(address _tokenIn, address _tokenOut, uint256 _minOut, address _to, bytes calldata extradata) external; } /** * @title Level library * @notice Functions to swap tokens on Level protocol */ library Level { using SafeERC20 for IERC20; /** * @dev Swaps tokens on a Level pool contract * @param from Address of a token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details. The `data` field should be empty * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { IERC20(from).safeTransfer(swapData.addr, amountIn); uint256 balanceBefore = IERC20(swapData.to).balanceOf(address(this)); ILevelPool(swapData.addr).swap(from, swapData.to, 0, address(this), new bytes(0)); amountOut = IERC20(swapData.to).balanceOf(address(this)) - balanceBefore; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title Maverick V1 pool interface */ interface IMaverickV1Pool { /** * @dev Swaps tokens on a Maverick v1 based pool * @param recipient Address to send swapped tokens to * @param amount Amount of tokens to swap * @param tokenAIn Flag that indicates token direction. True for tokenA to tokenB direction, * false for tokenB to tokenA * @param exactOutput Flag that indicates whether the amount is exact output or input * @param sqrtPriceLimit Price limit within which swap is processed * @param data Additional data to be send in callback function * @return amountIn Amount of the input token to be paid * @return amountOut Amount of the output token to be received */ function swap( address recipient, uint256 amount, bool tokenAIn, bool exactOutput, uint256 sqrtPriceLimit, bytes calldata data ) external returns (uint256 amountIn, uint256 amountOut); /** * @dev Returns the address of the first token of the Maverick v1 based pair * @return Address of the first token of the pair */ function tokenA() external view returns (address); /** * @dev Returns the address of the second token of the Maverick v1 based pair * @return Address of the second token of the pair */ function tokenB() external view returns (address); } /** * @title Maverick v1 library * @notice Functions to swap tokens on Maverick v1 and compatible protocol */ library MaverickV1 { using SafeERC20 for IERC20; /** * @dev Swaps tokens on a Maverick v1 based pair * @param amountIn Amount of tokens to swap * @param swapData Swap data. The `data` field should contain zeroForOne flag * @return amountOut Amount of tokens received */ function swap(uint256 amountIn, IWowmaxRouter.Swap memory swapData) internal returns (uint256 amountOut) { bool tokenAIn = abi.decode(swapData.data, (bool)); (, amountOut) = IMaverickV1Pool(swapData.addr).swap(address(this), amountIn, tokenAIn, false, 0, swapData.data); } /** * @dev Performs Maverick v1 callback, sends required amounts of tokens to the pool * @param amountToPay amount to pay * @param _data encoded swap direction */ function invokeCallback(uint256 amountToPay, uint256 /*amountOut*/, bytes calldata _data) internal { bool tokenAIn = abi.decode(_data, (bool)); if (tokenAIn) { IERC20(IMaverickV1Pool(msg.sender).tokenA()).safeTransfer(msg.sender, amountToPay); } else { IERC20(IMaverickV1Pool(msg.sender).tokenB()).safeTransfer(msg.sender, amountToPay); } } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title PancakeSwap pool interface */ interface IPancakeStablePool { /** * @notice Exchange `dx` amount of `i` token to at least `min_dy` amount of `j` token * @dev Same as Curve but uses uint256 instead of int128 * @param i Index of token to swap from * @param j Index of token to swap to * @param dx Amount of `i` token to swap from * @param min_dy Minimum amount of `j` token to receive */ function exchange(uint256 i, uint256 j, uint256 dx, uint256 min_dy) external; } /** * @title PancakeSwap library * @notice Functions to swap tokens on PancakeSwap like protocols */ library PancakeSwapStable { using SafeERC20 for IERC20; /** * @notice Swaps tokens on a PancakeSwap Stable like protocol contract * @param from Address of token to swap from * @param amountIn Amount of token to swap * @param swapData Swap operation details. The `data` field should contain two int128 values, * which are the indices of the tokens to swap from and to * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { (int128 i, int128 j) = abi.decode(swapData.data, (int128, int128)); uint256 balanceBefore = IERC20(swapData.to).balanceOf(address(this)); //slither-disable-next-line unused-return //it's safe to ignore IERC20(from).safeIncreaseAllowance(swapData.addr, amountIn); IPancakeStablePool(swapData.addr).exchange(uint256(uint128(i)), uint256(uint128(j)), amountIn, 0); amountOut = IERC20(swapData.to).balanceOf(address(this)) - balanceBefore; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title Saddle pool interface */ interface ISaddlePool { /** * @dev Swaps tokens on a Saddle based protocol contract * @param tokenIndexFrom Index of a token to swap from * @param tokenIndexTo Index of a token to swap to * @param dx Amount of tokens to swap * @param minDy Minimum amount of tokens to receive * @param deadline Timestamp after which transaction will revert */ function swap(uint8 tokenIndexFrom, uint8 tokenIndexTo, uint256 dx, uint256 minDy, uint256 deadline) external; } /** * @title Saddle library * @notice Functions to swap tokens on Saddle protocol */ library Saddle { using SafeERC20 for IERC20; /** * @dev Swaps tokens on a Saddle pool contract * @param from Address of a token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details. The `data` field should contain two uint8 values, * which are tokenIndexFrom and tokenIndexTo * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { (uint8 tokenIndexFrom, uint8 tokenIndexTo) = abi.decode(swapData.data, (uint8, uint8)); uint256 balanceBefore = IERC20(swapData.to).balanceOf(address(this)); //slither-disable-next-line unused-return //it's safe to ignore IERC20(from).safeIncreaseAllowance(swapData.addr, amountIn); ISaddlePool(swapData.addr).swap(tokenIndexFrom, tokenIndexTo, amountIn, 0, type(uint256).max); amountOut = IERC20(swapData.to).balanceOf(address(this)) - balanceBefore; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title SyncSwap pool interface */ interface ISyncSwapPool { /** * @dev Token amount structure * @param token Address of a token * @param amount Amount of tokens */ struct TokenAmount { address token; uint amount; } /** * @dev Swaps between tokens. * @param data Swap operation details * @param sender Address of the sender * @param callback Callback address * @param callbackData Callback data * @return tokenAmount Amount of tokens received */ function swap( bytes calldata data, address sender, address callback, bytes calldata callbackData ) external returns (TokenAmount memory tokenAmount); /** * @dev Returns the address of the SyncSwap pool vault * @return Vault address */ function vault() external view returns (address); } /** * @title SyncSwap vault interface */ interface ISyncSwapVault { /** * @dev Deposits tokens to the SyncSwap vault * @param token Address of a token to deposit * @param to SyncSwap pool address * @return amount Amount of tokens deposited */ function deposit(address token, address to) external payable returns (uint amount); } /** * @title SyncSwap library * @notice Functions to swap tokens on SyncSwap protocol */ library SyncSwap { using SafeERC20 for IERC20; /** * @dev Swaps tokens on a SyncSwap pool contract * @param from Address of a token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details. The `data` field should be empty * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { ISyncSwapVault vault = ISyncSwapVault(ISyncSwapPool(swapData.addr).vault()); IERC20(from).safeTransfer(address(vault), amountIn); vault.deposit(from, swapData.addr); bytes memory data = abi.encode(from, address(this), uint8(2)); // from, to, withdrawMode (0 - default, 1 - unwrapped, 2 - wrapped) ISyncSwapPool.TokenAmount memory out = ISyncSwapPool(swapData.addr).swap( data, address(0x0), address(0x0), new bytes(0) ); return out.amount; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title Uniswap v2 pair interface */ interface IUniswapV2Pair { /** * @dev Returns the address of the first token of the Uniswap v2 based pair * @return Address of the first token of the pair */ function token0() external view returns (address); /** * @dev Returns the address of the second token of the Uniswap v2 based pair * @return Address of the second token of the pair */ function token1() external view returns (address); /** * @dev Returns the Uniswap v2 based pair reserves * @return _reserve0 Reserve of the first token in the pair * @return _reserve1 Reserve of the second token in the pair * @return _blockTimestampLast Block timestamp of the last reserve update */ function getReserves() external view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast); /** * @dev Swaps tokens on a Uniswap v2 based pair * @param amount0Out Amount of the first token to receive * @param amount1Out Amount of the second token to receive * @param to Address to send tokens to * @param data Data to be send in callback function, if any */ function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; /** * @dev Returns the address of the Uniswap v2 based pair router * @return Router address */ function router() external returns (address); } /** * @title Uniswap v2 router interface */ interface IUniswapV2Router { /** * @dev Swaps tokens on a Uniswap v2 based router * @param amountIn Amount of tokens to swap * @param amountOutMin Minimal amount of tokens to receive * @param path Sequence of tokens to perform swap through * @param to Address to send swapped tokens to * @param deadline Timestamp after which the transaction will revert, * 0 if it is not defined * @return amounts Amounts of tokens received for each swap step */ function swapExactTokensForTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external returns (uint256[] memory amounts); } /** * @title Uniswap v2 library * @notice Functions to swap tokens on Uniswap v2 and compatible protocols */ library UniswapV2 { /** * @dev Common fee denominator */ uint256 private constant FEE_DENOMINATOR = 10000; using SafeERC20 for IERC20; /** * @dev Performs a direct swap through a Uniswap v2 based pair * @param from Address of a token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details. The `data` field should contain the fee value specific for the pair * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { IERC20(from).safeTransfer(swapData.addr, amountIn); uint256 fee = abi.decode(swapData.data, (uint256)); bool directSwap = IUniswapV2Pair(swapData.addr).token0() == from; (uint112 reserveIn, uint112 reserveOut) = getReserves(swapData.addr, directSwap); amountOut = getAmountOut(amountIn, reserveIn, reserveOut, fee); if (amountOut > 0) { IUniswapV2Pair(swapData.addr).swap( directSwap ? 0 : amountOut, directSwap ? amountOut : 0, address(this), new bytes(0) ); } } /** * @dev Performs a swap through a Uniswap v2 based protocol using a router contract * @param from Address of a token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details * data field should be empty * @return amountOut Amount of tokens received */ function routerSwap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { IUniswapV2Router router = IUniswapV2Router(IUniswapV2Pair(swapData.addr).router()); IERC20(from).safeIncreaseAllowance(address(router), amountIn); address[] memory path = new address[](2); path[0] = from; path[1] = swapData.to; return router.swapExactTokensForTokens(amountIn, 0, path, address(this), type(uint256).max)[1]; } /** * @dev Returns the reserves of a Uniswap v2 based pair ordered according to swap direction * @param pair Address of a Uniswap v2 based pair * @param directSwap True if the first token of the pair is the token to swap from, false otherwise * @return reserveIn Reserve of the token to swap from * @return reserveOut Reserve of the token to swap to */ function getReserves(address pair, bool directSwap) private view returns (uint112 reserveIn, uint112 reserveOut) { (uint112 reserve0, uint112 reserve1, ) = IUniswapV2Pair(pair).getReserves(); return directSwap ? (reserve0, reserve1) : (reserve1, reserve0); } /** * @dev Returns the amount of tokens to be received for a given input amount and pair reserves * @param amountIn Amount of tokens to swap * @param reserveIn Reserve of the token to swap from * @param reserveOut Reserve of the token to swap to * @param fee Fee of the Uniswap v2 based pair. This value is specific for the pair * and/or it's DEX, and should be provided externally * @return amountOut Amount of tokens received */ function getAmountOut( uint256 amountIn, uint112 reserveIn, uint112 reserveOut, uint256 fee ) private pure returns (uint256 amountOut) { uint256 amountInWithFee = amountIn * (FEE_DENOMINATOR - fee); uint256 numerator = amountInWithFee * reserveOut; uint256 denominator = reserveIn * FEE_DENOMINATOR + amountInWithFee; amountOut = numerator / denominator; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title Uniswap v2 pair interface */ interface IUniswapV3Pool { /** * @dev Swaps tokens on a Uniswap v3 based pair * @param recipient Address to send swapped tokens to * @param zeroForOne Flag that indicates token direction. True for token0 to token1 direction, * false for token1 to token0 * @param amountSpecified Amount of tokens to swap * @param sqrtPriceLimitX96 Price limit within which swap is processed * @param data Additional data to be send in callback function * @return amount0 Amount of the first token received * @return amount1 Amount of the second token received */ function swap( address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes calldata data ) external returns (int256 amount0, int256 amount1); /** * @dev Returns the address of the first token of the Uniswap v3 based pair * @return Address of the first token of the pair */ function token0() external view returns (address); /** * @dev Returns the address of the second token of the Uniswap v3 based pair * @return Address of the second token of the pair */ function token1() external view returns (address); } /** * @title Uniswap v3 library * @notice Functions to swap tokens on Uniswap v3 and compatible protocol */ library UniswapV3 { using SafeERC20 for IERC20; /** * @dev Swaps tokens on a Uniswap v3 based pair * @param amountIn Amount of tokens to swap * @param swapData Swap data. The `data` field should contain zeroForOne flag * @return amountOut Amount of tokens received */ function swap(uint256 amountIn, IWowmaxRouter.Swap memory swapData) internal returns (uint256 amountOut) { bool zeroForOne = abi.decode(swapData.data, (bool)); uint160 sqrtPriceLimitX96 = zeroForOne ? 4295128740 : 1461446703485210103287273052203988822378723970341; (int256 amount0, int256 amount1) = IUniswapV3Pool(swapData.addr).swap( address(this), zeroForOne, int256(amountIn), sqrtPriceLimitX96, new bytes(0) ); amountOut = uint(zeroForOne ? -amount1 : -amount0); } /** * @dev Performs Uniswap v3 callback, sends required amounts of tokens to the pair * @param amount0Delta Amount of the first token to send * @param amount1Delta Amount of the second token to send */ function invokeCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata /*_data*/) internal { if (amount0Delta > 0 && amount1Delta < 0) { IERC20(IUniswapV3Pool(msg.sender).token0()).safeTransfer(msg.sender, uint256(amount0Delta)); } else if (amount0Delta < 0 && amount1Delta > 0) { IERC20(IUniswapV3Pool(msg.sender).token1()).safeTransfer(msg.sender, uint256(amount1Delta)); } else { revert("WOWMAX: Uniswap v3 invariant violation"); } } /** * @notice Try to decode provided "dataWithSelector" as Uniswap V3 callback. * @return Flag indicating whether decoding succeeded, followed by decoded amount0Delta, amount1Delta and data. */ function decodeCallback( bytes calldata dataWithSelector ) internal pure returns (bool, int256, int256, bytes calldata) { int256 amount0Delta; int256 amount1Delta; bytes calldata data; assembly { amount0Delta := calldataload(add(dataWithSelector.offset, 4)) amount1Delta := calldataload(add(dataWithSelector.offset, 36)) // get offset of bytes length: selector + (amount0Delta | amount1Delta | data length offset | data length | data). // "length offset" is relative to start of first parameter in data. let dataLenOffset := add(add(dataWithSelector.offset, 4), calldataload(add(dataWithSelector.offset, 68))) data.length := calldataload(dataLenOffset) data.offset := add(dataLenOffset, 32) } // validate that what we got matches what we expect unchecked { // account for padding in 32-byte word unaligned data uint256 paddedDataLen = data.length; uint256 remainder = data.length % 32; if (remainder > 0) { paddedDataLen = paddedDataLen + (32 - remainder); } // 132 = 4 (selector) + 64 ("sender", "amount0Delta", "amount1Delta" offsets) + 64 ("length offset" + "length" offsets) if (dataWithSelector.length != (paddedDataLen + 132)) { return (false, 0, 0, emptyBytesCalldata()); } } return (true, amount0Delta, amount1Delta, data); } function emptyBytesCalldata() private pure returns (bytes calldata) { bytes calldata empty; assembly { empty.length := 0 empty.offset := 0 } return empty; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; import "../interfaces/IWETH.sol"; /** * @title Velocore vault interface */ interface IVelocoreVault { /** * @dev Swaps tokens on a Velocore based protocol * @param pool Address of a Velocore pool contract * @param method Swap method * @param t1 Address of a token to swap from * @param m1 Swap method for the first token * @param a1 Amount of the first token to swap * @param t2 Address of a token to swap to * @param m2 Swap method for the second token * @param a2 Amount of the second token to swap * @param data Additional data to be used in swap * @return amounts Amounts of tokens received */ function execute2( address pool, uint8 method, address t1, uint8 m1, int128 a1, address t2, uint8 m2, int128 a2, bytes memory data ) external payable returns (int128[] memory); function getPair(address tokenA, address tokenB) external view returns (address); } /** * @title Velocore library * @notice Functions to swap tokens on Velocore protocol */ library VelocoreV2 { uint8 constant SWAP = 0; uint8 constant EXACTLY = 0; uint8 constant AT_MOST = 1; address constant NATIVE_TOKEN = address(0x0); using SafeERC20 for IERC20; /** * @dev Swaps tokens on a Velocore pool contract * @param wrappedNativeToken Address of a wrapped native token * @param from Address of a token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details. The `data` field should contain vault address * @return amountOut Amount of tokens received */ function swap( address wrappedNativeToken, address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { address vaultAddress = abi.decode(swapData.data, (address)); IVelocoreVault vault = IVelocoreVault(vaultAddress); address fromToken = from == wrappedNativeToken ? NATIVE_TOKEN : from; address toToken = swapData.to == wrappedNativeToken ? NATIVE_TOKEN : swapData.to; int128[] memory result; if (fromToken == NATIVE_TOKEN) { IWETH(wrappedNativeToken).withdraw(amountIn); result = vault.execute2{ value: amountIn }( swapData.addr, SWAP, fromToken, EXACTLY, int128(int256(amountIn)), toToken, AT_MOST, 0, "" ); } else { IERC20(fromToken).safeIncreaseAllowance(address(vault), amountIn); result = vault.execute2( swapData.addr, SWAP, fromToken, EXACTLY, int128(int256(amountIn)), toToken, AT_MOST, 0, "" ); } amountOut = uint256(int256(result[1])); if (toToken == NATIVE_TOKEN) { IWETH(wrappedNativeToken).deposit{ value: amountOut }(); } } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title Velodrome pair interface */ interface IVelodromePair { /** * @dev Returns the Velodrome based pair amount out * @param amountIn Amount to swap * @param from Address of the token to swap from * @return Amount of tokens to receive */ function getAmountOut(uint256 amountIn, address from) external view returns (uint256); /** * @dev Swaps tokens on a Velodrome based pair * @param amount0Out Amount of the first token to receive * @param amount1Out Amount of the second token to receive * @param to Address to send tokens to * @param data Data to be send in callback function, if any */ function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; } /** * @title Velodrome library * @notice Functions to swap tokens on Velodrome and compatible protocols */ library Velodrome { using SafeERC20 for IERC20; /** * @dev Performs a swap through a Velodrome based pair * @param from Address of a token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details. The `data` field should contain from token index * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { uint256 fromIndex = abi.decode(swapData.data, (uint256)); amountOut = IVelodromePair(swapData.addr).getAmountOut(amountIn, from); if (amountOut > 0) { IERC20(from).safeTransfer(swapData.addr, amountIn); IVelodromePair(swapData.addr).swap( fromIndex == 0 ? 0 : amountOut, fromIndex == 0 ? amountOut : 0, address(this), new bytes(0) ); } } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title Vooi pool interface */ interface IVooiPool { /** * @notice Swap fromToken for toToken, ensures deadline and minimumToAmount and sends quoted amount to `to` address * @dev This function assumes tax free token. * @param _fromID The token being inserted into Pool by user for swap * @param _toID The token wanted by user, leaving the Pool * @param _fromAmount The amount of from token inserted * @param _minToAmount The minimum amount that will be accepted by user as result * @param _to The user receiving the result of swap * @param _deadline The deadline to be respected */ function swap( uint256 _fromID, uint256 _toID, uint256 _fromAmount, uint256 _minToAmount, address _to, uint256 _deadline ) external returns (uint256 actualToAmount, uint256 lpFeeAmount); } /** * @title Vooi library * @notice Functions to swap tokens on Vooi protocol */ library Vooi { using SafeERC20 for IERC20; /** * @dev Swaps tokens on a Vooi pool contract * @param from Address of a token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details. The `data` field should be empty * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { (uint8 fromID, uint8 toID) = abi.decode(swapData.data, (uint8, uint8)); IERC20(from).safeIncreaseAllowance(swapData.addr, amountIn); (amountOut, ) = IVooiPool(swapData.addr).swap(fromID, toID, amountIn, 0, address(this), type(uint256).max); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title Wombat pool interface */ interface IWombatPool { /** * @dev Swaps tokens on a Wombat based protocol contract * @param fromToken Address of a token to swap from * @param toToken Address of a token to swap to * @param fromAmount Amount of tokens to swap * @param minimumToAmount Minimal amount of tokens to receive * @param to Address to send swapped tokens to * @param deadline Timestamp after which the transaction will revert * @return actualToAmount Actual amount of tokens received * @return haircut Amount of tokens taken as fee */ function swap( address fromToken, address toToken, uint256 fromAmount, uint256 minimumToAmount, address to, uint256 deadline ) external returns (uint256 actualToAmount, uint256 haircut); } /** * @title Wombat library * @notice Functions to swap tokens on Wombat protocol */ library Wombat { using SafeERC20 for IERC20; /** * @dev Swaps tokens on a Wombat pool contract * @param from Address of a token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details. The `data` field should be empty * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { IERC20(from).safeIncreaseAllowance(swapData.addr, amountIn); (amountOut, ) = IWombatPool(swapData.addr).swap( from, swapData.to, amountIn, 0, address(this), type(uint256).max ); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; /** * @title WooFi pool interface */ interface IWooFiPool { /** * @dev Swaps tokens on a WooFi based protocol contract * @param fromToken Address of a token to swap from * @param toToken Address of a token to swap to * @param fromAmount Amount of tokens to swap * @param minToAmount Minimal amount of tokens to receive * @param to Address to send swapped tokens to * @param rebateTo The rebate address (optional, can be address ZERO) * @return realToAmount Amount of tokens received */ function swap( address fromToken, address toToken, uint256 fromAmount, uint256 minToAmount, address to, address rebateTo ) external returns (uint256 realToAmount); } /** * @title WooFi library * @notice Functions to swap tokens on WooFi protocol */ library WooFi { using SafeERC20 for IERC20; /** * @dev Swaps tokens on a WooFi pool contract * @param from Address of a token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details. The `data` field should be empty * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { IERC20(from).safeTransfer(swapData.addr, amountIn); amountOut = IWooFiPool(swapData.addr).swap(from, swapData.to, amountIn, 0, address(this), address(0x0)); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IWowmaxRouter.sol"; import "../interfaces/IWETH.sol"; /** * @title WETH library * @notice Functions to swap tokens on WETH contract */ library WrappedNative { using SafeERC20 for IERC20; /** * @dev Swaps tokens on a WETH contract * @param from Address of a token to swap from * @param amountIn Amount of tokens to swap * @param swapData Swap operation details. The `data` field should be empty * @return amountOut Amount of tokens received */ function swap( address from, uint256 amountIn, IWowmaxRouter.Swap memory swapData ) internal returns (uint256 amountOut) { if (from == swapData.addr) { IWETH(swapData.addr).withdraw(amountIn); } else { IWETH(swapData.addr).deposit{ value: amountIn }(); } amountOut = amountIn; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity =0.8.7; import "./interfaces/IWETH.sol"; import "./interfaces/IWowmaxRouter.sol"; import "./libraries/UniswapV2.sol"; import "./libraries/UniswapV3.sol"; import "./libraries/Curve.sol"; import "./libraries/PancakeSwapStable.sol"; import "./libraries/DODOV2.sol"; import "./libraries/DODOV1.sol"; import "./libraries/DODOV3.sol"; import "./libraries/Hashflow.sol"; import "./libraries/Saddle.sol"; import "./libraries/Wombat.sol"; import "./libraries/Level.sol"; import "./libraries/Fulcrom.sol"; import "./libraries/WooFi.sol"; import "./libraries/Elastic.sol"; import "./libraries/AlgebraV1.sol"; import "./libraries/SyncSwap.sol"; import "./libraries/Vooi.sol"; import "./libraries/VelocoreV2.sol"; import "./libraries/Iziswap.sol"; import "./libraries/Velodrome.sol"; import "./libraries/BalancerV2.sol"; import "./libraries/MaverickV1.sol"; import "./libraries/WrappedNative.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; import "./WowmaxSwapReentrancyGuard.sol"; /** * @title WOWMAX Router * @notice Router for stateless execution of swaps against multiple DEX protocols. * * The WowmaxRouter contract encompasses three primary responsibilities: * 1. Facilitating the exchange of user tokens based on a provided exchange route. * 2. Ensuring validation of the received output amounts for users, guaranteeing their alignment * within the designated slippage range. * 3. Transferring any surplus amounts to the treasury, thereby functioning as a service fee. * * The WowmaxRouter contract does not hold any tokens between swap operations. Tokens should not be transferred directly * to the contract. If, by any chance, tokens are transferred directly to the contract, they are most likely to be lost. */ contract WowmaxRouter is IWowmaxRouter, Ownable, WowmaxSwapReentrancyGuard { /** * @dev WETH contract */ IWETH public WETH; /** * @dev Treasury address */ address public treasury; /** * @dev Max fee percentage. All contract percentage values have two extra digits for precision. Default value is 1% */ uint256 public maxFeePercentage = 100; /** * @dev Max allowed slippage percentage, default value is 20% */ uint256 public maxSlippage = 2000; // Mapping of protocol names bytes32 internal constant UNISWAP_V2 = "UNISWAP_V2"; bytes32 internal constant UNISWAP_V3 = "UNISWAP_V3"; bytes32 internal constant UNISWAP_V2_ROUTER = "UNISWAP_V2_ROUTER"; bytes32 internal constant CURVE = "CURVE"; bytes32 internal constant DODO_V1 = "DODO_V1"; bytes32 internal constant DODO_V2 = "DODO_V2"; bytes32 internal constant DODO_V3 = "DODO_V3"; bytes32 internal constant HASHFLOW = "HASHFLOW"; bytes32 internal constant PANCAKESWAP_STABLE = "PANCAKESWAP_STABLE"; bytes32 internal constant SADDLE = "SADDLE"; bytes32 internal constant WOMBAT = "WOMBAT"; bytes32 internal constant LEVEL = "LEVEL"; bytes32 internal constant FULCROM = "FULCROM"; bytes32 internal constant WOOFI = "WOOFI"; bytes32 internal constant ELASTIC = "ELASTIC"; bytes32 internal constant ALGEBRA_V1 = "ALGEBRA_V1"; bytes32 internal constant ALGEBRA_V1_9 = "ALGEBRA_V1_9"; bytes32 internal constant SYNCSWAP = "SYNCSWAP"; bytes32 internal constant VOOI = "VOOI"; bytes32 internal constant VELOCORE_V2 = "VELOCORE_V2"; bytes32 internal constant IZISWAP = "IZISWAP"; bytes32 internal constant VELODROME = "VELODROME"; bytes32 internal constant BALANCER_V2 = "BALANCER_V2"; bytes32 internal constant MAVERICK_V1 = "MAVERICK_V1"; bytes32 internal constant WRAPPED_NATIVE = "WRAPPED_NATIVE"; using SafeERC20 for IERC20; /** * @dev sets the WETH and treasury addresses */ constructor(address _weth, address _treasury) { require(_weth != address(0), "WOWMAX: Wrong WETH address"); require(_treasury != address(0), "WOWMAX: Wrong treasury address"); WETH = IWETH(_weth); treasury = _treasury; } /** * @dev fallback function to receive native tokens */ receive() external payable {} /** * @dev fallback function to process various protocols callback functions */ fallback() external onlyDuringSwap { (bool success, int256 amount0Delta, int256 amount1Delta, bytes calldata data) = UniswapV3.decodeCallback({ dataWithSelector: msg.data }); require(success, "WOWMAX: unsupported callback"); UniswapV3.invokeCallback(amount0Delta, amount1Delta, data); } // Admin functions /** * @dev withdraws tokens from a contract, in case of leftovers after a swap, invalid swap requests, * or direct transfers. Only callable by the owner. * @param token Token to be withdrawn * @param amount Amount to be withdrawn */ function withdraw(address token, uint256 amount) external onlyOwner { IERC20(token).safeTransfer(treasury, amount); } /** * @dev withdraws native tokens from a contract, in case of leftovers after a swap or invalid swap requests. * Only callable by the owner. * @param amount Amount to be withdrawn */ function withdrawETH(uint256 amount) external onlyOwner { (bool sent, ) = payable(treasury).call{ value: amount }(""); require(sent, "Wowmax: Failed to send native tokens"); } /** * @dev sets the max fee percentage. Only callable by the owner. * @param _maxFeePercentage Max fee percentage */ function setMaxFeePercentage(uint256 _maxFeePercentage) external onlyOwner { maxFeePercentage = _maxFeePercentage; } /** * @dev sets the max allowed slippage. Only callable by the owner. * @param _maxSlippage Max allowed slippage percentage */ function setMaxSlippage(uint256 _maxSlippage) external onlyOwner { maxSlippage = _maxSlippage; } // Callbacks /** * @dev callback for Maverick V1 pools. Not allowed to be executed outside of a swap operation * @param amountToPay Amount to be paid * @param amountOut Amount to be received * @param data Additional data to be passed to the callback function */ function swapCallback(uint256 amountToPay, uint256 amountOut, bytes calldata data) external onlyDuringSwap { MaverickV1.invokeCallback(amountToPay, amountOut, data); } /** * @dev callback for Algebra V1 pairs. Not allowed to be executed outside of a swap operation * @param amount0Delta Amount of token0 to be transferred to the caller * @param amount1Delta Amount of token1 to be transferred to the caller * @param data Additional data to be passed to the callback function */ function algebraSwapCallback( int256 amount0Delta, int256 amount1Delta, bytes calldata data ) external onlyDuringSwap { AlgebraV1.invokeCallback(amount0Delta, amount1Delta, data); } /** * @notice Called to msg.sender in iZiSwapPool#swapX2Y(DesireY) call * @param x Amount of tokenX trader will pay * @param data Any dadta passed though by the msg.sender via the iZiSwapPool#swapX2Y(DesireY) call */ function swapX2YCallback(uint256 x, uint256 /*y*/, bytes calldata data) external onlyDuringSwap { Iziswap.transferTokens(x, data); } /** * @notice Called to msg.sender in iZiSwapPool#swapY2X(DesireX) call * @param y Amount of tokenY trader will pay * @param data Any dadta passed though by the msg.sender via the iZiSwapPool#swapY2X(DesireX) call */ function swapY2XCallback(uint256 /*x*/, uint256 y, bytes calldata data) external onlyDuringSwap { Iziswap.transferTokens(y, data); } /** * @notice Callback for DODO v3 Pools * @param token Token to be transferred to the caller * @param value Amount of tokens to be transferred to the caller * @param data Additional data to be passed to the callback function */ function d3MMSwapCallBack(address token, uint256 value, bytes calldata data) external { DODOV3.invokeCallback(token, value, data); } // Swap functions /** * @inheritdoc IWowmaxRouter */ function swap( ExchangeRequest calldata request ) external payable virtual override reentrancyProtectedSwap returns (uint256[] memory amountsOut) { amountsOut = _swap(request); } /** * @dev swap inner logic */ function _swap(ExchangeRequest calldata request) internal returns (uint256[] memory amountsOut) { checkRequest(request); uint256 amountIn = receiveTokens(request); for (uint256 i = 0; i < request.exchangeRoutes.length; i++) { exchange(request.exchangeRoutes[i]); } amountsOut = sendTokens(request); emit SwapExecuted( msg.sender, request.from == address(0) ? address(WETH) : request.from, amountIn, request.to, amountsOut ); } /** * @dev receives tokens from the caller * @param request Exchange request that contains the token to be received parameters. */ function receiveTokens(ExchangeRequest calldata request) private returns (uint256) { uint256 amountIn; if (msg.value > 0 && request.from == address(0) && request.amountIn == 0) { amountIn = msg.value; WETH.deposit{ value: amountIn }(); } else { if (request.amountIn > 0) { amountIn = request.amountIn; IERC20(request.from).safeTransferFrom(msg.sender, address(this), amountIn); } } return amountIn; } /** * @dev sends swapped received tokens to the caller and treasury * @param request Exchange request that contains output tokens parameters */ function sendTokens(ExchangeRequest calldata request) private returns (uint256[] memory amountsOut) { amountsOut = new uint256[](request.to.length); uint256 amountOut; IERC20 token; for (uint256 i = 0; i < request.to.length; i++) { token = IERC20(request.to[i]); amountOut = token.balanceOf(address(this)); uint256 feeAmount; if (amountOut > request.amountOutExpected[i]) { feeAmount = amountOut - request.amountOutExpected[i]; uint256 maxFeeAmount = (amountOut * maxFeePercentage) / 10000; if (feeAmount > maxFeeAmount) { feeAmount = maxFeeAmount; amountsOut[i] = amountOut - feeAmount; } else { amountsOut[i] = request.amountOutExpected[i]; } } else { require( amountOut >= (request.amountOutExpected[i] * (10000 - request.slippage[i])) / 10000, "WOWMAX: Insufficient output amount" ); amountsOut[i] = amountOut; } if (address(token) == address(WETH)) { WETH.withdraw(amountOut); } transfer(token, treasury, feeAmount); transfer(token, msg.sender, amountsOut[i]); } } /** * @dev transfers token to the recipient * @param token Token to be transferred * @param to Recipient address * @param amount Amount to be transferred */ function transfer(IERC20 token, address to, uint256 amount) private { //slither-disable-next-line incorrect-equality if (amount == 0) { return; } if (address(token) == address(WETH)) { //slither-disable-next-line arbitrary-send-eth //recipient is either a msg.sender or a treasury (bool sent, ) = payable(to).call{ value: amount }(""); require(sent, "Wowmax: Failed to send native tokens"); } else { token.safeTransfer(to, amount); } } /** * @dev executes an exchange operation according to the provided route * @param exchangeRoute Route to be executed */ function exchange(ExchangeRoute calldata exchangeRoute) private returns (uint256) { uint256 amountIn = IERC20(exchangeRoute.from).balanceOf(address(this)); uint256 amountOut; for (uint256 i = 0; i < exchangeRoute.swaps.length; i++) { amountOut += executeSwap( exchangeRoute.from, (amountIn * exchangeRoute.swaps[i].part) / exchangeRoute.parts, exchangeRoute.swaps[i] ); } return amountOut; } /** * @dev executes a swap operation according to the provided parameters * @param from Token to be swapped * @param amountIn Amount to be swapped * @param swapData Swap data that contains the swap parameters */ function executeSwap(address from, uint256 amountIn, Swap calldata swapData) private returns (uint256) { if (swapData.family == UNISWAP_V3) { return UniswapV3.swap(amountIn, swapData); } else if (swapData.family == HASHFLOW) { return Hashflow.swap(from, amountIn, swapData); } else if (swapData.family == WOMBAT) { return Wombat.swap(from, amountIn, swapData); } else if (swapData.family == LEVEL) { return Level.swap(from, amountIn, swapData); } else if (swapData.family == DODO_V2) { return DODOV2.swap(from, amountIn, swapData); } else if (swapData.family == DODO_V3) { return DODOV3.swap(from, amountIn, swapData); } else if (swapData.family == WOOFI) { return WooFi.swap(from, amountIn, swapData); } else if (swapData.family == UNISWAP_V2) { return UniswapV2.swap(from, amountIn, swapData); } else if (swapData.family == CURVE) { return Curve.swap(from, amountIn, swapData); } else if (swapData.family == PANCAKESWAP_STABLE) { return PancakeSwapStable.swap(from, amountIn, swapData); } else if (swapData.family == DODO_V1) { return DODOV1.swap(from, amountIn, swapData); } else if (swapData.family == BALANCER_V2) { return BalancerV2.swap(from, amountIn, swapData); } else if (swapData.family == MAVERICK_V1) { return MaverickV1.swap(amountIn, swapData); } else if (swapData.family == SADDLE) { return Saddle.swap(from, amountIn, swapData); } else if (swapData.family == FULCROM) { return Fulcrom.swap(from, amountIn, swapData); } else if (swapData.family == UNISWAP_V2_ROUTER) { return UniswapV2.routerSwap(from, amountIn, swapData); } else if (swapData.family == ELASTIC) { return Elastic.swap(from, amountIn, swapData); } else if (swapData.family == ALGEBRA_V1) { return AlgebraV1.swap(from, amountIn, swapData); } else if (swapData.family == ALGEBRA_V1_9) { return AlgebraV1.swap(from, amountIn, swapData); } else if (swapData.family == SYNCSWAP) { return SyncSwap.swap(from, amountIn, swapData); } else if (swapData.family == VOOI) { return Vooi.swap(from, amountIn, swapData); } else if (swapData.family == VELOCORE_V2) { return VelocoreV2.swap(address(WETH), from, amountIn, swapData); } else if (swapData.family == IZISWAP) { return Iziswap.swap(from, amountIn, swapData); } else if (swapData.family == VELODROME) { return Velodrome.swap(from, amountIn, swapData); } else if (swapData.family == WRAPPED_NATIVE) { return WrappedNative.swap(from, amountIn, swapData); } else { revert("WOWMAX: Unknown DEX family"); } } // Checks and verifications /** * @dev checks the swap request parameters * @param request Exchange request to be checked */ function checkRequest(ExchangeRequest calldata request) private view { require(request.to.length > 0, "WOWMAX: No output tokens specified"); require(request.to.length == request.amountOutExpected.length, "WOWMAX: Wrong amountOutExpected length"); require(request.to.length == request.slippage.length, "WOWMAX: Wrong slippage length"); for (uint256 i = 0; i < request.to.length; i++) { require(request.to[i] != address(0), "WOWMAX: Wrong output token address"); require(request.amountOutExpected[i] > 0, "WOWMAX: Wrong amountOutExpected value"); require(request.slippage[i] <= maxSlippage, "WOWMAX: Slippage is too high"); } } }
// SPDX-License-Identifier: MIT pragma solidity =0.8.7; /** * @dev Contract module that helps prevent reentrant swaps. Based on OpenZeppelin Contracts (last updated v4.8.0) * (security/ReentrancyGuard.sol) */ abstract contract WowmaxSwapReentrancyGuard { uint256 private constant _SWAP_IN_PROGRESS = 1; uint256 private constant _SWAP_NOT_IN_PROGRESS = 2; uint256 private _swapStatus; /** * @dev Prevents a contract from calling swap function again from within swap */ modifier reentrancyProtectedSwap() { _beforeSwap(); _; _afterSwap(); } /** * @dev Prevents operation from being called outside of swap */ modifier onlyDuringSwap() { require(_swapStatus == _SWAP_IN_PROGRESS, "WOWMAX: not allowed outside of swap"); _; } constructor() { _swapStatus = _SWAP_NOT_IN_PROGRESS; } /** * @dev checks if swap is in progress and prevents reentrant calls */ function _beforeSwap() private { require(_swapStatus != _SWAP_IN_PROGRESS, "WOWMAX: reentrant swap not allowed"); _swapStatus = _SWAP_IN_PROGRESS; } /** * @dev sets swap status to not in progress */ function _afterSwap() private { _swapStatus = _SWAP_NOT_IN_PROGRESS; } }
{ "metadata": { "bytecodeHash": "none" }, "optimizer": { "enabled": true, "runs": 800 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_weth","type":"address"},{"internalType":"address","name":"_treasury","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"address[]","name":"to","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"amountOut","type":"uint256[]"}],"name":"SwapExecuted","type":"event"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"contract IWETH","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"eventManager","type":"address"}],"name":"addEvent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"algebraSwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"d3MMSwapCallBack","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxFeePercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSlippage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"eventManager","type":"address"}],"name":"removeEvent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxFeePercentage","type":"uint256"}],"name":"setMaxFeePercentage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxSlippage","type":"uint256"}],"name":"setMaxSlippage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address[]","name":"to","type":"address[]"},{"components":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"parts","type":"uint256"},{"components":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"part","type":"uint256"},{"internalType":"address","name":"addr","type":"address"},{"internalType":"bytes32","name":"family","type":"bytes32"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct IWowmaxRouterBase.Swap[]","name":"swaps","type":"tuple[]"}],"internalType":"struct IWowmaxRouterBase.ExchangeRoute[]","name":"exchangeRoutes","type":"tuple[]"},{"internalType":"uint256[]","name":"slippage","type":"uint256[]"},{"internalType":"uint256[]","name":"amountOutExpected","type":"uint256[]"}],"internalType":"struct IWowmaxRouterBase.ExchangeRequest","name":"request","type":"tuple"}],"name":"swap","outputs":[{"internalType":"uint256[]","name":"amountsOut","type":"uint256[]"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountToPay","type":"uint256"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"swapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address[]","name":"to","type":"address[]"},{"components":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"parts","type":"uint256"},{"components":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"part","type":"uint256"},{"internalType":"address","name":"addr","type":"address"},{"internalType":"bytes32","name":"family","type":"bytes32"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct IWowmaxRouterBase.Swap[]","name":"swaps","type":"tuple[]"}],"internalType":"struct IWowmaxRouterBase.ExchangeRoute[]","name":"exchangeRoutes","type":"tuple[]"},{"internalType":"uint256[]","name":"slippage","type":"uint256[]"},{"internalType":"uint256[]","name":"amountOutExpected","type":"uint256[]"}],"internalType":"struct IWowmaxRouterBase.ExchangeRequest","name":"request","type":"tuple"},{"internalType":"address","name":"referral","type":"address"}],"name":"swapWithReferral","outputs":[{"internalType":"uint256[]","name":"amountsOut","type":"uint256[]"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"swapX2YCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"swapY2XCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000e5d7c2a44ffddf6b295a15c148167daaaf5cf34f000000000000000000000000bd4a0f12293c54e4e8ad221271cf0d395dd60a71
-----Decoded View---------------
Arg [0] : _weth (address): 0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f
Arg [1] : _treasury (address): 0xBD4a0F12293C54e4E8ad221271CF0d395dd60a71
-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000e5d7c2a44ffddf6b295a15c148167daaaf5cf34f
Arg [1] : 000000000000000000000000bd4a0f12293c54e4e8ad221271cf0d395dd60a71
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 31 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
LINEA | 100.00% | $2,716.89 | 0.00601207 | $16.33 |
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.