@towns-protocol/contracts 0.0.416 → 0.0.418

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towns-protocol/contracts",
-  "version": "0.0.416",
+  "version": "0.0.418",
   "scripts": {
     "clean": "forge clean",
     "compile": "forge build",
@@ -33,7 +33,7 @@
     "@layerzerolabs/oapp-evm": "^0.3.2",
     "@openzeppelin/merkle-tree": "^1.0.8",
     "@prb/test": "^0.6.4",
-    "@towns-protocol/prettier-config": "^0.0.416",
+    "@towns-protocol/prettier-config": "^0.0.418",
     "@wagmi/cli": "^2.2.0",
     "forge-std": "github:foundry-rs/forge-std#v1.10.0",
     "prettier": "^3.5.3",
@@ -53,5 +53,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "4bacd8cc3227801de12fea8f031db1983d2fb89a"
+  "gitHead": "735b3a67557584795c76b4b1632da911fcfe3abc"
 }

package/scripts/deployments/diamonds/DeployAppRegistry.s.sol

@@ -19,6 +19,7 @@ import {DeploySpaceFactory} from "../diamonds/DeploySpaceFactory.s.sol";
 import {DeploySimpleAppBeacon} from "../diamonds/DeploySimpleAppBeacon.s.sol";
 import {DeployIdentityRegistry} from "../facets/DeployIdentityRegistry.s.sol";
 import {DeployReputationRegistry} from "../facets/DeployReputationRegistry.s.sol";
+import {DeployValidationRegistry} from "../facets/DeployValidationRegistry.s.sol";
 
 // contracts
 import {Diamond} from "@towns-protocol/diamond/src/Diamond.sol";
@@ -110,6 +111,7 @@ contract DeployAppRegistry is IDiamondInitHelper, DiamondHelper, Deployer {
         facetHelper.add("AppFactoryFacet");
         facetHelper.add("IdentityRegistryFacet");
         facetHelper.add("ReputationRegistryFacet");
+        facetHelper.add("ValidationRegistryFacet");
 
         facetHelper.deployBatch(deployer);
 
@@ -154,6 +156,13 @@ contract DeployAppRegistry is IDiamondInitHelper, DiamondHelper, Deployer {
             DeployReputationRegistry.makeInitData(FEEDBACK_SCHEMA, RESPONSE_SCHEMA)
         );
 
+        facet = facetHelper.getDeployedAddress("ValidationRegistryFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployValidationRegistry.selectors()),
+            facet,
+            DeployValidationRegistry.makeInitData()
+        );
+
         address multiInit = facetHelper.getDeployedAddress("MultiInit");
 
         return
@@ -192,6 +201,9 @@ contract DeployAppRegistry is IDiamondInitHelper, DiamondHelper, Deployer {
             if (facetName.eq("IdentityRegistryFacet")) {
                 addCut(makeCut(facet, FacetCutAction.Add, DeployIdentityRegistry.selectors()));
             }
+            if (facetName.eq("ValidationRegistryFacet")) {
+                addCut(makeCut(facet, FacetCutAction.Add, DeployValidationRegistry.selectors()));
+            }
         }
 
         return baseFacets();

package/scripts/deployments/facets/DeployValidationRegistry.s.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+// contracts
+import {ValidationRegistryFacet} from "src/apps/facets/validation/ValidationRegistryFacet.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+library DeployValidationRegistry {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        uint256 selectorsCount = 6;
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(selectorsCount);
+
+        arr.p(ValidationRegistryFacet.validationRequest.selector);
+        arr.p(ValidationRegistryFacet.validationResponse.selector);
+        arr.p(ValidationRegistryFacet.getValidationStatus.selector);
+        arr.p(ValidationRegistryFacet.getSummary.selector);
+        arr.p(ValidationRegistryFacet.getAgentValidations.selector);
+        arr.p(ValidationRegistryFacet.getValidatorRequests.selector);
+
+        bytes32[] memory selectors_ = arr.asBytes32Array();
+
+        assembly ("memory-safe") {
+            res := selectors_
+        }
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return
+            IDiamond.FacetCut({
+                action: action,
+                facetAddress: facetAddress,
+                functionSelectors: selectors()
+            });
+    }
+
+    function makeInitData() internal pure returns (bytes memory) {
+        return abi.encodeCall(ValidationRegistryFacet.__ValidationRegistryFacet_init, ());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("ValidationRegistryFacet.sol", "");
+    }
+}

