MATIC Price: $0.99 (-2.22%)
Gas: 105 GWei
 

Overview

MATIC Balance

Polygon PoS Chain LogoPolygon PoS Chain LogoPolygon PoS Chain Logo0 MATIC

MATIC Value

$0.00

Sponsored

Transaction Hash
Method
Block
From
To
Value
0x60806040364914342022-12-06 9:52:11479 days ago1670320331IN
 Create: SwitchCelerDepositReceiver
0 MATIC0.0626261132.26562114

Parent Txn Hash Block From To Value
View All Internal Transactions
Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
SwitchCelerDepositReceiver

Compiler Version
v0.8.9+commit.e5eed63a

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity Standard Json-Input format)

File 1 of 22 : SwitchCelerDepositReceiver.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;

import "../dexs/Switch.sol";
import "../lib/DataTypes.sol";
import { ICallDataExecutor } from "../interfaces/ICallDataExecutor.sol";
import { ISwitchEvent } from "../interfaces/ISwitchEvent.sol";
import "sgn-v2-contracts/contracts/message/interfaces/IMessageReceiverApp.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract SwitchCelerDepositReceiver is Ownable, ReentrancyGuard {
    address public celerMessageBus;
    address public callDataExecutor;
    address public paraswapProxy;
    address public augustusSwapper;
    ISwitchEvent public switchEvent;
    using SafeERC20 for IERC20;
    using UniversalERC20 for IERC20;

    event CallDataExecutorSet(address callDataExecutor);
    event CelerMessageBusSet(address celerMessageBus);
    event ParaswapProxySet(address paraswapProxy);
    event AugustusSwapperSet(address augustusSwapper);

    struct CelerDepositRequest {
        bytes32 id;
        bytes32 bridge;
        address srcToken;
        address bridgeToken;
        address depositToken;
        address recipient;
        address depositContract;
        address toApprovalAddress; // the approval address for deposit
        address contractOutputsToken;  // optional, some contract will output a token (e.g. staking) to forward the token to the user.
        uint256 srcAmount;
        uint256 bridgeDstAmount;
        uint256 estimatedDepositAmount;
        uint32 toContractGasLimit;
        DataTypes.ParaswapUsageStatus paraswapUsageStatus;
        uint256[] dstDistribution;
        bytes depositCallData;
        bytes dstParaswapData;
    }

    constructor(
        address _switchEventAddress,
        address _callDataExecutor,
        address _celerMessageBus,
        address _paraswapProxy,
        address _augustusSwapper
    ) public {
        switchEvent = ISwitchEvent(_switchEventAddress);
        celerMessageBus = _celerMessageBus;
        callDataExecutor = _callDataExecutor;
        paraswapProxy = _paraswapProxy;
        augustusSwapper = _augustusSwapper;
    }

    modifier onlyMessageBus() {
        require(msg.sender == celerMessageBus, "caller is not message bus");
        _;
    }

    function setCelerMessageBus(address _newCelerMessageBus) external onlyOwner {
        celerMessageBus = _newCelerMessageBus;
        emit CelerMessageBusSet(_newCelerMessageBus);
    }

    function setCallDataExecutor(address _newCallDataExecutor) external onlyOwner {
        callDataExecutor = _newCallDataExecutor;
        emit CallDataExecutorSet(_newCallDataExecutor);
    }

    function setParaswapProxy(address _paraswapProxy) external onlyOwner {
        paraswapProxy = _paraswapProxy;
        emit ParaswapProxySet(_paraswapProxy);
    }

    function setAugustusSwapper(address _augustusSwapper) external onlyOwner {
        augustusSwapper = _augustusSwapper;
        emit AugustusSwapperSet(_augustusSwapper);
    }

    // handler function required by MsgReceiverApp
    function executeMessageWithTransfer(
        address, //sender
        address _token,
        uint256 _amount,
        uint64 _srcChainId,
        bytes memory _message,
        address // executor
    )
        external
        payable
        onlyMessageBus
        returns (IMessageReceiverApp.ExecutionStatus)
    {
        CelerDepositRequest memory m = abi.decode((_message), (CelerDepositRequest));
        require(_token == m.bridgeToken, "bridged token must be the same as the first token in destination swap path");
        uint256 depositAmount = m.estimatedDepositAmount;
        if (m.bridgeToken != m.depositToken) {
            require(m.bridgeDstAmount <= _amount, "estimated bridge token balance is insufficient");
            // swap token through paraswap
            ICallDataExecutor(callDataExecutor).execute(IERC20(_token), augustusSwapper, paraswapProxy, _amount, 0, m.dstParaswapData);
            // deposit token to lending protocal
            ICallDataExecutor(callDataExecutor).execute(IERC20(m.depositToken), m.depositContract, m.toApprovalAddress, depositAmount, m.toContractGasLimit, m.depositCallData);
            _emitCrosschainDepositDone(m, _amount, depositAmount, DataTypes.DepositStatus.Succeeded);
        } else {
            depositAmount = m.bridgeDstAmount;
            require(depositAmount <= _amount, "deposit balance is insufficient");

            if (IERC20(_token).isETH()) {
                ICallDataExecutor(callDataExecutor).sendNativeAndExecute{ value: _amount }(
                    IERC20(m.depositToken),
                    m.depositContract,
                    m.toApprovalAddress,
                    depositAmount,
                    m.toContractGasLimit,
                    m.depositCallData
                );
            } else {
                // Give approval
                IERC20(_token).universalApprove(callDataExecutor, _amount);
                ICallDataExecutor(callDataExecutor).sendAndExecute(
                    IERC20(m.depositToken),
                    m.depositContract,
                    m.toApprovalAddress,
                    depositAmount,
                    m.toContractGasLimit,
                    m.depositCallData
                );
            }

            _sendToRecipient(_token, m.recipient, _amount - depositAmount);
            _emitCrosschainDepositDone(m, _amount, _amount, DataTypes.DepositStatus.Succeeded);
        }
        // always return true since swap failure is already handled in-place
        return IMessageReceiverApp.ExecutionStatus.Success;
    }

    // called on source chain for handling of bridge failures (bad liquidity, bad slippage, etc...)
    function executeMessageWithTransferRefund(
        address _token,
        uint256 _amount,
        bytes calldata _message,
        address // executor
    )
        external
        payable
        onlyMessageBus
        returns (IMessageReceiverApp.ExecutionStatus)
    {
        CelerDepositRequest memory m = abi.decode((_message), (CelerDepositRequest));
        _sendToRecipient(_token, m.recipient, _amount);

        switchEvent.emitCrosschainDepositRequest(
            m.id,
            bytes32(0),
            m.bridge,
            m.recipient,
            m.depositContract, // contract address for deposit
            m.toApprovalAddress, // the approval address for deposit
            m.srcToken,
            m.depositToken,
            m.srcAmount,
            m.estimatedDepositAmount,
            DataTypes.DepositStatus.Fallback
        );

        return IMessageReceiverApp.ExecutionStatus.Success;
    }

    // handler function required by MsgReceiverApp
    // called only if handleMessageWithTransfer above was reverted
    function executeMessageWithTransferFallback(
        address, // sender
        address _token, // token,
        uint256 _amount, // amount
        uint64 _srcChainId,
        bytes memory _message,
        address // executor
    )
        external
        payable
        onlyMessageBus
        returns (IMessageReceiverApp.ExecutionStatus)
    {
        CelerDepositRequest memory m = abi.decode((_message), (CelerDepositRequest));
        _sendToRecipient(_token, m.recipient, _amount);

        _emitCrosschainSwapDone(m, _amount, 0, DataTypes.SwapStatus.Fallback);
        // we can do in this app as the swap failures are already handled in executeMessageWithTransfer
        return IMessageReceiverApp.ExecutionStatus.Success;
    }

    function _sendToRecipient(
        address token,
        address recipient,
        uint256 amount
    )
        internal
    {
        if (IERC20(token).isETH()) {
            payable(recipient).transfer(amount);
        } else {
            IERC20(token).universalTransfer(recipient, amount);
        }
    }

    function transferToken(address token, uint256 amount, address recipient) external onlyOwner {
        IERC20(token).universalTransfer(recipient, amount);
    }

    function _emitCrosschainDepositDone(
        CelerDepositRequest memory m,
        uint256 srcAmount,
        uint256 dstAmount,
        DataTypes.DepositStatus status
    )
        internal
    {
        switchEvent.emitCrosschainDepositDone(m.id, m.bridge, m.recipient, m.depositContract, m.toApprovalAddress, m.bridgeToken, m.depositToken, srcAmount, dstAmount, status);
    }

    function _emitCrosschainSwapDone(
        CelerDepositRequest memory m,
        uint256 srcAmount,
        uint256 dstAmount,
        DataTypes.SwapStatus status
    )
        internal
    {
        switchEvent.emitCrosschainSwapDone(m.id, m.bridge, m.recipient, m.bridgeToken, m.depositToken, srcAmount, dstAmount, status);
    }
}

