Source Code
Overview
ETH Balance
0 ETH
More Info
ContractCreator
Multichain Info
N/A
Loading...
Loading
Contract Name:
AllocationResolver
Compiler Version
v0.8.19+commit.7dd6d404
Optimization Enabled:
Yes with 200 runs
Other Settings:
paris EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity ^0.8.19; import "@ethereum-attestation-service/eas-contracts/contracts/resolver/SchemaResolver.sol"; import "@openzeppelin/contracts/access/AccessControl.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; contract AllocationResolver is Ownable, SchemaResolver { constructor(IEAS eas) SchemaResolver(eas) {} function isPayable() public pure override returns (bool) { return false; } function onAttest( Attestation calldata attestation, uint256 /*value*/ ) internal view override returns (bool) { (address projectAddress, , , , ) = abi.decode( attestation.data, (address, string, address[], uint32[], uint256[]) ); require(projectAddress != address(0), "Project not found."); return IAccessControl(projectAddress).hasRole(0x00, attestation.attester); } function onRevoke( Attestation calldata /*attestation*/, uint256 /*value*/ ) internal pure override returns (bool) { return true; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.4; import { IEAS, Attestation } from "../IEAS.sol"; import { InvalidEAS, uncheckedInc } from "../Common.sol"; import { Semver } from "../Semver.sol"; import { ISchemaResolver } from "./ISchemaResolver.sol"; /** * @title A base resolver contract */ abstract contract SchemaResolver is ISchemaResolver, Semver { error AccessDenied(); error InsufficientValue(); error NotPayable(); // The global EAS contract. IEAS internal immutable _eas; /** * @dev Creates a new resolver. * * @param eas The address of the global EAS contract. */ constructor(IEAS eas) Semver(1, 0, 0) { if (address(eas) == address(0)) { revert InvalidEAS(); } _eas = eas; } /** * @dev Ensures that only the EAS contract can make this call. */ modifier onlyEAS() { _onlyEAS(); _; } /** * @inheritdoc ISchemaResolver */ function isPayable() public pure virtual returns (bool) { return false; } /** * @dev ETH callback. */ receive() external payable virtual { if (!isPayable()) { revert NotPayable(); } } /** * @inheritdoc ISchemaResolver */ function attest(Attestation calldata attestation) external payable onlyEAS returns (bool) { return onAttest(attestation, msg.value); } /** * @inheritdoc ISchemaResolver */ function multiAttest( Attestation[] calldata attestations, uint256[] calldata values ) external payable onlyEAS returns (bool) { uint256 length = attestations.length; // We are keeping track of the remaining ETH amount that can be sent to resolvers and will keep deducting // from it to verify that there isn't any attempt to send too much ETH to resolvers. Please note that unless // some ETH was stuck in the contract by accident (which shouldn't happen in normal conditions), it won't be // possible to send too much ETH anyway. uint256 remainingValue = msg.value; for (uint256 i = 0; i < length; i = uncheckedInc(i)) { // Ensure that the attester/revoker doesn't try to spend more than available. uint256 value = values[i]; if (value > remainingValue) { revert InsufficientValue(); } // Forward the attestation to the underlying resolver and revert in case it isn't approved. if (!onAttest(attestations[i], value)) { return false; } unchecked { // Subtract the ETH amount, that was provided to this attestation, from the global remaining ETH amount. remainingValue -= value; } } return true; } /** * @inheritdoc ISchemaResolver */ function revoke(Attestation calldata attestation) external payable onlyEAS returns (bool) { return onRevoke(attestation, msg.value); } /** * @inheritdoc ISchemaResolver */ function multiRevoke( Attestation[] calldata attestations, uint256[] calldata values ) external payable onlyEAS returns (bool) { uint256 length = attestations.length; // We are keeping track of the remaining ETH amount that can be sent to resolvers and will keep deducting // from it to verify that there isn't any attempt to send too much ETH to resolvers. Please note that unless // some ETH was stuck in the contract by accident (which shouldn't happen in normal conditions), it won't be // possible to send too much ETH anyway. uint256 remainingValue = msg.value; for (uint256 i = 0; i < length; i = uncheckedInc(i)) { // Ensure that the attester/revoker doesn't try to spend more than available. uint256 value = values[i]; if (value > remainingValue) { revert InsufficientValue(); } // Forward the revocation to the underlying resolver and revert in case it isn't approved. if (!onRevoke(attestations[i], value)) { return false; } unchecked { // Subtract the ETH amount, that was provided to this attestation, from the global remaining ETH amount. remainingValue -= value; } } return true; } /** * @dev A resolver callback that should be implemented by child contracts. * * @param attestation The new attestation. * @param value An explicit ETH amount that was sent to the resolver. Please note that this value is verified in * both attest() and multiAttest() callbacks EAS-only callbacks and that in case of multi attestations, it'll * usually hold that msg.value != value, since msg.value aggregated the sent ETH amounts for all the attestations * in the batch. * * @return Whether the attestation is valid. */ function onAttest(Attestation calldata attestation, uint256 value) internal virtual returns (bool); /** * @dev Processes an attestation revocation and verifies if it can be revoked. * * @param attestation The existing attestation to be revoked. * @param value An explicit ETH amount that was sent to the resolver. Please note that this value is verified in * both revoke() and multiRevoke() callbacks EAS-only callbacks and that in case of multi attestations, it'll * usually hold that msg.value != value, since msg.value aggregated the sent ETH amounts for all the attestations * in the batch. * * @return Whether the attestation can be revoked. */ function onRevoke(Attestation calldata attestation, uint256 value) internal virtual returns (bool); /** * @dev Ensures that only the EAS contract can make this call. */ function _onlyEAS() private view { if (msg.sender != address(_eas)) { revert AccessDenied(); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol) pragma solidity ^0.8.0; import "./IAccessControl.sol"; import "../utils/Context.sol"; import "../utils/Strings.sol"; import "../utils/introspection/ERC165.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 AccessControl is Context, IAccessControl, ERC165 { 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(IAccessControl).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 ", Strings.toHexString(account), " is missing role ", Strings.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()); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import { ISchemaRegistry } from "./ISchemaRegistry.sol"; import { Attestation, EIP712Signature } from "./Common.sol"; /** * @dev A struct representing the arguments of the attestation request. */ struct AttestationRequestData { address recipient; // The recipient of the attestation. uint64 expirationTime; // The time when the attestation expires (Unix timestamp). bool revocable; // Whether the attestation is revocable. bytes32 refUID; // The UID of the related attestation. bytes data; // Custom attestation data. uint256 value; // An explicit ETH amount to send to the resolver. This is important to prevent accidental user errors. } /** * @dev A struct representing the full arguments of the attestation request. */ struct AttestationRequest { bytes32 schema; // The unique identifier of the schema. AttestationRequestData data; // The arguments of the attestation request. } /** * @dev A struct representing the full arguments of the full delegated attestation request. */ struct DelegatedAttestationRequest { bytes32 schema; // The unique identifier of the schema. AttestationRequestData data; // The arguments of the attestation request. EIP712Signature signature; // The EIP712 signature data. address attester; // The attesting account. } /** * @dev A struct representing the full arguments of the multi attestation request. */ struct MultiAttestationRequest { bytes32 schema; // The unique identifier of the schema. AttestationRequestData[] data; // The arguments of the attestation request. } /** * @dev A struct representing the full arguments of the delegated multi attestation request. */ struct MultiDelegatedAttestationRequest { bytes32 schema; // The unique identifier of the schema. AttestationRequestData[] data; // The arguments of the attestation requests. EIP712Signature[] signatures; // The EIP712 signatures data. Please note that the signatures are assumed to be signed with increasing nonces. address attester; // The attesting account. } /** * @dev A struct representing the arguments of the revocation request. */ struct RevocationRequestData { bytes32 uid; // The UID of the attestation to revoke. uint256 value; // An explicit ETH amount to send to the resolver. This is important to prevent accidental user errors. } /** * @dev A struct representing the full arguments of the revocation request. */ struct RevocationRequest { bytes32 schema; // The unique identifier of the schema. RevocationRequestData data; // The arguments of the revocation request. } /** * @dev A struct representing the arguments of the full delegated revocation request. */ struct DelegatedRevocationRequest { bytes32 schema; // The unique identifier of the schema. RevocationRequestData data; // The arguments of the revocation request. EIP712Signature signature; // The EIP712 signature data. address revoker; // The revoking account. } /** * @dev A struct representing the full arguments of the multi revocation request. */ struct MultiRevocationRequest { bytes32 schema; // The unique identifier of the schema. RevocationRequestData[] data; // The arguments of the revocation request. } /** * @dev A struct representing the full arguments of the delegated multi revocation request. */ struct MultiDelegatedRevocationRequest { bytes32 schema; // The unique identifier of the schema. RevocationRequestData[] data; // The arguments of the revocation requests. EIP712Signature[] signatures; // The EIP712 signatures data. Please note that the signatures are assumed to be signed with increasing nonces. address revoker; // The revoking account. } /** * @title EAS - Ethereum Attestation Service interface. */ interface IEAS { /** * @dev Emitted when an attestation has been made. * * @param recipient The recipient of the attestation. * @param attester The attesting account. * @param uid The UID the revoked attestation. * @param schema The UID of the schema. */ event Attested(address indexed recipient, address indexed attester, bytes32 uid, bytes32 indexed schema); /** * @dev Emitted when an attestation has been revoked. * * @param recipient The recipient of the attestation. * @param attester The attesting account. * @param schema The UID of the schema. * @param uid The UID the revoked attestation. */ event Revoked(address indexed recipient, address indexed attester, bytes32 uid, bytes32 indexed schema); /** * @dev Emitted when a data has been timestamped. * * @param data The data. * @param timestamp The timestamp. */ event Timestamped(bytes32 indexed data, uint64 indexed timestamp); /** * @dev Emitted when a data has been revoked. * * @param revoker The address of the revoker. * @param data The data. * @param timestamp The timestamp. */ event RevokedOffchain(address indexed revoker, bytes32 indexed data, uint64 indexed timestamp); /** * @dev Returns the address of the global schema registry. * * @return The address of the global schema registry. */ function getSchemaRegistry() external view returns (ISchemaRegistry); /** * @dev Attests to a specific schema. * * @param request The arguments of the attestation request. * * Example: * * attest({ * schema: "0facc36681cbe2456019c1b0d1e7bedd6d1d40f6f324bf3dd3a4cef2999200a0", * data: { * recipient: "0xdEADBeAFdeAdbEafdeadbeafDeAdbEAFdeadbeaf", * expirationTime: 0, * revocable: true, * refUID: "0x0000000000000000000000000000000000000000000000000000000000000000", * data: "0xF00D", * value: 0 * } * }) * * @return The UID of the new attestation. */ function attest(AttestationRequest calldata request) external payable returns (bytes32); /** * @dev Attests to a specific schema via the provided EIP712 signature. * * @param delegatedRequest The arguments of the delegated attestation request. * * Example: * * attestByDelegation({ * schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc', * data: { * recipient: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', * expirationTime: 1673891048, * revocable: true, * refUID: '0x0000000000000000000000000000000000000000000000000000000000000000', * data: '0x1234', * value: 0 * }, * signature: { * v: 28, * r: '0x148c...b25b', * s: '0x5a72...be22' * }, * attester: '0xc5E8740aD971409492b1A63Db8d83025e0Fc427e' * }) * * @return The UID of the new attestation. */ function attestByDelegation( DelegatedAttestationRequest calldata delegatedRequest ) external payable returns (bytes32); /** * @dev Attests to multiple schemas. * * @param multiRequests The arguments of the multi attestation requests. The requests should be grouped by distinct * schema ids to benefit from the best batching optimization. * * Example: * * multiAttest([{ * schema: '0x33e9094830a5cba5554d1954310e4fbed2ef5f859ec1404619adea4207f391fd', * data: [{ * recipient: '0xdEADBeAFdeAdbEafdeadbeafDeAdbEAFdeadbeaf', * expirationTime: 1673891048, * revocable: true, * refUID: '0x0000000000000000000000000000000000000000000000000000000000000000', * data: '0x1234', * value: 1000 * }, * { * recipient: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', * expirationTime: 0, * revocable: false, * refUID: '0x480df4a039efc31b11bfdf491b383ca138b6bde160988222a2a3509c02cee174', * data: '0x00', * value: 0 * }], * }, * { * schema: '0x5ac273ce41e3c8bfa383efe7c03e54c5f0bff29c9f11ef6ffa930fc84ca32425', * data: [{ * recipient: '0xdEADBeAFdeAdbEafdeadbeafDeAdbEAFdeadbeaf', * expirationTime: 0, * revocable: true, * refUID: '0x75bf2ed8dca25a8190c50c52db136664de25b2449535839008ccfdab469b214f', * data: '0x12345678', * value: 0 * }, * }]) * * @return The UIDs of the new attestations. */ function multiAttest(MultiAttestationRequest[] calldata multiRequests) external payable returns (bytes32[] memory); /** * @dev Attests to multiple schemas using via provided EIP712 signatures. * * @param multiDelegatedRequests The arguments of the delegated multi attestation requests. The requests should be * grouped by distinct schema ids to benefit from the best batching optimization. * * Example: * * multiAttestByDelegation([{ * schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc', * data: [{ * recipient: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', * expirationTime: 1673891048, * revocable: true, * refUID: '0x0000000000000000000000000000000000000000000000000000000000000000', * data: '0x1234', * value: 0 * }, * { * recipient: '0xdEADBeAFdeAdbEafdeadbeafDeAdbEAFdeadbeaf', * expirationTime: 0, * revocable: false, * refUID: '0x0000000000000000000000000000000000000000000000000000000000000000', * data: '0x00', * value: 0 * }], * signatures: [{ * v: 28, * r: '0x148c...b25b', * s: '0x5a72...be22' * }, * { * v: 28, * r: '0x487s...67bb', * s: '0x12ad...2366' * }], * attester: '0x1D86495b2A7B524D747d2839b3C645Bed32e8CF4' * }]) * * @return The UIDs of the new attestations. */ function multiAttestByDelegation( MultiDelegatedAttestationRequest[] calldata multiDelegatedRequests ) external payable returns (bytes32[] memory); /** * @dev Revokes an existing attestation to a specific schema. * * Example: * * revoke({ * schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc', * data: { * uid: '0x101032e487642ee04ee17049f99a70590c735b8614079fc9275f9dd57c00966d', * value: 0 * } * }) * * @param request The arguments of the revocation request. */ function revoke(RevocationRequest calldata request) external payable; /** * @dev Revokes an existing attestation to a specific schema via the provided EIP712 signature. * * Example: * * revokeByDelegation({ * schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc', * data: { * uid: '0xcbbc12102578c642a0f7b34fe7111e41afa25683b6cd7b5a14caf90fa14d24ba', * value: 0 * }, * signature: { * v: 27, * r: '0xb593...7142', * s: '0x0f5b...2cce' * }, * revoker: '0x244934dd3e31bE2c81f84ECf0b3E6329F5381992' * }) * * @param delegatedRequest The arguments of the delegated revocation request. */ function revokeByDelegation(DelegatedRevocationRequest calldata delegatedRequest) external payable; /** * @dev Revokes existing attestations to multiple schemas. * * @param multiRequests The arguments of the multi revocation requests. The requests should be grouped by distinct * schema ids to benefit from the best batching optimization. * * Example: * * multiRevoke([{ * schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc', * data: [{ * uid: '0x211296a1ca0d7f9f2cfebf0daaa575bea9b20e968d81aef4e743d699c6ac4b25', * value: 1000 * }, * { * uid: '0xe160ac1bd3606a287b4d53d5d1d6da5895f65b4b4bab6d93aaf5046e48167ade', * value: 0 * }], * }, * { * schema: '0x5ac273ce41e3c8bfa383efe7c03e54c5f0bff29c9f11ef6ffa930fc84ca32425', * data: [{ * uid: '0x053d42abce1fd7c8fcddfae21845ad34dae287b2c326220b03ba241bc5a8f019', * value: 0 * }, * }]) */ function multiRevoke(MultiRevocationRequest[] calldata multiRequests) external payable; /** * @dev Revokes existing attestations to multiple schemas via provided EIP712 signatures. * * @param multiDelegatedRequests The arguments of the delegated multi revocation attestation requests. The requests should be * grouped by distinct schema ids to benefit from the best batching optimization. * * Example: * * multiRevokeByDelegation([{ * schema: '0x8e72f5bc0a8d4be6aa98360baa889040c50a0e51f32dbf0baa5199bd93472ebc', * data: [{ * uid: '0x211296a1ca0d7f9f2cfebf0daaa575bea9b20e968d81aef4e743d699c6ac4b25', * value: 1000 * }, * { * uid: '0xe160ac1bd3606a287b4d53d5d1d6da5895f65b4b4bab6d93aaf5046e48167ade', * value: 0 * }], * signatures: [{ * v: 28, * r: '0x148c...b25b', * s: '0x5a72...be22' * }, * { * v: 28, * r: '0x487s...67bb', * s: '0x12ad...2366' * }], * revoker: '0x244934dd3e31bE2c81f84ECf0b3E6329F5381992' * }]) * */ function multiRevokeByDelegation( MultiDelegatedRevocationRequest[] calldata multiDelegatedRequests ) external payable; /** * @dev Timestamps the specified bytes32 data. * * @param data The data to timestamp. * * @return The timestamp the data was timestamped with. */ function timestamp(bytes32 data) external returns (uint64); /** * @dev Timestamps the specified multiple bytes32 data. * * @param data The data to timestamp. * * @return The timestamp the data was timestamped with. */ function multiTimestamp(bytes32[] calldata data) external returns (uint64); /** * @dev Revokes the specified bytes32 data. * * @param data The data to timestamp. * * @return The timestamp the data was revoked with. */ function revokeOffchain(bytes32 data) external returns (uint64); /** * @dev Revokes the specified multiple bytes32 data. * * @param data The data to timestamp. * * @return The timestamp the data was revoked with. */ function multiRevokeOffchain(bytes32[] calldata data) external returns (uint64); /** * @dev Returns an existing attestation by UID. * * @param uid The UID of the attestation to retrieve. * * @return The attestation data members. */ function getAttestation(bytes32 uid) external view returns (Attestation memory); /** * @dev Checks whether an attestation exists. * * @param uid The UID of the attestation to retrieve. * * @return Whether an attestation exists. */ function isAttestationValid(bytes32 uid) external view returns (bool); /** * @dev Returns the timestamp that the specified data was timestamped with. * * @param data The data to query. * * @return The timestamp the data was timestamped with. */ function getTimestamp(bytes32 data) external view returns (uint64); /** * @dev Returns the timestamp that the specified data was timestamped with. * * @param data The data to query. * * @return The timestamp the data was timestamped with. */ function getRevokeOffchain(address revoker, bytes32 data) external view returns (uint64); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; // A representation of an empty/uninitialized UID. bytes32 constant EMPTY_UID = 0; // A zero expiration represents an non-expiring attestation. uint64 constant NO_EXPIRATION_TIME = 0; error AccessDenied(); error InvalidEAS(); error InvalidLength(); error InvalidSignature(); error NotFound(); /** * @dev A struct representing EIP712 signature data. */ struct EIP712Signature { uint8 v; // The recovery ID. bytes32 r; // The x-coordinate of the nonce R. bytes32 s; // The signature data. } /** * @dev A struct representing a single attestation. */ struct Attestation { bytes32 uid; // A unique identifier of the attestation. bytes32 schema; // The unique identifier of the schema. uint64 time; // The time when the attestation was created (Unix timestamp). uint64 expirationTime; // The time when the attestation expires (Unix timestamp). uint64 revocationTime; // The time when the attestation was revoked (Unix timestamp). bytes32 refUID; // The UID of the related attestation. address recipient; // The recipient of the attestation. address attester; // The attester/sender of the attestation. bool revocable; // Whether the attestation is revocable. bytes data; // Custom attestation data. } /** * @dev A helper function to work with unchecked iterators in loops. */ function uncheckedInc(uint256 i) pure returns (uint256 j) { unchecked { j = i + 1; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.4; import { Strings } from "@openzeppelin/contracts/utils/Strings.sol"; /** * @dev A simple contract for managing contract versions. */ contract Semver { // Contract's major version number. uint256 private immutable _major; // Contract's minor version number. uint256 private immutable _minor; // Contract's patch version number. uint256 private immutable _path; /** * @param major Major version number. * @param minor Minor version number. * @param patch Patch version number. */ constructor(uint256 major, uint256 minor, uint256 patch) { _major = major; _minor = minor; _path = patch; } /** * @notice Returns the full semver contract version. * * @return Semver contract version as a string. */ function version() external view returns (string memory) { return string( abi.encodePacked(Strings.toString(_major), ".", Strings.toString(_minor), ".", Strings.toString(_path)) ); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import { Attestation } from "../Common.sol"; /** * @title The interface of an optional schema resolver. */ interface ISchemaResolver { /** * @dev Returns whether the resolver supports ETH transfers. */ function isPayable() external pure returns (bool); /** * @dev Processes an attestation and verifies whether it's valid. * * @param attestation The new attestation. * * @return Whether the attestation is valid. */ function attest(Attestation calldata attestation) external payable returns (bool); /** * @dev Processes multiple attestations and verifies whether they are valid. * * @param attestations The new attestations. * @param values Explicit ETH amounts which were sent with each attestation. * * @return Whether all the attestations are valid. */ function multiAttest( Attestation[] calldata attestations, uint256[] calldata values ) external payable returns (bool); /** * @dev Processes an attestation revocation and verifies if it can be revoked. * * @param attestation The existing attestation to be revoked. * * @return Whether the attestation can be revoked. */ function revoke(Attestation calldata attestation) external payable returns (bool); /** * @dev Processes revocation of multiple attestation and verifies they can be revoked. * * @param attestations The existing attestations to be revoked. * @param values Explicit ETH amounts which were sent with each revocation. * * @return Whether the attestations can be revoked. */ function multiRevoke( Attestation[] calldata attestations, uint256[] calldata values ) external payable returns (bool); }
// 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 IAccessControl { /** * @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.4) (utils/Context.sol) pragma solidity ^0.8.0; /** * @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 Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } function _contextSuffixLength() internal view virtual returns (uint256) { return 0; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol) pragma solidity ^0.8.0; import "./math/Math.sol"; import "./math/SignedMath.sol"; /** * @dev String operations. */ library Strings { 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 = Math.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(SignedMath.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, Math.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 v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; import "./IERC165.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 ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import { ISchemaResolver } from "./resolver/ISchemaResolver.sol"; /** * @title A struct representing a record for a submitted schema. */ struct SchemaRecord { bytes32 uid; // The unique identifier of the schema. ISchemaResolver resolver; // Optional schema resolver. bool revocable; // Whether the schema allows revocations explicitly. string schema; // Custom specification of the schema (e.g., an ABI). } /** * @title The global schema registry interface. */ interface ISchemaRegistry { /** * @dev Emitted when a new schema has been registered * * @param uid The schema UID. * @param registerer The address of the account used to register the schema. */ event Registered(bytes32 indexed uid, address registerer); /** * @dev Submits and reserves a new schema * * @param schema The schema data schema. * @param resolver An optional schema resolver. * @param revocable Whether the schema allows revocations explicitly. * * @return The UID of the new schema. */ function register(string calldata schema, ISchemaResolver resolver, bool revocable) external returns (bytes32); /** * @dev Returns an existing schema by UID * * @param uid The UID of the schema to retrieve. * * @return The schema data members. */ function getSchema(bytes32 uid) external view returns (SchemaRecord memory); }
// 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 Math { 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 SignedMath { /** * @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 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 IERC165 { /** * @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); }
{ "remappings": [ "@ethereum-attestation-service/eas-contracts/contracts/=node_modules/@ethereum-attestation-service/eas-contracts/contracts/", "@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/", "@openzeppelin/contracts-upgradeable/=node_modules/@openzeppelin/contracts-upgradeable/", "forge-std/=lib/forge-std/src/", "murky/=lib/murky/src/", "ds-test/=lib/forge-std/lib/ds-test/src/", "openzeppelin-contracts/=lib/murky/lib/openzeppelin-contracts/" ], "optimizer": { "enabled": true, "runs": 200 }, "metadata": { "useLiteralContent": false, "bytecodeHash": "ipfs", "appendCBOR": true }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "paris", "viaIR": false, "libraries": {} }
[{"inputs":[{"internalType":"contract IEAS","name":"eas","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessDenied","type":"error"},{"inputs":[],"name":"InsufficientValue","type":"error"},{"inputs":[],"name":"InvalidEAS","type":"error"},{"inputs":[],"name":"NotPayable","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"components":[{"internalType":"bytes32","name":"uid","type":"bytes32"},{"internalType":"bytes32","name":"schema","type":"bytes32"},{"internalType":"uint64","name":"time","type":"uint64"},{"internalType":"uint64","name":"expirationTime","type":"uint64"},{"internalType":"uint64","name":"revocationTime","type":"uint64"},{"internalType":"bytes32","name":"refUID","type":"bytes32"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"address","name":"attester","type":"address"},{"internalType":"bool","name":"revocable","type":"bool"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Attestation","name":"attestation","type":"tuple"}],"name":"attest","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"isPayable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"uid","type":"bytes32"},{"internalType":"bytes32","name":"schema","type":"bytes32"},{"internalType":"uint64","name":"time","type":"uint64"},{"internalType":"uint64","name":"expirationTime","type":"uint64"},{"internalType":"uint64","name":"revocationTime","type":"uint64"},{"internalType":"bytes32","name":"refUID","type":"bytes32"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"address","name":"attester","type":"address"},{"internalType":"bool","name":"revocable","type":"bool"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Attestation[]","name":"attestations","type":"tuple[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"multiAttest","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"uid","type":"bytes32"},{"internalType":"bytes32","name":"schema","type":"bytes32"},{"internalType":"uint64","name":"time","type":"uint64"},{"internalType":"uint64","name":"expirationTime","type":"uint64"},{"internalType":"uint64","name":"revocationTime","type":"uint64"},{"internalType":"bytes32","name":"refUID","type":"bytes32"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"address","name":"attester","type":"address"},{"internalType":"bool","name":"revocable","type":"bool"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Attestation[]","name":"attestations","type":"tuple[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"multiRevoke","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"uid","type":"bytes32"},{"internalType":"bytes32","name":"schema","type":"bytes32"},{"internalType":"uint64","name":"time","type":"uint64"},{"internalType":"uint64","name":"expirationTime","type":"uint64"},{"internalType":"uint64","name":"revocationTime","type":"uint64"},{"internalType":"bytes32","name":"refUID","type":"bytes32"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"address","name":"attester","type":"address"},{"internalType":"bool","name":"revocable","type":"bool"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Attestation","name":"attestation","type":"tuple"}],"name":"revoke","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
0x60806040526004361061008a5760003560e01c806391db0b7e1161005957806391db0b7e1461013a578063ce46e0461461014d578063e49617e114610161578063e60c350514610174578063f2fde38b1461018757600080fd5b806354fd4d50146100af578063715018a6146100da57806388e5b2d9146100ef5780638da5cb5b1461011257600080fd5b366100aa57604051631574f9f360e01b815260040160405180910390fd5b005b600080fd5b3480156100bb57600080fd5b506100c46101a7565b6040516100d191906107d5565b60405180910390f35b3480156100e657600080fd5b506100a861024a565b6101026100fd366004610854565b61025e565b60405190151581526020016100d1565b34801561011e57600080fd5b506000546040516001600160a01b0390911681526020016100d1565b610102610148366004610854565b61030d565b34801561015957600080fd5b506000610102565b61010261016f3660046108c0565b6103ac565b6101026101823660046108c0565b6103bf565b34801561019357600080fd5b506100a86101a2366004610918565b6103d3565b60606101d27f0000000000000000000000000000000000000000000000000000000000000001610451565b6101fb7f0000000000000000000000000000000000000000000000000000000000000000610451565b6102247f0000000000000000000000000000000000000000000000000000000000000000610451565b60405160200161023693929190610935565b604051602081830303815290604052905090565b6102526104e4565b61025c600061053e565b565b600061026861058e565b833460005b828110156102fd5760008686838181106102895761028961098f565b905060200201359050828111156102b35760405163044044a560e21b815260040160405180910390fd5b6102e08989848181106102c8576102c861098f565b90506020028101906102da91906109a5565b50600190565b6102f1576000945050505050610305565b9091039060010161026d565b506001925050505b949350505050565b600061031761058e565b833460005b828110156102fd5760008686838181106103385761033861098f565b905060200201359050828111156103625760405163044044a560e21b815260040160405180910390fd5b61038f8989848181106103775761037761098f565b905060200281019061038991906109a5565b826105d7565b6103a0576000945050505050610305565b9091039060010161031c565b60006103b661058e565b60015b92915050565b60006103c961058e565b6103b982346105d7565b6103db6104e4565b6001600160a01b0381166104455760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084015b60405180910390fd5b61044e8161053e565b50565b6060600061045e836106d9565b600101905060008167ffffffffffffffff81111561047e5761047e6109c6565b6040519080825280601f01601f1916602001820160405280156104a8576020820181803683370190505b5090508181016020015b600019016f181899199a1a9b1b9c1cb0b131b232b360811b600a86061a8153600a85049450846104b257509392505050565b6000546001600160a01b0316331461025c5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161043c565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b336001600160a01b037f0000000000000000000000004200000000000000000000000000000000000021161461025c57604051634ca8886760e01b815260040160405180910390fd5b6000806105e86101208501856109dc565b8101906105f59190610bb5565b50929350506001600160a01b038316915061064990505760405162461bcd60e51b8152602060048201526012602482015271283937b532b1ba103737ba103337bab7321760711b604482015260640161043c565b6001600160a01b0381166391d14854600061066b610100880160e08901610918565b6040516001600160e01b031960e085901b16815260048101929092526001600160a01b03166024820152604401602060405180830381865afa1580156106b5573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906103059190610cc9565b60008072184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b83106107185772184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b830492506040015b6d04ee2d6d415b85acef81000000008310610744576d04ee2d6d415b85acef8100000000830492506020015b662386f26fc10000831061076257662386f26fc10000830492506010015b6305f5e100831061077a576305f5e100830492506008015b612710831061078e57612710830492506004015b606483106107a0576064830492506002015b600a83106103b95760010192915050565b60005b838110156107cc5781810151838201526020016107b4565b50506000910152565b60208152600082518060208401526107f48160408501602087016107b1565b601f01601f19169190910160400192915050565b60008083601f84011261081a57600080fd5b50813567ffffffffffffffff81111561083257600080fd5b6020830191508360208260051b850101111561084d57600080fd5b9250929050565b6000806000806040858703121561086a57600080fd5b843567ffffffffffffffff8082111561088257600080fd5b61088e88838901610808565b909650945060208701359150808211156108a757600080fd5b506108b487828801610808565b95989497509550505050565b6000602082840312156108d257600080fd5b813567ffffffffffffffff8111156108e957600080fd5b820161014081850312156108fc57600080fd5b9392505050565b6001600160a01b038116811461044e57600080fd5b60006020828403121561092a57600080fd5b81356108fc81610903565b600084516109478184602089016107b1565b8083019050601760f91b8082528551610967816001850160208a016107b1565b600192019182015283516109828160028401602088016107b1565b0160020195945050505050565b634e487b7160e01b600052603260045260246000fd5b6000823561013e198336030181126109bc57600080fd5b9190910192915050565b634e487b7160e01b600052604160045260246000fd5b6000808335601e198436030181126109f357600080fd5b83018035915067ffffffffffffffff821115610a0e57600080fd5b60200191503681900382131561084d57600080fd5b604051601f8201601f1916810167ffffffffffffffff81118282101715610a4c57610a4c6109c6565b604052919050565b600067ffffffffffffffff821115610a6e57610a6e6109c6565b5060051b60200190565b600082601f830112610a8957600080fd5b81356020610a9e610a9983610a54565b610a23565b82815260059290921b84018101918181019086841115610abd57600080fd5b8286015b84811015610ae1578035610ad481610903565b8352918301918301610ac1565b509695505050505050565b600082601f830112610afd57600080fd5b81356020610b0d610a9983610a54565b82815260059290921b84018101918181019086841115610b2c57600080fd5b8286015b84811015610ae157803563ffffffff81168114610b4d5760008081fd5b8352918301918301610b30565b600082601f830112610b6b57600080fd5b81356020610b7b610a9983610a54565b82815260059290921b84018101918181019086841115610b9a57600080fd5b8286015b84811015610ae15780358352918301918301610b9e565b600080600080600060a08688031215610bcd57600080fd5b8535610bd881610903565b945060208681013567ffffffffffffffff80821115610bf657600080fd5b818901915089601f830112610c0a57600080fd5b813581811115610c1c57610c1c6109c6565b610c2e601f8201601f19168501610a23565b8181528b85838601011115610c4257600080fd5b81858501868301376000918101909401819052929650604089013592915080831115610c6c578182fd5b610c788a848b01610a78565b95506060890135925080831115610c8d578182fd5b610c998a848b01610aec565b94506080890135925080831115610cae578182fd5b5050610cbc88828901610b5a565b9150509295509295909350565b600060208284031215610cdb57600080fd5b815180151581146108fc57600080fdfea264697066735822122062a562744652cc2c437fe79e656e479d1015c5e36b43e41d26e943e45e85ea6964736f6c63430008130033
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000004200000000000000000000000000000000000021
-----Decoded View---------------
Arg [0] : eas (address): 0x4200000000000000000000000000000000000021
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000004200000000000000000000000000000000000021
Loading...
Loading
Loading...
Loading
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.