@towns-protocol/contracts 0.0.413 → 0.0.415

package/src/apps/facets/identity/IdentityRegistryStorage.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+library IdentityRegistryStorage {
+    // keccak256(abi.encode(uint256(keccak256("apps.facets.identity.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x66991193de0d3d5cfb03e1f2f26d7b691100aae98b32c0c50fcb3839feebe100;
+
+    struct Layout {
+        // agentId => key => value
+        mapping(uint256 => mapping(string => bytes)) metadata;
+        // agent uri
+        mapping(uint256 => string) agentUri;
+    }
+
+    function getLayout() internal pure returns (Layout storage $) {
+        assembly {
+            $.slot := STORAGE_SLOT
+        }
+    }
+}

package/src/apps/facets/registry/AppRegistryBase.sol

@@ -16,7 +16,6 @@ import {IAppAccount} from "../../../spaces/facets/account/IAppAccount.sol";
 import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
 import {BasisPoints} from "../../../utils/libraries/BasisPoints.sol";
 import {AppRegistryStorage, ClientInfo, AppInfo} from "./AppRegistryStorage.sol";
-import {LibClone} from "solady/utils/LibClone.sol";
 import {FixedPointMathLib} from "solady/utils/FixedPointMathLib.sol";
 import {CurrencyTransfer} from "../../../utils/libraries/CurrencyTransfer.sol";
 import {LibAppRegistry} from "./LibAppRegistry.sol";

package/src/apps/facets/reputation/IReputationRegistry.sol