File 2 of 22 : Ownable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

File 3 of 22 : ReentrancyGuard.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

File 4 of 22 : draft-IERC20Permit.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

File 5 of 22 : IERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

File 6 of 22 : SafeERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/draft-IERC20Permit.sol";
import "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

File 7 of 22 : Address.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

File 8 of 22 : Context.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

File 9 of 22 : ISwitchView.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;

import "../interfaces/IUniswapFactory.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

abstract contract ISwitchView {

    struct ReturnArgs {
        IERC20 fromToken;
        IERC20 destToken;
        uint256 amount;
        uint256 parts;
    }

    struct CalculateArgs {
        IERC20 fromToken;
        IERC20 destToken;
        IUniswapFactory factory;
        uint256 amount;
        uint256 parts;
    }

    function getExpectedReturn(
        IERC20 fromToken,
        IERC20 destToken,
        uint256 amount,
        uint256 parts
    )
        public
        virtual
        view
        returns (
            uint256 returnAmount,
            uint256[] memory distribution
        );
}

File 10 of 22 : IWETH.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

abstract contract IWETH is IERC20 {
    function deposit() external virtual payable;
    function withdraw(uint256 amount) virtual external;
}

File 11 of 22 : SwitchRoot.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;

import "./ISwitchView.sol";
import "./IWETH.sol";
import "../lib/DisableFlags.sol";
import "../lib/UniversalERC20.sol";
import "../interfaces/IUniswapFactory.sol";
import "../lib/UniswapExchangeLib.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

