GettersFacet | Address 0xE60E94fCCb18a81D501a38959E532C0A85A1be89 | Etherscan (2024)

0 ETH

Add

0x71d84c34...2033F9438 at txn 0x863d2052e900cd3a88560c67bbce9737422f20b16bb1cbc4672013d71c2dd2e7

File 1 of 13 : Getters.sol

// SPDX-License-Identifier: MITpragma solidity 0.8.24;import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";import {ZkSyncHyperchainBase} from "./ZkSyncHyperchainBase.sol";import {PubdataPricingMode} from "../ZkSyncHyperchainStorage.sol";import {VerifierParams} from "../../../state-transition/chain-interfaces/IVerifier.sol";import {Diamond} from "../../libraries/Diamond.sol";import {PriorityQueue, PriorityOperation} from "../../../state-transition/libraries/PriorityQueue.sol";import {UncheckedMath} from "../../../common/libraries/UncheckedMath.sol";import {IGetters} from "../../chain-interfaces/IGetters.sol";import {ILegacyGetters} from "../../chain-interfaces/ILegacyGetters.sol";import {SemVer} from "../../../common/libraries/SemVer.sol";// While formally the following import is not used, it is needed to inherit documentation from itimport {IZkSyncHyperchainBase} from "../../chain-interfaces/IZkSyncHyperchainBase.sol";/// @title Getters Contract implements functions for getting contract state from outside the blockchain./// @author Matter Labs/// @custom:security-contact [emailprotected]contract GettersFacet is ZkSyncHyperchainBase, IGetters, ILegacyGetters { using UncheckedMath for uint256; using PriorityQueue for PriorityQueue.Queue; /// @inheritdoc IZkSyncHyperchainBase string public constant override getName = "GettersFacet"; /*////////////////////////////////////////////////////////////// CUSTOM GETTERS //////////////////////////////////////////////////////////////*/ /// @inheritdoc IGetters function getVerifier() external view returns (address) { return address(s.verifier); } /// @inheritdoc IGetters function getAdmin() external view returns (address) { return s.admin; } /// @inheritdoc IGetters function getPendingAdmin() external view returns (address) { return s.pendingAdmin; } /// @inheritdoc IGetters function getBridgehub() external view returns (address) { return s.bridgehub; } /// @inheritdoc IGetters function getStateTransitionManager() external view returns (address) { return s.stateTransitionManager; } /// @inheritdoc IGetters function getBaseToken() external view returns (address) { return s.baseToken; } /// @inheritdoc IGetters function getBaseTokenBridge() external view returns (address) { return s.baseTokenBridge; } /// @inheritdoc IGetters function baseTokenGasPriceMultiplierNominator() external view returns (uint128) { return s.baseTokenGasPriceMultiplierNominator; } /// @inheritdoc IGetters function baseTokenGasPriceMultiplierDenominator() external view returns (uint128) { return s.baseTokenGasPriceMultiplierDenominator; } /// @inheritdoc IGetters function getTotalBatchesCommitted() external view returns (uint256) { return s.totalBatchesCommitted; } /// @inheritdoc IGetters function getTotalBatchesVerified() external view returns (uint256) { return s.totalBatchesVerified; } /// @inheritdoc IGetters function getTotalBatchesExecuted() external view returns (uint256) { return s.totalBatchesExecuted; } /// @inheritdoc IGetters function getTotalPriorityTxs() external view returns (uint256) { return s.priorityQueue.getTotalPriorityTxs(); } /// @inheritdoc IGetters function getFirstUnprocessedPriorityTx() external view returns (uint256) { return s.priorityQueue.getFirstUnprocessedPriorityTx(); } /// @inheritdoc IGetters function getPriorityQueueSize() external view returns (uint256) { return s.priorityQueue.getSize(); } /// @inheritdoc IGetters function priorityQueueFrontOperation() external view returns (PriorityOperation memory) { return s.priorityQueue.front(); } /// @inheritdoc IGetters function isValidator(address _address) external view returns (bool) { return s.validators[_address]; } /// @inheritdoc IGetters function l2LogsRootHash(uint256 _batchNumber) external view returns (bytes32) { return s.l2LogsRootHashes[_batchNumber]; } /// @inheritdoc IGetters function storedBatchHash(uint256 _batchNumber) external view returns (bytes32) { return s.storedBatchHashes[_batchNumber]; } /// @inheritdoc IGetters function getL2BootloaderBytecodeHash() external view returns (bytes32) { return s.l2BootloaderBytecodeHash; } /// @inheritdoc IGetters function getL2DefaultAccountBytecodeHash() external view returns (bytes32) { return s.l2DefaultAccountBytecodeHash; } /// @inheritdoc IGetters function getVerifierParams() external view returns (VerifierParams memory) { return s.__DEPRECATED_verifierParams; } /// @inheritdoc IGetters function getProtocolVersion() external view returns (uint256) { return s.protocolVersion; } /// @inheritdoc IGetters function getSemverProtocolVersion() external view returns (uint32, uint32, uint32) { // slither-disable-next-line unused-return return SemVer.unpackSemVer(SafeCast.toUint96(s.protocolVersion)); } /// @inheritdoc IGetters function getL2SystemContractsUpgradeTxHash() external view returns (bytes32) { return s.l2SystemContractsUpgradeTxHash; } /// @inheritdoc IGetters function getL2SystemContractsUpgradeBatchNumber() external view returns (uint256) { return s.l2SystemContractsUpgradeBatchNumber; } /// @inheritdoc IGetters function isDiamondStorageFrozen() external view returns (bool) { Diamond.DiamondStorage storage ds = Diamond.getDiamondStorage(); return ds.isFrozen; } /// @inheritdoc IGetters function isFacetFreezable(address _facet) external view returns (bool isFreezable) { Diamond.DiamondStorage storage ds = Diamond.getDiamondStorage(); // There is no direct way to get whether the facet address is freezable, // so we get it from one of the selectors that are associated with the facet. uint256 selectorsArrayLen = ds.facetToSelectors[_facet].selectors.length; if (selectorsArrayLen != 0) { bytes4 selector0 = ds.facetToSelectors[_facet].selectors[0]; isFreezable = ds.selectorToFacet[selector0].isFreezable; } } /// @inheritdoc IGetters function getPriorityTxMaxGasLimit() external view returns (uint256) { return s.priorityTxMaxGasLimit; } /// @inheritdoc IGetters function isFunctionFreezable(bytes4 _selector) external view returns (bool) { Diamond.DiamondStorage storage ds = Diamond.getDiamondStorage(); require(ds.selectorToFacet[_selector].facetAddress != address(0), "g2"); return ds.selectorToFacet[_selector].isFreezable; } /// @inheritdoc IGetters function isEthWithdrawalFinalized(uint256 _l2BatchNumber, uint256 _l2MessageIndex) external view returns (bool) { return s.isEthWithdrawalFinalized[_l2BatchNumber][_l2MessageIndex]; } /// @inheritdoc IGetters function getPubdataPricingMode() external view returns (PubdataPricingMode) { return s.feeParams.pubdataPricingMode; } /*////////////////////////////////////////////////////////////// DIAMOND LOUPE //////////////////////////////////////////////////////////////*/ /// @inheritdoc IGetters function facets() external view returns (Facet[] memory result) { Diamond.DiamondStorage storage ds = Diamond.getDiamondStorage(); uint256 facetsLen = ds.facets.length; result = new Facet[](facetsLen); for (uint256 i = 0; i < facetsLen; i = i.uncheckedInc()) { address facetAddr = ds.facets[i]; Diamond.FacetToSelectors memory facetToSelectors = ds.facetToSelectors[facetAddr]; result[i] = Facet(facetAddr, facetToSelectors.selectors); } } /// @inheritdoc IGetters function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory) { Diamond.DiamondStorage storage ds = Diamond.getDiamondStorage(); return ds.facetToSelectors[_facet].selectors; } /// @inheritdoc IGetters function facetAddresses() external view returns (address[] memory) { Diamond.DiamondStorage storage ds = Diamond.getDiamondStorage(); return ds.facets; } /// @inheritdoc IGetters function facetAddress(bytes4 _selector) external view returns (address) { Diamond.DiamondStorage storage ds = Diamond.getDiamondStorage(); return ds.selectorToFacet[_selector].facetAddress; } /*////////////////////////////////////////////////////////////// DEPRECATED METHODS //////////////////////////////////////////////////////////////*/ /// @inheritdoc ILegacyGetters function getTotalBlocksCommitted() external view returns (uint256) { return s.totalBatchesCommitted; } /// @inheritdoc ILegacyGetters function getTotalBlocksVerified() external view returns (uint256) { return s.totalBatchesVerified; } /// @inheritdoc ILegacyGetters function getTotalBlocksExecuted() external view returns (uint256) { return s.totalBatchesExecuted; } /// @inheritdoc ILegacyGetters function storedBlockHash(uint256 _batchNumber) external view returns (bytes32) { return s.storedBatchHashes[_batchNumber]; } /// @inheritdoc ILegacyGetters function getL2SystemContractsUpgradeBlockNumber() external view returns (uint256) { return s.l2SystemContractsUpgradeBatchNumber; }}

File 2 of 13 : SafeCast.sol

// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)// This file was procedurally generated from scripts/generate/templates/SafeCast.js.pragma solidity ^0.8.0;/** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. * * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing * all math on `uint256` and `int256` and then downcasting. */library SafeCast { /** * @dev Returns the downcasted uint248 from uint256, reverting on * overflow (when the input is greater than largest uint248). * * Counterpart to Solidity's `uint248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toUint248(uint256 value) internal pure returns (uint248) { require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits"); return uint248(value); } /** * @dev Returns the downcasted uint240 from uint256, reverting on * overflow (when the input is greater than largest uint240). * * Counterpart to Solidity's `uint240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toUint240(uint256 value) internal pure returns (uint240) { require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits"); return uint240(value); } /** * @dev Returns the downcasted uint232 from uint256, reverting on * overflow (when the input is greater than largest uint232). * * Counterpart to Solidity's `uint232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toUint232(uint256 value) internal pure returns (uint232) { require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits"); return uint232(value); } /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.2._ */ function toUint224(uint256 value) internal pure returns (uint224) { require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits"); return uint224(value); } /** * @dev Returns the downcasted uint216 from uint256, reverting on * overflow (when the input is greater than largest uint216). * * Counterpart to Solidity's `uint216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toUint216(uint256 value) internal pure returns (uint216) { require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits"); return uint216(value); } /** * @dev Returns the downcasted uint208 from uint256, reverting on * overflow (when the input is greater than largest uint208). * * Counterpart to Solidity's `uint208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toUint208(uint256 value) internal pure returns (uint208) { require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits"); return uint208(value); } /** * @dev Returns the downcasted uint200 from uint256, reverting on * overflow (when the input is greater than largest uint200). * * Counterpart to Solidity's `uint200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toUint200(uint256 value) internal pure returns (uint200) { require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits"); return uint200(value); } /** * @dev Returns the downcasted uint192 from uint256, reverting on * overflow (when the input is greater than largest uint192). * * Counterpart to Solidity's `uint192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toUint192(uint256 value) internal pure returns (uint192) { require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits"); return uint192(value); } /** * @dev Returns the downcasted uint184 from uint256, reverting on * overflow (when the input is greater than largest uint184). * * Counterpart to Solidity's `uint184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toUint184(uint256 value) internal pure returns (uint184) { require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits"); return uint184(value); } /** * @dev Returns the downcasted uint176 from uint256, reverting on * overflow (when the input is greater than largest uint176). * * Counterpart to Solidity's `uint176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toUint176(uint256 value) internal pure returns (uint176) { require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits"); return uint176(value); } /** * @dev Returns the downcasted uint168 from uint256, reverting on * overflow (when the input is greater than largest uint168). * * Counterpart to Solidity's `uint168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toUint168(uint256 value) internal pure returns (uint168) { require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits"); return uint168(value); } /** * @dev Returns the downcasted uint160 from uint256, reverting on * overflow (when the input is greater than largest uint160). * * Counterpart to Solidity's `uint160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toUint160(uint256 value) internal pure returns (uint160) { require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits"); return uint160(value); } /** * @dev Returns the downcasted uint152 from uint256, reverting on * overflow (when the input is greater than largest uint152). * * Counterpart to Solidity's `uint152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toUint152(uint256 value) internal pure returns (uint152) { require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits"); return uint152(value); } /** * @dev Returns the downcasted uint144 from uint256, reverting on * overflow (when the input is greater than largest uint144). * * Counterpart to Solidity's `uint144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toUint144(uint256 value) internal pure returns (uint144) { require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits"); return uint144(value); } /** * @dev Returns the downcasted uint136 from uint256, reverting on * overflow (when the input is greater than largest uint136). * * Counterpart to Solidity's `uint136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toUint136(uint256 value) internal pure returns (uint136) { require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits"); return uint136(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v2.5._ */ function toUint128(uint256 value) internal pure returns (uint128) { require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits"); return uint128(value); } /** * @dev Returns the downcasted uint120 from uint256, reverting on * overflow (when the input is greater than largest uint120). * * Counterpart to Solidity's `uint120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toUint120(uint256 value) internal pure returns (uint120) { require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits"); return uint120(value); } /** * @dev Returns the downcasted uint112 from uint256, reverting on * overflow (when the input is greater than largest uint112). * * Counterpart to Solidity's `uint112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toUint112(uint256 value) internal pure returns (uint112) { require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits"); return uint112(value); } /** * @dev Returns the downcasted uint104 from uint256, reverting on * overflow (when the input is greater than largest uint104). * * Counterpart to Solidity's `uint104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toUint104(uint256 value) internal pure returns (uint104) { require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits"); return uint104(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.2._ */ function toUint96(uint256 value) internal pure returns (uint96) { require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits"); return uint96(value); } /** * @dev Returns the downcasted uint88 from uint256, reverting on * overflow (when the input is greater than largest uint88). * * Counterpart to Solidity's `uint88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toUint88(uint256 value) internal pure returns (uint88) { require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits"); return uint88(value); } /** * @dev Returns the downcasted uint80 from uint256, reverting on * overflow (when the input is greater than largest uint80). * * Counterpart to Solidity's `uint80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toUint80(uint256 value) internal pure returns (uint80) { require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits"); return uint80(value); } /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toUint72(uint256 value) internal pure returns (uint72) { require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits"); return uint72(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v2.5._ */ function toUint64(uint256 value) internal pure returns (uint64) { require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits"); return uint64(value); } /** * @dev Returns the downcasted uint56 from uint256, reverting on * overflow (when the input is greater than largest uint56). * * Counterpart to Solidity's `uint56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toUint56(uint256 value) internal pure returns (uint56) { require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits"); return uint56(value); } /** * @dev Returns the downcasted uint48 from uint256, reverting on * overflow (when the input is greater than largest uint48). * * Counterpart to Solidity's `uint48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toUint48(uint256 value) internal pure returns (uint48) { require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits"); return uint48(value); } /** * @dev Returns the downcasted uint40 from uint256, reverting on * overflow (when the input is greater than largest uint40). * * Counterpart to Solidity's `uint40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toUint40(uint256 value) internal pure returns (uint40) { require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits"); return uint40(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v2.5._ */ function toUint32(uint256 value) internal pure returns (uint32) { require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits"); return uint32(value); } /** * @dev Returns the downcasted uint24 from uint256, reverting on * overflow (when the input is greater than largest uint24). * * Counterpart to Solidity's `uint24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toUint24(uint256 value) internal pure returns (uint24) { require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits"); return uint24(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v2.5._ */ function toUint16(uint256 value) internal pure returns (uint16) { require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits"); return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v2.5._ */ function toUint8(uint256 value) internal pure returns (uint8) { require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits"); return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. * * _Available since v3.0._ */ function toUint256(int256 value) internal pure returns (uint256) { require(value >= 0, "SafeCast: value must be positive"); return uint256(value); } /** * @dev Returns the downcasted int248 from int256, reverting on * overflow (when the input is less than smallest int248 or * greater than largest int248). * * Counterpart to Solidity's `int248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toInt248(int256 value) internal pure returns (int248 downcasted) { downcasted = int248(value); require(downcasted == value, "SafeCast: value doesn't fit in 248 bits"); } /** * @dev Returns the downcasted int240 from int256, reverting on * overflow (when the input is less than smallest int240 or * greater than largest int240). * * Counterpart to Solidity's `int240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toInt240(int256 value) internal pure returns (int240 downcasted) { downcasted = int240(value); require(downcasted == value, "SafeCast: value doesn't fit in 240 bits"); } /** * @dev Returns the downcasted int232 from int256, reverting on * overflow (when the input is less than smallest int232 or * greater than largest int232). * * Counterpart to Solidity's `int232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toInt232(int256 value) internal pure returns (int232 downcasted) { downcasted = int232(value); require(downcasted == value, "SafeCast: value doesn't fit in 232 bits"); } /** * @dev Returns the downcasted int224 from int256, reverting on * overflow (when the input is less than smallest int224 or * greater than largest int224). * * Counterpart to Solidity's `int224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.7._ */ function toInt224(int256 value) internal pure returns (int224 downcasted) { downcasted = int224(value); require(downcasted == value, "SafeCast: value doesn't fit in 224 bits"); } /** * @dev Returns the downcasted int216 from int256, reverting on * overflow (when the input is less than smallest int216 or * greater than largest int216). * * Counterpart to Solidity's `int216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toInt216(int256 value) internal pure returns (int216 downcasted) { downcasted = int216(value); require(downcasted == value, "SafeCast: value doesn't fit in 216 bits"); } /** * @dev Returns the downcasted int208 from int256, reverting on * overflow (when the input is less than smallest int208 or * greater than largest int208). * * Counterpart to Solidity's `int208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toInt208(int256 value) internal pure returns (int208 downcasted) { downcasted = int208(value); require(downcasted == value, "SafeCast: value doesn't fit in 208 bits"); } /** * @dev Returns the downcasted int200 from int256, reverting on * overflow (when the input is less than smallest int200 or * greater than largest int200). * * Counterpart to Solidity's `int200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toInt200(int256 value) internal pure returns (int200 downcasted) { downcasted = int200(value); require(downcasted == value, "SafeCast: value doesn't fit in 200 bits"); } /** * @dev Returns the downcasted int192 from int256, reverting on * overflow (when the input is less than smallest int192 or * greater than largest int192). * * Counterpart to Solidity's `int192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toInt192(int256 value) internal pure returns (int192 downcasted) { downcasted = int192(value); require(downcasted == value, "SafeCast: value doesn't fit in 192 bits"); } /** * @dev Returns the downcasted int184 from int256, reverting on * overflow (when the input is less than smallest int184 or * greater than largest int184). * * Counterpart to Solidity's `int184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toInt184(int256 value) internal pure returns (int184 downcasted) { downcasted = int184(value); require(downcasted == value, "SafeCast: value doesn't fit in 184 bits"); } /** * @dev Returns the downcasted int176 from int256, reverting on * overflow (when the input is less than smallest int176 or * greater than largest int176). * * Counterpart to Solidity's `int176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toInt176(int256 value) internal pure returns (int176 downcasted) { downcasted = int176(value); require(downcasted == value, "SafeCast: value doesn't fit in 176 bits"); } /** * @dev Returns the downcasted int168 from int256, reverting on * overflow (when the input is less than smallest int168 or * greater than largest int168). * * Counterpart to Solidity's `int168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toInt168(int256 value) internal pure returns (int168 downcasted) { downcasted = int168(value); require(downcasted == value, "SafeCast: value doesn't fit in 168 bits"); } /** * @dev Returns the downcasted int160 from int256, reverting on * overflow (when the input is less than smallest int160 or * greater than largest int160). * * Counterpart to Solidity's `int160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toInt160(int256 value) internal pure returns (int160 downcasted) { downcasted = int160(value); require(downcasted == value, "SafeCast: value doesn't fit in 160 bits"); } /** * @dev Returns the downcasted int152 from int256, reverting on * overflow (when the input is less than smallest int152 or * greater than largest int152). * * Counterpart to Solidity's `int152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toInt152(int256 value) internal pure returns (int152 downcasted) { downcasted = int152(value); require(downcasted == value, "SafeCast: value doesn't fit in 152 bits"); } /** * @dev Returns the downcasted int144 from int256, reverting on * overflow (when the input is less than smallest int144 or * greater than largest int144). * * Counterpart to Solidity's `int144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toInt144(int256 value) internal pure returns (int144 downcasted) { downcasted = int144(value); require(downcasted == value, "SafeCast: value doesn't fit in 144 bits"); } /** * @dev Returns the downcasted int136 from int256, reverting on * overflow (when the input is less than smallest int136 or * greater than largest int136). * * Counterpart to Solidity's `int136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toInt136(int256 value) internal pure returns (int136 downcasted) { downcasted = int136(value); require(downcasted == value, "SafeCast: value doesn't fit in 136 bits"); } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v3.1._ */ function toInt128(int256 value) internal pure returns (int128 downcasted) { downcasted = int128(value); require(downcasted == value, "SafeCast: value doesn't fit in 128 bits"); } /** * @dev Returns the downcasted int120 from int256, reverting on * overflow (when the input is less than smallest int120 or * greater than largest int120). * * Counterpart to Solidity's `int120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toInt120(int256 value) internal pure returns (int120 downcasted) { downcasted = int120(value); require(downcasted == value, "SafeCast: value doesn't fit in 120 bits"); } /** * @dev Returns the downcasted int112 from int256, reverting on * overflow (when the input is less than smallest int112 or * greater than largest int112). * * Counterpart to Solidity's `int112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toInt112(int256 value) internal pure returns (int112 downcasted) { downcasted = int112(value); require(downcasted == value, "SafeCast: value doesn't fit in 112 bits"); } /** * @dev Returns the downcasted int104 from int256, reverting on * overflow (when the input is less than smallest int104 or * greater than largest int104). * * Counterpart to Solidity's `int104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toInt104(int256 value) internal pure returns (int104 downcasted) { downcasted = int104(value); require(downcasted == value, "SafeCast: value doesn't fit in 104 bits"); } /** * @dev Returns the downcasted int96 from int256, reverting on * overflow (when the input is less than smallest int96 or * greater than largest int96). * * Counterpart to Solidity's `int96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.7._ */ function toInt96(int256 value) internal pure returns (int96 downcasted) { downcasted = int96(value); require(downcasted == value, "SafeCast: value doesn't fit in 96 bits"); } /** * @dev Returns the downcasted int88 from int256, reverting on * overflow (when the input is less than smallest int88 or * greater than largest int88). * * Counterpart to Solidity's `int88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toInt88(int256 value) internal pure returns (int88 downcasted) { downcasted = int88(value); require(downcasted == value, "SafeCast: value doesn't fit in 88 bits"); } /** * @dev Returns the downcasted int80 from int256, reverting on * overflow (when the input is less than smallest int80 or * greater than largest int80). * * Counterpart to Solidity's `int80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toInt80(int256 value) internal pure returns (int80 downcasted) { downcasted = int80(value); require(downcasted == value, "SafeCast: value doesn't fit in 80 bits"); } /** * @dev Returns the downcasted int72 from int256, reverting on * overflow (when the input is less than smallest int72 or * greater than largest int72). * * Counterpart to Solidity's `int72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toInt72(int256 value) internal pure returns (int72 downcasted) { downcasted = int72(value); require(downcasted == value, "SafeCast: value doesn't fit in 72 bits"); } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v3.1._ */ function toInt64(int256 value) internal pure returns (int64 downcasted) { downcasted = int64(value); require(downcasted == value, "SafeCast: value doesn't fit in 64 bits"); } /** * @dev Returns the downcasted int56 from int256, reverting on * overflow (when the input is less than smallest int56 or * greater than largest int56). * * Counterpart to Solidity's `int56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toInt56(int256 value) internal pure returns (int56 downcasted) { downcasted = int56(value); require(downcasted == value, "SafeCast: value doesn't fit in 56 bits"); } /** * @dev Returns the downcasted int48 from int256, reverting on * overflow (when the input is less than smallest int48 or * greater than largest int48). * * Counterpart to Solidity's `int48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toInt48(int256 value) internal pure returns (int48 downcasted) { downcasted = int48(value); require(downcasted == value, "SafeCast: value doesn't fit in 48 bits"); } /** * @dev Returns the downcasted int40 from int256, reverting on * overflow (when the input is less than smallest int40 or * greater than largest int40). * * Counterpart to Solidity's `int40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toInt40(int256 value) internal pure returns (int40 downcasted) { downcasted = int40(value); require(downcasted == value, "SafeCast: value doesn't fit in 40 bits"); } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v3.1._ */ function toInt32(int256 value) internal pure returns (int32 downcasted) { downcasted = int32(value); require(downcasted == value, "SafeCast: value doesn't fit in 32 bits"); } /** * @dev Returns the downcasted int24 from int256, reverting on * overflow (when the input is less than smallest int24 or * greater than largest int24). * * Counterpart to Solidity's `int24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toInt24(int256 value) internal pure returns (int24 downcasted) { downcasted = int24(value); require(downcasted == value, "SafeCast: value doesn't fit in 24 bits"); } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v3.1._ */ function toInt16(int256 value) internal pure returns (int16 downcasted) { downcasted = int16(value); require(downcasted == value, "SafeCast: value doesn't fit in 16 bits"); } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v3.1._ */ function toInt8(int256 value) internal pure returns (int8 downcasted) { downcasted = int8(value); require(downcasted == value, "SafeCast: value doesn't fit in 8 bits"); } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. * * _Available since v3.0._ */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256"); return int256(value); }}

