Overview
POL Balance
POL Value
$0.00More Info
Private Name Tags
ContractCreator
Loading...
Loading
Contract Name:
Eip712Checker
Compiler Version
v0.8.13+commit.abaa5c0e
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.13; import "./Eip712CheckerStorage.sol"; import {DEFAULT_ADMIN_ROLE} from "../shared/Roles.sol"; import "@solidstate/contracts/access/access_control/AccessControlInternal.sol"; /// @title Eip712Checker /// @notice Contract used for verifying signatures /// @dev Based on the EIP-712 https://eips.ethereum.org/EIPS/eip-712 contract Eip712Checker is AccessControlInternal { /// @notice Sets name and version /// @param name Domain name /// @param version Domain version function initialize(string calldata name, string calldata version) external onlyRole(DEFAULT_ADMIN_ROLE) { Eip712CheckerStorage.Storage storage s = Eip712CheckerStorage .getStorage(); s.name = keccak256(abi.encodePacked(name)); s.version = keccak256(abi.encodePacked(version)); } }
//SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.13; /// @title Eip712CheckerStorage /// @notice Storage of the Eip712Checker contract library Eip712CheckerStorage { bytes32 internal constant EIP712_CHECKER_STORAGE_SLOT = keccak256("DIMORegistry.eip712Checker.storage"); struct Storage { bytes32 name; bytes32 version; } /* solhint-disable no-inline-assembly */ function getStorage() internal pure returns (Storage storage s) { bytes32 slot = EIP712_CHECKER_STORAGE_SLOT; assembly { s.slot := slot } } /* solhint-enable no-inline-assembly */ }
//SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.13; bytes32 constant DEFAULT_ADMIN_ROLE = 0x00; bytes32 constant MINTER_ROLE = keccak256("Minter"); bytes32 constant MANUFACTURER_ROLE = keccak256("Manufacturer");
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import { EnumerableSet } from '../../data/EnumerableSet.sol'; import { AddressUtils } from '../../utils/AddressUtils.sol'; import { UintUtils } from '../../utils/UintUtils.sol'; import { IAccessControlInternal } from './IAccessControlInternal.sol'; import { AccessControlStorage } from './AccessControlStorage.sol'; /** * @title Role-based access control system * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts (MIT license) */ abstract contract AccessControlInternal is IAccessControlInternal { using AddressUtils for address; using EnumerableSet for EnumerableSet.AddressSet; using UintUtils for uint256; modifier onlyRole(bytes32 role) { _checkRole(role); _; } /* * @notice query whether role is assigned to account * @param role role to query * @param account account to query * @return whether role is assigned to account */ function _hasRole(bytes32 role, address account) internal view virtual returns (bool) { return AccessControlStorage.layout().roles[role].members.contains(account); } /** * @notice revert if sender does not have given role * @param role role to query */ function _checkRole(bytes32 role) internal view virtual { _checkRole(role, msg.sender); } /** * @notice revert if given account does not have given role * @param role role to query * @param account to query */ function _checkRole(bytes32 role, address account) internal view virtual { if (!_hasRole(role, account)) { revert( string( abi.encodePacked( 'AccessControl: account ', account.toString(), ' is missing role ', uint256(role).toHexString(32) ) ) ); } } /* * @notice query admin role for given role * @param role role to query * @return admin role */ function _getRoleAdmin(bytes32 role) internal view virtual returns (bytes32) { return AccessControlStorage.layout().roles[role].adminRole; } /** * @notice set role as admin role * @param role role to set * @param adminRole admin role to set */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { bytes32 previousAdminRole = _getRoleAdmin(role); AccessControlStorage.layout().roles[role].adminRole = adminRole; emit RoleAdminChanged(role, previousAdminRole, adminRole); } /* * @notice assign role to given account * @param role role to assign * @param account recipient of role assignment */ function _grantRole(bytes32 role, address account) internal virtual { AccessControlStorage.layout().roles[role].members.add(account); emit RoleGranted(role, account, msg.sender); } /* * @notice unassign role from given account * @param role role to unassign * @parm account */ function _revokeRole(bytes32 role, address account) internal virtual { AccessControlStorage.layout().roles[role].members.remove(account); emit RoleRevoked(role, account, msg.sender); } /** * @notice relinquish role * @param role role to relinquish */ function _renounceRole(bytes32 role) internal virtual { _revokeRole(role, msg.sender); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.8; /** * @title Set implementation with enumeration functions * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts (MIT license) */ library EnumerableSet { error EnumerableSet__IndexOutOfBounds(); struct Set { bytes32[] _values; // 1-indexed to allow 0 to signify nonexistence mapping(bytes32 => uint256) _indexes; } struct Bytes32Set { Set _inner; } struct AddressSet { Set _inner; } struct UintSet { Set _inner; } function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } function indexOf(Bytes32Set storage set, bytes32 value) internal view returns (uint256) { return _indexOf(set._inner, value); } function indexOf(AddressSet storage set, address value) internal view returns (uint256) { return _indexOf(set._inner, bytes32(uint256(uint160(value)))); } function indexOf(UintSet storage set, uint256 value) internal view returns (uint256) { return _indexOf(set._inner, bytes32(value)); } function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } function toArray(Bytes32Set storage set) internal view returns (bytes32[] memory) { uint256 len = _length(set._inner); bytes32[] memory arr = new bytes32[](len); unchecked { for (uint256 index; index < len; ++index) { arr[index] = at(set, index); } } return arr; } function toArray(AddressSet storage set) internal view returns (address[] memory) { uint256 len = _length(set._inner); address[] memory arr = new address[](len); unchecked { for (uint256 index; index < len; ++index) { arr[index] = at(set, index); } } return arr; } function toArray(UintSet storage set) internal view returns (uint256[] memory) { uint256 len = _length(set._inner); uint256[] memory arr = new uint256[](len); unchecked { for (uint256 index; index < len; ++index) { arr[index] = at(set, index); } } return arr; } function _at(Set storage set, uint256 index) private view returns (bytes32) { if (index >= set._values.length) revert EnumerableSet__IndexOutOfBounds(); return set._values[index]; } function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } function _indexOf(Set storage set, bytes32 value) private view returns (uint256) { unchecked { return set._indexes[value] - 1; } } function _length(Set storage set) private view returns (uint256) { return set._values.length; } function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); set._indexes[value] = set._values.length; return true; } else { return false; } } function _remove(Set storage set, bytes32 value) private returns (bool) { uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { unchecked { bytes32 last = set._values[set._values.length - 1]; // move last value to now-vacant index set._values[valueIndex - 1] = last; set._indexes[last] = valueIndex; } // clear last index set._values.pop(); delete set._indexes[value]; return true; } else { return false; } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.8; import { UintUtils } from './UintUtils.sol'; library AddressUtils { using UintUtils for uint256; error AddressUtils__InsufficientBalance(); error AddressUtils__NotContract(); error AddressUtils__SendValueFailed(); function toString(address account) internal pure returns (string memory) { return uint256(uint160(account)).toHexString(20); } function isContract(address account) internal view returns (bool) { uint256 size; assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable account, uint256 amount) internal { (bool success, ) = account.call{ value: amount }(''); if (!success) revert AddressUtils__SendValueFailed(); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, 'AddressUtils: failed low-level call'); } function functionCall( address target, bytes memory data, string memory error ) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, error); } function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue( target, data, value, 'AddressUtils: failed low-level call with value' ); } function functionCallWithValue( address target, bytes memory data, uint256 value, string memory error ) internal returns (bytes memory) { if (value > address(this).balance) revert AddressUtils__InsufficientBalance(); return _functionCallWithValue(target, data, value, error); } function _functionCallWithValue( address target, bytes memory data, uint256 value, string memory error ) private returns (bytes memory) { if (!isContract(target)) revert AddressUtils__NotContract(); (bool success, bytes memory returnData) = target.call{ value: value }( data ); if (success) { return returnData; } else if (returnData.length > 0) { assembly { let returnData_size := mload(returnData) revert(add(32, returnData), returnData_size) } } else { revert(error); } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.8; /** * @title utility functions for uint256 operations * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts/ (MIT license) */ library UintUtils { error UintUtils__InsufficientHexLength(); bytes16 private constant HEX_SYMBOLS = '0123456789abcdef'; function add(uint256 a, int256 b) internal pure returns (uint256) { return b < 0 ? sub(a, -b) : a + uint256(b); } function sub(uint256 a, int256 b) internal pure returns (uint256) { return b < 0 ? add(a, -b) : a - uint256(b); } function toString(uint256 value) internal pure returns (string memory) { if (value == 0) { return '0'; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return '0x00'; } uint256 length = 0; for (uint256 temp = value; temp != 0; temp >>= 8) { unchecked { length++; } } return toHexString(value, 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'; unchecked { for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = HEX_SYMBOLS[value & 0xf]; value >>= 4; } } if (value != 0) revert UintUtils__InsufficientHexLength(); return string(buffer); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @title Partial AccessControl interface needed by internal functions */ interface IAccessControlInternal { event RoleAdminChanged( bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole ); event RoleGranted( bytes32 indexed role, address indexed account, address indexed sender ); event RoleRevoked( bytes32 indexed role, address indexed account, address indexed sender ); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import { EnumerableSet } from '../../data/EnumerableSet.sol'; library AccessControlStorage { struct RoleData { EnumerableSet.AddressSet members; bytes32 adminRole; } struct Layout { mapping(bytes32 => RoleData) roles; } bytes32 internal constant DEFAULT_ADMIN_ROLE = 0x00; bytes32 internal constant STORAGE_SLOT = keccak256('solidstate.contracts.storage.AccessControl'); function layout() internal pure returns (Layout storage l) { bytes32 slot = STORAGE_SLOT; assembly { l.slot := slot } } }
{ "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"name":"UintUtils__InsufficientHexLength","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.