Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

• Similar
• Compare

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.24;

import {IMessageTransmitter} from "./interfaces/IMessageTransmitter.sol";
import {ITokenMessenger} from "./interfaces/ITokenMessenger.sol";

import {Ownable2StepMsgSender} from "@chainlink/contracts/src/v0.8/shared/access/Ownable2StepMsgSender.sol";
import {ITypeAndVersion} from "@chainlink/contracts/src/v0.8/shared/interfaces/ITypeAndVersion.sol";
import {EnumerableSet} from
  "@chainlink/contracts/src/v0.8/vendor/openzeppelin-solidity/v5.0.2/contracts/utils/structs/EnumerableSet.sol";

/// @title CCTP Message Transmitter Proxy
/// @notice A proxy contract for handling messages transmitted via the Cross Chain Transfer Protocol (CCTP).
/// @dev This contract is responsible for sending messages to the `IMessageTransmitter` and ensuring only allowed callers can invoke it.
contract CCTPMessageTransmitterProxy is Ownable2StepMsgSender, ITypeAndVersion {
  using EnumerableSet for EnumerableSet.AddressSet;

  /// @notice Error thrown when a function is called by an unauthorized address.
  error Unauthorized(address caller);

  /// @notice Emitted when an allowed caller is added.
  event AllowedCallerAdded(address indexed caller);
  /// @notice Emitted when an allowed caller is removed.
  event AllowedCallerRemoved(address indexed caller);

  string public constant override typeAndVersion = "CCTPMessageTransmitterProxy 1.6.2";

  struct AllowedCallerConfigArgs {
    address caller;
    bool allowed;
  }

  /// @notice Immutable reference to the `IMessageTransmitter` contract.
  IMessageTransmitter public immutable i_cctpTransmitter;

  /// @notice Enumerable set of addresses allowed to call `receiveMessage`.
  EnumerableSet.AddressSet private s_allowedCallers;

  /// @notice One-time cyclic dependency between TokenPool and MessageTransmitter.
  constructor(
    ITokenMessenger tokenMessenger
  ) {
    i_cctpTransmitter = IMessageTransmitter(tokenMessenger.localMessageTransmitter());
  }

  /// @notice Receives a message from the `IMessageTransmitter` contract and validates it.
  /// @dev Can only be called by an allowed caller to process incoming messages.
  /// @param message The payload of the message being received.
  /// @param attestation The cryptographic proof validating the message.
  /// @return success A boolean indicating if the message was successfully processed.
  function receiveMessage(bytes calldata message, bytes calldata attestation) external returns (bool success) {
    if (!s_allowedCallers.contains(msg.sender)) {
      revert Unauthorized(msg.sender);
    }
    return i_cctpTransmitter.receiveMessage(message, attestation);
  }

  /// @notice Configures the allowed callers for the `receiveMessage` function.
  /// @param configArgs An array of `AllowedCallerConfigArgs` structs.
  function configureAllowedCallers(
    AllowedCallerConfigArgs[] calldata configArgs
  ) external onlyOwner {
    for (uint256 i = 0; i < configArgs.length; ++i) {
      if (configArgs[i].allowed) {
        if (s_allowedCallers.add(configArgs[i].caller)) {
          emit AllowedCallerAdded(configArgs[i].caller);
        }
      } else {
        if (s_allowedCallers.remove(configArgs[i].caller)) {
          emit AllowedCallerRemoved(configArgs[i].caller);
        }
      }
    }
  }

  /// @notice Checks if the caller is allowed to call the `receiveMessage` function.
  /// @param caller The address to check.
  /// @return allowed A boolean indicating if the caller is allowed.
  function isAllowedCaller(
    address caller
  ) external view returns (bool allowed) {
    return s_allowedCallers.contains(caller);
  }

  /// @notice Returns an array of all allowed callers.
  /// @return allowedCallers An array of allowed caller addresses.
  function getAllowedCallers() external view returns (address[] memory allowedCallers) {
    return s_allowedCallers.values();
  }
}