@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+/// @title Reputation Registry Base - ERC-8004 Data Structures
+/// @notice Core data structures and events for the ERC-8004 reputation system
+interface IReputationRegistryBase {
+    struct Feedback {
+        uint8 rating;
+        bytes32 tag1;
+        bytes32 tag2;
+    }
+
+    struct FeedbackAuth {
+        uint256 agentId;
+        address reviewerAddress;
+        uint64 indexLimit;
+        uint256 expiry;
+        uint256 chainId;
+        address identityRegistry;
+        address signerAddress;
+    }
+
+    event NewFeedback(
+        uint256 indexed agentId,
+        address indexed reviewerAddress,
+        uint8 score,
+        bytes32 indexed tag1,
+        bytes32 tag2,
+        string feedbackUri,
+        bytes32 feedbackHash
+    );
+
+    event FeedbackRevoked(
+        uint256 indexed agentId,
+        address indexed reviewerAddress,
+        uint64 indexed feedbackIndex
+    );
+
+    event ResponseAppended(
+        uint256 indexed agentId,
+        address indexed reviewerAddress,
+        uint64 feedbackIndex,
+        address indexed responder,
+        string responseUri,
+        bytes32 responseHash
+    );
+}
+
+/// @title Reputation Registry - ERC-8004 Implementation
+/// @notice A reputation system for AI agents enabling feedback collection, scoring, and trust establishment
+/// @dev This contract implements the ERC-8004 Reputation Registry specification, which enables
+///      discovering and trusting agents across organizational boundaries through reputation signals.
+interface IReputationRegistry is IReputationRegistryBase {
+    /// @notice Returns the address of the identity registry where agents are registered as NFTs
+    /// @dev The identity registry is an ERC-721 contract where each agent has a unique token ID.
+    ///      This registry links reputation data to agent identities defined in the ERC-8004 Identity Registry.
+    /// @return The address of the identity registry contract
+    function getIdentityRegistry() external view returns (address);
+
+    /// @notice Posts feedback for an agent after completing a task or interaction
+    /// @param agentId The NFT token ID of the agent being reviewed
+    /// @param score The rating from 0 (worst) to 100 (best)
+    /// @param tag1 First tag for categorization and filtering (use bytes32(0) for none)
+    /// @param tag2 Second tag for categorization and filtering (use bytes32(0) for none)
+    /// @param feedbackUri URI pointing to detailed off-chain feedback data (IPFS recommended)
+    /// @param feedbackHash KECCAK-256 hash of off-chain data for integrity verification
+    function giveFeedback(
+        uint256 agentId,
+        uint8 score,
+        bytes32 tag1,
+        bytes32 tag2,
+        string calldata feedbackUri,
+        bytes32 feedbackHash
+    ) external;
+
+    /// @notice Revokes previously submitted feedback
+    /// @dev Only the original reviewer can revoke their feedback. Revoked feedback is excluded
+    ///      from getSummary() calculations but remains visible in readAllFeedback() with the
+    ///      revoked status flag. This maintains audit trail integrity per ERC-8004 principles.
+    /// @param agentId The NFT token ID of the agent
+    /// @param feedbackIndex The 1-based index of the feedback to revoke (must be > 0)
+    function revokeFeedback(uint256 agentId, uint64 feedbackIndex) external;
+
+    /// @notice Appends a response to existing feedback
+    /// @param agentId The NFT token ID of the agent
+    /// @param reviewerAddress The address that gave the original feedback
+    /// @param feedbackIndex The 1-based index of the feedback being responded to
+    /// @param responseUri URI pointing to the response content (IPFS recommended)
+    /// @param responseHash KECCAK-256 hash of response data for integrity verification
+    function appendResponse(
+        uint256 agentId,
+        address reviewerAddress,
+        uint64 feedbackIndex,
+        string calldata responseUri,
+        bytes32 responseHash
+    ) external;
+
+    /// @notice Retrieves aggregated reputation statistics for an agent with optional filtering
+    /// @param agentId The NFT token ID of the agent
+    /// @param clientAddresses Optional filter for specific reviewers (empty = all reviewers)
+    /// @param tag1 Optional filter for first tag (bytes32(0) = no filter)
+    /// @param tag2 Optional filter for second tag (bytes32(0) = no filter)
+    /// @return count Number of matching feedback entries (excludes revoked)
+    /// @return averageScore Mean score 0-100 (returns 0 if no feedback matches)
+    function getSummary(
+        uint256 agentId,
+        address[] calldata clientAddresses,
+        bytes32 tag1,
+        bytes32 tag2
+    ) external view returns (uint64 count, uint8 averageScore);
+
+    /// @notice Reads a specific feedback entry by agent, reviewer, and index
+    /// @param agentId The NFT token ID of the agent
+    /// @param reviewerAddress The address that gave the feedback
+    /// @param index The 1-based feedback index (must be > 0 and <= lastIndex)
+    /// @return score The rating from 0 to 100
+    /// @return tag1 The first categorization tag
+    /// @return tag2 The second categorization tag
+    /// @return isRevoked True if feedback has been revoked, false otherwise
+    function readFeedback(
+        uint256 agentId,
+        address reviewerAddress,
+        uint64 index
+    ) external view returns (uint8 score, bytes32 tag1, bytes32 tag2, bool isRevoked);
+
+    /// @notice Reads all feedback for an agent with flexible filtering options
+    /// @param agentId The NFT token ID of the agent
+    /// @param clientAddresses Optional filter for specific reviewers (empty = all reviewers)
+    /// @param tag1 Optional filter for first tag (bytes32(0) = no filter)
+    /// @param tag2 Optional filter for second tag (bytes32(0) = no filter)
+    /// @param includeRevoked Whether to include revoked feedback in results
+    /// @return clients Array of reviewer addresses (one per feedback entry)
+    /// @return scores Array of ratings 0-100 (parallel to clients array)
+    /// @return tag1s Array of first tags (parallel to clients array)
+    /// @return tag2s Array of second tags (parallel to clients array)
+    /// @return revokedStatuses Array of revocation flags (parallel to clients array)
+    function readAllFeedback(
+        uint256 agentId,
+        address[] calldata clientAddresses,
+        bytes32 tag1,
+        bytes32 tag2,
+        bool includeRevoked
+    )
+        external
+        view
+        returns (
+            address[] memory clients,
+            uint8[] memory scores,
+            bytes32[] memory tag1s,
+            bytes32[] memory tag2s,
+            bool[] memory revokedStatuses
+        );
+
+    /// @notice Gets the total count of responses with flexible filtering
+    /// @param agentId The NFT token ID of the agent
+    /// @param reviewerAddress Filter by reviewer (address(0) = all reviewers)
+    /// @param feedbackIndex Filter by specific feedback index (0 = all feedback)
+    /// @param responders Filter by specific responders (empty = all responders)
+    /// @return Total count of responses matching the filter criteria
+    function getResponseCount(
+        uint256 agentId,
+        address reviewerAddress,
+        uint64 feedbackIndex,
+        address[] calldata responders
+    ) external view returns (uint256);
+
+    /// @notice Returns all addresses that have given feedback to this agent
+    /// @param agentId The NFT token ID of the agent
+    /// @return clients Array of all reviewer addresses (in order of first feedback)
+    function getClients(uint256 agentId) external view returns (address[] memory clients);
+
+    /// @notice Gets the highest feedback index for a specific reviewer-agent pair
+    /// @param agentId The NFT token ID of the agent
+    /// @param reviewerAddress The address of the reviewer
+    /// @return lastIndex The highest assigned index (0 if no feedback exists)
+    function getLastIndex(
+        uint256 agentId,
+        address reviewerAddress
+    ) external view returns (uint64 lastIndex);
+}

