Sepolia Testnet

Contract

0x72de35dC43acfC49B6B21e559F8cA586e0E12011

Overview

ETH Balance

0 ETH

Token Holdings

Multichain Info

N/A
Transaction Hash
Method
Block
From
To
Forward77237102025-02-17 1:38:0022 mins ago1739756280IN
0x72de35dC...6e0E12011
0 ETH0.000589565.77213777
Forward77236882025-02-17 1:33:3626 mins ago1739756016IN
0x72de35dC...6e0E12011
0 ETH0.000876748.57778424
Forward77236712025-02-17 1:30:0030 mins ago1739755800IN
0x72de35dC...6e0E12011
0 ETH0.0011851611.59753318
Forward77235892025-02-17 1:13:2447 mins ago1739754804IN
0x72de35dC...6e0E12011
0 ETH0.000501394.90899173
Forward77235772025-02-17 1:10:1250 mins ago1739754612IN
0x72de35dC...6e0E12011
0 ETH0.000441274.30965726
Forward77234232025-02-17 0:39:121 hr ago1739752752IN
0x72de35dC...6e0E12011
0 ETH0.000277682.73712808
Forward77234052025-02-17 0:35:241 hr ago1739752524IN
0x72de35dC...6e0E12011
0 ETH0.0002872.80998867
Forward77231202025-02-16 23:37:002 hrs ago1739749020IN
0x72de35dC...6e0E12011
0 ETH0.000261292.55819849
Forward77229652025-02-16 23:05:002 hrs ago1739747100IN
0x72de35dC...6e0E12011
0 ETH0.000207822.03280649
Forward77226912025-02-16 22:08:243 hrs ago1739743704IN
0x72de35dC...6e0E12011
0 ETH0.000255162.49853174
Forward77225432025-02-16 21:36:124 hrs ago1739741772IN
0x72de35dC...6e0E12011
0 ETH0.00020762.0320682
Forward77224532025-02-16 21:18:004 hrs ago1739740680IN
0x72de35dC...6e0E12011
0 ETH0.000201581.9870214
Forward77222282025-02-16 20:31:365 hrs ago1739737896IN
0x72de35dC...6e0E12011
0 ETH0.000266332.6057527
Forward77221162025-02-16 20:08:245 hrs ago1739736504IN
0x72de35dC...6e0E12011
0 ETH0.000202841.99594297
Forward77218682025-02-16 19:16:486 hrs ago1739733408IN
0x72de35dC...6e0E12011
0 ETH0.000224422.19549225
Forward77216492025-02-16 18:31:007 hrs ago1739730660IN
0x72de35dC...6e0E12011
0 ETH0.000225132.20422996
Forward77215122025-02-16 18:02:487 hrs ago1739728968IN
0x72de35dC...6e0E12011
0 ETH0.000220892.16267405
Forward77214442025-02-16 17:48:128 hrs ago1739728092IN
0x72de35dC...6e0E12011
0 ETH0.000131191.28461654
Forward77207022025-02-16 15:14:4810 hrs ago1739718888IN
0x72de35dC...6e0E12011
0 ETH0.000223092.18268477
Forward77206592025-02-16 15:06:0010 hrs ago1739718360IN
0x72de35dC...6e0E12011
0 ETH0.00027512.68652806
Forward77204692025-02-16 14:26:2411 hrs ago1739715984IN
0x72de35dC...6e0E12011
0 ETH0.000261092.55207999
Forward77204232025-02-16 14:17:0011 hrs ago1739715420IN
0x72de35dC...6e0E12011
0 ETH0.000111271.08930636
Forward77203672025-02-16 14:05:2411 hrs ago1739714724IN
0x72de35dC...6e0E12011
0 ETH0.000218452.13358043
Forward77202712025-02-16 13:45:0012 hrs ago1739713500IN
0x72de35dC...6e0E12011
0 ETH0.00020391.99681103
Forward77201792025-02-16 13:26:0012 hrs ago1739712360IN
0x72de35dC...6e0E12011
0 ETH0.000254872.4924818
View all transactions

Latest 25 internal transactions (View All)

Advanced mode:
Parent Transaction Hash Block
From
To
77237102025-02-17 1:38:0022 mins ago1739756280
0x72de35dC...6e0E12011
0 ETH
77236882025-02-17 1:33:3626 mins ago1739756016
0x72de35dC...6e0E12011
0 ETH
77236712025-02-17 1:30:0030 mins ago1739755800
0x72de35dC...6e0E12011
0 ETH
77235892025-02-17 1:13:2447 mins ago1739754804
0x72de35dC...6e0E12011
0 ETH
77235772025-02-17 1:10:1250 mins ago1739754612
0x72de35dC...6e0E12011
0 ETH
77234232025-02-17 0:39:121 hr ago1739752752
0x72de35dC...6e0E12011
0 ETH
77234052025-02-17 0:35:241 hr ago1739752524
0x72de35dC...6e0E12011
0 ETH
77231202025-02-16 23:37:002 hrs ago1739749020
0x72de35dC...6e0E12011
0 ETH
77229652025-02-16 23:05:002 hrs ago1739747100
0x72de35dC...6e0E12011
0 ETH
77226912025-02-16 22:08:243 hrs ago1739743704
0x72de35dC...6e0E12011
0 ETH
77225432025-02-16 21:36:124 hrs ago1739741772
0x72de35dC...6e0E12011
0 ETH
77224532025-02-16 21:18:004 hrs ago1739740680
0x72de35dC...6e0E12011
0 ETH
77222282025-02-16 20:31:365 hrs ago1739737896
0x72de35dC...6e0E12011
0 ETH
77221162025-02-16 20:08:245 hrs ago1739736504
0x72de35dC...6e0E12011
0 ETH
77218682025-02-16 19:16:486 hrs ago1739733408
0x72de35dC...6e0E12011
0 ETH
77216492025-02-16 18:31:007 hrs ago1739730660
0x72de35dC...6e0E12011
0 ETH
77215122025-02-16 18:02:487 hrs ago1739728968
0x72de35dC...6e0E12011
0 ETH
77214442025-02-16 17:48:128 hrs ago1739728092
0x72de35dC...6e0E12011
0 ETH
77207022025-02-16 15:14:4810 hrs ago1739718888
0x72de35dC...6e0E12011
0 ETH
77206592025-02-16 15:06:0010 hrs ago1739718360
0x72de35dC...6e0E12011
0 ETH
77204692025-02-16 14:26:2411 hrs ago1739715984
0x72de35dC...6e0E12011
0 ETH
77204232025-02-16 14:17:0011 hrs ago1739715420
0x72de35dC...6e0E12011
0 ETH
77203672025-02-16 14:05:2411 hrs ago1739714724
0x72de35dC...6e0E12011
0 ETH
77202712025-02-16 13:45:0012 hrs ago1739713500
0x72de35dC...6e0E12011
0 ETH
77201792025-02-16 13:26:0012 hrs ago1739712360
0x72de35dC...6e0E12011
0 ETH
View All Internal Transactions
Loading...
Loading

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0xfa2a7Ef2...0dC363690
The constructor portion of the code might be different and could alter the actual behaviour of the contract

Contract Name:
AuthorizedForwarder

Compiler Version
v0.7.6+commit.7338295f

Optimization Enabled:
Yes with 1000 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity Standard Json-Input format)

File 1 of 9 : AuthorizedForwarder.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

import "./interfaces/OperatorInterface.sol";
import "./ConfirmedOwnerWithProposal.sol";
import "./AuthorizedReceiver.sol";
import "./vendor/Address.sol";

contract AuthorizedForwarder is ConfirmedOwnerWithProposal, AuthorizedReceiver {
  using Address for address;

  address public immutable getChainlinkToken;

  event OwnershipTransferRequestedWithMessage(address indexed from, address indexed to, bytes message);

  constructor(
    address link,
    address owner,
    address recipient,
    bytes memory message
  ) ConfirmedOwnerWithProposal(owner, recipient) {
    require(link != address(0));
    getChainlinkToken = link;
    if (recipient != address(0)) {
      emit OwnershipTransferRequestedWithMessage(owner, recipient, message);
    }
  }

  /**
   * @notice The type and version of this contract
   * @return Type and version string
   */
  function typeAndVersion() external pure virtual returns (string memory) {
    return "AuthorizedForwarder 1.0.0";
  }

  /**
   * @notice Forward a call to another contract
   * @dev Only callable by an authorized sender
   * @param to address
   * @param data to forward
   */
  function forward(address to, bytes calldata data) external validateAuthorizedSender {
    require(to != getChainlinkToken, "Cannot forward to Link token");
    _forward(to, data);
  }

  /**
   * @notice Forward a call to another contract
   * @dev Only callable by the owner
   * @param to address
   * @param data to forward
   */
  function ownerForward(address to, bytes calldata data) external onlyOwner {
    _forward(to, data);
  }

  /**
   * @notice Transfer ownership with instructions for recipient
   * @param to address proposed recipient of ownership
   * @param message instructions for recipient upon accepting ownership
   */
  function transferOwnershipWithMessage(address to, bytes calldata message) external {
    transferOwnership(to);
    emit OwnershipTransferRequestedWithMessage(msg.sender, to, message);
  }

  /**
   * @notice concrete implementation of AuthorizedReceiver
   * @return bool of whether sender is authorized
   */
  function _canSetAuthorizedSenders() internal view override returns (bool) {
    return owner() == msg.sender;
  }

  /**
   * @notice common forwarding functionality and validation
   */
  function _forward(address to, bytes calldata data) private {
    require(to.isContract(), "Must forward to a contract");
    (bool success, bytes memory result) = to.call(data);
    if (!success) {
      if (result.length == 0) revert("Forwarded call reverted without reason");
      assembly {
        revert(add(32, result), mload(result))
      }
    }
  }
}

