Transaction Hash:
Block:
18816886 at Dec-19-2023 01:57:23 AM +UTC
Transaction Fee:
0.009471337958903056 ETH
$28.42
Gas Used:
155,024 Gas / 61.095946169 Gwei
Emitted Events:
263 |
TransparentUpgradeableProxy.0x64a8bb55d9dc0d3344c39d9c65ff20418734996690c8ecf27785086ddf7ddebd( 0x64a8bb55d9dc0d3344c39d9c65ff20418734996690c8ecf27785086ddf7ddebd, 0000000000000000000000000000000000000000000000000429d069189e0000 )
|
264 |
TransparentUpgradeableProxy.0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef( 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x0000000000000000000000000000000000000000000000000000000000000000, 0x000000000000000000000000d0bb63e2c183db414977eaa6b547601e46e12ed4, 00000000000000000000000000000000000000000000000004299a37a340a375 )
|
265 |
TransparentUpgradeableProxy.0xdcbc1c05240f31ff3ad067ef1ee35ce4997762752e3a095284754544f4c709d7( 0xdcbc1c05240f31ff3ad067ef1ee35ce4997762752e3a095284754544f4c709d7, 000000000000000000000000d0bb63e2c183db414977eaa6b547601e46e12ed4, 0000000000000000000000000000000000000000000000000000000000000000, 0000000000000000000000000000000000000000000000000429d069189e0000, 00000000000000000000000000000000000000000000000004299a37a340a375 )
|
Account State Difference:
Address | Before | After | State Difference | ||
---|---|---|---|---|---|
0x4838B106...B0BAD5f97
Miner
| (Titan Builder) | 33.788892250424501955 Eth | 33.788907752824501955 Eth | 0.0000155024 | |
0xbf5495Ef...7e58d2110 | |||||
0xd0bB63e2...e46E12ed4 |
0.86723356757772745 Eth
Nonce: 2777
|
0.557762229618824394 Eth
Nonce: 2778
| 0.309471337958903056 | ||
0xf2F305D1...4795D0d60 | 29.762673422457779678 Eth | 30.062673422457779678 Eth | 0.3 |
Execution Trace
ETH 0.3
TransparentUpgradeableProxy.CALL( )
ETH 0.3
RestakeManager.DELEGATECALL( )
TransparentUpgradeableProxy.STATICCALL( )
-
OperatorDelegator.DELEGATECALL( )
-
ETH 0.3
TransparentUpgradeableProxy.CALL( )
- ETH 0.3
DepositQueue.DELEGATECALL( )
- ETH 0.3
TransparentUpgradeableProxy.STATICCALL( )
-
EzEthToken.DELEGATECALL( )
-
TransparentUpgradeableProxy.8f686e6a( )
-
RenzoOracle.calculateMintAmount( _currentValueInProtocol=1021785148220457779678, _newValueAdded=300000000000000000, _existingEzETHSupply=1021582201082828847239 ) => ( 299940413949649781 )
-
TransparentUpgradeableProxy.40c10f19( )
EzEthToken.mint( to=0xd0bB63e2c183DB414977Eaa6B547601e46E12ed4, amount=299940413949649781 )
TransparentUpgradeableProxy.b58f66d4( )
-
RoleManager.isEzETHMinterBurner( potentialAddress=0x74a09653A083691711cF8215a6ab074BB4e99ef5 ) => ( True )
-
File 1 of 12: TransparentUpgradeableProxy
File 2 of 12: TransparentUpgradeableProxy
File 3 of 12: TransparentUpgradeableProxy
File 4 of 12: RestakeManager
File 5 of 12: TransparentUpgradeableProxy
File 6 of 12: OperatorDelegator
File 7 of 12: DepositQueue
File 8 of 12: EzEthToken
File 9 of 12: TransparentUpgradeableProxy
File 10 of 12: RenzoOracle
File 11 of 12: TransparentUpgradeableProxy
File 12 of 12: RoleManager
12345678910111213141516// 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.*/
File 2 of 12: TransparentUpgradeableProxy
12345678910111213141516// 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.*/
File 3 of 12: TransparentUpgradeableProxy
12345678910111213141516// 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.*/
File 4 of 12: RestakeManager
12345678910111213141516// 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:*
File 5 of 12: TransparentUpgradeableProxy
12345678910111213141516// 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.*/
File 6 of 12: OperatorDelegator
12345678910111213141516// 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:*
File 7 of 12: DepositQueue
12345678910111213141516// 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:*
File 8 of 12: EzEthToken
12345678910111213141516// 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:*
File 9 of 12: TransparentUpgradeableProxy
12345678910111213141516// 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.*/
File 10 of 12: RenzoOracle
12345678910111213141516// SPDX-License-Identifier: MITpragma 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()externalviewreturns (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)
File 11 of 12: TransparentUpgradeableProxy
12345678910111213141516// 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.*/
File 12 of 12: RoleManager
12345678910111213141516// 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