File 3 of 13 : SemVer.sol

// SPDX-License-Identifier: MITpragma solidity 0.8.24;/// @dev The number of bits dedicated to the "patch" portion of the protocol version./// This also defines the bit starting from which the "minor" part is located.uint256 constant SEMVER_MINOR_OFFSET = 32;/// @dev The number of bits dedicated to the "patch" and "minor" portions of the protocol version./// This also defines the bit starting from which the "major" part is located./// Note, that currently, only major version of "0" is supported.uint256 constant SEMVER_MAJOR_OFFSET = 64;/** * @author Matter Labs * @custom:security-contact [emailprotected] * @notice The library for managing SemVer for the protocol version. */library SemVer { /// @notice Unpacks the SemVer version from a single uint256 into major, minor and patch components. /// @param _packedProtocolVersion The packed protocol version. /// @return major The major version. /// @return minor The minor version. /// @return patch The patch version. function unpackSemVer( uint96 _packedProtocolVersion ) internal pure returns (uint32 major, uint32 minor, uint32 patch) { patch = uint32(_packedProtocolVersion); minor = uint32(_packedProtocolVersion >> SEMVER_MINOR_OFFSET); major = uint32(_packedProtocolVersion >> SEMVER_MAJOR_OFFSET); } /// @notice Packs the SemVer version from the major, minor and patch components into a single uint96. /// @param _major The major version. /// @param _minor The minor version. /// @param _patch The patch version. /// @return packedProtocolVersion The packed protocol version. function packSemVer( uint32 _major, uint32 _minor, uint32 _patch ) internal pure returns (uint96 packedProtocolVersion) { packedProtocolVersion = uint96(_patch) | (uint96(_minor) << SEMVER_MINOR_OFFSET) | (uint96(_major) << SEMVER_MAJOR_OFFSET); }}

File 4 of 13 : UncheckedMath.sol

// SPDX-License-Identifier: MITpragma solidity 0.8.24;/** * @author Matter Labs * @custom:security-contact [emailprotected] * @notice The library for unchecked math. */library UncheckedMath { function uncheckedInc(uint256 _number) internal pure returns (uint256) { unchecked { return _number + 1; } } function uncheckedAdd(uint256 _lhs, uint256 _rhs) internal pure returns (uint256) { unchecked { return _lhs + _rhs; } }}

File 5 of 13 : ReentrancyGuard.sol

// SPDX-License-Identifier: MITpragma solidity 0.8.24;/** * @custom:security-contact [emailprotected] * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. * * _Since v2.5.0:_ this module is now much more gas efficient, given net gas * metering changes introduced in the Istanbul hardfork. */abstract contract ReentrancyGuard { /// @dev Address of lock flag variable. /// @dev Flag is placed at random memory location to not interfere with Storage contract. // keccak256("ReentrancyGuard") - 1; uint256 private constant LOCK_FLAG_ADDRESS = 0x8e94fed44239eb2314ab7a406345e6c5a8f0ccedf3b600de3d004e672c33abf4; // solhint-disable-next-line max-line-length // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/566a774222707e424896c0c390a84dc3c13bdcb2/contracts/security/ReentrancyGuard.sol // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; modifier reentrancyGuardInitializer() { _initializeReentrancyGuard(); _; } function _initializeReentrancyGuard() private { uint256 lockSlotOldValue; // Storing an initial non-zero value makes deployment a bit more // expensive but in exchange every call to nonReentrant // will be cheaper. assembly { lockSlotOldValue := sload(LOCK_FLAG_ADDRESS) sstore(LOCK_FLAG_ADDRESS, _NOT_ENTERED) } // Check that storage slot for reentrancy guard is empty to rule out possibility of slot conflict require(lockSlotOldValue == 0, "1B"); } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and make it call a * `private` function that does the actual work. */ modifier nonReentrant() { uint256 _status; assembly { _status := sload(LOCK_FLAG_ADDRESS) } // On the first call to nonReentrant, _notEntered will be true require(_status == _NOT_ENTERED, "r1"); // Any calls to nonReentrant after this point will fail assembly { sstore(LOCK_FLAG_ADDRESS, _ENTERED) } _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) assembly { sstore(LOCK_FLAG_ADDRESS, _NOT_ENTERED) } }}

File 6 of 13 : ZkSyncHyperchainBase.sol

// SPDX-License-Identifier: MITpragma solidity 0.8.24;import {ZkSyncHyperchainStorage} from "../ZkSyncHyperchainStorage.sol";import {ReentrancyGuard} from "../../../common/ReentrancyGuard.sol";/// @title Base contract containing functions accessible to the other facets./// @author Matter Labs/// @custom:security-contact [emailprotected]contract ZkSyncHyperchainBase is ReentrancyGuard { // slither-disable-next-line uninitialized-state ZkSyncHyperchainStorage internal s; /// @notice Checks that the message sender is an active admin modifier onlyAdmin() { require(msg.sender == s.admin, "Hyperchain: not admin"); _; } /// @notice Checks if validator is active modifier onlyValidator() { require(s.validators[msg.sender], "Hyperchain: not validator"); _; } modifier onlyStateTransitionManager() { require(msg.sender == s.stateTransitionManager, "Hyperchain: not state transition manager"); _; } modifier onlyBridgehub() { require(msg.sender == s.bridgehub, "Hyperchain: not bridgehub"); _; } modifier onlyAdminOrStateTransitionManager() { require( msg.sender == s.admin || msg.sender == s.stateTransitionManager, "Hyperchain: Only by admin or state transition manager" ); _; } modifier onlyValidatorOrStateTransitionManager() { require( s.validators[msg.sender] || msg.sender == s.stateTransitionManager, "Hyperchain: Only by validator or state transition manager" ); _; } modifier onlyBaseTokenBridge() { require(msg.sender == s.baseTokenBridge, "Hyperchain: Only base token bridge can call this function"); _; }}

File 7 of 13 : ZkSyncHyperchainStorage.sol

// SPDX-License-Identifier: MITpragma solidity 0.8.24;import {IVerifier, VerifierParams} from "../chain-interfaces/IVerifier.sol";import {PriorityQueue} from "../../state-transition/libraries/PriorityQueue.sol";/// @notice Indicates whether an upgrade is initiated and if yes what type/// @param None Upgrade is NOT initiated/// @param Transparent Fully transparent upgrade is initiated, upgrade data is publicly known/// @param Shadow Shadow upgrade is initiated, upgrade data is hiddenenum UpgradeState { None, Transparent, Shadow}/// @dev Logically separated part of the storage structure, which is responsible for everything related to proxy/// upgrades and diamond cuts/// @param proposedUpgradeHash The hash of the current upgrade proposal, zero if there is no active proposal/// @param state Indicates whether an upgrade is initiated and if yes what type/// @param securityCouncil Address which has the permission to approve instant upgrades (expected to be a Gnosis/// multisig)/// @param approvedBySecurityCouncil Indicates whether the security council has approved the upgrade/// @param proposedUpgradeTimestamp The timestamp when the upgrade was proposed, zero if there are no active proposals/// @param currentProposalId The serial number of proposed upgrades, increments when proposing a new onestruct UpgradeStorage { bytes32 proposedUpgradeHash; UpgradeState state; address securityCouncil; bool approvedBySecurityCouncil; uint40 proposedUpgradeTimestamp; uint40 currentProposalId;}/// @notice The struct that describes whether users will be charged for pubdata for L1->L2 transactions./// @param Rollup The users are charged for pubdata & it is priced based on the gas price on Ethereum./// @param Validium The pubdata is considered free with regard to the L1 gas price.enum PubdataPricingMode { Rollup, Validium}/// @notice The fee params for L1->L2 transactions for the network./// @param pubdataPricingMode How the users will charged for pubdata in L1->L2 transactions./// @param batchOverheadL1Gas The amount of L1 gas required to process the batch (except for the calldata)./// @param maxPubdataPerBatch The maximal number of pubdata that can be emitted per batch./// @param priorityTxMaxPubdata The maximal amount of pubdata a priority transaction is allowed to publish./// It can be slightly less than maxPubdataPerBatch in order to have some margin for the bootloader execution./// @param minimalL2GasPrice The minimal L2 gas price to be used by L1->L2 transactions. It should represent/// the price that a single unit of compute costs.struct FeeParams { PubdataPricingMode pubdataPricingMode; uint32 batchOverheadL1Gas; uint32 maxPubdataPerBatch; uint32 maxL2GasPerBatch; uint32 priorityTxMaxPubdata; uint64 minimalL2GasPrice;}/// @dev storing all storage variables for hyperchain diamond facets/// NOTE: It is used in a proxy, so it is possible to add new variables to the end/// but NOT to modify already existing variables or change their order./// NOTE: variables prefixed with '__DEPRECATED_' are deprecated and shouldn't be used./// Their presence is maintained for compatibility and to prevent storage collision.struct ZkSyncHyperchainStorage { /// @dev Storage of variables needed for deprecated diamond cut facet uint256[7] __DEPRECATED_diamondCutStorage; /// @notice Address which will exercise critical changes to the Diamond Proxy (upgrades, freezing & unfreezing). Replaced by STM address __DEPRECATED_governor; /// @notice Address that the governor proposed as one that will replace it address __DEPRECATED_pendingGovernor; /// @notice List of permitted validators mapping(address validatorAddress => bool isValidator) validators; /// @dev Verifier contract. Used to verify aggregated proof for batches IVerifier verifier; /// @notice Total number of executed batches i.e. batches[totalBatchesExecuted] points at the latest executed batch /// (batch 0 is genesis) uint256 totalBatchesExecuted; /// @notice Total number of proved batches i.e. batches[totalBatchesProved] points at the latest proved batch uint256 totalBatchesVerified; /// @notice Total number of committed batches i.e. batches[totalBatchesCommitted] points at the latest committed /// batch uint256 totalBatchesCommitted; /// @dev Stored hashed StoredBatch for batch number mapping(uint256 batchNumber => bytes32 batchHash) storedBatchHashes; /// @dev Stored root hashes of L2 -> L1 logs mapping(uint256 batchNumber => bytes32 l2LogsRootHash) l2LogsRootHashes; /// @dev Container that stores transactions requested from L1 PriorityQueue.Queue priorityQueue; /// @dev The smart contract that manages the list with permission to call contract functions address __DEPRECATED_allowList; VerifierParams __DEPRECATED_verifierParams; /// @notice Bytecode hash of bootloader program. /// @dev Used as an input to zkp-circuit. bytes32 l2BootloaderBytecodeHash; /// @notice Bytecode hash of default account (bytecode for EOA). /// @dev Used as an input to zkp-circuit. bytes32 l2DefaultAccountBytecodeHash; /// @dev Indicates that the porter may be touched on L2 transactions. /// @dev Used as an input to zkp-circuit. bool zkPorterIsAvailable; /// @dev The maximum number of the L2 gas that a user can request for L1 -> L2 transactions /// @dev This is the maximum number of L2 gas that is available for the "body" of the transaction, i.e. /// without overhead for proving the batch. uint256 priorityTxMaxGasLimit; /// @dev Storage of variables needed for upgrade facet UpgradeStorage __DEPRECATED_upgrades; /// @dev A mapping L2 batch number => message number => flag. /// @dev The L2 -> L1 log is sent for every withdrawal, so this mapping is serving as /// a flag to indicate that the message was already processed. /// @dev Used to indicate that eth withdrawal was already processed mapping(uint256 l2BatchNumber => mapping(uint256 l2ToL1MessageNumber => bool isFinalized)) isEthWithdrawalFinalized; /// @dev The most recent withdrawal time and amount reset uint256 __DEPRECATED_lastWithdrawalLimitReset; /// @dev The accumulated withdrawn amount during the withdrawal limit window uint256 __DEPRECATED_withdrawnAmountInWindow; /// @dev A mapping user address => the total deposited amount by the user mapping(address => uint256) __DEPRECATED_totalDepositedAmountPerUser; /// @dev Stores the protocol version. Note, that the protocol version may not only encompass changes to the /// smart contracts, but also to the node behavior. uint256 protocolVersion; /// @dev Hash of the system contract upgrade transaction. If 0, then no upgrade transaction needs to be done. bytes32 l2SystemContractsUpgradeTxHash; /// @dev Batch number where the upgrade transaction has happened. If 0, then no upgrade transaction has happened /// yet. uint256 l2SystemContractsUpgradeBatchNumber; /// @dev Address which will exercise non-critical changes to the Diamond Proxy (changing validator set & unfreezing) address admin; /// @notice Address that the admin proposed as one that will replace admin role address pendingAdmin; /// @dev Fee params used to derive gasPrice for the L1->L2 transactions. For L2 transactions, /// the bootloader gives enough freedom to the operator. FeeParams feeParams; /// @dev Address of the blob versioned hash getter smart contract used for EIP-4844 versioned hashes. address blobVersionedHashRetriever; /// @dev The chainId of the chain uint256 chainId; /// @dev The address of the bridgehub address bridgehub; /// @dev The address of the StateTransitionManager address stateTransitionManager; /// @dev The address of the baseToken contract. Eth is address(1) address baseToken; /// @dev The address of the baseTokenbridge. Eth also uses the shared bridge address baseTokenBridge; /// @notice gasPriceMultiplier for each baseToken, so that each L1->L2 transaction pays for its transaction on the destination /// we multiply by the nominator, and divide by the denominator uint128 baseTokenGasPriceMultiplierNominator; uint128 baseTokenGasPriceMultiplierDenominator; /// @dev The optional address of the contract that has to be used for transaction filtering/whitelisting address transactionFilterer;}

