Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "../interfaces/IERC20.sol";
import "../interfaces/IAdapter.sol";
import "../interfaces/IVenusToken.sol";
import "../interfaces/IWETH.sol";
import "../libraries/SafeERC20.sol";
import {RefundLib} from "../libraries/Adapters.sol";

contract VenusAdapter is IAdapter {
    address constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    address public immutable WETH;
    address public immutable vNative;

    event Received(address sender, uint256 amount);

    constructor(address _weth, address _vNative) {
        WETH = _weth;
        vNative = _vNative;
    }

    function sellQuote(
        address to,
        address pool,
        bytes memory
    ) external override {
        // pool = vToken
        require(IVenusToken(pool).isVToken(), "VenusAdapter: pool is not a vToken");
        uint256 amountIn = IERC20(pool).balanceOf(address(this));

        // If the pool is vNative, the underlying is ETH, otherwise it's the underlying token
        address underlying;
        if (pool == vNative) {
            underlying = ETH;
        } else {
            underlying = IVenusToken(pool).underlying();
        }

        IVenusToken(pool).redeem(amountIn);

        address tokenOut = underlying;
        if (underlying == ETH) {
            IWETH(WETH).deposit{value: address(this).balance}();
            tokenOut = WETH;
        }
        uint256 amountOut = IERC20(tokenOut).balanceOf(address(this));
        SafeERC20.safeTransfer(IERC20(tokenOut), to, amountOut);

        refund(pool);
    }

    function sellBase(
        address to,
        address pool,
        bytes memory
    ) external override {
        // pool = vToken
        require(IVenusToken(pool).isVToken(), "VenusAdapter: pool is not a vToken");
        
        // If the pool is vNative, the underlying is ETH, otherwise it's the underlying token
        address underlying;
        if (pool == vNative) {
            underlying = ETH;
        } else {
            underlying = IVenusToken(pool).underlying();
        }

        uint256 amountIn;
        if (underlying == ETH) {
            amountIn = IERC20(WETH).balanceOf(address(this));
            IWETH(WETH).withdraw(amountIn);
            IVenusToken(pool).mint{value: amountIn}();
        } else {
            amountIn = IERC20(underlying).balanceOf(address(this));
            SafeERC20.safeApprove(IERC20(underlying), pool, amountIn);
            IVenusToken(pool).mint(amountIn);
        }
        SafeERC20.safeTransfer(
            IERC20(pool),
            to,
            IERC20(pool).balanceOf(address(this))
        );

        refund(underlying);
    }

    receive() external payable {
        emit Received(msg.sender, msg.value);
    }

    function refund(address token) internal {
        address payerOrigin = RefundLib.getPayerOrigin();
        if (payerOrigin == address(0)) return;
        
        if (token == ETH) {
            uint256 remainAmount = address(this).balance;
            if (remainAmount > 0) {
                (bool success, ) = payerOrigin.call{value: remainAmount}("");
                require(success, "VenusAdapter: ETH refund failed");
            }
        } else {
            uint256 remainAmount = IERC20(token).balanceOf(address(this));
            if (remainAmount > 0) {
                SafeERC20.safeTransfer(
                    IERC20(token),
                    payerOrigin,
                    remainAmount
                );
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IERC20 {
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Transfer(address indexed from, address indexed to, uint256 value);

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);
}

/// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;

interface IAdapter {
    function sellBase(
        address to,
        address pool,
        bytes memory data
    ) external;

    function sellQuote(
        address to,
        address pool,
        bytes memory data
    ) external;
}

/// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;

interface IVenusToken {
    function mint() external payable;
    function mint(uint256 mintAmount) external returns (uint);
    function redeem(uint256 redeemTokens) external returns (uint256);
    function underlying() external view returns (address);
    function isVToken() external view returns (bool);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;

interface IWETH {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address src,
        address dst,
        uint256 wad
    ) external returns (bool);

    function deposit() external payable;

    function withdraw(uint256 wad) external;
}

/// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./SafeMath.sol";
import "./Address.sol";
import "./RevertReasonForwarder.sol";
import "../interfaces/IERC20.sol";
import "../interfaces/IERC20Permit.sol";
import "../interfaces/IDaiLikePermit.sol";

// File @1inch/solidity-utils/contracts/libraries/[email protected]

library SafeERC20 {
    error SafeTransferFailed();
    error SafeTransferFromFailed();
    error ForceApproveFailed();
    error SafeIncreaseAllowanceFailed();
    error SafeDecreaseAllowanceFailed();
    error SafePermitBadLength();

    // Ensures method do not revert or return boolean `true`, admits call to non-smart-contract
    function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {
        bytes4 selector = token.transferFrom.selector;
        bool success;
        /// @solidity memory-safe-assembly
        assembly { // solhint-disable-line no-inline-assembly
            let data := mload(0x40)

            mstore(data, selector)
            mstore(add(data, 0x04), from)
            mstore(add(data, 0x24), to)
            mstore(add(data, 0x44), amount)
            success := call(gas(), token, 0, data, 100, 0x0, 0x20)
            if success {
                switch returndatasize()
                case 0 { success := gt(extcodesize(token), 0) }
                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }
            }
        }
        if (!success) revert SafeTransferFromFailed();
    }

    // Ensures method do not revert or return boolean `true`, admits call to non-smart-contract
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        if (!_makeCall(token, token.transfer.selector, to, value)) {
            revert SafeTransferFailed();
        }
    }

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        forceApprove(token, spender, value);
    }

    // If `approve(from, to, amount)` fails, try to `approve(from, to, 0)` before retry
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        if (!_makeCall(token, token.approve.selector, spender, value)) {
            if (!_makeCall(token, token.approve.selector, spender, 0) ||
                !_makeCall(token, token.approve.selector, spender, value))
            {
                revert ForceApproveFailed();
            }
        }
    }

    

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 allowance = token.allowance(address(this), spender);
        if (value > type(uint256).max - allowance) revert SafeIncreaseAllowanceFailed();
        forceApprove(token, spender, allowance + value);
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 allowance = token.allowance(address(this), spender);
        if (value > allowance) revert SafeDecreaseAllowanceFailed();
        forceApprove(token, spender, allowance - value);
    }

    function safePermit(IERC20 token, bytes calldata permit) internal {
        bool success;
        if (permit.length == 32 * 7) {
            success = _makeCalldataCall(token, IERC20Permit.permit.selector, permit);
        } else if (permit.length == 32 * 8) {
            success = _makeCalldataCall(token, IDaiLikePermit.permit.selector, permit);
        } else {
            revert SafePermitBadLength();
        }
        if (!success) RevertReasonForwarder.reRevert();
    }

    function _makeCall(IERC20 token, bytes4 selector, address to, uint256 amount) private returns(bool success) {
        /// @solidity memory-safe-assembly
        assembly { // solhint-disable-line no-inline-assembly
            let data := mload(0x40)

            mstore(data, selector)
            mstore(add(data, 0x04), to)
            mstore(add(data, 0x24), amount)
            success := call(gas(), token, 0, data, 0x44, 0x0, 0x20)
            if success {
                switch returndatasize()
                case 0 { success := gt(extcodesize(token), 0) }
                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }
            }
        }
    }

    function _makeCalldataCall(IERC20 token, bytes4 selector, bytes calldata args) private returns(bool success) {
        /// @solidity memory-safe-assembly
        assembly { // solhint-disable-line no-inline-assembly
            let len := add(4, args.length)
            let data := mload(0x40)

            mstore(data, selector)
            calldatacopy(add(data, 0x04), args.offset, args.length)
            success := call(gas(), token, 0, data, len, 0x0, 0x20)
            if success {
                switch returndatasize()
                case 0 { success := gt(extcodesize(token), 0) }
                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }
            }
        }
    }
}

