Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.25;

/// @title zkLighter DesertMode Interface
/// @author zkLighter Team
interface IZkLighterDesertMode {
  /// @notice thrown when DesertMode is active
  error ZkLighter_DesertModeActive();

  function desertMode() external view returns (bool);
}

// SPDX-License-Identifier: MIT OR Apache-2.0

pragma solidity 0.8.25;

/// @title Interface of the upgradeable contract
/// @author Matter Labs (https://github.com/matter-labs/zksync/blob/master/contracts/contracts/Upgradeable.sol)
interface IUpgradeable {
  /// @notice Upgrades target of upgradeable contract
  /// @param newTarget New target
  /// @param newTargetInitializationParameters New target initialization parameters
  function upgradeTarget(address newTarget, bytes calldata newTargetInitializationParameters) external;
}

// SPDX-License-Identifier: MIT OR Apache-2.0

pragma solidity 0.8.25;

/// @title Upgrade events
/// @author Matter Labs (https://github.com/matter-labs/zksync/blob/master/contracts/contracts/Events.sol)
interface IUpgradeEvents {
  /// @notice Event emitted when new upgradeable contract is added to upgrade gatekeeper's list of managed contracts
  event NewUpgradable(uint256 indexed versionId, address indexed upgradeable);

  /// @notice Upgrade mode enter event
  event NoticePeriodStart(
    uint256 indexed versionId,
    address[] newTargets,
    uint256 noticePeriod // notice period (in seconds)
  );

  /// @notice Upgrade mode cancel event
  event UpgradeCancel(uint256 indexed versionId);

  /// @notice Upgrade mode preparation status event
  event PreparationStart(uint256 indexed versionId);

  /// @notice Upgrade mode complete event
  event UpgradeComplete(uint256 indexed versionId, address[] newTargets);
}

// SPDX-License-Identifier: MIT OR Apache-2.0

pragma solidity 0.8.25;

/// @title Ownable Contract
/// @author Matter Labs (https://github.com/matter-labs/zksync/blob/master/contracts/contracts/Ownable.sol)
contract Ownable {
  /// @dev Storage position of the masters address (keccak256('eip1967.proxy.admin') - 1)
  bytes32 private constant MASTER_POSITION = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

  /// @notice Contract constructor
  /// @dev Sets msg sender address as masters address
  /// @param masterAddress Master address
  constructor(address masterAddress) {
    require(masterAddress != address(0), "1b"); // oro11 - master address can't be zero address
    setMaster(masterAddress);
  }

  /// @notice Check if specified address is master
  /// @param _address Address to check
  function requireMaster(address _address) internal view {
    require(_address == getMaster(), "1c"); // oro11 - only by master
  }

  /// @notice Returns contract masters address
  /// @return master Master's address
  function getMaster() public view returns (address master) {
    bytes32 position = MASTER_POSITION;
    assembly {
      master := sload(position)
    }
  }

  /// @dev Sets new masters address
  /// @param _newMaster New master's address
  function setMaster(address _newMaster) internal {
    bytes32 position = MASTER_POSITION;
    assembly {
      sstore(position, _newMaster)
    }
  }

  /// @notice Transfer mastership of the contract to new master
  /// @param _newMaster New masters address
  function transferMastership(address _newMaster) external {
    requireMaster(msg.sender);
    require(_newMaster != address(0), "1d"); // otp11 - new masters address can't be zero address
    setMaster(_newMaster);
  }
}

// SPDX-License-Identifier: MIT OR Apache-2.0

pragma solidity 0.8.25;

import "./IUpgradeEvents.sol";
import "./Ownable.sol";
import "./IUpgradeable.sol";
import "../UpgradeableMaster.sol";