package/src/apps/facets/reputation/ReputationRegistryBase.sol

@@ -0,0 +1,450 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IReputationRegistryBase} from "./IReputationRegistry.sol";
+
+// libraries
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {ReputationRegistryStorage} from "./ReputationRegistryStorage.sol";
+import {SignatureCheckerLib} from "solady/utils/SignatureCheckerLib.sol";
+import {AttestationRequest, RevocationRequestData, Attestation} from "@ethereum-attestation-service/eas-contracts/IEAS.sol";
+import {EMPTY_UID} from "@ethereum-attestation-service/eas-contracts/Common.sol";
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+
+// contracts
+import {ERC721ABase} from "../../../diamond/facets/token/ERC721A/ERC721ABase.sol";
+import {AttestationBase} from "../attest/AttestationBase.sol";
+
+abstract contract ReputationRegistryBase is IReputationRegistryBase, ERC721ABase, AttestationBase {
+    using CustomRevert for bytes4;
+    using ReputationRegistryStorage for ReputationRegistryStorage.Layout;
+    using SignatureCheckerLib for address;
+    using SignatureCheckerLib for bytes32;
+    using EnumerableSetLib for EnumerableSetLib.AddressSet;
+
+    error Reputation__InvalidScore();
+    error Reputation__AgentNotExists();
+    error Reputation__SelfFeedbackNotAllowed();
+    error Reputation__InvalidSignature();
+    error Reputation__InvalidSignerAddress();
+    error Reputation__InvalidFeedbackIndex();
+
+    bytes32 constant EMPTY_TAG = bytes32(0);
+
+    struct CachedFeedback {
+        address client;
+        uint8 rating;
+        bool revoked;
+        bytes32 tag1;
+        bytes32 tag2;
+    }
+
+    function _giveFeedback(uint256 agentId, Feedback memory feedback) internal {
+        if (feedback.rating > 100) Reputation__InvalidScore.selector.revertWith();
+        if (!_exists(agentId)) Reputation__AgentNotExists.selector.revertWith();
+
+        address agentAddress = _ownerOf(agentId);
+        _verifyNotSelfFeedback(agentAddress, agentId);
+
+        ReputationRegistryStorage.Layout storage $ = ReputationRegistryStorage.getLayout();
+        uint64 currentIndex = $.lastIndex[agentId][msg.sender] + 1;
+        $.lastIndex[agentId][msg.sender] = currentIndex;
+        $.clients[agentId].add(msg.sender);
+
+        bytes32 attestationId = _createAttestation($.feedbackSchemaId, agentAddress, feedback);
+        $.feedback[agentId][msg.sender][currentIndex] = attestationId;
+    }
+
+    /// @notice Revokes a feedback
+    /// @param agentId The ID of the agent
+    /// @param feedbackIndex The index of the feedback
+    function _revokeFeedback(uint256 agentId, uint64 feedbackIndex) internal {
+        if (feedbackIndex == 0) Reputation__InvalidFeedbackIndex.selector.revertWith();
+        ReputationRegistryStorage.Layout storage $ = ReputationRegistryStorage.getLayout();
+        if (feedbackIndex > $.lastIndex[agentId][msg.sender])
+            Reputation__InvalidFeedbackIndex.selector.revertWith();
+
+        bytes32 attestationId = $.feedback[agentId][msg.sender][feedbackIndex];
+        if (attestationId == EMPTY_UID) Reputation__InvalidFeedbackIndex.selector.revertWith();
+
+        RevocationRequestData memory request;
+        request.uid = attestationId;
+
+        _revoke($.feedbackSchemaId, request, msg.sender, 0, true);
+
+        emit FeedbackRevoked(agentId, msg.sender, feedbackIndex);
+    }
+
+    /// @notice Appends a response to a feedback
+    /// @param agentId The ID of the agent
+    /// @param reviewerAddress The address of the feedback reviewer
+    /// @param feedbackIndex The index of the feedback
+    /// @param comment The comment of the response
+    /// @param commentHash The hash of the comment
+    function _appendResponse(
+        uint256 agentId,
+        address reviewerAddress,
+        uint64 feedbackIndex,
+        string calldata comment,
+        bytes32 commentHash
+    ) internal {
+        if (feedbackIndex == 0) Reputation__InvalidFeedbackIndex.selector.revertWith();
+
+        ReputationRegistryStorage.Layout storage $ = ReputationRegistryStorage.getLayout();
+        if (feedbackIndex > $.lastIndex[agentId][reviewerAddress])
+            Reputation__InvalidFeedbackIndex.selector.revertWith();
+
+        bytes32 attestationId = $.feedback[agentId][reviewerAddress][feedbackIndex];
+        if (attestationId == EMPTY_UID) Reputation__InvalidFeedbackIndex.selector.revertWith();
+
+        $.responders[agentId][reviewerAddress][feedbackIndex].add(msg.sender);
+        $.responseCount[agentId][reviewerAddress][feedbackIndex][msg.sender]++;
+
+        emit ResponseAppended(
+            agentId,
+            reviewerAddress,
+            feedbackIndex,
+            msg.sender,
+            comment,
+            commentHash
+        );
+    }
+
+    function _getLastIndex(
+        uint256 agentId,
+        address reviewerAddress
+    ) internal view returns (uint64) {
+        return ReputationRegistryStorage.getLayout().lastIndex[agentId][reviewerAddress];
+    }
+
+    function _readFeedback(
+        uint256 agentId,
+        address reviewerAddress,
+        uint64 feedbackIndex
+    ) internal view returns (Feedback memory feedback, bool isRevoked) {
+        if (feedbackIndex == 0) Reputation__InvalidFeedbackIndex.selector.revertWith();
+
+        ReputationRegistryStorage.Layout storage $ = ReputationRegistryStorage.getLayout();
+        if (feedbackIndex > $.lastIndex[agentId][reviewerAddress])
+            Reputation__InvalidFeedbackIndex.selector.revertWith();
+
+        bytes32 attestationId = $.feedback[agentId][reviewerAddress][feedbackIndex];
+        if (attestationId == EMPTY_UID) Reputation__InvalidFeedbackIndex.selector.revertWith();
+
+        Attestation memory attestation = _getAttestation(attestationId);
+        feedback = abi.decode(attestation.data, (Feedback));
+        return (feedback, attestation.revocationTime != 0);
+    }
+
+    function _getSummary(
+        uint256 agentId,
+        address[] calldata reviewers,
+        bytes32 tag1,
+        bytes32 tag2
+    ) internal view returns (uint64 count, uint8 averageRating) {
+        address[] memory clients;
+
+        ReputationRegistryStorage.Layout storage $ = ReputationRegistryStorage.getLayout();
+
+        if (reviewers.length > 0) clients = reviewers;
+        else clients = $.clients[agentId].values();
+
+        uint256 totalRating;
+        for (uint256 i; i < clients.length; ++i) {
+            uint64 lastIndex = $.lastIndex[agentId][clients[i]];
+            for (uint64 j = 1; j <= lastIndex; ++j) {
+                bytes32 attestationId = $.feedback[agentId][clients[i]][j];
+                if (attestationId == EMPTY_UID) continue;
+                Attestation memory attestation = _getAttestation(attestationId);
+                if (attestation.revocationTime != 0) continue;
+
+                Feedback memory feedback = abi.decode(attestation.data, (Feedback));
+                if (tag1 != EMPTY_TAG && feedback.tag1 != tag1) continue;
+                if (tag2 != EMPTY_TAG && feedback.tag2 != tag2) continue;
+                totalRating += feedback.rating;
+                count++;
+            }
+        }
+
+        averageRating = count > 0 ? uint8(totalRating / count) : 0;
+    }
+
+    struct AllFeedback {
+        address[] clients;
+        uint8[] scores;
+        bytes32[] tag1s;
+        bytes32[] tag2s;
+        bool[] revokedStatuses;
+    }
+
+    function _readAllFeedback(
+        uint256 agentId,
+        address[] calldata reviewers,
+        bytes32 tag1,
+        bytes32 tag2,
+        bool includeRevoked
+    ) internal view returns (AllFeedback memory allFeedback) {
+        ReputationRegistryStorage.Layout storage $ = ReputationRegistryStorage.getLayout();
+        address[] memory clientList = reviewers.length > 0
+            ? reviewers
+            : $.clients[agentId].values();
+
+        uint256 maxCount = _estimateMaxFeedback(agentId, clientList, $);
+        CachedFeedback[] memory cache = new CachedFeedback[](maxCount);
+
+        uint256 totalCount = _populateCache(
+            cache,
+            agentId,
+            clientList,
+            tag1,
+            tag2,
+            includeRevoked,
+            $
+        );
+
+        allFeedback.clients = new address[](totalCount);
+        allFeedback.scores = new uint8[](totalCount);
+        allFeedback.tag1s = new bytes32[](totalCount);
+        allFeedback.tag2s = new bytes32[](totalCount);
+        allFeedback.revokedStatuses = new bool[](totalCount);
+
+        for (uint256 i; i < totalCount; ++i) {
+            allFeedback.clients[i] = cache[i].client;
+            allFeedback.scores[i] = cache[i].rating;
+            allFeedback.tag1s[i] = cache[i].tag1;
+            allFeedback.tag2s[i] = cache[i].tag2;
+            allFeedback.revokedStatuses[i] = cache[i].revoked;
+        }
+    }
+
+    function _populateCache(
+        CachedFeedback[] memory cache,
+        uint256 agentId,
+        address[] memory clientList,
+        bytes32 tag1,
+        bytes32 tag2,
+        bool includeRevoked,
+        ReputationRegistryStorage.Layout storage $
+    ) private view returns (uint256 count) {
+        uint256 clientListLength = clientList.length;
+
+        for (uint256 i; i < clientListLength; ++i) {
+            count = _processFeedbackForClient(
+                cache,
+                count,
+                agentId,
+                clientList[i],
+                tag1,
+                tag2,
+                includeRevoked,
+                $
+            );
+        }
+    }
+
+    function _processFeedbackForClient(
+        CachedFeedback[] memory cache,
+        uint256 currentCount,
+        uint256 agentId,
+        address client,
+        bytes32 tag1,
+        bytes32 tag2,
+        bool includeRevoked,
+        ReputationRegistryStorage.Layout storage $
+    ) private view returns (uint256 newCount) {
+        newCount = currentCount;
+        uint64 lastIndex = $.lastIndex[agentId][client];
+
+        for (uint64 j = 1; j <= lastIndex; ++j) {
+            bytes32 attestationId = $.feedback[agentId][client][j];
+
+            if (attestationId != EMPTY_UID) {
+                Attestation memory att = _getAttestation(attestationId);
+
+                if (includeRevoked || att.revocationTime == 0) {
+                    Feedback memory fdbk = abi.decode(att.data, (Feedback));
+
+                    if (
+                        (tag1 == EMPTY_TAG || fdbk.tag1 == tag1) &&
+                        (tag2 == EMPTY_TAG || fdbk.tag2 == tag2)
+                    ) {
+                        cache[newCount] = CachedFeedback({
+                            client: client,
+                            rating: fdbk.rating,
+                            tag1: fdbk.tag1,
+                            tag2: fdbk.tag2,
+                            revoked: att.revocationTime != 0
+                        });
+                        ++newCount;
+                    }
+                }
+            }
+        }
+    }
+
+    function _getResponseCount(
+        uint256 agentId,
+        address reviewerAddress,
+        uint64 feedbackIndex,
+        address[] calldata responders
+    ) internal view returns (uint256 count) {
+        ReputationRegistryStorage.Layout storage $ = ReputationRegistryStorage.getLayout();
+
+        if (reviewerAddress == address(0)) {
+            return _countAllClientsResponses(agentId, responders, $);
+        }
+
+        if (feedbackIndex == 0) {
+            return _countReviewerAllFeedback(agentId, reviewerAddress, responders, $);
+        }
+
+        return _countSingleFeedback(agentId, reviewerAddress, feedbackIndex, responders, $);
+    }
+
+    function _countAllClientsResponses(
+        uint256 agentId,
+        address[] calldata responders,
+        ReputationRegistryStorage.Layout storage $
+    ) private view returns (uint256 count) {
+        address[] memory clients = $.clients[agentId].values();
+        uint256 clientsLength = clients.length;
+
+        if (responders.length == 0) {
+            for (uint256 i; i < clientsLength; ++i) {
+                count += _countClientAllResponses(agentId, clients[i], $);
+            }
+        } else {
+            for (uint256 i; i < clientsLength; ++i) {
+                count += _countClientSpecificResponders(agentId, clients[i], responders, $);
+            }
+        }
+    }
+
+    function _countClientAllResponses(
+        uint256 agentId,
+        address client,
+        ReputationRegistryStorage.Layout storage $
+    ) private view returns (uint256 count) {
+        uint64 lastIdx = $.lastIndex[agentId][client];
+
+        for (uint64 j = 1; j <= lastIdx; ++j) {
+            address[] memory allResponders = $.responders[agentId][client][j].values();
+            uint256 respondersLength = allResponders.length;
+
+            for (uint256 k; k < respondersLength; ++k) {
+                count += $.responseCount[agentId][client][j][allResponders[k]];
+            }
+        }
+    }
+
+    function _countClientSpecificResponders(
+        uint256 agentId,
+        address client,
+        address[] calldata responders,
+        ReputationRegistryStorage.Layout storage $
+    ) private view returns (uint256 count) {
+        uint64 lastIdx = $.lastIndex[agentId][client];
+        uint256 respondersLength = responders.length;
+
+        for (uint64 j = 1; j <= lastIdx; ++j) {
+            for (uint256 k; k < respondersLength; ++k) {
+                count += $.responseCount[agentId][client][j][responders[k]];
+            }
+        }
+    }
+
+    function _countReviewerAllFeedback(
+        uint256 agentId,
+        address reviewerAddress,
+        address[] calldata responders,
+        ReputationRegistryStorage.Layout storage $
+    ) private view returns (uint256 count) {
+        uint64 lastIdx = $.lastIndex[agentId][reviewerAddress];
+
+        if (responders.length == 0) {
+            for (uint64 j = 1; j <= lastIdx; ++j) {
+                address[] memory allResponders = $.responders[agentId][reviewerAddress][j].values();
+                uint256 respondersLength = allResponders.length;
+
+                for (uint256 k; k < respondersLength; ++k) {
+                    count += $.responseCount[agentId][reviewerAddress][j][allResponders[k]];
+                }
+            }
+        } else {
+            uint256 respondersLength = responders.length;
+
+            for (uint64 j = 1; j <= lastIdx; ++j) {
+                for (uint256 k; k < respondersLength; ++k) {
+                    count += $.responseCount[agentId][reviewerAddress][j][responders[k]];
+                }
+            }
+        }
+    }
+
+    function _countSingleFeedback(
+        uint256 agentId,
+        address reviewerAddress,
+        uint64 feedbackIndex,
+        address[] calldata responders,
+        ReputationRegistryStorage.Layout storage $
+    ) private view returns (uint256 count) {
+        if (responders.length == 0) {
+            address[] memory allResponders = $
+            .responders[agentId][reviewerAddress][feedbackIndex].values();
+            uint256 respondersLength = allResponders.length;
+
+            for (uint256 k; k < respondersLength; ++k) {
+                count += $.responseCount[agentId][reviewerAddress][feedbackIndex][allResponders[k]];
+            }
+        } else {
+            uint256 respondersLength = responders.length;
+
+            for (uint256 k; k < respondersLength; ++k) {
+                count += $.responseCount[agentId][reviewerAddress][feedbackIndex][responders[k]];
+            }
+        }
+    }
+
+    function _getClients(uint256 agentId) internal view returns (address[] memory) {
+        return ReputationRegistryStorage.getLayout().clients[agentId].values();
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                     Utility Functions                      */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _createAttestation(
+        bytes32 schemaId,
+        address recipient,
+        Feedback memory feedback
+    ) internal returns (bytes32 attestationId) {
+        AttestationRequest memory request;
+        request.schema = schemaId;
+        request.data.recipient = recipient;
+        request.data.revocable = true;
+        request.data.refUID = EMPTY_UID;
+        request.data.data = abi.encode(feedback);
+        return _attest(msg.sender, 0, request).uid;
+    }
+
+    function _estimateMaxFeedback(
+        uint256 agentId,
+        address[] memory clientList,
+        ReputationRegistryStorage.Layout storage $
+    ) private view returns (uint256 maxCount) {
+        for (uint256 i; i < clientList.length; ++i) {
+            maxCount += $.lastIndex[agentId][clientList[i]];
+        }
+    }
+
+    function _verifyNotSelfFeedback(address agent, uint256 agentId) internal view {
+        if (
+            msg.sender == agent ||
+            _isApprovedForAll(agent, msg.sender) ||
+            _getApproved(agentId) == msg.sender
+        ) {
+            Reputation__SelfFeedbackNotAllowed.selector.revertWith();
+        }
+    }
+}