abstract contract SwitchRoot is ISwitchView {
    using DisableFlags for uint256;
    using UniversalERC20 for IERC20;
    using UniversalERC20 for IWETH;
    using UniswapExchangeLib for IUniswapExchange;

    address public ETH_ADDRESS = address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
    address public ZERO_ADDRESS = address(0);

    uint256 public dexCount;
    uint256 public pathCount;
    uint256 public pathSplit;
    IWETH public weth; // chain's native token
    IWETH public otherToken; //could be weth on a non-eth chain or other mid token(like busd)

    address[] public factories;

    int256 internal constant VERY_NEGATIVE_VALUE = -1e72;

    constructor(address _weth, address _otherToken, uint256 _pathCount, uint256 _pathSplit, address[] memory _factories) {
        weth = IWETH(_weth);
        otherToken = IWETH(_otherToken);
        pathCount = _pathCount;
        pathSplit = _pathSplit;
        dexCount = _factories.length;
        for (uint256 i = 0; i < _factories.length; i++) {
            factories.push(_factories[i]);
        }
    }

    function _findBestDistribution(
        uint256 s,                // parts
        int256[][] memory amounts // exchangesReturns
    )
        internal
        view
        returns (
            int256 returnAmount,
            uint256[] memory distribution
        )
    {
        uint256 n = amounts.length;

        int256[][] memory answer = new int256[][](n); // int[n][s+1]
        uint256[][] memory parent = new uint256[][](n); // int[n][s+1]

        for (uint i = 0; i < n; i++) {
            answer[i] = new int256[](s + 1);
            parent[i] = new uint256[](s + 1);
        }

        for (uint j = 0; j <= s; j++) {
            answer[0][j] = amounts[0][j];
            for (uint i = 1; i < n; i++) {
                answer[i][j] = -1e72;
            }
            parent[0][j] = 0;
        }

        for (uint i = 1; i < n; i++) {
            for (uint j = 0; j <= s; j++) {
                answer[i][j] = answer[i - 1][j];
                parent[i][j] = j;

                for (uint k = 1; k <= j; k++) {
                    if (answer[i - 1][j - k] + amounts[i][k] > answer[i][j]) {
                        answer[i][j] = answer[i - 1][j - k] + amounts[i][k];
                        parent[i][j] = j - k;
                    }
                }
            }
        }

        distribution = new uint256[](dexCount*pathCount*pathSplit);

        uint256 partsLeft = s;
        unchecked {
            for (uint curExchange = n - 1; partsLeft > 0; curExchange--) {
                distribution[curExchange] = partsLeft - parent[curExchange][partsLeft];
                partsLeft = parent[curExchange][partsLeft];
            }
        }

        returnAmount = (answer[n - 1][s] == VERY_NEGATIVE_VALUE) ? int256(0) : answer[n - 1][s];
    }

    function _linearInterpolation(
        uint256 value,
        uint256 parts
    )
        internal
        pure
        returns (uint256[] memory rets)
    {
        rets = new uint256[](parts);
        for (uint i = 0; i < parts; i++) {
            rets[i] = value * (i + 1) / parts;
        }
    }

    function _tokensEqual(
        IERC20 tokenA,
        IERC20 tokenB
    )
        internal
        pure
        returns (bool)
    {
        return ((tokenA.isETH() && tokenB.isETH()) || tokenA == tokenB);
    }
}

File 12 of 22 : Switch.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;