File 8 of 13 : IGetters.sol

// SPDX-License-Identifier: MITpragma solidity 0.8.24;import {PriorityOperation} from "../libraries/PriorityQueue.sol";import {VerifierParams} from "../chain-interfaces/IVerifier.sol";import {PubdataPricingMode} from "../chain-deps/ZkSyncHyperchainStorage.sol";import {IZkSyncHyperchainBase} from "./IZkSyncHyperchainBase.sol";/// @title The interface of the Getters Contract that implements functions for getting contract state from outside the blockchain./// @author Matter Labs/// @custom:security-contact [emailprotected]interface IGetters is IZkSyncHyperchainBase { /*////////////////////////////////////////////////////////////// CUSTOM GETTERS //////////////////////////////////////////////////////////////*/ /// @return The address of the verifier smart contract function getVerifier() external view returns (address); /// @return The address of the current admin function getAdmin() external view returns (address); /// @return The address of the pending admin function getPendingAdmin() external view returns (address); /// @return The address of the bridgehub function getBridgehub() external view returns (address); /// @return The address of the state transition function getStateTransitionManager() external view returns (address); /// @return The address of the base token function getBaseToken() external view returns (address); /// @return The address of the base token bridge function getBaseTokenBridge() external view returns (address); /// @return The total number of batches that were committed function getTotalBatchesCommitted() external view returns (uint256); /// @return The total number of batches that were committed & verified function getTotalBatchesVerified() external view returns (uint256); /// @return The total number of batches that were committed & verified & executed function getTotalBatchesExecuted() external view returns (uint256); /// @return The total number of priority operations that were added to the priority queue, including all processed ones function getTotalPriorityTxs() external view returns (uint256); /// @notice The function that returns the first unprocessed priority transaction. /// @dev Returns zero if and only if no operations were processed from the queue. /// @dev If all the transactions were processed, it will return the last processed index, so /// in case exactly *unprocessed* transactions are needed, one should check that getPriorityQueueSize() is greater than 0. /// @return Index of the oldest priority operation that wasn't processed yet function getFirstUnprocessedPriorityTx() external view returns (uint256); /// @return The number of priority operations currently in the queue function getPriorityQueueSize() external view returns (uint256); /// @return The first unprocessed priority operation from the queue function priorityQueueFrontOperation() external view returns (PriorityOperation memory); /// @return Whether the address has a validator access function isValidator(address _address) external view returns (bool); /// @return merkleRoot Merkle root of the tree with L2 logs for the selected batch function l2LogsRootHash(uint256 _batchNumber) external view returns (bytes32 merkleRoot); /// @notice For unfinalized (non executed) batches may change /// @dev returns zero for non-committed batches /// @return The hash of committed L2 batch. function storedBatchHash(uint256 _batchNumber) external view returns (bytes32); /// @return Bytecode hash of bootloader program. function getL2BootloaderBytecodeHash() external view returns (bytes32); /// @return Bytecode hash of default account (bytecode for EOA). function getL2DefaultAccountBytecodeHash() external view returns (bytes32); /// @return Verifier parameters. /// @dev This function is deprecated and will soon be removed. function getVerifierParams() external view returns (VerifierParams memory); /// @return Whether the diamond is frozen or not function isDiamondStorageFrozen() external view returns (bool); /// @return The current packed protocol version. To access human-readable version, use `getSemverProtocolVersion` function. function getProtocolVersion() external view returns (uint256); /// @return The tuple of (major, minor, patch) protocol version. function getSemverProtocolVersion() external view returns (uint32, uint32, uint32); /// @return The upgrade system contract transaction hash, 0 if the upgrade is not initialized function getL2SystemContractsUpgradeTxHash() external view returns (bytes32); /// @return The L2 batch number in which the upgrade transaction was processed. /// @dev It is equal to 0 in the following two cases: /// - No upgrade transaction has ever been processed. /// - The upgrade transaction has been processed and the batch with such transaction has been /// executed (i.e. finalized). function getL2SystemContractsUpgradeBatchNumber() external view returns (uint256); /// @return The maximum number of L2 gas that a user can request for L1 -> L2 transactions function getPriorityTxMaxGasLimit() external view returns (uint256); /// @return Whether a withdrawal has been finalized. /// @param _l2BatchNumber The L2 batch number within which the withdrawal happened. /// @param _l2MessageIndex The index of the L2->L1 message denoting the withdrawal. function isEthWithdrawalFinalized(uint256 _l2BatchNumber, uint256 _l2MessageIndex) external view returns (bool); /// @return The pubdata pricing mode. function getPubdataPricingMode() external view returns (PubdataPricingMode); /// @return the baseTokenGasPriceMultiplierNominator, used to compare the baseTokenPrice to ether for L1->L2 transactions function baseTokenGasPriceMultiplierNominator() external view returns (uint128); /// @return the baseTokenGasPriceMultiplierDenominator, used to compare the baseTokenPrice to ether for L1->L2 transactions function baseTokenGasPriceMultiplierDenominator() external view returns (uint128); /*////////////////////////////////////////////////////////////// DIAMOND LOUPE //////////////////////////////////////////////////////////////*/ /// @notice Faсet structure compatible with the EIP-2535 diamond loupe /// @param addr The address of the facet contract /// @param selectors The NON-sorted array with selectors associated with facet struct Facet { address addr; bytes4[] selectors; } /// @return result All facet addresses and their function selectors function facets() external view returns (Facet[] memory); /// @return NON-sorted array with function selectors supported by a specific facet function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory); /// @return facets NON-sorted array of facet addresses supported on diamond function facetAddresses() external view returns (address[] memory facets); /// @return facet The facet address associated with a selector. Zero if the selector is not added to the diamond function facetAddress(bytes4 _selector) external view returns (address facet); /// @return Whether the selector can be frozen by the admin or always accessible function isFunctionFreezable(bytes4 _selector) external view returns (bool); /// @return isFreezable Whether the facet can be frozen by the admin or always accessible function isFacetFreezable(address _facet) external view returns (bool isFreezable);}

File 9 of 13 : ILegacyGetters.sol

// SPDX-License-Identifier: MITpragma solidity 0.8.24;import {IZkSyncHyperchainBase} from "./IZkSyncHyperchainBase.sol";/// @author Matter Labs/// @dev This interface contains getters for the zkSync contract that should not be used,/// but still are kept for backward compatibility./// @custom:security-contact [emailprotected]interface ILegacyGetters is IZkSyncHyperchainBase { /// @return The total number of batches that were committed /// @dev It is a *deprecated* method, please use `getTotalBatchesCommitted` instead function getTotalBlocksCommitted() external view returns (uint256); /// @return The total number of batches that were committed & verified /// @dev It is a *deprecated* method, please use `getTotalBatchesVerified` instead. function getTotalBlocksVerified() external view returns (uint256); /// @return The total number of batches that were committed & verified & executed /// @dev It is a *deprecated* method, please use `getTotalBatchesExecuted` instead. function getTotalBlocksExecuted() external view returns (uint256); /// @notice For unfinalized (non executed) batches may change /// @dev It is a *deprecated* method, please use `storedBatchHash` instead. /// @dev returns zero for non-committed batches /// @return The hash of committed L2 batch. function storedBlockHash(uint256 _batchNumber) external view returns (bytes32); /// @return The L2 batch number in which the upgrade transaction was processed. /// @dev It is a *deprecated* method, please use `getL2SystemContractsUpgradeBatchNumber` instead. /// @dev It is equal to 0 in the following two cases: /// - No upgrade transaction has ever been processed. /// - The upgrade transaction has been processed and the batch with such transaction has been /// executed (i.e. finalized). function getL2SystemContractsUpgradeBlockNumber() external view returns (uint256);}

File 10 of 13 : IVerifier.sol

// SPDX-License-Identifier: MITpragma solidity 0.8.24;/// @notice Part of the configuration parameters of ZKP circuitsstruct VerifierParams { bytes32 recursionNodeLevelVkHash; bytes32 recursionLeafLevelVkHash; bytes32 recursionCircuitsSetVksHash;}/// @title The interface of the Verifier contract, responsible for the zero knowledge proof verification./// @author Matter Labs/// @custom:security-contact [emailprotected]interface IVerifier { /// @dev Verifies a zk-SNARK proof. /// @return A boolean value indicating whether the zk-SNARK proof is valid. /// Note: The function may revert execution instead of returning false in some cases. function verify( uint256[] calldata _publicInputs, uint256[] calldata _proof, uint256[] calldata _recursiveAggregationInput ) external view returns (bool); /// @notice Calculates a keccak256 hash of the runtime loaded verification keys. /// @return vkHash The keccak256 hash of the loaded verification keys. function verificationKeyHash() external pure returns (bytes32);}

File 11 of 13 : IZkSyncHyperchainBase.sol

// SPDX-License-Identifier: UNLICENSEDpragma solidity 0.8.24;/// @title The interface of the zkSync contract, responsible for the main zkSync logic./// @author Matter Labs/// @custom:security-contact [emailprotected]interface IZkSyncHyperchainBase { /// @return Returns facet name. function getName() external view returns (string memory);}

File 12 of 13 : Diamond.sol

// SPDX-License-Identifier: MITpragma solidity 0.8.24;import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";import {UncheckedMath} from "../../common/libraries/UncheckedMath.sol";/// @author Matter Labs/// @custom:security-contact [emailprotected]/// @notice The helper library for managing the EIP-2535 diamond proxy.library Diamond { using UncheckedMath for uint256; using SafeCast for uint256; /// @dev Magic value that should be returned by diamond cut initialize contracts. /// @dev Used to distinguish calls to contracts that were supposed to be used as diamond initializer from other contracts. bytes32 internal constant DIAMOND_INIT_SUCCESS_RETURN_VALUE = 0x33774e659306e47509050e97cb651e731180a42d458212294d30751925c551a2; // keccak256("diamond.zksync.init") - 1 /// @dev Storage position of `DiamondStorage` structure. bytes32 private constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b; // keccak256("diamond.standard.diamond.storage") - 1; event DiamondCut(FacetCut[] facetCuts, address initAddress, bytes initCalldata); /// @dev Utility struct that contains associated facet & meta information of selector /// @param facetAddress address of the facet which is connected with selector /// @param selectorPosition index in `FacetToSelectors.selectors` array, where is selector stored /// @param isFreezable denotes whether the selector can be frozen. struct SelectorToFacet { address facetAddress; uint16 selectorPosition; bool isFreezable; } /// @dev Utility struct that contains associated selectors & meta information of facet /// @param selectors list of all selectors that belong to the facet /// @param facetPosition index in `DiamondStorage.facets` array, where is facet stored struct FacetToSelectors { bytes4[] selectors; uint16 facetPosition; } /// @notice The structure that holds all diamond proxy associated parameters /// @dev According to the EIP-2535 should be stored on a special storage key - `DIAMOND_STORAGE_POSITION` /// @param selectorToFacet A mapping from the selector to the facet address and its meta information /// @param facetToSelectors A mapping from facet address to its selectors with meta information /// @param facets The array of all unique facet addresses that belong to the diamond proxy /// @param isFrozen Denotes whether the diamond proxy is frozen and all freezable facets are not accessible struct DiamondStorage { mapping(bytes4 selector => SelectorToFacet selectorInfo) selectorToFacet; mapping(address facetAddress => FacetToSelectors facetInfo) facetToSelectors; address[] facets; bool isFrozen; } /// @dev Parameters for diamond changes that touch one of the facets /// @param facet The address of facet that's affected by the cut /// @param action The action that is made on the facet /// @param isFreezable Denotes whether the facet & all their selectors can be frozen /// @param selectors An array of unique selectors that belongs to the facet address struct FacetCut { address facet; Action action; bool isFreezable; bytes4[] selectors; } /// @dev Structure of the diamond proxy changes /// @param facetCuts The set of changes (adding/removing/replacement) of implementation contracts /// @param initAddress The address that's delegate called after setting up new facet changes /// @param initCalldata Calldata for the delegate call to `initAddress` struct DiamondCutData { FacetCut[] facetCuts; address initAddress; bytes initCalldata; } /// @dev Type of change over diamond: add/replace/remove facets enum Action { Add, Replace, Remove } /// @return diamondStorage The pointer to the storage where all specific diamond proxy parameters stored function getDiamondStorage() internal pure returns (DiamondStorage storage diamondStorage) { bytes32 position = DIAMOND_STORAGE_POSITION; assembly { diamondStorage.slot := position } } /// @dev Add/replace/remove any number of selectors and optionally execute a function with delegatecall /// @param _diamondCut Diamond's facet changes and the parameters to optional initialization delegatecall function diamondCut(DiamondCutData memory _diamondCut) internal { FacetCut[] memory facetCuts = _diamondCut.facetCuts; address initAddress = _diamondCut.initAddress; bytes memory initCalldata = _diamondCut.initCalldata; uint256 facetCutsLength = facetCuts.length; for (uint256 i = 0; i < facetCutsLength; i = i.uncheckedInc()) { Action action = facetCuts[i].action; address facet = facetCuts[i].facet; bool isFacetFreezable = facetCuts[i].isFreezable; bytes4[] memory selectors = facetCuts[i].selectors; require(selectors.length > 0, "B"); // no functions for diamond cut if (action == Action.Add) { _addFunctions(facet, selectors, isFacetFreezable); } else if (action == Action.Replace) { _replaceFunctions(facet, selectors, isFacetFreezable); } else if (action == Action.Remove) { _removeFunctions(facet, selectors); } else { revert("C"); // undefined diamond cut action } } _initializeDiamondCut(initAddress, initCalldata); emit DiamondCut(facetCuts, initAddress, initCalldata); } /// @dev Add new functions to the diamond proxy /// NOTE: expect but NOT enforce that `_selectors` is NON-EMPTY array function _addFunctions(address _facet, bytes4[] memory _selectors, bool _isFacetFreezable) private { DiamondStorage storage ds = getDiamondStorage(); // Facet with no code cannot be added. // This check also verifies that the facet does not have zero address, since it is the // address with which 0x00000000 selector is associated. require(_facet.code.length > 0, "G"); // Add facet to the list of facets if the facet address is new one _saveFacetIfNew(_facet); uint256 selectorsLength = _selectors.length; for (uint256 i = 0; i < selectorsLength; i = i.uncheckedInc()) { bytes4 selector = _selectors[i]; SelectorToFacet memory oldFacet = ds.selectorToFacet[selector]; require(oldFacet.facetAddress == address(0), "J"); // facet for this selector already exists _addOneFunction(_facet, selector, _isFacetFreezable); } } /// @dev Change associated facets to already known function selectors /// NOTE: expect but NOT enforce that `_selectors` is NON-EMPTY array function _replaceFunctions(address _facet, bytes4[] memory _selectors, bool _isFacetFreezable) private { DiamondStorage storage ds = getDiamondStorage(); // Facet with no code cannot be added. // This check also verifies that the facet does not have zero address, since it is the // address with which 0x00000000 selector is associated. require(_facet.code.length > 0, "K"); uint256 selectorsLength = _selectors.length; for (uint256 i = 0; i < selectorsLength; i = i.uncheckedInc()) { bytes4 selector = _selectors[i]; SelectorToFacet memory oldFacet = ds.selectorToFacet[selector]; require(oldFacet.facetAddress != address(0), "L"); // it is impossible to replace the facet with zero address _removeOneFunction(oldFacet.facetAddress, selector); // Add facet to the list of facets if the facet address is a new one _saveFacetIfNew(_facet); _addOneFunction(_facet, selector, _isFacetFreezable); } } /// @dev Remove association with function and facet /// NOTE: expect but NOT enforce that `_selectors` is NON-EMPTY array function _removeFunctions(address _facet, bytes4[] memory _selectors) private { DiamondStorage storage ds = getDiamondStorage(); require(_facet == address(0), "a1"); // facet address must be zero uint256 selectorsLength = _selectors.length; for (uint256 i = 0; i < selectorsLength; i = i.uncheckedInc()) { bytes4 selector = _selectors[i]; SelectorToFacet memory oldFacet = ds.selectorToFacet[selector]; require(oldFacet.facetAddress != address(0), "a2"); // Can't delete a non-existent facet _removeOneFunction(oldFacet.facetAddress, selector); } } /// @dev Add address to the list of known facets if it is not on the list yet /// NOTE: should be called ONLY before adding a new selector associated with the address function _saveFacetIfNew(address _facet) private { DiamondStorage storage ds = getDiamondStorage(); uint256 selectorsLength = ds.facetToSelectors[_facet].selectors.length; // If there are no selectors associated with facet then save facet as new one if (selectorsLength == 0) { ds.facetToSelectors[_facet].facetPosition = ds.facets.length.toUint16(); ds.facets.push(_facet); } } /// @dev Add one function to the already known facet /// NOTE: It is expected but NOT enforced that: /// - `_facet` is NON-ZERO address /// - `_facet` is already stored address in `DiamondStorage.facets` /// - `_selector` is NOT associated by another facet function _addOneFunction(address _facet, bytes4 _selector, bool _isSelectorFreezable) private { DiamondStorage storage ds = getDiamondStorage(); uint16 selectorPosition = (ds.facetToSelectors[_facet].selectors.length).toUint16(); // if selectorPosition is nonzero, it means it is not a new facet // so the freezability of the first selector must be matched to _isSelectorFreezable // so all the selectors in a facet will have the same freezability if (selectorPosition != 0) { bytes4 selector0 = ds.facetToSelectors[_facet].selectors[0]; require(_isSelectorFreezable == ds.selectorToFacet[selector0].isFreezable, "J1"); } ds.selectorToFacet[_selector] = SelectorToFacet({ facetAddress: _facet, selectorPosition: selectorPosition, isFreezable: _isSelectorFreezable }); ds.facetToSelectors[_facet].selectors.push(_selector); } /// @dev Remove one associated function with facet /// NOTE: It is expected but NOT enforced that `_facet` is NON-ZERO address function _removeOneFunction(address _facet, bytes4 _selector) private { DiamondStorage storage ds = getDiamondStorage(); // Get index of `FacetToSelectors.selectors` of the selector and last element of array uint256 selectorPosition = ds.selectorToFacet[_selector].selectorPosition; uint256 lastSelectorPosition = ds.facetToSelectors[_facet].selectors.length - 1; // If the selector is not at the end of the array then move the last element to the selector position if (selectorPosition != lastSelectorPosition) { bytes4 lastSelector = ds.facetToSelectors[_facet].selectors[lastSelectorPosition]; ds.facetToSelectors[_facet].selectors[selectorPosition] = lastSelector; ds.selectorToFacet[lastSelector].selectorPosition = selectorPosition.toUint16(); } // Remove last element from the selectors array ds.facetToSelectors[_facet].selectors.pop(); // Finally, clean up the association with facet delete ds.selectorToFacet[_selector]; // If there are no selectors for facet then remove the facet from the list of known facets if (lastSelectorPosition == 0) { _removeFacet(_facet); } } /// @dev remove facet from the list of known facets /// NOTE: It is expected but NOT enforced that there are no selectors associated with `_facet` function _removeFacet(address _facet) private { DiamondStorage storage ds = getDiamondStorage(); // Get index of `DiamondStorage.facets` of the facet and last element of array uint256 facetPosition = ds.facetToSelectors[_facet].facetPosition; uint256 lastFacetPosition = ds.facets.length - 1; // If the facet is not at the end of the array then move the last element to the facet position if (facetPosition != lastFacetPosition) { address lastFacet = ds.facets[lastFacetPosition]; ds.facets[facetPosition] = lastFacet; ds.facetToSelectors[lastFacet].facetPosition = facetPosition.toUint16(); } // Remove last element from the facets array ds.facets.pop(); } /// @dev Delegates call to the initialization address with provided calldata /// @dev Used as a final step of diamond cut to execute the logic of the initialization for changed facets function _initializeDiamondCut(address _init, bytes memory _calldata) private { if (_init == address(0)) { require(_calldata.length == 0, "H"); // Non-empty calldata for zero address } else { // Do not check whether `_init` is a contract since later we check that it returns data. (bool success, bytes memory data) = _init.delegatecall(_calldata); if (!success) { // If the returndata is too small, we still want to produce some meaningful error if (data.length <= 4) { revert("I"); // delegatecall failed } assembly { revert(add(data, 0x20), mload(data)) } } // Check that called contract returns magic value to make sure that contract logic // supposed to be used as diamond cut initializer. require(data.length == 32, "lp"); require(abi.decode(data, (bytes32)) == DIAMOND_INIT_SUCCESS_RETURN_VALUE, "lp1"); } }}

