@towns-protocol/contracts 0.0.414 → 0.0.415

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towns-protocol/contracts",
-  "version": "0.0.414",
+  "version": "0.0.415",
   "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.414",
+    "@towns-protocol/prettier-config": "^0.0.415",
     "@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": "2790c60001fe1cc5a492e571f59e2c13dd301962"
+  "gitHead": "27f0f8758cd1a18fad7a2774490389e48637942b"
 }

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

@@ -3,7 +3,7 @@ pragma solidity ^0.8.23;
 
 // interfaces
 import {IDiamondInitHelper} from "./IDiamondInitHelper.sol";
-import {IAppFactory, IAppFactoryBase} from "src/apps/facets/factory/IAppFactory.sol";
+import {IAppFactoryBase} from "src/apps/facets/factory/IAppFactory.sol";
 
 // libraries
 import {DeployDiamondCut} from "@towns-protocol/diamond/scripts/deployments/facets/DeployDiamondCut.sol";
@@ -17,6 +17,8 @@ import {DeployAppInstallerFacet} from "../facets/DeployAppInstallerFacet.s.sol";
 import {DeployAppFactoryFacet} from "../facets/DeployAppFactoryFacet.s.sol";
 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";
 
 // contracts
 import {Diamond} from "@towns-protocol/diamond/src/Diamond.sol";
@@ -36,6 +38,11 @@ contract DeployAppRegistry is IDiamondInitHelper, DiamondHelper, Deployer {
     DeploySimpleAppBeacon private deploySimpleAppBeacon = new DeploySimpleAppBeacon();
 
     string internal constant APP_REGISTRY_SCHEMA = "address app, address client";
+    string internal constant FEEDBACK_SCHEMA =
+        "uint256 agentId, uint8 score, bytes32 tag1, bytes32 tag2, string feedbackUri, bytes32 feedbackHash";
+    string internal constant RESPONSE_SCHEMA =
+        "uint256 agentId, address reviewerAddress, uint64 feedbackIndex, string responseUri, bytes32 responseHash";
+
     address internal spaceFactory;
     address internal simpleAppBeacon;
 
@@ -101,6 +108,8 @@ contract DeployAppRegistry is IDiamondInitHelper, DiamondHelper, Deployer {
         facetHelper.add("AppRegistryFacet");
         facetHelper.add("AppInstallerFacet");
         facetHelper.add("AppFactoryFacet");
+        facetHelper.add("IdentityRegistryFacet");
+        facetHelper.add("ReputationRegistryFacet");
 
         facetHelper.deployBatch(deployer);
 
@@ -131,6 +140,20 @@ contract DeployAppRegistry is IDiamondInitHelper, DiamondHelper, Deployer {
             DeployAppFactoryFacet.makeInitData(beacons, _getEntryPoint())
         );
 
+        facet = facetHelper.getDeployedAddress("IdentityRegistryFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployIdentityRegistry.selectors()),
+            facet,
+            DeployIdentityRegistry.makeInitData()
+        );
+
+        facet = facetHelper.getDeployedAddress("ReputationRegistryFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployReputationRegistry.selectors()),
+            facet,
+            DeployReputationRegistry.makeInitData(FEEDBACK_SCHEMA, RESPONSE_SCHEMA)
+        );
+
         address multiInit = facetHelper.getDeployedAddress("MultiInit");
 
         return
@@ -166,6 +189,9 @@ contract DeployAppRegistry is IDiamondInitHelper, DiamondHelper, Deployer {
             if (facetName.eq("AppFactoryFacet")) {
                 addCut(makeCut(facet, FacetCutAction.Add, DeployAppFactoryFacet.selectors()));
             }
+            if (facetName.eq("IdentityRegistryFacet")) {
+                addCut(makeCut(facet, FacetCutAction.Add, DeployIdentityRegistry.selectors()));
+            }
         }
 
         return baseFacets();

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

@@ -0,0 +1,64 @@
+// 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";
+import {DeployERC721A} from "../facets/DeployERC721A.s.sol";
+
+// contracts
+import {IdentityRegistryFacet} from "src/apps/facets/identity/IdentityRegistryFacet.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+library DeployIdentityRegistry {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        uint256 selectorsCount = 20;
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(selectorsCount);
+        arr.p(bytes4(keccak256("register()")));
+        arr.p(bytes4(keccak256("register(string)")));
+        arr.p(bytes4(keccak256("register(string,(string,bytes)[])")));
+        arr.p(IdentityRegistryFacet.getMetadata.selector);
+        arr.p(IdentityRegistryFacet.setMetadata.selector);
+        arr.p(IdentityRegistryFacet.setAgentUri.selector);
+
+        {
+            bytes4[] memory selectors_2 = DeployERC721A.selectors();
+            if (selectors_2.length > selectorsCount) {
+                revert("Selectors count is greater than the reserved space");
+            }
+            for (uint256 i; i < selectors_2.length; ++i) {
+                arr.p(selectors_2[i]);
+            }
+        }
+
+        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(IdentityRegistryFacet.__IdentityRegistryFacet_init, ());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("IdentityRegistryFacet.sol", "");
+    }
+}

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

@@ -0,0 +1,64 @@
+// 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";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+// contracts
+import {ReputationRegistryFacet} from "src/apps/facets/reputation/ReputationRegistryFacet.sol";
+
+library DeployReputationRegistry {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        uint256 selectorsCount = 10;
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(selectorsCount);
+        arr.p(ReputationRegistryFacet.giveFeedback.selector);
+        arr.p(ReputationRegistryFacet.revokeFeedback.selector);
+        arr.p(ReputationRegistryFacet.appendResponse.selector);
+        arr.p(ReputationRegistryFacet.getIdentityRegistry.selector);
+        arr.p(ReputationRegistryFacet.getSummary.selector);
+        arr.p(ReputationRegistryFacet.readFeedback.selector);
+        arr.p(ReputationRegistryFacet.readAllFeedback.selector);
+        arr.p(ReputationRegistryFacet.getResponseCount.selector);
+        arr.p(ReputationRegistryFacet.getClients.selector);
+        arr.p(ReputationRegistryFacet.getLastIndex.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(
+        string memory feedbackSchema,
+        string memory responseSchema
+    ) internal pure returns (bytes memory) {
+        return
+            abi.encodeCall(
+                ReputationRegistryFacet.__ReputationRegistry_init,
+                (feedbackSchema, responseSchema)
+            );
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("ReputationRegistryFacet.sol", "");
+    }
+}

package/scripts/interactions/InteractAppRegistry.s.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.23;
 
 // interfaces
 import {IAppFactoryBase} from "src/apps/facets/factory/IAppFactory.sol";
+import {UpgradeableBeaconFacet} from "src/diamond/facets/beacon/UpgradeableBeaconFacet.sol";
 
 // libraries
 import {console} from "forge-std/console.sol";
@@ -14,50 +15,83 @@ import {DeployAppRegistry} from "../deployments/diamonds/DeployAppRegistry.s.sol
 import {DeploySimpleAppBeacon} from "../deployments/diamonds/DeploySimpleAppBeacon.s.sol";
 
 // facet deployers
-import {DeployAppRegistryFacet} from "../deployments/facets/DeployAppRegistryFacet.s.sol";
-import {DeployAppInstallerFacet} from "../deployments/facets/DeployAppInstallerFacet.s.sol";
-import {DeployAppFactoryFacet} from "../deployments/facets/DeployAppFactoryFacet.s.sol";
+import {MultiInit} from "@towns-protocol/diamond/src/initializers/MultiInit.sol";
+import {DeployIdentityRegistry} from "../deployments/facets/DeployIdentityRegistry.s.sol";
+import {DeployReputationRegistry} from "../deployments/facets/DeployReputationRegistry.s.sol";
+import {DeployFacet} from "../common/DeployFacet.s.sol";
 
 contract InteractAppRegistry is Interaction, AlphaHelper {
     DeployAppRegistry private deployHelper = new DeployAppRegistry();
     DeploySimpleAppBeacon private beaconHelper = new DeploySimpleAppBeacon();
+    DeployFacet private facetHelper = new DeployFacet();
+
+    string internal constant FEEDBACK_SCHEMA =
+        "uint256 agentId, uint8 score, bytes32 tag1, bytes32 tag2, string feedbackUri, bytes32 feedbackHash";
+    string internal constant RESPONSE_SCHEMA =
+        "uint256 agentId, address reviewerAddress, uint64 feedbackIndex, string responseUri, bytes32 responseHash";
 
     function __interact(address deployer) internal override {
-        // Get the deployed AppRegistry diamond address
+        // Get the deployed contract addresses
         address appRegistry = getDeployment("appRegistry");
-        address spaceFactory = getDeployment("spaceFactory");
         address simpleAppBeacon = getDeployment("simpleAppBeacon");
-        address entryPoint = getDeployment("entryPoint");
 
         console.log("AppRegistry Diamond:", appRegistry);
-        console.log("Space Factory:", spaceFactory);
         console.log("Simple App Beacon:", simpleAppBeacon);
 
         // Deploy new facet implementations
         console.log("\n=== Deploying New Facets ===");
         vm.setEnv("OVERRIDE_DEPLOYMENTS", "1");
 
-        address appRegistryFacet = DeployAppRegistryFacet.deploy();
-        console.log("AppRegistryFacet deployed at:", appRegistryFacet);
+        // Deploy Identity Registry Facet
+        address identityRegistryFacet = DeployIdentityRegistry.deploy();
+        console.log("IdentityRegistryFacet deployed at:", identityRegistryFacet);
+
+        // Deploy Reputation Registry Facet
+        address reputationRegistryFacet = DeployReputationRegistry.deploy();
+        console.log("ReputationRegistryFacet deployed at:", reputationRegistryFacet);
+
+        // Deploy new version of Simple App Facet
+        facetHelper.add("SimpleAppFacet");
+        facetHelper.deployBatch(deployer);
+        address newSimpleAppFacet = facetHelper.getDeployedAddress("SimpleAppFacet");
+        console.log("SimpleAppFacet deployed at:", newSimpleAppFacet);
 
-        address appInstallerFacet = DeployAppInstallerFacet.deploy();
-        console.log("AppInstallerFacet deployed at:", appInstallerFacet);
+        // Upgrade Simple App Beacon to use new implementation
+        console.log("\n=== Upgrading Simple App Beacon ===");
+        vm.broadcast(deployer);
+        UpgradeableBeaconFacet(simpleAppBeacon).upgradeTo(newSimpleAppFacet);
+        console.log("Simple App Beacon upgraded to:", newSimpleAppFacet);
 
-        address appFactoryFacet = DeployAppFactoryFacet.deploy();
-        console.log("AppFactoryFacet deployed at:", appFactoryFacet);
+        // Add the cuts for the new registry facets (Add action)
+        addCut(DeployIdentityRegistry.makeCut(identityRegistryFacet, FacetCutAction.Add));
+        addCut(DeployReputationRegistry.makeCut(reputationRegistryFacet, FacetCutAction.Add));
+
+        // Prepare initialization data for the new facets
+        bytes memory identityInitData = DeployIdentityRegistry.makeInitData();
+        bytes memory reputationInitData = DeployReputationRegistry.makeInitData(
+            FEEDBACK_SCHEMA,
+            RESPONSE_SCHEMA
+        );
 
-        // Add the cuts for the new facet implementations
-        addCut(DeployAppRegistryFacet.makeCut(appRegistryFacet, FacetCutAction.Replace));
-        addCut(DeployAppInstallerFacet.makeCut(appInstallerFacet, FacetCutAction.Replace));
-        addCut(DeployAppFactoryFacet.makeCut(appFactoryFacet, FacetCutAction.Replace));
+        // Prepare combined initialization using MultiInit pattern
+        address[] memory initAddresses = new address[](2);
+        bytes[] memory initDatas = new bytes[](2);
 
-        // Prepare initialization data for AppFactoryFacet with the beacon configuration
-        IAppFactoryBase.Beacon[] memory beacons = new IAppFactoryBase.Beacon[](1);
-        beacons[0] = IAppFactoryBase.Beacon({
-            beaconId: beaconHelper.SIMPLE_APP_BEACON_ID(),
-            beacon: simpleAppBeacon
-        });
-        bytes memory initData = DeployAppFactoryFacet.makeInitData(beacons, entryPoint);
+        initAddresses[0] = identityRegistryFacet;
+        initDatas[0] = identityInitData;
+
+        initAddresses[1] = reputationRegistryFacet;
+        initDatas[1] = reputationInitData;
+
+        // Get MultiInit address from facet helper
+        facetHelper.add("MultiInit");
+        facetHelper.deployBatch(deployer);
+        address multiInit = facetHelper.getDeployedAddress("MultiInit");
+
+        bytes memory combinedInitData = abi.encodeCall(
+            MultiInit.multiInit,
+            (initAddresses, initDatas)
+        );
 
         // Generate and execute smart cuts with initialization
         console.log("\n=== Executing Diamond Cut with Initialization ===");
@@ -66,8 +100,8 @@ contract InteractAppRegistry is Interaction, AlphaHelper {
             appRegistry,
             "AppRegistry",
             deployHelper,
-            appFactoryFacet,
-            initData
+            multiInit,
+            combinedInitData
         );
 
         console.log("\n=== Diamond Cut Complete ===");

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

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+/// @title IIdentityRegistryBase
+/// @notice Base interface for ERC-8004 compliant agent identity registry
+/// @dev Defines core data structures, events, and errors for agent registration and metadata management
+interface IIdentityRegistryBase {
+    /// @notice Metadata entry for storing additional on-chain agent information
+    /// @dev Used in batch metadata operations during agent registration
+    struct MetadataEntry {
+        /// @notice The metadata key identifier
+        string metadataKey;
+        /// @notice The metadata value stored as bytes
+        bytes metadataValue;
+    }
+
+    /// @notice Emitted when a new agent is registered in the identity registry
+    /// @param agentId The unique identifier (agentId) assigned to the agent
+    /// @param agentUri The URI pointing to the agent's registration file
+    /// @param owner The address that owns the agent identity
+    event Registered(uint256 indexed agentId, string agentUri, address indexed owner);
+
+    /// @notice Emitted when metadata is set or updated for an agent
+    /// @param agentId The unique identifier of the agent
+    /// @param indexedKey The metadata key as indexed parameter for efficient filtering
+    /// @param metadataKey The metadata key as non-indexed parameter for reading
+    /// @param metadataValue The metadata value stored as bytes
+    event MetadataSet(
+        uint256 indexed agentId,
+        string indexed indexedKey,
+        string metadataKey,
+        bytes metadataValue
+    );
+
+    /// @notice Emitted when an agent's URI is updated
+    /// @param agentId The unique identifier of the agent
+    /// @param agentUri The new URI pointing to the agent's registration file
+    /// @param updatedBy The address that performed the update
+    event UriUpdated(uint256 indexed agentId, string agentUri, address indexed updatedBy);
+
+    /// @notice Thrown when caller is not authorized to perform the operation
+    /// @dev Authorization requires being the owner, an approved operator, or approved for the specific token
+    error IdentityRegistry__NotAuthorized();
+
+    /// @notice Thrown when attempting to access an agent that does not exist
+    error IdentityRegistry__AgentDoesNotExist();
+
+    /// @notice Thrown when attempting an operation on an agent that is not registered
+    error IdentityRegistry__AgentNotRegistered();
+
+    /// @notice Thrown when attempting to register an agent that is banned
+    error IdentityRegistry__AgentBanned();
+
+    /// @notice Thrown when attempting to promote or register an agent that already has a promoted identity
+    error IdentityRegistry__AgentAlreadyPromoted();
+
+    /// @notice Thrown when attempting to register an agent with too many metadata entries
+    error IdentityRegistry__TooManyMetadataEntries();
+}
+
+/// @title IIdentityRegistry
+/// @notice ERC-8004 compliant agent identity registry interface
+/// @dev Extends ERC-721 with agent registration, metadata management, and URI storage capabilities.
+///      Each agent is uniquely identified globally by: namespace (eip155), chainId, identityRegistry address, and agentId.
+///      The tokenURI resolves to an agent registration file containing endpoints, capabilities, and trust model information.
+interface IIdentityRegistry is IIdentityRegistryBase {
+    /// @notice Register a new agent identity without initial URI or metadata
+    /// @dev Mints a new ERC-721 token to msg.sender. URI can be set later via setAgentUri.
+    /// @return agentId The unique identifier assigned to the newly registered agent
+    function register() external returns (uint256 agentId);
+
+    /// @notice Register a new agent identity with a tokenURI
+    /// @dev Mints a new ERC-721 token to msg.sender and sets the tokenURI
+    /// @param agentUri The URI pointing to the agent's registration file (e.g., ipfs://cid or https://domain.com/agent.json)
+    /// @return agentId The unique identifier assigned to the newly registered agent
+    function register(string calldata agentUri) external returns (uint256 agentId);
+
+    /// @notice Register a new agent identity with tokenURI and metadata
+    /// @dev Mints a new ERC-721 token to msg.sender, sets the tokenURI, and stores metadata entries.
+    ///      This is the most complete registration method for agents with immediate metadata.
+    /// @param agentUri The URI pointing to the agent's registration file
+    /// @param metadata Array of metadata entries to store as on-chain metadata
+    /// @return agentId The unique identifier assigned to the newly registered agent
+    function register(
+        string calldata agentUri,
+        MetadataEntry[] calldata metadata
+    ) external returns (uint256 agentId);
+
+    /// @notice Retrieve metadata value for a specific agent and metadataKey
+    /// @dev Returns empty bytes if the metadataKey does not exist
+    /// @param agentId The unique identifier of the agent
+    /// @param metadataKey The metadata key to retrieve
+    /// @return The metadata value stored as bytes
+    function getMetadata(
+        uint256 agentId,
+        string memory metadataKey
+    ) external view returns (bytes memory);
+
+    /// @notice Set or update metadata for a specific agent
+    /// @dev Only callable by the agent owner, approved operator, or token-specific approved address.
+    ///      Emits MetadataSet event.
+    /// @param agentId The unique identifier of the agent
+    /// @param metadataKey The metadata key to set
+    /// @param metadataValue The metadata value to store as bytes
+    function setMetadata(
+        uint256 agentId,
+        string memory metadataKey,
+        bytes memory metadataValue
+    ) external;
+
+    /// @notice Update the tokenURI for an agent
+    /// @dev Only callable by the agent owner, approved operator, or token-specific approved address.
+    ///      Emits UriUpdated event. Useful when agent registration data changes.
+    /// @param agentId The unique identifier of the agent
+    /// @param agentUri The new URI pointing to the agent's updated registration file
+    function setAgentUri(uint256 agentId, string calldata agentUri) external;
+
+    /// @notice Get the tokenURI for an agent
+    /// @dev Returns the URI pointing to the agent's registration file.
+    ///      Reverts if the token does not exist.
+    /// @param agentId The unique identifier of the agent (ERC-721 tokenId)
+    /// @return The URI string pointing to the agent's registration file
+    function tokenURI(uint256 agentId) external view returns (string memory);
+}

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

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IIdentityRegistryBase} from "./IIdentityRegistry.sol";
+
+// libraries
+import {IdentityRegistryStorage} from "./IdentityRegistryStorage.sol";
+
+// contracts
+
+abstract contract IdentityRegistryBase is IIdentityRegistryBase {
+    function _setAgentUri(uint256 agentId, string memory agentUri) internal {
+        IdentityRegistryStorage.getLayout().agentUri[agentId] = agentUri;
+    }
+
+    function _getAgentUri(uint256 agentId) internal view returns (string memory) {
+        return IdentityRegistryStorage.getLayout().agentUri[agentId];
+    }
+
+    function _setMetadata(uint256 agentId, string memory metadataKey, bytes memory value) internal {
+        IdentityRegistryStorage.getLayout().metadata[agentId][metadataKey] = value;
+        emit MetadataSet(agentId, metadataKey, metadataKey, value);
+    }
+
+    function _getMetadata(
+        uint256 agentId,
+        string memory metadataKey
+    ) internal view returns (bytes memory) {
+        return IdentityRegistryStorage.getLayout().metadata[agentId][metadataKey];
+    }
+}

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

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IIdentityRegistry} from "./IIdentityRegistry.sol";
+
+// libraries
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {EMPTY_UID} from "@ethereum-attestation-service/eas-contracts/Common.sol";
+
+// contracts
+import {AppRegistryBase} from "../registry/AppRegistryBase.sol";
+import {IdentityRegistryBase} from "./IdentityRegistryBase.sol";
+import {ERC721A} from "../../../diamond/facets/token/ERC721A/ERC721A.sol";
+
+contract IdentityRegistryFacet is
+    IIdentityRegistry,
+    AppRegistryBase,
+    IdentityRegistryBase,
+    ERC721A
+{
+    using CustomRevert for bytes4;
+
+    uint256 internal constant MAX_METADATA_ENTRIES = 10;
+
+    function __IdentityRegistryFacet_init() external onlyInitializing {
+        __IdentityRegistryFacet_init_unchained();
+        __ERC721A_init_unchained("Towns Bot Agent", "TBA");
+    }
+
+    function __IdentityRegistryFacet_init_unchained() internal {
+        _addInterface(type(IIdentityRegistry).interfaceId);
+    }
+
+    /// @inheritdoc IIdentityRegistry
+    function register() external returns (uint256 agentId) {
+        _verifyAgent();
+        agentId = _nextTokenId();
+        _mint(msg.sender, 1);
+        emit Registered(agentId, "", msg.sender);
+    }
+
+    /// @inheritdoc IIdentityRegistry
+    function register(string calldata agentUri) external returns (uint256 agentId) {
+        _verifyAgent();
+        agentId = _nextTokenId();
+        _mint(msg.sender, 1);
+        _setAgentUri(agentId, agentUri);
+        emit Registered(agentId, agentUri, msg.sender);
+    }
+
+    /// @inheritdoc IIdentityRegistry
+    function register(
+        string calldata agentUri,
+        MetadataEntry[] calldata metadata
+    ) external returns (uint256 agentId) {
+        _verifyMetadataLength(metadata);
+        _verifyAgent();
+        agentId = _nextTokenId();
+        _mint(msg.sender, 1);
+        _setAgentUri(agentId, agentUri);
+
+        for (uint256 i; i < metadata.length; ++i) {
+            _setMetadata(agentId, metadata[i].metadataKey, metadata[i].metadataValue);
+        }
+
+        emit Registered(agentId, agentUri, msg.sender);
+    }
+
+    /// @inheritdoc IIdentityRegistry
+    function setMetadata(
+        uint256 agentId,
+        string memory metadataKey,
+        bytes memory metadataValue
+    ) external {
+        _verifyAuthorization(agentId);
+        _setMetadata(agentId, metadataKey, metadataValue);
+    }
+
+    /// @inheritdoc IIdentityRegistry
+    function setAgentUri(uint256 agentId, string calldata agentUri) external {
+        _verifyAuthorization(agentId);
+        _setAgentUri(agentId, agentUri);
+        emit UriUpdated(agentId, agentUri, msg.sender);
+    }
+
+    /// @inheritdoc IIdentityRegistry
+    function getMetadata(
+        uint256 agentId,
+        string memory metadataKey
+    ) external view returns (bytes memory) {
+        return _getMetadata(agentId, metadataKey);
+    }
+
+    /// @inheritdoc IIdentityRegistry
+    function tokenURI(
+        uint256 agentId
+    ) public view override(ERC721A, IIdentityRegistry) returns (string memory) {
+        if (!_exists(agentId)) revert IdentityRegistry__AgentDoesNotExist();
+        return _getAgentUri(agentId);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                      INTERNAL FUNCTIONS                    */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _verifyMetadataLength(MetadataEntry[] calldata metadata) internal pure {
+        uint256 metadataLength = metadata.length;
+        if (metadataLength > MAX_METADATA_ENTRIES)
+            IdentityRegistry__TooManyMetadataEntries.selector.revertWith();
+    }
+
+    function _verifyAgent() internal view {
+        if (_balanceOf(msg.sender) > 0)
+            IdentityRegistry__AgentAlreadyPromoted.selector.revertWith();
+        if (_getLatestAppId(msg.sender) == EMPTY_UID)
+            IdentityRegistry__AgentNotRegistered.selector.revertWith();
+        if (_isBanned(msg.sender)) IdentityRegistry__AgentBanned.selector.revertWith();
+    }
+
+    function _verifyAuthorization(uint256 agentId) internal view {
+        address owner = _ownerOf(agentId);
+        if (
+            msg.sender != owner &&
+            !_isApprovedForAll(owner, msg.sender) &&
+            msg.sender != _getApproved(agentId)
+        ) {
+            revert IdentityRegistry__NotAuthorized();
+        }
+    }
+
+    function _startTokenId() internal pure override returns (uint256) {
+        return 1;
+    }
+}