import "../core/ISwitchView.sol";
import "../core/SwitchRoot.sol";
import "../interfaces/ISwitchEvent.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract Switch is Ownable, SwitchRoot, ReentrancyGuard {
    using UniswapExchangeLib for IUniswapExchange;
    using UniversalERC20 for IERC20;
    using SafeERC20 for IERC20;

    ISwitchView public switchView;
    ISwitchEvent public switchEvent;
    address public reward;
    address private paraswapProxy;
    address private augustusSwapper;
    address public tradeFeeReceiver;
    uint256 public tradeFeeRate;
    mapping (address => uint256) public partnerFeeRates;

    uint256 public constant FEE_BASE = 10000;

    event RewardSet(address reward);
    event SwitchEventSet(ISwitchEvent switchEvent);
    event PartnerFeeSet(address partner, uint256 feeRate);
    event TradeFeeSet(uint256 tradeFee);
    event TradeFeeReceiverSet(address tradeFeeReceiver);
    event ParaswapProxySet(address paraswapProxy);
    event AugustusSwapperSet(address augustusSwapper);

    constructor(
        address _weth,
        address _otherToken,
        uint256 _pathCount,
        uint256 _pathSplit,
        address[] memory _factories,
        address _switchViewAddress,
        address _switchEventAddress,
        address _paraswapProxy,
        address _augustusSwapper
    ) SwitchRoot(_weth, _otherToken, _pathCount, _pathSplit, _factories)
        public
    {
        switchView = ISwitchView(_switchViewAddress);
        switchEvent = ISwitchEvent(_switchEventAddress);
        paraswapProxy = _paraswapProxy;
        augustusSwapper = _augustusSwapper;
        reward = msg.sender;
    }

    fallback() external payable {
        // solium-disable-next-line security/no-tx-origin
        require(msg.sender != tx.origin);
    }

    function setReward(address _reward) external onlyOwner {
        reward = _reward;
        emit RewardSet(_reward);
    }

    function setSwitchEvent(ISwitchEvent _switchEvent) external onlyOwner {
        switchEvent = _switchEvent;
        emit SwitchEventSet(_switchEvent);
    }

    function setParaswapProxy(address _paraswapProxy) external onlyOwner {
        paraswapProxy = _paraswapProxy;
        emit ParaswapProxySet(_paraswapProxy);
    }

    function setAugustusSwapper(address _augustusSwapper) external onlyOwner {
        augustusSwapper = _augustusSwapper;
        emit AugustusSwapperSet(_augustusSwapper);
    }

    function setPartnerFeeRate(address _partner, uint256 _feeRate) external onlyOwner {
        partnerFeeRates[_partner] = _feeRate;
        emit PartnerFeeSet(_partner, _feeRate);
    }

    function setTradeFeeRate(uint256 _tradeFeeRate) external onlyOwner {
        tradeFeeRate = _tradeFeeRate;
        emit TradeFeeSet(_tradeFeeRate);
    }

    function setTradeFeeReceiver(address _tradeFeeReceiver) external onlyOwner {
        tradeFeeReceiver = _tradeFeeReceiver;
        emit TradeFeeReceiverSet(_tradeFeeReceiver);
    }

    function getTokenBalance(address token) external view onlyOwner returns(uint256 amount) {
        amount = IERC20(token).universalBalanceOf(address(this));
    }

    function transferToken(address token, uint256 amount, address recipient) external onlyOwner {
        IERC20(token).universalTransfer(recipient, amount);
    }

    function getExpectedReturn(
        IERC20 fromToken,
        IERC20 destToken,
        uint256 amount,
        uint256 parts
    )
        public
        override
        view
        returns (
            uint256 returnAmount,
            uint256[] memory distribution
        )
    {
        (returnAmount, distribution) = switchView.getExpectedReturn(fromToken, destToken, amount, parts);
    }

    function swap(
        IERC20 fromToken,
        IERC20 destToken,
        uint256 amount,
        uint256 expectedReturn,
        uint256 minReturn,
        address recipient,
        uint256[] memory distribution
    )
        public
        payable
        nonReentrant
        returns (uint256 returnAmount)
    {
        require(expectedReturn >= minReturn, "expectedReturn must be equal or larger than minReturn");
        if (fromToken == destToken) {
            revert("it's not allowed to swap with same token");
        }

        uint256 parts = 0;
        uint256 lastNonZeroIndex = 0;
        for (uint i = 0; i < distribution.length; i++) {
            if (distribution[i] > 0) {
                parts += distribution[i];
                lastNonZeroIndex = i;
            }
        }

        if (parts == 0) {
            if (fromToken.isETH()) {
                payable(msg.sender).transfer(msg.value);
                return msg.value;
            }
            return amount;
        }

        fromToken.universalTransferFrom(msg.sender, address(this), amount);
        returnAmount = _swapInternalForSingleSwap(distribution, amount, parts, lastNonZeroIndex, fromToken, destToken);
        if (returnAmount > 0) {
            require(returnAmount >= minReturn, "Switch: Return amount was not enough");

            if (returnAmount > expectedReturn) {
                destToken.universalTransfer(recipient, expectedReturn);
                destToken.universalTransfer(reward, returnAmount - expectedReturn);
                switchEvent.emitSwapped(msg.sender, recipient, fromToken, destToken, amount, expectedReturn, returnAmount - expectedReturn);
            } else {
                destToken.universalTransfer(recipient, returnAmount);
                switchEvent.emitSwapped(msg.sender, recipient, fromToken, destToken, amount, returnAmount, 0);
            }
        } else {
            if (fromToken.universalBalanceOf(address(this)) > amount) {
                fromToken.universalTransfer(msg.sender, amount);
            } else {
                fromToken.universalTransfer(msg.sender, fromToken.universalBalanceOf(address(this)));
            }
        }
    }

    function swapWithParaswap(
        IERC20 fromToken,
        IERC20 destToken,
        uint256 amount,
        uint256 destAmount,
        address recipient,
        bytes memory callData
    )
        public
        payable
        nonReentrant
    {
        if (fromToken == destToken) {
            revert("it's not allowed to swap with same token");
        }
        fromToken.universalTransferFrom(msg.sender, address(this), amount);
        _callParaswap(fromToken, amount, callData);
        switchEvent.emitSwapped(msg.sender, recipient, fromToken, destToken, amount, destAmount, 0);
    }

    function getFeeInfo(
        uint256 amount,
        address partner
    )
        public
        view
        returns (
            uint256 tradeRate,
            uint256 partnerFeeRate,
            uint256 tradeFee,
            uint256 partnerFee,
            uint256 remainAmount
        )
    {
        tradeRate = tradeFeeRate;
        tradeFee = 0;
        partnerFeeRate = partnerFeeRates[partner];
        partnerFee = 0;
        if (tradeFeeRate > 0) {
            tradeFee = tradeFeeRate * amount / FEE_BASE;
        }
        if (partnerFeeRates[partner] > 0) {
            partnerFee = partnerFeeRates[partner] * amount / FEE_BASE;
        }
        remainAmount = amount - tradeFee - partnerFee;
    }

    function getTradeFee(
        uint256 amount
    )
        public
        view
        returns (
            uint256 feeRate,
            uint256 tradeFee,
            uint256 remainAmount
        )
    {
        feeRate = tradeFeeRate;
        tradeFee = 0;
        if (tradeFeeRate > 0) {
            tradeFee = tradeFeeRate * amount / FEE_BASE;
        }
        remainAmount = amount - tradeFee;
    }

    function getPartnerFee(
        uint256 amount,
        address partner
    )
        public
        view
        returns (
            uint256 feeRate,
            uint256 partnerFee,
            uint256 remainAmount
        )
    {
        feeRate = partnerFeeRates[partner];
        partnerFee = 0;
        if (partnerFeeRates[partner] > 0) {
            partnerFee = partnerFeeRates[partner] * amount / FEE_BASE;
        }
        remainAmount = amount - partnerFee;
    }

    function _swapInternalWithParaSwap(
        IERC20 fromToken,
        IERC20 destToken,
        uint256 amount,
        bytes memory callData
    )
        internal
        returns (
            uint256 totalAmount
        )
    {
        if (fromToken == destToken) {
            revert("it's not allowed to swap with same token");
        }

        _callParaswap(fromToken, amount, callData);
        totalAmount = destToken.universalBalanceOf(address(this));
        switchEvent.emitSwapped(msg.sender, address(this), fromToken, destToken, amount, totalAmount, 0);
    }

    function _callParaswap(
        IERC20 token,
        uint256 amount,
        bytes memory callData
    )
        internal
    {
        uint256 ethAmountToTransfert = 0;
        if (token.isETH()) {
            require(address(this).balance >= amount, "ETH balance is insufficient");
            ethAmountToTransfert = amount;
        } else {
            token.universalApprove(paraswapProxy, amount);
        }

        (bool success,) = augustusSwapper.call{ value: ethAmountToTransfert }(callData);
        require(success, "Paraswap execution failed");
    }

    function _swapInternalForSingleSwap(
        uint256[] memory distribution,
        uint256 amount,
        uint256 parts,
        uint256 lastNonZeroIndex,
        IERC20 fromToken,
        IERC20 destToken
    )
        internal
        returns (
            uint256 totalAmount
        )
    {
        require(distribution.length <= dexCount*pathCount, "Switch: Distribution array should not exceed factories array size");

        uint256 remainingAmount = amount;
        uint256 swappedAmount = 0;
        for (uint i = 0; i < distribution.length; i++) {
            if (distribution[i] == 0) {
                continue;
            }
            uint256 swapAmount = amount * distribution[i] / parts;
            if (i == lastNonZeroIndex) {
                swapAmount = remainingAmount;
            }
            remainingAmount -= swapAmount;
            if (i % pathCount == 0) {
                swappedAmount = _swap(fromToken, destToken, swapAmount, IUniswapFactory(factories[i/pathCount]));
            } else if (i % pathCount == 1) {
                swappedAmount = _swapETH(fromToken, destToken, swapAmount, IUniswapFactory(factories[i/pathCount]));
            } else {
                swappedAmount = _swapOtherToken(fromToken, destToken, swapAmount, IUniswapFactory(factories[i/pathCount]));
            }
            totalAmount += swappedAmount;
        }
    }

    function _getAmountAfterFee(
        IERC20 token,
        uint256 amount,
        address partner
    )
        internal
        returns (
            uint256 amountAfterFee
        )
    {
        amountAfterFee = amount;
        if (tradeFeeRate > 0) {
            token.universalTransfer(tradeFeeReceiver, tradeFeeRate * amount / FEE_BASE);
            amountAfterFee = amount - tradeFeeRate * amount / FEE_BASE;
        }
        if (partnerFeeRates[partner] > 0) {
            token.universalTransfer(partner, partnerFeeRates[partner] * amount / FEE_BASE);
            amountAfterFee = amount - partnerFeeRates[partner] * amount / FEE_BASE;
        }
    }

    // Swap helpers
    function _swapInternal(
        IERC20 fromToken,
        IERC20 destToken,
        uint256 amount,
        IUniswapFactory factory
    )
        internal
        returns (
            uint256 returnAmount
        )
    {
        if (fromToken.isETH()) {
            weth.deposit{value: amount}();
        }

        IERC20 fromTokenReal = fromToken.isETH() ? weth : fromToken;
        IERC20 toTokenReal = destToken.isETH() ? weth : destToken;
        IUniswapExchange exchange = factory.getPair(fromTokenReal, toTokenReal);
        bool needSync;
        bool needSkim;
        (returnAmount, needSync, needSkim) = exchange.getReturn(fromTokenReal, toTokenReal, amount);
        if (needSync) {
            exchange.sync();
        } else if (needSkim) {
            exchange.skim(0x46Fd07da395799F113a7584563b8cB886F33c2bc);
        }

        fromTokenReal.universalTransfer(address(exchange), amount);
        if (uint160(address(fromTokenReal)) < uint160(address(toTokenReal))) {
            exchange.swap(0, returnAmount, address(this), "");
        } else {
            exchange.swap(returnAmount, 0, address(this), "");
        }

        if (destToken.isETH()) {
            weth.withdraw(weth.balanceOf(address(this)));
        }
    }

    function _swapOverMid(
        IERC20 fromToken,
        IERC20 midToken,
        IERC20 destToken,
        uint256 amount,
        IUniswapFactory factory
    )
        internal
        returns (
            uint256 returnAmount
        )
    {
        returnAmount = _swapInternal(
            midToken,
            destToken,
            _swapInternal(
                fromToken,
                midToken,
                amount,
                factory
            ),
            factory
        );
    }

    function _swap(
        IERC20 fromToken,
        IERC20 destToken,
        uint256 amount,
        IUniswapFactory factory
    )
        internal
        returns (
            uint256 returnAmount
        )
    {
        returnAmount = _swapInternal(
            fromToken,
            destToken,
            amount,
            factory
        );
    }

    function _swapETH(
        IERC20 fromToken,
        IERC20 destToken,
        uint256 amount,
        IUniswapFactory factory
    )
        internal
        returns (
            uint256 returnAmount
        )
    {
        returnAmount = _swapOverMid(
            fromToken,
            weth,
            destToken,
            amount,
            factory
        );
    }

    function _swapOtherToken(
        IERC20 fromToken,
        IERC20 destToken,
        uint256 amount,
        IUniswapFactory factory
    )
        internal
        returns (
            uint256 returnAmount
        )
    {
        returnAmount = _swapOverMid(
            fromToken,
            otherToken,
            destToken,
            amount,
            factory
        );
    }
}