File 13 of 13 : PriorityQueue.sol

// SPDX-License-Identifier: MITpragma solidity 0.8.24;/// @notice The structure that contains meta information of the L2 transaction that was requested from L1/// @dev The weird size of fields was selected specifically to minimize the structure storage size/// @param canonicalTxHash Hashed L2 transaction data that is needed to process it/// @param expirationTimestamp Expiration timestamp for this request (must be satisfied before)/// @param layer2Tip Additional payment to the validator as an incentive to perform the operationstruct PriorityOperation { bytes32 canonicalTxHash; uint64 expirationTimestamp; uint192 layer2Tip;}/// @author Matter Labs/// @custom:security-contact [emailprotected]/// @dev The library provides the API to interact with the priority queue container/// @dev Order of processing operations from queue - FIFO (Fist in - first out)library PriorityQueue { using PriorityQueue for Queue; /// @notice Container that stores priority operations /// @param data The inner mapping that saves priority operation by its index /// @param head The pointer to the first unprocessed priority operation, equal to the tail if the queue is empty /// @param tail The pointer to the free slot struct Queue { mapping(uint256 priorityOpId => PriorityOperation priorityOp) data; uint256 tail; uint256 head; } /// @notice Returns zero if and only if no operations were processed from the queue /// @return Index of the oldest priority operation that wasn't processed yet function getFirstUnprocessedPriorityTx(Queue storage _queue) internal view returns (uint256) { return _queue.head; } /// @return The total number of priority operations that were added to the priority queue, including all processed ones function getTotalPriorityTxs(Queue storage _queue) internal view returns (uint256) { return _queue.tail; } /// @return The total number of unprocessed priority operations in a priority queue function getSize(Queue storage _queue) internal view returns (uint256) { return uint256(_queue.tail - _queue.head); } /// @return Whether the priority queue contains no operations function isEmpty(Queue storage _queue) internal view returns (bool) { return _queue.tail == _queue.head; } /// @notice Add the priority operation to the end of the priority queue function pushBack(Queue storage _queue, PriorityOperation memory _operation) internal { // Save value into the stack to avoid double reading from the storage uint256 tail = _queue.tail; _queue.data[tail] = _operation; _queue.tail = tail + 1; } /// @return The first unprocessed priority operation from the queue function front(Queue storage _queue) internal view returns (PriorityOperation memory) { require(!_queue.isEmpty(), "D"); // priority queue is empty return _queue.data[_queue.head]; } /// @notice Remove the first unprocessed priority operation from the queue /// @return priorityOperation that was popped from the priority queue function popFront(Queue storage _queue) internal returns (PriorityOperation memory priorityOperation) { require(!_queue.isEmpty(), "s"); // priority queue is empty // Save value into the stack to avoid double reading from the storage uint256 head = _queue.head; priorityOperation = _queue.data[head]; delete _queue.data[head]; _queue.head = head + 1; }}

Settings

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

Contract Security Audit

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"baseTokenGasPriceMultiplierDenominator","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseTokenGasPriceMultiplierNominator","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"_selector","type":"bytes4"}],"name":"facetAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"facetAddresses","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_facet","type":"address"}],"name":"facetFunctionSelectors","outputs":[{"internalType":"bytes4[]","name":"","type":"bytes4[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"facets","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"bytes4[]","name":"selectors","type":"bytes4[]"}],"internalType":"struct IGetters.Facet[]","name":"result","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBaseToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBaseTokenBridge","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBridgehub","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getFirstUnprocessedPriorityTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getL2BootloaderBytecodeHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getL2DefaultAccountBytecodeHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getL2SystemContractsUpgradeBatchNumber","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getL2SystemContractsUpgradeBlockNumber","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getL2SystemContractsUpgradeTxHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPendingAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPriorityQueueSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPriorityTxMaxGasLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getProtocolVersion","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPubdataPricingMode","outputs":[{"internalType":"enum PubdataPricingMode","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSemverProtocolVersion","outputs":[{"internalType":"uint32","name":"","type":"uint32"},{"internalType":"uint32","name":"","type":"uint32"},{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStateTransitionManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalBatchesCommitted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalBatchesExecuted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalBatchesVerified","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalBlocksCommitted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalBlocksExecuted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalBlocksVerified","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalPriorityTxs","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getVerifier","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getVerifierParams","outputs":[{"components":[{"internalType":"bytes32","name":"recursionNodeLevelVkHash","type":"bytes32"},{"internalType":"bytes32","name":"recursionLeafLevelVkHash","type":"bytes32"},{"internalType":"bytes32","name":"recursionCircuitsSetVksHash","type":"bytes32"}],"internalType":"struct VerifierParams","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isDiamondStorageFrozen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_l2BatchNumber","type":"uint256"},{"internalType":"uint256","name":"_l2MessageIndex","type":"uint256"}],"name":"isEthWithdrawalFinalized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_facet","type":"address"}],"name":"isFacetFreezable","outputs":[{"internalType":"bool","name":"isFreezable","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"_selector","type":"bytes4"}],"name":"isFunctionFreezable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"isValidator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_batchNumber","type":"uint256"}],"name":"l2LogsRootHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"priorityQueueFrontOperation","outputs":[{"components":[{"internalType":"bytes32","name":"canonicalTxHash","type":"bytes32"},{"internalType":"uint64","name":"expirationTimestamp","type":"uint64"},{"internalType":"uint192","name":"layer2Tip","type":"uint192"}],"internalType":"struct PriorityOperation","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_batchNumber","type":"uint256"}],"name":"storedBatchHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_batchNumber","type":"uint256"}],"name":"storedBlockHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"}]

