Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// 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.9.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. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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 (last updated v4.9.4) (token/ERC20/extensions/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.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
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].
     *
     * CAUTION: See Security Considerations above.
     */
    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.9.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.9.3) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/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;

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    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));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    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");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    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");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation 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).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // 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 cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [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://consensys.net/diligence/blog/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.8.0/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 (last updated v4.9.4) (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;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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.
 *
 * ```solidity
 * 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";
import "../interfaces/IWETH.sol";

/**
 * @title Curve Tricrypto pool interface
 */
interface ICurveTricryptoPool {
    /**
     * @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(uint256 i, uint256 j, uint256 dx, uint256 min_dy) external;
}

/**
 * @title Curve Tricrypto library
 * @notice Functions to swap tokens on Curve Tricrypto based protocols
 */
library CurveTricrypto {
    using SafeERC20 for IERC20;

    /**
     * @dev Swaps tokens on a Curve Tricrypto 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 uint128 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) {
        (uint256 i, uint256 j) = abi.decode(swapData.data, (uint256, uint256));
        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);
        ICurveTricryptoPool(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 Liquiditybook V2.1 pool interface
 */
interface ILiquiditybookV2_1Pool {
    /**
     * @notice Swap tokens iterating over the bins until the entire amount is swapped.
     * Token X will be swapped for token Y if `swapForY` is true, and token Y for token X if `swapForY` is false.
     * This function will not transfer the tokens from the caller, it is expected that the tokens have already been
     * transferred to this contract through another contract, most likely the router.
     * That is why this function shouldn't be called directly, but only through one of the swap functions of a router
     * that will also perform safety checks, such as minimum amounts and slippage.
     * The variable fee is updated throughout the swap, it increases with the number of bins crossed.
     * The oracle is updated at the end of the swap.
     * @param swapForY Whether you're swapping token X for token Y (true) or token Y for token X (false)
     * @param to The address to send the tokens to
     * @return amountsOut The encoded amounts of token X and token Y sent to `to`
     */
    function swap(bool swapForY, address to) external returns (bytes32 amountsOut);
}

/**
 * @title Liquiditybook V2.1 library
 * @notice Functions to swap tokens on Liquiditybook V2.1 based protocols
 */
library LiquiditybookV2_1 {
    using SafeERC20 for IERC20;

    /**
     * @dev Swaps tokens on a Liquiditybook V2.1 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 swapForY flag
     * @return amountOut Amount of tokens received
     */
    function swap(
        address from,
        uint256 amountIn,
        IWowmaxRouter.Swap memory swapData
    ) internal returns (uint256 amountOut) {
        bool swapForY = abi.decode(swapData.data, (uint256)) == 1;
        uint256 balanceBefore = IERC20(swapData.to).balanceOf(address(this));
        IERC20(from).safeTransfer(swapData.addr, amountIn);
        ILiquiditybookV2_1Pool(swapData.addr).swap(swapForY, address(this));
        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 Maverick V2 pool interface
 */
interface IMaverickV2Pool {
    /**
     * @notice Parameters for swap.
     * @param amount Amount of the token that is either the input if exactOutput is false
     * or the output if exactOutput is true.
     * @param tokenAIn Boolean indicating whether tokenA is the input.
     * @param exactOutput Boolean indicating whether the amount specified is
     * the exact output amount (true).
     * @param tickLimit The furthest tick a swap will execute in. If no limit
     * is desired, value should be set to type(int32).max for a tokenAIn swap
     * and type(int32).min for a swap where tokenB is the input.
     */
    struct SwapParams {
        uint256 amount;
        bool tokenAIn;
        bool exactOutput;
        int32 tickLimit;
    }

    /**
     * @notice Swap tokenA/tokenB assets in the pool.  The swap user has two
     * options for funding their swap.
     * - The user can push the input token amount to the pool before calling
     * the swap function. In order to avoid having the pool call the callback,
     * the user should pass a zero-length `data` bytes object with the swap
     * call.
     * - The user can send the input token amount to the pool when the pool
     * calls the `maverickV2SwapCallback` function on the calling contract.
     * That callback has input parameters that specify the token address of the
     * input token, the input and output amounts, and the bytes data sent to
     * the swap function.
     * @dev  If the users elects to do a callback-based swap, the output
     * assets will be sent before the callback is called, allowing the user to
     * execute flash swaps.  However, the pool does have reentrancy protection,
     * so a swapper will not be able to interact with the same pool again
     * while they are in the callback function.
     * @param recipient The address to receive the output tokens.
     * @param params Parameters containing the details of the swap
     * @param data Bytes information that gets passed to the callback.
     */
    function swap(
        address recipient,
        SwapParams memory params,
        bytes calldata data
    ) external returns (uint256 amountIn, uint256 amountOut);

    /**
     * @dev Returns the address of the first token of the Maverick V2 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 V2 based pair
     * @return Address of the second token of the pair
     */
    function tokenB() external view returns (address);
}

/**
 * @title Maverick V2 library
 * @notice Functions to swap tokens on Maverick V2 and compatible protocol
 */
library MaverickV2 {
    using SafeERC20 for IERC20;

    /**
     * @dev Swaps tokens on a Maverick V2 based pair
     * @param amountIn Amount of tokens to swap
     * @param swapData Swap data. The `data` field should contain tokenAIn 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));
        int32 tickLimit = tokenAIn ? type(int32).max : type(int32).min;
        IMaverickV2Pool.SwapParams memory params = IMaverickV2Pool.SwapParams({
            amount: amountIn,
            tokenAIn: tokenAIn,
            exactOutput: false,
            tickLimit: tickLimit
        });
        (, amountOut) = IMaverickV2Pool(swapData.addr).swap(address(this), params, swapData.data);
    }

    /**
     * @dev Performs Maverick V2 callback, sends required amounts of tokens to the pool
     * @param tokenIn token to pay
     * @param amountIn amount to pay
     */
    function invokeCallback(address tokenIn, uint256 amountIn) internal {
        IERC20(tokenIn).safeTransfer(msg.sender, amountIn);
    }
}

// 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 Swaap V2 Asset interface
 */
interface ISwaapV2Asset {
    // solhint-disable-previous-line no-empty-blocks
}

/**
 * @title Swaap V2 vault interface
 */
interface ISwaapV2Vault {
    enum SwapKind {
        GIVEN_IN,
        GIVEN_OUT
    }

    struct SingleSwap {
        bytes32 poolId;
        SwapKind kind;
        ISwaapV2Asset assetIn;
        ISwaapV2Asset assetOut;
        uint256 amount;
        bytes userData;
    }

    struct FundManagement {
        address sender;
        bool fromInternalBalance;
        address payable recipient;
        bool toInternalBalance;
    }

    function swap(
        SingleSwap memory singleSwap,
        FundManagement memory funds,
        uint256 limit,
        uint256 deadline
    ) external payable returns (uint256);
}

/**
 * @title Swaap V2 library
 * @notice Functions to swap tokens on Swaap V2 and compatible protocols
 */
library SwaapV2 {
    using SafeERC20 for IERC20;

    /**
     * @dev Performs a swap through a Swaap V2 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 calldata for the swap
     * @return amountOut Amount of tokens received
     */
    function swap(
        address from,
        uint256 amountIn,
        IWowmaxRouter.Swap memory swapData
    ) internal returns (uint256 amountOut) {
        (bytes32 poolId, bytes memory userData) = abi.decode(swapData.data, (bytes32, bytes));

        ISwaapV2Vault.SingleSwap memory singleSwap = ISwaapV2Vault.SingleSwap({
            poolId: poolId,
            kind: ISwaapV2Vault.SwapKind.GIVEN_IN,
            assetIn: ISwaapV2Asset(from),
            assetOut: ISwaapV2Asset(swapData.to),
            amount: amountIn,
            userData: userData
        });

        ISwaapV2Vault.FundManagement memory funds = ISwaapV2Vault.FundManagement({
            sender: address(this),
            fromInternalBalance: false,
            recipient: payable(address(this)),
            toInternalBalance: false
        });

        IERC20(from).safeIncreaseAllowance(swapData.addr, amountIn);

        amountOut = ISwaapV2Vault(swapData.addr).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 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/CurveTricrypto.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/MaverickV2.sol";
import "./libraries/WrappedNative.sol";
import "./libraries/LiquiditybookV2_1.sol";
import "./libraries/SwaapV2.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 CURVE_TRICRYPTO = "CURVE_TRICRYPTO";
    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";
    bytes32 internal constant LIQUIDITY_BOOK_V2_1 = "LIQUIDITY_BOOK_V2_1";
    bytes32 internal constant MAVERICK_V2 = "MAVERICK_V2";
    bytes32 internal constant SWAAP_V2 = "SWAAP_V2";

    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 Maverick V2 pools. Not allowed to be executed outside of a swap operation
     * @param tokenIn Token to be transferred to the caller
     * @param amountIn Amount of tokens to be transferred to the caller
     */
    function maverickV2SwapCallback(
        address tokenIn,
        uint256 amountIn,
        uint256 /*amountOut*/,
        bytes calldata /*data*/
    ) external onlyDuringSwap {
        MaverickV2.invokeCallback(tokenIn, amountIn);
    }

    /**
     * @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 = address(token) == address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
                ? WETH.balanceOf(address(this))
                : 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(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)) {
                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(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)) {
            //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 == CURVE_TRICRYPTO) {
            return CurveTricrypto.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 if (swapData.family == LIQUIDITY_BOOK_V2_1) {
            return LiquiditybookV2_1.swap(from, amountIn, swapData);
        } else if (swapData.family == MAVERICK_V2) {
            return MaverickV2.swap(amountIn, swapData);
        } else if (swapData.family == SWAAP_V2) {
            return SwaapV2.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",
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 800
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• 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":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"maverickV2SwapCallback","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"}]

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

00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1000000000000000000000000bd4a0f12293c54e4e8ad221271cf0d395dd60a71

-----Decoded View---------------
Arg [0] : _weth (address): 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1
Arg [1] : _treasury (address): 0xBD4a0F12293C54e4E8ad221271CF0d395dd60a71

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1
Arg [1] : 000000000000000000000000bd4a0f12293c54e4e8ad221271cf0d395dd60a71