package/src/apps/facets/validation/IValidationRegistry.sol

@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+/// @title IValidationRegistryBase
+/// @notice Base interface for validation registry events
+/// @dev Implements ERC-8004 validation event standards for trustless agent verification
+interface IValidationRegistryBase {
+    /// @notice Emitted when an agent requests validation from a validator
+    /// @dev This event is emitted by validationRequest() and enables tracking of all validation requests
+    /// @param validatorAddress The address of the validator smart contract that will perform the validation
+    /// @param agentId The unique identifier of the agent requesting validation (ERC-721 tokenId from Identity Registry)
+    /// @param requestUri The URI pointing to off-chain data containing inputs, outputs, and all information needed for validation
+    /// @param requestHash The KECCAK-256 commitment hash of the request data (optional if requestUri is IPFS)
+    event ValidationRequest(
+        address indexed validatorAddress,
+        uint256 indexed agentId,
+        string requestUri,
+        bytes32 indexed requestHash
+    );
+
+    /// @notice Emitted when a validator responds to a validation request
+    /// @dev This event can be emitted multiple times for the same requestHash to support progressive validation states
+    /// @param validatorAddress The address of the validator providing the response
+    /// @param agentId The unique identifier of the agent being validated
+    /// @param requestHash The hash of the original validation request being responded to
+    /// @param response The validation result (0-100 scale: 0=failed, 100=passed, or intermediate values for spectrum outcomes)
+    /// @param responseUri The URI pointing to off-chain evidence or audit trail of the validation (optional)
+    /// @param responseHash The KECCAK-256 hash of the response data (optional if responseUri is IPFS, use bytes32(0) if not provided)
+    /// @param tag Custom categorization or additional metadata for the validation (optional, e.g., "soft-finality", "hard-finality")
+    event ValidationResponse(
+        address indexed validatorAddress,
+        uint256 indexed agentId,
+        bytes32 indexed requestHash,
+        uint8 response,
+        string responseUri,
+        bytes32 responseHash,
+        bytes32 tag
+    );
+
+    error ValidationRegistry__InvalidValidator();
+    error ValidationRegistry__InvalidAgent();
+    error ValidationRegistry__RequestAlreadyExists();
+    error ValidationRegistry__AgentNotExists();
+    error ValidationRegistry__NotAuthorized();
+    error ValidationRegistry__RequestNotFound();
+    error ValidationRegistry__InvalidResponseScore();
+    error ValidationRegistry__ZeroResponseRequiresMetadata();
+}
+
+/// @title IValidationRegistry
+/// @notice Interface for the ERC-8004 Validation Registry enabling trustless agent verification
+/// @dev This registry enables agents to request verification of their work through various trust models:
+///      stake-secured inference re-execution, zkML verifiers, TEE oracles, or trusted judges.
+///      The identityRegistry address is set at deployment and accessible via getIdentityRegistry().
+///      All validation data is stored on-chain for composability and transparency.
+interface IValidationRegistry is IValidationRegistryBase {
+    /// @notice Request validation of agent work from a validator smart contract
+    /// @dev MUST be called by the owner or operator of the agentId.
+    ///      The requestUri should contain all information needed for validation including inputs and outputs.
+    ///      The requestHash is a KECCAK-256 commitment to the request data (optional if requestUri is IPFS).
+    ///      Emits a ValidationRequest event upon success.
+    /// @param validatorAddress The address of the validator smart contract that will perform the validation (mandatory)
+    /// @param agentId The unique identifier of the agent requesting validation (mandatory, must be validly registered)
+    /// @param requestUri The URI pointing to off-chain validation data (mandatory)
+    /// @param requestHash The KECCAK-256 hash of the request data (mandatory unless requestUri is content-addressable like IPFS)
+    function validationRequest(
+        address validatorAddress,
+        uint256 agentId,
+        string calldata requestUri,
+        bytes32 requestHash
+    ) external;
+
+    /// @notice Submit a validation response for a previously requested validation
+    /// @dev MUST be called by the validatorAddress specified in the original ValidationRequest.
+    ///      Can be called multiple times for the same requestHash to support use cases like
+    ///      progressive validation states or updates to validation status.
+    ///      Stores requestHash, validatorAddress, agentId, response, lastUpdate, and tag on-chain.
+    ///      Emits a ValidationResponse event upon success.
+    /// @param requestHash The hash of the validation request being responded to (mandatory)
+    /// @param response The validation result on a 0-100 scale where 0=failed, 100=passed, or intermediate values (mandatory)
+    /// @param responseUri The URI pointing to off-chain evidence or audit trail (optional, use empty string if not provided)
+    /// @param responseHash The KECCAK-256 hash of the response data (optional if responseUri is IPFS, use bytes32(0) if not provided)
+    /// @param tag Custom categorization or metadata for this validation response (optional, use bytes32(0) if not provided)
+    function validationResponse(
+        bytes32 requestHash,
+        uint8 response,
+        string calldata responseUri,
+        bytes32 responseHash,
+        bytes32 tag
+    ) external;
+
+    /// @notice Retrieve the current validation status for a specific request
+    /// @dev Returns the stored validation data for the given requestHash.
+    ///      If no validation exists, returns zero values.
+    /// @param requestHash The hash of the validation request to query
+    /// @return validatorAddress The address of the validator that provided the response
+    /// @return agentId The unique identifier of the agent that was validated
+    /// @return response The validation result (0-100 scale)
+    /// @return tag The custom tag associated with this validation response
+    /// @return lastUpdate The timestamp of the last validation response update
+    function getValidationStatus(
+        bytes32 requestHash
+    )
+        external
+        view
+        returns (
+            address validatorAddress,
+            uint256 agentId,
+            uint8 response,
+            bytes32 tag,
+            uint256 lastUpdate
+        );
+
+    /// @notice Returns aggregated validation statistics for an agent
+    /// @dev Provides on-chain composable reputation metrics. The agentId parameter is mandatory;
+    ///      validatorAddresses and tag are optional filters to narrow results.
+    ///      Use empty array for validatorAddresses and bytes32(0) for tag to include all validations.
+    /// @param agentId The agent ID to get statistics for (mandatory)
+    /// @param validatorAddresses Array of validator addresses to filter by (optional, use empty array for no filter)
+    /// @param tag The tag to filter by (optional, use bytes32(0) for no filter)
+    /// @return count The total number of validations matching the filters
+    /// @return avgResponse The average validation response across all matching validations (0-100 scale)
+    function getSummary(
+        uint256 agentId,
+        address[] calldata validatorAddresses,
+        bytes32 tag
+    ) external view returns (uint64 count, uint8 avgResponse);
+
+    /// @notice Returns all validation request hashes for a specific agent
+    /// @dev Useful for discovering the complete validation history of an agent.
+    ///      The returned hashes can be used with getValidationStatus() to retrieve full details.
+    /// @param agentId The agent ID to query validation requests for
+    /// @return requestHashes Array of all validation request hashes associated with this agent
+    function getAgentValidations(
+        uint256 agentId
+    ) external view returns (bytes32[] memory requestHashes);
+
+    /// @notice Returns all validation request hashes handled by a specific validator
+    /// @dev Useful for discovering all validations performed by a validator contract.
+    ///      The returned hashes can be used with getValidationStatus() to retrieve full details.
+    /// @param validatorAddress The validator address to query validation requests for
+    /// @return requestHashes Array of all validation request hashes handled by this validator
+    function getValidatorRequests(
+        address validatorAddress
+    ) external view returns (bytes32[] memory requestHashes);
+}

