Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import {IRouterClient} from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol";
import {Client} from "@chainlink/contracts-ccip/src/v0.8/ccip/libraries/Client.sol";

import {SafeERC20} from "@chainlink/contracts-ccip/src/v0.8/vendor/openzeppelin-solidity/v4.8.0/token/ERC20/utils/SafeERC20.sol";
import {IERC20} from "@chainlink/contracts-ccip/src/v0.8/vendor/openzeppelin-solidity/v4.8.0/token/ERC20/IERC20.sol";

contract CCIPTokenProxy {
    using SafeERC20 for IERC20;

    error InvalidToken();
    error NoDataAllowed();
    error GasShouldBeZero();

    /// @notice The CCIP router contract
    IRouterClient internal immutable i_router;
    /// @notice Only this token is allowed to be sent using this proxy
    address internal immutable i_token;

    constructor(address router, address token) {
        i_router = IRouterClient(router);
        i_token = token;
        // Approve the router to spend an unlimited amount of tokens to reduce
        // gas cost per tx.
        IERC20(token).approve(router, type(uint256).max);
    }

    /// @notice Simply forwards the request to the CCIP router and returns the result.
    /// @param destinationChainSelector The destination chainSelector
    /// @param message The cross-chain CCIP message including data and/or tokens
    /// @return fee returns execution fee for the message delivery to destination chain,
    /// denominated in the feeToken specified in the message.
    /// @dev Reverts with appropriate reason upon invalid message.
    function getFee(
        uint64 destinationChainSelector,
        Client.EVM2AnyMessage calldata message
    ) external view returns (uint256 fee) {
        _validateMessage(message);
        return i_router.getFee(destinationChainSelector, message);
    }

    /// @notice Validates the message content, forwards it to the CCIP router and returns the result.
    function ccipSend(
        uint64 destinationChainSelector,
        Client.EVM2AnyMessage calldata message
    ) external payable returns (bytes32 messageId) {
        _validateMessage(message);
        if (message.feeToken != address(0)) {
            // This path is probably warmed up already so the extra cost isn't too bad.
            uint256 feeAmount = i_router.getFee(
                destinationChainSelector,
                message
            );
            IERC20(message.feeToken).safeTransferFrom(
                msg.sender,
                address(this),
                feeAmount
            );
            IERC20(message.feeToken).approve(address(i_router), feeAmount);
        }

        // Transfer the tokens from the sender to this contract.
        IERC20(message.tokenAmounts[0].token).transferFrom(
            msg.sender,
            address(this),
            message.tokenAmounts[0].amount
        );

        return
            i_router.ccipSend{value: msg.value}(
                destinationChainSelector,
                message
            );
    }

    /// @notice Validates the message content.
    /// @dev Only allows a single token to be sent, and no data.
    function _validateMessage(
        Client.EVM2AnyMessage calldata message
    ) internal view {
        if (
            message.tokenAmounts.length != 1 ||
            message.tokenAmounts[0].token != i_token
        ) revert InvalidToken();
        if (message.data.length > 0) revert NoDataAllowed();

        if (
            message.extraArgs.length == 0 ||
            bytes4(message.extraArgs) != Client.EVM_EXTRA_ARGS_V1_TAG
        ) revert GasShouldBeZero();

        if (
            abi
                .decode(message.extraArgs[4:], (Client.EVMExtraArgsV1))
                .gasLimit != 0
        ) revert GasShouldBeZero();
    }

    /// @notice Returns the CCIP router contract.
    function getRouter() external view returns (IRouterClient) {
        return i_router;
    }

    /// @notice Returns the token that this proxy is allowed to send.
    function getToken() external view returns (address) {
        return i_token;
    }
}

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

import {Client} from "../libraries/Client.sol";

interface IRouterClient {
  error UnsupportedDestinationChain(uint64 destChainSelector);
  error InsufficientFeeTokenAmount();
  error InvalidMsgValue();

  /// @notice Checks if the given chain ID is supported for sending/receiving.
  /// @param chainSelector The chain to check.
  /// @return supported is true if it is supported, false if not.
  function isChainSupported(uint64 chainSelector) external view returns (bool supported);