File 2 of 9 : AuthorizedReceiver.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

import "./interfaces/AuthorizedReceiverInterface.sol";

abstract contract AuthorizedReceiver is AuthorizedReceiverInterface {
  mapping(address => bool) private s_authorizedSenders;
  address[] private s_authorizedSenderList;

  event AuthorizedSendersChanged(address[] senders, address changedBy);

  /**
   * @notice Sets the fulfillment permission for a given node. Use `true` to allow, `false` to disallow.
   * @param senders The addresses of the authorized Chainlink node
   */
  function setAuthorizedSenders(address[] calldata senders) external override validateAuthorizedSenderSetter {
    require(senders.length > 0, "Must have at least 1 authorized sender");
    // Set previous authorized senders to false
    uint256 authorizedSendersLength = s_authorizedSenderList.length;
    for (uint256 i = 0; i < authorizedSendersLength; i++) {
      s_authorizedSenders[s_authorizedSenderList[i]] = false;
    }
    // Set new to true
    for (uint256 i = 0; i < senders.length; i++) {
      s_authorizedSenders[senders[i]] = true;
    }
    // Replace list
    s_authorizedSenderList = senders;
    emit AuthorizedSendersChanged(senders, msg.sender);
  }

  /**
   * @notice Retrieve a list of authorized senders
   * @return array of addresses
   */
  function getAuthorizedSenders() external view override returns (address[] memory) {
    return s_authorizedSenderList;
  }

  /**
   * @notice Use this to check if a node is authorized for fulfilling requests
   * @param sender The address of the Chainlink node
   * @return The authorization status of the node
   */
  function isAuthorizedSender(address sender) public view override returns (bool) {
    return s_authorizedSenders[sender];
  }

  /**
   * @notice customizable guard of who can update the authorized sender list
   * @return bool whether sender can update authorized sender list
   */
  function _canSetAuthorizedSenders() internal virtual returns (bool);

  /**
   * @notice validates the sender is an authorized sender
   */
  function _validateIsAuthorizedSender() internal view {
    require(isAuthorizedSender(msg.sender), "Not authorized sender");
  }

  /**
   * @notice prevents non-authorized addresses from calling this method
   */
  modifier validateAuthorizedSender() {
    _validateIsAuthorizedSender();
    _;
  }

  /**
   * @notice prevents non-authorized addresses from calling this method
   */
  modifier validateAuthorizedSenderSetter() {
    require(_canSetAuthorizedSenders(), "Cannot set authorized senders");
    _;
  }
}

File 3 of 9 : ConfirmedOwnerWithProposal.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

import "./interfaces/OwnableInterface.sol";

/**
 * @title The ConfirmedOwner contract
 * @notice A contract with helpers for basic contract ownership.
 */
contract ConfirmedOwnerWithProposal is OwnableInterface {
  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();
    _;
  }
}

File 4 of 9 : AuthorizedReceiverInterface.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

interface AuthorizedReceiverInterface {
  function isAuthorizedSender(address sender) external view returns (bool);

  function getAuthorizedSenders() external returns (address[] memory);

  function setAuthorizedSenders(address[] calldata senders) external;
}

File 5 of 9 : ChainlinkRequestInterface.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

interface ChainlinkRequestInterface {
  function oracleRequest(
    address sender,
    uint256 requestPrice,
    bytes32 serviceAgreementID,
    address callbackAddress,
    bytes4 callbackFunctionId,
    uint256 nonce,
    uint256 dataVersion,
    bytes calldata data
  ) external;

