Contract Name:
LineaRollup
Contract Source Code:
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)
pragma solidity ^0.8.0;
import "./IAccessControlUpgradeable.sol";
import "../utils/ContextUpgradeable.sol";
import "../utils/StringsUpgradeable.sol";
import "../utils/introspection/ERC165Upgradeable.sol";
import "../proxy/utils/Initializable.sol";
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms. This is a lightweight version that doesn't allow enumerating role
* members except through off-chain means by accessing the contract event logs. Some
* applications may benefit from on-chain enumerability, for those cases see
* {AccessControlEnumerable}.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```solidity
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```solidity
* function foo() public {
* require(hasRole(MY_ROLE, msg.sender));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
* grant and revoke this role. Extra precautions should be taken to secure
* accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
* to enforce additional security measures for this role.
*/
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {
function __AccessControl_init() internal onlyInitializing {
}
function __AccessControl_init_unchained() internal onlyInitializing {
}
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Modifier that checks that an account has a specific role. Reverts
* with a standardized message including the required role.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*
* _Available since v4.1._
*/
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
return _roles[role].members[account];
}
/**
* @dev Revert with a standard message if `_msgSender()` is missing `role`.
* Overriding this function changes the behavior of the {onlyRole} modifier.
*
* Format of the revert message is described in {_checkRole}.
*
* _Available since v4.6._
*/
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
/**
* @dev Revert with a standard message if `account` is missing `role`.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*/
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
StringsUpgradeable.toHexString(account),
" is missing role ",
StringsUpgradeable.toHexString(uint256(role), 32)
)
)
);
}
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
return _roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleGranted} event.
*/
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleRevoked} event.
*/
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been revoked `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*
* May emit a {RoleRevoked} event.
*/
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event. Note that unlike {grantRole}, this function doesn't perform any
* checks on the calling account.
*
* May emit a {RoleGranted} event.
*
* [WARNING]
* ====
* This function should only be called from the constructor when setting
* up the initial roles for the system.
*
* Using this function in any other way is effectively circumventing the admin
* system imposed by {AccessControl}.
* ====
*
* NOTE: This function is deprecated in favor of {_grantRole}.
*/
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
/**
* @dev Grants `role` to `account`.
*
* Internal function without access restriction.
*
* May emit a {RoleGranted} event.
*/
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
/**
* @dev Revokes `role` from `account`.
*
* Internal function without access restriction.
*
* May emit a {RoleRevoked} event.
*/
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)
pragma solidity ^0.8.0;
/**
* @dev External interface of AccessControl declared to support ERC165 detection.
*/
interface IAccessControlUpgradeable {
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*
* _Available since v3.1._
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call, an admin role
* bearer except when using {AccessControl-_setupRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) external view returns (bool);
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {AccessControl-_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) external view returns (bytes32);
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) external;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
* constructor.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: setting the version to 255 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized != type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuardUpgradeable is Initializable {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
function __ReentrancyGuard_init() internal onlyInitializing {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal onlyInitializing {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
// On the first call to nonReentrant, _status will be _NOT_ENTERED
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
}
function _nonReentrantAfter() private {
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
/**
* @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
* `nonReentrant` function in the call stack.
*/
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
*
* Furthermore, `isContract` will also return true if the target contract within
* the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
* which only has an effect at the end of a transaction.
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
import "./IERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
function __ERC165_init() internal onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165Upgradeable {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library MathUpgradeable {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
* with further edits by Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1, "Math: mulDiv overflow");
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256, rounded down, of a positive value.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard signed math utilities missing in the Solidity language.
*/
library SignedMathUpgradeable {
/**
* @dev Returns the largest of two signed numbers.
*/
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two signed numbers.
*/
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two signed numbers without overflow.
* The result is rounded towards zero.
*/
function average(int256 a, int256 b) internal pure returns (int256) {
// Formula from the book "Hacker's Delight"
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
/**
* @dev Returns the absolute unsigned value of a signed value.
*/
function abs(int256 n) internal pure returns (uint256) {
unchecked {
// must be unchecked in order to support `n = type(int256).min`
return uint256(n >= 0 ? n : -n);
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
import "./math/MathUpgradeable.sol";
import "./math/SignedMathUpgradeable.sol";
/**
* @dev String operations.
*/
library StringsUpgradeable {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = MathUpgradeable.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `int256` to its ASCII `string` decimal representation.
*/
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMathUpgradeable.abs(value))));
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, MathUpgradeable.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
/**
* @dev Returns true if the two strings are equal.
*/
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/BitMaps.sol)
pragma solidity ^0.8.0;
/**
* @dev Library for managing uint256 to bool mapping in a compact and efficient way, providing the keys are sequential.
* Largely inspired by Uniswap's https://github.com/Uniswap/merkle-distributor/blob/master/contracts/MerkleDistributor.sol[merkle-distributor].
*/
library BitMaps {
struct BitMap {
mapping(uint256 => uint256) _data;
}
/**
* @dev Returns whether the bit at `index` is set.
*/
function get(BitMap storage bitmap, uint256 index) internal view returns (bool) {
uint256 bucket = index >> 8;
uint256 mask = 1 << (index & 0xff);
return bitmap._data[bucket] & mask != 0;
}
/**
* @dev Sets the bit at `index` to the boolean `value`.
*/
function setTo(BitMap storage bitmap, uint256 index, bool value) internal {
if (value) {
set(bitmap, index);
} else {
unset(bitmap, index);
}
}
/**
* @dev Sets the bit at `index`.
*/
function set(BitMap storage bitmap, uint256 index) internal {
uint256 bucket = index >> 8;
uint256 mask = 1 << (index & 0xff);
bitmap._data[bucket] |= mask;
}
/**
* @dev Unsets the bit at `index`.
*/
function unset(BitMap storage bitmap, uint256 index) internal {
uint256 bucket = index >> 8;
uint256 mask = 1 << (index & 0xff);
bitmap._data[bucket] &= ~mask;
}
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity >=0.8.19 <=0.8.22;
/**
* @title Interface declaring generic errors.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
interface IGenericErrors {
/**
* @dev Thrown when a parameter is the zero address.
*/
error ZeroAddressNotAllowed();
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity >=0.8.19 <=0.8.22;
/**
* @title Interface declaring pre-existing cross-chain messaging functions, events and errors.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
interface IMessageService {
/**
* @dev Emitted when a message is sent.
* @dev We include the message hash to save hashing costs on the rollup.
*/
event MessageSent(
address indexed _from,
address indexed _to,
uint256 _fee,
uint256 _value,
uint256 _nonce,
bytes _calldata,
bytes32 indexed _messageHash
);
/**
* @dev Emitted when a message is claimed.
*/
event MessageClaimed(bytes32 indexed _messageHash);
/**
* @dev Thrown when fees are lower than the minimum fee.
*/
error FeeTooLow();
/**
* @dev Thrown when the value sent is less than the fee.
* @dev Value to forward on is msg.value - _fee.
*/
error ValueSentTooLow();
/**
* @dev Thrown when the destination address reverts.
*/
error MessageSendingFailed(address destination);
/**
* @dev Thrown when the recipient address reverts.
*/
error FeePaymentFailed(address recipient);
/**
* @notice Sends a message for transporting from the given chain.
* @dev This function should be called with a msg.value = _value + _fee. The fee will be paid on the destination chain.
* @param _to The destination address on the destination chain.
* @param _fee The message service fee on the origin chain.
* @param _calldata The calldata used by the destination message service to call the destination contract.
*/
function sendMessage(address _to, uint256 _fee, bytes calldata _calldata) external payable;
/**
* @notice Deliver a message to the destination chain.
* @notice Is called by the Postman, dApp or end user.
* @param _from The msg.sender calling the origin message service.
* @param _to The destination address on the destination chain.
* @param _value The value to be transferred to the destination address.
* @param _fee The message service fee on the origin chain.
* @param _feeRecipient Address that will receive the fees.
* @param _calldata The calldata used by the destination message service to call/forward to the destination contract.
* @param _nonce Unique message number.
*/
function claimMessage(
address _from,
address _to,
uint256 _fee,
uint256 _value,
address payable _feeRecipient,
bytes calldata _calldata,
uint256 _nonce
) external;
/**
* @notice Returns the original sender of the message on the origin layer.
* @return The original sender of the message on the origin layer.
*/
function sender() external view returns (address);
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity >=0.8.19 <=0.8.22;
/**
* @title Interface declaring pre-existing pausing functions, events and errors.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
interface IPauseManager {
/**
* @dev Thrown when a specific pause type is paused.
*/
error IsPaused(uint256 pauseType);
/**
* @dev Thrown when a specific pause type is not paused and expected to be.
*/
error IsNotPaused(uint256 pauseType);
/**
* @dev Emitted when a pause type is paused.
*/
event Paused(address messageSender, uint256 indexed pauseType);
/**
* @dev Emitted when a pause type is unpaused.
*/
event UnPaused(address messageSender, uint256 indexed pauseType);
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity >=0.8.19 <=0.8.22;
/**
* @title Interface declaring rate limiting messaging functions, events and errors.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
interface IRateLimiter {
/**
* @dev Thrown when an amount breaches the limit in the period.
*/
error RateLimitExceeded();
/**
* @dev Thrown when the period is initialised to zero.
*/
error PeriodIsZero();
/**
* @dev Thrown when the limit is initialised to zero.
*/
error LimitIsZero();
/**
* @dev Emitted when the Rate Limit is initialized.
*/
event RateLimitInitialized(uint256 periodInSeconds, uint256 limitInWei, uint256 currentPeriodEnd);
/**
* @dev Emitted when the amount in the period is reset to zero.
*/
event AmountUsedInPeriodReset(address indexed resettingAddress);
/**
* @dev Emitted when the limit is changed.
* @dev If the current used amount is higher than the new limit, the used amount is lowered to the limit.
*/
event LimitAmountChanged(
address indexed amountChangeBy,
uint256 amount,
bool amountUsedLoweredToLimit,
bool usedAmountResetToZero
);
/**
* @notice Resets the rate limit amount to the amount specified.
* @param _amount sets the new limit amount.
*/
function resetRateLimitAmount(uint256 _amount) external;
/**
* @notice Resets the amount used in the period to zero.
*/
function resetAmountUsedInPeriod() external;
}
// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.22;
/**
* @title L1 Message manager interface for current functions, events and errors.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
interface IL1MessageManager {
/**
* @dev Emitted when a new message is sent and the rolling hash updated.
*/
event RollingHashUpdated(uint256 indexed messageNumber, bytes32 indexed rollingHash, bytes32 indexed messageHash);
/**
* @dev Emitted when the l2 merkle root has been anchored on L1.
*/
event L2MerkleRootAdded(bytes32 indexed l2MerkleRoot, uint256 indexed treeDepth);
/**
* @dev Emitted when the l2 block contains L2 messages during finalization
*/
event L2MessagingBlockAnchored(uint256 indexed l2Block);
/**
* @dev Thrown when the message has already been claimed.
*/
error MessageAlreadyClaimed(uint256 messageIndex);
/**
* @dev Thrown when the L2 merkle root has already been anchored on L1.
*/
error L2MerkleRootAlreadyAnchored(bytes32 merkleRoot);
/**
* @dev Thrown when the L2 messaging blocks offsets bytes length is not a multiple of 2.
*/
error BytesLengthNotMultipleOfTwo(uint256 bytesLength);
/**
* @notice Check if the L2->L1 message is claimed or not.
* @param _messageNumber The message number on L2.
*/
function isMessageClaimed(uint256 _messageNumber) external view returns (bool);
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.22;
/**
* @title L1 Message manager V1 interface for pre-existing functions, events and errors.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
interface IL1MessageManagerV1 {
/**
* @dev Emitted when L2->L1 message hashes have been added to L1 storage.
*/
event L2L1MessageHashAddedToInbox(bytes32 indexed messageHash);
/**
* @dev Emitted when L1->L2 messages have been anchored on L2 and updated on L1.
*/
event L1L2MessagesReceivedOnL2(bytes32[] messageHashes);
/**
* @dev Thrown when the message has already been claimed.
*/
error MessageDoesNotExistOrHasAlreadyBeenClaimed(bytes32 messageHash);
/**
* @dev Thrown when the message has already been received.
*/
error MessageAlreadyReceived(bytes32 messageHash);
/**
* @dev Thrown when the L1->L2 message has not been sent.
*/
error L1L2MessageNotSent(bytes32 messageHash);
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.22;
/**
* @title L1 Message Service interface for pre-existing functions, events and errors.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
interface IL1MessageService {
/**
* @dev Emitted when initializing Linea Rollup contract with a system migration block.
*/
event SystemMigrationBlockInitialized(uint256 systemMigrationBlock);
/**
* @dev Thrown when L2 merkle root does not exist.
*/
error L2MerkleRootDoesNotExist();
/**
* @dev Thrown when the merkle proof is invalid.
*/
error InvalidMerkleProof();
/**
* @dev Thrown when merkle depth doesn't match proof length.
*/
error ProofLengthDifferentThanMerkleDepth(uint256 actual, uint256 expected);
/**
* @dev Thrown when the system migration block is 0.
*/
error SystemMigrationBlockZero();
/**
* @param proof The proof array related to the claimed message.
* @param messageNumber The message number of the claimed message.
* @param leafIndex The leaf index related to the merkle proof of the message.
* @param from The address of the original sender.
* @param to The address the message is intended for.
* @param fee The fee being paid for the message delivery.
* @param value The value to be transferred to the destination address.
* @param feeRecipient The recipient for the fee.
* @param merkleRoot The merkle root of the claimed message.
* @param data The calldata to pass to the recipient.
*/
struct ClaimMessageWithProofParams {
bytes32[] proof;
uint256 messageNumber;
uint32 leafIndex;
address from;
address to;
uint256 fee;
uint256 value;
address payable feeRecipient;
bytes32 merkleRoot;
bytes data;
}
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.22;
/**
* @title LineaRollup interface for current functions, events and errors.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
interface ILineaRollup {
/**
* @dev parentStateRootHash is the starting root hash.
* @dev dataParentHash is used in order to link data.
* @dev finalStateRootHash is used to set next data.
* @dev firstBlockInData is the first block that is included in the data submitted.
* @dev finalBlockInData is the last block that is included in the data submitted.
* @dev snarkHash is the computed hash for compressed data (using a SNARK-friendly hash function) that aggregates per data submission to be used in public input.
* @dev compressedData is the compressed transaction data. It contains ordered data for each L2 block - l2Timestamps, the encoded txData.
*/
struct SubmissionData {
bytes32 parentStateRootHash;
bytes32 dataParentHash;
bytes32 finalStateRootHash;
uint256 firstBlockInData;
uint256 finalBlockInData;
bytes32 snarkHash;
bytes compressedData;
}
/**
* @dev parentStateRootHash is the expected last state root hash finalized.
* @dev dataHashes is the optional previously submitted compressed data item hashes.
* @dev dataParentHash is the last finalized compressed data item hash.
* @dev finalBlockNumber is the last block that is being finalized.
* @dev lastFinalizedTimestamp is the expected last finalized block's timestamp.
* @dev finalTimestamp is the timestamp of the last block being finalized.
* @dev l1RollingHash is the calculated rolling hash on L2 that is expected to match L1 at l1RollingHashMessageNumber.
* This value will be used along with the stored last finalized L2 calculated rolling hash in the public input.
* @dev l1RollingHashMessageNumber is the calculated message number on L2 that is expected to match the existing L1 rolling hash.
* This value will be used along with the stored last finalized L2 calculated message number in the public input.
* @dev l2MerkleRoots is an array of L2 message merkle roots of depth l2MerkleTreesDepth between last finalized block and finalBlockNumber.
* @dev l2MerkleTreesDepth is the depth of all l2MerkleRoots.
* @dev l2MessagingBlocksOffsets indicates by offset from currentL2BlockNumber which L2 blocks contain MessageSent events.
*/
struct FinalizationData {
bytes32 parentStateRootHash;
bytes32[] dataHashes;
bytes32 dataParentHash;
uint256 finalBlockNumber;
uint256 lastFinalizedTimestamp;
uint256 finalTimestamp;
bytes32 l1RollingHash;
uint256 l1RollingHashMessageNumber;
bytes32[] l2MerkleRoots;
uint256 l2MerkleTreesDepth;
bytes l2MessagingBlocksOffsets;
}
/**
* @dev Emitted when a verifier is set for a particular proof type.
*/
event VerifierAddressChanged(
address indexed verifierAddress,
uint256 indexed proofType,
address indexed verifierSetBy,
address oldVerifierAddress
);
/**
* @dev Emitted when compressed data is being submitted and verified succesfully on L1.
*/
event DataSubmitted(bytes32 indexed dataHash, uint256 indexed startBlock, uint256 indexed endBlock);
/**
* @dev Emitted when L2 blocks have been finalized on L1.
*/
event DataFinalized(
uint256 indexed lastBlockFinalized,
bytes32 indexed startingRootHash,
bytes32 indexed finalRootHash,
bool withProof
);
/**
* @dev Thrown when the starting block in the data item is out of sequence with the last block number.
*/
error DataStartingBlockDoesNotMatch(uint256 expected, uint256 actual);
/**
* @dev Thrown when the ending block in the data item is out of sequence with the finalization data.
*/
error DataEndingBlockDoesNotMatch(uint256 expected, uint256 actual);
/**
* @dev Thrown when the expected data item's shnarf is empty.
*/
error DataParentHasEmptyShnarf();
/**
* @dev Thrown when the current data was already submitted.
*/
error DataAlreadySubmitted(bytes32 currentDataHash);
/**
* @dev Thrown when parent stateRootHash does not match or is empty.
*/
error StateRootHashInvalid(bytes32 expected, bytes32 actual);
/**
* @dev Thrown when submissionData is empty.
*/
error EmptySubmissionData();
/**
* @dev Thrown when finalizationData.dataHashes is empty.
*/
error FinalizationDataMissing();
/**
* @dev Thrown when finalizationData.l1RollingHash does not exist on L1 (Feedback loop).
*/
error L1RollingHashDoesNotExistOnL1(uint256 messageNumber, bytes32 rollingHash);
/**
* @dev Thrown when finalizationData.lastFinalizedTimestamp does not match currentTimestamp.
*/
error TimestampsNotInSequence(uint256 expected, uint256 value);
/**
* @dev Thrown when the last submissionData finalBlockInData does not match finalizationData.finalBlockNumber.
*/
error FinalBlockNumberInvalid(uint256 expected, uint256 value);
/**
* @dev Thrown when finalizationData.dataParentHash does not match parent of _finalizationData.dataHashes[0].
*/
error ParentHashesDoesNotMatch(bytes32 firstHash, bytes32 secondHash);
/**
* @dev Thrown when parent finalStateRootHash does not match _finalizationData.parentStateRootHash.
*/
error FinalStateRootHashDoesNotMatch(bytes32 firstHash, bytes32 secondHash);
/**
* @dev Thrown when data hashes are not in sequence.
*/
error DataHashesNotInSequence(bytes32 expected, bytes32 value);
/**
* @dev Thrown when the first block is greater than final block in submission data.
*/
error FirstBlockGreaterThanFinalBlock(uint256 firstBlockNumber, uint256 finalBlockNumber);
/**
* @dev Thrown when the first block in data is less than or equal to the last finalized block during data submission.
*/
error FirstBlockLessThanOrEqualToLastFinalizedBlock(uint256 firstBlockNumber, uint256 lastFinalizedBlock);
/**
* @dev Thrown when the final block number in finalization data is less than or equal to the last finalized block during finalization.
*/
error FinalBlockNumberLessThanOrEqualToLastFinalizedBlock(uint256 finalBlockNumber, uint256 lastFinalizedBlock);
/**
* @dev Thrown when the final block state equals the zero hash during finalization.
*/
error FinalBlockStateEqualsZeroHash();
/**
* @dev Thrown when final l2 block timestamp higher than current block.timestamp during finalization.
*/
error FinalizationInTheFuture(uint256 l2BlockTimestamp, uint256 currentBlockTimestamp);
/**
* @dev Thrown when a rolling hash is provided without a corresponding message number.
*/
error MissingMessageNumberForRollingHash(bytes32 rollingHash);
/**
* @dev Thrown when a message number is provided without a corresponding rolling hash.
*/
error MissingRollingHashForMessageNumber(uint256 messageNumber);
/**
* @dev Thrown when the first byte is not zero.
* @dev This is used explicitly with the four bytes in assembly 0x729eebce.
*/
error FirstByteIsNotZero();
/**
* @dev Thrown when bytes length is not a multiple of 32.
*/
error BytesLengthNotMultipleOf32();
/**
* @notice Adds or updated the verifier contract address for a proof type.
* @dev VERIFIER_SETTER_ROLE is required to execute.
* @param _newVerifierAddress The address for the verifier contract.
* @param _proofType The proof type being set/updated.
*/
function setVerifierAddress(address _newVerifierAddress, uint256 _proofType) external;
/**
* @notice Submit compressed data.
* @dev OPERATOR_ROLE is required to execute.
* @param _submissionData The full compressed data collection - parentStateRootHash, dataParentHash,
* finalStateRootHash, firstBlockInData, finalBlockInData, snarkHash, compressedData.
*/
function submitData(SubmissionData calldata _submissionData) external;
/**
* @notice Finalize compressed blocks without proof.
* @dev DEFAULT_ADMIN_ROLE is required to execute.
* @param _finalizationData The full finalization data.
*/
function finalizeCompressedBlocksWithoutProof(FinalizationData calldata _finalizationData) external;
/**
* @notice Finalize compressed blocks with proof.
* @dev OPERATOR_ROLE is required to execute.
* @param _aggregatedProof The aggregated proof.
* @param _proofType The proof type.
* @param _finalizationData The full finalization data.
*/
function finalizeCompressedBlocksWithProof(
bytes calldata _aggregatedProof,
uint256 _proofType,
FinalizationData calldata _finalizationData
) external;
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.22;
/**
* @title Interface declaring verifier functions.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
interface IPlonkVerifier {
/**
* @notice Interface for verifier contracts.
* @param _proof The proof used to verify.
* @param _public_inputs The computed public inputs for the proof verification.
*/
function Verify(bytes calldata _proof, uint256[] calldata _public_inputs) external returns (bool);
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.22;
/**
* @title ZkEvm rollup interface for pre-existing functions, events and errors.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
interface IZkEvmV2 {
/**
* @dev blockRootHash is the calculated root hash of the block.
* @dev l2BlockTimestamp corresponds to the time the block was produced.
* @dev transactions is the transaction collection on the block RLP encoded.
* @dev l2ToL1MsgHashes collection contains all the hashes for L2 to L1 anchoring.
* @dev fromAddresses is a concatenation of all the from addresses for the transactions.
* @dev batchReceptionIndices defines which transactions in the collection are L2 to L1 messages.
*/
struct BlockData {
bytes32 blockRootHash;
uint32 l2BlockTimestamp;
bytes[] transactions;
bytes32[] l2ToL1MsgHashes;
bytes fromAddresses;
uint16[] batchReceptionIndices;
}
/**
* @dev Emitted when a L2 block has been finalized on L1
*/
event BlockFinalized(uint256 indexed blockNumber, bytes32 indexed stateRootHash, bool indexed finalizedWithProof);
/**
* @dev Emitted when a L2 blocks have been finalized on L1
*/
event BlocksVerificationDone(uint256 indexed lastBlockFinalized, bytes32 startingRootHash, bytes32 finalRootHash);
/**
* @dev Thrown when l2 block timestamp is not correct
*/
error BlockTimestampError(uint256 l2BlockTimestamp, uint256 currentBlockTimestamp);
/**
* @dev Thrown when the starting rootHash does not match the existing state
*/
error StartingRootHashDoesNotMatch();
/**
* @dev Thrown when blockData is empty
*/
error EmptyBlockDataArray();
/**
* @dev Thrown when block contains zero transactions
*/
error EmptyBlock();
/**
* @dev Thrown when zk proof is empty bytes
*/
error ProofIsEmpty();
/**
* @dev Thrown when zk proof type is invalid
*/
error InvalidProofType();
/**
* @dev Thrown when zk proof is invalid
*/
error InvalidProof();
/**
* @notice Finalizes blocks without using a proof
* @dev DEFAULT_ADMIN_ROLE is required to execute
* @param _calldata The full BlockData collection - block, transaction and log data
*/
function finalizeBlocksWithoutProof(BlockData[] calldata _calldata) external;
/**
* @notice Finalizes blocks using a proof.
* @dev OPERATOR_ROLE is required to execute.
* @dev If the verifier based on proof type is not found, it reverts.
* @param _blocksData The full BlockData collection - block, transaction and log data.
* @param _proof The proof to be verified with the proof type verifier contract.
* @param _proofType The proof type to determine which verifier contract to use.
* @param _parentStateRootHash The starting roothash for the last known block.
*/
function finalizeBlocks(
BlockData[] calldata _blocksData,
bytes calldata _proof,
uint256 _proofType,
bytes32 _parentStateRootHash
) external;
}
// SPDX-License-Identifier: AGPL-3.0
pragma solidity >=0.8.19 <=0.8.22;
library Utils {
/**
* @notice Performs a gas optimized keccak hash.
* @param _left Left value.
* @param _right Right value.
*/
function _efficientKeccak(bytes32 _left, bytes32 _right) internal pure returns (bytes32 value) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, _left)
mstore(0x20, _right)
value := keccak256(0x00, 0x40)
}
}
}
// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.22;
import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import { L1MessageService } from "./messageService/l1/L1MessageService.sol";
import { ZkEvmV2 } from "./ZkEvmV2.sol";
import { ILineaRollup } from "./interfaces/l1/ILineaRollup.sol";
/**
* @title Contract to manage cross-chain messaging on L1 and rollup proving.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
contract LineaRollup is AccessControlUpgradeable, ZkEvmV2, L1MessageService, ILineaRollup {
bytes32 public constant VERIFIER_SETTER_ROLE = keccak256("VERIFIER_SETTER_ROLE");
bytes32 internal constant EMPTY_HASH = 0x0;
uint256 internal constant Y_MODULUS = 52435875175126190479447740508185965837690552500527637822603658699938581184513;
mapping(bytes32 dataHash => bytes32 finalStateRootHash) public dataFinalStateRootHashes;
mapping(bytes32 dataHash => bytes32 parentHash) public dataParents;
mapping(bytes32 dataHash => bytes32 shnarfHash) public dataShnarfHashes;
mapping(bytes32 dataHash => uint256 startingBlock) public dataStartingBlock;
mapping(bytes32 dataHash => uint256 endingBlock) public dataEndingBlock;
uint256 public currentL2StoredL1MessageNumber;
bytes32 public currentL2StoredL1RollingHash;
uint256[50] private __gap_ZkEvm;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {
_disableInitializers();
}
/**
* @notice Initializes LineaRollup and underlying service dependencies.
* @dev DEFAULT_ADMIN_ROLE is set for the security council.
* @dev OPERATOR_ROLE is set for operators.
* @param _initialStateRootHash The initial hash at migration used for proof verification.
* @param _initialL2BlockNumber The initial block number at migration.
* @param _defaultVerifier The default verifier for rollup proofs.
* @param _securityCouncil The address for the security council performing admin operations.
* @param _operators The allowed rollup operators at initialization.
* @param _rateLimitPeriodInSeconds The period in which withdrawal amounts and fees will be accumulated.
* @param _rateLimitAmountInWei The limit allowed for withdrawing in the period.
* @param _systemMigrationBlock The service migration block.
*/
function initialize(
bytes32 _initialStateRootHash,
uint256 _initialL2BlockNumber,
address _defaultVerifier,
address _securityCouncil,
address[] calldata _operators,
uint256 _rateLimitPeriodInSeconds,
uint256 _rateLimitAmountInWei,
uint256 _systemMigrationBlock
) external initializer {
if (_defaultVerifier == address(0)) {
revert ZeroAddressNotAllowed();
}
for (uint256 i; i < _operators.length; ++i) {
if (_operators[i] == address(0)) {
revert ZeroAddressNotAllowed();
}
_grantRole(OPERATOR_ROLE, _operators[i]);
}
_grantRole(DEFAULT_ADMIN_ROLE, _securityCouncil);
_grantRole(VERIFIER_SETTER_ROLE, _securityCouncil);
__ReentrancyGuard_init();
__MessageService_init(
_securityCouncil,
_securityCouncil,
_rateLimitPeriodInSeconds,
_rateLimitAmountInWei,
_systemMigrationBlock
);
verifiers[0] = _defaultVerifier;
currentL2BlockNumber = _initialL2BlockNumber;
stateRootHashes[_initialL2BlockNumber] = _initialStateRootHash;
}
/**
* @notice Reinitializes the LineaRollup and sets the compressed data migration block.
* @param _systemMigrationBlock The block number we are synchronizing from.
* @dev This must be called in the same upgrade transaction to avoid issues.
* @dev __SystemMigrationBlock_init validates the block value.
*/
function initializeSystemMigrationBlock(uint256 _systemMigrationBlock) external reinitializer(2) {
__SystemMigrationBlock_init(_systemMigrationBlock);
}
/**
* @notice Adds or updates the verifier contract address for a proof type.
* @dev VERIFIER_SETTER_ROLE is required to execute.
* @param _newVerifierAddress The address for the verifier contract.
* @param _proofType The proof type being set/updated.
*/
function setVerifierAddress(address _newVerifierAddress, uint256 _proofType) external onlyRole(VERIFIER_SETTER_ROLE) {
if (_newVerifierAddress == address(0)) {
revert ZeroAddressNotAllowed();
}
emit VerifierAddressChanged(_newVerifierAddress, _proofType, msg.sender, verifiers[_proofType]);
verifiers[_proofType] = _newVerifierAddress;
}
/**
* @notice Submit compressed data.
* @dev OPERATOR_ROLE is required to execute.
* @param _submissionData The full compressed data collection - parentStateRootHash, dataParentHash,
* finalStateRootHash, firstBlockInData, finalBlockInData, snarkHash, compressedData.
*/
function submitData(
SubmissionData calldata _submissionData
) external whenTypeAndGeneralNotPaused(PROVING_SYSTEM_PAUSE_TYPE) onlyRole(OPERATOR_ROLE) {
_submitData(_submissionData);
}
/**
* @notice Internal function to submit compressed data.
* @param _submissionData The full compressed data collection - parentStateRootHash, dataParentHash,
* finalStateRootHash, firstBlockInData, finalBlockInData, snarkHash, compressedData.
*/
function _submitData(SubmissionData calldata _submissionData) internal returns (bytes32 shnarf) {
if (_submissionData.compressedData.length == 0) {
revert EmptySubmissionData();
}
if (_submissionData.finalStateRootHash == EMPTY_HASH) {
revert FinalBlockStateEqualsZeroHash();
}
shnarf = dataShnarfHashes[_submissionData.dataParentHash];
bytes32 parentFinalStateRootHash = dataFinalStateRootHashes[_submissionData.dataParentHash];
uint256 lastFinalizedBlock = currentL2BlockNumber;
uint256 parentEndingBlock = dataEndingBlock[_submissionData.dataParentHash];
// once upgraded, this initial condition will be removed - the internals remain
if (_submissionData.dataParentHash != EMPTY_HASH) {
if (parentFinalStateRootHash == EMPTY_HASH) {
revert StateRootHashInvalid(parentFinalStateRootHash, _submissionData.parentStateRootHash);
}
uint256 expectedStartingBlock = parentEndingBlock + 1;
if (expectedStartingBlock != _submissionData.firstBlockInData) {
revert DataStartingBlockDoesNotMatch(expectedStartingBlock, _submissionData.firstBlockInData);
}
if (shnarf == EMPTY_HASH) {
revert DataParentHasEmptyShnarf();
}
}
if (_submissionData.firstBlockInData <= lastFinalizedBlock) {
revert FirstBlockLessThanOrEqualToLastFinalizedBlock(_submissionData.firstBlockInData, lastFinalizedBlock);
}
if (_submissionData.firstBlockInData > _submissionData.finalBlockInData) {
revert FirstBlockGreaterThanFinalBlock(_submissionData.firstBlockInData, _submissionData.finalBlockInData);
}
if (_submissionData.parentStateRootHash != parentFinalStateRootHash) {
revert StateRootHashInvalid(parentFinalStateRootHash, _submissionData.parentStateRootHash);
}
bytes32 currentDataHash = keccak256(_submissionData.compressedData);
if (dataFinalStateRootHashes[currentDataHash] != EMPTY_HASH) {
revert DataAlreadySubmitted(currentDataHash);
}
dataParents[currentDataHash] = _submissionData.dataParentHash;
dataFinalStateRootHashes[currentDataHash] = _submissionData.finalStateRootHash;
dataStartingBlock[currentDataHash] = _submissionData.firstBlockInData;
dataEndingBlock[currentDataHash] = _submissionData.finalBlockInData;
bytes32 compressedDataComputedX = keccak256(abi.encode(_submissionData.snarkHash, currentDataHash));
shnarf = keccak256(
abi.encode(
shnarf,
_submissionData.snarkHash,
_submissionData.finalStateRootHash,
compressedDataComputedX,
_calculateY(_submissionData.compressedData, compressedDataComputedX)
)
);
dataShnarfHashes[currentDataHash] = shnarf;
emit DataSubmitted(currentDataHash, _submissionData.firstBlockInData, _submissionData.finalBlockInData);
}
/**
* @notice Finalize compressed blocks with proof.
* @dev OPERATOR_ROLE is required to execute.
* @param _aggregatedProof The aggregated proof.
* @param _proofType The proof type.
* @param _finalizationData The full finalization data.
*/
function finalizeCompressedBlocksWithProof(
bytes calldata _aggregatedProof,
uint256 _proofType,
FinalizationData calldata _finalizationData
) external whenTypeAndGeneralNotPaused(PROVING_SYSTEM_PAUSE_TYPE) onlyRole(OPERATOR_ROLE) {
if (_aggregatedProof.length == 0) {
revert ProofIsEmpty();
}
uint256 lastFinalizedBlockNumber = currentL2BlockNumber;
if (stateRootHashes[lastFinalizedBlockNumber] != _finalizationData.parentStateRootHash) {
revert StartingRootHashDoesNotMatch();
}
uint256 lastFinalizedL2StoredL1MessageNumber = currentL2StoredL1MessageNumber;
bytes32 lastFinalizedL2StoredL1RollingHash = currentL2StoredL1RollingHash;
_finalizeCompressedBlocks(_finalizationData, lastFinalizedBlockNumber, true);
bytes32 shnarf;
unchecked {
shnarf = dataShnarfHashes[_finalizationData.dataHashes[_finalizationData.dataHashes.length - 1]];
if (shnarf == EMPTY_HASH) {
revert DataParentHasEmptyShnarf();
}
}
uint256 publicInput = uint256(
keccak256(
bytes.concat(
abi.encode(
shnarf,
_finalizationData.parentStateRootHash,
_finalizationData.lastFinalizedTimestamp,
_finalizationData.finalTimestamp,
lastFinalizedBlockNumber,
_finalizationData.finalBlockNumber
),
abi.encode(
lastFinalizedL2StoredL1RollingHash,
_finalizationData.l1RollingHash,
lastFinalizedL2StoredL1MessageNumber,
_finalizationData.l1RollingHashMessageNumber,
_finalizationData.l2MerkleTreesDepth,
keccak256(abi.encodePacked(_finalizationData.l2MerkleRoots))
)
)
)
);
assembly {
publicInput := mod(publicInput, MODULO_R)
}
_verifyProof(publicInput, _proofType, _aggregatedProof, _finalizationData.parentStateRootHash);
}
/**
* @notice Finalize compressed blocks without proof.
* @dev DEFAULT_ADMIN_ROLE is required to execute.
* @param _finalizationData The simplified finalization data without proof.
*/
function finalizeCompressedBlocksWithoutProof(
FinalizationData calldata _finalizationData
) external whenTypeNotPaused(GENERAL_PAUSE_TYPE) onlyRole(DEFAULT_ADMIN_ROLE) {
uint256 lastFinalizedBlock = currentL2BlockNumber;
_finalizeCompressedBlocks(_finalizationData, lastFinalizedBlock, false);
}
/**
* @notice Internal function to finalize compressed blocks.
* @param _finalizationData The full finalization data.
* @param _lastFinalizedBlock The last finalized block.
* @param _withProof If we are finalizing with a proof.
*/
function _finalizeCompressedBlocks(
FinalizationData calldata _finalizationData,
uint256 _lastFinalizedBlock,
bool _withProof
) internal {
uint256 finalizationDataDataHashesLength = _finalizationData.dataHashes.length;
if (finalizationDataDataHashesLength == 0) {
revert FinalizationDataMissing();
}
if (_finalizationData.finalBlockNumber <= _lastFinalizedBlock) {
revert FinalBlockNumberLessThanOrEqualToLastFinalizedBlock(
_finalizationData.finalBlockNumber,
_lastFinalizedBlock
);
}
_validateL2ComputedRollingHash(_finalizationData.l1RollingHashMessageNumber, _finalizationData.l1RollingHash);
if (currentTimestamp != _finalizationData.lastFinalizedTimestamp) {
revert TimestampsNotInSequence(currentTimestamp, _finalizationData.lastFinalizedTimestamp);
}
if (_finalizationData.finalTimestamp >= block.timestamp) {
revert FinalizationInTheFuture(_finalizationData.finalTimestamp, block.timestamp);
}
bytes32 startingDataParentHash = dataParents[_finalizationData.dataHashes[0]];
if (startingDataParentHash != _finalizationData.dataParentHash) {
revert ParentHashesDoesNotMatch(startingDataParentHash, _finalizationData.dataParentHash);
}
bytes32 startingParentFinalStateRootHash = dataFinalStateRootHashes[startingDataParentHash];
// once upgraded, this initial condition will be removed - the internals remain
if (startingDataParentHash != EMPTY_HASH) {
if (startingParentFinalStateRootHash != _finalizationData.parentStateRootHash) {
revert FinalStateRootHashDoesNotMatch(startingParentFinalStateRootHash, _finalizationData.parentStateRootHash);
}
}
bytes32 finalBlockState = dataFinalStateRootHashes[
_finalizationData.dataHashes[finalizationDataDataHashesLength - 1]
];
if (finalBlockState == EMPTY_HASH) {
revert FinalBlockStateEqualsZeroHash();
}
_addL2MerkleRoots(_finalizationData.l2MerkleRoots, _finalizationData.l2MerkleTreesDepth);
_anchorL2MessagingBlocks(_finalizationData.l2MessagingBlocksOffsets, _lastFinalizedBlock);
for (uint256 i = 1; i < finalizationDataDataHashesLength; ++i) {
unchecked {
if (dataParents[_finalizationData.dataHashes[i]] != _finalizationData.dataHashes[i - 1]) {
revert DataHashesNotInSequence(
_finalizationData.dataHashes[i - 1],
dataParents[_finalizationData.dataHashes[i]]
);
}
}
}
uint256 suppliedStartingBlock = dataStartingBlock[_finalizationData.dataHashes[0]];
uint256 suppliedFinalBlock = dataEndingBlock[_finalizationData.dataHashes[finalizationDataDataHashesLength - 1]];
// check final item supplied matches
if (suppliedFinalBlock != _finalizationData.finalBlockNumber) {
revert DataEndingBlockDoesNotMatch(suppliedFinalBlock, _finalizationData.finalBlockNumber);
}
// check suppliedStartingBlock is 1 more than the last finalized block
if (suppliedStartingBlock != _lastFinalizedBlock + 1) {
revert DataStartingBlockDoesNotMatch(_lastFinalizedBlock + 1, suppliedStartingBlock);
}
stateRootHashes[_finalizationData.finalBlockNumber] = finalBlockState;
currentTimestamp = _finalizationData.finalTimestamp;
currentL2BlockNumber = _finalizationData.finalBlockNumber;
currentL2StoredL1MessageNumber = _finalizationData.l1RollingHashMessageNumber;
currentL2StoredL1RollingHash = _finalizationData.l1RollingHash;
emit DataFinalized(
_finalizationData.finalBlockNumber,
_finalizationData.parentStateRootHash,
finalBlockState,
_withProof
);
}
/**
* @notice Private function to validate l1 rolling hash.
* @param _rollingHashMessageNumber Message number associated with the rolling hash as computed on L2.
* @param _rollingHash L1 rolling hash as computed on L2.
*/
function _validateL2ComputedRollingHash(uint256 _rollingHashMessageNumber, bytes32 _rollingHash) internal view {
if (_rollingHashMessageNumber == 0) {
if (_rollingHash != EMPTY_HASH) {
revert MissingMessageNumberForRollingHash(_rollingHash);
}
} else {
if (_rollingHash == EMPTY_HASH) {
revert MissingRollingHashForMessageNumber(_rollingHashMessageNumber);
}
if (rollingHashes[_rollingHashMessageNumber] != _rollingHash) {
revert L1RollingHashDoesNotExistOnL1(_rollingHashMessageNumber, _rollingHash);
}
}
}
/**
* @notice Internal function to calculate Y for public input generation.
* @param _data Compressed data from submission data.
* @param _compressedDataComputedX Computed X for public input generation.
* @dev Each chunk of 32 bytes must start with a 0 byte.
* @dev The compressedDataComputedX value is modulo-ed down during the computation and scalar field checking is not needed.
* @dev There is a hard constraint in the circuit to enforce the polynomial degree limit (4096), which will also be enforced with EIP-4844.
* @return compressedDataComputedY The Y calculated value using the Horner method.
*/
function _calculateY(
bytes calldata _data,
bytes32 _compressedDataComputedX
) internal pure returns (bytes32 compressedDataComputedY) {
if (_data.length % 0x20 != 0) {
revert BytesLengthNotMultipleOf32();
}
bytes4 errorSelector = ILineaRollup.FirstByteIsNotZero.selector;
assembly {
for {
let i := _data.length
} gt(i, 0) {
} {
i := sub(i, 0x20)
let chunk := calldataload(add(_data.offset, i))
if iszero(iszero(and(chunk, 0xFF00000000000000000000000000000000000000000000000000000000000000))) {
let ptr := mload(0x40)
mstore(ptr, errorSelector)
revert(ptr, 0x4)
}
compressedDataComputedY := addmod(
mulmod(compressedDataComputedY, _compressedDataComputedX, Y_MODULUS),
chunk,
Y_MODULUS
)
}
}
}
}
// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.22;
import { BitMaps } from "@openzeppelin/contracts/utils/structs/BitMaps.sol";
import { L1MessageManagerV1 } from "./v1/L1MessageManagerV1.sol";
import { IL1MessageManager } from "../../interfaces/l1/IL1MessageManager.sol";
import { Utils } from "../../lib/Utils.sol";
/**
* @title Contract to manage cross-chain message rolling hash computation and storage on L1.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
abstract contract L1MessageManager is L1MessageManagerV1, IL1MessageManager {
using BitMaps for BitMaps.BitMap;
using Utils for *;
mapping(uint256 messageNumber => bytes32 rollingHash) public rollingHashes;
BitMaps.BitMap internal _messageClaimedBitMap;
mapping(bytes32 merkleRoot => uint256 treeDepth) public l2MerkleRootsDepths;
/// @dev Keep free storage slots for future implementation updates to avoid storage collision.
uint256[50] private __gap_L1MessageManager;
/**
* @notice Take an existing message hash, calculates the rolling hash and stores at the message number.
* @param _messageNumber The current message number being sent.
* @param _messageHash The hash of the message being sent.
*/
function _addRollingHash(uint256 _messageNumber, bytes32 _messageHash) internal {
unchecked {
bytes32 newRollingHash = Utils._efficientKeccak(rollingHashes[_messageNumber - 1], _messageHash);
rollingHashes[_messageNumber] = newRollingHash;
emit RollingHashUpdated(_messageNumber, newRollingHash, _messageHash);
}
}
/**
* @notice Set the L2->L1 message as claimed when a user claims a message on L1.
* @param _messageNumber The message number on L2.
*/
function _setL2L1MessageToClaimed(uint256 _messageNumber) internal {
if (_messageClaimedBitMap.get(_messageNumber)) {
revert MessageAlreadyClaimed(_messageNumber);
}
_messageClaimedBitMap.set(_messageNumber);
}
/**
* @notice Add the L2 merkle roots to the storage.
* @dev This function is called during block finalization.
* @param _newRoots New L2 merkle roots.
*/
function _addL2MerkleRoots(bytes32[] calldata _newRoots, uint256 _treeDepth) internal {
for (uint256 i; i < _newRoots.length; ++i) {
if (l2MerkleRootsDepths[_newRoots[i]] != 0) {
revert L2MerkleRootAlreadyAnchored(_newRoots[i]);
}
l2MerkleRootsDepths[_newRoots[i]] = _treeDepth;
emit L2MerkleRootAdded(_newRoots[i], _treeDepth);
}
}
/**
* @notice Emit an event for each L2 block containing L2->L1 messages.
* @dev This function is called during block finalization.
* @param _l2MessagingBlocksOffsets Is a sequence of uint16 values, where each value plus the last finalized L2 block number.
* indicates which L2 blocks have L2->L1 messages.
* @param _currentL2BlockNumber Last L2 block number finalized on L1.
*/
function _anchorL2MessagingBlocks(bytes calldata _l2MessagingBlocksOffsets, uint256 _currentL2BlockNumber) internal {
if (_l2MessagingBlocksOffsets.length % 2 != 0) {
revert BytesLengthNotMultipleOfTwo(_l2MessagingBlocksOffsets.length);
}
uint256 l2BlockOffset;
unchecked {
for (uint256 i; i < _l2MessagingBlocksOffsets.length; ) {
assembly {
l2BlockOffset := shr(240, calldataload(add(_l2MessagingBlocksOffsets.offset, i)))
}
emit L2MessagingBlockAnchored(_currentL2BlockNumber + l2BlockOffset);
i += 2;
}
}
}
/**
* @notice Check if the L2->L1 message is claimed or not.
* @param _messageNumber The message number on L2.
*/
function isMessageClaimed(uint256 _messageNumber) external view returns (bool) {
return _messageClaimedBitMap.get(_messageNumber);
}
}
// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.22;
import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import { L1MessageServiceV1 } from "./v1/L1MessageServiceV1.sol";
import { L1MessageManager } from "./L1MessageManager.sol";
import { IL1MessageService } from "../../interfaces/l1/IL1MessageService.sol";
import { IGenericErrors } from "../../interfaces/IGenericErrors.sol";
import { SparseMerkleTreeVerifier } from "../lib/SparseMerkleTreeVerifier.sol";
/**
* @title Contract to manage cross-chain messaging on L1.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
abstract contract L1MessageService is
AccessControlUpgradeable,
L1MessageServiceV1,
L1MessageManager,
IL1MessageService,
IGenericErrors
{
using SparseMerkleTreeVerifier for *;
uint256 public systemMigrationBlock;
// Keep free storage slots for future implementation updates to avoid storage collision.
uint256[50] private __gap_L1MessageService;
/**
* @notice Initialises underlying message service dependencies.
* @dev _messageSender is initialised to a non-zero value for gas efficiency on claiming.
* @param _limitManagerAddress The address owning the rate limiting management role.
* @param _pauseManagerAddress The address owning the pause management role.
* @param _rateLimitPeriod The period to rate limit against.
* @param _rateLimitAmount The limit allowed for withdrawing the period.
* @param _systemMigrationBlock The service migration block.
*/
function __MessageService_init(
address _limitManagerAddress,
address _pauseManagerAddress,
uint256 _rateLimitPeriod,
uint256 _rateLimitAmount,
uint256 _systemMigrationBlock
) internal onlyInitializing {
if (_limitManagerAddress == address(0)) {
revert ZeroAddressNotAllowed();
}
if (_pauseManagerAddress == address(0)) {
revert ZeroAddressNotAllowed();
}
__ERC165_init();
__Context_init();
__AccessControl_init();
__RateLimiter_init(_rateLimitPeriod, _rateLimitAmount);
_grantRole(RATE_LIMIT_SETTER_ROLE, _limitManagerAddress);
_grantRole(PAUSE_MANAGER_ROLE, _pauseManagerAddress);
__SystemMigrationBlock_init(_systemMigrationBlock);
nextMessageNumber = 1;
_messageSender = DEFAULT_SENDER_ADDRESS;
}
/**
* @notice Initializer function when upgrading.
* @dev Sets the systemMigrationBlock when the migration will occur.
* @param _systemMigrationBlock The future migration block.
*/
function __SystemMigrationBlock_init(uint256 _systemMigrationBlock) internal onlyInitializing {
if (_systemMigrationBlock == 0) {
revert SystemMigrationBlockZero();
}
systemMigrationBlock = _systemMigrationBlock;
emit SystemMigrationBlockInitialized(systemMigrationBlock);
}
/**
* @notice Adds a message for sending cross-chain and emits MessageSent.
* @dev The message number is preset (nextMessageNumber) and only incremented at the end if successful for the next caller.
* @dev This function should be called with a msg.value = _value + _fee. The fee will be paid on the destination chain.
* @param _to The address the message is intended for.
* @param _fee The fee being paid for the message delivery.
* @param _calldata The calldata to pass to the recipient.
*/
function sendMessage(
address _to,
uint256 _fee,
bytes calldata _calldata
) external payable whenTypeAndGeneralNotPaused(L1_L2_PAUSE_TYPE) {
if (_to == address(0)) {
revert ZeroAddressNotAllowed();
}
if (_fee > msg.value) {
revert ValueSentTooLow();
}
uint256 messageNumber = nextMessageNumber++;
uint256 valueSent = msg.value - _fee;
bytes32 messageHash = keccak256(abi.encode(msg.sender, _to, _fee, valueSent, messageNumber, _calldata));
if (systemMigrationBlock > block.number) {
_addL1L2MessageHash(messageHash);
} else {
_addRollingHash(messageNumber, messageHash);
}
emit MessageSent(msg.sender, _to, _fee, valueSent, messageNumber, _calldata, messageHash);
}
/**
* @notice Claims and delivers a cross-chain message using merkle proof.
* @dev if merkle depth is empty, it will revert with L2MerkleRootDoesNotExist.
* @dev if merkle depth is different than proof size, it will revert with ProofLengthDifferentThanMerkleDepth.
* @param _params Collection of claim data with proof and supporting data.
*/
function claimMessageWithProof(
ClaimMessageWithProofParams calldata _params
) external nonReentrant distributeFees(_params.fee, _params.to, _params.data, _params.feeRecipient) {
_requireTypeAndGeneralNotPaused(L2_L1_PAUSE_TYPE);
uint256 merkleDepth = l2MerkleRootsDepths[_params.merkleRoot];
if (merkleDepth == 0) {
revert L2MerkleRootDoesNotExist();
}
if (merkleDepth != _params.proof.length) {
revert ProofLengthDifferentThanMerkleDepth(merkleDepth, _params.proof.length);
}
_setL2L1MessageToClaimed(_params.messageNumber);
_addUsedAmount(_params.fee + _params.value);
bytes32 messageLeafHash = keccak256(
abi.encode(_params.from, _params.to, _params.fee, _params.value, _params.messageNumber, _params.data)
);
if (
!SparseMerkleTreeVerifier._verifyMerkleProof(
messageLeafHash,
_params.proof,
_params.leafIndex,
_params.merkleRoot
)
) {
revert InvalidMerkleProof();
}
_messageSender = _params.from;
(bool callSuccess, bytes memory returnData) = _params.to.call{ value: _params.value }(_params.data);
if (!callSuccess) {
if (returnData.length > 0) {
assembly {
let data_size := mload(returnData)
revert(add(32, returnData), data_size)
}
} else {
revert MessageSendingFailed(_params.to);
}
}
_messageSender = DEFAULT_SENDER_ADDRESS;
emit MessageClaimed(messageLeafHash);
}
/**
* @notice Claims and delivers a cross-chain message.
* @dev _messageSender is set temporarily when claiming.
*/
function sender() external view returns (address) {
return _messageSender;
}
}
// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.22;
import { IL1MessageManagerV1 } from "../../../interfaces/l1/IL1MessageManagerV1.sol";
/**
* @title Contract to manage cross-chain message hashes storage and status on L1.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
abstract contract L1MessageManagerV1 is IL1MessageManagerV1 {
uint8 public constant INBOX_STATUS_UNKNOWN = 0;
uint8 public constant INBOX_STATUS_RECEIVED = 1;
uint8 public constant OUTBOX_STATUS_UNKNOWN = 0;
uint8 public constant OUTBOX_STATUS_SENT = 1;
uint8 public constant OUTBOX_STATUS_RECEIVED = 2;
/// @dev Mapping to store L1->L2 message hashes status.
/// @dev messageHash => messageStatus (0: unknown, 1: sent, 2: received).
mapping(bytes32 messageHash => uint256 messageStatus) public outboxL1L2MessageStatus;
/// @dev Mapping to store L2->L1 message hashes status.
/// @dev messageHash => messageStatus (0: unknown, 1: received).
mapping(bytes32 messageHash => uint256 messageStatus) public inboxL2L1MessageStatus;
/// @dev Keep free storage slots for future implementation updates to avoid storage collision.
// *******************************************************************************************
// NB: THIS GAP HAS BEEN PUSHED OUT IN FAVOUR OF THE GAP INSIDE THE REENTRANCY CODE
//uint256[50] private __gap;
// NB: DO NOT USE THIS GAP
// *******************************************************************************************
/**
* @notice Add cross-chain L2->L1 message hash in storage.
* @dev Once the event is emitted, it should be ready for claiming (post block finalization).
* @param _messageHash Hash of the message.
*/
function _addL2L1MessageHash(bytes32 _messageHash) internal {
if (inboxL2L1MessageStatus[_messageHash] != INBOX_STATUS_UNKNOWN) {
revert MessageAlreadyReceived(_messageHash);
}
inboxL2L1MessageStatus[_messageHash] = INBOX_STATUS_RECEIVED;
emit L2L1MessageHashAddedToInbox(_messageHash);
}
/**
* @notice Update the status of L2->L1 message when a user claims a message on L1.
* @dev The L2->L1 message is removed from storage.
* @dev Due to the nature of the rollup, we should not get a second entry of this.
* @param _messageHash Hash of the message.
*/
function _updateL2L1MessageStatusToClaimed(bytes32 _messageHash) internal {
if (inboxL2L1MessageStatus[_messageHash] != INBOX_STATUS_RECEIVED) {
revert MessageDoesNotExistOrHasAlreadyBeenClaimed(_messageHash);
}
delete inboxL2L1MessageStatus[_messageHash];
}
/**
* @notice Add L1->L2 message hash in storage when a message is sent on L1.
* @param _messageHash Hash of the message.
*/
function _addL1L2MessageHash(bytes32 _messageHash) internal {
outboxL1L2MessageStatus[_messageHash] = OUTBOX_STATUS_SENT;
}
/**
* @notice Update the status of L1->L2 messages as received when messages have been stored on L2.
* @dev The expectation here is that the rollup is limited to 100 hashes being added here - array is not open ended.
* @param _messageHashes List of message hashes.
*/
function _updateL1L2MessageStatusToReceived(bytes32[] memory _messageHashes) internal {
uint256 messageHashArrayLength = _messageHashes.length;
for (uint256 i; i < messageHashArrayLength; ++i) {
bytes32 messageHash = _messageHashes[i];
uint256 existingStatus = outboxL1L2MessageStatus[messageHash];
if (existingStatus == OUTBOX_STATUS_UNKNOWN) {
revert L1L2MessageNotSent(messageHash);
}
if (existingStatus != OUTBOX_STATUS_RECEIVED) {
outboxL1L2MessageStatus[messageHash] = OUTBOX_STATUS_RECEIVED;
}
}
emit L1L2MessagesReceivedOnL2(_messageHashes);
}
}
// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.22;
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import { PauseManager } from "../../lib/PauseManager.sol";
import { RateLimiter } from "../../lib/RateLimiter.sol";
import { L1MessageManagerV1 } from "./L1MessageManagerV1.sol";
import { IMessageService } from "../../../interfaces/IMessageService.sol";
/**
* @title Contract to manage cross-chain messaging on L1.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
abstract contract L1MessageServiceV1 is
Initializable,
RateLimiter,
L1MessageManagerV1,
ReentrancyGuardUpgradeable,
PauseManager,
IMessageService
{
// @dev This is initialised to save user cost with existing slot.
uint256 public nextMessageNumber;
address internal _messageSender;
// Keep free storage slots for future implementation updates to avoid storage collision.
uint256[50] private __gap;
// @dev adding these should not affect storage as they are constants and are stored in bytecode.
uint256 internal constant REFUND_OVERHEAD_IN_GAS = 48252;
address internal constant DEFAULT_SENDER_ADDRESS = address(123456789);
/**
* @notice The unspent fee is refunded if applicable.
* @param _feeInWei The fee paid for delivery in Wei.
* @param _to The recipient of the message and gas refund.
* @param _calldata The calldata of the message.
*/
modifier distributeFees(
uint256 _feeInWei,
address _to,
bytes calldata _calldata,
address _feeRecipient
) {
//pre-execution
uint256 startingGas = gasleft();
_;
//post-execution
// we have a fee
if (_feeInWei > 0) {
// default postman fee
uint256 deliveryFee = _feeInWei;
// do we have empty calldata?
if (_calldata.length == 0) {
bool isDestinationEOA;
assembly {
isDestinationEOA := iszero(extcodesize(_to))
}
// are we calling an EOA
if (isDestinationEOA) {
// initial + cost to call and refund minus gasleft
deliveryFee = (startingGas + REFUND_OVERHEAD_IN_GAS - gasleft()) * tx.gasprice;
if (_feeInWei > deliveryFee) {
payable(_to).send(_feeInWei - deliveryFee);
} else {
deliveryFee = _feeInWei;
}
}
}
address feeReceiver = _feeRecipient == address(0) ? msg.sender : _feeRecipient;
bool callSuccess = payable(feeReceiver).send(deliveryFee);
if (!callSuccess) {
revert FeePaymentFailed(feeReceiver);
}
}
}
/**
* @notice Claims and delivers a cross-chain message.
* @dev _feeRecipient can be set to address(0) to receive as msg.sender.
* @dev _messageSender is set temporarily when claiming and reset post. Used in sender().
* @dev _messageSender is reset to DEFAULT_SENDER_ADDRESS to be more gas efficient.
* @param _from The address of the original sender.
* @param _to The address the message is intended for.
* @param _fee The fee being paid for the message delivery.
* @param _value The value to be transferred to the destination address.
* @param _feeRecipient The recipient for the fee.
* @param _calldata The calldata to pass to the recipient.
* @param _nonce The unique auto generated nonce used when sending the message.
*/
function claimMessage(
address _from,
address _to,
uint256 _fee,
uint256 _value,
address payable _feeRecipient,
bytes calldata _calldata,
uint256 _nonce
) external nonReentrant distributeFees(_fee, _to, _calldata, _feeRecipient) {
_requireTypeAndGeneralNotPaused(L2_L1_PAUSE_TYPE);
bytes32 messageHash = keccak256(abi.encode(_from, _to, _fee, _value, _nonce, _calldata));
// @dev Status check and revert is in the message manager.
_updateL2L1MessageStatusToClaimed(messageHash);
_addUsedAmount(_fee + _value);
_messageSender = _from;
(bool callSuccess, bytes memory returnData) = _to.call{ value: _value }(_calldata);
if (!callSuccess) {
if (returnData.length > 0) {
assembly {
let data_size := mload(returnData)
revert(add(32, returnData), data_size)
}
} else {
revert MessageSendingFailed(_to);
}
}
_messageSender = DEFAULT_SENDER_ADDRESS;
emit MessageClaimed(messageHash);
}
}
// SPDX-License-Identifier: AGPL-3.0
pragma solidity >=0.8.19 <=0.8.22;
/**
* @title Decoding functions for message service anchoring and bytes slicing.
* @author ConsenSys Software Inc.
* @notice You can use this to slice bytes and extract anchoring hashes from calldata.
* @custom:security-contact [email protected]
*/
library CodecV2 {
/**
* @notice Decodes a collection of bytes32 (hashes) from the calldata of a transaction.
* @dev Extracts and decodes skipping the function selector (selector is expected in the input).
* @dev A check beforehand must be performed to confirm this is the correct type of transaction.
* @dev NB: A memory manipulation strips out the function signature, do not reuse.
* @param _calldataWithSelector The calldata for the transaction.
* @return bytes32[] - array of message hashes.
*/
function _extractXDomainAddHashes(bytes memory _calldataWithSelector) internal pure returns (bytes32[] memory) {
assembly {
let len := sub(mload(_calldataWithSelector), 4)
_calldataWithSelector := add(_calldataWithSelector, 0x4)
mstore(_calldataWithSelector, len)
}
return abi.decode(_calldataWithSelector, (bytes32[]));
}
}
// SPDX-License-Identifier: AGPL-3.0
pragma solidity >=0.8.19 <=0.8.22;
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import { IPauseManager } from "../../interfaces/IPauseManager.sol";
/**
* @title Contract to manage cross-chain function pausing.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
abstract contract PauseManager is Initializable, IPauseManager, AccessControlUpgradeable {
bytes32 public constant PAUSE_MANAGER_ROLE = keccak256("PAUSE_MANAGER_ROLE");
uint8 public constant GENERAL_PAUSE_TYPE = 1;
uint8 public constant L1_L2_PAUSE_TYPE = 2;
uint8 public constant L2_L1_PAUSE_TYPE = 3;
uint8 public constant PROVING_SYSTEM_PAUSE_TYPE = 4;
// @dev DEPRECATED. USE _pauseTypeStatusesBitMap INSTEAD
mapping(bytes32 pauseType => bool pauseStatus) public pauseTypeStatuses;
uint256 private _pauseTypeStatusesBitMap;
uint256[9] private __gap;
/**
* @dev Modifier to make a function callable only when the specific and general types are not paused.
* @param _pauseType The pause type value being checked.
* Requirements:
*
* - The type must not be paused.
*/
modifier whenTypeAndGeneralNotPaused(uint8 _pauseType) {
_requireTypeAndGeneralNotPaused(_pauseType);
_;
}
/**
* @dev Modifier to make a function callable only when the type is not paused.
* @param _pauseType The pause type value being checked.
* Requirements:
*
* - The type must not be paused.
*/
modifier whenTypeNotPaused(uint8 _pauseType) {
_requireTypeNotPaused(_pauseType);
_;
}
/**
* @dev Throws if the specific or general types are paused.
* @dev Checks the specific and general pause types.
* @param _pauseType The pause type value being checked.
*/
function _requireTypeAndGeneralNotPaused(uint8 _pauseType) internal view virtual {
uint256 pauseBitMap = _pauseTypeStatusesBitMap;
if (pauseBitMap & (1 << uint256(_pauseType)) != 0) {
revert IsPaused(_pauseType);
}
if (pauseBitMap & (1 << uint256(GENERAL_PAUSE_TYPE)) != 0) {
revert IsPaused(GENERAL_PAUSE_TYPE);
}
}
/**
* @dev Throws if the type is paused.
* @dev Checks the specific pause type.
* @param _pauseType The pause type value being checked.
*/
function _requireTypeNotPaused(uint8 _pauseType) internal view virtual {
if (isPaused(_pauseType)) {
revert IsPaused(_pauseType);
}
}
/**
* @notice Pauses functionality by specific type.
* @dev Requires PAUSE_MANAGER_ROLE.
* @param _pauseType The pause type value.
*/
function pauseByType(uint8 _pauseType) external onlyRole(PAUSE_MANAGER_ROLE) {
if (isPaused(_pauseType)) {
revert IsPaused(_pauseType);
}
_pauseTypeStatusesBitMap |= 1 << uint256(_pauseType);
emit Paused(_msgSender(), _pauseType);
}
/**
* @notice Unpauses functionality by specific type.
* @dev Requires PAUSE_MANAGER_ROLE.
* @param _pauseType The pause type value.
*/
function unPauseByType(uint8 _pauseType) external onlyRole(PAUSE_MANAGER_ROLE) {
if (!isPaused(_pauseType)) {
revert IsNotPaused(_pauseType);
}
_pauseTypeStatusesBitMap &= ~(1 << uint256(_pauseType));
emit UnPaused(_msgSender(), _pauseType);
}
/**
* @notice Check if a pause type is enabled.
* @param _pauseType The pause type value.
* @return boolean True if the pause type if enabled, false otherwise.
*/
function isPaused(uint8 _pauseType) public view returns (bool) {
return (_pauseTypeStatusesBitMap & (1 << uint256(_pauseType))) != 0;
}
}
// SPDX-License-Identifier: AGPL-3.0
pragma solidity >=0.8.19 <=0.8.22;
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import { IRateLimiter } from "../../interfaces/IRateLimiter.sol";
/**
* @title Rate Limiter by period and amount using the block timestamp.
* @author ConsenSys Software Inc.
* @notice You can use this control numeric limits over a period using timestamp.
* @custom:security-contact [email protected]
*/
contract RateLimiter is Initializable, IRateLimiter, AccessControlUpgradeable {
bytes32 public constant RATE_LIMIT_SETTER_ROLE = keccak256("RATE_LIMIT_SETTER_ROLE");
uint256 public periodInSeconds; // how much time before limit resets.
uint256 public limitInWei; // max ether to withdraw per period.
// @dev Public for ease of consumption.
// @notice The time at which the current period ends at.
uint256 public currentPeriodEnd;
// @dev Public for ease of consumption.
// @notice Amounts already withdrawn this period.
uint256 public currentPeriodAmountInWei;
uint256[10] private __gap;
/**
* @notice Initialises the limits and period for the rate limiter.
* @param _periodInSeconds The length of the period in seconds.
* @param _limitInWei The limit allowed in the period in Wei.
*/
function __RateLimiter_init(uint256 _periodInSeconds, uint256 _limitInWei) internal onlyInitializing {
if (_periodInSeconds == 0) {
revert PeriodIsZero();
}
if (_limitInWei == 0) {
revert LimitIsZero();
}
periodInSeconds = _periodInSeconds;
limitInWei = _limitInWei;
currentPeriodEnd = block.timestamp + _periodInSeconds;
emit RateLimitInitialized(periodInSeconds, limitInWei, currentPeriodEnd);
}
/**
* @notice Increments the amount used in the period.
* @dev The amount determining logic is external to this (e.g. fees are included when calling here).
* @dev Reverts if the limit is breached.
* @param _usedAmount The amount used to be added.
*/
function _addUsedAmount(uint256 _usedAmount) internal {
uint256 currentPeriodAmountTemp;
if (currentPeriodEnd < block.timestamp) {
currentPeriodEnd = block.timestamp + periodInSeconds;
currentPeriodAmountTemp = _usedAmount;
} else {
currentPeriodAmountTemp = currentPeriodAmountInWei + _usedAmount;
}
if (currentPeriodAmountTemp > limitInWei) {
revert RateLimitExceeded();
}
currentPeriodAmountInWei = currentPeriodAmountTemp;
}
/**
* @notice Resets the rate limit amount.
* @dev If the used amount is higher, it is set to the limit to avoid confusion/issues.
* @dev Only the RATE_LIMIT_SETTER_ROLE is allowed to execute this function.
* @dev Emits the LimitAmountChanged event.
* @dev usedLimitAmountToSet will use the default value of zero if period has expired
* @param _amount The amount to reset the limit to.
*/
function resetRateLimitAmount(uint256 _amount) external onlyRole(RATE_LIMIT_SETTER_ROLE) {
uint256 usedLimitAmountToSet;
bool amountUsedLoweredToLimit;
bool usedAmountResetToZero;
if (currentPeriodEnd < block.timestamp) {
currentPeriodEnd = block.timestamp + periodInSeconds;
usedAmountResetToZero = true;
} else {
if (_amount < currentPeriodAmountInWei) {
usedLimitAmountToSet = _amount;
amountUsedLoweredToLimit = true;
}
}
limitInWei = _amount;
if (usedAmountResetToZero || amountUsedLoweredToLimit) {
currentPeriodAmountInWei = usedLimitAmountToSet;
}
emit LimitAmountChanged(_msgSender(), _amount, amountUsedLoweredToLimit, usedAmountResetToZero);
}
/**
* @notice Resets the amount used to zero.
* @dev Only the RATE_LIMIT_SETTER_ROLE is allowed to execute this function.
* @dev Emits the AmountUsedInPeriodReset event.
*/
function resetAmountUsedInPeriod() external onlyRole(RATE_LIMIT_SETTER_ROLE) {
currentPeriodAmountInWei = 0;
emit AmountUsedInPeriodReset(_msgSender());
}
}
// SPDX-License-Identifier: Apache-2.0
/**
* @author Hamdi Allam [email protected]
* @notice Please reach out with any questions or concerns.
* @custom:security-contact [email protected]
*/
pragma solidity 0.8.22;
error NotList();
error WrongBytesLength();
error NoNext();
error MemoryOutOfBounds(uint256 inde);
library RLPReader {
uint8 internal constant STRING_SHORT_START = 0x80;
uint8 internal constant STRING_LONG_START = 0xb8;
uint8 internal constant LIST_SHORT_START = 0xc0;
uint8 internal constant LIST_LONG_START = 0xf8;
uint8 internal constant LIST_SHORT_START_MAX = 0xf7;
uint8 internal constant WORD_SIZE = 32;
struct RLPItem {
uint256 len;
uint256 memPtr;
}
struct Iterator {
RLPItem item; // Item that's being iterated over.
uint256 nextPtr; // Position of the next item in the list.
}
/**
* @dev Returns the next element in the iteration. Reverts if it has no next element.
* @param _self The iterator.
* @return nextItem The next element in the iteration.
*/
function _next(Iterator memory _self) internal pure returns (RLPItem memory nextItem) {
if (!_hasNext(_self)) {
revert NoNext();
}
uint256 ptr = _self.nextPtr;
uint256 itemLength = _itemLength(ptr);
_self.nextPtr = ptr + itemLength;
nextItem.len = itemLength;
nextItem.memPtr = ptr;
}
/**
* @dev Returns the number 'skiptoNum' element in the iteration.
* @param _self The iterator.
* @param _skipToNum Element position in the RLP item iterator to return.
* @return item The number 'skipToNum' element in the iteration.
*/
function _skipTo(Iterator memory _self, uint256 _skipToNum) internal pure returns (RLPItem memory item) {
uint256 lenX;
uint256 memPtrStart = _self.item.memPtr;
uint256 endPtr;
uint256 byte0;
uint256 byteLen;
assembly {
// get first byte to know if it is a short/long list
byte0 := byte(0, mload(memPtrStart))
// yul has no if/else so if it a short list ( < long list start )
switch lt(byte0, LIST_LONG_START)
case 1 {
// the length is just the difference in bytes
lenX := sub(byte0, 0xc0)
}
case 0 {
// at this point we care only about lists, so this is the default
// get how many next bytes indicate the list length
byteLen := sub(byte0, 0xf7)
// move one over to the list length start
memPtrStart := add(memPtrStart, 1)
// shift over grabbing the bytelen elements
lenX := div(mload(memPtrStart), exp(256, sub(32, byteLen)))
}
// get the end
endPtr := add(memPtrStart, lenX)
}
uint256 ptr = _self.nextPtr;
uint256 itemLength = _itemLength(ptr);
_self.nextPtr = ptr + itemLength;
for (uint256 i; i < _skipToNum - 1; ) {
ptr = _self.nextPtr;
if (ptr > endPtr) revert MemoryOutOfBounds(endPtr);
itemLength = _itemLength(ptr);
_self.nextPtr = ptr + itemLength;
unchecked {
i++;
}
}
item.len = itemLength;
item.memPtr = ptr;
}
/**
* @dev Returns true if the iteration has more elements.
* @param _self The iterator.
* @return True if the iteration has more elements.
*/
function _hasNext(Iterator memory _self) internal pure returns (bool) {
RLPItem memory item = _self.item;
return _self.nextPtr < item.memPtr + item.len;
}
/**
* @param item RLP encoded bytes.
* @return newItem The RLP item.
*/
function _toRlpItem(bytes memory item) internal pure returns (RLPItem memory newItem) {
uint256 memPtr;
assembly {
memPtr := add(item, 0x20)
}
newItem.len = item.length;
newItem.memPtr = memPtr;
}
/**
* @dev Creates an iterator. Reverts if item is not a list.
* @param _self The RLP item.
* @return iterator 'Iterator' over the item.
*/
function _iterator(RLPItem memory _self) internal pure returns (Iterator memory iterator) {
if (!_isList(_self)) {
revert NotList();
}
uint256 ptr = _self.memPtr + _payloadOffset(_self.memPtr);
iterator.item = _self;
iterator.nextPtr = ptr;
}
/**
* @param _item The RLP item.
* @return (memPtr, len) Tuple: Location of the item's payload in memory.
*/
function _payloadLocation(RLPItem memory _item) internal pure returns (uint256, uint256) {
uint256 offset = _payloadOffset(_item.memPtr);
uint256 memPtr = _item.memPtr + offset;
uint256 len = _item.len - offset; // data length
return (memPtr, len);
}
/**
* @param _item The RLP item.
* @return Indicator whether encoded payload is a list.
*/
function _isList(RLPItem memory _item) internal pure returns (bool) {
if (_item.len == 0) return false;
uint8 byte0;
uint256 memPtr = _item.memPtr;
assembly {
byte0 := byte(0, mload(memPtr))
}
if (byte0 < LIST_SHORT_START) return false;
return true;
}
/**
* @param _item The RLP item.
* @return result Returns the item as an address.
*/
function _toAddress(RLPItem memory _item) internal pure returns (address) {
// 1 byte for the length prefix
if (_item.len != 21) {
revert WrongBytesLength();
}
return address(uint160(_toUint(_item)));
}
/**
* @param _item The RLP item.
* @return result Returns the item as a uint256.
*/
function _toUint(RLPItem memory _item) internal pure returns (uint256 result) {
if (_item.len == 0 || _item.len > 33) {
revert WrongBytesLength();
}
(uint256 memPtr, uint256 len) = _payloadLocation(_item);
assembly {
result := mload(memPtr)
// Shfit to the correct location if neccesary.
if lt(len, 32) {
result := div(result, exp(256, sub(32, len)))
}
}
}
/**
* @param _item The RLP item.
* @return result Returns the item as bytes.
*/
function _toBytes(RLPItem memory _item) internal pure returns (bytes memory result) {
if (_item.len == 0) {
revert WrongBytesLength();
}
(uint256 memPtr, uint256 len) = _payloadLocation(_item);
result = new bytes(len);
uint256 destPtr;
assembly {
destPtr := add(0x20, result)
}
_copy(memPtr, destPtr, len);
}
/**
* Private Helpers
*/
/**
* @param _memPtr Item memory pointer.
* @return Entire RLP item byte length.
*/
function _itemLength(uint256 _memPtr) private pure returns (uint256) {
uint256 itemLen;
uint256 dataLen;
uint256 byte0;
assembly {
byte0 := byte(0, mload(_memPtr))
}
if (byte0 < STRING_SHORT_START) itemLen = 1;
else if (byte0 < STRING_LONG_START) itemLen = byte0 - STRING_SHORT_START + 1;
else if (byte0 < LIST_SHORT_START) {
assembly {
let byteLen := sub(byte0, 0xb7) // # Of bytes the actual length is.
_memPtr := add(_memPtr, 1) // Skip over the first byte.
/* 32 byte word size */
dataLen := div(mload(_memPtr), exp(256, sub(32, byteLen))) // Right shifting to get the len.
itemLen := add(dataLen, add(byteLen, 1))
}
} else if (byte0 < LIST_LONG_START) {
itemLen = byte0 - LIST_SHORT_START + 1;
} else {
assembly {
let byteLen := sub(byte0, 0xf7)
_memPtr := add(_memPtr, 1)
dataLen := div(mload(_memPtr), exp(256, sub(32, byteLen))) // Right shifting to the correct length.
itemLen := add(dataLen, add(byteLen, 1))
}
}
return itemLen;
}
/**
* @param _memPtr Item memory pointer.
* @return Number of bytes until the data.
*/
function _payloadOffset(uint256 _memPtr) private pure returns (uint256) {
uint256 byte0;
assembly {
byte0 := byte(0, mload(_memPtr))
}
if (byte0 < STRING_SHORT_START) return 0;
else if (byte0 < STRING_LONG_START || (byte0 >= LIST_SHORT_START && byte0 < LIST_LONG_START)) return 1;
else if (byte0 < LIST_SHORT_START)
// being explicit
return byte0 - (STRING_LONG_START - 1) + 1;
else return byte0 - (LIST_LONG_START - 1) + 1;
}
/**
* @param _src Pointer to source.
* @param _dest Pointer to destination.
* @param _len Amount of memory to copy from the source.
*/
function _copy(uint256 _src, uint256 _dest, uint256 _len) private pure {
if (_len == 0) return;
// copy as many word sizes as possible
for (; _len >= WORD_SIZE; _len -= WORD_SIZE) {
assembly {
mstore(_dest, mload(_src))
}
_src += WORD_SIZE;
_dest += WORD_SIZE;
}
if (_len > 0) {
// Left over bytes. Mask is used to remove unwanted bytes from the word.
uint256 mask = 256 ** (WORD_SIZE - _len) - 1;
assembly {
let srcpart := and(mload(_src), not(mask)) // Zero out src.
let destpart := and(mload(_dest), mask) // Retrieve the bytes.
mstore(_dest, or(destpart, srcpart))
}
}
}
}
// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.22;
/**
* @title Library to verify sparse merkle proofs and to get the leaf hash value
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
library SparseMerkleTreeVerifier {
/**
* @notice Verify merkle proof
* @param _leafHash Leaf hash.
* @param _proof Sparse merkle tree proof.
* @param _leafIndex Index of the leaf.
* @param _root Merkle root.
*/
function _verifyMerkleProof(
bytes32 _leafHash,
bytes32[] calldata _proof,
uint32 _leafIndex,
bytes32 _root
) internal pure returns (bool) {
bytes32 node = _leafHash;
for (uint256 height; height < _proof.length; ++height) {
if (((_leafIndex >> height) & 1) == 1) {
node = _efficientKeccak(_proof[height], node);
} else {
node = _efficientKeccak(node, _proof[height]);
}
}
return node == _root;
}
/**
* @notice Performs a gas optimized keccak hash
* @param _left Left value.
* @param _right Right value.
*/
function _efficientKeccak(bytes32 _left, bytes32 _right) internal pure returns (bytes32 value) {
assembly {
mstore(0x00, _left)
mstore(0x20, _right)
value := keccak256(0x00, 0x40)
}
}
}
// SPDX-License-Identifier: AGPL-3.0
pragma solidity >=0.8.19 <=0.8.22;
import { RLPReader } from "./Rlp.sol";
using RLPReader for RLPReader.RLPItem;
using RLPReader for RLPReader.Iterator;
using RLPReader for bytes;
/**
* dev Thrown when the transaction data length is too short.
*/
error TransactionShort();
/**
* dev Thrown when the transaction type is unknown.
*/
error UnknownTransactionType(bytes1 versionByte);
/**
* @title Contract to decode RLP formatted transactions.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
library TransactionDecoder {
/**
* @notice Decodes the transaction extracting the calldata.
* @param _transaction The RLP transaction.
* @return data Returns the transaction calldata as bytes.
*/
function decodeTransaction(bytes calldata _transaction) internal pure returns (bytes memory) {
if (_transaction.length < 1) {
revert TransactionShort();
}
bytes1 version = _transaction[0];
if (version == 0x01) {
return _decodeEIP2930Transaction(_transaction);
}
if (version == 0x02) {
return _decodeEIP1559Transaction(_transaction);
}
if (version >= 0xc0) {
return _decodeLegacyTransaction(_transaction);
}
revert UnknownTransactionType(version);
}
/**
* @notice Decodes the EIP1559 transaction extracting the calldata.
* @param _transaction The RLP transaction.
* @return data Returns the transaction calldata as bytes.
*/
function _decodeEIP1559Transaction(bytes calldata _transaction) private pure returns (bytes memory data) {
bytes memory txData = _transaction[1:]; // skip the version byte
RLPReader.RLPItem memory rlp = txData._toRlpItem();
RLPReader.Iterator memory it = rlp._iterator();
data = it._skipTo(8)._toBytes();
}
/**
* @notice Decodes the EIP2930 transaction extracting the calldata.
* @param _transaction The RLP transaction.
* @return data Returns the transaction calldata as bytes.
*/
function _decodeEIP2930Transaction(bytes calldata _transaction) private pure returns (bytes memory data) {
bytes memory txData = _transaction[1:]; // skip the version byte
RLPReader.RLPItem memory rlp = txData._toRlpItem();
RLPReader.Iterator memory it = rlp._iterator();
data = it._skipTo(7)._toBytes();
}
/**
* @notice Decodes the legacy transaction extracting the calldata.
* @param _transaction The RLP transaction.
* @return data Returns the transaction calldata as bytes.
*/
function _decodeLegacyTransaction(bytes calldata _transaction) private pure returns (bytes memory data) {
bytes memory txData = _transaction;
RLPReader.RLPItem memory rlp = txData._toRlpItem();
RLPReader.Iterator memory it = rlp._iterator();
data = it._skipTo(6)._toBytes();
}
}
// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.22;
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import { L1MessageServiceV1 } from "./messageService/l1/v1/L1MessageServiceV1.sol";
import { IZkEvmV2 } from "./interfaces/l1/IZkEvmV2.sol";
import { TransactionDecoder } from "./messageService/lib/TransactionDecoder.sol";
import { CodecV2 } from "./messageService/lib/Codec.sol";
import { IPlonkVerifier } from "./interfaces/l1/IPlonkVerifier.sol";
/**
* @title Contract to manage cross-chain messaging on L1 and rollup proving.
* @author ConsenSys Software Inc.
* @custom:security-contact [email protected]
*/
abstract contract ZkEvmV2 is Initializable, AccessControlUpgradeable, L1MessageServiceV1, IZkEvmV2 {
using TransactionDecoder for *;
using CodecV2 for *;
uint256 internal constant MODULO_R = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
uint256 public currentTimestamp;
uint256 public currentL2BlockNumber;
mapping(uint256 blockNumber => bytes32 stateRootHash) public stateRootHashes;
mapping(uint256 proofType => address verifierAddress) public verifiers;
uint256[50] private __gap;
/**
* @notice Finalizes blocks without using a proof.
* @dev DEFAULT_ADMIN_ROLE is required to execute.
* @dev _blocksData[0].fromAddresses is a temporary workaround to pass bytes calldata.
* @param _blocksData The full BlockData collection - block, transaction and log data.
*/
function finalizeBlocksWithoutProof(
BlockData[] calldata _blocksData
) external whenTypeNotPaused(GENERAL_PAUSE_TYPE) onlyRole(DEFAULT_ADMIN_ROLE) {
_finalizeBlocks(_blocksData, _blocksData[0].fromAddresses, 0, bytes32(0), false);
}
/**
* @notice Finalizes blocks using a proof.
* @dev OPERATOR_ROLE is required to execute.
* @dev If the verifier based on proof type is not found, it reverts.
* @param _blocksData The full BlockData collection - block, transaction and log data.
* @param _proof The proof to be verified with the proof type verifier contract.
* @param _proofType The proof type to determine which verifier contract to use.
* @param _parentStateRootHash The starting roothash for the last known block.
*/
function finalizeBlocks(
BlockData[] calldata _blocksData,
bytes calldata _proof,
uint256 _proofType,
bytes32 _parentStateRootHash
) external whenTypeAndGeneralNotPaused(PROVING_SYSTEM_PAUSE_TYPE) onlyRole(OPERATOR_ROLE) {
if (stateRootHashes[currentL2BlockNumber] != _parentStateRootHash) {
revert StartingRootHashDoesNotMatch();
}
_finalizeBlocks(_blocksData, _proof, _proofType, _parentStateRootHash, true);
}
/**
* @notice Finalizes blocks with or without using a proof depending on _withProof.
* @dev OPERATOR_ROLE is required to execute.
* @dev If the verifier based on proof type is not found, it reverts.
* @param _blocksData The full BlockData collection - block, transaction and log data.
* @param _proof The proof to be verified with the proof type verifier contract.
* @param _proofType The proof type to determine which verifier contract to use.
* @param _parentStateRootHash The starting roothash for the last known block.
*/
function _finalizeBlocks(
BlockData[] calldata _blocksData,
bytes calldata _proof,
uint256 _proofType,
bytes32 _parentStateRootHash,
bool _withProof
) private {
if (_blocksData.length == 0) {
revert EmptyBlockDataArray();
}
uint256 currentBlockNumberTemp = currentL2BlockNumber;
uint256 firstBlockNumber;
unchecked {
firstBlockNumber = currentBlockNumberTemp + 1;
}
uint256[] memory timestamps = new uint256[](_blocksData.length);
bytes32[] memory blockHashes = new bytes32[](_blocksData.length);
bytes32[] memory rootHashes;
unchecked {
rootHashes = new bytes32[](_blocksData.length + 1);
}
rootHashes[0] = _parentStateRootHash;
bytes32 hashOfTxHashes;
bytes32 hashOfMessageHashes;
for (uint256 i; i < _blocksData.length; ++i) {
BlockData calldata blockInfo = _blocksData[i];
if (blockInfo.l2BlockTimestamp >= block.timestamp) {
revert BlockTimestampError(blockInfo.l2BlockTimestamp, block.timestamp);
}
hashOfTxHashes = _processBlockTransactions(blockInfo.transactions, blockInfo.batchReceptionIndices);
hashOfMessageHashes = _processMessageHashes(blockInfo.l2ToL1MsgHashes);
unchecked {
++currentBlockNumberTemp;
}
blockHashes[i] = keccak256(
abi.encodePacked(
hashOfTxHashes,
hashOfMessageHashes,
keccak256(abi.encodePacked(blockInfo.batchReceptionIndices)),
keccak256(blockInfo.fromAddresses)
)
);
timestamps[i] = blockInfo.l2BlockTimestamp;
unchecked {
rootHashes[i + 1] = blockInfo.blockRootHash;
}
emit BlockFinalized(currentBlockNumberTemp, blockInfo.blockRootHash, _withProof);
}
unchecked {
uint256 arrayIndex = _blocksData.length - 1;
stateRootHashes[currentBlockNumberTemp] = _blocksData[arrayIndex].blockRootHash;
currentTimestamp = _blocksData[arrayIndex].l2BlockTimestamp;
currentL2BlockNumber = currentBlockNumberTemp;
}
if (_withProof) {
uint256 publicInput = uint256(
keccak256(
abi.encode(
keccak256(abi.encodePacked(blockHashes)),
firstBlockNumber,
keccak256(abi.encodePacked(timestamps)),
keccak256(abi.encodePacked(rootHashes))
)
)
);
assembly {
publicInput := mod(publicInput, MODULO_R)
}
_verifyProof(publicInput, _proofType, _proof, _parentStateRootHash);
}
}
/**
* @notice Hashes all transactions individually and then hashes the packed hash array.
* @dev Updates the outbox status on L1 as received.
* @param _transactions The transactions in a particular block.
* @param _batchReceptionIndices The indexes where the transaction type is the L1->L2 anchoring message hashes transaction.
*/
function _processBlockTransactions(
bytes[] calldata _transactions,
uint16[] calldata _batchReceptionIndices
) internal returns (bytes32 hashOfTxHashes) {
bytes32[] memory transactionHashes = new bytes32[](_transactions.length);
if (_transactions.length == 0) {
revert EmptyBlock();
}
for (uint256 i; i < _batchReceptionIndices.length; ++i) {
_updateL1L2MessageStatusToReceived(
TransactionDecoder.decodeTransaction(_transactions[_batchReceptionIndices[i]])._extractXDomainAddHashes()
);
}
for (uint256 i; i < _transactions.length; ++i) {
transactionHashes[i] = keccak256(_transactions[i]);
}
hashOfTxHashes = keccak256(abi.encodePacked(transactionHashes));
}
/**
* @notice Anchors message hashes and hashes the packed hash array.
* @dev Also adds L2->L1 sent message hashes for later claiming.
* @param _messageHashes The hashes in the message sent event logs.
*/
function _processMessageHashes(bytes32[] calldata _messageHashes) internal returns (bytes32 hashOfLogHashes) {
for (uint256 i; i < _messageHashes.length; ++i) {
_addL2L1MessageHash(_messageHashes[i]);
}
hashOfLogHashes = keccak256(abi.encodePacked(_messageHashes));
}
/**
* @notice Verifies the proof with locally computed public inputs.
* @dev If the verifier based on proof type is not found, it reverts with InvalidProofType.
* @param _publicInputHash The full BlockData collection - block, transaction and log data.
* @param _proofType The proof type to determine which verifier contract to use.
* @param _proof The proof to be verified with the proof type verifier contract.
* @param _parentStateRootHash The beginning roothash to start with.
*/
function _verifyProof(
uint256 _publicInputHash,
uint256 _proofType,
bytes calldata _proof,
bytes32 _parentStateRootHash
) internal {
uint256[] memory input = new uint256[](1);
input[0] = _publicInputHash;
address verifierToUse = verifiers[_proofType];
if (verifierToUse == address(0)) {
revert InvalidProofType();
}
bool success = IPlonkVerifier(verifierToUse).Verify(_proof, input);
if (!success) {
revert InvalidProof();
}
emit BlocksVerificationDone(currentL2BlockNumber, _parentStateRootHash, stateRootHashes[currentL2BlockNumber]);
}
}