  /// @notice Gets a list of all supported tokens which can be sent or received
  /// to/from a given chain id.
  /// @param chainSelector The chainSelector.
  /// @return tokens The addresses of all tokens that are supported.
  function getSupportedTokens(uint64 chainSelector) external view returns (address[] memory tokens);

  /// @param destinationChainSelector The destination chainSelector
  /// @param message The cross-chain CCIP message including data and/or tokens
  /// @return fee returns guaranteed execution fee for the specified message
  /// delivery to destination chain
  /// @dev returns 0 fee on invalid message.
  function getFee(
    uint64 destinationChainSelector,
    Client.EVM2AnyMessage memory message
  ) external view returns (uint256 fee);

  /// @notice Request a message to be sent to the destination chain
  /// @param destinationChainSelector The destination chain ID
  /// @param message The cross-chain CCIP message including data and/or tokens
  /// @return messageId The message ID
  /// @dev Note if msg.value is larger than the required fee (from getFee) we accept
  /// the overpayment with no refund.
  function ccipSend(
    uint64 destinationChainSelector,
    Client.EVM2AnyMessage calldata message
  ) external payable returns (bytes32);
}

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

// End consumer library.
library Client {
  struct EVMTokenAmount {
    address token; // token address on the local chain.
    uint256 amount; // Amount of tokens.
  }

  struct Any2EVMMessage {
    bytes32 messageId; // MessageId corresponding to ccipSend on source.
    uint64 sourceChainSelector; // Source chain selector.
    bytes sender; // abi.decode(sender) if coming from an EVM chain.
    bytes data; // payload sent in original message.
    EVMTokenAmount[] destTokenAmounts; // Tokens and their amounts in their destination chain representation.
  }

  // If extraArgs is empty bytes, the default is 200k gas limit and strict = false.
  struct EVM2AnyMessage {
    bytes receiver; // abi.encode(receiver address) for dest EVM chains
    bytes data; // Data payload
    EVMTokenAmount[] tokenAmounts; // Token transfers
    address feeToken; // Address of feeToken. address(0) means you will send msg.value.
    bytes extraArgs; // Populate this with _argsToBytes(EVMExtraArgsV1)
  }

  // extraArgs will evolve to support new features
  // bytes4(keccak256("CCIP EVMExtraArgsV1"));
  bytes4 public constant EVM_EXTRA_ARGS_V1_TAG = 0x97a657c9;
  struct EVMExtraArgsV1 {
    uint256 gasLimit; // ATTENTION!!! MAX GAS LIMIT 4M FOR BETA TESTING
    bool strict; // See strict sequencing details below.
  }

  function _argsToBytes(EVMExtraArgsV1 memory extraArgs) internal pure returns (bytes memory bts) {
    return abi.encodeWithSelector(EVM_EXTRA_ARGS_V1_TAG, extraArgs);
  }
}

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.1;

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

    return account.code.length > 0;
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