package/src/apps/facets/validation/ValidationRegistryBase.sol

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IValidationRegistryBase} from "./IValidationRegistry.sol";
+
+// libraries
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {ValidationRegistryStorage, ValidationStatus} from "./ValidationRegistryStorage.sol";
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+
+// contracts
+import {ERC721ABase} from "../../../diamond/facets/token/ERC721A/ERC721ABase.sol";
+
+abstract contract ValidationRegistryBase is IValidationRegistryBase, ERC721ABase {
+    using CustomRevert for bytes4;
+    using EnumerableSetLib for EnumerableSetLib.Bytes32Set;
+
+    function _requestValidation(
+        address validatorAddress,
+        uint256 agentId,
+        string calldata requestUri,
+        bytes32 requestHash
+    ) internal {
+        ValidationRegistryStorage.Layout storage $ = ValidationRegistryStorage.getLayout();
+        if ($.validations[requestHash].validatorAddress != address(0))
+            ValidationRegistry__RequestAlreadyExists.selector.revertWith();
+
+        ValidationStatus storage validation = $.validations[requestHash];
+        validation.validatorAddress = validatorAddress;
+        validation.agentId = agentId;
+        validation.lastUpdate = block.timestamp;
+
+        $.requestByAgent[agentId].add(requestHash);
+        $.requestByValidator[validatorAddress].add(requestHash);
+
+        emit ValidationRequest(validatorAddress, agentId, requestUri, requestHash);
+    }
+
+    function _responseValidation(
+        bytes32 requestHash,
+        uint8 response,
+        string calldata responseUri,
+        bytes32 responseHash,
+        bytes32 tag
+    ) internal {
+        ValidationRegistryStorage.Layout storage $ = ValidationRegistryStorage.getLayout();
+        ValidationStatus storage val = $.validations[requestHash];
+        if (val.validatorAddress == address(0))
+            ValidationRegistry__RequestNotFound.selector.revertWith();
+        if (msg.sender != val.validatorAddress)
+            ValidationRegistry__NotAuthorized.selector.revertWith();
+        if (response > 100) ValidationRegistry__InvalidResponseScore.selector.revertWith();
+        if (response == 0 && responseHash == bytes32(0) && tag == bytes32(0)) {
+            ValidationRegistry__ZeroResponseRequiresMetadata.selector.revertWith();
+        }
+
+        val.response = response;
+        val.responseHash = responseHash;
+        val.tag = tag;
+        val.lastUpdate = block.timestamp;
+
+        emit ValidationResponse(
+            val.validatorAddress,
+            val.agentId,
+            requestHash,
+            response,
+            responseUri,
+            responseHash,
+            tag
+        );
+    }
+
+    function _getValidationStatus(
+        bytes32 requestHash
+    ) internal view returns (ValidationStatus storage) {
+        ValidationRegistryStorage.Layout storage $ = ValidationRegistryStorage.getLayout();
+        return $.validations[requestHash];
+    }
+
+    function _getSummary(
+        uint256 agentId,
+        address[] calldata validatorAddresses,
+        bytes32 tag
+    ) internal view returns (uint64 count, uint8 avgResponse) {
+        uint256 totalResponse;
+
+        ValidationRegistryStorage.Layout storage $ = ValidationRegistryStorage.getLayout();
+        EnumerableSetLib.Bytes32Set storage requests = $.requestByAgent[agentId];
+
+        for (uint256 i; i < requests.length(); ++i) {
+            // Fetch the validation status for the current requestHash
+            ValidationStatus storage val = $.validations[requests.at(i)];
+
+            // If no validatorAddresses filter is provided (i.e., length == 0), match any validator.
+            // Otherwise, check if the validatorAddress matches any address in the filter array.
+            bool matchValidator = (validatorAddresses.length == 0);
+            if (!matchValidator) {
+                // Loop through validatorAddresses to see if current validation was made by any provided validator
+                for (uint256 j; j < validatorAddresses.length; ++j) {
+                    if (val.validatorAddress == validatorAddresses[j]) {
+                        matchValidator = true;
+                        break; // Stop searching if a match is found
+                    }
+                }
+            }
+
+            // Tag filtering: If a zero tag is provided (no filtering), any tag matches.
+            // Otherwise, only include validations whose tag matches the requested tag.
+            bool matchTag = (tag == bytes32(0)) || (val.tag == tag);
+
+            // Check if a response has been given: at least one of (response, responseHash, tag) must be non-zero
+            // This distinguishes between "request with no response" and "request with response=0"
+            bool hasResponse = (val.response > 0) ||
+                (val.responseHash != bytes32(0)) ||
+                (val.tag != bytes32(0));
+
+            // Only count responses that matched validator and tag criteria, and have actually been responded to
+            if (matchValidator && matchTag && hasResponse) {
+                totalResponse += val.response; // Add the response value for averaging
+                count++; // Increment the count of included responses
+            }
+        }
+
+        avgResponse = count > 0 ? uint8(totalResponse / count) : 0;
+    }
+
+    function _getAgentValidations(
+        uint256 agentId
+    ) internal view returns (bytes32[] memory requestHashes) {
+        ValidationRegistryStorage.Layout storage $ = ValidationRegistryStorage.getLayout();
+        return $.requestByAgent[agentId].values();
+    }
+
+    function _getValidatorRequests(
+        address validatorAddress
+    ) internal view returns (bytes32[] memory requestHashes) {
+        ValidationRegistryStorage.Layout storage $ = ValidationRegistryStorage.getLayout();
+        return $.requestByValidator[validatorAddress].values();
+    }
+
+    /// @dev Check validation request inputs
+    function _verifyValidationRequest(address validatorAddress, uint256 agentId) internal view {
+        if (validatorAddress == address(0))
+            ValidationRegistry__InvalidValidator.selector.revertWith();
+        if (agentId == 0) ValidationRegistry__InvalidAgent.selector.revertWith();
+        if (!_exists(agentId)) ValidationRegistry__AgentNotExists.selector.revertWith();
+
+        address owner = _ownerOf(agentId);
+        if (
+            msg.sender != owner &&
+            !_isApprovedForAll(owner, msg.sender) &&
+            msg.sender != _getApproved(agentId)
+        ) {
+            ValidationRegistry__NotAuthorized.selector.revertWith();
+        }
+    }
+}