  function cancelOracleRequest(
    bytes32 requestId,
    uint256 payment,
    bytes4 callbackFunctionId,
    uint256 expiration
  ) external;
}

File 6 of 9 : OperatorInterface.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

import "./ChainlinkRequestInterface.sol";
import "./OracleInterface.sol";

interface OperatorInterface is ChainlinkRequestInterface, OracleInterface {
  function operatorRequest(
    address sender,
    uint256 payment,
    bytes32 specId,
    bytes4 callbackFunctionId,
    uint256 nonce,
    uint256 dataVersion,
    bytes calldata data
  ) external;

  function fulfillOracleRequest2(
    bytes32 requestId,
    uint256 payment,
    address callbackAddress,
    bytes4 callbackFunctionId,
    uint256 expiration,
    bytes calldata data
  ) external returns (bool);

  function ownerTransferAndCall(
    address to,
    uint256 value,
    bytes calldata data
  ) external returns (bool success);
}

File 7 of 9 : OracleInterface.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

interface OracleInterface {
  function fulfillOracleRequest(
    bytes32 requestId,
    uint256 payment,
    address callbackAddress,
    bytes4 callbackFunctionId,
    uint256 expiration,
    bytes32 data
  ) external returns (bool);

  function withdraw(address recipient, uint256 amount) external;

  function withdrawable() external view returns (uint256);
}

File 8 of 9 : OwnableInterface.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

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

  function transferOwnership(address recipient) external;

  function acceptOwnership() external;
}

File 9 of 9 : Address.sol
// SPDX-License-Identifier: MIT
// From https://github.com/OpenZeppelin/openzeppelin-contracts v3.4.0(fa64a1ced0b70ab89073d5d0b6e01b0778f7e7d6)

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
  /**
   * @dev Returns true if `account` is a contract.
   *
   * [IMPORTANT]
   * ====
   * It is unsafe to assume that an address for which this function returns
   * false is an externally-owned account (EOA) and not a contract.
   *
   * Among others, `isContract` will return false for the following
   * types of addresses:
   *
   *  - an externally-owned account
   *  - a contract in construction
   *  - an address where a contract will be created
   *  - an address where a contract lived, but was destroyed
   * ====
   */
  function isContract(address account) internal view returns (bool) {
    // This method relies on extcodesize, which returns 0 for contracts in
    // construction, since the code is only stored at the end of the
    // constructor execution.

    uint256 size;
    // solhint-disable-next-line no-inline-assembly
    assembly {
      size := extcodesize(account)
    }
    return size > 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");

    // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
    (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 functionCall(target, data, "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");
    require(isContract(target), "Address: call to non-contract");

    // solhint-disable-next-line avoid-low-level-calls
    (bool success, bytes memory returndata) = target.call{value: value}(data);
    return _verifyCallResult(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) {
    require(isContract(target), "Address: static call to non-contract");

    // solhint-disable-next-line avoid-low-level-calls
    (bool success, bytes memory returndata) = target.staticcall(data);
    return _verifyCallResult(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) {
    require(isContract(target), "Address: delegate call to non-contract");

    // solhint-disable-next-line avoid-low-level-calls
    (bool success, bytes memory returndata) = target.delegatecall(data);
    return _verifyCallResult(success, returndata, errorMessage);
  }

  function _verifyCallResult(
    bool success,
    bytes memory returndata,
    string memory errorMessage
  ) private pure returns (bytes memory) {
    if (success) {
      return returndata;
    } else {
      // 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

        // solhint-disable-next-line no-inline-assembly
        assembly {
          let returndata_size := mload(returndata)
          revert(add(32, returndata), returndata_size)
        }
      } else {
        revert(errorMessage);
      }
    }
  }
}

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 1000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

Contract ABI

[{"inputs":[{"internalType":"address","name":"link","type":"address"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"bytes","name":"message","type":"bytes"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"senders","type":"address[]"},{"indexed":false,"internalType":"address","name":"changedBy","type":"address"}],"name":"AuthorizedSendersChanged","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"},{"indexed":false,"internalType":"bytes","name":"message","type":"bytes"}],"name":"OwnershipTransferRequestedWithMessage","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":"address","name":"to","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"forward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAuthorizedSenders","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainlinkToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"isAuthorizedSender","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"ownerForward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"senders","type":"address[]"}],"name":"setAuthorizedSenders","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes","name":"message","type":"bytes"}],"name":"transferOwnershipWithMessage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"typeAndVersion","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"}]

Deployed Bytecode

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

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.