{
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs",
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 7777777
  },
  "remappings": [],
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"router","type":"address"},{"internalType":"address","name":"token","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"GasShouldBeZero","type":"error"},{"inputs":[],"name":"InvalidToken","type":"error"},{"inputs":[],"name":"NoDataAllowed","type":"error"},{"inputs":[{"internalType":"uint64","name":"destinationChainSelector","type":"uint64"},{"components":[{"internalType":"bytes","name":"receiver","type":"bytes"},{"internalType":"bytes","name":"data","type":"bytes"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct Client.EVMTokenAmount[]","name":"tokenAmounts","type":"tuple[]"},{"internalType":"address","name":"feeToken","type":"address"},{"internalType":"bytes","name":"extraArgs","type":"bytes"}],"internalType":"struct Client.EVM2AnyMessage","name":"message","type":"tuple"}],"name":"ccipSend","outputs":[{"internalType":"bytes32","name":"messageId","type":"bytes32"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint64","name":"destinationChainSelector","type":"uint64"},{"components":[{"internalType":"bytes","name":"receiver","type":"bytes"},{"internalType":"bytes","name":"data","type":"bytes"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct Client.EVMTokenAmount[]","name":"tokenAmounts","type":"tuple[]"},{"internalType":"address","name":"feeToken","type":"address"},{"internalType":"bytes","name":"extraArgs","type":"bytes"}],"internalType":"struct Client.EVM2AnyMessage","name":"message","type":"tuple"}],"name":"getFee","outputs":[{"internalType":"uint256","name":"fee","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRouter","outputs":[{"internalType":"contract IRouterClient","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

0x60806040526004361061003f5760003560e01c806320487ded1461004457806321df0da71461007757806396f4e9f9146100cb578063b0f479a1146100de575b600080fd5b34801561005057600080fd5b5061006461005f366004610b86565b610111565b6040519081526020015b60405180910390f35b34801561008357600080fd5b507f00000000000000000000000094025780a1ab58868d9b2dbbb775f44b32e8e6e55b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200161006e565b6100646100d9366004610b86565b6101d8565b3480156100ea57600080fd5b507f000000000000000000000000e561d5e02207fb5eb32cca20a699e0d8919a14766100a6565b600061011c8261059d565b6040517f20487ded00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000e561d5e02207fb5eb32cca20a699e0d8919a147616906320487ded906101909086908690600401610d21565b602060405180830381865afa1580156101ad573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101d19190610e6a565b9392505050565b60006101e38261059d565b60006101f56080840160608501610e83565b73ffffffffffffffffffffffffffffffffffffffff16146103cc576040517f20487ded00000000000000000000000000000000000000000000000000000000815260009073ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000e561d5e02207fb5eb32cca20a699e0d8919a147616906320487ded906102879087908790600401610d21565b602060405180830381865afa1580156102a4573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906102c89190610e6a565b90506102fe3330836102e06080880160608901610e83565b73ffffffffffffffffffffffffffffffffffffffff169291906107c6565b61030e6080840160608501610e83565b6040517f095ea7b300000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000e561d5e02207fb5eb32cca20a699e0d8919a14768116600483015260248201849052919091169063095ea7b3906044016020604051808303816000875af11580156103a5573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906103c99190610eac565b50505b6103d96040830183610ec9565b60008181106103ea576103ea610f31565b6104009260206040909202019081019150610e83565b73ffffffffffffffffffffffffffffffffffffffff166323b872dd333061042a6040870187610ec9565b600081811061043b5761043b610f31565b6040805160e088901b7fffffffff0000000000000000000000000000000000000000000000000000000016815273ffffffffffffffffffffffffffffffffffffffff96871660048201529490951660248501529093020160200135604482015260640190506020604051808303816000875af11580156104bf573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906104e39190610eac565b506040517f96f4e9f900000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000e561d5e02207fb5eb32cca20a699e0d8919a147616906396f4e9f990349061055a9087908790600401610d21565b60206040518083038185885af1158015610578573d6000803e3d6000fd5b50505050506040513d601f19601f820116820180604052508101906101d19190610e6a565b6105aa6040820182610ec9565b9050600114158061063a575073ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000094025780a1ab58868d9b2dbbb775f44b32e8e6e5166105fa6040830183610ec9565b600081811061060b5761060b610f31565b6106219260206040909202019081019150610e83565b73ffffffffffffffffffffffffffffffffffffffff1614155b15610671576040517fc1ab6dc100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60006106806020830183610f60565b905011156106ba576040517f27eb6f2d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6106c76080820182610f60565b1590508061072c57507f97a657c9000000000000000000000000000000000000000000000000000000006106fe6080830183610f60565b61070791610fc5565b7fffffffff000000000000000000000000000000000000000000000000000000001614155b15610763576040517f6633e5f600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6107706080820182610f60565b61077e91600490829061100d565b81019061078b9190611037565b51156107c3576040517f6633e5f600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b50565b6040805173ffffffffffffffffffffffffffffffffffffffff85811660248301528416604482015260648082018490528251808303909101815260849091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f23b872dd0000000000000000000000000000000000000000000000000000000017905261085b908590610861565b50505050565b60006108c3826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166109779092919063ffffffff16565b80519091501561097257808060200190518101906108e19190610eac565b610972576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b505050565b6060610986848460008561098e565b949350505050565b606082471015610a20576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c00000000000000000000000000000000000000000000000000006064820152608401610969565b6000808673ffffffffffffffffffffffffffffffffffffffff168587604051610a4991906110d8565b60006040518083038185875af1925050503d8060008114610a86576040519150601f19603f3d011682016040523d82523d6000602084013e610a8b565b606091505b5091509150610a9c87838387610aa7565b979650505050505050565b60608315610b3d578251600003610b365773ffffffffffffffffffffffffffffffffffffffff85163b610b36576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610969565b5081610986565b6109868383815115610b525781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161096991906110f4565b60008060408385031215610b9957600080fd5b823567ffffffffffffffff8082168214610bb257600080fd5b90925060208401359080821115610bc857600080fd5b50830160a08186031215610bdb57600080fd5b809150509250929050565b60008083357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1843603018112610c1b57600080fd5b830160208101925035905067ffffffffffffffff811115610c3b57600080fd5b803603821315610c4a57600080fd5b9250929050565b8183528181602085013750600060208284010152600060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f840116840101905092915050565b803573ffffffffffffffffffffffffffffffffffffffff81168114610cbe57600080fd5b919050565b8183526000602080850194508260005b85811015610d165773ffffffffffffffffffffffffffffffffffffffff610cf983610c9a565b168752818301358388015260409687019690910190600101610cd3565b509495945050505050565b600067ffffffffffffffff808516835260406020840152610d428485610be6565b60a06040860152610d5760e086018284610c51565b915050610d676020860186610be6565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc080878503016060880152610d9d848385610c51565b9350604088013592507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1883603018312610dd657600080fd5b60209288019283019235915084821115610def57600080fd5b8160061b3603831315610e0157600080fd5b80878503016080880152610e16848385610cc3565b9450610e2460608901610c9a565b73ffffffffffffffffffffffffffffffffffffffff811660a08901529350610e4f6080890189610be6565b94509250808786030160c08801525050610a9c838383610c51565b600060208284031215610e7c57600080fd5b5051919050565b600060208284031215610e9557600080fd5b6101d182610c9a565b80151581146107c357600080fd5b600060208284031215610ebe57600080fd5b81516101d181610e9e565b60008083357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1843603018112610efe57600080fd5b83018035915067ffffffffffffffff821115610f1957600080fd5b6020019150600681901b3603821315610c4a57600080fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60008083357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1843603018112610f9557600080fd5b83018035915067ffffffffffffffff821115610fb057600080fd5b602001915036819003821315610c4a57600080fd5b7fffffffff0000000000000000000000000000000000000000000000000000000081358181169160048510156110055780818660040360031b1b83161692505b505092915050565b6000808585111561101d57600080fd5b8386111561102a57600080fd5b5050820193919092039150565b60006040828403121561104957600080fd5b6040516040810181811067ffffffffffffffff82111715611093577f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6040528235815260208301356110a881610e9e565b60208201529392505050565b60005b838110156110cf5781810151838201526020016110b7565b50506000910152565b600082516110ea8184602087016110b4565b9190910192915050565b60208152600082518060208401526111138160408501602087016110b4565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016919091016040019291505056fea26469706673582212208d6f6df3131dace3f5eafa03ac77904bc6b545c5505438d8b352ab414ca47faa64736f6c63430008110033

000000000000000000000000e561d5e02207fb5eb32cca20a699e0d8919a147600000000000000000000000094025780a1ab58868d9b2dbbb775f44b32e8e6e5

-----Decoded View---------------
Arg [0] : router (address): 0xE561d5E02207fb5eB32cca20a699E0d8919a1476
Arg [1] : token (address): 0x94025780a1aB58868D9B2dBBB775f44b32e8E6e5

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000e561d5e02207fb5eb32cca20a699e0d8919a1476
Arg [1] : 00000000000000000000000094025780a1ab58868d9b2dbbb775f44b32e8e6e5