package/src/apps/facets/validation/ValidationRegistryFacet.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IValidationRegistry} from "./IValidationRegistry.sol";
+
+// libraries
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {ValidationStatus} from "./ValidationRegistryStorage.sol";
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {ValidationRegistryBase} from "./ValidationRegistryBase.sol";
+
+contract ValidationRegistryFacet is IValidationRegistry, Facet, ValidationRegistryBase {
+    using CustomRevert for bytes4;
+
+    function __ValidationRegistryFacet_init() external onlyInitializing {
+        __ValidationRegistryFacet_init_unchained();
+    }
+
+    function __ValidationRegistryFacet_init_unchained() internal {
+        _addInterface(type(IValidationRegistry).interfaceId);
+    }
+
+    /// @inheritdoc IValidationRegistry
+    function validationRequest(
+        address validatorAddress,
+        uint256 agentId,
+        string calldata requestUri,
+        bytes32 requestHash
+    ) external {
+        _verifyValidationRequest(validatorAddress, agentId);
+        _requestValidation(validatorAddress, agentId, requestUri, requestHash);
+    }
+
+    /// @inheritdoc IValidationRegistry
+    function validationResponse(
+        bytes32 requestHash,
+        uint8 response,
+        string calldata responseUri,
+        bytes32 responseHash,
+        bytes32 tag
+    ) external {
+        _responseValidation(requestHash, response, responseUri, responseHash, tag);
+    }
+
+    /// @inheritdoc IValidationRegistry
+    function getValidationStatus(
+        bytes32 requestHash
+    )
+        external
+        view
+        returns (
+            address validatorAddress,
+            uint256 agentId,
+            uint8 response,
+            bytes32 tag,
+            uint256 lastUpdate
+        )
+    {
+        ValidationStatus memory val = _getValidationStatus(requestHash);
+        return (val.validatorAddress, val.agentId, val.response, val.tag, val.lastUpdate);
+    }
+
+    /// @inheritdoc IValidationRegistry
+    function getSummary(
+        uint256 agentId,
+        address[] calldata validatorAddresses,
+        bytes32 tag
+    ) external view returns (uint64 count, uint8 avgResponse) {
+        return _getSummary(agentId, validatorAddresses, tag);
+    }
+
+    /// @inheritdoc IValidationRegistry
+    function getAgentValidations(
+        uint256 agentId
+    ) external view returns (bytes32[] memory requestHashes) {
+        return _getAgentValidations(agentId);
+    }
+
+    /// @inheritdoc IValidationRegistry
+    function getValidatorRequests(
+        address validatorAddress
+    ) external view returns (bytes32[] memory requestHashes) {
+        return _getValidatorRequests(validatorAddress);
+    }
+}

package/src/apps/facets/validation/ValidationRegistryStorage.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+
+// libraries
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+
+// contracts
+
+struct ValidationStatus {
+    address validatorAddress;
+    uint256 agentId;
+    uint8 response; // 0..100
+    bytes32 responseHash;
+    bytes32 tag;
+    uint256 lastUpdate;
+}
+
+library ValidationRegistryStorage {
+    using EnumerableSetLib for EnumerableSetLib.Bytes32Set;
+
+    // keccak256(abi.encode(uint256(keccak256("apps.facets.validation.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x81b3fc8d09a49d21221f3e1495c2f4652ebf044e3338065682b43c2012468400;
+
+    struct Layout {
+        mapping(bytes32 requestHash => ValidationStatus) validations;
+        mapping(uint256 agentId => EnumerableSetLib.Bytes32Set requestHashes) requestByAgent;
+        mapping(address validatorAddress => EnumerableSetLib.Bytes32Set requestHashes) requestByValidator;
+    }
+
+    function getLayout() internal pure returns (Layout storage $) {
+        assembly {
+            $.slot := STORAGE_SLOT
+        }
+    }
+}