ETH Price: $2,977.32 (-1.56%)

Transaction Decoder

Block:
19335804 at Feb-29-2024 09:18:59 PM +UTC
Transaction Fee:
0.008651767352684838 ETH $25.76
Gas Used:
78,751 Gas / 109.862317338 Gwei

Account State Difference:

  Address   Before After State Difference Code
(beaverbuild)
8.659209605425850232 Eth8.660784625425850232 Eth0.00157502
0x9a1c0a04...7Bb7f687d
1.0967 Eth
Nonce: 0
1.088048232647315162 Eth
Nonce: 1
0.008651767352684838

Execution Trace

ETH 1.07 L1ChugSplashProxy.CALL( )
  • ProxyAdmin.STATICCALL( )
  • ETH 1.07 L1BlastBridge.DELEGATECALL( )
    • ETH 1.07 ResolvedDelegateProxy.3dbb202b( )
      • AddressManager.getAddress( _name=OVM_L1CrossDomainMessenger ) => ( 0x84efcFCE2dEe08072d5D57BF232D379b6E92A836 )
      • ETH 1.07 L1CrossDomainMessenger.sendMessage( _target=0x4300000000000000000000000000000000000005, _message=0x1635F5FD0000000000000000000000009A1C0A04C3C59B20C23A9B372F4FB007BB7F687D0000000000000000000000009A1C0A04C3C59B20C23A9B372F4FB007BB7F687D0000000000000000000000000000000000000000000000000ED96754B5AB000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000, _minGasLimit=200000 )
        File 1 of 6: L1ChugSplashProxy
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        // SPDX-License-Identifier: BSL 1.1 - Copyright 2024 MetaLayer Labs Ltd.
        pragma solidity 0.8.15;
        import { Constants } from "src/libraries/Constants.sol";
        /// @title IL1ChugSplashDeployer
        interface IL1ChugSplashDeployer {
        function isUpgrading() external view returns (bool);
        }
        /// @custom:legacy
        /// @title L1ChugSplashProxy
        /// @notice Basic ChugSplash proxy contract for L1. Very close to being a normal proxy but has added
        /// functions `setCode` and `setStorage` for changing the code or storage of the contract.
        /// Note for future developers: do NOT make anything in this contract 'public' unless you
        /// know what you're doing. Anything public can potentially have a function signature that
        /// conflicts with a signature attached to the implementation contract. Public functions
        /// SHOULD always have the `proxyCallIfNotOwner` modifier unless there's some *really* good
        /// reason not to have that modifier. And there almost certainly is not a good reason to not
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

        File 2 of 6: ProxyAdmin
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        // SPDX-License-Identifier: BSL 1.1 - Copyright 2024 MetaLayer Labs Ltd.
        pragma solidity 0.8.15;
        import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
        import { Proxy } from "src/universal/Proxy.sol";
        import { AddressManager } from "src/legacy/AddressManager.sol";
        import { L1ChugSplashProxy } from "src/legacy/L1ChugSplashProxy.sol";
        import { Constants } from "src/libraries/Constants.sol";
        /// @title IStaticERC1967Proxy
        /// @notice IStaticERC1967Proxy is a static version of the ERC1967 proxy interface.
        interface IStaticERC1967Proxy {
        function implementation() external view returns (address);
        function admin() external view returns (address);
        }
        /// @title IStaticL1ChugSplashProxy
        /// @notice IStaticL1ChugSplashProxy is a static version of the ChugSplash proxy interface.
        interface IStaticL1ChugSplashProxy {
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

        File 3 of 6: L1BlastBridge
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        // SPDX-License-Identifier: BSL 1.1 - Copyright 2024 MetaLayer Labs Ltd.
        pragma solidity 0.8.15;
        import { Address } from "@openzeppelin/contracts/utils/Address.sol";
        import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";
        import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
        import { Predeploys } from "src/libraries/Predeploys.sol";
        import { SafeCall } from "src/libraries/SafeCall.sol";
        import { StandardBridge } from "src/universal/StandardBridge.sol";
        import { L2BlastBridge } from "src/mainnet-bridge/L2BlastBridge.sol";
        import { ISemver } from "src/universal/ISemver.sol";
        import { CrossDomainMessenger } from "src/universal/CrossDomainMessenger.sol";
        import { OptimismPortal } from "src/L1/OptimismPortal.sol";
        import { Predeploys } from "src/libraries/Predeploys.sol";
        import { USDYieldManager } from "src/mainnet-bridge/USDYieldManager.sol";
        import { ETHYieldManager } from "src/mainnet-bridge/ETHYieldManager.sol";
        import { USDB } from "src/L2/USDB.sol";
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

        File 4 of 6: ResolvedDelegateProxy
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        // SPDX-License-Identifier: BSL 1.1 - Copyright 2024 MetaLayer Labs Ltd.
        pragma solidity 0.8.15;
        import { AddressManager } from "src/legacy/AddressManager.sol";
        /// @custom:legacy
        /// @title ResolvedDelegateProxy
        /// @notice ResolvedDelegateProxy is a legacy proxy contract that makes use of the AddressManager to
        /// resolve the implementation address. We're maintaining this contract for backwards
        /// compatibility so we can manage all legacy proxies where necessary.
        contract ResolvedDelegateProxy {
        /// @notice Mapping used to store the implementation name that corresponds to this contract. A
        /// mapping was originally used as a way to bypass the same issue normally solved by
        /// storing the implementation address in a specific storage slot that does not conflict
        /// with any other storage slot. Generally NOT a safe solution but works as long as the
        /// implementation does not also keep a mapping in the first storage slot.
        mapping(address => string) private implementationName;
        /// @notice Mapping used to store the address of the AddressManager contract where the
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

        File 5 of 6: AddressManager
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        // SPDX-License-Identifier: BSL 1.1 - Copyright 2024 MetaLayer Labs Ltd.
        pragma solidity 0.8.15;
        import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
        /// @custom:legacy
        /// @title AddressManager
        /// @notice AddressManager is a legacy contract that was used in the old version of the Optimism
        /// system to manage a registry of string names to addresses. We now use a more standard
        /// proxy system instead, but this contract is still necessary for backwards compatibility
        /// with several older contracts.
        contract AddressManager is Ownable {
        /// @notice Mapping of the hashes of string names to addresses.
        mapping(bytes32 => address) private addresses;
        /// @notice Emitted when an address is modified in the registry.
        /// @param name String name being set in the registry.
        /// @param newAddress Address set for the given name.
        /// @param oldAddress Address that was previously set for the given name.
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

        File 6 of 6: L1CrossDomainMessenger
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        // SPDX-License-Identifier: BSL 1.1 - Copyright 2024 MetaLayer Labs Ltd.
        pragma solidity 0.8.15;
        import { Predeploys } from "src/libraries/Predeploys.sol";
        import { SafeCall } from "src/libraries/SafeCall.sol";
        import { Hashing } from "src/libraries/Hashing.sol";
        import { Encoding } from "src/libraries/Encoding.sol";
        import { OptimismPortal } from "src/L1/OptimismPortal.sol";
        import { CrossDomainMessenger } from "src/universal/CrossDomainMessenger.sol";
        import { ISemver } from "src/universal/ISemver.sol";
        import { Constants } from "src/libraries/Constants.sol";
        /// @custom:proxied
        /// @title L1CrossDomainMessenger
        /// @notice The L1CrossDomainMessenger is a message passing interface between L1 and L2 responsible
        /// for sending and receiving data on the L1 side. Users are encouraged to use this
        /// interface instead of interacting with lower-level contracts directly.
        contract L1CrossDomainMessenger is CrossDomainMessenger, ISemver {
        XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX