Merge 5999900 into 5ab0970

ERCS/erc-7734.md

@@ -0,0 +1,188 @@
+---
+eip: xx
+title: Decentralized Identity Verification (DID) Standard
+description: A standard for decentralized identity verification on the blockchain.
+author: Anushka Yadav <@64anushka>
+discussions-to: https://ethereum-magicians.org/t/discussion-on-decentralized-identity-verification-did-standard/20392
+status: Draft
+type: Standards Track
+category: ERC
+created: 2024-06-26
+---
+
+## Abstract
+
+This proposal introduces a standard for decentralized identity verification (DID) on the Ethereum blockchain. The standard aims to provide a secure, privacy-preserving method for identity verification that can be used by decentralized applications (dApps).
+
+## Motivation
+
+Centralized identity verification methods are often cumbersome, prone to data breaches, and do not give users control over their identity data. Current DID solutions, while innovative, often come with complexity and additional requirements that can be burdensome for dApp developers and users. Our proposal aims to address these issues by providing a straightforward, minimalistic approach to decentralized identity verification. This standard focuses on user control and privacy, ensuring that users can manage their identity information securely without unnecessary overhead. By leveraging cryptographic hashes and events, we provide a transparent, traceable, and efficient method for identity verification. This simplicity encourages wider adoption and integration into various dApps, fostering a more secure and user-centric ecosystem on the Ethereum blockchain.
+
+## Specification
+
+The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 and RFC 8174.
+
+### Interface
+
+```solidity
+pragma solidity ^0.8.0;
+
+interface IDecentralizedIdentity {
+    // Struct to represent an identity
+    struct Identity {
+        address userAddress; // Ethereum address of the user
+        bytes32 identityHash; // Hash of the identity data
+        bytes32[2] verificationHashes; // Hashes used for verifying identity
+        bool isVerified; // Indicates if the identity is verified
+        uint256 timestamp; // Timestamp of identity creation
+    }
+
+    // Event emitted when a new identity is created
+    event IdentityCreated(address indexed userAddress, bytes32 identityHash, uint256 timestamp);
+
+    // Event emitted when an identity is verified
+    event IdentityVerified(address indexed userAddress, bytes32[2] verificationHashes, uint256 timestamp);
+
+    // Event emitted when an identity is revoked
+    event IdentityRevoked(address indexed userAddress, uint256 timestamp);
+
+    // Function to create a new decentralized identity for the caller.
+    // Parameters:
+    // - identityHash: Hash of the identity data.
+    function createIdentity(bytes32 identityHash) external;
+
+    // Function to verify the decentralized identity for the caller.
+    // Parameters:
+    // - verificationHashes: Hashes used for verifying the identity.
+    function verifyIdentity(bytes32[2] calldata verificationHashes) external;
+
+    // Function to revoke the decentralized identity for the caller.
+    function revokeIdentity() external;
+    
+    // Function to retrieve the decentralized identity for a given user address
+    // Parameters:
+    // - userAddress Ethereum address of the user.
+    // Returns:
+    // identity The decentralized identity struct.
+    function getIdentity(address userAddress) external view returns (Identity memory);
+}
+
+```
+
+### Usage
+#### Who Would Want to Implement It
+##### dApp Developers:
+Developers creating decentralized applications that require identity verification can implement this standard to provide users with secure, decentralized identity management.
+
+##### Service Providers: 
+Platforms offering services such as decentralized finance (DeFi), gaming, or social networking can integrate this standard to verify user identities without relying on centralized authorities.
+
+###### Enterprises: 
+Companies looking to integrate blockchain-based identity solutions into their existing systems can use this standard to ensure secure and privacy-preserving identity verification.
+
+##### Developers of Interoperability Solutions: 
+Developers working on cross-platform and cross-blockchain interoperability can implement this standard to enable a unified identity verification mechanism across different systems.
+
+### How It's Supposed to Be Used
+#### Creating an Identity
+
+To create a new decentralized identity, a user calls the createIdentity function with the hash of their identity data. The contract stores this hash and emits the IdentityCreated event. This step ensures that the user's identity is registered on the blockchain.
+
+#### Verifying an Identity
+
+To verify an identity, a user calls the verifyIdentity function with two verification hashes. These hashes could be derived from proofs or attestations. The contract updates the identity's verification status and emits the IdentityVerified event. This process ensures that the identity is verified using off-chain proofs, maintaining privacy and security.
+
+#### Revoking an Identity
+
+If a user wishes to revoke their identity, they can call the revokeIdentity function. The contract marks the identity as not verified and emits the IdentityRevoked event. This feature allows users to manage their identities actively and revoke them if necessary.
+
+#### Retrieving an Identity
+
+Anyone can retrieve the details of a user's identity by calling the getIdentity function with the user's Ethereum address. This function returns the identity details, including whether the identity is verified. This feature allows dApps and services to check the identity status of users securely.
+
+## Differentiation
+
+This proposal distinguishes itself from other DID standards by focusing on a minimalistic approach, emphasizing user control and privacy. Unlike other proposals that might include a broader scope of identity attributes and interactions, this standard keeps the identity structure simple and relies on off-chain mechanisms for detailed identity management and verification. This simplicity encourages wider adoption and integration into various dApps, fostering a more secure and user-centric ecosystem on the Ethereum blockchain.
+
+## Rationale
+
+The design leverages cryptographic hashes to represent identity information, ensuring that sensitive data is not stored directly on the blockchain. The use of verification hashes allows for flexible identity verification mechanisms, and the inclusion of events ensures transparency and traceability.
+
+## Reference Implementation
+
+```solidity
+pragma solidity ^0.8.0;
+
+import "./IDecentralizedIdentity.sol";
+
+contract DecentralizedIdentity is IDecentralizedIdentity {
+    // Mapping to store identities by user address
+    mapping(address => Identity) private identities;
+
+    // Function to create a new decentralized identity for the caller.
+    // Parameters:
+    // - identityHash Hash of the identity data.
+    function createIdentity(bytes32 identityHash) external override {
+        // Ensure identity does not already exist
+        require(identities[msg.sender].userAddress == address(0), "Identity already exists");
+
+        // Create the identity for the caller
+        identities[msg.sender] = Identity({
+            userAddress: msg.sender,
+            identityHash: identityHash,
+            verificationHashes: [bytes32(0), bytes32(0)], // Initialize with empty hashes
+            isVerified: false,
+            timestamp: block.timestamp
+        });
+
+        // Emit event for the creation of a new identity
+        emit IdentityCreated(msg.sender, identityHash, block.timestamp);
+    }
+
+    // Function to verify the decentralized identity for the caller.
+    // Parameters:
+    // - verificationHashes: Hashes used for verifying the identity.
+    function verifyIdentity(bytes32[2] calldata verificationHashes) external override {
+        // Ensure identity exists
+        require(identities[msg.sender].userAddress != address(0), "Identity does not exist");
+
+        // Update verification hashes and mark identity as verified
+        identities[msg.sender].verificationHashes = verificationHashes;
+        identities[msg.sender].isVerified = true;
+
+        // Emit event for the verification of identity
+        emit IdentityVerified(msg.sender, verificationHashes, block.timestamp);
+    }
+
+    // Function to revoke the decentralized identity for the caller.
+    function revokeIdentity() external override {
+        // Ensure identity exists
+        require(identities[msg.sender].userAddress != address(0), "Identity does not exist");
+
+        // Mark identity as not verified
+        identities[msg.sender].isVerified = false;
+
+        // Emit event for the revocation of identity
+        emit IdentityRevoked(msg.sender, block.timestamp);
+    }
+
+    // Function to retrieve the decentralized identity for a given user address
+    // Parameters:
+    // - userAddress Ethereum address of the user.
+    // Returns:
+    // identity The decentralized identity struct.
+    function getIdentity(address userAddress) external view override returns (Identity memory) {
+        return identities[userAddress];
+    }
+}
+```
+
+## Security Considerations
+
+**Secure Hashing**: Ensure that identity and verification hashes are generated using a secure hashing algorithm to prevent collisions and ensure the integrity of the identity data.
+
+**User Control**: Users have control over their identity data, which reduces the risk of unauthorized access and ensures privacy.
+
+## Copyright
+
+Copyright and related rights waived via [CC0](../LICENSE.md).