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/IAdapter.sol";
import "../interfaces/IHashflowV3.sol";
import "../interfaces/IERC20.sol";
import "../libraries/SafeERC20.sol";
import "../interfaces/IWETH.sol";

contract HashflowV3Adapter is IAdapter {
    address public HASHFLOW_V3_ROUTER;
    address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    address public WETH_ADDRESS;

    constructor(address _HashflowV3Router, address _weth) {
        HASHFLOW_V3_ROUTER = _HashflowV3Router;
        WETH_ADDRESS = _weth;
    }

    function _hashflowSwap(
        address to,
        address pool,
        bytes memory moreInfo
    ) internal {
        (address fromToken, address toToken, RFQTQuote memory Quote) = abi
            .decode(moreInfo, (address, address, RFQTQuote));
        require(Quote.pool == pool, "error pool");

        Quote.effectiveBaseTokenAmount = IERC20(fromToken).balanceOf(
            address(this)
        );
        SafeERC20.safeApprove(
            IERC20(fromToken),
            HASHFLOW_V3_ROUTER,
            Quote.effectiveBaseTokenAmount
        );
        IHashflowV3(HASHFLOW_V3_ROUTER).tradeRFQT(Quote);

        if (to != address(this)) {
            if (toToken == ETH_ADDRESS) {
                IWETH(WETH_ADDRESS).deposit{value: address(this).balance}();
                toToken = WETH_ADDRESS;
            }
            SafeERC20.safeTransfer(
                IERC20(toToken),
                to,
                IERC20(toToken).balanceOf(address(this))
            );
        }
    }

    function sellBase(
        address to,
        address pool,
        bytes memory moreInfo
    ) external override {
        _hashflowSwap(to, pool, moreInfo);
    }

    function sellQuote(
        address to,
        address pool,
        bytes memory moreInfo
    ) external override {
        _hashflowSwap(to, pool, moreInfo);
    }

    event Received(address, uint256);

    receive() external payable {
        require(msg.value > 0, "receive error");
        emit Received(msg.sender, msg.value);
    }
}

/// 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;


/// @notice Used for intra-chain RFQ-T trades.
struct RFQTQuote {
    /// @notice The address of the HashflowPool to trade against.
    address pool;
    /**
        * @notice The external account linked to the HashflowPool.
        * If the HashflowPool holds funds, this should be address(0).
        */
    address externalAccount;
    /// @notice The recipient of the quoteToken at the end of the trade.
    address trader;
    /**
        * @notice The account "effectively" making the trade (ultimately receiving the funds).
        * This is commonly used by aggregators, where a proxy contract (the 'trader')
        * receives the quoteToken, and the effective trader is the user initiating the call.
        *
        * This field DOES NOT influence movement of funds. However, it is used to check against
        * quote replay.
        */
    address effectiveTrader;
    /// @notice The token that the trader sells.
    address baseToken;
    /// @notice The token that the trader buys.
    address quoteToken;
    /**
        * @notice The amount of baseToken sold in this trade. The exchange rate
        * is going to be preserved as the quoteTokenAmount / baseTokenAmount ratio.
        *
        * Most commonly, effectiveBaseTokenAmount will == baseTokenAmount.
        */
    uint256 effectiveBaseTokenAmount;
    /// @notice The max amount of baseToken sold.
    uint256 baseTokenAmount;
    /// @notice The amount of quoteToken bought when baseTokenAmount is sold.
    uint256 quoteTokenAmount;
    /// @notice The Unix timestamp (in seconds) when the quote expires.
    /// @dev This gets checked against block.timestamp.
    uint256 quoteExpiry;
    /// @notice The nonce used by this effectiveTrader. Nonces are used to protect against replay.
    uint256 nonce;
    /// @notice Unique identifier for the quote.
    /// @dev Generated off-chain via a distributed UUID generator.
    bytes32 txid;
    /// @notice Signature provided by the market maker (EIP-191).
    bytes signature;
}

interface IHashflowV3 {
    function tradeRFQT(
        RFQTQuote memory rpcStruct
    ) external payable;
}

// 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;

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)) }
            }
        }
    }
}

// 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;

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": false,
    "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":"_HashflowV3Router","type":"address"},{"internalType":"address","name":"_weth","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ForceApproveFailed","type":"error"},{"inputs":[],"name":"SafeTransferFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"","type":"address"},{"indexed":false,"internalType":"uint256","name":"","type":"uint256"}],"name":"Received","type":"event"},{"inputs":[],"name":"HASHFLOW_V3_ROUTER","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH_ADDRESS","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":"moreInfo","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":"moreInfo","type":"bytes"}],"name":"sellQuote","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000ca310b1b942a30ff4b40a5e1b69ab4607ec79bc10000000000000000000000004200000000000000000000000000000000000006

-----Decoded View---------------
Arg [0] : _HashflowV3Router (address): 0xCa310B1B942A30Ff4b40a5E1b69AB4607eC79Bc1
Arg [1] : _weth (address): 0x4200000000000000000000000000000000000006

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