pragma solidity ^0.8.0;

// restricted liquidity lib for adapter developer
library RestrictedLiquidityLib {

    // if dex is restricted liquidity, then must use this struct to build more info
    struct TradeInfo {
        address fundAddress; // fromTokenAddress
        address tokenAddress; // toTokenAddress
        bool buyMeme;
        uint256 sellMemeAmount;
        uint256 sellCommissionRate1;
        address sellCommissionReceiver1;
        uint256 sellCommissionRate2;
        address sellCommissionReceiver2;
        uint256 minReturnAmount;
    }

}

// refund lib for adapter developer
library RefundLib {
    uint256 private constant ORIGIN_PAYER = 0x3ca20afc2ccc0000000000000000000000000000000000000000000000000000;
    uint256 private constant ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;

    function getPayerOrigin() internal pure returns (address payerOriginAddr) {
        uint256 _payerOrigin;
        // solhint-disable-next-line no-inline-assembly
        // This assembly is necessary to access calldata size and load data from specific positions
        // which cannot be achieved with pure Solidity code
        assembly {
            // Get the total size of the calldata
            let size := calldatasize()
            // Load the last 32 bytes of the calldata, which is assumed to contain the payer origin
            // Assumption: The calldata is structured such that the payer origin is always at the end
            _payerOrigin := calldataload(sub(size, 32))
        }
        if ((_payerOrigin & ORIGIN_PAYER) == ORIGIN_PAYER) {
            payerOriginAddr = address(uint160(uint256(_payerOrigin) & ADDRESS_MASK));
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

library SafeMath {
    uint256 constant WAD = 10**18;
    uint256 constant RAY = 10**27;

    function wad() public pure returns (uint256) {
        return WAD;
    }

    function ray() public pure returns (uint256) {
        return RAY;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a <= b ? a : b;
    }

    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    function sqrt(uint256 a) internal pure returns (uint256 b) {
        if (a > 3) {
            b = a;
            uint256 x = a / 2 + 1;
            while (x < b) {
                b = x;
                x = (a / x + x) / 2;
            }
        } else if (a != 0) {
            b = 1;
        }
    }

    function wmul(uint256 a, uint256 b) internal pure returns (uint256) {
        return mul(a, b) / WAD;
    }

    function wmulRound(uint256 a, uint256 b) internal pure returns (uint256) {
        return add(mul(a, b), WAD / 2) / WAD;
    }

    function rmul(uint256 a, uint256 b) internal pure returns (uint256) {
        return mul(a, b) / RAY;
    }

    function rmulRound(uint256 a, uint256 b) internal pure returns (uint256) {
        return add(mul(a, b), RAY / 2) / RAY;
    }

    function wdiv(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(mul(a, WAD), b);
    }

    function wdivRound(uint256 a, uint256 b) internal pure returns (uint256) {
        return add(mul(a, WAD), b / 2) / b;
    }

    function rdiv(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(mul(a, RAY), b);
    }

    function rdivRound(uint256 a, uint256 b) internal pure returns (uint256) {
        return add(mul(a, RAY), b / 2) / b;
    }

    function wpow(uint256 x, uint256 n) internal pure returns (uint256) {
        uint256 result = WAD;
        while (n > 0) {
            if (n % 2 != 0) {
                result = wmul(result, x);
            }
            x = wmul(x, x);
            n /= 2;
        }
        return result;
    }

    function rpow(uint256 x, uint256 n) internal pure returns (uint256) {
        uint256 result = RAY;
        while (n > 0) {
            if (n % 2 != 0) {
                result = rmul(result, x);
            }
            x = rmul(x, x);
            n /= 2;
        }
        return result;
    }

    function divCeil(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 quotient = div(a, b);
        uint256 remainder = a - quotient * b;
        if (remainder > 0) {
            return quotient + 1;
        } else {
            return quotient;
        }
    }
}

/// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/**
 * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            codehash := extcodehash(account)
        }
        return (codehash != accountHash && codehash != 0x0);
    }

    /**
     * @dev Converts an `address` into `address payable`. Note that this is
     * simply a type cast: the actual underlying value is not changed.
     *
     * _Available since v2.4.0._
     */
    function toPayable(address account)
        internal
        pure
        returns (address payable)
    {
        return payable(account);
    }

    /**
     * @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].
     *
     * _Available since v2.4.0._
     */
    function sendValue(address recipient, uint256 amount) internal {
        require(
            address(this).balance >= amount,
            "Address: insufficient balance"
        );

        // solhint-disable-next-line avoid-call-value
        (bool success, ) = recipient.call{value: amount}("");
        require(
            success,
            "Address: unable to send value, recipient may have reverted"
        );
    }
}

/// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library RevertReasonForwarder {
    function reRevert() internal pure {
        // bubble up revert reason from latest external call
        /// @solidity memory-safe-assembly
        assembly { // solhint-disable-line no-inline-assembly
            let ptr := mload(0x40)
            returndatacopy(ptr, 0, returndatasize())
            revert(ptr, returndatasize())
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

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

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/// @title Interface for DAI-style permits
interface IDaiLikePermit {
    function permit(
        address holder,
        address spender,
        uint256 nonce,
        uint256 expiry,
        bool allowed,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
}

{
  "remappings": [
    "@ensdomains/=node_modules/@ensdomains/",
    "@openzeppelin/=node_modules/@openzeppelin/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "eth-gas-reporter/=node_modules/eth-gas-reporter/",
    "forge-std/=lib/forge-std/src/",
    "hardhat/=node_modules/hardhat/",
    "@dex/=contracts/8/",
    "@uniswap/=node_modules/@uniswap/",
    "@zetachain/=node_modules/@zetachain/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 1
  },
  "metadata": {
    "useLiteralContent": true,
    "bytecodeHash": "ipfs"
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "london",
  "viaIR": false
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_weth","type":"address"},{"internalType":"address","name":"_vNative","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ForceApproveFailed","type":"error"},{"inputs":[],"name":"SafeTransferFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Received","type":"event"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"pool","type":"address"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"sellBase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"pool","type":"address"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"sellQuote","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vNative","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

00000000000000000000000042000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _weth (address): 0x4200000000000000000000000000000000000006
Arg [1] : _vNative (address): 0x0000000000000000000000000000000000000000

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000004200000000000000000000000000000000000006
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000