agentwallet-sdk 3.3.0 → 3.4.1

package/dist/identity/erc8004.js

@@ -6,85 +6,50 @@
  * with URIStorage extension.
  *
  * Spec: https://eips.ethereum.org/EIPS/eip-8004
- * Status: DRAFT (August 2025). No official mainnet singleton deployed yet —
- * registry address is configurable per deployment.
- *
- * Key Principle: Non-custodial. All signing happens locally via the caller's
- * WalletClient. Keys never leave the device.
+ * Status: DRAFT (August 2025). No official mainnet singleton deployed yet.
+ * Key Principle: Non-custodial. All signing happens locally via WalletClient.
  */
 import { createPublicClient, getContract, http, } from 'viem';
 import { base, baseSepolia, mainnet, arbitrum, polygon } from 'viem/chains';
 // ─── ABI ─────────────────────────────────────────────────────────────────────
-/**
- * Minimal ABI for the ERC-8004 Identity Registry.
- * Extends ERC-721 with agent-specific registration functions.
- */
 export const ERC8004IdentityRegistryAbi = [
-    // Registration
     {
-        name: 'register',
-        type: 'function',
-        stateMutability: 'nonpayable',
+        name: 'register', type: 'function', stateMutability: 'nonpayable',
         inputs: [{ name: 'agentURI', type: 'string' }],
         outputs: [{ name: 'agentId', type: 'uint256' }],
     },
     {
-        name: 'registerWithMetadata',
-        type: 'function',
-        stateMutability: 'nonpayable',
+        name: 'registerWithMetadata', type: 'function', stateMutability: 'nonpayable',
         inputs: [
             { name: 'agentURI', type: 'string' },
-            {
-                name: 'metadata',
-                type: 'tuple[]',
-                components: [
+            { name: 'metadata', type: 'tuple[]', components: [
                     { name: 'metadataKey', type: 'string' },
                     { name: 'metadataValue', type: 'bytes' },
-                ],
-            },
+                ] },
         ],
         outputs: [{ name: 'agentId', type: 'uint256' }],
     },
     {
-        name: 'registerEmpty',
-        type: 'function',
-        stateMutability: 'nonpayable',
-        inputs: [],
-        outputs: [{ name: 'agentId', type: 'uint256' }],
+        name: 'registerEmpty', type: 'function', stateMutability: 'nonpayable',
+        inputs: [], outputs: [{ name: 'agentId', type: 'uint256' }],
     },
-    // URI management
     {
-        name: 'setAgentURI',
-        type: 'function',
-        stateMutability: 'nonpayable',
-        inputs: [
-            { name: 'agentId', type: 'uint256' },
-            { name: 'newURI', type: 'string' },
-        ],
+        name: 'setAgentURI', type: 'function', stateMutability: 'nonpayable',
+        inputs: [{ name: 'agentId', type: 'uint256' }, { name: 'newURI', type: 'string' }],
         outputs: [],
     },
     {
-        name: 'tokenURI',
-        type: 'function',
-        stateMutability: 'view',
+        name: 'tokenURI', type: 'function', stateMutability: 'view',
         inputs: [{ name: 'agentId', type: 'uint256' }],
         outputs: [{ name: '', type: 'string' }],
     },
-    // On-chain metadata
     {
-        name: 'getMetadata',
-        type: 'function',
-        stateMutability: 'view',
-        inputs: [
-            { name: 'agentId', type: 'uint256' },
-            { name: 'metadataKey', type: 'string' },
-        ],
+        name: 'getMetadata', type: 'function', stateMutability: 'view',
+        inputs: [{ name: 'agentId', type: 'uint256' }, { name: 'metadataKey', type: 'string' }],
         outputs: [{ name: '', type: 'bytes' }],
     },
     {
-        name: 'setMetadata',
-        type: 'function',
-        stateMutability: 'nonpayable',
+        name: 'setMetadata', type: 'function', stateMutability: 'nonpayable',
         inputs: [
             { name: 'agentId', type: 'uint256' },
             { name: 'metadataKey', type: 'string' },
@@ -92,64 +57,44 @@ export const ERC8004IdentityRegistryAbi = [
         ],
         outputs: [],
     },
-    // Agent wallet (payment address)
     {
-        name: 'getAgentWallet',
-        type: 'function',
-        stateMutability: 'view',
+        name: 'getAgentWallet', type: 'function', stateMutability: 'view',
         inputs: [{ name: 'agentId', type: 'uint256' }],
         outputs: [{ name: '', type: 'address' }],
     },
     {
-        name: 'setAgentWallet',
-        type: 'function',
-        stateMutability: 'nonpayable',
+        name: 'setAgentWallet', type: 'function', stateMutability: 'nonpayable',
         inputs: [
-            { name: 'agentId', type: 'uint256' },
-            { name: 'newWallet', type: 'address' },
-            { name: 'deadline', type: 'uint256' },
-            { name: 'signature', type: 'bytes' },
+            { name: 'agentId', type: 'uint256' }, { name: 'newWallet', type: 'address' },
+            { name: 'deadline', type: 'uint256' }, { name: 'signature', type: 'bytes' },
         ],
         outputs: [],
     },
     {
-        name: 'unsetAgentWallet',
-        type: 'function',
-        stateMutability: 'nonpayable',
-        inputs: [{ name: 'agentId', type: 'uint256' }],
-        outputs: [],
+        name: 'unsetAgentWallet', type: 'function', stateMutability: 'nonpayable',
+        inputs: [{ name: 'agentId', type: 'uint256' }], outputs: [],
     },
-    // ERC-721 ownership
     {
-        name: 'ownerOf',
-        type: 'function',
-        stateMutability: 'view',
+        name: 'ownerOf', type: 'function', stateMutability: 'view',
         inputs: [{ name: 'tokenId', type: 'uint256' }],
         outputs: [{ name: '', type: 'address' }],
     },
-    // Events
     {
-        name: 'Registered',
-        type: 'event',
-        inputs: [
+        name: 'Registered', type: 'event', inputs: [
             { name: 'agentId', type: 'uint256', indexed: true },
             { name: 'agentURI', type: 'string', indexed: false },
             { name: 'owner', type: 'address', indexed: true },
         ],
     },
     {
-        name: 'URIUpdated',
-        type: 'event',
-        inputs: [
+        name: 'URIUpdated', type: 'event', inputs: [
             { name: 'agentId', type: 'uint256', indexed: true },
             { name: 'newURI', type: 'string', indexed: false },
             { name: 'updatedBy', type: 'address', indexed: true },
         ],
     },
     {
-        name: 'MetadataSet',
-        type: 'event',
-        inputs: [
+        name: 'MetadataSet', type: 'event', inputs: [
             { name: 'agentId', type: 'uint256', indexed: true },
             { name: 'indexedMetadataKey', type: 'string', indexed: true },
             { name: 'metadataKey', type: 'string', indexed: false },
@@ -157,73 +102,24 @@ export const ERC8004IdentityRegistryAbi = [
         ],
     },
 ];
-// ─── Reserved metadata keys (per spec) ───────────────────────────────────────
+// ─── Constants ───────────────────────────────────────────────────────────────
 export const METADATA_KEYS = {
-    /** Reserved by spec — set via setAgentWallet(), not setMetadata() */
     AGENT_WALLET: 'agentWallet',
-    /** Optional: AI model identifier */
     MODEL: 'agentModel',
-    /** Optional: model provider */
     MODEL_PROVIDER: 'agentModelProvider',
-    /** Optional: agent version string */
     VERSION: 'agentVersion',
-    /** Optional: JSON-encoded capability tags */
     CAPABILITIES: 'agentCapabilities',
-    /** Optional: agent framework name */
     FRAMEWORK: 'agentFramework',
 };
-/** ERC-8004 registration file type string (MUST match this exactly) */
 export const REGISTRATION_FILE_TYPE = 'https://eips.ethereum.org/EIPS/eip-8004#registration-v1';
-/**
- * Known testnet deployments of ERC-8004 Identity Registry.
- * Mainnet singleton not yet deployed (spec is DRAFT as of Feb 2026).
- * Update these addresses once official deployments are announced.
- */
 export const KNOWN_REGISTRY_ADDRESSES = {
-    // Placeholder — replace with official addresses once deployed
     'base-sepolia': '0x0000000000000000000000000000000000000000',
 };
-// ─── Chain map (mirrors index.ts) ─────────────────────────────────────────────
 const CHAINS = {
-    base,
-    'base-sepolia': baseSepolia,
-    ethereum: mainnet,
-    arbitrum,
-    polygon,
+    base, 'base-sepolia': baseSepolia, ethereum: mainnet, arbitrum, polygon,
 };
+const REGISTERED_TOPIC = '0x6f3c9b7e8c3a5a5f2c3f9b7e8c3a5a5f2c3f9b7e8c3a5a5f2c3f9b7e8c3a5a';
 // ─── Client ──────────────────────────────────────────────────────────────────
-/**
- * ERC-8004 Identity Registry client.
- *
- * Provides type-safe, non-custodial access to the ERC-8004 Identity Registry.
- * All write operations require a WalletClient — keys never leave the caller's device.
- *
- * @example
- * ```typescript
- * import { ERC8004Client } from '@agentwallet/sdk';
- *
- * const identity = new ERC8004Client({
- *   registryAddress: '0xYOUR_REGISTRY',
- *   chain: 'base',
- * });
- *
- * // Register a new agent identity
- * const { txHash, agentId } = await identity.registerAgent(
- *   walletClient,
- *   {
- *     name: 'MyTradingAgent',
- *     description: 'Autonomous DeFi trading agent',
- *     services: [{ name: 'A2A', endpoint: 'https://agent.example/.well-known/agent-card.json' }],
- *     x402Support: true,
- *     active: true,
- *   },
- *   'ipfs://QmYourCID'
- * );
- *
- * // Lookup an agent
- * const agentIdentity = await identity.lookupAgentIdentity(walletClient.account!.address);
- * ```
- */
 export class ERC8004Client {
     constructor(config) {
         this.config = config;
@@ -231,12 +127,8 @@ export class ERC8004Client {
         if (!chain)
             throw new Error(`ERC8004Client: Unsupported chain "${config.chain}"`);
         this.chain = chain;
-        this.publicClient = createPublicClient({
-            chain,
-            transport: http(config.rpcUrl),
-        });
+        this.publicClient = createPublicClient({ chain, transport: http(config.rpcUrl) });
     }
-    /** @internal Get a viem contract instance for read operations */
     getReadContract() {
         return getContract({
             address: this.config.registryAddress,
@@ -244,7 +136,6 @@ export class ERC8004Client {
             client: this.publicClient,
         });
     }
-    /** @internal Get a viem contract instance for read+write operations */
     getWriteContract(walletClient) {
         return getContract({
             address: this.config.registryAddress,
@@ -252,50 +143,24 @@ export class ERC8004Client {
             client: { public: this.publicClient, wallet: walletClient },
         });
     }
-    // ─── Registration ───────────────────────────────────────────────────────
-    /**
-     * Register a new agent identity on-chain.
-     *
-     * Builds a spec-compliant registration file JSON and registers it via
-     * the Identity Registry. The URI can be:
-     * - An IPFS URI you've already pinned: "ipfs://QmYourCID"
-     * - A base64 data URI for fully on-chain storage (auto-generated if not provided)
-     * - An HTTPS URI pointing to a static JSON file
-     *
-     * Non-custodial: the walletClient signs the transaction locally.
-     *
-     * @param walletClient - WalletClient controlling the agent owner key
-     * @param metadata - Agent metadata to include in the registration file
-     * @param agentURI - URI for the registration file (auto-builds data URI if omitted)
-     * @param onChainMetadata - Optional extra on-chain key/value pairs
-     * @returns txHash and agentId (from Registered event)
-     */
     async registerAgent(walletClient, metadata, agentURI, onChainMetadata) {
         if (!walletClient.account)
             throw new Error('ERC8004Client: WalletClient has no account');
-        const registrationFile = {
-            type: REGISTRATION_FILE_TYPE,
-            ...metadata,
-        };
-        // Build data URI if no external URI provided
-        const resolvedURI = agentURI ??
-            buildDataURI(registrationFile);
+        const registrationFile = { type: REGISTRATION_FILE_TYPE, ...metadata };
+        const resolvedURI = agentURI ?? buildDataURI(registrationFile);
         const contract = this.getWriteContract(walletClient);
         let txHash;
         if (onChainMetadata && Object.keys(onChainMetadata).length > 0) {
             const entries = encodeMetadataEntries(onChainMetadata);
             txHash = await contract.write.registerWithMetadata([resolvedURI, entries], {
-                account: walletClient.account,
-                chain: this.chain,
+                account: walletClient.account, chain: this.chain,
             });
         }
         else {
             txHash = await contract.write.register([resolvedURI], {
-                account: walletClient.account,
-                chain: this.chain,
+                account: walletClient.account, chain: this.chain,
             });
         }
-        // Extract agentId from Registered event in receipt
         let agentId = null;
         try {
             const receipt = await this.publicClient.waitForTransactionReceipt({ hash: txHash });
@@ -306,19 +171,10 @@ export class ERC8004Client {
             }
         }
         catch {
-            // agentId remains null; caller can use lookupAgentsByOwner after confirmation
+            // agentId remains null
         }
         return { txHash, agentId };
     }
-    // ─── Lookup ─────────────────────────────────────────────────────────────
-    /**
-     * Look up an agent's full identity by their on-chain token ID.
-     *
-     * Fetches: owner, URI, payment wallet, and attempts to parse the
-     * registration file. Also reads standard on-chain model metadata if present.
-     *
-     * @param agentId - The ERC-721 tokenId assigned during registration
-     */
     async lookupAgentIdentity(agentId) {
         const contract = this.getReadContract();
         const [owner, agentURI, agentWallet] = await Promise.all([
@@ -326,97 +182,50 @@ export class ERC8004Client {
             contract.read.tokenURI([agentId]),
             contract.read.getAgentWallet([agentId]),
         ]);
-        // Attempt to parse registration file from URI
         let registrationFile = null;
         try {
             registrationFile = await resolveAgentURI(agentURI);
         }
-        catch {
-            // URI may be an external HTTPS/IPFS that's unavailable in this context
-        }
-        // Read optional on-chain model metadata
+        catch { /* unavailable */ }
         const modelMetadata = await this.readModelMetadata(agentId);
         return {
-            agentId,
-            owner,
-            agentURI,
-            agentWallet,
-            registrationFile,
-            modelMetadata,
+            agentId, owner: owner, agentURI: agentURI,
+            agentWallet: agentWallet, registrationFile, modelMetadata,
         };
     }
-    /**
-     * Look up an agent's identity by their wallet/owner address.
-     * Scans the Registered event log to find the most recent agentId for this owner.
-     *
-     * @param ownerAddress - The agent owner's Ethereum address
-     * @param fromBlock - Start scanning from this block (default: 0)
-     */
     async lookupAgentByOwner(ownerAddress, fromBlock = 0n) {
         const logs = await this.publicClient.getLogs({
             address: this.config.registryAddress,
             event: {
-                type: 'event',
-                name: 'Registered',
+                type: 'event', name: 'Registered',
                 inputs: [
                     { name: 'agentId', type: 'uint256', indexed: true },
                     { name: 'agentURI', type: 'string', indexed: false },
                     { name: 'owner', type: 'address', indexed: true },
                 ],
             },
-            args: {
-                owner: ownerAddress,
-            },
-            fromBlock,
-            toBlock: 'latest',
+            args: { owner: ownerAddress },
+            fromBlock, toBlock: 'latest',
         });
         if (logs.length === 0)
             return null;
-        // Use the most recently registered agentId
         const latestLog = logs[logs.length - 1];
         const agentId = BigInt(latestLog.args?.agentId ?? 0);
         return this.lookupAgentIdentity(agentId);
     }
-    // ─── URI Management ─────────────────────────────────────────────────────
-    /**
-     * Update the agent's registration file URI.
-     * Only callable by the NFT owner or an approved operator.
-     *
-     * @param walletClient - Owner/operator WalletClient
-     * @param agentId - The agent's tokenId
-     * @param newURI - New URI pointing to updated registration file
-     */
     async updateAgentURI(walletClient, agentId, newURI) {
         if (!walletClient.account)
             throw new Error('ERC8004Client: WalletClient has no account');
         const contract = this.getWriteContract(walletClient);
         return contract.write.setAgentURI([agentId, newURI], {
-            account: walletClient.account,
-            chain: this.chain,
+            account: walletClient.account, chain: this.chain,
         });
     }
-    // ─── On-chain Metadata ──────────────────────────────────────────────────
-    /**
-     * Read a single on-chain metadata value for an agent.
-     *
-     * @param agentId - The agent's tokenId
-     * @param key - Metadata key (see METADATA_KEYS for standard keys)
-     * @returns Raw bytes value, or null if not set
-     */
     async getOnChainMetadata(agentId, key) {
         const contract = this.getReadContract();
         const value = await contract.read.getMetadata([agentId, key]);
         return value === '0x' || value === null ? null : value;
     }
-    /**
-     * Write a single on-chain metadata value for an agent.
-     * Note: the reserved 'agentWallet' key cannot be set via this method.
-     *
-     * @param walletClient - Owner/operator WalletClient
-     * @param agentId - The agent's tokenId
-     * @param key - Metadata key
-     * @param value - UTF-8 string value (will be hex-encoded)
-     */
     async setOnChainMetadata(walletClient, agentId, key, value) {
         if (!walletClient.account)
             throw new Error('ERC8004Client: WalletClient has no account');
@@ -426,18 +235,9 @@ export class ERC8004Client {
         const contract = this.getWriteContract(walletClient);
         const hexValue = stringToHex(value);
         return contract.write.setMetadata([agentId, key, hexValue], {
-            account: walletClient.account,
-            chain: this.chain,
+            account: walletClient.account, chain: this.chain,
         });
     }
-    /**
-     * Write model metadata on-chain for an agent.
-     * Uses the standard METADATA_KEYS constants.
-     *
-     * @param walletClient - Owner/operator WalletClient
-     * @param agentId - The agent's tokenId
-     * @param model - Model metadata object
-     */
     async setModelMetadata(walletClient, agentId, model) {
         const hashes = [];
         const entries = [];
@@ -449,33 +249,20 @@ export class ERC8004Client {
             entries.push([METADATA_KEYS.VERSION, model.version]);
         if (model.framework)
             entries.push([METADATA_KEYS.FRAMEWORK, model.framework]);
-        if (model.capabilities?.length) {
+        if (model.capabilities?.length)
             entries.push([METADATA_KEYS.CAPABILITIES, JSON.stringify(model.capabilities)]);
-        }
         for (const [key, val] of entries) {
             const hash = await this.setOnChainMetadata(walletClient, agentId, key, val);
             hashes.push(hash);
         }
         return hashes;
     }
-    /**
-     * Read all standard model metadata for an agent.
-     * Returns null if no model metadata has been set.
-     */
     async readModelMetadata(agentId) {
-        const keys = [
-            METADATA_KEYS.MODEL,
-            METADATA_KEYS.MODEL_PROVIDER,
-            METADATA_KEYS.VERSION,
-            METADATA_KEYS.FRAMEWORK,
-            METADATA_KEYS.CAPABILITIES,
-        ];
+        const keys = [METADATA_KEYS.MODEL, METADATA_KEYS.MODEL_PROVIDER, METADATA_KEYS.VERSION, METADATA_KEYS.FRAMEWORK, METADATA_KEYS.CAPABILITIES];
         const values = await Promise.all(keys.map((k) => this.getOnChainMetadata(agentId, k)));
         const [modelHex, providerHex, versionHex, frameworkHex, capabilitiesHex] = values;
-        // Check if any model metadata is set
-        if (!modelHex && !providerHex && !versionHex && !frameworkHex && !capabilitiesHex) {
+        if (!modelHex && !providerHex && !versionHex && !frameworkHex && !capabilitiesHex)
             return null;
-        }
         const result = {};
         if (modelHex)
             result.model = hexToString(modelHex);
@@ -495,115 +282,63 @@ export class ERC8004Client {
         }
         return result;
     }
-    // ─── Agent Wallet ────────────────────────────────────────────────────────
-    /**
-     * Get the configured payment wallet for an agent.
-     * Returns zero address if not set (payment defaults to NFT owner).
-     *
-     * @param agentId - The agent's tokenId
-     */
     async getAgentWallet(agentId) {
         const contract = this.getReadContract();
         return contract.read.getAgentWallet([agentId]);
     }
-    /**
-     * Set the payment wallet for an agent.
-     * Requires an EIP-712 signature from the new wallet to prove control.
-     * This prevents draining payments to an attacker-controlled address.
-     *
-     * Non-custodial: the signature is generated locally by the walletClient.
-     *
-     * @param walletClient - Owner WalletClient (must own the agent NFT)
-     * @param agentId - The agent's tokenId
-     * @param newWallet - New payment wallet address
-     * @param deadline - Signature deadline (Unix timestamp)
-     * @param signature - EIP-712 or ERC-1271 signature from newWallet proving control
-     */
     async setAgentWallet(walletClient, agentId, newWallet, deadline, signature) {
         if (!walletClient.account)
             throw new Error('ERC8004Client: WalletClient has no account');
         const contract = this.getWriteContract(walletClient);
-        return contract.write.setAgentWallet([agentId, newWallet, deadline, signature], { account: walletClient.account, chain: this.chain });
+        return contract.write.setAgentWallet([agentId, newWallet, deadline, signature], {
+            account: walletClient.account, chain: this.chain,
+        });
     }
-    /**
-     * Clear the agent wallet (resets payment address to NFT owner).
-     *
-     * @param walletClient - Owner WalletClient
-     * @param agentId - The agent's tokenId
-     */
     async unsetAgentWallet(walletClient, agentId) {
         if (!walletClient.account)
             throw new Error('ERC8004Client: WalletClient has no account');
         const contract = this.getWriteContract(walletClient);
         return contract.write.unsetAgentWallet([agentId], {
-            account: walletClient.account,
-            chain: this.chain,
+            account: walletClient.account, chain: this.chain,
         });
     }
 }
 // ─── Standalone helpers ───────────────────────────────────────────────────────
-/**
- * Build a base64 data URI from an agent registration file.
- * Enables fully on-chain metadata storage without IPFS or HTTPS dependencies.
- *
- * @example
- * const uri = buildDataURI({ name: 'MyAgent', description: '...', ... });
- * // → "data:application/json;base64,eyJ0..."
- */
 export function buildDataURI(registrationFile) {
-    // Ensure type field isn't duplicated if registrationFile already has it
     const payload = { ...registrationFile, type: REGISTRATION_FILE_TYPE };
     const json = JSON.stringify(payload);
-    // btoa requires Latin1 — use encodeURIComponent to handle UTF-8 safely
     const b64 = btoa(unescape(encodeURIComponent(json)));
     return `data:application/json;base64,${b64}`;
 }
-/**
- * Parse a data URI or plain JSON string into an AgentRegistrationFile.
- * For HTTPS/IPFS URIs, use resolveAgentURI() instead.
- */
 export function parseDataURI(uri) {
     if (uri.startsWith('data:application/json;base64,')) {
         const b64 = uri.replace('data:application/json;base64,', '');
         const json = decodeURIComponent(escape(atob(b64)));
         return JSON.parse(json);
     }
-    if (uri.startsWith('{')) {
+    if (uri.startsWith('{'))
         return JSON.parse(uri);
-    }
-    throw new Error(`parseDataURI: Cannot parse URI scheme — use resolveAgentURI for HTTP/IPFS: ${uri.substring(0, 50)}`);
+    throw new Error(`parseDataURI: Cannot parse URI scheme: ${uri.substring(0, 50)}`);
 }
-/**
- * Resolve an agentURI to its registration file.
- * Supports: data URIs (inline), HTTPS (fetch), IPFS (not fetched — throws).
- */
 export async function resolveAgentURI(uri) {
-    if (uri.startsWith('data:')) {
+    if (uri.startsWith('data:'))
         return parseDataURI(uri);
-    }
     if (uri.startsWith('https://') || uri.startsWith('http://')) {
         const response = await fetch(uri);
         if (!response.ok)
             throw new Error(`resolveAgentURI: HTTP ${response.status} for ${uri}`);
         return response.json();
     }
-    throw new Error(`resolveAgentURI: Unsupported URI scheme. Pin to IPFS or use data URI: ${uri}`);
+    throw new Error(`resolveAgentURI: Unsupported URI scheme: ${uri}`);
 }
-/**
- * Validate an AgentRegistrationFile against ERC-8004 requirements.
- * Returns an array of validation errors (empty = valid).
- */
 export function validateRegistrationFile(file) {
     const errors = [];
-    if (file.type !== REGISTRATION_FILE_TYPE) {
+    if (file.type !== REGISTRATION_FILE_TYPE)
         errors.push(`type must be "${REGISTRATION_FILE_TYPE}"`);
-    }
-    if (!file.name || typeof file.name !== 'string' || file.name.trim() === '') {
-        errors.push('name is required and must be a non-empty string');
-    }
-    if (!file.description || typeof file.description !== 'string') {
+    if (!file.name || typeof file.name !== 'string' || file.name.trim() === '')
+        errors.push('name is required');
+    if (!file.description || typeof file.description !== 'string')
         errors.push('description is required');
-    }
     if (file.services) {
         file.services.forEach((svc, i) => {
             if (!svc.name)
@@ -622,29 +357,18 @@ export function validateRegistrationFile(file) {
     }
     return errors;
 }
-/**
- * Format an agent registry identifier per ERC-8004 spec.
- *
- * @param chainId - Chain ID (e.g. 8453 for Base)
- * @param registryAddress - Identity Registry contract address
- * @returns "{namespace}:{chainId}:{identityRegistry}" e.g. "eip155:8453:0x742..."
- */
 export function formatAgentRegistry(chainId, registryAddress) {
     return `eip155:${chainId}:${registryAddress}`;
 }
 // ─── Internal utilities ───────────────────────────────────────────────────────
-/** keccak256 topic for Registered(uint256 indexed, string, address indexed) */
-const REGISTERED_TOPIC = '0x6f3c9b7e8c3a5a5f2c3f9b7e8c3a5a5f2c3f9b7e8c3a5a5f2c3f9b7e8c3a5a';
 function stringToHex(str) {
     const bytes = new TextEncoder().encode(str);
-    const hexStr = Array.from(bytes)
-        .map((b) => b.toString(16).padStart(2, '0'))
-        .join('');
+    const hexStr = Array.from(bytes).map((b) => b.toString(16).padStart(2, '0')).join('');
     return ('0x' + hexStr);
 }
 function hexToString(hex) {
     const stripped = hex.startsWith('0x') ? hex.slice(2) : hex;
-    const bytes = new Uint8Array(stripped.match(/.{1,2}/g).map(byte => parseInt(byte, 16)));
+    const bytes = new Uint8Array(stripped.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
     return new TextDecoder('utf-8').decode(bytes);
 }
 function encodeMetadataEntries(entries) {