ETH Price: $3,001.07 (+8.03%)

Transaction Decoder

Block:
18819226 at Dec-19-2023 09:51:47 AM +UTC
Transaction Fee:
0.016726312217889792 ETH $50.20
Gas Used:
155,024 Gas / 107.894985408 Gwei

Emitted Events:

301 TransparentUpgradeableProxy.0x64a8bb55d9dc0d3344c39d9c65ff20418734996690c8ecf27785086ddf7ddebd( 0x64a8bb55d9dc0d3344c39d9c65ff20418734996690c8ecf27785086ddf7ddebd, 000000000000000000000000000000000000000000000001a055690d9db80000 )
302 TransparentUpgradeableProxy.0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef( 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x0000000000000000000000000000000000000000000000000000000000000000, 0x000000000000000000000000123432244443b54409430979df8333f9308a6040, 000000000000000000000000000000000000000000000001a0403dbbc54041e3 )
303 TransparentUpgradeableProxy.0xdcbc1c05240f31ff3ad067ef1ee35ce4997762752e3a095284754544f4c709d7( 0xdcbc1c05240f31ff3ad067ef1ee35ce4997762752e3a095284754544f4c709d7, 000000000000000000000000123432244443b54409430979df8333f9308a6040, 0000000000000000000000000000000000000000000000000000000000000000, 000000000000000000000000000000000000000000000001a055690d9db80000, 000000000000000000000000000000000000000000000001a0403dbbc54041e3 )

Account State Difference:

  Address   Before After State Difference Code
0x12343224...9308A6040
31.270509081039964506 Eth
Nonce: 1297
1.253782768822074714 Eth
Nonce: 1298
30.016726312217889792
(beaverbuild)
14.105588229581022955 Eth14.105603731981022955 Eth0.0000155024
0xbf5495Ef...7e58d2110
0xf2F305D1...4795D0d60 39.788653422457779678 Eth69.788653422457779678 Eth30

Execution Trace

