@evvm/testnet-contracts 2.1.3 → 2.2.1

package/contracts/nameService/lib/ErrorsLib.sol

@@ -8,13 +8,7 @@ library ErrorsLib {
     error UserIsNotOwnerOfIdentity();
     error NonceAlreadyUsed();
     error InvalidSignatureOnNameService();
-    /**
-     * @dev Error thrown when a username is not valid.
-     *      0x01 - Username is too short.
-     *      0x02 - Username does not start with a letter.
-     *      0x03 - Username contains invalid characters.
-     */
-    error InvalidUsername(bytes1);
+    error InvalidUsername();
     error UsernameAlreadyRegistered();
     error PreRegistrationNotValid();
     error MakeOfferVerificationFailed();
@@ -24,4 +18,4 @@ library ErrorsLib {
     error EmptyCustomMetadata();
     error InvalidKey();
     error FlushUsernameVerificationFailed();
-}
+}

package/contracts/nameService/lib/IdentityValidation.sol

@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+
+library IdentityValidation{
+    /**
+     * @notice Validates username format according to system rules
+     * @dev Username must be at least 4 characters, start with a letter, and contain only letters/digits
+     * @param username The username string to validate
+     */
+    function isValidUsername(string memory username) internal pure returns (bool) {
+        bytes memory usernameBytes = bytes(username);
+
+        // Check if username length is at least 4 characters
+        if (usernameBytes.length < 4) return false;
+
+        // Check if username begins with a letter
+        if (!_isLetter(usernameBytes[0]))
+            return false;
+
+
+        // Iterate through each character in the username
+        for (uint256 i = 0; i < usernameBytes.length; i++) {
+            // Check if character is not a digit or letter
+            if (!_isDigit(usernameBytes[i]) && !_isLetter(usernameBytes[i])) {
+                return false;
+
+            }
+        }
+        return true;
+    }
+
+    /**
+     * @notice Validates phone number format
+     * @dev Phone number must be 6-19 digits only
+     * @param _phoneNumber The phone number string to validate
+     * @return True if valid phone number format
+     */
+    function isValidPhoneNumberNumber(
+        string memory _phoneNumber
+    ) internal pure returns (bool) {
+        bytes memory _telephoneNumberBytes = bytes(_phoneNumber);
+        if (
+            _telephoneNumberBytes.length < 20 &&
+            _telephoneNumberBytes.length > 5
+        ) {
+            return false;
+        }
+        for (uint256 i = 0; i < _telephoneNumberBytes.length; i++) {
+            if (!_isDigit(_telephoneNumberBytes[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * @notice Validates email address format
+     * @dev Checks for proper email structure: prefix(3+ chars) + @ + domain(3+ chars) + . + TLD(2+ chars)
+     * @param _email The email address string to validate
+     * @return True if valid email format
+     */
+    function isValidEmail(string memory _email) internal pure returns (bool) {
+        bytes memory _emailBytes = bytes(_email);
+        uint256 lengthCount = 0;
+        bytes1 flagVerify = 0x00;
+        for (uint point = 0; point < _emailBytes.length; point++) {
+            //step 1 0x00 prefix
+            if (flagVerify == 0x00) {
+                if (_isOnlyEmailPrefixCharacters(_emailBytes[point])) {
+                    lengthCount++;
+                } else {
+                    if (_isAAt(_emailBytes[point])) {
+                        flagVerify = 0x01;
+                    } else {
+                        return false;
+                    }
+                }
+            }
+
+            //step 2 0x01 count the prefix length
+            if (flagVerify == 0x01) {
+                if (lengthCount < 3) {
+                    return false;
+                } else {
+                    flagVerify = 0x02;
+                    lengthCount = 0;
+                    point++;
+                }
+            }
+
+            //step 3 0x02 domain name
+            if (flagVerify == 0x02) {
+                if (_isLetter(_emailBytes[point])) {
+                    lengthCount++;
+                } else {
+                    if (_isAPoint(_emailBytes[point])) {
+                        flagVerify = 0x03;
+                    } else {
+                        return false;
+                    }
+                }
+            }
+
+            //step 4 0x03 count the domain name length
+            if (flagVerify == 0x03) {
+                if (lengthCount < 3) {
+                    return false;
+                } else {
+                    flagVerify = 0x04;
+                    lengthCount = 0;
+                    point++;
+                }
+            }
+
+            //step 5 0x04 top level domain
+            if (flagVerify == 0x04) {
+                if (_isLetter(_emailBytes[point])) {
+                    lengthCount++;
+                } else {
+                    if (_isAPoint(_emailBytes[point])) {
+                        if (lengthCount < 2) {
+                            return false;
+                        } else {
+                            lengthCount = 0;
+                        }
+                    } else {
+                        return false;
+                    }
+                }
+            }
+        }
+
+        if (flagVerify != 0x04) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /// @dev Checks if a byte represents a digit (0-9)
+    function _isDigit(bytes1 character) private pure returns (bool) {
+        return (character >= 0x30 && character <= 0x39); // ASCII range for digits 0-9
+    }
+
+    /// @dev Checks if a byte represents a letter (A-Z or a-z)
+    function _isLetter(bytes1 character) private pure returns (bool) {
+        return ((character >= 0x41 && character <= 0x5A) ||
+            (character >= 0x61 && character <= 0x7A)); // ASCII ranges for letters A-Z and a-z
+    }
+
+    /// @dev Checks if a byte represents any symbol character
+    function _isAnySimbol(bytes1 character) private pure returns (bool) {
+        return ((character >= 0x21 && character <= 0x2F) || /// @dev includes characters from "!" to "/"
+            (character >= 0x3A && character <= 0x40) || /// @dev includes characters from ":" to "@"
+            (character >= 0x5B && character <= 0x60) || /// @dev includes characters from "[" to "`"
+            (character >= 0x7B && character <= 0x7E)); /// @dev includes characters from "{" to "~"
+    }
+
+    /// @dev Checks if a byte is valid for email prefix (letters, digits, and specific symbols)
+    function _isOnlyEmailPrefixCharacters(
+        bytes1 character
+    ) private pure returns (bool) {
+        return (_isLetter(character) ||
+            _isDigit(character) ||
+            (character >= 0x21 && character <= 0x2F) || /// @dev includes characters from "!" to "/"
+            (character >= 0x3A && character <= 0x3F) || /// @dev includes characters from ":" to "?"
+            (character >= 0x5B && character <= 0x60) || /// @dev includes characters from "[" to "`"
+            (character >= 0x7B && character <= 0x7E)); /// @dev includes characters from "{" to "~"
+    }
+
+    /// @dev Checks if a byte represents a period/dot character (.)
+    function _isAPoint(bytes1 character) private pure returns (bool) {
+        return character == 0x2E;
+    }
+
+    /// @dev Checks if a byte represents an at symbol (@)
+    function _isAAt(bytes1 character) private pure returns (bool) {
+        return character == 0x40;
+    }
+}

package/contracts/nameService/lib/NameServiceStructs.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+
+abstract contract NameServiceStructs {
+    /**
+     * @dev Struct for managing address change proposals with time delay
+     * @param current Currently active address
+     * @param proposal Proposed new address waiting for approval
+     * @param timeToAccept Timestamp when the proposal can be accepted
+     */
+    struct AddressTypeProposal {
+        address current;
+        address proposal;
+        uint256 timeToAccept;
+    }
+
+    /**
+     * @dev Struct for managing uint256 value proposals with time delay
+     * @param current Currently active value
+     * @param proposal Proposed new value waiting for approval
+     * @param timeToAccept Timestamp when the proposal can be accepted
+     */
+    struct UintTypeProposal {
+        uint256 current;
+        uint256 proposal;
+        uint256 timeToAccept;
+    }
+
+    /**
+     * @dev Struct for managing boolean flag changes with time delay
+     * @param flag Current boolean state
+     * @param timeToAcceptChange Timestamp when the flag change can be executed
+     */
+    struct BoolTypeProposal {
+        bool flag;
+        uint256 timeToAcceptChange;
+    }
+
+    /**
+     * @dev Core metadata for each registered identity/username
+     * @param owner Address that owns this identity
+     * @param expireDate Timestamp when the registration expires
+     * @param customMetadataMaxSlots Number of custom metadata entries stored
+     * @param offerMaxSlots Maximum number of offers that have been made
+     * @param flagNotAUsername Flag indicating if this is a pre-registration (0x01) or actual username (0x00)
+     */
+    struct IdentityBaseMetadata {
+        address owner;
+        uint256 expireDate;
+        uint256 customMetadataMaxSlots;
+        uint256 offerMaxSlots;
+        bytes1 flagNotAUsername;
+    }
+
+
+    /**
+     * @dev Metadata for marketplace offers on usernames
+     * @param offerer Address making the offer
+     * @param expireDate Timestamp when the offer expires
+     * @param amount Amount offered in Principal Tokens (after 0.5% marketplace fee deduction)
+     */
+    struct OfferMetadata {
+        address offerer;
+        uint256 expireDate;
+        uint256 amount;
+    }
+}

package/contracts/nameService/lib/SignatureUtils.sol

@@ -1,12 +1,10 @@
 // SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
 // Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
-
-import {SignatureRecover} from "@evvm/testnet-contracts/library/SignatureRecover.sol";
-import {AdvancedStrings} from "@evvm/testnet-contracts/library/AdvancedStrings.sol";
-import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
-
 pragma solidity ^0.8.0;
 
+import {SignatureUtil} from "@evvm/testnet-contracts/library/utils/SignatureUtil.sol";
+import {AdvancedStrings} from "@evvm/testnet-contracts/library/utils/AdvancedStrings.sol";
+
 library SignatureUtils {
     /**
      *  @dev using EIP-191 (https://eips.ethereum.org/EIPS/eip-191) can be used to sign and
@@ -22,13 +20,13 @@ library SignatureUtils {
         bytes memory signature
     ) internal pure returns (bool) {
         return
-            SignatureRecover.signatureVerification(
-                Strings.toString(evvmID),
+            SignatureUtil.verifySignature(
+                evvmID,
                 "preRegistrationUsername",
                 string.concat(
                     AdvancedStrings.bytes32ToString(_hashUsername),
                     ",",
-                    Strings.toString(_nameServiceNonce)
+                    AdvancedStrings.uintToString(_nameServiceNonce)
                 ),
                 signature,
                 signer
@@ -44,15 +42,15 @@ library SignatureUtils {
         bytes memory signature
     ) internal pure returns (bool) {
         return
-            SignatureRecover.signatureVerification(
-                Strings.toString(evvmID),
+            SignatureUtil.verifySignature(
+                evvmID,
                 "registrationUsername",
                 string.concat(
                     _username,
                     ",",
-                    Strings.toString(_clowNumber),
+                    AdvancedStrings.uintToString(_clowNumber),
                     ",",
-                    Strings.toString(_nameServiceNonce)
+                    AdvancedStrings.uintToString(_nameServiceNonce)
                 ),
                 signature,
                 signer
@@ -69,17 +67,17 @@ library SignatureUtils {
         bytes memory signature
     ) internal pure returns (bool) {
         return
-            SignatureRecover.signatureVerification(
-                Strings.toString(evvmID),
+            SignatureUtil.verifySignature(
+                evvmID,
                 "makeOffer",
                 string.concat(
                     _username,
                     ",",
-                    Strings.toString(_dateExpire),
+                    AdvancedStrings.uintToString(_dateExpire),
                     ",",
-                    Strings.toString(_amount),
+                    AdvancedStrings.uintToString(_amount),
                     ",",
-                    Strings.toString(_nameServiceNonce)
+                    AdvancedStrings.uintToString(_nameServiceNonce)
                 ),
                 signature,
                 signer
@@ -95,15 +93,15 @@ library SignatureUtils {
         bytes memory signature
     ) internal pure returns (bool) {
         return
-            SignatureRecover.signatureVerification(
-                Strings.toString(evvmID),
+            SignatureUtil.verifySignature(
+                evvmID,
                 "withdrawOffer",
                 string.concat(
                     _username,
                     ",",
-                    Strings.toString(_offerId),
+                    AdvancedStrings.uintToString(_offerId),
                     ",",
-                    Strings.toString(_nameServiceNonce)
+                    AdvancedStrings.uintToString(_nameServiceNonce)
                 ),
                 signature,
                 signer
@@ -119,15 +117,15 @@ library SignatureUtils {
         bytes memory signature
     ) internal pure returns (bool) {
         return
-            SignatureRecover.signatureVerification(
-                Strings.toString(evvmID),
+            SignatureUtil.verifySignature(
+                evvmID,
                 "acceptOffer",
                 string.concat(
                     _username,
                     ",",
-                    Strings.toString(_offerId),
+                    AdvancedStrings.uintToString(_offerId),
                     ",",
-                    Strings.toString(_nameServiceNonce)
+                    AdvancedStrings.uintToString(_nameServiceNonce)
                 ),
                 signature,
                 signer
@@ -142,13 +140,13 @@ library SignatureUtils {
         bytes memory signature
     ) internal pure returns (bool) {
         return
-            SignatureRecover.signatureVerification(
-                Strings.toString(evvmID),
+            SignatureUtil.verifySignature(
+                evvmID,
                 "renewUsername",
                 string.concat(
                     _username,
                     ",",
-                    Strings.toString(_nameServiceNonce)
+                    AdvancedStrings.uintToString(_nameServiceNonce)
                 ),
                 signature,
                 signer
@@ -164,15 +162,15 @@ library SignatureUtils {
         bytes memory signature
     ) internal pure returns (bool) {
         return
-            SignatureRecover.signatureVerification(
-                Strings.toString(evvmID),
+            SignatureUtil.verifySignature(
+                evvmID,
                 "addCustomMetadata",
                 string.concat(
                     _identity,
                     ",",
                     _value,
                     ",",
-                    Strings.toString(_nameServiceNonce)
+                    AdvancedStrings.uintToString(_nameServiceNonce)
                 ),
                 signature,
                 signer
@@ -188,15 +186,15 @@ library SignatureUtils {
         bytes memory signature
     ) internal pure returns (bool) {
         return
-            SignatureRecover.signatureVerification(
-                Strings.toString(evvmID),
+            SignatureUtil.verifySignature(
+                evvmID,
                 "removeCustomMetadata",
                 string.concat(
                     _username,
                     ",",
-                    Strings.toString(_key),
+                    AdvancedStrings.uintToString(_key),
                     ",",
-                    Strings.toString(_nonce)
+                    AdvancedStrings.uintToString(_nonce)
                 ),
                 signature,
                 signer
@@ -211,10 +209,14 @@ library SignatureUtils {
         bytes memory signature
     ) internal pure returns (bool) {
         return
-            SignatureRecover.signatureVerification(
-                Strings.toString(evvmID),
+            SignatureUtil.verifySignature(
+                evvmID,
                 "flushCustomMetadata",
-                string.concat(_identity, ",", Strings.toString(_nonce)),
+                string.concat(
+                    _identity,
+                    ",",
+                    AdvancedStrings.uintToString(_nonce)
+                ),
                 signature,
                 signer
             );
@@ -228,10 +230,14 @@ library SignatureUtils {
         bytes memory signature
     ) internal pure returns (bool) {
         return
-            SignatureRecover.signatureVerification(
-                Strings.toString(evvmID),
+            SignatureUtil.verifySignature(
+                evvmID,
                 "flushUsername",
-                string.concat(_username, ",", Strings.toString(_nonce)),
+                string.concat(
+                    _username,
+                    ",",
+                    AdvancedStrings.uintToString(_nonce)
+                ),
                 signature,
                 signer
             );