Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library Client
•    - function _argsToBytes(EVMExtraArgsV1 ...
• interface IRouterClient
•    - function isChainSupported(uint64 chai ...
•    - function getSupportedTokens(uint64 ch ...
•    - function getFee(
•    - function ccipSend(
• interface IOwnable
•    - function owner()
•    - function transferOwnership(address re ...
•    - function acceptOwnership()
•  contract ConfirmedOwnerWithProposa ...
•    - function transferOwnership(address to ...
•    - function acceptOwnership()
•    - function owner()
•    - function _transferOwnership(address t ...
•    - function _validateOwnership()
•  contract ConfirmedOwner is Confirm ...
•  contract OwnerIsCreator is Confirm ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(
•    - function _revert(bytes memory returnd ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function safePermit(
•    - function _callOptionalReturn(IERC20 t ...
•  contract TokenProxy is OwnerIsCrea ... *
•    - function getFee(
•    - function ccipSend(
•    - function _validateMessage(Client.EVM2 ...
•    - function getRouter()
•    - function getToken()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-09-14
*/

// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

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

  // bytes4(keccak256("CCIP EVMExtraArgsV1"));
  bytes4 public constant EVM_EXTRA_ARGS_V1_TAG = 0x97a657c9;
  struct EVMExtraArgsV1 {
    uint256 gasLimit;
  }

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

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 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 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.
  /// @dev Reverts with appropriate reason upon invalid message.
  function ccipSend(
    uint64 destinationChainSelector,
    Client.EVM2AnyMessage calldata message
  ) external payable returns (bytes32);
}

interface IOwnable {
  function owner() external returns (address);

  function transferOwnership(address recipient) external;

  function acceptOwnership() external;
}

/**
 * @title The ConfirmedOwner contract
 * @notice A contract with helpers for basic contract ownership.
 */
contract ConfirmedOwnerWithProposal is IOwnable {
  address private s_owner;
  address private s_pendingOwner;

  event OwnershipTransferRequested(address indexed from, address indexed to);
  event OwnershipTransferred(address indexed from, address indexed to);

  constructor(address newOwner, address pendingOwner) {
    require(newOwner != address(0), "Cannot set owner to zero");

    s_owner = newOwner;
    if (pendingOwner != address(0)) {
      _transferOwnership(pendingOwner);
    }
  }

  /**
   * @notice Allows an owner to begin transferring ownership to a new address,
   * pending.
   */
  function transferOwnership(address to) public override onlyOwner {
    _transferOwnership(to);
  }

  /**
   * @notice Allows an ownership transfer to be completed by the recipient.
   */
  function acceptOwnership() external override {
    require(msg.sender == s_pendingOwner, "Must be proposed owner");

    address oldOwner = s_owner;
    s_owner = msg.sender;
    s_pendingOwner = address(0);

    emit OwnershipTransferred(oldOwner, msg.sender);
  }

  /**
   * @notice Get the current owner
   */
  function owner() public view override returns (address) {
    return s_owner;
  }

  /**
   * @notice validate, transfer ownership, and emit relevant events
   */
  function _transferOwnership(address to) private {
    require(to != msg.sender, "Cannot transfer to self");

    s_pendingOwner = to;

    emit OwnershipTransferRequested(s_owner, to);
  }

  /**
   * @notice validate access
   */
  function _validateOwnership() internal view {
    require(msg.sender == s_owner, "Only callable by owner");
  }

  /**
   * @notice Reverts if called by anyone other than the contract owner.
   */
  modifier onlyOwner() {
    _validateOwnership();
    _;
  }
}

/**
 * @title The ConfirmedOwner contract
 * @notice A contract with helpers for basic contract ownership.
 */
contract ConfirmedOwner is ConfirmedOwnerWithProposal {
  constructor(address newOwner) ConfirmedOwnerWithProposal(newOwner, address(0)) {}
}

/// @title The OwnerIsCreator contract
/// @notice A contract with helpers for basic contract ownership.
contract OwnerIsCreator is ConfirmedOwner {
  constructor() ConfirmedOwner(msg.sender) {}
}

// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

/**
 * @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);
}

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

/**
 * @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);
}

// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

/**
 * @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);
    }
  }
}

/**
 * @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");
    }
  }
}

contract TokenProxy is OwnerIsCreator {
  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) OwnerIsCreator() {
    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;
  }
}

• 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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"OwnershipTransferRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","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":"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"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000e561d5e02207fb5eb32cca20a699e0d8919a1476000000000000000000000000183015a9ba6ff60230fdeadc3f43b3d788b13e21

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

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000e561d5e02207fb5eb32cca20a699e0d8919a1476
Arg [1] : 000000000000000000000000183015a9ba6ff60230fdeadc3f43b3d788b13e21

23368:3184:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24461:242;;;;;;;;;;-1:-1:-1;24461:242:0;;;;;:::i;:::-;;:::i;:::-;;;734:25:1;;;722:2;707:18;24461:242:0;;;;;;;;26470:79;;;;;;;;;;-1:-1:-1;26536:7:0;26470:79;;;-1:-1:-1;;;;;1043:32:1;;;1025:51;;1013:2;998:18;26470:79:0;879:203:1;4410:273:0;;;;;;;;;;;;;:::i;:::-;;4739:83;;;;;;;;;;-1:-1:-1;4786:7:0;4809;-1:-1:-1;;;;;4809:7:0;4739:83;;24810:826;;;;;;:::i;:::-;;:::i;26308:87::-;;;;;;;;;;-1:-1:-1;26381:8:0;26308:87;;4213:100;;;;;;;;;;-1:-1:-1;4213:100:0;;;;;:::i;:::-;;:::i;24461:242::-;24588:11;24608:25;24625:7;24608:16;:25::i;:::-;24647:50;;-1:-1:-1;;;24647:50:0;;-1:-1:-1;;;;;24647:8:0;:15;;;;:50;;24663:24;;24689:7;;24647:50;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24640:57;24461:242;-1:-1:-1;;;24461:242:0:o;4410:273::-;4484:14;;-1:-1:-1;;;;;4484:14:0;4470:10;:28;4462:63;;;;-1:-1:-1;;;4462:63:0;;5414:2:1;4462:63:0;;;5396:21:1;5453:2;5433:18;;;5426:30;-1:-1:-1;;;5472:18:1;;;5465:52;5534:18;;4462:63:0;;;;;;;;;4534:16;4553:7;;4577:10;-1:-1:-1;;;;;;4567:20:0;;;;;;;-1:-1:-1;4594:27:0;;;;;;;4635:42;;-1:-1:-1;;;;;4553:7:0;;;;4577:10;;4553:7;;4635:42;;;4455:228;4410:273::o;24810:826::-;24942:17;24968:25;24985:7;24968:16;:25::i;:::-;25032:1;25004:16;;;;;;;;:::i;:::-;-1:-1:-1;;;;;25004:30:0;;25000:365;;25148:50;;-1:-1:-1;;;25148:50:0;;25128:17;;-1:-1:-1;;;;;25148:8:0;:15;;;;:50;;25164:24;;25190:7;;25148:50;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25128:70;-1:-1:-1;25207:79:0;25249:10;25269:4;25128:70;25214:16;;;;;;;;:::i;:::-;-1:-1:-1;;;;;25207:41:0;;:79;;:41;:79::i;:::-;25302:16;;;;;;;;:::i;:::-;25295:62;;-1:-1:-1;;;25295:62:0;;-1:-1:-1;;;;;25336:8:0;5755:32:1;;25295:62:0;;;5737:51:1;5804:18;;;5797:34;;;25295:32:0;;;;;;;5710:18:1;;25295:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;25036:329;25000:365;25442:20;;;;:7;:20;:::i;:::-;25463:1;25442:23;;;;;;;:::i;:::-;:29;;;:23;;;;;:29;;;;-1:-1:-1;25442:29:0;:::i;:::-;-1:-1:-1;;;;;25435:50:0;;25486:10;25506:4;25513:20;;;;:7;:20;:::i;:::-;25534:1;25513:23;;;;;;;:::i;:::-;;25435:109;;;;;;-1:-1:-1;;;;;;25435:109:0;;;-1:-1:-1;;;;;7095:15:1;;;25435:109:0;;;7077:34:1;7147:15;;;;7127:18;;;7120:43;25513:23:0;;;;:30;;;7179:18:1;;;7172:34;7012:18;;;-1:-1:-1;25435:109:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;25560:70:0;;-1:-1:-1;;;25560:70:0;;-1:-1:-1;;;;;25560:8:0;:17;;;;25585:9;;25560:70;;25596:24;;25622:7;;25560:70;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;4213:100::-;5389:20;:18;:20::i;:::-;4285:22:::1;4304:2;4285:18;:22::i;:::-;4213:100:::0;:::o;25752:501::-;25843:20;;;;:7;:20;:::i;:::-;:27;;25874:1;25843:32;;:76;;;-1:-1:-1;;;;;;25912:7:0;25879:40;:20;;;;:7;:20;:::i;:::-;25900:1;25879:23;;;;;;;:::i;:::-;:29;;;:23;;;;;:29;;;;-1:-1:-1;25879:29:0;:::i;:::-;-1:-1:-1;;;;;25879:40:0;;;25843:76;25839:103;;;25928:14;;-1:-1:-1;;;25928:14:0;;;;;;;;;;;25839:103;25975:1;25953:12;;;;:7;:12;:::i;:::-;:19;;:23;25949:51;;;25985:15;;-1:-1:-1;;;25985:15:0;;;;;;;;;;;25949:51;26013:17;;;;:7;:17;:::i;:::-;:29;;-1:-1:-1;26013:29:0;:90;;-1:-1:-1;;;;26053:17:0;;;;:7;:17;:::i;:::-;26046:25;;;:::i;:::-;-1:-1:-1;;;;;;26046:57:0;;;26013:90;26009:127;;;26119:17;;-1:-1:-1;;;26119:17:0;;;;;;;;;;;26009:127;26160:17;;;;:7;:17;:::i;:::-;:21;;26178:1;;26160:21;;;:::i;:::-;26149:58;;;;;;;:::i;:::-;:67;:72;26145:102;;26230:17;;-1:-1:-1;;;26230:17:0;;;;;;;;;;;20156:199;20280:68;;;-1:-1:-1;;;;;7095:15:1;;;20280:68:0;;;7077:34:1;7147:15;;7127:18;;;7120:43;7179:18;;;;7172:34;;;20280:68:0;;;;;;;;;;7012:18:1;;;;20280:68:0;;;;;;;;-1:-1:-1;;;;;20280:68:0;-1:-1:-1;;;20280:68:0;;;20253:96;;20273:5;;20253:19;:96::i;:::-;20156:199;;;;:::o;5155:113::-;5228:7;;-1:-1:-1;;;;;5228:7:0;5214:10;:21;5206:56;;;;-1:-1:-1;;;5206:56:0;;9343:2:1;5206:56:0;;;9325:21:1;9382:2;9362:18;;;9355:30;-1:-1:-1;;;9401:18:1;;;9394:52;9463:18;;5206:56:0;9141:346:1;5206:56:0;5155:113::o;4911:194::-;4980:10;-1:-1:-1;;;;;4974:16:0;;;4966:52;;;;-1:-1:-1;;;4966:52:0;;9694:2:1;4966:52:0;;;9676:21:1;9733:2;9713:18;;;9706:30;9772:25;9752:18;;;9745:53;9815:18;;4966:52:0;9492:347:1;4966:52:0;5027:14;:19;;-1:-1:-1;;;;;;5027:19:0;-1:-1:-1;;;;;5027:19:0;;;;;;;;;-1:-1:-1;5087:7:0;;5060:39;;5027:19;;5087:7;;5060:39;;-1:-1:-1;5060:39:0;4911:194;:::o;22683:678::-;23091:23;23117:69;23145:4;23117:69;;;;;;;;;;;;;;;;;23125:5;-1:-1:-1;;;;;23117:27:0;;;:69;;;;;:::i;:::-;23197:17;;23091:95;;-1:-1:-1;23197:21:0;23193:163;;23282:10;23271:30;;;;;;;;;;;;:::i;:::-;23263:85;;;;-1:-1:-1;;;23263:85:0;;10046:2:1;23263:85:0;;;10028:21:1;10085:2;10065:18;;;10058:30;10124:34;10104:18;;;10097:62;-1:-1:-1;;;10175:18:1;;;10168:40;10225:19;;23263:85:0;9844:406:1;23263:85:0;22753:608;22683:678;;:::o;14499:189::-;14602:12;14630:52;14652:6;14660:4;14666:1;14669:12;14630:21;:52::i;:::-;14623:59;14499:189;-1:-1:-1;;;;14499:189:0:o;15501:423::-;15653:12;15707:5;15682:21;:30;;15674:81;;;;-1:-1:-1;;;15674:81:0;;10457:2:1;15674:81:0;;;10439:21:1;10496:2;10476:18;;;10469:30;10535:34;10515:18;;;10508:62;-1:-1:-1;;;10586:18:1;;;10579:36;10632:19;;15674:81:0;10255:402:1;15674:81:0;15763:12;15777:23;15804:6;-1:-1:-1;;;;;15804:11:0;15823:5;15830:4;15804:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15762:73;;;;15849:69;15876:6;15884:7;15893:10;15905:12;15849:26;:69::i;:::-;15842:76;15501:423;-1:-1:-1;;;;;;;15501:423:0:o;17912:564::-;18079:12;18104:7;18100:371;;;18126:10;:17;18147:1;18126:22;18122:260;;-1:-1:-1;;;;;12145:19:0;;;18312:60;;;;-1:-1:-1;;;18312:60:0;;11411:2:1;18312:60:0;;;11393:21:1;11450:2;11430:18;;;11423:30;11489:31;11469:18;;;11462:59;11538:18;;18312:60:0;11209:353:1;18312:60:0;-1:-1:-1;18397:10:0;18390:17;;18100:371;18430:33;18438:10;18450:12;19115:17;;:21;19111:334;;19321:10;19315:17;19370:15;19357:10;19353:2;19349:19;19342:44;19111:334;19424:12;19417:20;;-1:-1:-1;;;19417:20:0;;;;;;;;:::i;14:569:1:-;113:6;121;174:2;162:9;153:7;149:23;145:32;142:52;;;190:1;187;180:12;142:52;229:9;216:23;258:18;316:2;309:5;305:14;298:5;295:25;285:53;;334:1;331;324:12;285:53;357:5;;-1:-1:-1;413:2:1;398:18;;385:32;;429:14;;;426:34;;;456:1;453;446:12;426:34;-1:-1:-1;479:22:1;;535:3;517:16;;;513:26;510:46;;;552:1;549;542:12;510:46;575:2;565:12;;;14:569;;;;;:::o;1498:173::-;1566:20;;-1:-1:-1;;;;;1615:31:1;;1605:42;;1595:70;;1661:1;1658;1651:12;1595:70;1498:173;;;:::o;1676:186::-;1735:6;1788:2;1776:9;1767:7;1763:23;1759:32;1756:52;;;1804:1;1801;1794:12;1756:52;1827:29;1846:9;1827:29;:::i;1867:500::-;1925:5;1932:6;1992:3;1979:17;2078:2;2074:7;2063:8;2047:14;2043:29;2039:43;2019:18;2015:68;2005:96;;2097:1;2094;2087:12;2005:96;2125:33;;2229:4;2216:18;;;-1:-1:-1;2177:21:1;;-1:-1:-1;2257:18:1;2246:30;;2243:50;;;2289:1;2286;2279:12;2243:50;2336:6;2320:14;2316:27;2309:5;2305:39;2302:59;;;2357:1;2354;2347:12;2302:59;1867:500;;;;;:::o;2372:266::-;2460:6;2455:3;2448:19;2512:6;2505:5;2498:4;2493:3;2489:14;2476:43;-1:-1:-1;2564:1:1;2539:16;;;2557:4;2535:27;;;2528:38;;;;2620:2;2599:15;;;-1:-1:-1;;2595:29:1;2586:39;;;2582:50;;2372:266::o;2643:561::-;2766:6;2761:3;2754:19;2736:3;2792:4;2821:2;2816:3;2812:12;2805:19;;2847:5;2870:1;2880:299;2894:6;2891:1;2888:13;2880:299;;;-1:-1:-1;;;;;2959:26:1;2978:6;2959:26;:::i;:::-;2955:52;2943:65;;3055:15;;;3042:29;3028:12;;;3021:51;3095:4;3119:12;;;;3154:15;;;;2916:1;2909:9;2880:299;;;-1:-1:-1;3195:3:1;;2643:561;-1:-1:-1;;;;;2643:561:1:o;3209:1809::-;3389:4;3418:18;3475:2;3467:6;3463:15;3452:9;3445:34;3515:2;3510;3499:9;3495:18;3488:30;3561:46;3600:6;3592;3561:46;:::i;:::-;3643:4;3638:2;3627:9;3623:18;3616:32;3671:74;3740:3;3729:9;3725:19;3711:12;3697;3671:74;:::i;:::-;3657:88;;;3792:55;3843:2;3835:6;3831:15;3823:6;3792:55;:::i;:::-;3870:2;3866:7;3937:2;3925:9;3917:6;3913:22;3909:31;3904:2;3893:9;3889:18;3882:59;3964:65;4022:6;4006:14;3990;3964:65;:::i;:::-;3950:79;;4089:2;4081:6;4077:15;4064:29;4038:55;;4173:2;4169:7;4160:6;4144:14;4140:27;4136:41;4116:18;4112:66;4102:94;;4192:1;4189;4182:12;4102:94;4326:2;4218:31;;;4315:14;;;;4272:19;;-1:-1:-1;4341:14:1;;;4338:34;;;4368:1;4365;4358:12;4338:34;4424:6;4421:1;4417:14;4401;4397:35;4388:7;4384:49;4381:69;;;4446:1;4443;4436:12;4381:69;4515:2;4503:9;4495:6;4491:22;4487:31;4481:3;4470:9;4466:19;4459:60;4542:85;4620:6;4612;4603:7;4542:85;:::i;:::-;4528:99;;4658:35;4689:2;4681:6;4677:15;4658:35;:::i;:::-;-1:-1:-1;;;;;836:31:1;;4752:4;4737:20;;824:44;4636:57;-1:-1:-1;4805:56:1;4856:3;4848:6;4844:16;4836:6;4805:56;:::i;:::-;4767:94;;;;4926:2;4914:9;4906:6;4902:22;4898:31;4892:3;4881:9;4877:19;4870:60;;;4947:65;5005:6;4989:14;4973;4947:65;:::i;5023:184::-;5093:6;5146:2;5134:9;5125:7;5121:23;5117:32;5114:52;;;5162:1;5159;5152:12;5114:52;-1:-1:-1;5185:16:1;;5023:184;-1:-1:-1;5023:184:1:o;5842:277::-;5909:6;5962:2;5950:9;5941:7;5937:23;5933:32;5930:52;;;5978:1;5975;5968:12;5930:52;6010:9;6004:16;6063:5;6056:13;6049:21;6042:5;6039:32;6029:60;;6085:1;6082;6075:12;6124:576;6248:4;6254:6;6314:11;6301:25;6408:2;6404:7;6393:8;6377:14;6373:29;6369:43;6349:18;6345:68;6335:96;;6427:1;6424;6417:12;6335:96;6454:33;;6506:20;;;-1:-1:-1;6549:18:1;6538:30;;6535:50;;;6581:1;6578;6571:12;6535:50;6614:4;6602:17;;-1:-1:-1;6665:1:1;6661:14;;;6645;6641:35;6631:46;;6628:66;;;6690:1;6687;6680:12;6705:127;6766:10;6761:3;6757:20;6754:1;6747:31;6797:4;6794:1;6787:15;6821:4;6818:1;6811:15;7406:521;7483:4;7489:6;7549:11;7536:25;7643:2;7639:7;7628:8;7612:14;7608:29;7604:43;7584:18;7580:68;7570:96;;7662:1;7659;7652:12;7570:96;7689:33;;7741:20;;;-1:-1:-1;7784:18:1;7773:30;;7770:50;;;7816:1;7813;7806:12;7770:50;7849:4;7837:17;;-1:-1:-1;7880:14:1;7876:27;;;7866:38;;7863:58;;;7917:1;7914;7907:12;7932:323;-1:-1:-1;;;;;;8052:19:1;;8128:11;;;;8159:1;8151:10;;8148:101;;;8236:2;8230;8223:3;8220:1;8216:11;8213:1;8209:19;8205:28;8201:2;8197:37;8193:46;8184:55;;8148:101;;;7932:323;;;;:::o;8260:331::-;8365:9;8376;8418:8;8406:10;8403:24;8400:44;;;8440:1;8437;8430:12;8400:44;8469:6;8459:8;8456:20;8453:40;;;8489:1;8486;8479:12;8453:40;-1:-1:-1;;8515:23:1;;;8560:25;;;;;-1:-1:-1;8260:331:1:o;8596:540::-;8685:6;8738:2;8726:9;8717:7;8713:23;8709:32;8706:52;;;8754:1;8751;8744:12;8706:52;8787:2;8781:9;8829:2;8821:6;8817:15;8898:6;8886:10;8883:22;8862:18;8850:10;8847:34;8844:62;8841:185;;;8948:10;8943:3;8939:20;8936:1;8929:31;8983:4;8980:1;8973:15;9011:4;9008:1;9001:15;8841:185;9042:2;9035:22;9081:23;;9066:39;;-1:-1:-1;9073:6:1;8596:540;-1:-1:-1;8596:540:1:o;10662:250::-;10747:1;10757:113;10771:6;10768:1;10765:13;10757:113;;;10847:11;;;10841:18;10828:11;;;10821:39;10793:2;10786:10;10757:113;;;-1:-1:-1;;10904:1:1;10886:16;;10879:27;10662:250::o;10917:287::-;11046:3;11084:6;11078:13;11100:66;11159:6;11154:3;11147:4;11139:6;11135:17;11100:66;:::i;:::-;11182:16;;;;;10917:287;-1:-1:-1;;10917:287:1:o;11567:396::-;11716:2;11705:9;11698:21;11679:4;11748:6;11742:13;11791:6;11786:2;11775:9;11771:18;11764:34;11807:79;11879:6;11874:2;11863:9;11859:18;11854:2;11846:6;11842:15;11807:79;:::i;:::-;11947:2;11926:15;-1:-1:-1;;11922:29:1;11907:45;;;;11954:2;11903:54;;11567:396;-1:-1:-1;;11567:396:1:o

ipfs://16a90721c2c1f4cd387add172e73915f4089df344c992e3200700b4f71e79559