0x608060405234801561000f575f80fd5b50600436106102cd575f3560e01c80639cd939e41161017c578063d0468156116100dd578063ea6c029c11610093578063facd743b1161006e578063facd743b1461072f578063fd791f3c14610767578063fe26699e146106cb575f80fd5b8063ea6c029c146106e6578063ef3f0bae14610601578063f5c1182c14610700575f80fd5b8063db1f0bf9116100c3578063db1f0bf9146106cb578063e5355c75146105d1578063e81e0ba1146106d3575f80fd5b8063d0468156146106a5578063d86970d8146106c3575f80fd5b8063b22dd78e11610132578063bd7c541211610118578063bd7c541214610609578063c3bbd2d71461061c578063cdffacc61461062f575f80fd5b8063b22dd78e14610550578063b8c2f66f14610483575f80fd5b8063a1954fc511610162578063a1954fc5146105d9578063adfca15e146105e1578063af6a2dcd14610601575f80fd5b80639cd939e4146105b25780639d1b5a81146105d1575f80fd5b806346657fe9116102315780636e9960c3116101e75780637a0ed627116101c25780637a0ed627146105775780637b30c8da1461058c57806398acd7a614610594575f80fd5b80636e9960c31461053257806374f4d30d1461055057806379823c9a1461056f575f80fd5b80635518c73b116102175780635518c73b146104be57806356142d7a146104dc578063631f4bac1461052a575f80fd5b806346657fe91461048b57806352ef6b2c146104a9575f80fd5b80631de72e341161028657806333ce93fe1161026c57806333ce93fe1461045d5780633591c1a0146104655780633960738214610483575f80fd5b80631de72e34146103dc57806329b98c6714610427575f80fd5b80630ec6b0b7116102b65780630ec6b0b71461032c57806317d7de7c1461033e57806318e3a94114610387575f80fd5b806306d49e5b146102d1578063086a56f8146102ed575b5f80fd5b60265460ff166040516102e49190610f83565b60405180910390f35b602c5473ffffffffffffffffffffffffffffffffffffffff165b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020016102e4565b601a545b6040519081526020016102e4565b61037a6040518060400160405280600c81526020017f476574746572734661636574000000000000000000000000000000000000000081525081565b6040516102e49190610fc2565b60408051606080820183525f80835260208084018290529284015282518082018452601454808252601554828501908152601654928601928352855191825251938101939093525192820192909252016102e4565b602d5470010000000000000000000000000000000090046fffffffffffffffffffffffffffffffff165b6040516fffffffffffffffffffffffffffffffff90911681526020016102e4565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131e5460ff165b60405190151581526020016102e4565b602154610330565b60295473ffffffffffffffffffffffffffffffffffffffff16610307565b600b54610330565b600a5473ffffffffffffffffffffffffffffffffffffffff16610307565b6104b161076f565b6040516102e4919061102c565b602a5473ffffffffffffffffffffffffffffffffffffffff16610307565b6104e46107fe565b604080518251815260208084015167ffffffffffffffff16908201529181015177ffffffffffffffffffffffffffffffffffffffffffffffff16908201526060016102e4565b610330610829565b60245473ffffffffffffffffffffffffffffffffffffffff16610307565b61033061055e366004611085565b5f908152600e602052604090205490565b601254610330565b61057f610834565b6040516102e491906110f8565b602254610330565b602b5473ffffffffffffffffffffffffffffffffffffffff16610307565b6103306105c0366004611085565b5f908152600f602052604090205490565b602354610330565b601154610330565b6105f46105ef3660046111a0565b610a3e565b6040516102e491906111da565b600c54610330565b61044d6106173660046111ec565b610b3a565b61044d61062a3660046111a0565b610b5d565b61030761063d36600461120c565b7fffffffff00000000000000000000000000000000000000000000000000000000165f9081527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b602052604090205473ffffffffffffffffffffffffffffffffffffffff1690565b60255473ffffffffffffffffffffffffffffffffffffffff16610307565b601754610330565b600d54610330565b61044d6106e136600461120c565b610c74565b602d546fffffffffffffffffffffffffffffffff16610406565b610708610d9c565b6040805163ffffffff948516815292841660208401529216918101919091526060016102e4565b61044d61073d3660046111a0565b73ffffffffffffffffffffffffffffffffffffffff165f9081526009602052604090205460ff1690565b601854610330565b60605f7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b600281018054604080516020808402820181019092528281529394508301828280156107f357602002820191905f5260205f20905b815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116107c8575b505050505091505090565b604080516060810182525f80825260208201819052918101919091526108246010610dd9565b905090565b5f6108246010610ecd565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131d546060907fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b908067ffffffffffffffff8111156108945761089461124b565b6040519080825280602002602001820160405280156108d957816020015b604080518082019091525f8152606060208201528152602001906001900390816108b25790505b5092505f5b81811015610a38575f8360020182815481106108fc576108fc611278565b5f91825260208083209091015473ffffffffffffffffffffffffffffffffffffffff168083526001870182526040808420815181546060958102820186018452928101838152939650939092849290918491908401828280156109bd57602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168152602001906004019060208260030104928301926001038202915080841161096a5790505b50505091835250506001919091015461ffff166020918201526040805180820190915273ffffffffffffffffffffffffffffffffffffffff85168152825191810191909152875191925090879085908110610a1a57610a1a611278565b60200260200101819052505050610a318160010190565b90506108de565b50505090565b73ffffffffffffffffffffffffffffffffffffffff81165f9081527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c602090815260409182902080548351818402810184019094528084526060937fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b9390929190830182828015610b2d57602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191681526020019060040190602082600301049283019260010382029150808411610ada5790505b5050505050915050919050565b5f828152601d6020908152604080832084845290915290205460ff165b92915050565b73ffffffffffffffffffffffffffffffffffffffff81165f9081527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c60205260408120547fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b908015610c6d5773ffffffffffffffffffffffffffffffffffffffff84165f908152600183016020526040812080548290610bff57610bff611278565b5f918252602080832060088304015460079092166004026101000a90910460e01b7fffffffff000000000000000000000000000000000000000000000000000000001682528490526040902054760100000000000000000000000000000000000000000000900460ff169350505b5050919050565b7fffffffff0000000000000000000000000000000000000000000000000000000081165f9081527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b6020819052604082205473ffffffffffffffffffffffffffffffffffffffff16610d47576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152600260248201527f673200000000000000000000000000000000000000000000000000000000000060448201526064015b60405180910390fd5b7fffffffff000000000000000000000000000000000000000000000000000000009092165f90815260209290925250604090205460ff7601000000000000000000000000000000000000000000009091041690565b5f805f610dce610daf5f60210154610ee2565b63ffffffff604082901c169167ffffffffffffffff602083901c169190565b925092509250909192565b604080516060810182525f80825260208201819052918101919091526002820154600183015403610e66576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152600160248201527f44000000000000000000000000000000000000000000000000000000000000006044820152606401610d3e565b5060028101545f908152602091825260409081902081516060810183528154815260019091015467ffffffffffffffff8116938201939093526801000000000000000090920477ffffffffffffffffffffffffffffffffffffffffffffffff169082015290565b5f81600201548260010154610b5791906112a5565b5f6bffffffffffffffffffffffff821115610f7f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f53616665436173743a2076616c756520646f65736e27742066697420696e203960448201527f36206269747300000000000000000000000000000000000000000000000000006064820152608401610d3e565b5090565b6020810160028310610fbc577f4e487b71000000000000000000000000000000000000000000000000000000005f52602160045260245ffd5b91905290565b5f602080835283518060208501525f5b81811015610fee57858101830151858201604001528201610fd2565b505f6040828601015260407fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f8301168501019250505092915050565b602080825282518282018190525f9190848201906040850190845b8181101561107957835173ffffffffffffffffffffffffffffffffffffffff1683529284019291840191600101611047565b50909695505050505050565b5f60208284031215611095575f80fd5b5035919050565b5f815180845260208085019450602084015f5b838110156110ed5781517fffffffff0000000000000000000000000000000000000000000000000000000016875295820195908201906001016110af565b509495945050505050565b5f60208083018184528085518083526040925060408601915060408160051b8701018488015f5b83811015611192578883037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc00185528151805173ffffffffffffffffffffffffffffffffffffffff16845287015187840187905261117f8785018261109c565b958801959350509086019060010161111f565b509098975050505050505050565b5f602082840312156111b0575f80fd5b813573ffffffffffffffffffffffffffffffffffffffff811681146111d3575f80fd5b9392505050565b602081525f6111d3602083018461109c565b5f80604083850312156111fd575f80fd5b50508035926020909101359150565b5f6020828403121561121c575f80fd5b81357fffffffff00000000000000000000000000000000000000000000000000000000811681146111d3575f80fd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b81810381811115610b57577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffdfea26469706673582212207f84426949a8783a520070d96eaf00855696114eff3c2f65a18e0bdef99fad2864736f6c63430008180033

View All Withdrawals

View All Deposits

Display all chains•

Last updated: less than 1 sec ago