File 13 of 22 : ICallDataExecutor.sol
pragma solidity >=0.8.9;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface ICallDataExecutor {
    function execute(
        IERC20 token,
        address addr,
        address approveAddress,
        uint256 amount,
        uint256 gasLimit,
        bytes memory payload
    ) external payable;

    function sendNativeAndExecute(
        IERC20 token,
        address callTo,
        address approveAddress,
        uint256 amount,
        uint256 gasLimit,
        bytes memory payload
    ) external payable;

    function sendAndExecute(
        IERC20 token,
        address callTo,
        address approveAddress,
        uint256 amount,
        uint256 gasLimit,
        bytes memory payload
    ) external payable;
}

File 14 of 22 : ISwitchEvent.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../lib/DataTypes.sol";

interface ISwitchEvent {
    function emitSwapped(
        address from,
        address recipient,
        IERC20 fromToken,
        IERC20 destToken,
        uint256 fromAmount,
        uint256 destAmount,
        uint256 reward
    ) external;

    function emitParaswapSwapped(
        address from,
        IERC20 fromToken,
        uint256 fromAmount
    ) external;

    function emitCrosschainSwapRequest(
        bytes32 id,
        bytes32 bridgeTransferId,
        bytes32 bridge, // bridge slug
        address from, // user address
        address fromToken, // source token on sending chain
        address bridgeToken, // bridge token on sending chain
        address destToken, // dest token on receiving chain
        uint256 fromAmount, // source token amount on sending chain
        uint256 bridgeAmount, // swapped amount on sending chain
        uint256 dstAmount, // estimated amount of dest token on receiving chain
        DataTypes.SwapStatus status
    ) external;

    function emitCrosschainDepositRequest(
        bytes32 id,
        bytes32 bridgeTransferId,
        bytes32 bridge, // bridge slug
        address from, // user address
        address depositContract, // contract address for deposit
        address toApprovalAddress, // the approval address for deposit
        address fromToken, // source token on sending chain
        address depositToken, // dest token on receiving chain
        uint256 fromAmount, // source token amount on sending chain
        uint256 depositAmount, // estimated amount of dest token on receiving chain
        DataTypes.DepositStatus status
    ) external;

    function emitCrosschainSwapDone(
        bytes32 id,
        bytes32 bridge,
        address from, // user address
        address bridgeToken, // source token on receiving chain
        address destToken, // dest token on receiving chain
        uint256 bridgeAmount, // bridge token amount on receiving chain
        uint256 destAmount, //dest token amount on receiving chain
        DataTypes.SwapStatus status
    ) external;

    function emitCrosschainDepositDone(
        bytes32 id,
        bytes32 bridge,
        address from, // user address
        address depositContract, // contract address for deposit
        address toApprovalAddress, // the approval address for deposit
        address bridgeToken, // source token on receiving chain
        address depositToken, // dest token on receiving chain
        uint256 bridgeAmount, // bridge token amount on receiving chain
        uint256 depositAmount, //dest token amount on receiving chain
        DataTypes.DepositStatus status
    ) external;
}

File 15 of 22 : IUniswapExchange.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;

interface IUniswapExchange {
    function getReserves() external view returns(uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;
}

File 16 of 22 : IUniswapFactory.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IUniswapExchange.sol";

interface IUniswapFactory {
    function getPair(IERC20 tokenA, IERC20 tokenB) external view returns (IUniswapExchange pair);
}

File 17 of 22 : DataTypes.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;
/**
 * @title DataTypes
 * @dev Definition of shared types
 */
library DataTypes {
    /// @notice Type for representing a swapping status type
    enum SwapStatus {
        Null,
        Succeeded,
        Failed,
        Fallback
    }

    enum DepositStatus {
        Null,
        Succeeded,
        Failed,
        Fallback
    }

    /// @notice Type for representing a paraswap usage status
    enum ParaswapUsageStatus {
        None,
        OnSrcChain,
        OnDestChain,
        Both
    }

    /// @notice Swap params
    struct SwapInfo {
        address srcToken;
        address dstToken;
    }
}

File 18 of 22 : DisableFlags.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;

library DisableFlags {
    function check(
        uint256 flags,
        uint256 flag
    )
        internal
        pure
        returns (bool)
    {
        return (flags & flag) != 0;
    }
}

File 19 of 22 : Math.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;

library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}

File 20 of 22 : UniswapExchangeLib.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;

import "../interfaces/IUniswapExchange.sol";
import "./Math.sol";
import "./UniversalERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

library UniswapExchangeLib {
    using Math for uint256;
    using UniversalERC20 for IERC20;

    function getReturn(
        IUniswapExchange exchange,
        IERC20 fromToken,
        IERC20 destToken,
        uint amountIn
    )
        internal
        view
        returns (uint256 result, bool needSync, bool needSkim)
    {
        uint256 reserveIn = fromToken.universalBalanceOf(address(exchange));
        uint256 reserveOut = destToken.universalBalanceOf(address(exchange));
        (uint112 reserve0, uint112 reserve1,) = exchange.getReserves();
        if (fromToken > destToken) {
            (reserve0, reserve1) = (reserve1, reserve0);
        }
        needSync = (reserveIn < reserve0 || reserveOut < reserve1);
        needSkim = !needSync && (reserveIn > reserve0 || reserveOut > reserve1);

        uint256 amountInWithFee = amountIn * 997;
        uint256 numerator = amountInWithFee * Math.min(reserveOut, reserve1);
        uint256 denominator = Math.min(reserveIn, reserve0) * 1000 + amountInWithFee;
        result = (denominator == 0) ? 0 : numerator / denominator;
    }
}

File 21 of 22 : UniversalERC20.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

library UniversalERC20 {

    using SafeERC20 for IERC20;

    address private constant ZERO_ADDRESS = address(0x0000000000000000000000000000000000000000);
    address private constant ETH_ADDRESS = address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);

    function universalTransfer(
        IERC20 token,
        address to,
        uint256 amount
    )
        internal
        returns (bool)
    {
        if (amount == 0) {
            return true;
        }
        if (isETH(token)) {
            payable(to).transfer(amount);
            return true;
        } else {
            token.safeTransfer(to, amount);
            return true;
        }
    }

    function universalTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 amount
    )
        internal
    {
        if (amount == 0) {
            return;
        }

        if (isETH(token)) {
            require(from == msg.sender && msg.value >= amount, "Wrong useage of ETH.universalTransferFrom()");
            if (to != address(this)) {
                payable(to).transfer(amount);
            }
            // commented following lines for passing celer fee properly.
//            if (msg.value > amount) {
//                payable(msg.sender).transfer(msg.value - amount);
//            }
        } else {
            token.safeTransferFrom(from, to, amount);
        }
    }

    function universalTransferFromSenderToThis(
        IERC20 token,
        uint256 amount
    )
        internal
    {
        if (amount == 0) {
            return;
        }

        if (isETH(token)) {
            if (msg.value > amount) {
                // Return remainder if exist
                payable(msg.sender).transfer(msg.value - amount);
            }
        } else {
            token.safeTransferFrom(msg.sender, address(this), amount);
        }
    }

    function universalApprove(
        IERC20 token,
        address to,
        uint256 amount
    )
        internal
    {
        if (!isETH(token)) {
            if (amount == 0) {
                token.safeApprove(to, 0);
                return;
            }

            uint256 approvedAmount = token.allowance(address(this), to);

            if (approvedAmount < amount) {
                token.safeIncreaseAllowance(to, amount - approvedAmount);
            } else if (approvedAmount > amount) {
                token.safeDecreaseAllowance(to, approvedAmount - amount);
            }
        }
    }

    function universalBalanceOf(IERC20 token, address who) internal view returns (uint256) {
        if (isETH(token)) {
            return who.balance;
        } else {
            return token.balanceOf(who);
        }
    }

    function isETH(IERC20 token) internal pure returns(bool) {
        return (address(token) == address(ZERO_ADDRESS) || address(token) == address(ETH_ADDRESS));
    }

    // function notExist(IERC20 token) internal pure returns(bool) {
    //     return (address(token) == address(-1));
    // }
}

File 22 of 22 : IMessageReceiverApp.sol
// SPDX-License-Identifier: GPL-3.0-only

pragma solidity >=0.8.0;

interface IMessageReceiverApp {
    enum ExecutionStatus {
        Fail, // execution failed, finalized
        Success, // execution succeeded, finalized
        Retry // execution rejected, can retry later
    }

    /**
     * @notice Called by MessageBus (MessageBusReceiver) if the process is originated from MessageBus (MessageBusSender)'s
     *         sendMessageWithTransfer it is only called when the tokens are checked to be arrived at this contract's address.
     * @param _sender The address of the source app contract
     * @param _token The address of the token that comes out of the bridge
     * @param _amount The amount of tokens received at this contract through the cross-chain bridge.
     *        the contract that implements this contract can safely assume that the tokens will arrive before this
     *        function is called.
     * @param _srcChainId The source chain ID where the transfer is originated from
     * @param _message Arbitrary message bytes originated from and encoded by the source app contract
     * @param _executor Address who called the MessageBus execution function
     */
    function executeMessageWithTransfer(
        address _sender,
        address _token,
        uint256 _amount,
        uint64 _srcChainId,
        bytes calldata _message,
        address _executor
    ) external payable returns (ExecutionStatus);