/// @title Upgrade Gatekeeper Contract
/// @author Matter Labs (https://github.com/matter-labs/zksync/blob/master/contracts/contracts/UpgradeGatekeeper.sol)
/// Modified to implement UpgradeableMaster, since Proxy no longer implements the interface
contract UpgradeGatekeeper is UpgradeableMaster, IUpgradeEvents, Ownable {
  /// @notice Array of addresses of upgradeable contracts managed by the gatekeeper
  IUpgradeable[] public managedContracts;

  /// @notice Upgrade mode statuses
  enum UpgradeStatus {
    Idle,
    NoticePeriod,
    Preparation
  }

  UpgradeStatus public upgradeStatus;

  /// @notice Notice period finish timestamp (as seconds since unix epoch)
  /// @dev Will be equal to zero in case of not active upgrade mode
  uint256 public noticePeriodFinishTimestamp;

  /// @notice Addresses of the next versions of the contracts to be upgraded (if element of this array is equal to zero address it means that appropriate upgradeable contract wouldn't be upgraded this time)
  /// @dev Will be empty in case of not active upgrade mode
  address[] public nextTargets;

  /// @notice Version id of contracts
  uint256 public versionId;

  /// @notice Contract constructor
  /// @param _securityCouncilAddress Security council address
  /// @param _zkLighterProxy ZkLighter proxy address for desert mode checks to disable upgrades
  /// @dev Calls Ownable contract constructor
  constructor(
    address _securityCouncilAddress,
    address _zkLighterProxy
  ) UpgradeableMaster(_securityCouncilAddress, _zkLighterProxy) Ownable(msg.sender) {
    versionId = 0;
  }

  /// @notice Adds a new upgradeable contract to the list of contracts managed by the gatekeeper
  /// @param addr Address of upgradeable contract to add
  function addUpgradeable(address addr) external {
    requireMaster(msg.sender);
    require(upgradeStatus == UpgradeStatus.Idle, "apc11"); /// apc11 - upgradeable contract can't be added during upgrade

    managedContracts.push(IUpgradeable(addr));
    emit NewUpgradable(versionId, addr);
  }

  /// @notice Starts upgrade (activates notice period)
  /// @param newTargets New managed contracts targets (if element of this array is equal to zero address it means that appropriate upgradeable contract wouldn't be upgraded this time)
  function startUpgrade(address[] calldata newTargets) external {
    requireMaster(msg.sender);
    require(upgradeStatus == UpgradeStatus.Idle, "spu11"); // spu11 - unable to activate active upgrade mode
    require(newTargets.length == managedContracts.length, "spu12"); // spu12 - number of new targets must be equal to the number of managed contracts

    uint256 noticePeriod = getNoticePeriod();
    upgradeNoticePeriodStarted();
    upgradeStatus = UpgradeStatus.NoticePeriod;
    noticePeriodFinishTimestamp = block.timestamp + noticePeriod;
    nextTargets = newTargets;
    emit NoticePeriodStart(versionId, newTargets, noticePeriod);
  }

  /// @notice Cancels upgrade
  function cancelUpgrade() external {
    requireMaster(msg.sender);
    require(upgradeStatus != UpgradeStatus.Idle, "cpu11"); // cpu11 - unable to cancel not active upgrade mode

    upgradeCanceled();
    upgradeStatus = UpgradeStatus.Idle;
    noticePeriodFinishTimestamp = 0;
    delete nextTargets;
    emit UpgradeCancel(versionId);
  }

  /// @notice Activates preparation status
  /// @return Bool flag indicating that preparation status has been successfully activated
  function startPreparation() external returns (bool) {
    requireMaster(msg.sender);
    require(upgradeStatus == UpgradeStatus.NoticePeriod, "ugp11"); // ugp11 - unable to activate preparation status in case of not active notice period status

    if (block.timestamp >= noticePeriodFinishTimestamp) {
      upgradeStatus = UpgradeStatus.Preparation;
      upgradePreparationStarted();
      emit PreparationStart(versionId);
      return true;
    } else {
      return false;
    }
  }

  /// @notice Finishes upgrade
  /// @param targetsUpgradeParameters New targets upgrade parameters per each upgradeable contract
  function finishUpgrade(bytes[] calldata targetsUpgradeParameters) external {
    requireMaster(msg.sender);
    require(upgradeStatus == UpgradeStatus.Preparation, "fpu11"); // fpu11 - unable to finish upgrade without preparation status active
    require(targetsUpgradeParameters.length == managedContracts.length, "fpu12"); // fpu12 - number of new targets upgrade parameters must be equal to the number of managed contracts
    require(isReadyForUpgrade(), "fpu13"); // fpu13 - main contract is not ready for upgrade
    upgradeFinishes();

    for (uint64 i = 0; i < managedContracts.length; i++) {
      address newTarget = nextTargets[i];
      if (newTarget != address(0)) {
        managedContracts[i].upgradeTarget(newTarget, targetsUpgradeParameters[i]);
      }
    }
    versionId++;
    emit UpgradeComplete(versionId, nextTargets);

    upgradeStatus = UpgradeStatus.Idle;
    noticePeriodFinishTimestamp = 0;
    delete nextTargets;
  }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.8.25;

import "./interfaces/IZkLighterDesertMode.sol";

/// @title Upgradeable Master Contract
/// @author zkLighter Team
/// @dev UpgradeableMaster is used by the UpgradeGatekeeper when upgrading contracts.
/// It is controlled by the security council. The whole state of the contract is read only.
/// It's indented to be inherited by the UpgradeGatekeeper. Due to this, all methods which are used in the flow of
/// deploying updates are internal.
/// It has 2 main roles:
/// - It delays the deployment of upgrades by at most 3 weeks, in case the upgrade is malicious.
/// This gives users enough time to withdraw the funds using full exit operation from the system.
/// - It stops any upgrade if the system has entered desert mode.
contract UpgradeableMaster {
  /// @notice Notice period changed
  event NoticePeriodChange(uint256 newNoticePeriod);

  /// @dev Notice period before activation of the upgrade (in seconds)
  /// @dev NOTE: Gives users enough time to send full exit requests if the upgrade is malicious
  uint256 internal constant UPGRADE_NOTICE_PERIOD = 3 weeks;

  /// @dev Upgrade notice period, possibly shorten by the security council
  uint256 public approvedUpgradeNoticePeriod;

  /// @dev Upgrade start timestamp
  /// @dev Will be equal to zero if there is no active upgrade
  uint256 public upgradeStartTimestamp;

  /// @dev Instead of keeping a list of council members and requiring approval from all of them,
  /// keep just one council member to simplify the workflow. The council member itself could be a multi signature wallet
  address public immutable securityCouncilAddress;

  /// @dev zkLighter contract used to detect if system is in desert mode. If desert mode is detected, upgrades are not allowed
  IZkLighterDesertMode public immutable zkLighterProxy;

  constructor(address _securityCouncilAddress, address _zkLighterProxy) {
    require(_zkLighterProxy != address(0), "c1");
    securityCouncilAddress = _securityCouncilAddress;
    zkLighterProxy = IZkLighterDesertMode(_zkLighterProxy);
    approvedUpgradeNoticePeriod = UPGRADE_NOTICE_PERIOD;
    emit NoticePeriodChange(approvedUpgradeNoticePeriod);
  }

  /// @notice Minimum notice period before setting the activation preparation for the upgrade
  function getNoticePeriod() internal pure returns (uint256) {
    return 0;
  }

  /// @notice Sets the upgradeStartTimestamp when an upgrade starts
  function upgradeNoticePeriodStarted() internal {
    upgradeStartTimestamp = block.timestamp;
  }

  /// @notice Checks if the upgrade preparation has started for the current upgrade
  function upgradePreparationStarted() internal view {
    require(block.timestamp >= upgradeStartTimestamp + approvedUpgradeNoticePeriod);
  }

  /// @dev Clears the current upgrade when upgrade is finished or canceled
  function clearUpgradeStatus() internal {
    approvedUpgradeNoticePeriod = UPGRADE_NOTICE_PERIOD;
    emit NoticePeriodChange(approvedUpgradeNoticePeriod);
    upgradeStartTimestamp = 0;
  }

  /// @notice Clears the upgrade status when the upgrade is canceled
  function upgradeCanceled() internal {
    clearUpgradeStatus();
  }

  /// @notice Clears the upgrade status when the upgrade is finished
  function upgradeFinishes() internal {
    clearUpgradeStatus();
  }

  /// @notice Checks if the contract can be upgraded (does not allow upgrades in desert mode)
  /// @return bool flag indicating that contract is ready for upgrade
  function isReadyForUpgrade() internal view returns (bool) {
    return !zkLighterProxy.desertMode();
  }

  /// @notice Allows security council to decrease upgrade notice period time to 0
  /// @dev Can only be called after the start of the upgrade (getNoticePeriod)
  function cutUpgradeNoticePeriod(uint256 _upgradeStartTimestamp) external {
    require(upgradeStartTimestamp != 0, "p1");
    require(upgradeStartTimestamp == _upgradeStartTimestamp, "p2"); // given target is not the active upgrade
    require(msg.sender == securityCouncilAddress, "p3"); // only security council can call this

    // decrease upgrade notice period time to zero
    if (approvedUpgradeNoticePeriod > 0) {
      approvedUpgradeNoticePeriod = 0;
      emit NoticePeriodChange(approvedUpgradeNoticePeriod);
    }
  }
}