/*
 * Copyright (c) 2022, Circle Internet Financial Limited.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
pragma solidity ^0.8.0;

interface IMessageTransmitter {
  /// @notice Unlocks USDC tokens on the destination chain
  /// @param message The original message on the source chain
  ///     * Message format:
  ///     * Field                 Bytes      Type       Index
  ///     * version               4          uint32     0
  ///     * sourceDomain          4          uint32     4
  ///     * destinationDomain     4          uint32     8
  ///     * nonce                 8          uint64     12
  ///     * sender                32         bytes32    20
  ///     * recipient             32         bytes32    52
  ///     * destinationCaller     32         bytes32    84
  ///     * messageBody           dynamic    bytes      116
  /// param attestation A valid attestation is the concatenated 65-byte signature(s) of
  /// exactly `thresholdSignature` signatures, in increasing order of attester address.
  /// ***If the attester addresses recovered from signatures are not in increasing order,
  /// signature verification will fail.***
  /// If incorrect number of signatures or duplicate signatures are supplied,
  /// signature verification will fail.
  function receiveMessage(bytes calldata message, bytes calldata attestation) external returns (bool success);

  /// Returns domain of chain on which the contract is deployed.
  /// @dev immutable
  function localDomain() external view returns (uint32);

  /// Returns message format version.
  /// @dev immutable
  function version() external view returns (uint32);
}

/*
 * Copyright (c) 2022, Circle Internet Financial Limited.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
pragma solidity ^0.8.0;

interface ITokenMessenger {
  /// @notice Emitted when a DepositForBurn message is sent
  /// @param nonce Unique nonce reserved by message
  /// @param burnToken Address of token burnt on source domain
  /// @param amount Deposit amount
  /// @param depositor Address where deposit is transferred from
  /// @param mintRecipient Address receiving minted tokens on destination domain as bytes32
  /// @param destinationDomain Destination domain
  /// @param destinationTokenMessenger Address of TokenMessenger on destination domain as bytes32
  /// @param destinationCaller Authorized caller as bytes32 of receiveMessage() on destination domain,
  /// if not equal to bytes32(0). If equal to bytes32(0), any address can call receiveMessage().
  event DepositForBurn(
    uint64 indexed nonce,
    address indexed burnToken,
    uint256 amount,
    address indexed depositor,
    bytes32 mintRecipient,
    uint32 destinationDomain,
    bytes32 destinationTokenMessenger,
    bytes32 destinationCaller
  );

  /// @notice Burns the tokens on the source side to produce a nonce through
  /// Circles Cross Chain Transfer Protocol.
  /// @param amount Amount of tokens to deposit and burn.
  /// @param destinationDomain Destination domain identifier.
  /// @param mintRecipient Address of mint recipient on destination domain.
  /// @param burnToken Address of contract to burn deposited tokens, on local domain.
  /// @param destinationCaller Caller on the destination domain, as bytes32.
  /// @return nonce The unique nonce used in unlocking the funds on the destination chain.
  /// @dev emits DepositForBurn
  function depositForBurnWithCaller(
    uint256 amount,
    uint32 destinationDomain,
    bytes32 mintRecipient,
    address burnToken,
    bytes32 destinationCaller
  ) external returns (uint64 nonce);

  /// Returns the version of the message body format.
  /// @dev immutable
  function messageBodyVersion() external view returns (uint32);

  /// Returns local Message Transmitter responsible for sending and receiving messages
  /// to/from remote domainsmessage transmitter for this token messenger.
  /// @dev immutable
  function localMessageTransmitter() external view returns (address);
}

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

import {IOwnable} from "../interfaces/IOwnable.sol";

/// @notice A minimal contract that implements 2-step ownership transfer and nothing more. It's made to be minimal
/// to reduce the impact of the bytecode size on any contract that inherits from it.
contract Ownable2Step is IOwnable {
  /// @notice The pending owner is the address to which ownership may be transferred.
  address private s_pendingOwner;
  /// @notice The owner is the current owner of the contract.
  /// @dev The owner is the second storage variable so any implementing contract could pack other state with it
  /// instead of the much less used s_pendingOwner.
  address private s_owner;

  error OwnerCannotBeZero();
  error MustBeProposedOwner();
  error CannotTransferToSelf();
  error OnlyCallableByOwner();

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

  constructor(address newOwner, address pendingOwner) {
    if (newOwner == address(0)) {
      revert OwnerCannotBeZero();
    }

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

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

  /// @notice Allows an owner to begin transferring ownership to a new address. The new owner needs to call
  /// `acceptOwnership` to accept the transfer before any permissions are changed.
  /// @param to The address to which ownership will be transferred.
  function transferOwnership(address to) public override onlyOwner {
    _transferOwnership(to);
  }

  /// @notice validate, transfer ownership, and emit relevant events
  /// @param to The address to which ownership will be transferred.
  function _transferOwnership(address to) private {
    if (to == msg.sender) {
      revert CannotTransferToSelf();
    }

    s_pendingOwner = to;

    emit OwnershipTransferRequested(s_owner, to);
  }

  /// @notice Allows an ownership transfer to be completed by the recipient.
  function acceptOwnership() external override {
    if (msg.sender != s_pendingOwner) {
      revert MustBeProposedOwner();
    }

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

    emit OwnershipTransferred(oldOwner, msg.sender);
  }

  /// @notice validate access
  function _validateOwnership() internal view {
    if (msg.sender != s_owner) {
      revert OnlyCallableByOwner();
    }
  }

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

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

import {Ownable2Step} from "./Ownable2Step.sol";

/// @notice Sets the msg.sender to be the owner of the contract and does not set a pending owner.
contract Ownable2StepMsgSender is Ownable2Step {
  constructor() Ownable2Step(msg.sender, address(0)) {}
}

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

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

  function transferOwnership(address recipient) external;

  function acceptOwnership() external;
}

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

interface ITypeAndVersion {
  function typeAndVersion() external pure returns (string memory);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position is the index of the value in the `values` array plus 1.
        // Position 0 is used to mean a value is not in the set.
        mapping(bytes32 value => uint256) _positions;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._positions[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We cache the value's position to prevent multiple reads from the same storage slot
        uint256 position = set._positions[value];

        if (position != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 valueIndex = position - 1;
            uint256 lastIndex = set._values.length - 1;

            if (valueIndex != lastIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the lastValue to the index where the value to delete is
                set._values[valueIndex] = lastValue;
                // Update the tracked position of the lastValue (that was just moved)
                set._positions[lastValue] = position;
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the tracked position for the deleted slot
            delete set._positions[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._positions[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

{
  "evmVersion": "paris",
  "metadata": {
    "appendCBOR": true,
    "bytecodeHash": "none",
    "useLiteralContent": false
  },
  "optimizer": {
    "enabled": true,
    "runs": 80000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "remappings": [
    "forge-std/=node_modules/@chainlink/contracts/src/v0.8/vendor/forge-std/src/",
    "@chainlink/contracts/=node_modules/@chainlink/contracts/"
  ],
  "viaIR": true
}

[{"inputs":[{"internalType":"contract ITokenMessenger","name":"tokenMessenger","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"CannotTransferToSelf","type":"error"},{"inputs":[],"name":"MustBeProposedOwner","type":"error"},{"inputs":[],"name":"OnlyCallableByOwner","type":"error"},{"inputs":[],"name":"OwnerCannotBeZero","type":"error"},{"inputs":[{"internalType":"address","name":"caller","type":"address"}],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"}],"name":"AllowedCallerAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"}],"name":"AllowedCallerRemoved","type":"event"},{"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":[{"components":[{"internalType":"address","name":"caller","type":"address"},{"internalType":"bool","name":"allowed","type":"bool"}],"internalType":"struct CCTPMessageTransmitterProxy.AllowedCallerConfigArgs[]","name":"configArgs","type":"tuple[]"}],"name":"configureAllowedCallers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAllowedCallers","outputs":[{"internalType":"address[]","name":"allowedCallers","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"i_cctpTransmitter","outputs":[{"internalType":"contract IMessageTransmitter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"caller","type":"address"}],"name":"isAllowedCaller","outputs":[{"internalType":"bool","name":"allowed","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"message","type":"bytes"},{"internalType":"bytes","name":"attestation","type":"bytes"}],"name":"receiveMessage","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"typeAndVersion","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000009f3b8679c73c2fef8b59b4f3444d4e156fb70aa5

-----Decoded View---------------
Arg [0] : tokenMessenger (address): 0x9f3B8679c73C2Fef8b59B4f3444d4e156fb70AA5

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000009f3b8679c73c2fef8b59b4f3444d4e156fb70aa5