{"file_path":"lib/mento-core-2.6.2/contracts/governance/locking/Locking.sol","creation_status":"success","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.18;\n// solhint-disable func-name-mixedcase, gas-custom-errors\n\nimport \"./LockingBase.sol\";\nimport \"./LockingRelock.sol\";\nimport \"./LockingVotes.sol\";\nimport \"./interfaces/ILocking.sol\";\n\n/**\n * @title Locking\n * @notice Implements locking mechanism for tokens to enable voting power accumulation\n * @notice https://github.com/rarible/locking-contracts/tree/4f189a96b3e85602dedfbaf69d9a1f5056d835eb\n */\ncontract Locking is ILocking, LockingBase, LockingRelock, LockingVotes {\n  using LibBrokenLine for LibBrokenLine.BrokenLine;\n\n  constructor(bool disableInitializers) {\n    if (disableInitializers) {\n      _disableInitializers();\n    }\n  }\n\n  /**\n   * @notice Initializes the locking contract.\n   * @dev Sets up the base locking parameters and initializes ownership and context setup\n   * @param _token Address of the ERC20 that will be locked. (Mento Token)\n   * @param _startingPointWeek Origin week number for the week-based time system\n   * @param _minCliffPeriod Minimum cliff period for locks\n   * @param _minSlopePeriod Minimum slope period for locks\n   */\n  function __Locking_init(\n    IERC20Upgradeable _token,\n    uint32 _startingPointWeek,\n    uint32 _minCliffPeriod,\n    uint32 _minSlopePeriod\n  ) external initializer {\n    __LockingBase_init_unchained(_token, _startingPointWeek, _minCliffPeriod, _minSlopePeriod);\n    __Ownable_init_unchained();\n    __Context_init_unchained();\n  }\n\n  /**\n   * @notice Locks a specified amount of tokens for a given period\n   * @dev Delegate is not optional, it can be set to the lock owner if no delegate is desired\n   * @param account Account for which tokens are being locked\n   * @param _delegate Address that will receive the voting power from the locked tokens\n   * @param amount Amount of tokens to lock\n   * @param slopePeriod Period over which the tokens will unlock\n   * @param cliff Initial period during which tokens remain locked and do not start unlocking\n   * @return Id for the created lock\n   */\n  function lock(\n    address account,\n    address _delegate,\n    uint96 amount,\n    uint32 slopePeriod,\n    uint32 cliff\n  ) external override returns (uint256) {\n    require(amount >= 1e18, \"amount is less than minimum\");\n    require(cliff <= MAX_CLIFF_PERIOD, \"cliff too big\");\n    require(slopePeriod <= MAX_SLOPE_PERIOD, \"period too big\");\n    require(account != address(0), \"account is zero\");\n    require(_delegate != address(0), \"delegate is zero\");\n\n    counter++;\n\n    uint32 currentBlock = getBlockNumber();\n    uint32 time = getWeekNumber(currentBlock);\n    addLines(account, _delegate, amount, slopePeriod, cliff, time, currentBlock);\n    accounts[account].amount = accounts[account].amount + (amount);\n\n    // slither-disable-next-line reentrancy-events\n    require(token.transferFrom(msg.sender, address(this), amount), \"transfer failed\");\n\n    emit LockCreate(counter, account, _delegate, time, amount, slopePeriod, cliff);\n    return counter;\n  }\n\n  /**\n   * @notice Withdraws unlocked tokens for the caller\n   */\n  function withdraw() external {\n    uint96 value = getAvailableForWithdraw(msg.sender);\n    if (value > 0) {\n      accounts[msg.sender].amount = accounts[msg.sender].amount - (value);\n      // slither-disable-next-line reentrancy-events\n      require(token.transfer(msg.sender, value), \"transfer failed\");\n    }\n    emit Withdraw(msg.sender, value);\n  }\n\n  /**\n   * @notice Calculates the amount available for withdrawal by an account\n   * @param account The account to check the withdrawable amount for\n   * @return The amount of tokens available for withdrawal\n   */\n  function getAvailableForWithdraw(address account) public view returns (uint96) {\n    uint96 value = accounts[account].amount;\n    uint32 currentBlock = getBlockNumber();\n    uint32 time = getWeekNumber(currentBlock);\n    uint96 bias = accounts[account].locked.actualValue(time, currentBlock);\n    value = value - (bias);\n    return value;\n  }\n\n  /**\n   * @notice Returns the total amount of tokens locked for an account\n   * @param account The account to check locked amount for\n   * @return The locked amount for the account\n   */\n  function locked(address account) external view returns (uint256) {\n    return accounts[account].amount;\n  }\n\n  /**\n   * @notice Retrieves the account and delegate associated with a given lock ID\n   * @param id The id of the lock\n   * @return _account The account that owns the lock\n   * @return _delegate The account that owns the voting power\n   */\n  function getAccountAndDelegate(uint256 id) external view returns (address _account, address _delegate) {\n    _account = locks[id].account;\n    _delegate = locks[id].delegate;\n  }\n\n  /**\n   * @notice Returns \"current week\" of the contract. The Locking contract works with a week-based time system\n   * for managing locks and voting power. The current week number is calculated based on the number of weeks passed\n   * since the starting point week. The starting point is set during the contract initialization.\n   */\n  function getWeek() external view returns (uint256) {\n    return getWeekNumber(getBlockNumber());\n  }\n\n  /**\n   * @notice Changes the delegate for a specific lock\n   * @dev Updates the delegation and adjusts the voting power accordingly\n   * @param id The unique identifier for the lock whose delegate is to be changed\n   * @param newDelegate The address to which the delegation will be transferred\n   */\n  function delegateTo(uint256 id, address newDelegate) external {\n    require(newDelegate != address(0), \"delegate is zero\");\n\n    address account = verifyLockOwner(id);\n    address _delegate = locks[id].delegate;\n    uint32 currentBlock = getBlockNumber();\n    uint32 time = getWeekNumber(currentBlock);\n    accounts[_delegate].balance.update(time);\n    (uint96 bias, uint96 slope, uint32 cliff) = accounts[_delegate].balance.remove(id, time, currentBlock);\n    LibBrokenLine.Line memory line = LibBrokenLine.Line(time, bias, slope, cliff);\n    accounts[newDelegate].balance.update(time);\n    accounts[newDelegate].balance.addOneLine(id, line, currentBlock);\n    locks[id].delegate = newDelegate;\n    emit Delegate(id, account, newDelegate, time);\n  }\n\n  /**\n   * @notice Returns the current total supply of veMENTO tokens\n   * @return The total supply of veMENTO tokens\n   */\n  function totalSupply() external view returns (uint256) {\n    if (totalSupplyLine.initial.bias == 0) {\n      return 0;\n    }\n    uint32 currentBlock = getBlockNumber();\n    uint32 time = getWeekNumber(currentBlock);\n    return totalSupplyLine.actualValue(time, currentBlock);\n  }\n\n  /**\n   * @notice Retrieves the veMENTO balance of an account\n   * @param account The account to check the balance for\n   * @return The accounts balance of veMENTO tokens\n   */\n  function balanceOf(address account) external view returns (uint256) {\n    if (accounts[account].balance.initial.bias == 0) {\n      return 0;\n    }\n    uint32 currentBlock = getBlockNumber();\n    uint32 time = getWeekNumber(currentBlock);\n    return accounts[account].balance.actualValue(time, currentBlock);\n  }\n\n  /**\n   * @notice Returns the name of the token\n   */\n  function name() public view virtual returns (string memory) {\n    return \"Mento Vote-Escrow\";\n  }\n\n  /**\n   * @notice Returns the symbol of the token\n   */\n  function symbol() public view virtual returns (string memory) {\n    return \"veMENTO\";\n  }\n\n  /**\n   * @notice Returns the decimal points of the token\n   */\n  function decimals() public view virtual returns (uint8) {\n    return 18;\n  }\n\n  uint256[50] private __gap;\n}\n","deployed_bytecode":"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","optimization_enabled":true,"verified_twin_address_hash":null,"is_verified":true,"compiler_settings":{"evmVersion":"paris","libraries":{"lib/mento-core-2.0.0/contracts/common/linkedlists/AddressLinkedList.sol":{"AddressLinkedList":"0x2f0f7686fffefc3c266403ad600035581deaedff"},"lib/mento-core-2.0.0/contracts/common/linkedlists/AddressSortedLinkedListWithMedian.sol":{"AddressSortedLinkedListWithMedian":"0x29b1b5e05217c751038861af2c77494eab10a257"}},"metadata":{"bytecodeHash":"none"},"optimizer":{"enabled":true,"runs":10000},"remappings":[":@celo/=lib/mento-core-2.6.0/node_modules/@celo/contracts/",":@chainlink/contracts/=lib/mento-core-2.6.2/lib/foundry-chainlink-toolkit/lib/chainlink-brownie-contracts/contracts/src/",":@openzeppelin/=lib/mento-core-2.6.2/lib/foundry-chainlink-toolkit/lib/openzeppelin-contracts/",":@prb/test/=lib/mento-core-2.6.2/lib/prb-math/lib/prb-test/src/",":celo-foundry/=lib/celo-foundry/src/",":celo/=node_modules/@celo/",":chainlink-brownie-contracts/=lib/mento-core-2.6.2/lib/foundry-chainlink-toolkit/lib/chainlink-brownie-contracts/contracts/src/v0.6/vendor/@arbitrum/nitro-contracts/src/",":contracts/=contracts/",":ds-test/=lib/celo-foundry/lib/forge-std/lib/ds-test/src/",":forge-std-next/=lib/forge-std-next/src/",":forge-std/=lib/celo-foundry/lib/forge-std/src/",":foundry-chainlink-toolkit/=lib/mento-core-2.6.2/lib/foundry-chainlink-toolkit/",":mento-core-2.0.0/=lib/mento-core-2.0.0/contracts/",":mento-core-2.1.0/=lib/mento-core-2.1.0/contracts/",":mento-core-2.2.0/=lib/mento-core-2.2.0/contracts/",":mento-core-2.3.1/=lib/mento-core-2.3.1/contracts/",":mento-core-2.5.0/=lib/mento-core-2.5.0/contracts/",":mento-core-2.6.0-oz/=lib/mento-core-2.6.0/lib/openzeppelin-contracts-next/",":mento-core-2.6.0/=lib/mento-core-2.6.0/contracts/",":mento-core-2.6.2/=lib/mento-core-2.6.2/contracts/",":mento-std/=lib/mento-core-2.6.2/lib/mento-std/src/",":merkle-distributor/=lib/merkle-distributor/contracts/",":openzeppelin-contracts-next/=lib/mento-core-2.6.2/lib/openzeppelin-contracts-next/",":openzeppelin-contracts-upgradeable/=lib/mento-core-2.6.2/lib/openzeppelin-contracts-upgradeable/",":openzeppelin-contracts/=lib/mento-core-2.6.2/lib/openzeppelin-contracts-next/",":openzeppelin-solidity/=lib/mento-core-2.0.0/lib/openzeppelin-contracts/",":prb-math/=lib/mento-core-2.6.2/lib/prb-math/src/",":prb-test/=lib/mento-core-2.6.2/lib/prb-math/lib/prb-test/src/",":prb/math/=lib/mento-core-2.6.2/lib/prb-math/src/",":safe-contracts/=lib/mento-core-2.6.2/lib/safe-contracts/",":src/=lib/mento-core-2.6.2/lib/prb-math/src/",":test/=lib/mento-core-2.6.2/test/"],"viaIR":true},"optimization_runs":10000,"sourcify_repo_url":null,"decoded_constructor_args":[["true",{"internalType":"bool","name":"disableInitializers","type":"bool"}]],"compiler_version":"0.8.18+commit.87f61d96","is_verified_via_verifier_alliance":true,"verified_at":"2025-03-06T19:42:27.511705Z","implementations":[],"proxy_type":null,"external_libraries":[{"name":"AddressLinkedList","address_hash":"0x2F0F7686fFFEfc3C266403Ad600035581deaedff"},{"name":"AddressSortedLinkedListWithMedian","address_hash":"0x29B1B5e05217c751038861aF2C77494EAB10A257"}],"creation_bytecode":"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","name":"Locking","is_blueprint":false,"license_type":"none","is_fully_verified":false,"is_verified_via_eth_bytecode_db":true,"language":"solidity","evm_version":"paris","can_be_visualized_via_sol2uml":true,"is_verified_via_sourcify":false,"additional_sources":[{"file_path":"lib/mento-core-2.6.2/contracts/governance/locking/LockingBase.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.18;\n// solhint-disable state-visibility, func-name-mixedcase, gas-custom-errors\n\nimport \"openzeppelin-contracts-upgradeable/contracts/token/ERC20/IERC20Upgradeable.sol\";\nimport \"openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol\";\nimport \"openzeppelin-contracts-upgradeable/contracts/governance/utils/IVotesUpgradeable.sol\";\nimport \"./libs/LibBrokenLine.sol\";\n\n/**\n * @title LockingBase\n * @dev This abstract contract provides the foundational functionality\n * for locking ERC20 tokens to accrue voting power.\n * @dev It utilizes the Broken Line library to represent the decay of voting power as tokens unlock.\n * @notice https://github.com/rarible/locking-contracts/tree/4f189a96b3e85602dedfbaf69d9a1f5056d835eb\n */\nabstract contract LockingBase is OwnableUpgradeable, IVotesUpgradeable {\n  using LibBrokenLine for LibBrokenLine.BrokenLine;\n  /**\n   * @dev Duration of a week in blocks on the CELO blockchain before the L2 transition (5 seconds per block)\n   */\n  uint32 public constant WEEK = 120_960;\n  /**\n   * @dev Duration of a week in blocks on the CELO blockchain after the L2 transition (1 seconds per block)\n   */\n  uint32 public constant L2_WEEK = 604_800;\n  /**\n   * @dev Epoch shift for L1\n   */\n  uint32 public constant L1_EPOCH_SHIFT = 89964;\n  /**\n   * @dev Maximum allowable cliff period for token locks in weeks\n   */\n  uint32 constant MAX_CLIFF_PERIOD = 103;\n  /**\n   * @dev Maximum allowable slope period for token locks in weeks\n   */\n  uint32 constant MAX_SLOPE_PERIOD = 104;\n  /**\n   * @dev Basis for locking formula calculations\n   */\n  uint32 constant ST_FORMULA_BASIS = 1 * (10 ** 8);\n  /**\n   * @dev ERC20 token that will be locked\n   */\n  IERC20Upgradeable public token;\n  /**\n   * @dev Counter for Lock identifiers\n   */\n  uint256 public counter;\n  /**\n   * @dev Minimum cliff period in weeks\n   */\n  uint256 public minCliffPeriod;\n  /**\n   * @dev Minimum slope period in weeks\n   */\n  uint256 public minSlopePeriod;\n  /**\n   * @dev Starting point week for the locking week-based time system\n   */\n  uint256 public startingPointWeek;\n  /**\n   * @dev Struct used to represent a lock\n   * account - Address owning the lock\n   * delegate - Address that will receive the voting power from the locked tokens\n   */\n  struct Lock {\n    address account;\n    address delegate;\n  }\n  /**\n   * @dev Mapping of lock identifiers to Lock structs\n   */\n  mapping(uint256 => Lock) locks;\n  /**\n   * @dev Struct used to represent an account's locked and unlocked token balances\n   * balance - BrokenLine representing the linear function of the veMento balance\n   * locked - BrokenLine representing the linear function of the locked token balance\n   * amount - amount of locked tokens\n   */\n  struct Account {\n    LibBrokenLine.BrokenLine balance;\n    LibBrokenLine.BrokenLine locked;\n    uint96 amount;\n  }\n  /**\n   * @dev Mapping of addresses to Account structs\n   */\n  mapping(address => Account) accounts;\n  /**\n   * @dev Total supply line of veMento\n   */\n  LibBrokenLine.BrokenLine public totalSupplyLine;\n\n  // ***************\n  // New variables for L2 transition upgrade (3 slots)\n  // ***************\n  /**\n   * @dev L2 transition block number\n   */\n  uint256 public l2TransitionBlock;\n  /**\n   * @dev L2 starting point week number\n   */\n  int256 public l2StartingPointWeek;\n  /**\n   * @dev Shift amount used after L2 transition to move the start of the epoch to 00-00 UTC Wednesday (approx)\n   */\n  uint32 public l2EpochShift;\n  /**\n   * @dev Address of the Mento Labs multisig\n   */\n  address public mentoLabsMultisig;\n  /**\n   * @dev Flag to pause locking and governance\n   */\n  bool public paused;\n\n  /**\n   * @dev Emitted when create Lock with parameters (account, delegate, amount, slopePeriod, cliff)\n   */\n  event LockCreate(\n    uint256 indexed id,\n    address indexed account,\n    address indexed delegate,\n    uint256 time,\n    uint256 amount,\n    uint256 slopePeriod,\n    uint256 cliff\n  );\n  /**\n   * @dev Emitted when change Lock parameters (newDelegate, newAmount, newSlopePeriod, newCliff) for Lock with given id\n   */\n  event Relock(\n    uint256 indexed id,\n    address indexed account,\n    address indexed delegate,\n    uint256 counter,\n    uint256 time,\n    uint256 amount,\n    uint256 slopePeriod,\n    uint256 cliff\n  );\n  /**\n   * @dev Emitted when to set newDelegate address for Lock with given id\n   */\n  event Delegate(uint256 indexed id, address indexed account, address indexed delegate, uint256 time);\n  /**\n   * @dev Emitted when withdraw amount of Rari, account - msg.sender, amount - amount Rari\n   */\n  event Withdraw(address indexed account, uint256 amount);\n  /**\n   * @dev set newMinCliffPeriod\n   */\n  event SetMinCliffPeriod(uint256 indexed newMinCliffPeriod);\n  /**\n   * @dev set newMinSlopePeriod\n   */\n  event SetMinSlopePeriod(uint256 indexed newMinSlopePeriod);\n  /**\n   * @dev set new Mento Labs multisig address\n   */\n  event SetMentoLabsMultisig(address indexed mentoLabsMultisig);\n  /**\n   * @dev set new L2 transition block number\n   */\n  event SetL2TransitionBlock(uint256 indexed l2TransitionBlock);\n  /**\n   * @dev set new L2 shift amount\n   */\n  event SetL2EpochShift(uint32 indexed l2EpochShift);\n  /**\n   * @dev set new L2 starting point week number\n   */\n  event SetL2StartingPointWeek(int256 indexed l2StartingPointWeek);\n  /**\n   * @dev set new paused flag\n   */\n  event SetPaused(bool indexed paused);\n\n  /**\n   * @dev Initializes the contract with token, starting point week, and minimum cliff and slope periods.\n   * @param _token ERC20 token to be locked. (Mento Token)\n   * @param _startingPointWeek Origin week number for the week-based time system.\n   * @param _minCliffPeriod Minimum cliff period for locks.\n   * @param _minSlopePeriod Minimum slope period for locks.\n   */\n  function __LockingBase_init_unchained(\n    IERC20Upgradeable _token,\n    uint32 _startingPointWeek,\n    uint32 _minCliffPeriod,\n    uint32 _minSlopePeriod\n  ) internal onlyInitializing {\n    token = _token;\n    startingPointWeek = _startingPointWeek;\n\n    //setting min cliff and slope\n    require(_minCliffPeriod <= MAX_CLIFF_PERIOD, \"cliff too big\");\n    require(_minSlopePeriod <= MAX_SLOPE_PERIOD, \"period too big\");\n    minCliffPeriod = _minCliffPeriod;\n    minSlopePeriod = _minSlopePeriod;\n  }\n\n  modifier onlyMentoLabs() {\n    require(msg.sender == mentoLabsMultisig, \"caller is not MentoLabs multisig\");\n    _;\n  }\n\n  /**\n   * @notice Adds a new locking line for an account, initializing the lock with specified parameters.\n   * @param account  Address for which tokens are being locked.\n   * @param _delegate Address that will receive the voting power from the locked tokens.\n   * @param amount Amount of tokens to lock.\n   * @param slopePeriod Period over which the tokens will unlock.\n   * @param cliff Initial period during which tokens remain locked and do not start unlocking.\n   * @param time Week number when the line is added.\n   * @param currentBlock Current block number.\n   */\n  function addLines(\n    address account,\n    address _delegate,\n    uint96 amount,\n    uint32 slopePeriod,\n    uint32 cliff,\n    uint32 time,\n    uint32 currentBlock\n  ) internal {\n    require(slopePeriod <= amount, \"Wrong value slopePeriod\");\n    updateLines(account, _delegate, time);\n    (uint96 stAmount, uint96 stSlope) = getLock(amount, slopePeriod, cliff);\n    LibBrokenLine.Line memory line = LibBrokenLine.Line(time, stAmount, stSlope, cliff);\n    totalSupplyLine.addOneLine(counter, line, currentBlock);\n    accounts[_delegate].balance.addOneLine(counter, line, currentBlock);\n    {\n      uint96 slope = divUp(amount, slopePeriod);\n      line = LibBrokenLine.Line(time, amount, slope, cliff);\n    }\n    accounts[account].locked.addOneLine(counter, line, currentBlock);\n    locks[counter].account = account;\n    locks[counter].delegate = _delegate;\n  }\n\n  /**\n   * @notice Updates broken lines for account, delegate and total supply\n   * @param account address of account that locked tokens\n   * @param _delegate address of delegate that owns the voting power\n   * @param time week number till which to update lines\n   */\n  function updateLines(address account, address _delegate, uint32 time) internal {\n    totalSupplyLine.update(time);\n    accounts[_delegate].balance.update(time);\n    accounts[account].locked.update(time);\n  }\n\n  /**\n   * @notice Calculates lockAmount and lockSlope for given lock parameters\n   * @dev Сalculate and return (lockAmount, lockSlope), using formula:\n   * P = t * min(c/c_max + s/s_max, 1),\n   *\n   * The formula has the following properties:\n   * - the voting power can't exceed the amount of tokens locked.\n   * - a voter can reach 100% voting power by relying on either the slope or the cliff,\n   *   or a combination of both.\n   * - there is a parameter space above a diagonal on the (c, s) plane where the\n   *   voting power is capped at 100%, moving past that diagonal is disadvantageous\n   *   but the contract doesn't forbid it.\n   *\n   *\n   * The formula roughly translates to solidity as:\n   * votingPower = (\n   *   tokens *\n   *   min(\n   *    (ST_FORMULA_BASIS * cliffPeriod) / MAX_CLIFF_PERIOD +\n   *    (ST_FORMULA_BASIS * slopePeriod) / MAX_SLOPE_PERIOD,\n   *    ST_FORMULA_BASIS\n   *   )\n   * ) / ST_FORMULA_BASIS\n   * @param amount of tokens to lock\n   * @param slopePeriod period over which the tokens will unlock\n   * @param cliff initial period during which tokens remain locked and do not start unlocking\n   */\n  function getLock(\n    uint96 amount,\n    uint32 slopePeriod,\n    uint32 cliff\n  ) public view returns (uint96 lockAmount, uint96 lockSlope) {\n    require(cliff >= minCliffPeriod, \"cliff period < minimal lock period\");\n    require(slopePeriod >= minSlopePeriod, \"slope period < minimal lock period\");\n\n    uint96 cliffSide = (uint96(cliff) * ST_FORMULA_BASIS) / MAX_CLIFF_PERIOD;\n    uint96 slopeSide = (uint96(slopePeriod) * ST_FORMULA_BASIS) / MAX_SLOPE_PERIOD;\n    uint96 multiplier = cliffSide + slopeSide;\n\n    if (multiplier > ST_FORMULA_BASIS) {\n      multiplier = ST_FORMULA_BASIS;\n    }\n\n    uint256 amountMultiplied = uint256(amount) * uint256(multiplier);\n    lockAmount = uint96(amountMultiplied / (ST_FORMULA_BASIS));\n    require(lockAmount > 0, \"voting power is 0\");\n    lockSlope = divUp(lockAmount, slopePeriod);\n  }\n\n  /**\n   * @notice Calculates a divided by b rounded up\n   * @param a numerator\n   * @param b denominator\n   * @return ⌈a/b⌉\n   */\n  function divUp(uint96 a, uint96 b) internal pure returns (uint96) {\n    return ((a - 1) / b) + 1;\n  }\n\n  /**\n   * @notice Calculates the week number for a given blocknumber\n   * @dev It takes L2 transition into account to calculate the week number consistently\n   * @param blockNumber block number to calculate the week number for\n   * @return week number the block number belongs to\n   */\n  function getWeekNumber(uint32 blockNumber) public view returns (uint32) {\n    require(!paused, \"locking is paused\");\n\n    if (blockNumber < _getEpochShift(blockNumber)) {\n      return 0;\n    }\n    uint32 shifted = blockNumber - _getEpochShift(blockNumber);\n\n    if (_isPreL2Transition(blockNumber)) {\n      return shifted / WEEK - uint32(startingPointWeek);\n    } else {\n      return uint32(uint256(int256(uint256(shifted / L2_WEEK)) - l2StartingPointWeek));\n    }\n  }\n\n  /**\n   * @notice Returns the epoch shift based on L2 transition status\n   * @dev Epoch shift is the amount of blocks to move the epoch start to 00-00 UTC Wednesday (approx).\n   * @dev l2EpochShift will be moved into a constant once L2 transition is complete and stable.\n   * @param blockNumber block number to calculate the shift for\n   * @return shift amount in blocks (L1_EPOCH_SHIFT for L1, l2EpochShift for L2)\n   */\n  function _getEpochShift(uint32 blockNumber) internal view virtual returns (uint32) {\n    if (_isPreL2Transition(blockNumber)) {\n      return L1_EPOCH_SHIFT;\n    }\n    return l2EpochShift;\n  }\n\n  /**\n   * @notice Determines if a block is before the L2 transition point\n   * @param blockNumber block number to check\n   * @return true if before L2 transition, false if after\n   */\n  function _isPreL2Transition(uint32 blockNumber) internal view returns (bool) {\n    return l2TransitionBlock == 0 || blockNumber < l2TransitionBlock;\n  }\n\n  /**\n   * @notice Verifies msg.sender is lock owner\n   * @param id lock id to verify\n   * @return account address of lock owner\n   */\n  function verifyLockOwner(uint256 id) internal view returns (address account) {\n    account = locks[id].account;\n    require(account == msg.sender, \"caller not a lock owner\");\n  }\n\n  /**\n   * @notice Returns the current block number as a uint32\n   * @return current block number\n   */\n  function getBlockNumber() internal view virtual returns (uint32) {\n    return uint32(block.number);\n  }\n\n  /**\n   * @notice Sets the minimum cliff period\n   * @param newMinCliffPeriod new minimum cliff period\n   */\n  function setMinCliffPeriod(uint32 newMinCliffPeriod) external onlyOwner {\n    require(newMinCliffPeriod <= MAX_CLIFF_PERIOD, \"new cliff period > 2 years\");\n    minCliffPeriod = newMinCliffPeriod;\n\n    emit SetMinCliffPeriod(newMinCliffPeriod);\n  }\n\n  /**\n   * @notice Sets the minimum slope period\n   * @param newMinSlopePeriod new minimum slope period\n   */\n  function setMinSlopePeriod(uint32 newMinSlopePeriod) external onlyOwner {\n    require(newMinSlopePeriod <= MAX_SLOPE_PERIOD, \"new slope period > 2 years\");\n    minSlopePeriod = newMinSlopePeriod;\n\n    emit SetMinSlopePeriod(newMinSlopePeriod);\n  }\n\n  /**\n   * @notice Updates the broken lines for an account until a given week number\n   * @param account address of account to update\n   * @param time week number until which to update lines\n   */\n  function updateAccountLines(address account, uint32 time) public onlyOwner {\n    accounts[account].balance.update(time);\n    accounts[account].locked.update(time);\n  }\n\n  /**\n   * @notice updates the total supply line until a given week number\n   * @param time week number until which to update lines\n   */\n  function updateTotalSupplyLine(uint32 time) public onlyOwner {\n    totalSupplyLine.update(time);\n  }\n\n  /**\n   * @notice updates the broken lines for an account until a given block number\n   * @param account address of account to update\n   * @param blockNumber block number until which to update lines\n   */\n  function updateAccountLinesBlockNumber(address account, uint32 blockNumber) external onlyOwner {\n    uint32 time = getWeekNumber(blockNumber);\n    updateAccountLines(account, time);\n  }\n\n  /**\n   * @notice Updates the total supply line until a given block number\n   * @param blockNumber block number until which to update line\n   */\n  function updateTotalSupplyLineBlockNumber(uint32 blockNumber) external onlyOwner {\n    uint32 time = getWeekNumber(blockNumber);\n    updateTotalSupplyLine(time);\n  }\n\n  /**\n   * @notice Sets the Mento Labs multisig address\n   * @param mentoLabsMultisig_ address of the Mento Labs multisig\n   */\n  function setMentoLabsMultisig(address mentoLabsMultisig_) external onlyOwner {\n    mentoLabsMultisig = mentoLabsMultisig_;\n    emit SetMentoLabsMultisig(mentoLabsMultisig_);\n  }\n\n  /**\n   * @notice Sets the L2 transition block number and pauses locking and governance\n   * @param l2TransitionBlock_ block number of the L2 transition\n   */\n  function setL2TransitionBlock(uint256 l2TransitionBlock_) external onlyMentoLabs {\n    l2TransitionBlock = l2TransitionBlock_;\n    paused = true;\n\n    emit SetL2TransitionBlock(l2TransitionBlock_);\n  }\n\n  /**\n   * @notice Sets the L2 epoch shift amount\n   * @param l2EpochShift_ shift amount that will be used after L2 transition\n   */\n  function setL2EpochShift(uint32 l2EpochShift_) external onlyMentoLabs {\n    l2EpochShift = l2EpochShift_;\n\n    emit SetL2EpochShift(l2EpochShift_);\n  }\n\n  /**\n   * @notice Sets the L2 starting point week number\n   * @param l2StartingPointWeek_ starting point week number that will be used after L2 transition\n   */\n  function setL2StartingPointWeek(int256 l2StartingPointWeek_) external onlyMentoLabs {\n    l2StartingPointWeek = l2StartingPointWeek_;\n\n    emit SetL2StartingPointWeek(l2StartingPointWeek_);\n  }\n\n  /**\n   * @notice Sets the paused flag\n   * @param paused_ flag to pause locking and governance\n   */\n  function setPaused(bool paused_) external onlyMentoLabs {\n    paused = paused_;\n\n    emit SetPaused(paused_);\n  }\n\n  uint256[47] private __gap;\n}\n"},{"file_path":"lib/mento-core-2.6.2/contracts/governance/locking/LockingRelock.sol","source_code":"// SPDX-License-Identifier: MIT\n// solhint-disable gas-custom-errors\npragma solidity 0.8.18;\n\nimport \"./LockingBase.sol\";\n\n/**\n * @notice https://github.com/rarible/locking-contracts/tree/4f189a96b3e85602dedfbaf69d9a1f5056d835eb\n */\nabstract contract LockingRelock is LockingBase {\n  using LibBrokenLine for LibBrokenLine.BrokenLine;\n\n  /**\n   * @notice Relocking tokens allows to changing lock parameters\n   * @param id lock id of lock to relock\n   * @param newDelegate new delegate address\n   * @param newAmount new amount to lock\n   * @param newSlopePeriod new slope period\n   * @param newCliff new cliff period\n   * @return counter new lock id\n   */\n  function relock(\n    uint256 id,\n    address newDelegate,\n    uint96 newAmount,\n    uint32 newSlopePeriod,\n    uint32 newCliff\n  ) external returns (uint256) {\n    require(newAmount >= 1e18, \"amount is less than minimum\");\n    require(newDelegate != address(0), \"delegate is zero\");\n\n    address account = verifyLockOwner(id);\n    uint32 currentBlock = getBlockNumber();\n    uint32 time = getWeekNumber(currentBlock);\n    verification(account, id, newAmount, newSlopePeriod, newCliff, time);\n\n    address _delegate = locks[id].delegate;\n    accounts[account].locked.update(time);\n\n    rebalance(id, account, accounts[account].locked.initial.bias, removeLines(id, account, _delegate, time), newAmount);\n\n    counter++;\n\n    addLines(account, newDelegate, newAmount, newSlopePeriod, newCliff, time, currentBlock);\n    emit Relock(id, account, newDelegate, counter, time, newAmount, newSlopePeriod, newCliff);\n\n    return counter;\n  }\n\n  /**\n   * @notice Verifies parameters for relock\n   * @dev Verification parameters:\n   *      1. amount > 0, slope > 0\n   *      2. cliff period and slope period less or equal two years\n   *      3. newFinishTime more or equal oldFinishTime\n   * @param account address of account that owns the old lock\n   * @param id lock id of lock to relock\n   * @param newAmount new amount to lock\n   * @param newSlopePeriod new slope period\n   * @param newCliff new cliff period\n   * @param toTime current week number\n   */\n  function verification(\n    address account,\n    uint256 id,\n    uint96 newAmount,\n    uint32 newSlopePeriod,\n    uint32 newCliff,\n    uint32 toTime\n  ) internal view {\n    require(newCliff <= MAX_CLIFF_PERIOD, \"cliff too big\");\n    require(newSlopePeriod <= MAX_SLOPE_PERIOD, \"slope period too big\");\n    require(newSlopePeriod > 0, \"slope period equal 0\");\n\n    //check Line with new parameters don`t finish earlier than old Line\n    uint32 newEnd = toTime + (newCliff) + (newSlopePeriod);\n    LibBrokenLine.Line memory line = accounts[account].locked.initiatedLines[id];\n    uint32 oldSlopePeriod = uint32(divUp(line.bias, line.slope));\n    uint32 oldEnd = line.start + (line.cliff) + (oldSlopePeriod);\n    require(oldEnd <= newEnd, \"new line period lock too short\");\n\n    //check Line with new parameters don`t cut corner old Line\n    uint32 oldCliffEnd = line.start + (line.cliff);\n    uint32 newCliffEnd = toTime + (newCliff);\n    if (oldCliffEnd > newCliffEnd) {\n      uint32 balance = oldCliffEnd - (newCliffEnd);\n      uint32 newSlope = uint32(divUp(newAmount, newSlopePeriod));\n      uint96 newBias = newAmount - (balance * (newSlope));\n      require(newBias >= line.bias, \"detect cut deposit corner\");\n    }\n  }\n\n  /**\n   * @notice Removes a given lock from the lock owner, delegate and total supply\n   * @param id lock id of lock to remove\n   * @param account address of account that owns the lock\n   * @param delegate address of delegate that owns the voting power\n   * @return residue amount of tokens still locked in the old lock\n   */\n  function removeLines(uint256 id, address account, address delegate, uint32 toTime) internal returns (uint96 residue) {\n    updateLines(account, delegate, toTime);\n    uint32 currentBlock = getBlockNumber();\n    // slither-disable-start unused-return\n    accounts[delegate].balance.remove(id, toTime, currentBlock);\n    totalSupplyLine.remove(id, toTime, currentBlock);\n    (residue, , ) = accounts[account].locked.remove(id, toTime, currentBlock);\n    // slither-disable-end unused-return\n  }\n\n  /**\n   * @notice Rebalances additional tokens for the relock\n   * @param id lock id of lock to relock\n   * @param account address of account that owns the old lock\n   * @param bias bias of the old lock\n   * @param residue amount of tokens still locked in the old lock\n   * @param newAmount new amount to lock\n   */\n  function rebalance(uint256 id, address account, uint96 bias, uint96 residue, uint96 newAmount) internal {\n    require(residue <= newAmount, \"Impossible to relock: less amount, then now is\");\n    uint96 addAmount = newAmount - (residue);\n    uint96 amount = accounts[account].amount;\n    uint96 balance = amount - (bias);\n    if (addAmount > balance) {\n      //need more, than balance, so need transfer tokens to this\n      uint96 transferAmount = addAmount - (balance);\n      accounts[account].amount = accounts[account].amount + (transferAmount);\n      // slither-disable-start arbitrary-send-erc20\n      // slither-disable-start reentrancy-events\n      // slither-disable-start reentrancy-benign\n      // slither-disable-next-line reentrancy-no-eth\n      require(token.transferFrom(locks[id].account, address(this), transferAmount), \"transfer failed\");\n      // slither-disable-end arbitrary-send-erc20\n      // slither-disable-end reentrancy-events\n      // slither-disable-end reentrancy-benign\n    }\n  }\n\n  uint256[50] private __gap;\n}\n"},{"file_path":"lib/mento-core-2.6.2/contracts/governance/locking/LockingVotes.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.18;\n// solhint-disable no-unused-vars, gas-custom-errors\n\nimport \"./LockingBase.sol\";\n\n/**\n * @notice https://github.com/rarible/locking-contracts/tree/4f189a96b3e85602dedfbaf69d9a1f5056d835eb\n */\ncontract LockingVotes is LockingBase {\n  using LibBrokenLine for LibBrokenLine.BrokenLine;\n\n  /**\n   * @dev Returns the current amount of votes that `account` has.\n   */\n  function getVotes(address account) external view override returns (uint256) {\n    uint32 currentBlock = getBlockNumber();\n    uint32 currentWeek = getWeekNumber(currentBlock);\n    return accounts[account].balance.actualValue(currentWeek, currentBlock);\n  }\n\n  /**\n   * @dev Returns the amount of votes that `account` had\n   * at the end of the last period\n   */\n  function getPastVotes(address account, uint256 blockNumber) external view override returns (uint256) {\n    uint32 currentWeek = getWeekNumber(uint32(blockNumber));\n    require(blockNumber < getBlockNumber() && currentWeek > 0, \"block not yet mined\");\n\n    return accounts[account].balance.actualValue(currentWeek, uint32(blockNumber));\n  }\n\n  /**\n   * @dev Returns the total supply of votes available\n   * at the end of the last period\n   */\n  function getPastTotalSupply(uint256 blockNumber) external view override returns (uint256) {\n    uint32 currentWeek = getWeekNumber(uint32(blockNumber));\n    require(blockNumber < getBlockNumber() && currentWeek > 0, \"block not yet mined\");\n\n    return totalSupplyLine.actualValue(currentWeek, uint32(blockNumber));\n  }\n\n  /**\n   * @dev Returns the delegate that `account` has chosen.\n   */\n  function delegates(address /* account */) external pure override returns (address) {\n    revert(\"not implemented\");\n  }\n\n  /**\n   * @dev Delegates votes from the sender to `delegatee`.\n   */\n  function delegate(address /* delegatee */) external pure override {\n    revert(\"not implemented\");\n  }\n\n  /**\n   * @dev Delegates votes from signer to `delegatee`.\n   */\n  function delegateBySig(\n    address, // delegatee\n    uint256, // nonce\n    uint256, // expiry\n    uint8, // v\n    bytes32, // r\n    bytes32 // s\n  ) external pure override {\n    revert(\"not implemented\");\n  }\n\n  uint256[50] private __gap;\n}\n"},{"file_path":"lib/mento-core-2.6.2/contracts/governance/locking/interfaces/ILocking.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.18;\n\n/**\n * @title ILocking\n * @notice Interface for the Locking contract\n */\n\ninterface ILocking {\n  /**\n   * @notice Locks a specified amount of tokens for a given period\n   * @param account Account for which tokens are being locked\n   * @param delegate Address that will receive the voting power from the locked tokens\n   * If address(0) passed, voting power will be lost\n   * @param amount Amount of tokens to lock\n   * @param slope Period over which the tokens will unlock\n   * @param cliff Initial period during which tokens remain locked and do not start unlocking\n   * @return Id for the created lock\n   */\n  function lock(\n    address account,\n    address delegate,\n    uint96 amount,\n    uint32 slope,\n    uint32 cliff\n  ) external returns (uint256);\n}\n"},{"file_path":"lib/mento-core-2.6.2/contracts/governance/locking/libs/LibBrokenLine.sol","source_code":"// SPDX-License-Identifier: MIT\n// solhint-disable gas-custom-errors\npragma solidity 0.8.18;\n\nimport \"./LibIntMapping.sol\";\n\n/**\n * Line describes a linear function, how the user's voice decreases from point (start, bias) with speed slope\n * BrokenLine - a curve that describes the curve of the change in the sum of votes of several users\n * This curve starts with a line (Line) and then, at any time, the slope can be changed.\n * All slope changes are stored in slopeChanges. The slope can always be reduced only, it cannot increase,\n * because users can only run out of lockup periods.\n **/\n\nlibrary LibBrokenLine {\n  using LibIntMapping for mapping(uint256 => int96);\n  /**\n   * @dev Line describes a function\n   * start - week number when line starts\n   * bias - initial y value of the function\n   * slope - absolute value of the slope applied during slope period\n   * cliff - period where slope is 0 and bias is not changing\n   */\n  struct Line {\n    uint32 start;\n    uint96 bias;\n    uint96 slope;\n    uint32 cliff;\n  }\n  /**\n   * @dev Point describes a point in time\n   * blockNumber - block number when the point was saved\n   * bias - y value of the line at snapshot time\n   * slope - current slope at snapshot time\n   * epoch - week number when the point was saved\n   */\n  struct Point {\n    uint32 blockNumber;\n    uint96 bias;\n    uint96 slope;\n    uint32 epoch;\n  }\n  /**\n   * @dev BrokenLine struct is used to track and document a function\n   * slopeChanges - a map of changes in slope at a certain time\n   * initiatedLines - a map of initiated (successfully added) Lines\n   * history - a list of snapshots of the function\n   * initial - the line representing the aggregated lines from the initiatedLines mapping\n   */\n  struct BrokenLine {\n    mapping(uint256 => int96) slopeChanges; //change of slope applies to the next time point\n    mapping(uint256 => Line) initiatedLines; //initiated (successfully added) Lines\n    Point[] history;\n    Line initial;\n  }\n\n  /**\n   * @notice Adds a line to a given BrokenLine struct\n   * @dev Add Line, save data in LineData. Run update BrokenLine, require:\n   *      1. slope != 0, slope <= bias\n   *      2. line not exists\n   * @param brokenLine the BrokenLine struct to add the line to\n   * @param id the id of the line to add\n   * @param line the line to add\n   */\n  function _addOneLine(BrokenLine storage brokenLine, uint256 id, Line memory line) internal {\n    require(line.slope != 0, \"Slope == 0, unacceptable value for slope\");\n    require(line.slope <= line.bias, \"Slope > bias, unacceptable value for slope\");\n    require(brokenLine.initiatedLines[id].bias == 0, \"Line with given id is already exist\");\n    brokenLine.initiatedLines[id] = line;\n\n    update(brokenLine, line.start);\n    brokenLine.initial.bias = brokenLine.initial.bias + (line.bias);\n    //save bias for history in line.start minus one\n    uint32 lineStartMinusOne = line.start - 1;\n    //period is time without tail\n    uint32 period = uint32(line.bias / (line.slope));\n\n    if (line.cliff == 0) {\n      //no cliff, need to increase brokenLine.initial.slope write now\n      brokenLine.initial.slope = brokenLine.initial.slope + (line.slope);\n      //no cliff, save slope in history in time minus one\n      brokenLine.slopeChanges.addToItem(lineStartMinusOne, safeInt(line.slope));\n    } else {\n      //cliffEnd finish in lineStart minus one plus cliff\n      uint32 cliffEnd = lineStartMinusOne + (line.cliff);\n      //save slope in history in cliffEnd\n      brokenLine.slopeChanges.addToItem(cliffEnd, safeInt(line.slope));\n      period = period + (line.cliff);\n    }\n\n    int96 mod = safeInt(line.bias % (line.slope));\n    uint32 endPeriod = line.start + (period);\n    uint32 endPeriodMinus1 = endPeriod - 1;\n    brokenLine.slopeChanges.subFromItem(endPeriodMinus1, safeInt(line.slope) - (mod));\n    brokenLine.slopeChanges.subFromItem(endPeriod, mod);\n  }\n\n  /**\n   * @notice Adds a line to a given BrokenLine struct and saves a snapshot\n   * @param brokenLine the BrokenLine struct to add the line to\n   * @param id the id of the line to add\n   * @param line the line to add\n   * @param blockNumber the block number when the line is added\n   */\n  function addOneLine(BrokenLine storage brokenLine, uint256 id, Line memory line, uint32 blockNumber) internal {\n    _addOneLine(brokenLine, id, line);\n    saveSnapshot(brokenLine, line.start, blockNumber);\n  }\n\n  /**\n   * @notice Removes a line from a given BrokenLine struct\n   * @param brokenLine the BrokenLine struct to remove the line from\n   * @param id the id of the line to remove\n   * @param toTime current week number\n   * @return bias - the current y value of the removed line\n   * @return slope - the current absolute slope value of the removed line\n   * @return cliff - the remaining cliff period of the removed line\n   */\n  function _remove(\n    BrokenLine storage brokenLine,\n    uint256 id,\n    uint32 toTime\n  ) internal returns (uint96 bias, uint96 slope, uint32 cliff) {\n    Line memory line = brokenLine.initiatedLines[id];\n    require(line.bias != 0, \"Removing Line, which not exists\");\n\n    update(brokenLine, toTime);\n    //check time Line is over\n    bias = line.bias;\n    slope = line.slope;\n    cliff = 0;\n    //for information: bias / (slope) - this`s period while slope works\n    uint32 finishTime = line.start + (uint32(bias / (slope))) + (line.cliff);\n    if (toTime > finishTime) {\n      bias = 0;\n      slope = 0;\n      return (bias, slope, cliff);\n    }\n    uint32 finishTimeMinusOne = finishTime - 1;\n    uint32 toTimeMinusOne = toTime - 1;\n    int96 mod = safeInt(bias % slope);\n    uint32 cliffEnd = line.start + (line.cliff) - 1;\n    if (toTime <= cliffEnd) {\n      //cliff works\n      cliff = cliffEnd - (toTime) + 1;\n      //in cliff finish time compensate change slope by oldLine.slope\n      brokenLine.slopeChanges.subFromItem(cliffEnd, safeInt(slope));\n      //in new Line finish point use oldLine.slope\n      brokenLine.slopeChanges.addToItem(finishTimeMinusOne, safeInt(slope) - (mod));\n    } else if (toTime <= finishTimeMinusOne) {\n      //slope works\n      //now compensate change slope by oldLine.slope\n      brokenLine.initial.slope = brokenLine.initial.slope - (slope);\n      //in new Line finish point use oldLine.slope\n      brokenLine.slopeChanges.addToItem(finishTimeMinusOne, safeInt(slope) - (mod));\n      bias = (uint96(finishTime - (toTime)) * slope) + (uint96(mod));\n      //save slope for history\n      brokenLine.slopeChanges.subFromItem(toTimeMinusOne, safeInt(slope));\n    } else {\n      //tail works\n      //now compensate change slope by tail\n      brokenLine.initial.slope = brokenLine.initial.slope - (uint96(mod));\n      bias = uint96(mod);\n      slope = bias;\n      //save slope for history\n      brokenLine.slopeChanges.subFromItem(toTimeMinusOne, safeInt(slope));\n    }\n    brokenLine.slopeChanges.addToItem(finishTime, mod);\n    brokenLine.initial.bias = brokenLine.initial.bias - (bias);\n    brokenLine.initiatedLines[id].bias = 0;\n  }\n\n  /**\n   * @notice Removes a line from a given BrokenLine struct and saves a snapshot\n   * @param brokenLine the BrokenLine struct to remove the line from\n   * @param id the id of the line to remove\n   * @param toTime current week number\n   * @param blockNumber the block number when the line is removed\n   * @return bias - the current y value of the removed line\n   * @return slope - the current absolute slope value of the removed line\n   * @return cliff - the remaining cliff period of the removed line\n   */\n  function remove(\n    BrokenLine storage brokenLine,\n    uint256 id,\n    uint32 toTime,\n    uint32 blockNumber\n  ) internal returns (uint96 bias, uint96 slope, uint32 cliff) {\n    (bias, slope, cliff) = _remove(brokenLine, id, toTime);\n    saveSnapshot(brokenLine, toTime, blockNumber);\n  }\n\n  /**\n   * @notice Updates a given BrokenLine until a given week number\n   * @param brokenLine the BrokenLine struct to update\n   * @param toTime the week number to update the BrokenLine to\n   */\n  function update(BrokenLine storage brokenLine, uint32 toTime) internal {\n    uint32 time = brokenLine.initial.start;\n    if (time == toTime) {\n      return;\n    }\n    uint96 slope = brokenLine.initial.slope;\n    uint96 bias = brokenLine.initial.bias;\n    if (bias != 0) {\n      require(toTime > time, \"can't update BrokenLine for past time\");\n      while (time < toTime) {\n        bias = bias - (slope);\n\n        int96 newSlope = safeInt(slope) + (brokenLine.slopeChanges[time]);\n        require(newSlope >= 0, \"slope < 0, something wrong with slope\");\n        slope = uint96(newSlope);\n\n        time = time + 1;\n      }\n    }\n    brokenLine.initial.start = toTime;\n    brokenLine.initial.bias = bias;\n    brokenLine.initial.slope = slope;\n  }\n\n  /**\n   * @notice Returns y value of a given BrokenLine at a given week and block number\n   * @param brokenLine the BrokenLine struct to get the value from\n   * @param toTime the week number to get the value at\n   * @param toBlock the block number to get the value at\n   * @return the y value of the BrokenLine at the given week and block number\n   */\n  function actualValue(BrokenLine storage brokenLine, uint32 toTime, uint32 toBlock) internal view returns (uint96) {\n    uint32 fromTime = brokenLine.initial.start;\n    if (fromTime == toTime) {\n      if (brokenLine.history[brokenLine.history.length - 1].blockNumber < toBlock) {\n        return (brokenLine.initial.bias);\n      } else {\n        return actualValueBack(brokenLine, toTime, toBlock);\n      }\n    }\n    if (toTime > fromTime) {\n      return actualValueForward(brokenLine, fromTime, toTime, brokenLine.initial.bias, brokenLine.initial.slope);\n    }\n    return actualValueBack(brokenLine, toTime, toBlock);\n  }\n\n  /**\n   * @notice Calculates and returns the y value of a given BrokenLine for given a week\n   * @dev calculates the y value at toTime by applying the slope to the bias starting at the fromTime.\n   * Per week the slope is updated by the slopeChanges map until the toTime is reached.\n   * @param brokenLine the BrokenLine struct to calculate the value for\n   * @param fromTime the week number to start the calculation from\n   * @param toTime the week number to calculate the value at\n   * @param bias the y value at the fromTime\n   * @param slope the absolute slope value at the fromTime\n   * @return the y value of the BrokenLine at the given toTime week\n   */\n  function actualValueForward(\n    BrokenLine storage brokenLine,\n    uint32 fromTime,\n    uint32 toTime,\n    uint96 bias,\n    uint96 slope\n  ) internal view returns (uint96) {\n    if ((bias == 0)) {\n      return (bias);\n    }\n    uint32 time = fromTime;\n\n    while (time < toTime) {\n      bias = bias - (slope);\n\n      int96 newSlope = safeInt(slope) + (brokenLine.slopeChanges[time]);\n      require(newSlope >= 0, \"slope < 0, something wrong with slope\");\n      slope = uint96(newSlope);\n\n      time = time + 1;\n    }\n    return bias;\n  }\n\n  /**\n   * @notice Finds the closest snapshot to a given block number and calculates the y value based on that.\n   * @param brokenLine the BrokenLine struct to calculate the value for\n   * @param toTime the week number to get the y value at\n   * @param toBlock the block number to get the y value at\n   * @return the y value of the BrokenLine at the given toTime week\n   */\n  function actualValueBack(\n    BrokenLine storage brokenLine,\n    uint32 toTime,\n    uint32 toBlock\n  ) internal view returns (uint96) {\n    (uint96 bias, uint96 slope, uint32 fromTime) = binarySearch(brokenLine.history, toBlock);\n    return actualValueForward(brokenLine, fromTime, toTime, bias, slope);\n  }\n\n  /**\n   * @notice Safely casts a uint96 to an int96\n   * @param value the uint96 to cast\n   * @return result the int96 represesntation of the given uint96 value\n   */\n  function safeInt(uint96 value) internal pure returns (int96 result) {\n    require(value < 2 ** 95, \"int cast error\");\n    result = int96(value);\n  }\n\n  /**\n   * @notice Saves a point in the history of a given BrokenLine\n   * @param brokenLine The BrokenLine that will be snapshotted\n   * @param epoch The week number of the snapshot\n   * @param blockNumber The block number of the snapshot\n   */\n  function saveSnapshot(BrokenLine storage brokenLine, uint32 epoch, uint32 blockNumber) internal {\n    brokenLine.history.push(\n      Point({ blockNumber: blockNumber, bias: brokenLine.initial.bias, slope: brokenLine.initial.slope, epoch: epoch })\n    );\n  }\n\n  /**\n   * @notice Search for a block number in Points array\n   * @dev Performs a binary search on an arrary of Points to find the\n   *      element with the closest block number less than or equal to toBlock\n   * @param history The array of snapshots of Points\n   * @param toBlock The block number to search for\n   * @return bias The y value of the point\n   * @return slope The slope of the point\n   * @return epoch The week number of the point\n   */\n  function binarySearch(Point[] storage history, uint32 toBlock) internal view returns (uint96, uint96, uint32) {\n    uint256 len = history.length;\n    if (len == 0 || history[0].blockNumber > toBlock) {\n      return (0, 0, 0);\n    }\n    uint256 min = 0;\n    uint256 max = len - 1;\n\n    for (uint256 i = 0; i < 128; i++) {\n      if (min >= max) {\n        break;\n      }\n      uint256 mid = (min + max + 1) / 2;\n      if (history[mid].blockNumber <= toBlock) {\n        min = mid;\n      } else {\n        max = mid - 1;\n      }\n    }\n    return (history[min].bias, history[min].slope, history[min].epoch);\n  }\n}\n"},{"file_path":"lib/mento-core-2.6.2/contracts/governance/locking/libs/LibIntMapping.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.18;\n\n/**\n * @title LibIntMapping\n * @notice Library for working with int96 mappings\n */\nlibrary LibIntMapping {\n  /**\n   * @notice Adds value to the item in the mapping\n   * @param map Mapping to add to\n   * @param key Key of the item\n   * @param value Value to add\n   */\n  function addToItem(mapping(uint256 => int96) storage map, uint256 key, int96 value) internal {\n    map[key] = map[key] + (value);\n  }\n\n  /**\n   * @notice Subtracts value from the item in the mapping\n   * @param map Mapping to subtract from\n   * @param key Key of the item\n   * @param value Value to subtract\n   */\n  function subFromItem(mapping(uint256 => int96) storage map, uint256 key, int96 value) internal {\n    map[key] = map[key] - (value);\n  }\n}\n"},{"file_path":"lib/mento-core-2.6.2/lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    function __Ownable_init() internal onlyInitializing {\n        __Ownable_init_unchained();\n    }\n\n    function __Ownable_init_unchained() internal onlyInitializing {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n"},{"file_path":"lib/mento-core-2.6.2/lib/openzeppelin-contracts-upgradeable/contracts/governance/utils/IVotesUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (governance/utils/IVotes.sol)\npragma solidity ^0.8.0;\n\n/**\n * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts.\n *\n * _Available since v4.5._\n */\ninterface IVotesUpgradeable {\n    /**\n     * @dev Emitted when an account changes their delegate.\n     */\n    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);\n\n    /**\n     * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of votes.\n     */\n    event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);\n\n    /**\n     * @dev Returns the current amount of votes that `account` has.\n     */\n    function getVotes(address account) external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of votes that `account` had at the end of a past block (`blockNumber`).\n     */\n    function getPastVotes(address account, uint256 blockNumber) external view returns (uint256);\n\n    /**\n     * @dev Returns the total supply of votes available at the end of a past block (`blockNumber`).\n     *\n     * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes.\n     * Votes that have not been delegated are still part of total supply, even though they would not participate in a\n     * vote.\n     */\n    function getPastTotalSupply(uint256 blockNumber) external view returns (uint256);\n\n    /**\n     * @dev Returns the delegate that `account` has chosen.\n     */\n    function delegates(address account) external view returns (address);\n\n    /**\n     * @dev Delegates votes from the sender to `delegatee`.\n     */\n    function delegate(address delegatee) external;\n\n    /**\n     * @dev Delegates votes from signer to `delegatee`.\n     */\n    function delegateBySig(\n        address delegatee,\n        uint256 nonce,\n        uint256 expiry,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n}\n"},{"file_path":"lib/mento-core-2.6.2/lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.1) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * contract MyToken is ERC20Upgradeable {\n *     function initialize() initializer public {\n *         __ERC20_init(\"MyToken\", \"MTK\");\n *     }\n * }\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n *     function initializeV2() reinitializer(2) public {\n *         __ERC20Permit_init(\"MyToken\");\n *     }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n *     _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n    /**\n     * @dev Indicates that the contract has been initialized.\n     * @custom:oz-retyped-from bool\n     */\n    uint8 private _initialized;\n\n    /**\n     * @dev Indicates that the contract is in the process of being initialized.\n     */\n    bool private _initializing;\n\n    /**\n     * @dev Triggered when the contract has been initialized or reinitialized.\n     */\n    event Initialized(uint8 version);\n\n    /**\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n     * `onlyInitializing` functions can be used to initialize parent contracts.\n     *\n     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\n     * constructor.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier initializer() {\n        bool isTopLevelCall = !_initializing;\n        require(\n            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n            \"Initializable: contract is already initialized\"\n        );\n        _initialized = 1;\n        if (isTopLevelCall) {\n            _initializing = true;\n        }\n        _;\n        if (isTopLevelCall) {\n            _initializing = false;\n            emit Initialized(1);\n        }\n    }\n\n    /**\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n     * used to initialize parent contracts.\n     *\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n     * are added through upgrades and that require initialization.\n     *\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\n     *\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n     * a contract, executing them in the right order is up to the developer or operator.\n     *\n     * WARNING: setting the version to 255 will prevent any future reinitialization.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier reinitializer(uint8 version) {\n        require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n        _initialized = version;\n        _initializing = true;\n        _;\n        _initializing = false;\n        emit Initialized(version);\n    }\n\n    /**\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\n     */\n    modifier onlyInitializing() {\n        require(_initializing, \"Initializable: contract is not initializing\");\n        _;\n    }\n\n    /**\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n     * through proxies.\n     *\n     * Emits an {Initialized} event the first time it is successfully executed.\n     */\n    function _disableInitializers() internal virtual {\n        require(!_initializing, \"Initializable: contract is initializing\");\n        if (_initialized < type(uint8).max) {\n            _initialized = type(uint8).max;\n            emit Initialized(type(uint8).max);\n        }\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function _getInitializedVersion() internal view returns (uint8) {\n        return _initialized;\n    }\n\n    /**\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n     */\n    function _isInitializing() internal view returns (bool) {\n        return _initializing;\n    }\n}\n"},{"file_path":"lib/mento-core-2.6.2/lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/IERC20Upgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20Upgradeable {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(\n        address from,\n        address to,\n        uint256 amount\n    ) external returns (bool);\n}\n"},{"file_path":"lib/mento-core-2.6.2/lib/openzeppelin-contracts-upgradeable/contracts/utils/AddressUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n"},{"file_path":"lib/mento-core-2.6.2/lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n    function __Context_init() internal onlyInitializing {\n    }\n\n    function __Context_init_unchained() internal onlyInitializing {\n    }\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n"}],"certified":false,"conflicting_implementations":null,"abi":[{"inputs":[{"internalType":"bool","name":"disableInitializers","type":"bool"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"time","type":"uint256"}],"name":"Delegate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"DelegateVotesChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"time","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"slopePeriod","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cliff","type":"uint256"}],"name":"LockCreate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"counter","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"time","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"slopePeriod","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cliff","type":"uint256"}],"name":"Relock","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint32","name":"l2EpochShift","type":"uint32"}],"name":"SetL2EpochShift","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"int256","name":"l2StartingPointWeek","type":"int256"}],"name":"SetL2StartingPointWeek","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"l2TransitionBlock","type":"uint256"}],"name":"SetL2TransitionBlock","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"mentoLabsMultisig","type":"address"}],"name":"SetMentoLabsMultisig","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"newMinCliffPeriod","type":"uint256"}],"name":"SetMinCliffPeriod","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"newMinSlopePeriod","type":"uint256"}],"name":"SetMinSlopePeriod","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bool","name":"paused","type":"bool"}],"name":"SetPaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"L1_EPOCH_SHIFT","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"L2_WEEK","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WEEK","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20Upgradeable","name":"_token","type":"address"},{"internalType":"uint32","name":"_startingPointWeek","type":"uint32"},{"internalType":"uint32","name":"_minCliffPeriod","type":"uint32"},{"internalType":"uint32","name":"_minSlopePeriod","type":"uint32"}],"name":"__Locking_init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"counter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint8","name":"","type":"uint8"},{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"newDelegate","type":"address"}],"name":"delegateTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"getAccountAndDelegate","outputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"address","name":"_delegate","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getAvailableForWithdraw","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint96","name":"amount","type":"uint96"},{"internalType":"uint32","name":"slopePeriod","type":"uint32"},{"internalType":"uint32","name":"cliff","type":"uint32"}],"name":"getLock","outputs":[{"internalType":"uint96","name":"lockAmount","type":"uint96"},{"internalType":"uint96","name":"lockSlope","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getWeek","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"blockNumber","type":"uint32"}],"name":"getWeekNumber","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l2EpochShift","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l2StartingPointWeek","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l2TransitionBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"_delegate","type":"address"},{"internalType":"uint96","name":"amount","type":"uint96"},{"internalType":"uint32","name":"slopePeriod","type":"uint32"},{"internalType":"uint32","name":"cliff","type":"uint32"}],"name":"lock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"locked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mentoLabsMultisig","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minCliffPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minSlopePeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"newDelegate","type":"address"},{"internalType":"uint96","name":"newAmount","type":"uint96"},{"internalType":"uint32","name":"newSlopePeriod","type":"uint32"},{"internalType":"uint32","name":"newCliff","type":"uint32"}],"name":"relock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"l2EpochShift_","type":"uint32"}],"name":"setL2EpochShift","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"l2StartingPointWeek_","type":"int256"}],"name":"setL2StartingPointWeek","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"l2TransitionBlock_","type":"uint256"}],"name":"setL2TransitionBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"mentoLabsMultisig_","type":"address"}],"name":"setMentoLabsMultisig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"newMinCliffPeriod","type":"uint32"}],"name":"setMinCliffPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"newMinSlopePeriod","type":"uint32"}],"name":"setMinSlopePeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"paused_","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startingPointWeek","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20Upgradeable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupplyLine","outputs":[{"components":[{"internalType":"uint32","name":"start","type":"uint32"},{"internalType":"uint96","name":"bias","type":"uint96"},{"internalType":"uint96","name":"slope","type":"uint96"},{"internalType":"uint32","name":"cliff","type":"uint32"}],"internalType":"struct LibBrokenLine.Line","name":"initial","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint32","name":"time","type":"uint32"}],"name":"updateAccountLines","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint32","name":"blockNumber","type":"uint32"}],"name":"updateAccountLinesBlockNumber","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"time","type":"uint32"}],"name":"updateTotalSupplyLine","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"blockNumber","type":"uint32"}],"name":"updateTotalSupplyLineBlockNumber","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}],"is_changed_bytecode":false,"is_partially_verified":true,"constructor_args":"0x0000000000000000000000000000000000000000000000000000000000000001"}