    /**
     * @notice Only called by MessageBus (MessageBusReceiver) if
     *         1. executeMessageWithTransfer reverts, or
     *         2. executeMessageWithTransfer returns ExecutionStatus.Fail
     * @param _sender The address of the source app contract
     * @param _token The address of the token that comes out of the bridge
     * @param _amount The amount of tokens received at this contract through the cross-chain bridge.
     *        the contract that implements this contract can safely assume that the tokens will arrive before this
     *        function is called.
     * @param _srcChainId The source chain ID where the transfer is originated from
     * @param _message Arbitrary message bytes originated from and encoded by the source app contract
     * @param _executor Address who called the MessageBus execution function
     */
    function executeMessageWithTransferFallback(
        address _sender,
        address _token,
        uint256 _amount,
        uint64 _srcChainId,
        bytes calldata _message,
        address _executor
    ) external payable returns (ExecutionStatus);

    /**
     * @notice Called by MessageBus (MessageBusReceiver) to process refund of the original transfer from this contract
     * @param _token The token address of the original transfer
     * @param _amount The amount of the original transfer
     * @param _message The same message associated with the original transfer
     * @param _executor Address who called the MessageBus execution function
     */
    function executeMessageWithTransferRefund(
        address _token,
        uint256 _amount,
        bytes calldata _message,
        address _executor
    ) external payable returns (ExecutionStatus);

    /**
     * @notice Called by MessageBus (MessageBusReceiver)
     * @param _sender The address of the source app contract
     * @param _srcChainId The source chain ID where the transfer is originated from
     * @param _message Arbitrary message bytes originated from and encoded by the source app contract
     * @param _executor Address who called the MessageBus execution function
     */
    function executeMessage(
        address _sender,
        uint64 _srcChainId,
        bytes calldata _message,
        address _executor
    ) external payable returns (ExecutionStatus);
}

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_switchEventAddress","type":"address"},{"internalType":"address","name":"_callDataExecutor","type":"address"},{"internalType":"address","name":"_celerMessageBus","type":"address"},{"internalType":"address","name":"_paraswapProxy","type":"address"},{"internalType":"address","name":"_augustusSwapper","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"augustusSwapper","type":"address"}],"name":"AugustusSwapperSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"callDataExecutor","type":"address"}],"name":"CallDataExecutorSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"celerMessageBus","type":"address"}],"name":"CelerMessageBusSet","type":"event"},{"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":false,"internalType":"address","name":"paraswapProxy","type":"address"}],"name":"ParaswapProxySet","type":"event"},{"inputs":[],"name":"augustusSwapper","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"callDataExecutor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"celerMessageBus","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint64","name":"_srcChainId","type":"uint64"},{"internalType":"bytes","name":"_message","type":"bytes"},{"internalType":"address","name":"","type":"address"}],"name":"executeMessageWithTransfer","outputs":[{"internalType":"enum IMessageReceiverApp.ExecutionStatus","name":"","type":"uint8"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint64","name":"_srcChainId","type":"uint64"},{"internalType":"bytes","name":"_message","type":"bytes"},{"internalType":"address","name":"","type":"address"}],"name":"executeMessageWithTransferFallback","outputs":[{"internalType":"enum IMessageReceiverApp.ExecutionStatus","name":"","type":"uint8"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bytes","name":"_message","type":"bytes"},{"internalType":"address","name":"","type":"address"}],"name":"executeMessageWithTransferRefund","outputs":[{"internalType":"enum IMessageReceiverApp.ExecutionStatus","name":"","type":"uint8"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paraswapProxy","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_augustusSwapper","type":"address"}],"name":"setAugustusSwapper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newCallDataExecutor","type":"address"}],"name":"setCallDataExecutor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newCelerMessageBus","type":"address"}],"name":"setCelerMessageBus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_paraswapProxy","type":"address"}],"name":"setParaswapProxy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"switchEvent","outputs":[{"internalType":"contract ISwitchEvent","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"transferToken","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000002f421339aa22162555a2b74b44f92954d70b27cd0000000000000000000000005844f597e2824ec53e59c3ebe5ae7e54769cb965000000000000000000000000afdb9c40c7144022811f034ee07ce2e110093fe6000000000000000000000000216b4b4ba9f3e719726886d34a177484278bfcae000000000000000000000000def171fe48cf0115b1d80b88dc8eab59176fee57

-----Decoded View---------------
Arg [0] : _switchEventAddress (address): 0x2f421339aA22162555a2B74b44f92954D70b27CD
Arg [1] : _callDataExecutor (address): 0x5844f597E2824Ec53e59c3EbE5Ae7E54769cB965
Arg [2] : _celerMessageBus (address): 0xaFDb9C40C7144022811F034EE07Ce2E110093fe6
Arg [3] : _paraswapProxy (address): 0x216B4B4Ba9F3e719726886d34a177484278Bfcae
Arg [4] : _augustusSwapper (address): 0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000002f421339aa22162555a2b74b44f92954d70b27cd
Arg [1] : 0000000000000000000000005844f597e2824ec53e59c3ebe5ae7e54769cb965
Arg [2] : 000000000000000000000000afdb9c40c7144022811f034ee07ce2e110093fe6
Arg [3] : 000000000000000000000000216b4b4ba9f3e719726886d34a177484278bfcae
Arg [4] : 000000000000000000000000def171fe48cf0115b1d80b88dc8eab59176fee57


Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Txn Hash Block Value Eth2 PubKey Valid
View All Deposits
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.