ETH 30 TransparentUpgradeableProxy.CALL( )
  • ETH 30 RestakeManager.DELEGATECALL( )
    • TransparentUpgradeableProxy.STATICCALL( )
      • OperatorDelegator.DELEGATECALL( )
      • ETH 30 TransparentUpgradeableProxy.CALL( )
        • ETH 30 DepositQueue.DELEGATECALL( )
        • TransparentUpgradeableProxy.STATICCALL( )
          • EzEthToken.DELEGATECALL( )
          • TransparentUpgradeableProxy.8f686e6a( )
            • RenzoOracle.calculateMintAmount( _currentValueInProtocol=1191811128220457779678, _newValueAdded=30000000000000000000, _existingEzETHSupply=1191574410494145217600 ) => ( 29994041394965004771 )
            • TransparentUpgradeableProxy.40c10f19( )
              • EzEthToken.mint( to=0x123432244443B54409430979DF8333f9308A6040, amount=29994041394965004771 )
                • TransparentUpgradeableProxy.b58f66d4( )
                  • RoleManager.isEzETHMinterBurner( potentialAddress=0x74a09653A083691711cF8215a6ab074BB4e99ef5 ) => ( True )
                    File 1 of 12: TransparentUpgradeableProxy
                    1
                    2
                    3
                    4
                    5
                    6
                    7
                    8
                    9
                    10
                    11
                    12
                    13
                    14
                    15
                    16
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.5.0-rc.0) (interfaces/draft-IERC1822.sol)
                    pragma solidity ^0.8.0;
                    /**
                    * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
                    * proxy whose upgrades are fully controlled by the current implementation.
                    */
                    interface IERC1822Proxiable {
                    /**
                    * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
                    * address.
                    *
                    * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                    * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                    * function revert if invoked through a proxy.
                    */
                    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                    File 2 of 12: TransparentUpgradeableProxy
                    1
                    2
                    3
                    4
                    5
                    6
                    7
                    8
                    9
                    10
                    11
                    12
                    13
                    14
                    15
                    16
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.5.0-rc.0) (interfaces/draft-IERC1822.sol)
                    pragma solidity ^0.8.0;
                    /**
                    * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
                    * proxy whose upgrades are fully controlled by the current implementation.
                    */
                    interface IERC1822Proxiable {
                    /**
                    * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
                    * address.
                    *
                    * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                    * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                    * function revert if invoked through a proxy.
                    */
                    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                    File 3 of 12: TransparentUpgradeableProxy
                    1
                    2
                    3
                    4
                    5
                    6
                    7
                    8
                    9
                    10
                    11
                    12
                    13
                    14
                    15
                    16
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.5.0-rc.0) (interfaces/draft-IERC1822.sol)
                    pragma solidity ^0.8.0;
                    /**
                    * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
                    * proxy whose upgrades are fully controlled by the current implementation.
                    */
                    interface IERC1822Proxiable {
                    /**
                    * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
                    * address.
                    *
                    * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                    * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                    * function revert if invoked through a proxy.
                    */
                    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                    File 4 of 12: RestakeManager
                    1
                    2
                    3
                    4
                    5
                    6
                    7
                    8
                    9
                    10
                    11
                    12
                    13
                    14
                    15
                    16
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)
                    pragma solidity ^0.8.2;
                    import "../../utils/AddressUpgradeable.sol";
                    /**
                    * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
                    * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
                    * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
                    * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
                    *
                    * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
                    * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
                    * case an upgrade adds a module that needs to be initialized.
                    *
                    * For example:
                    *
                    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                    File 5 of 12: TransparentUpgradeableProxy
                    1
                    2
                    3
                    4
                    5
                    6
                    7
                    8
                    9
                    10
                    11
                    12
                    13
                    14
                    15
                    16
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.5.0-rc.0) (interfaces/draft-IERC1822.sol)
                    pragma solidity ^0.8.0;
                    /**
                    * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
                    * proxy whose upgrades are fully controlled by the current implementation.
                    */
                    interface IERC1822Proxiable {
                    /**
                    * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
                    * address.
                    *
                    * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                    * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                    * function revert if invoked through a proxy.
                    */
                    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                    File 6 of 12: OperatorDelegator
                    1
                    2
                    3
                    4
                    5
                    6
                    7
                    8
                    9
                    10
                    11
                    12
                    13
                    14
                    15
                    16
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)
                    pragma solidity ^0.8.2;
                    import "../../utils/AddressUpgradeable.sol";
                    /**
                    * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
                    * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
                    * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
                    * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
                    *
                    * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
                    * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
                    * case an upgrade adds a module that needs to be initialized.
                    *
                    * For example:
                    *
                    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                    File 7 of 12: DepositQueue
                    1
                    2
                    3
                    4
                    5
                    6
                    7
                    8
                    9
                    10
                    11
                    12
                    13
                    14
                    15
                    16
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)
                    pragma solidity ^0.8.2;
                    import "../../utils/AddressUpgradeable.sol";
                    /**
                    * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
                    * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
                    * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
                    * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
                    *
                    * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
                    * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
                    * case an upgrade adds a module that needs to be initialized.
                    *
                    * For example:
                    *
                    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                    File 8 of 12: EzEthToken
                    1
                    2
                    3
                    4
                    5
                    6
                    7
                    8
                    9
                    10
                    11
                    12
                    13
                    14
                    15
                    16
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)
                    pragma solidity ^0.8.2;
                    import "../../utils/AddressUpgradeable.sol";
                    /**
                    * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
                    * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
                    * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
                    * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
                    *
                    * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
                    * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
                    * case an upgrade adds a module that needs to be initialized.
                    *
                    * For example:
                    *
                    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                    File 9 of 12: TransparentUpgradeableProxy
                    1
                    2
                    3
                    4
                    5
                    6
                    7
                    8
                    9
                    10
                    11
                    12
                    13
                    14
                    15
                    16
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.5.0-rc.0) (interfaces/draft-IERC1822.sol)
                    pragma solidity ^0.8.0;
                    /**
                    * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
                    * proxy whose upgrades are fully controlled by the current implementation.
                    */
                    interface IERC1822Proxiable {
                    /**
                    * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
                    * address.
                    *
                    * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                    * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                    * function revert if invoked through a proxy.
                    */
                    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                    File 10 of 12: RenzoOracle
                    1
                    2
                    3
                    4
                    5
                    6
                    7
                    8
                    9
                    10
                    11
                    12
                    13
                    14
                    15
                    16
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.8.0;
                    interface AggregatorV3Interface {
                    function decimals() external view returns (uint8);
                    function description() external view returns (string memory);
                    function version() external view returns (uint256);
                    function getRoundData(
                    uint80 _roundId
                    ) external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
                    function latestRoundData()
                    external
                    view
                    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)
                    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                    File 11 of 12: TransparentUpgradeableProxy
                    1
                    2
                    3
                    4
                    5
                    6
                    7
                    8
                    9
                    10
                    11
                    12
                    13
                    14
                    15
                    16
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.5.0-rc.0) (interfaces/draft-IERC1822.sol)
                    pragma solidity ^0.8.0;
                    /**
                    * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
                    * proxy whose upgrades are fully controlled by the current implementation.
                    */
                    interface IERC1822Proxiable {
                    /**
                    * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
                    * address.
                    *
                    * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                    * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                    * function revert if invoked through a proxy.
                    */
                    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                    File 12 of 12: RoleManager
                    1
                    2
                    3
                    4
                    5
                    6
                    7
                    8
                    9
                    10
                    11
                    12
                    13
                    14
                    15
                    16
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)
                    pragma solidity ^0.8.0;
                    import "./IAccessControlUpgradeable.sol";
                    import "../utils/ContextUpgradeable.sol";
                    import "../utils/StringsUpgradeable.sol";
                    import "../utils/introspection/ERC165Upgradeable.sol";
                    import "../proxy/utils/Initializable.sol";
                    /**
                    * @dev Contract module that allows children to implement role-based access
                    * control mechanisms. This is a lightweight version that doesn't allow enumerating role
                    * members except through off-chain means by accessing the contract event logs. Some
                    * applications may benefit from on-chain enumerability, for those cases see
                    * {AccessControlEnumerable}.
                    *
                    * Roles are referred to by their `bytes32` identifier. These should be exposed
                    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX