[Bug]: Fix: enforce required identity fields (name + email/phone)

src/IdentityToken.sol

@@ -22,6 +22,11 @@ contract IdentityToken is ERC721, IIdentityToken {
     // tokenId => attribute keyHash => attribute value
     mapping(uint256 => mapping(bytes32 => bytes)) public attributes;
 
+    // required attribute key hashes
+    bytes32 private constant NAME_KEY = keccak256(abi.encodePacked("name"));
+    bytes32 private constant EMAIL_KEY = keccak256(abi.encodePacked("email"));
+    bytes32 private constant PHONE_KEY = keccak256(abi.encodePacked("phone"));
+
     // tokenId => array of Endorsements
     mapping(uint256 => DataTypes.Endorsement[]) public endorsements;
 
@@ -76,6 +81,25 @@ contract IdentityToken is ERC721, IIdentityToken {
         return tokenId;
     }
 
+    /**
+     * @dev Adds validation to ensure required identity fields are present.
+     *      Name is mandatory and at least one contact method (email or phone)
+     *      must be provided.
+     */
+    function _validateRequiredFields(uint256 tokenId) internal view {
+        bytes storage name = attributes[tokenId][NAME_KEY];
+        bytes storage email = attributes[tokenId][EMAIL_KEY];
+        bytes storage phone = attributes[tokenId][PHONE_KEY];
+
+        // Name is mandatory
+        if (name.length == 0) revert Errors.MissingName();
+
+        // At least one contact method required
+        if (email.length == 0 && phone.length == 0) {
+            revert Errors.MissingContact();
+        }
+    }
+
     /**
      * @dev Sets a metadata attribute (e.g., name, social link) for an identity.
      */
@@ -84,7 +108,14 @@ contract IdentityToken is ERC721, IIdentityToken {
         string calldata key,
         bytes calldata value
     ) external onlyTokenOwner(tokenId) notCompromised(tokenId) {
+        bytes32 keyHash = keccak256(abi.encodePacked(key));
+
         _setAttribute(tokenId, key, value);
+
+        // skip validation if the updated attribute is one of the required fields, since
+        if (keyHash != NAME_KEY && keyHash != EMAIL_KEY && keyHash != PHONE_KEY) {
+            _validateRequiredFields(tokenId);
+        }
     }
 
     /**
@@ -108,9 +139,13 @@ contract IdentityToken is ERC721, IIdentityToken {
     ) external onlyTokenOwner(tokenId) notCompromised(tokenId) {
         if (keys.length != values.length) revert Errors.ArrayLengthMismatch();
 
+        uint8 shouldValidate = 0;
+
         for (uint256 i = 0; i < keys.length; i++) {
             _setAttribute(tokenId, keys[i], values[i]);
         }
+
+        _validateRequiredFields(tokenId);
     }
 
     /**
@@ -120,6 +155,27 @@ contract IdentityToken is ERC721, IIdentityToken {
         _setAttribute(tokenId, "name", bytes(name));
     }
 
+    /**
+     * @dev Convenience setter for the "email" / "phone" attribute.
+     */
+    function setContact(
+        uint256 tokenId,
+        string calldata email,
+        string calldata phone
+    ) external onlyTokenOwner(tokenId) notCompromised(tokenId) {
+        if (bytes(email).length == 0 && bytes(phone).length == 0) {
+            revert Errors.MissingContact();
+        }
+
+        if (bytes(email).length != 0) {
+            _setAttribute(tokenId, "email", bytes(email));
+        }
+
+        if (bytes(phone).length != 0) {
+            _setAttribute(tokenId, "phone", bytes(phone));
+        }
+    }
+
     /**
      * @dev Convenience setter for the "github" attribute.
      */
@@ -128,6 +184,18 @@ contract IdentityToken is ERC721, IIdentityToken {
         string calldata github
     ) external onlyTokenOwner(tokenId) notCompromised(tokenId) {
         _setAttribute(tokenId, "github", bytes(github));
+        _validateRequiredFields(tokenId);
+    }
+
+    function deleteAttribute(
+        uint256 tokenId,
+        string calldata key
+    ) external onlyTokenOwner(tokenId) notCompromised(tokenId) {
+        bytes32 keyHash = keccak256(abi.encodePacked(key));
+
+        delete attributes[tokenId][keyHash];
+
+        emit Events.AttributeDeleted(tokenId, keyHash);
     }
 
     /**
@@ -184,4 +252,56 @@ contract IdentityToken is ERC721, IIdentityToken {
 
         emit Events.AttributeSet(tokenId, keyHash, key, value);
     }
+
+    // Identity helpers
+
+    /// @notice Returns true if the address owns any identity token.
+    function hasIdentity(address owner) external view returns (bool) {
+        return balanceOf(owner) > 0;
+    }
+
+    /// @notice Returns full metadata for a given token.
+    function getIdentity(uint256 tokenId) external view returns (DataTypes.Identity memory) {
+        address owner = _requireOwned(tokenId);
+        DataTypes.IdentityState storage state = identityStates[tokenId];
+        return
+            DataTypes.Identity({
+                tokenId: tokenId,
+                owner: owner,
+                isCompromised: state.isCompromised,
+                backupWallet: state.backupWallet,
+                pendingBackupWallet: state.pendingBackupWallet,
+                backupUnlockTime: state.backupUnlockTime,
+                validUntil: state.validUntil,
+                endorsementCount: endorsements[tokenId].length
+            });
+    }
+
+    /// @notice Returns all token IDs owned by an address (0 or 1 given soulbound constraint).
+    function getIdentityByOwner(address owner) external view returns (uint256[] memory) {
+        uint256 tokenId = ownerToTokenId[owner];
+        if (tokenId == 0) {
+            return new uint256[](0);
+        }
+        uint256[] memory result = new uint256[](1);
+        result[0] = tokenId;
+        return result;
+    }
+
+    /// @notice Returns true if the token has at least one active (non-revoked, non-expired) endorsement.
+    function isVerified(uint256 tokenId) external view returns (bool) {
+        DataTypes.Endorsement[] storage list = endorsements[tokenId];
+        for (uint256 i = 0; i < list.length; i++) {
+            DataTypes.Endorsement storage e = list[i];
+            bool active = e.revokedAt == 0 && (e.validUntil == 0 || e.validUntil >= block.timestamp);
+            if (active) return true;
+        }
+        return false;
+    }
+
+    /// @notice Returns true if the token's validUntil is set and has passed.
+    function isExpired(uint256 tokenId) external view returns (bool) {
+        uint256 validUntil = identityStates[tokenId].validUntil;
+        return validUntil != 0 && block.timestamp > validUntil;
+    }
 }

src/interfaces/IIdentityToken.sol

@@ -3,13 +3,15 @@ pragma solidity ^0.8.24;
 
 import { IERC721 } from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
 import { IERC721Metadata } from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
+import { DataTypes } from "../libraries/DataTypes.sol";
 
 interface IIdentityToken is IERC721, IERC721Metadata {
     // -------------------------------------------------------------------------
     // Attribute management
     // -------------------------------------------------------------------------
 
     function setAttribute(uint256 tokenId, string calldata key, bytes calldata value) external;
+    function deleteAttribute(uint256 tokenId, string calldata key) external;
 
     function getAttribute(uint256 tokenId, string calldata key) external view returns (bytes memory);
 
@@ -36,7 +38,13 @@ interface IIdentityToken is IERC721, IERC721Metadata {
     )
         external
         view
-        returns (bool isCompromised, address backupWallet, address pendingBackupWallet, uint256 backupUnlockTime);
+        returns (
+            bool isCompromised,
+            address backupWallet,
+            address pendingBackupWallet,
+            uint256 backupUnlockTime,
+            uint256 validUntil
+        );
 
     function attributes(uint256 tokenId, bytes32 keyHash) external view returns (bytes memory);
 
@@ -53,4 +61,16 @@ interface IIdentityToken is IERC721, IERC721Metadata {
             uint256 validUntil,
             uint256 revokedAt
         );
+
+    // Identity helpers
+
+    function hasIdentity(address owner) external view returns (bool);
+
+    function getIdentity(uint256 tokenId) external view returns (DataTypes.Identity memory);
+
+    function getIdentityByOwner(address owner) external view returns (uint256[] memory);
+
+    function isVerified(uint256 tokenId) external view returns (bool);
+
+    function isExpired(uint256 tokenId) external view returns (bool);
 }

src/libraries/DataTypes.sol

@@ -15,5 +15,17 @@ library DataTypes {
         address backupWallet;
         address pendingBackupWallet;
         uint256 backupUnlockTime;
+        uint256 validUntil;
+    }
+
+    struct Identity {
+        uint256 tokenId;
+        address owner;
+        bool isCompromised;
+        address backupWallet;
+        address pendingBackupWallet;
+        uint256 backupUnlockTime;
+        uint256 validUntil;
+        uint256 endorsementCount;
     }
 }

src/libraries/Errors.sol

@@ -16,4 +16,6 @@ library Errors {
     error AlreadyHasIdentity();
     error DuplicateEndorsement();
     error ArrayLengthMismatch();
+    error MissingName();
+    error MissingContact();
 }

src/libraries/Events.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.20;
 
 library Events {
+    event AttributeDeleted(uint256 indexed tokenId, bytes32 indexed keyHash);
     event AttributeSet(uint256 indexed tokenId, bytes32 indexed keyHash, string key, bytes value);
     event EndorsementGiven(uint256 indexed fromId, uint256 indexed toId, bytes32 typeHash, uint256 expiry);
     event EndorsementRevoked(uint256 indexed fromId, uint256 indexed toId, uint256 index);

src/libraries/Schema.sol

@@ -18,4 +18,6 @@ library Schema {
     bytes32 internal constant GITHUB = keccak256(abi.encodePacked("github"));
     bytes32 internal constant LINKEDIN = keccak256(abi.encodePacked("linkedin"));
     bytes32 internal constant TWITTER = keccak256(abi.encodePacked("twitter"));
+    bytes32 internal constant PHONE = keccak256(abi.encodePacked("phone"));
+    bytes32 internal constant EMAIL = keccak256(abi.encodePacked("email"));
 }