@aixyz/erc-8004 0.0.6

package/README.md

@@ -0,0 +1,145 @@
+# @aixyz/erc-8004
+
+TypeScript SDK for [ERC-8004](https://eips.ethereum.org/EIPS/eip-8004), the decentralized agent registry standard. Provides contract ABIs, deployed addresses, and Zod schemas for agent registration and feedback files.
+
+## Installation
+
+```bash
+bun add @aixyz/erc-8004
+# or
+npm install @aixyz/erc-8004
+```
+
+## Usage
+
+### Contract Interaction
+
+```typescript
+import { IdentityRegistryAbi, ADDRESSES, CHAIN_ID } from "@aixyz/erc-8004";
+import { createPublicClient, http } from "viem";
+import { sepolia } from "viem/chains";
+
+const client = createPublicClient({
+  chain: sepolia,
+  transport: http(),
+});
+
+const address = ADDRESSES[CHAIN_ID.SEPOLIA].identityRegistry;
+
+const tokenURI = await client.readContract({
+  address,
+  abi: IdentityRegistryAbi,
+  functionName: "tokenURI",
+  args: [1n],
+});
+```
+
+### Parsing Registration Files
+
+```typescript
+import { parseRawRegistrationFile, getServices, hasX402Support } from "@aixyz/erc-8004";
+
+// Parse an existing file fetched from an agent's tokenURI
+const result = parseRawRegistrationFile(fetchedData);
+if (result.success) {
+  const services = getServices(result.data);
+  const supportsPayment = hasX402Support(result.data);
+}
+```
+
+### Creating Registration Files
+
+```typescript
+import { validateRegistrationFile } from "@aixyz/erc-8004";
+
+// Strict validation before on-chain submission — requires type literal and at least one service
+const result = validateRegistrationFile(newFile);
+if (!result.success) {
+  console.error(result.error.issues);
+}
+```
+
+### Parsing Feedback Files
+
+```typescript
+import { parseRawFeedbackFile } from "@aixyz/erc-8004";
+
+const result = parseRawFeedbackFile(fetchedData);
+if (result.success) {
+  const { agentId, value, valueDecimals, clientAddress } = result.data;
+}
+```
+
+### Solidity (Foundry)
+
+```toml
+# foundry.toml
+remappings = ["@aixyz/erc-8004/=node_modules/@aixyz/erc-8004/"]
+```
+
+```solidity
+import { IdentityRegistryUpgradeable } from "@aixyz/erc-8004/contracts/IdentityRegistryUpgradeable.sol";
+import { ReputationRegistryUpgradeable } from "@aixyz/erc-8004/contracts/ReputationRegistryUpgradeable.sol";
+import { ValidationRegistryUpgradeable } from "@aixyz/erc-8004/contracts/ValidationRegistryUpgradeable.sol";
+```
+
+## Supported Chains
+
+**Mainnets:**
+
+| Chain   | Chain ID | Constant           |
+| ------- | -------- | ------------------ |
+| Mainnet | `1`      | `CHAIN_ID.MAINNET` |
+| Base    | `8453`   | `CHAIN_ID.BASE`    |
+| Polygon | `137`    | `CHAIN_ID.POLYGON` |
+| Scroll  | `534352` | `CHAIN_ID.SCROLL`  |
+| Monad   | `143`    | `CHAIN_ID.MONAD`   |
+| BSC     | `56`     | `CHAIN_ID.BSC`     |
+| Gnosis  | `100`    | `CHAIN_ID.GNOSIS`  |
+
+**Testnets:**
+
+| Chain          | Chain ID   | Constant                  |
+| -------------- | ---------- | ------------------------- |
+| Sepolia        | `11155111` | `CHAIN_ID.SEPOLIA`        |
+| Base Sepolia   | `84532`    | `CHAIN_ID.BASE_SEPOLIA`   |
+| Polygon Amoy   | `80002`    | `CHAIN_ID.POLYGON_AMOY`   |
+| Scroll Sepolia | `534351`   | `CHAIN_ID.SCROLL_SEPOLIA` |
+| Monad Testnet  | `10143`    | `CHAIN_ID.MONAD_TESTNET`  |
+| BSC Testnet    | `97`       | `CHAIN_ID.BSC_TESTNET`    |
+
+## ABIs
+
+| Export                  | Description                           |
+| ----------------------- | ------------------------------------- |
+| `IdentityRegistryAbi`   | ERC-721 based agent identity registry |
+| `ReputationRegistryAbi` | Agent reputation/feedback registry    |
+| `ValidationRegistryAbi` | Third-party agent validation registry |
+
+Versioned ABIs (e.g. `IdentityRegistryAbi_V1`, `ReputationRegistryAbi_V3`) are available for pinning. See [CHANGELOG.md](./CHANGELOG.md) for details.
+
+## Contract Addresses
+
+All contracts use UUPS proxies. Addresses are consistent across all chains within each environment.
+
+**Mainnets** (Ethereum, Base, Polygon, Scroll, Monad, BSC, Gnosis):
+
+| Contract             | Address                                      |
+| -------------------- | -------------------------------------------- |
+| `identityRegistry`   | `0x8004A169FB4a3325136EB29fA0ceB6D2e539a432` |
+| `reputationRegistry` | `0x8004BAa17C55a88189AE136b182e5fdA19dE9b63` |
+| `validationRegistry` | `0x8004Cc8439f36fd5F9F049D9fF86523Df6dAAB58` |
+
+**Testnets** (Sepolia, Base Sepolia, Polygon Amoy, Scroll Sepolia, Monad Testnet, BSC Testnet):
+
+| Contract             | Address                                      |
+| -------------------- | -------------------------------------------- |
+| `identityRegistry`   | `0x8004A818BFB912233c491871b3d84c89A494BD9e` |
+| `reputationRegistry` | `0x8004B663056A597Dffe9eCcC1965A193B7388713` |
+| `validationRegistry` | `0x8004Cb1BF31DAf7788923b405b754f57acEB4272` |
+
+## References
+
+- [ERC-8004 Specification](https://eips.ethereum.org/EIPS/eip-8004)
+- [erc-8004-contracts](https://github.com/erc-8004/erc-8004-contracts)
+- [CHANGELOG.md](./CHANGELOG.md) - ABI version history and breaking changes

package/contracts/IdentityRegistryUpgradeable.sol

@@ -0,0 +1,214 @@
+// As copied from https://github.com/erc-8004/erc-8004-contracts/blob/093d7b91eb9c22048d411896ed397d695742a5f8/contracts/IdentityRegistryUpgradeable.sol
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721URIStorageUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol";
+import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import "@openzeppelin/contracts/interfaces/IERC1271.sol";
+
+contract IdentityRegistryUpgradeable is
+    ERC721URIStorageUpgradeable,
+    OwnableUpgradeable,
+    UUPSUpgradeable,
+    EIP712Upgradeable
+{
+    struct MetadataEntry {
+        string metadataKey;
+        bytes metadataValue;
+    }
+
+    /// @custom:storage-location erc7201:erc8004.identity.registry
+    struct IdentityRegistryStorage {
+        uint256 _lastId;
+        // agentId => metadataKey => metadataValue (includes "agentWallet")
+        mapping(uint256 => mapping(string => bytes)) _metadata;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("erc8004.identity.registry")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant IDENTITY_REGISTRY_STORAGE_LOCATION =
+    0xa040f782729de4970518741823ec1276cbcd41a0c7493f62d173341566a04e00;
+
+    function _getIdentityRegistryStorage() private pure returns (IdentityRegistryStorage storage $) {
+        assembly {
+            $.slot := IDENTITY_REGISTRY_STORAGE_LOCATION
+        }
+    }
+
+    event Registered(uint256 indexed agentId, string agentURI, address indexed owner);
+    event MetadataSet(uint256 indexed agentId, string indexed indexedMetadataKey, string metadataKey, bytes metadataValue);
+    event URIUpdated(uint256 indexed agentId, string newURI, address indexed updatedBy);
+
+    bytes32 private constant AGENT_WALLET_SET_TYPEHASH =
+    keccak256("AgentWalletSet(uint256 agentId,address newWallet,address owner,uint256 deadline)");
+    bytes4 private constant ERC1271_MAGICVALUE = 0x1626ba7e;
+    uint256 private constant MAX_DEADLINE_DELAY = 5 minutes;
+    bytes32 private constant RESERVED_AGENT_WALLET_KEY_HASH = keccak256("agentWallet");
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize() public reinitializer(2) onlyOwner {
+        __ERC721_init("AgentIdentity", "AGENT");
+        __ERC721URIStorage_init();
+        __EIP712_init("ERC8004IdentityRegistry", "1");
+    }
+
+    function register() external returns (uint256 agentId) {
+        IdentityRegistryStorage storage $ = _getIdentityRegistryStorage();
+        agentId = $._lastId++;
+        $._metadata[agentId]["agentWallet"] = abi.encodePacked(msg.sender);
+        _safeMint(msg.sender, agentId);
+        emit Registered(agentId, "", msg.sender);
+        emit MetadataSet(agentId, "agentWallet", "agentWallet", abi.encodePacked(msg.sender));
+    }
+
+    function register(string memory agentURI) external returns (uint256 agentId) {
+        IdentityRegistryStorage storage $ = _getIdentityRegistryStorage();
+        agentId = $._lastId++;
+        $._metadata[agentId]["agentWallet"] = abi.encodePacked(msg.sender);
+        _safeMint(msg.sender, agentId);
+        _setTokenURI(agentId, agentURI);
+        emit Registered(agentId, agentURI, msg.sender);
+        emit MetadataSet(agentId, "agentWallet", "agentWallet", abi.encodePacked(msg.sender));
+    }
+
+    function register(string memory agentURI, MetadataEntry[] memory metadata) external returns (uint256 agentId) {
+        IdentityRegistryStorage storage $ = _getIdentityRegistryStorage();
+        agentId = $._lastId++;
+        $._metadata[agentId]["agentWallet"] = abi.encodePacked(msg.sender);
+        _safeMint(msg.sender, agentId);
+        _setTokenURI(agentId, agentURI);
+        emit Registered(agentId, agentURI, msg.sender);
+        emit MetadataSet(agentId, "agentWallet", "agentWallet", abi.encodePacked(msg.sender));
+
+        for (uint256 i; i < metadata.length; i++) {
+            require(keccak256(bytes(metadata[i].metadataKey)) != RESERVED_AGENT_WALLET_KEY_HASH, "reserved key");
+            $._metadata[agentId][metadata[i].metadataKey] = metadata[i].metadataValue;
+            emit MetadataSet(agentId, metadata[i].metadataKey, metadata[i].metadataKey, metadata[i].metadataValue);
+        }
+    }
+
+    function getMetadata(uint256 agentId, string memory metadataKey) external view returns (bytes memory) {
+        IdentityRegistryStorage storage $ = _getIdentityRegistryStorage();
+        return $._metadata[agentId][metadataKey];
+    }
+
+    function setMetadata(uint256 agentId, string memory metadataKey, bytes memory metadataValue) external {
+        address agentOwner = _ownerOf(agentId);
+        require(
+            msg.sender == agentOwner ||
+            isApprovedForAll(agentOwner, msg.sender) ||
+            msg.sender == getApproved(agentId),
+            "Not authorized"
+        );
+        require(keccak256(bytes(metadataKey)) != RESERVED_AGENT_WALLET_KEY_HASH, "reserved key");
+        IdentityRegistryStorage storage $ = _getIdentityRegistryStorage();
+        $._metadata[agentId][metadataKey] = metadataValue;
+        emit MetadataSet(agentId, metadataKey, metadataKey, metadataValue);
+    }
+
+    function setAgentURI(uint256 agentId, string calldata newURI) external {
+        address owner = ownerOf(agentId);
+        require(
+            msg.sender == owner ||
+            isApprovedForAll(owner, msg.sender) ||
+            msg.sender == getApproved(agentId),
+            "Not authorized"
+        );
+        _setTokenURI(agentId, newURI);
+        emit URIUpdated(agentId, newURI, msg.sender);
+    }
+
+    function getAgentWallet(uint256 agentId) external view returns (address) {
+        IdentityRegistryStorage storage $ = _getIdentityRegistryStorage();
+        bytes memory walletData = $._metadata[agentId]["agentWallet"];
+        return address(bytes20(walletData));
+    }
+
+    function setAgentWallet(
+        uint256 agentId,
+        address newWallet,
+        uint256 deadline,
+        bytes calldata signature
+    ) external {
+        address owner = ownerOf(agentId);
+        require(
+            msg.sender == owner ||
+            isApprovedForAll(owner, msg.sender) ||
+            msg.sender == getApproved(agentId),
+            "Not authorized"
+        );
+        require(newWallet != address(0), "bad wallet");
+        require(block.timestamp <= deadline, "expired");
+        require(deadline <= block.timestamp + MAX_DEADLINE_DELAY, "deadline too far");
+
+        bytes32 structHash = keccak256(abi.encode(AGENT_WALLET_SET_TYPEHASH, agentId, newWallet, owner, deadline));
+        bytes32 digest = _hashTypedDataV4(structHash);
+
+        // Try ECDSA first (EOAs + EIP-7702 delegated EOAs)
+        (address recovered, ECDSA.RecoverError err, ) = ECDSA.tryRecover(digest, signature);
+        if (err != ECDSA.RecoverError.NoError || recovered != newWallet) {
+            // ECDSA failed, try ERC1271 (smart contract wallets)
+            (bool ok, bytes memory res) = newWallet.staticcall(
+                abi.encodeCall(IERC1271.isValidSignature, (digest, signature))
+            );
+            require(ok && res.length >= 32 && abi.decode(res, (bytes4)) == ERC1271_MAGICVALUE, "invalid wallet sig");
+        }
+
+        IdentityRegistryStorage storage $ = _getIdentityRegistryStorage();
+        $._metadata[agentId]["agentWallet"] = abi.encodePacked(newWallet);
+        emit MetadataSet(agentId, "agentWallet", "agentWallet", abi.encodePacked(newWallet));
+    }
+
+    function unsetAgentWallet(uint256 agentId) external {
+        address owner = ownerOf(agentId);
+        require(
+            msg.sender == owner ||
+            isApprovedForAll(owner, msg.sender) ||
+            msg.sender == getApproved(agentId),
+            "Not authorized"
+        );
+
+        IdentityRegistryStorage storage $ = _getIdentityRegistryStorage();
+        $._metadata[agentId]["agentWallet"] = "";
+        emit MetadataSet(agentId, "agentWallet", "agentWallet", "");
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+
+    /**
+     * @dev Override _update to clear agentWallet on transfer.
+     * This ensures the verified wallet doesn't persist to new owners.
+     * Clear BEFORE super._update() to follow Checks-Effects-Interactions pattern.
+     */
+    function _update(address to, uint256 tokenId, address auth) internal override returns (address) {
+        address from = _ownerOf(tokenId);
+
+        // If this is a transfer (not mint), clear agentWallet BEFORE external call
+        if (from != address(0) && to != address(0)) {
+            IdentityRegistryStorage storage $ = _getIdentityRegistryStorage();
+            $._metadata[tokenId]["agentWallet"] = "";
+            emit MetadataSet(tokenId, "agentWallet", "agentWallet", "");
+        }
+
+        return super._update(to, tokenId, auth);
+    }
+
+    /**
+     * @notice Checks if spender is owner or approved for the agent
+     * @dev Reverts with ERC721NonexistentToken if agent doesn't exist
+     */
+    function isAuthorizedOrOwner(address spender, uint256 agentId) external view returns (bool) {
+        address owner = ownerOf(agentId);
+        return _isAuthorized(owner, spender, agentId);
+    }
+
+    function getVersion() external pure returns (string memory) {
+        return "2.0.0";
+    }
+}