ETH Price: $2,997.37 (+0.25%)

Transaction Decoder

Block:
19882387 at May-16-2024 11:57:59 AM +UTC
Transaction Fee:
0.000809968738828265 ETH $2.43
Gas Used:
203,545 Gas / 3.979310417 Gwei

Account State Difference:

  Address   Before After State Difference Code
4.414576787178072879 Eth4.414579152375247324 Eth0.000002365197174445
0xBBD2f4DE...60e694D0c
0.001491341590542001 Eth
Nonce: 101
0.000681372851713736 Eth
Nonce: 102
0.000809968738828265

Execution Trace

ETH 0.0005 L1ChugSplashProxy.e11013dd( )
  • ProxyAdmin.STATICCALL( )
  • ETH 0.0005 L1StandardBridge.bridgeETHTo( _to=0xBBD2f4DEb40Cd2f03aEadEb312c809360e694D0c, _minGasLimit=200000, _extraData=0x7375706572627269646765 )
    • ETH 0.0005 ResolvedDelegateProxy.3dbb202b( )
      • AddressManager.getAddress( _name=OVM_L1CrossDomainMessenger ) => ( 0x958487e21ba9E073836d598E31f749726f23413f )
      • ETH 0.0005 L1CrossDomainMessenger.sendMessage( _target=0x4200000000000000000000000000000000000010, _message=0x1635F5FD000000000000000000000000BBD2F4DEB40CD2F03AEADEB312C809360E694D0C000000000000000000000000BBD2F4DEB40CD2F03AEADEB312C809360E694D0C0000000000000000000000000000000000000000000000000001C6BF526340000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000B7375706572627269646765000000000000000000000000000000000000000000, _minGasLimit=200000 )
        • ETH 0.0005 Proxy.e9e05c42( )
          • ETH 0.0005 OptimismPortal.depositTransaction( _to=0x4200000000000000000000000000000000000007, _value=500000000000000, _gasLimit=491310, _isCreation=False, _data=0xD764AD0B00010000000000000000000000000000000000000000000000000000000003460000000000000000000000002B3F201543ADF73160BA42E1A5B7750024F3042000000000000000000000000042000000000000000000000000000000000000100000000000000000000000000000000000000000000000000001C6BF526340000000000000000000000000000000000000000000000000000000000000030D4000000000000000000000000000000000000000000000000000000000000000C000000000000000000000000000000000000000000000000000000000000000C41635F5FD000000000000000000000000BBD2F4DEB40CD2F03AEADEB312C809360E694D0C000000000000000000000000BBD2F4DEB40CD2F03AEADEB312C809360E694D0C0000000000000000000000000000000000000000000000000001C6BF526340000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000B737570657262726964676500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 )
            • Proxy.STATICCALL( )
              File 1 of 9: L1ChugSplashProxy
              1
              2
              3
              4
              5
              6
              7
              8
              9
              10
              11
              12
              13
              14
              15
              16
              // SPDX-License-Identifier: MIT
              pragma solidity 0.8.15;
              /**
              * @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
              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

              File 2 of 9: ProxyAdmin
              1
              2
              3
              4
              5
              6
              7
              8
              9
              10
              11
              12
              13
              14
              15
              16
              // SPDX-License-Identifier: MIT
              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;
              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

              File 3 of 9: L1StandardBridge
              1
              2
              3
              4
              5
              6
              7
              8
              9
              10
              11
              12
              13
              14
              15
              16
              // SPDX-License-Identifier: MIT
              pragma solidity 0.8.15;
              import { Predeploys } from "../libraries/Predeploys.sol";
              import { StandardBridge } from "../universal/StandardBridge.sol";
              import { Semver } from "../universal/Semver.sol";
              /**
              * @custom:proxied
              * @title L1StandardBridge
              * @notice The L1StandardBridge is responsible for transfering ETH and ERC20 tokens between L1 and
              * L2. In the case that an ERC20 token is native to L1, it will be escrowed within this
              * contract. If the ERC20 token is native to L2, it will be burnt. Before Bedrock, ETH was
              * stored within this contract. After Bedrock, ETH is instead stored inside the
              * OptimismPortal contract.
              * NOTE: this contract is not intended to support all variations of ERC20 tokens. Examples
              * of some token types that may not be properly supported by this contract include, but are
              * not limited to: tokens with transfer fees, rebasing tokens, and tokens with blocklists.
              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

              File 4 of 9: ResolvedDelegateProxy
              1
              2
              3
              4
              5
              6
              7
              8
              9
              10
              11
              12
              13
              14
              15
              16
              // SPDX-License-Identifier: MIT
              pragma solidity 0.8.15;
              import { AddressManager } from "./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
              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

              File 5 of 9: AddressManager
              1
              2
              3
              4
              5
              6
              7
              8
              9
              10
              11
              12
              13
              14
              15
              16
              // SPDX-License-Identifier: MIT
              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;
              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

              File 6 of 9: L1CrossDomainMessenger
              1
              2
              3
              4
              5
              6
              7
              8
              9
              10
              11
              12
              13
              14
              15
              16
              // SPDX-License-Identifier: MIT
              pragma solidity 0.8.15;
              import { Predeploys } from "../libraries/Predeploys.sol";
              import { OptimismPortal } from "./OptimismPortal.sol";
              import { CrossDomainMessenger } from "../universal/CrossDomainMessenger.sol";
              import { Semver } from "../universal/Semver.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, Semver {
              /**
              * @notice Address of the OptimismPortal.
              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

              File 7 of 9: Proxy
              1
              2
              3
              4
              5
              6
              7
              8
              9
              10
              11
              12
              13
              14
              15
              16
              // SPDX-License-Identifier: MIT
              pragma solidity 0.8.15;
              /**
              * @title Proxy
              * @notice Proxy is a transparent proxy that passes through the call if the caller is the owner or
              * if the caller is address(0), meaning that the call originated from an off-chain
              * simulation.
              */
              contract Proxy {
              /**
              * @notice The storage slot that holds the address of the implementation.
              * bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)
              */
              bytes32 internal constant IMPLEMENTATION_KEY =
              0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
              /**
              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

              File 8 of 9: OptimismPortal
              1
              2
              3
              4
              5
              6
              7
              8
              9
              10
              11
              12
              13
              14
              15
              16
              // SPDX-License-Identifier: MIT
              pragma solidity 0.8.15;
              import { Initializable } from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
              import { SafeCall } from "../libraries/SafeCall.sol";
              import { L2OutputOracle } from "./L2OutputOracle.sol";
              import { SystemConfig } from "./SystemConfig.sol";
              import { Constants } from "../libraries/Constants.sol";
              import { Types } from "../libraries/Types.sol";
              import { Hashing } from "../libraries/Hashing.sol";
              import { SecureMerkleTrie } from "../libraries/trie/SecureMerkleTrie.sol";
              import { AddressAliasHelper } from "../vendor/AddressAliasHelper.sol";
              import { ResourceMetering } from "./ResourceMetering.sol";
              import { Semver } from "../universal/Semver.sol";
              /// @custom:proxied
              /// @title OptimismPortal
              /// @notice The OptimismPortal is a low-level contract responsible for passing messages between L1
              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

              File 9 of 9: Proxy
              1
              2
              3
              4
              5
              6
              7
              8
              9
              10
              11
              12
              13
              14
              15
              16
              // SPDX-License-Identifier: MIT
              pragma solidity 0.8.15;
              /**
              * @title Proxy
              * @notice Proxy is a transparent proxy that passes through the call if the caller is the owner or
              * if the caller is address(0), meaning that the call originated from an off-chain
              * simulation.
              */
              contract Proxy {
              /**
              * @notice The storage slot that holds the address of the implementation.
              * bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)
              */
              bytes32 internal constant IMPLEMENTATION_KEY =
              0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
              /**
              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX