@aixyz/erc-8004 0.0.6

package/contracts/ReputationRegistryUpgradeable.sol

@@ -0,0 +1,386 @@
+// As copied from https://github.com/erc-8004/erc-8004-contracts/blob/093d7b91eb9c22048d411896ed397d695742a5f8/contracts/ReputationRegistryUpgradeable.sol
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+interface IIdentityRegistry {
+    function isAuthorizedOrOwner(address spender, uint256 agentId) external view returns (bool);
+}
+
+contract ReputationRegistryUpgradeable is OwnableUpgradeable, UUPSUpgradeable {
+
+    int128 private constant MAX_ABS_VALUE = 1e38;
+
+    event NewFeedback(
+        uint256 indexed agentId,
+        address indexed clientAddress,
+        uint64 feedbackIndex,
+        int128 value,
+        uint8 valueDecimals,
+        string indexed indexedTag1,
+        string tag1,
+        string tag2,
+        string endpoint,
+        string feedbackURI,
+        bytes32 feedbackHash
+    );
+
+    event FeedbackRevoked(
+        uint256 indexed agentId,
+        address indexed clientAddress,
+        uint64 indexed feedbackIndex
+    );
+
+    event ResponseAppended(
+        uint256 indexed agentId,
+        address indexed clientAddress,
+        uint64 feedbackIndex,
+        address indexed responder,
+        string responseURI,
+        bytes32 responseHash
+    );
+
+    struct Feedback {
+        int128 value;          // 16 bytes
+        uint8 valueDecimals;   // 1 byte  (packed with value + isRevoked)
+        bool isRevoked;        // 1 byte  (packed with value + valueDecimals)
+        string tag1;
+        string tag2;
+    }
+
+    /// @dev Identity registry address stored at slot 0 (matches MinimalUUPS)
+    address private _identityRegistry;
+
+    /// @custom:storage-location erc7201:erc8004.reputation.registry
+    struct ReputationRegistryStorage {
+        // agentId => clientAddress => feedbackIndex => Feedback (1-indexed)
+        mapping(uint256 => mapping(address => mapping(uint64 => Feedback))) _feedback;
+        // agentId => clientAddress => last feedback index
+        mapping(uint256 => mapping(address => uint64)) _lastIndex;
+        // agentId => clientAddress => feedbackIndex => responder => response count
+        mapping(uint256 => mapping(address => mapping(uint64 => mapping(address => uint64)))) _responseCount;
+        // Track all unique responders for each feedback
+        mapping(uint256 => mapping(address => mapping(uint64 => address[]))) _responders;
+        mapping(uint256 => mapping(address => mapping(uint64 => mapping(address => bool)))) _responderExists;
+        // Track all unique clients that have given feedback for each agent
+        mapping(uint256 => address[]) _clients;
+        mapping(uint256 => mapping(address => bool)) _clientExists;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("erc8004.reputation.registry.2")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant REPUTATION_REGISTRY_STORAGE_LOCATION =
+    0xa03d7693f2b3746b2d03f163c788147b71aa82854399a21fdf4de143ba778300;
+
+    function _getReputationRegistryStorage() private pure returns (ReputationRegistryStorage storage $) {
+        assembly {
+            $.slot := REPUTATION_REGISTRY_STORAGE_LOCATION
+        }
+    }
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(address identityRegistry_) public reinitializer(2) onlyOwner {
+        require(identityRegistry_ != address(0), "bad identity");
+        _identityRegistry = identityRegistry_;
+    }
+
+    function getIdentityRegistry() external view returns (address) {
+        return _identityRegistry;
+    }
+
+    function giveFeedback(
+        uint256 agentId,
+        int128 value,
+        uint8 valueDecimals,
+        string calldata tag1,
+        string calldata tag2,
+        string calldata endpoint,
+        string calldata feedbackURI,
+        bytes32 feedbackHash
+    ) external {
+        require(valueDecimals <= 18, "too many decimals");
+        require(value >= -MAX_ABS_VALUE && value <= MAX_ABS_VALUE, "value too large");
+
+        // SECURITY: Prevent self-feedback from owner and operators
+        // Also reverts with ERC721NonexistentToken if agent doesn't exist
+        require(!IIdentityRegistry(_identityRegistry).isAuthorizedOrOwner(msg.sender, agentId), "Self-feedback not allowed");
+
+        ReputationRegistryStorage storage $ = _getReputationRegistryStorage();
+
+        // Increment and get current index (1-indexed)
+        uint64 currentIndex = ++$._lastIndex[agentId][msg.sender];
+
+        // Store feedback
+        $._feedback[agentId][msg.sender][currentIndex] = Feedback({
+            value: value,
+            valueDecimals: valueDecimals,
+            tag1: tag1,
+            tag2: tag2,
+            isRevoked: false
+        });
+
+        // track new client
+        if (!$._clientExists[agentId][msg.sender]) {
+            $._clients[agentId].push(msg.sender);
+            $._clientExists[agentId][msg.sender] = true;
+        }
+
+        emit NewFeedback(agentId, msg.sender, currentIndex, value, valueDecimals, tag1, tag1, tag2, endpoint, feedbackURI, feedbackHash);
+    }
+
+    function revokeFeedback(uint256 agentId, uint64 feedbackIndex) external {
+        require(feedbackIndex > 0, "index must be > 0");
+        ReputationRegistryStorage storage $ = _getReputationRegistryStorage();
+        require(feedbackIndex <= $._lastIndex[agentId][msg.sender], "index out of bounds");
+        require(!$._feedback[agentId][msg.sender][feedbackIndex].isRevoked, "Already revoked");
+
+        $._feedback[agentId][msg.sender][feedbackIndex].isRevoked = true;
+        emit FeedbackRevoked(agentId, msg.sender, feedbackIndex);
+    }
+
+    function appendResponse(
+        uint256 agentId,
+        address clientAddress,
+        uint64 feedbackIndex,
+        string calldata responseURI,
+        bytes32 responseHash
+    ) external {
+        require(feedbackIndex > 0, "index must be > 0");
+        require(bytes(responseURI).length > 0, "Empty URI");
+        ReputationRegistryStorage storage $ = _getReputationRegistryStorage();
+        require(feedbackIndex <= $._lastIndex[agentId][clientAddress], "index out of bounds");
+
+        // Track new responder
+        if (!$._responderExists[agentId][clientAddress][feedbackIndex][msg.sender]) {
+            $._responders[agentId][clientAddress][feedbackIndex].push(msg.sender);
+            $._responderExists[agentId][clientAddress][feedbackIndex][msg.sender] = true;
+        }
+
+        // Increment response count for this responder
+        $._responseCount[agentId][clientAddress][feedbackIndex][msg.sender]++;
+
+        emit ResponseAppended(agentId, clientAddress, feedbackIndex, msg.sender, responseURI, responseHash);
+    }
+
+    function getLastIndex(uint256 agentId, address clientAddress) external view returns (uint64) {
+        ReputationRegistryStorage storage $ = _getReputationRegistryStorage();
+        return $._lastIndex[agentId][clientAddress];
+    }
+
+    function readFeedback(uint256 agentId, address clientAddress, uint64 feedbackIndex)
+    external
+    view
+    returns (int128 value, uint8 valueDecimals, string memory tag1, string memory tag2, bool isRevoked)
+    {
+        ReputationRegistryStorage storage $ = _getReputationRegistryStorage();
+        require(feedbackIndex > 0, "index must be > 0");
+        require(feedbackIndex <= $._lastIndex[agentId][clientAddress], "index out of bounds");
+        Feedback storage f = $._feedback[agentId][clientAddress][feedbackIndex];
+        return (f.value, f.valueDecimals, f.tag1, f.tag2, f.isRevoked);
+    }
+
+    function getSummary(
+        uint256 agentId,
+        address[] calldata clientAddresses,
+        string calldata tag1,
+        string calldata tag2
+    ) external view returns (uint64 count, int128 summaryValue, uint8 summaryValueDecimals) {
+
+        ReputationRegistryStorage storage $ = _getReputationRegistryStorage();
+        address[] memory clientList;
+        if (clientAddresses.length > 0) {
+            clientList = clientAddresses;
+        } else {
+            revert("clientAddresses required");
+        }
+
+        bytes32 emptyHash = keccak256(bytes(""));
+        bytes32 tag1Hash = keccak256(bytes(tag1));
+        bytes32 tag2Hash = keccak256(bytes(tag2));
+
+        // WAD: 18 decimal fixed-point precision for internal math
+        int256 sum;
+
+        // Track frequency of each valueDecimals (0-18, anything >18 treated as 18)
+        uint64[19] memory decimalCounts;
+
+        for (uint256 i; i < clientList.length; i++) {
+            uint64 lastIdx = $._lastIndex[agentId][clientList[i]];
+            for (uint64 j = 1; j <= lastIdx; j++) {
+                Feedback storage fb = $._feedback[agentId][clientList[i]][j];
+                if (fb.isRevoked) continue;
+                if (emptyHash != tag1Hash &&
+                    tag1Hash != keccak256(bytes(fb.tag1))) continue;
+                if (emptyHash != tag2Hash &&
+                    tag2Hash != keccak256(bytes(fb.tag2))) continue;
+
+                // Normalize to 18 decimals (WAD)
+                // `valueDecimals` is bounded to <= 18 on write; keep math signed.
+                int256 factor = int256(10 ** uint256(18 - fb.valueDecimals));
+                int256 normalized = fb.value * factor;
+                decimalCounts[fb.valueDecimals]++;
+
+                sum += normalized;
+                count++;
+            }
+        }
+
+        if (count == 0) {
+            return (0, 0, 0);
+        }
+
+        // Find mode (most frequent valueDecimals)
+        uint8 modeDecimals;
+        uint64 maxCount;
+        for (uint8 d; d <= 18; d++) {
+            if (decimalCounts[d] > maxCount) {
+                maxCount = decimalCounts[d];
+                modeDecimals = d;
+            }
+        }
+
+        // Calculate average in WAD, then scale to mode precision
+        int256 avgWad = sum / int256(uint256(count));
+        summaryValue = int128(avgWad / int256(10 ** uint256(18 - modeDecimals)));
+        summaryValueDecimals = modeDecimals;
+    }
+
+    function readAllFeedback(
+        uint256 agentId,
+        address[] calldata clientAddresses,
+        string calldata tag1,
+        string calldata tag2,
+        bool includeRevoked
+    ) external view returns (
+        address[] memory clients,
+        uint64[] memory feedbackIndexes,
+        int128[] memory values,
+        uint8[] memory valueDecimals,
+        string[] memory tag1s,
+        string[] memory tag2s,
+        bool[] memory revokedStatuses
+    ) {
+        ReputationRegistryStorage storage $ = _getReputationRegistryStorage();
+        address[] memory clientList;
+        if (clientAddresses.length > 0) {
+            clientList = clientAddresses;
+        } else {
+            clientList = $._clients[agentId];
+        }
+
+        // First pass: count matching feedback
+        bytes32 emptyHash = keccak256(bytes(""));
+        bytes32 tag1Hash = keccak256(bytes(tag1));
+        bytes32 tag2Hash = keccak256(bytes(tag2));
+        uint256 totalCount;
+        for (uint256 i; i < clientList.length; i++) {
+            uint64 lastIdx = $._lastIndex[agentId][clientList[i]];
+            for (uint64 j = 1; j <= lastIdx; j++) {
+                Feedback storage fb = $._feedback[agentId][clientList[i]][j];
+                if (!includeRevoked && fb.isRevoked) continue;
+                if (emptyHash != tag1Hash &&
+                    tag1Hash != keccak256(bytes(fb.tag1))) continue;
+                if (emptyHash != tag2Hash &&
+                    tag2Hash != keccak256(bytes(fb.tag2))) continue;
+                totalCount++;
+            }
+        }
+
+        // Initialize arrays
+        clients = new address[](totalCount);
+        feedbackIndexes = new uint64[](totalCount);
+        values = new int128[](totalCount);
+        valueDecimals = new uint8[](totalCount);
+        tag1s = new string[](totalCount);
+        tag2s = new string[](totalCount);
+        revokedStatuses = new bool[](totalCount);
+
+        // Second pass: populate arrays
+        uint256 idx;
+        for (uint256 i; i < clientList.length; i++) {
+            uint64 lastIdx = $._lastIndex[agentId][clientList[i]];
+            for (uint64 j = 1; j <= lastIdx; j++) {
+                Feedback storage fb = $._feedback[agentId][clientList[i]][j];
+                if (!includeRevoked && fb.isRevoked) continue;
+                if (emptyHash != tag1Hash &&
+                    tag1Hash != keccak256(bytes(fb.tag1))) continue;
+                if (emptyHash != tag2Hash &&
+                    tag2Hash != keccak256(bytes(fb.tag2))) continue;
+
+                clients[idx] = clientList[i];
+                feedbackIndexes[idx] = j;
+                values[idx] = fb.value;
+                valueDecimals[idx] = fb.valueDecimals;
+                tag1s[idx] = fb.tag1;
+                tag2s[idx] = fb.tag2;
+                revokedStatuses[idx] = fb.isRevoked;
+                idx++;
+            }
+        }
+    }
+
+    function getResponseCount(
+        uint256 agentId,
+        address clientAddress,
+        uint64 feedbackIndex,
+        address[] calldata responders
+    ) external view returns (uint64 count) {
+        ReputationRegistryStorage storage $ = _getReputationRegistryStorage();
+        if (clientAddress == address(0)) {
+            // Count all responses for all clients
+            address[] memory clients = $._clients[agentId];
+            for (uint256 i; i < clients.length; i++) {
+                uint64 lastIdx = $._lastIndex[agentId][clients[i]];
+                for (uint64 j = 1; j <= lastIdx; j++) {
+                    count += _countResponses(agentId, clients[i], j, responders);
+                }
+            }
+        } else if (feedbackIndex == 0) {
+            // Count all responses for specific clientAddress
+            uint64 lastIdx = $._lastIndex[agentId][clientAddress];
+            for (uint64 j = 1; j <= lastIdx; j++) {
+                count += _countResponses(agentId, clientAddress, j, responders);
+            }
+        } else {
+            // Count responses for specific clientAddress and feedbackIndex
+            count = _countResponses(agentId, clientAddress, feedbackIndex, responders);
+        }
+    }
+
+    function _countResponses(
+        uint256 agentId,
+        address clientAddress,
+        uint64 feedbackIndex,
+        address[] calldata responders
+    ) internal view returns (uint64 count) {
+        ReputationRegistryStorage storage $ = _getReputationRegistryStorage();
+        if (responders.length == 0) {
+            // Count from all responders
+            address[] memory allResponders = $._responders[agentId][clientAddress][feedbackIndex];
+            for (uint256 k; k < allResponders.length; k++) {
+                count += $._responseCount[agentId][clientAddress][feedbackIndex][allResponders[k]];
+            }
+        } else {
+            // Count from specified responders
+            for (uint256 k; k < responders.length; k++) {
+                count += $._responseCount[agentId][clientAddress][feedbackIndex][responders[k]];
+            }
+        }
+    }
+
+    function getClients(uint256 agentId) external view returns (address[] memory) {
+        ReputationRegistryStorage storage $ = _getReputationRegistryStorage();
+        return $._clients[agentId];
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+
+    function getVersion() external pure returns (string memory) {
+        return "2.0.0";
+    }
+}

package/contracts/ValidationRegistryUpgradeable.sol

@@ -0,0 +1,198 @@
+// As copied from https://github.com/erc-8004/erc-8004-contracts/blob/093d7b91eb9c22048d411896ed397d695742a5f8/contracts/ValidationRegistryUpgradeable.sol
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+interface IIdentityRegistry {
+    function ownerOf(uint256 tokenId) external view returns (address);
+    function getApproved(uint256 tokenId) external view returns (address);
+    function isApprovedForAll(address owner, address operator) external view returns (bool);
+}
+
+contract ValidationRegistryUpgradeable is OwnableUpgradeable, UUPSUpgradeable {
+    event ValidationRequest(
+        address indexed validatorAddress,
+        uint256 indexed agentId,
+        string requestURI,
+        bytes32 indexed requestHash
+    );
+
+    event ValidationResponse(
+        address indexed validatorAddress,
+        uint256 indexed agentId,
+        bytes32 indexed requestHash,
+        uint8 response,
+        string responseURI,
+        bytes32 responseHash,
+        string tag
+    );
+
+    struct ValidationStatus {
+        address validatorAddress;
+        uint256 agentId;
+        uint8 response;       // 0..100
+        bytes32 responseHash;
+        string tag;
+        uint256 lastUpdate;
+        bool hasResponse;
+    }
+
+    /// @dev Identity registry address stored at slot 0 (matches MinimalUUPS)
+    address private _identityRegistry;
+
+    /// @custom:storage-location erc7201:erc8004.validation.registry
+    struct ValidationRegistryStorage {
+        // requestHash => validation status
+        mapping(bytes32 => ValidationStatus) validations;
+        // agentId => list of requestHashes
+        mapping(uint256 => bytes32[]) _agentValidations;
+        // validatorAddress => list of requestHashes
+        mapping(address => bytes32[]) _validatorRequests;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("erc8004.validation.registry")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant VALIDATION_REGISTRY_STORAGE_LOCATION =
+    0x21543a2dd0df813994fbf82c69c61d1aafcdce183d68d2ef40068bdce1481100;
+
+    function _getValidationRegistryStorage() private pure returns (ValidationRegistryStorage storage $) {
+        assembly {
+            $.slot := VALIDATION_REGISTRY_STORAGE_LOCATION
+        }
+    }
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(address identityRegistry_) public reinitializer(2) onlyOwner {
+        require(identityRegistry_ != address(0), "bad identity");
+        _identityRegistry = identityRegistry_;
+    }
+
+    function getIdentityRegistry() external view returns (address) {
+        return _identityRegistry;
+    }
+
+    function validationRequest(
+        address validatorAddress,
+        uint256 agentId,
+        string calldata requestURI,
+        bytes32 requestHash
+    ) external {
+        ValidationRegistryStorage storage $ = _getValidationRegistryStorage();
+        require(validatorAddress != address(0), "bad validator");
+        require($.validations[requestHash].validatorAddress == address(0), "exists");
+
+        // Check permission: caller must be owner or approved operator
+        IIdentityRegistry registry = IIdentityRegistry(_identityRegistry);
+        address owner = registry.ownerOf(agentId);
+        require(
+            msg.sender == owner ||
+            registry.isApprovedForAll(owner, msg.sender) ||
+            registry.getApproved(agentId) == msg.sender,
+            "Not authorized"
+        );
+
+        $.validations[requestHash] = ValidationStatus({
+            validatorAddress: validatorAddress,
+            agentId: agentId,
+            response: 0,
+            responseHash: bytes32(0),
+            tag: "",
+            lastUpdate: block.timestamp,
+            hasResponse: false
+        });
+
+        // Track for lookups
+        $._agentValidations[agentId].push(requestHash);
+        $._validatorRequests[validatorAddress].push(requestHash);
+
+        emit ValidationRequest(validatorAddress, agentId, requestURI, requestHash);
+    }
+
+    function validationResponse(
+        bytes32 requestHash,
+        uint8 response,
+        string calldata responseURI,
+        bytes32 responseHash,
+        string calldata tag
+    ) external {
+        ValidationRegistryStorage storage $ = _getValidationRegistryStorage();
+        ValidationStatus storage s = $.validations[requestHash];
+        require(s.validatorAddress != address(0), "unknown");
+        require(msg.sender == s.validatorAddress, "not validator");
+        require(response <= 100, "resp>100");
+        s.response = response;
+        s.responseHash = responseHash;
+        s.tag = tag;
+        s.lastUpdate = block.timestamp;
+        s.hasResponse = true;
+        emit ValidationResponse(s.validatorAddress, s.agentId, requestHash, response, responseURI, responseHash, tag);
+    }
+
+    function getValidationStatus(bytes32 requestHash)
+    external
+    view
+    returns (address validatorAddress, uint256 agentId, uint8 response, bytes32 responseHash, string memory tag, uint256 lastUpdate)
+    {
+        ValidationRegistryStorage storage $ = _getValidationRegistryStorage();
+        ValidationStatus memory s = $.validations[requestHash];
+        require(s.validatorAddress != address(0), "unknown");
+        return (s.validatorAddress, s.agentId, s.response, s.responseHash, s.tag, s.lastUpdate);
+    }
+
+    function getSummary(
+        uint256 agentId,
+        address[] calldata validatorAddresses,
+        string calldata tag
+    ) external view returns (uint64 count, uint8 avgResponse) {
+        ValidationRegistryStorage storage $ = _getValidationRegistryStorage();
+        uint256 totalResponse;
+
+        bytes32[] storage requestHashes = $._agentValidations[agentId];
+
+        for (uint256 i; i < requestHashes.length; i++) {
+            ValidationStatus storage s = $.validations[requestHashes[i]];
+
+            // Filter by validator if specified
+            bool matchValidator = (validatorAddresses.length == 0);
+            if (!matchValidator) {
+                for (uint256 j; j < validatorAddresses.length; j++) {
+                    if (s.validatorAddress == validatorAddresses[j]) {
+                        matchValidator = true;
+                        break;
+                    }
+                }
+            }
+
+            // Filter by tag (empty string means no filter)
+            bool matchTag = (bytes(tag).length == 0) || (keccak256(bytes(s.tag)) == keccak256(bytes(tag)));
+
+            if (matchValidator && matchTag && s.hasResponse) {
+                totalResponse += s.response;
+                count++;
+            }
+        }
+
+        avgResponse = count > 0 ? uint8(totalResponse / count) : 0;
+    }
+
+    function getAgentValidations(uint256 agentId) external view returns (bytes32[] memory) {
+        ValidationRegistryStorage storage $ = _getValidationRegistryStorage();
+        return $._agentValidations[agentId];
+    }
+
+    function getValidatorRequests(address validatorAddress) external view returns (bytes32[] memory) {
+        ValidationRegistryStorage storage $ = _getValidationRegistryStorage();
+        return $._validatorRequests[validatorAddress];
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+
+    function getVersion() external pure returns (string memory) {
+        return "2.0.0";
+    }
+}