Add ERC: ATF-AI Governance Framework for ESG Compliance

EIPS/eip-8040.md

@@ -0,0 +1,171 @@
+---
+eip: 8040
+title: ESG Tokenization Protocol
+description: ESG-compliant, AI-native asset tokenization with quantum auditability and lifecycle integrity.
+author: Leandro Lemos (@agronetlabs) <[email protected]>
+discussions-to: https://ethereum-magicians.org/t/erc-8040-esg-tokenization-protocol/25846
+status: Draft
+type: Standards Track
+category: ERC
+created: 2025-09-06
+requires: 20, 721, 1155
+---
+
+## Abstract
+
+This ERC defines an AI-native protocol for ESG-compliant asset tokenization, with quantum auditability, compliance-grade metadata, and lifecycle integrity.
+
+## Specification
+
+### Metadata Structure
+
+Tokens MUST expose a metadata JSON with the following minimum fields:
+
+
+```json
+{
+  "standard": "ERC-ESG/1.0",
+  "category": "carbon",
+  "geo": "BR-RS",
+  "carbon_value": 12.5,
+  "cycle": "2025-Q3",
+  "digest": "sha3-512:...",
+  "physical_id": "seal:XYZ123",
+  "attestation": {
+    "atf_digest": "sha3-512:...",
+    "signer": "did:atf:ai:..."
+  },
+  "status": "issued|audited|retired",
+  "evidence": "cid:Qm..."
+}
+```
+
+### Smart Contract Interface
+
+Contracts implementing this standard MUST support the following interface:
+
+```solidity
+
+pragma solidity ^0.8.0;
+
+interface IERC8040 {
+    /// @notice Metadata structure for ESG tokens
+    /// @dev All digest fields use bytes to support SHA3-512 (64 bytes)
+    struct Metadata {
+        string standard;
+        string category;
+        string geo;
+        uint256 carbon_value;
+        string cycle;
+        bytes digest;  // SHA3-512 digest (64 bytes)
+        string physical_id;
+        Attestation attestation;
+        string status;
+        string evidence;
+    }
+
+    /// @notice Attestation structure for AI-native validation
+    /// @dev atf_digest uses bytes to support SHA3-512 (64 bytes)
+    struct Attestation {
+        bytes atf_digest;  // SHA3-512 attestation digest (64 bytes)
+        string signer;
+    }
+
+    /// @notice Mints a new ESG token with provided metadata
+    /// @param metadata The ESG metadata structure
+    /// @return tokenId The ID of the newly minted token
+    function mintESGToken(Metadata memory metadata) external returns (uint256 tokenId);
+
+    /// @notice Audits an existing ESG token
+    /// @param tokenId The token to audit
+    /// @param auditDigest SHA3-512 digest of the audit report (64 bytes)
+    function auditESGToken(uint256 tokenId, bytes memory auditDigest) external;
+
+    /// @notice Retires an ESG token permanently
+    /// @param tokenId The token to retire
+    /// @param reason Human-readable retirement reason
+    function retireESGToken(uint256 tokenId, string memory reason) external;
+
+    /// @notice Returns the ESG metadata URI for a token
+    /// @param tokenId The token ID
+    /// @return The URI string pointing to off-chain metadata
+    function esgURI(uint256 tokenId) external view returns (string memory);
+
+    /// @notice Returns the complete on-chain metadata for a token
+    /// @param tokenId The token ID
+    /// @return The complete Metadata structure
+    function getMetadata(uint256 tokenId) external view returns (Metadata memory);
+
+    /// @notice Emitted when a new ESG token is minted
+    /// @param tokenId The ID of the minted token
+    /// @param category The ESG category (e.g., "carbon")
+    /// @param geo Geographic identifier (e.g., "BR-RS")
+    event Minted(uint256 indexed tokenId, string category, string geo);
+
+    /// @notice Emitted when a token is attested by AI validator
+    /// @param tokenId The ID of the attested token
+    /// @param atfDigest SHA3-512 digest of the attestation (64 bytes)
+    /// @param esgURI The URI of the ESG metadata
+    event Attested(uint256 indexed tokenId, bytes atfDigest, string esgURI);
+
+    /// @notice Emitted when a token is permanently retired
+    /// @param tokenId The ID of the retired token
+    /// @param timestamp The retirement timestamp
+    /// @param reason Human-readable retirement reason
+    event Retired(uint256 indexed tokenId, uint256 timestamp, string reason);
+}
+```
+
+### JSON-RPC Example
+
+```json
+
+{
+  "method": "eth_call",
+  "params": [
+    {
+      "to": "0xContractAddress",
+      "data": "0x..."
+    }
+  ],
+  "example_metadata": {
+    "category": "carbon",
+    "geo": "BR-RS",
+    "carbon_value": 12.5,
+    "digest": "sha3-512:abc123def456...",
+    "attestation": {
+      "atf_digest": "sha3-512:xyz789...",
+      "signer": "did:atf:ai:validator-001"
+    }
+  }
+}
+```
+
+### Mapping & Compatibility
+
+- [ERC-20](./eip-20.md): Each unit represents a standardized fraction (e.g., 1e18 = 1 tCO2e).
+- [ERC-721](./eip-721.md): Single credit with unique esgURI and immutable metadata.
+- [ERC-1155](./eip-1155.md): Homogeneous batch with common URI, metadata, and fungible amounts.
+
+## Rationale
+
+- **Deterministic flows**: Lifecycle follows strict state transitions (issued → audited → retired).
+- **Immutable metadata**: SHA3-512 digest ensures tamper-proof records with 512-bit security.
+- **Machine-verifiable audit trails**: ATF-AI validates compliance deterministically.
+- **Post-quantum readiness**: SHA3-512 hash functions provide quantum-resistant cryptography.
+- **Full hash storage**: Using bytes instead of bytes32 allows complete SHA3-512 digest storage (64 bytes).
+
+## Security Considerations
+
+1. **Metadata immutability**: All metadata fields MUST be cryptographically sealed after minting.
+2. **Zero-trust validation**: ATF-AI provides deterministic validation; all attestations are timestamped.
+3. **Digest integrity**: SHA3-512 (64 bytes) ensures audit-trail integrity. Implementations MUST use bytes type to store complete 512-bit digests.
+4. **Post-quantum cryptography**: Hash functions and signature schemes MUST be quantum-resistant. SHA3-512 provides 512-bit security suitable for post-quantum scenarios.
+5. **Irreversible retirement**: Once retired, tokens cannot be reactivated.
+6. **Physical seal validation**: On-chain digest MUST match physical seal cryptographic hash.
+7. **Input validation**: All off-chain documents MUST be hashed using SHA3-512 and publicly referenced on-chain.
+8. **Hash truncation prevention**: Implementations MUST NOT truncate SHA3-512 digests. The bytes type MUST be used instead of bytes32 to prevent loss of cryptographic security.
+
+## Copyright
+
+Copyright and related rights waived via CC0-1.0.

README.md

@@ -1,5 +1,4 @@
-# Ethereum Improvement Proposals (EIPs)
-
+# EIPs Ethereum Improvement Proposals
 > **_ATTENTION_**: The EIPs repository has recently [undergone](https://github.com/ethereum/EIPs/pull/7206) a separation of ERCs and EIPs. ERCs are now accessible at [https://github.com/ethereum/ercs](https://github.com/ethereum/ercs). All new ERCs and updates to existing ones must be directed at this new repository. The editors apologize for this inconvenience.
 
 The goal of the EIP project is to standardize and provide high-quality documentation for Ethereum itself and conventions built upon it. This repository tracks past and ongoing improvements to Ethereum in the form of Ethereum Improvement Proposals (EIPs). [EIP-1](https://eips.ethereum.org/EIPS/eip-1) governs how EIPs are published.