@ch4r10teer41/clawpass 1.0.1

package/dist/index.js

@@ -0,0 +1,1169 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentRegistrationFileSchema: () => AgentRegistrationFileSchema,
+  AgentRegistrationSchema: () => AgentRegistrationSchema,
+  AgentServiceSchema: () => AgentServiceSchema,
+  ClawpassClient: () => ClawpassClient,
+  FeedbackFileSchema: () => FeedbackFileSchema,
+  IdentityRegistryABI: () => IdentityRegistry_default,
+  IdentityRegistryClient: () => IdentityRegistryClient,
+  ReputationRegistryABI: () => ReputationRegistry_default,
+  ReputationRegistryClient: () => ReputationRegistryClient,
+  ValidationRegistryABI: () => ValidationRegistry_default,
+  ValidationRegistryClient: () => ValidationRegistryClient,
+  calculateAverageFeedback: () => calculateAverageFeedback,
+  calculateHash: () => calculateHash,
+  createDataURI: () => createDataURI,
+  createFeedbackFile: () => createFeedbackFile,
+  createIPFSUri: () => createIPFSUri,
+  decodeMetadata: () => decodeMetadata,
+  encodeMetadata: () => encodeMetadata,
+  extractCIDFromIPFS: () => extractCIDFromIPFS,
+  formatAgentRegistry: () => formatAgentRegistry,
+  formatAgentRegistryString: () => formatAgentRegistryString,
+  fromFixedPoint: () => fromFixedPoint,
+  ipfsToHTTP: () => ipfsToHTTP,
+  parseAgentRegistry: () => parseAgentRegistry,
+  parseAgentRegistryString: () => parseAgentRegistryString,
+  parseDataURI: () => parseDataURI,
+  toFixedPoint: () => toFixedPoint,
+  verifyHash: () => verifyHash
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/clients/IdentityRegistryClient.ts
+var import_ethers = require("ethers");
+
+// src/abis/IdentityRegistry.json
+var IdentityRegistry_default = [
+  {
+    type: "function",
+    name: "register",
+    inputs: [
+      { name: "agentURI", type: "string" },
+      {
+        name: "metadata",
+        type: "tuple[]",
+        components: [
+          { name: "metadataKey", type: "string" },
+          { name: "metadataValue", type: "bytes" }
+        ]
+      }
+    ],
+    outputs: [{ name: "agentId", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "register",
+    inputs: [{ name: "agentURI", type: "string" }],
+    outputs: [{ name: "agentId", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "register",
+    inputs: [],
+    outputs: [{ name: "agentId", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setAgentURI",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "newURI", type: "string" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "tokenURI",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getMetadata",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "metadataKey", type: "string" }
+    ],
+    outputs: [{ name: "", type: "bytes" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "setMetadata",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "metadataKey", type: "string" },
+      { name: "metadataValue", type: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getAgentWallet",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "setAgentWallet",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "newWallet", type: "address" },
+      { name: "deadline", type: "uint256" },
+      { name: "signature", type: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "unsetAgentWallet",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "ownerOf",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "Registered",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "agentURI", type: "string", indexed: false },
+      { name: "owner", type: "address", indexed: true }
+    ]
+  },
+  {
+    type: "event",
+    name: "URIUpdated",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "newURI", type: "string", indexed: false },
+      { name: "updatedBy", type: "address", indexed: true }
+    ]
+  },
+  {
+    type: "event",
+    name: "MetadataSet",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "indexedMetadataKey", type: "string", indexed: true },
+      { name: "metadataKey", type: "string", indexed: false },
+      { name: "metadataValue", type: "bytes", indexed: false }
+    ]
+  }
+];
+
+// src/schemas/index.ts
+var import_zod = require("zod");
+var AgentServiceSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  endpoint: import_zod.z.string(),
+  version: import_zod.z.string().optional(),
+  skills: import_zod.z.array(import_zod.z.string()).optional(),
+  domains: import_zod.z.array(import_zod.z.string()).optional()
+});
+var AgentRegistrationSchema = import_zod.z.object({
+  agentId: import_zod.z.number(),
+  agentRegistry: import_zod.z.string().regex(/^[^:]+:[^:]+:0x[a-fA-F0-9]{40}$/)
+});
+var AgentRegistrationFileSchema = import_zod.z.object({
+  type: import_zod.z.literal("https://eips.ethereum.org/EIPS/eip-8004#registration-v1"),
+  name: import_zod.z.string(),
+  description: import_zod.z.string(),
+  image: import_zod.z.string().optional(),
+  services: import_zod.z.array(AgentServiceSchema),
+  x402Support: import_zod.z.boolean(),
+  active: import_zod.z.boolean(),
+  registrations: import_zod.z.array(AgentRegistrationSchema),
+  supportedTrust: import_zod.z.array(import_zod.z.enum(["reputation", "crypto-economic", "tee-attestation"])).optional()
+});
+var FeedbackFileSchema = import_zod.z.object({
+  agentRegistry: import_zod.z.string(),
+  agentId: import_zod.z.number(),
+  clientAddress: import_zod.z.string(),
+  createdAt: import_zod.z.string(),
+  value: import_zod.z.number(),
+  valueDecimals: import_zod.z.number().min(0).max(18),
+  tag1: import_zod.z.string().optional(),
+  tag2: import_zod.z.string().optional(),
+  endpoint: import_zod.z.string().optional(),
+  mcp: import_zod.z.object({
+    tool: import_zod.z.string().optional(),
+    prompt: import_zod.z.string().optional(),
+    resource: import_zod.z.string().optional()
+  }).optional(),
+  a2a: import_zod.z.object({
+    skills: import_zod.z.array(import_zod.z.string()).optional(),
+    contextId: import_zod.z.string().optional(),
+    taskId: import_zod.z.string().optional()
+  }).optional(),
+  oasf: import_zod.z.object({
+    skills: import_zod.z.array(import_zod.z.string()).optional(),
+    domains: import_zod.z.array(import_zod.z.string()).optional()
+  }).optional(),
+  proofOfPayment: import_zod.z.object({
+    fromAddress: import_zod.z.string(),
+    toAddress: import_zod.z.string(),
+    chainId: import_zod.z.string(),
+    txHash: import_zod.z.string()
+  }).optional()
+});
+
+// src/clients/IdentityRegistryClient.ts
+var IdentityRegistryClient = class {
+  constructor(contractAddress, providerOrSigner) {
+    if ("provider" in providerOrSigner && providerOrSigner.provider) {
+      this.signer = providerOrSigner;
+      this.contract = new import_ethers.Contract(contractAddress, IdentityRegistry_default, this.signer);
+    } else {
+      this.contract = new import_ethers.Contract(contractAddress, IdentityRegistry_default, providerOrSigner);
+    }
+  }
+  /**
+   * Register a new agent with URI and optional metadata
+   */
+  async register(agentURI, metadata) {
+    if (!this.signer) {
+      throw new Error("Signer required for registration");
+    }
+    let tx;
+    if (agentURI && metadata && metadata.length > 0) {
+      const formattedMetadata = metadata.map((m) => ({
+        metadataKey: m.metadataKey,
+        metadataValue: m.metadataValue
+      }));
+      tx = await this.contract["register(string,(string,bytes)[])"](agentURI, formattedMetadata);
+    } else if (agentURI) {
+      tx = await this.contract["register(string)"](agentURI);
+    } else {
+      tx = await this.contract["register()"]();
+    }
+    const receipt = await tx.wait();
+    const event = receipt.logs.find(
+      (log) => log.fragment && log.fragment.name === "Registered"
+    );
+    if (!event) {
+      throw new Error("Registration event not found");
+    }
+    return event.args.agentId;
+  }
+  /**
+   * Update the agent URI
+   */
+  async setAgentURI(agentId, newURI) {
+    if (!this.signer) {
+      throw new Error("Signer required for updating URI");
+    }
+    const tx = await this.contract.setAgentURI(agentId, newURI);
+    await tx.wait();
+  }
+  /**
+   * Get the agent URI (tokenURI)
+   */
+  async getAgentURI(agentId) {
+    return await this.contract.tokenURI(agentId);
+  }
+  /**
+   * Fetch and parse the agent registration file from URI
+   */
+  async getAgentRegistrationFile(agentId) {
+    const uri = await this.getAgentURI(agentId);
+    let content;
+    if (uri.startsWith("data:")) {
+      const base64Data = uri.split(",")[1];
+      content = Buffer.from(base64Data, "base64").toString("utf-8");
+    } else if (uri.startsWith("ipfs://")) {
+      const cid = uri.replace("ipfs://", "");
+      const response = await fetch(`https://ipfs.io/ipfs/${cid}`);
+      content = await response.text();
+    } else if (uri.startsWith("http://") || uri.startsWith("https://")) {
+      const response = await fetch(uri);
+      content = await response.text();
+    } else {
+      throw new Error(`Unsupported URI scheme: ${uri}`);
+    }
+    const data = JSON.parse(content);
+    return AgentRegistrationFileSchema.parse(data);
+  }
+  /**
+   * Set metadata for an agent
+   */
+  async setMetadata(agentId, metadataKey, metadataValue) {
+    if (!this.signer) {
+      throw new Error("Signer required for setting metadata");
+    }
+    const tx = await this.contract.setMetadata(agentId, metadataKey, metadataValue);
+    await tx.wait();
+  }
+  /**
+   * Get metadata for an agent
+   */
+  async getMetadata(agentId, metadataKey) {
+    return await this.contract.getMetadata(agentId, metadataKey);
+  }
+  /**
+   * Get the agent wallet address
+   */
+  async getAgentWallet(agentId) {
+    return await this.contract.getAgentWallet(agentId);
+  }
+  /**
+   * Set the agent wallet with signature
+   */
+  async setAgentWallet(agentId, newWallet, deadline, signature) {
+    if (!this.signer) {
+      throw new Error("Signer required for setting agent wallet");
+    }
+    const tx = await this.contract.setAgentWallet(agentId, newWallet, deadline, signature);
+    await tx.wait();
+  }
+  /**
+   * Unset the agent wallet
+   */
+  async unsetAgentWallet(agentId) {
+    if (!this.signer) {
+      throw new Error("Signer required for unsetting agent wallet");
+    }
+    const tx = await this.contract.unsetAgentWallet(agentId);
+    await tx.wait();
+  }
+  /**
+   * Get the owner of an agent
+   */
+  async getOwner(agentId) {
+    return await this.contract.ownerOf(agentId);
+  }
+  /**
+   * Create a signature for setting agent wallet (EIP-712)
+   */
+  async createAgentWalletSignature(agentId, newWallet, deadline, chainId) {
+    if (!this.signer) {
+      throw new Error("Signer required for creating signature");
+    }
+    const domain = {
+      name: "IdentityRegistry",
+      version: "1",
+      chainId,
+      verifyingContract: await this.contract.getAddress()
+    };
+    const types = {
+      SetAgentWallet: [
+        { name: "agentId", type: "uint256" },
+        { name: "newWallet", type: "address" },
+        { name: "deadline", type: "uint256" }
+      ]
+    };
+    const value = {
+      agentId,
+      newWallet,
+      deadline
+    };
+    return await this.signer.signTypedData(domain, types, value);
+  }
+};
+
+// src/clients/ReputationRegistryClient.ts
+var import_ethers2 = require("ethers");
+
+// src/abis/ReputationRegistry.json
+var ReputationRegistry_default = [
+  {
+    type: "function",
+    name: "initialize",
+    inputs: [{ name: "identityRegistry_", type: "address" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getIdentityRegistry",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "giveFeedback",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "value", type: "int128" },
+      { name: "valueDecimals", type: "uint8" },
+      { name: "tag1", type: "string" },
+      { name: "tag2", type: "string" },
+      { name: "endpoint", type: "string" },
+      { name: "feedbackURI", type: "string" },
+      { name: "feedbackHash", type: "bytes32" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "revokeFeedback",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "feedbackIndex", type: "uint64" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "appendResponse",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "clientAddress", type: "address" },
+      { name: "feedbackIndex", type: "uint64" },
+      { name: "responseURI", type: "string" },
+      { name: "responseHash", type: "bytes32" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getSummary",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "clientAddresses", type: "address[]" },
+      { name: "tag1", type: "string" },
+      { name: "tag2", type: "string" }
+    ],
+    outputs: [
+      { name: "count", type: "uint64" },
+      { name: "summaryValue", type: "int128" },
+      { name: "summaryValueDecimals", type: "uint8" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "readFeedback",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "clientAddress", type: "address" },
+      { name: "feedbackIndex", type: "uint64" }
+    ],
+    outputs: [
+      { name: "value", type: "int128" },
+      { name: "valueDecimals", type: "uint8" },
+      { name: "tag1", type: "string" },
+      { name: "tag2", type: "string" },
+      { name: "isRevoked", type: "bool" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "readAllFeedback",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "clientAddresses", type: "address[]" },
+      { name: "tag1", type: "string" },
+      { name: "tag2", type: "string" },
+      { name: "includeRevoked", type: "bool" }
+    ],
+    outputs: [
+      { name: "clients", type: "address[]" },
+      { name: "feedbackIndexes", type: "uint64[]" },
+      { name: "values", type: "int128[]" },
+      { name: "valueDecimals", type: "uint8[]" },
+      { name: "tag1s", type: "string[]" },
+      { name: "tag2s", type: "string[]" },
+      { name: "revokedStatuses", type: "bool[]" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getResponseCount",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "clientAddress", type: "address" },
+      { name: "feedbackIndex", type: "uint64" },
+      { name: "responders", type: "address[]" }
+    ],
+    outputs: [{ name: "count", type: "uint64" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getClients",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ name: "", type: "address[]" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getLastIndex",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "clientAddress", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint64" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "NewFeedback",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "clientAddress", type: "address", indexed: true },
+      { name: "feedbackIndex", type: "uint64", indexed: false },
+      { name: "value", type: "int128", indexed: false },
+      { name: "valueDecimals", type: "uint8", indexed: false },
+      { name: "indexedTag1", type: "string", indexed: true },
+      { name: "tag1", type: "string", indexed: false },
+      { name: "tag2", type: "string", indexed: false },
+      { name: "endpoint", type: "string", indexed: false },
+      { name: "feedbackURI", type: "string", indexed: false },
+      { name: "feedbackHash", type: "bytes32", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "FeedbackRevoked",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "clientAddress", type: "address", indexed: true },
+      { name: "feedbackIndex", type: "uint64", indexed: true }
+    ]
+  },
+  {
+    type: "event",
+    name: "ResponseAppended",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "clientAddress", type: "address", indexed: true },
+      { name: "feedbackIndex", type: "uint64", indexed: false },
+      { name: "responder", type: "address", indexed: true },
+      { name: "responseURI", type: "string", indexed: false },
+      { name: "responseHash", type: "bytes32", indexed: false }
+    ]
+  }
+];
+
+// src/clients/ReputationRegistryClient.ts
+var ReputationRegistryClient = class {
+  constructor(contractAddress, providerOrSigner) {
+    if ("provider" in providerOrSigner && providerOrSigner.provider) {
+      this.signer = providerOrSigner;
+      this.contract = new import_ethers2.Contract(contractAddress, ReputationRegistry_default, this.signer);
+    } else {
+      this.contract = new import_ethers2.Contract(contractAddress, ReputationRegistry_default, providerOrSigner);
+    }
+  }
+  /**
+   * Get the identity registry address
+   */
+  async getIdentityRegistry() {
+    return await this.contract.getIdentityRegistry();
+  }
+  /**
+   * Give feedback to an agent
+   */
+  async giveFeedback(feedback) {
+    if (!this.signer) {
+      throw new Error("Signer required for giving feedback");
+    }
+    if (feedback.valueDecimals < 0 || feedback.valueDecimals > 18) {
+      throw new Error("valueDecimals must be between 0 and 18");
+    }
+    const tx = await this.contract.giveFeedback(
+      feedback.agentId,
+      feedback.value,
+      feedback.valueDecimals,
+      feedback.tag1 || "",
+      feedback.tag2 || "",
+      feedback.endpoint || "",
+      feedback.feedbackURI || "",
+      feedback.feedbackHash || import_ethers2.ethers.ZeroHash
+    );
+    await tx.wait();
+  }
+  /**
+   * Revoke feedback
+   */
+  async revokeFeedback(agentId, feedbackIndex) {
+    if (!this.signer) {
+      throw new Error("Signer required for revoking feedback");
+    }
+    const tx = await this.contract.revokeFeedback(agentId, feedbackIndex);
+    await tx.wait();
+  }
+  /**
+   * Append a response to feedback
+   */
+  async appendResponse(agentId, clientAddress, feedbackIndex, responseURI, responseHash) {
+    if (!this.signer) {
+      throw new Error("Signer required for appending response");
+    }
+    const tx = await this.contract.appendResponse(
+      agentId,
+      clientAddress,
+      feedbackIndex,
+      responseURI,
+      responseHash || import_ethers2.ethers.ZeroHash
+    );
+    await tx.wait();
+  }
+  /**
+   * Get feedback summary for an agent
+   */
+  async getSummary(agentId, clientAddresses, tag1, tag2) {
+    if (clientAddresses.length === 0) {
+      throw new Error("clientAddresses must not be empty (Sybil attack prevention)");
+    }
+    const result = await this.contract.getSummary(
+      agentId,
+      clientAddresses,
+      tag1 || "",
+      tag2 || ""
+    );
+    return {
+      count: result.count,
+      summaryValue: result.summaryValue,
+      summaryValueDecimals: result.summaryValueDecimals
+    };
+  }
+  /**
+   * Read a specific feedback
+   */
+  async readFeedback(agentId, clientAddress, feedbackIndex) {
+    const result = await this.contract.readFeedback(agentId, clientAddress, feedbackIndex);
+    return {
+      agentId,
+      clientAddress,
+      feedbackIndex,
+      value: result.value,
+      valueDecimals: Number(result.valueDecimals),
+      tag1: result.tag1,
+      tag2: result.tag2,
+      isRevoked: result.isRevoked
+    };
+  }
+  /**
+   * Read all feedback for an agent with optional filters
+   */
+  async readAllFeedback(agentId, clientAddresses, tag1, tag2, includeRevoked = false) {
+    const result = await this.contract.readAllFeedback(
+      agentId,
+      clientAddresses || [],
+      tag1 || "",
+      tag2 || "",
+      includeRevoked
+    );
+    const feedback = [];
+    for (let i = 0; i < result.clients.length; i++) {
+      feedback.push({
+        agentId,
+        clientAddress: result.clients[i],
+        feedbackIndex: result.feedbackIndexes[i],
+        value: result.values[i],
+        valueDecimals: Number(result.valueDecimals[i]),
+        tag1: result.tag1s[i],
+        tag2: result.tag2s[i],
+        isRevoked: result.revokedStatuses[i]
+      });
+    }
+    return feedback;
+  }
+  /**
+   * Get response count for feedback
+   */
+  async getResponseCount(agentId, clientAddress, feedbackIndex, responders) {
+    return await this.contract.getResponseCount(
+      agentId,
+      clientAddress || import_ethers2.ethers.ZeroAddress,
+      feedbackIndex || 0n,
+      responders || []
+    );
+  }
+  /**
+   * Get all clients who gave feedback to an agent
+   */
+  async getClients(agentId) {
+    return await this.contract.getClients(agentId);
+  }
+  /**
+   * Get the last feedback index for a client-agent pair
+   */
+  async getLastIndex(agentId, clientAddress) {
+    return await this.contract.getLastIndex(agentId, clientAddress);
+  }
+  /**
+   * Fetch and parse feedback file from URI
+   */
+  async getFeedbackFile(feedbackURI) {
+    let content;
+    if (feedbackURI.startsWith("ipfs://")) {
+      const cid = feedbackURI.replace("ipfs://", "");
+      const response = await fetch(`https://ipfs.io/ipfs/${cid}`);
+      content = await response.text();
+    } else if (feedbackURI.startsWith("http://") || feedbackURI.startsWith("https://")) {
+      const response = await fetch(feedbackURI);
+      content = await response.text();
+    } else {
+      throw new Error(`Unsupported URI scheme: ${feedbackURI}`);
+    }
+    const data = JSON.parse(content);
+    return FeedbackFileSchema.parse(data);
+  }
+  /**
+   * Calculate hash for feedback file content
+   */
+  static calculateFeedbackHash(content) {
+    return import_ethers2.ethers.keccak256(import_ethers2.ethers.toUtf8Bytes(content));
+  }
+};
+
+// src/clients/ValidationRegistryClient.ts
+var import_ethers3 = require("ethers");
+
+// src/abis/ValidationRegistry.json
+var ValidationRegistry_default = [
+  {
+    type: "function",
+    name: "initialize",
+    inputs: [{ name: "identityRegistry_", type: "address" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getIdentityRegistry",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "validationRequest",
+    inputs: [
+      { name: "validatorAddress", type: "address" },
+      { name: "agentId", type: "uint256" },
+      { name: "requestURI", type: "string" },
+      { name: "requestHash", type: "bytes32" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "validationResponse",
+    inputs: [
+      { name: "requestHash", type: "bytes32" },
+      { name: "response", type: "uint8" },
+      { name: "responseURI", type: "string" },
+      { name: "responseHash", type: "bytes32" },
+      { name: "tag", type: "string" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getValidationStatus",
+    inputs: [{ name: "requestHash", type: "bytes32" }],
+    outputs: [
+      { name: "validatorAddress", type: "address" },
+      { name: "agentId", type: "uint256" },
+      { name: "response", type: "uint8" },
+      { name: "responseHash", type: "bytes32" },
+      { name: "tag", type: "string" },
+      { name: "lastUpdate", type: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getSummary",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "validatorAddresses", type: "address[]" },
+      { name: "tag", type: "string" }
+    ],
+    outputs: [
+      { name: "count", type: "uint64" },
+      { name: "averageResponse", type: "uint8" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAgentValidations",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ name: "", type: "bytes32[]" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getValidatorRequests",
+    inputs: [{ name: "validatorAddress", type: "address" }],
+    outputs: [{ name: "", type: "bytes32[]" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "ValidationRequest",
+    inputs: [
+      { name: "validatorAddress", type: "address", indexed: true },
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "requestURI", type: "string", indexed: false },
+      { name: "requestHash", type: "bytes32", indexed: true }
+    ]
+  },
+  {
+    type: "event",
+    name: "ValidationResponse",
+    inputs: [
+      { name: "validatorAddress", type: "address", indexed: true },
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "requestHash", type: "bytes32", indexed: true },
+      { name: "response", type: "uint8", indexed: false },
+      { name: "responseURI", type: "string", indexed: false },
+      { name: "responseHash", type: "bytes32", indexed: false },
+      { name: "tag", type: "string", indexed: false }
+    ]
+  }
+];
+
+// src/clients/ValidationRegistryClient.ts
+var ValidationRegistryClient = class {
+  constructor(contractAddress, providerOrSigner) {
+    if ("provider" in providerOrSigner && providerOrSigner.provider) {
+      this.signer = providerOrSigner;
+      this.contract = new import_ethers3.Contract(contractAddress, ValidationRegistry_default, this.signer);
+    } else {
+      this.contract = new import_ethers3.Contract(contractAddress, ValidationRegistry_default, providerOrSigner);
+    }
+  }
+  /**
+   * Get the identity registry address
+   */
+  async getIdentityRegistry() {
+    return await this.contract.getIdentityRegistry();
+  }
+  /**
+   * Submit a validation request
+   */
+  async validationRequest(request) {
+    if (!this.signer) {
+      throw new Error("Signer required for validation request");
+    }
+    const tx = await this.contract.validationRequest(
+      request.validatorAddress,
+      request.agentId,
+      request.requestURI,
+      request.requestHash
+    );
+    await tx.wait();
+  }
+  /**
+   * Submit a validation response (called by validator)
+   */
+  async validationResponse(response) {
+    if (!this.signer) {
+      throw new Error("Signer required for validation response");
+    }
+    if (response.response < 0 || response.response > 100) {
+      throw new Error("response must be between 0 and 100");
+    }
+    const tx = await this.contract.validationResponse(
+      response.requestHash,
+      response.response,
+      response.responseURI || "",
+      response.responseHash || import_ethers3.ethers.ZeroHash,
+      response.tag || ""
+    );
+    await tx.wait();
+  }
+  /**
+   * Get validation status for a request
+   */
+  async getValidationStatus(requestHash) {
+    const result = await this.contract.getValidationStatus(requestHash);
+    return {
+      validatorAddress: result.validatorAddress,
+      agentId: result.agentId,
+      response: result.response,
+      responseHash: result.responseHash,
+      tag: result.tag,
+      lastUpdate: result.lastUpdate
+    };
+  }
+  /**
+   * Get validation summary for an agent
+   */
+  async getSummary(agentId, validatorAddresses, tag) {
+    const result = await this.contract.getSummary(
+      agentId,
+      validatorAddresses || [],
+      tag || ""
+    );
+    return {
+      count: result.count,
+      averageResponse: result.averageResponse
+    };
+  }
+  /**
+   * Get all validation request hashes for an agent
+   */
+  async getAgentValidations(agentId) {
+    return await this.contract.getAgentValidations(agentId);
+  }
+  /**
+   * Get all validation request hashes for a validator
+   */
+  async getValidatorRequests(validatorAddress) {
+    return await this.contract.getValidatorRequests(validatorAddress);
+  }
+  /**
+   * Calculate request hash from request data
+   */
+  static calculateRequestHash(requestData) {
+    return import_ethers3.ethers.keccak256(import_ethers3.ethers.toUtf8Bytes(requestData));
+  }
+  /**
+   * Calculate response hash from response data
+   */
+  static calculateResponseHash(responseData) {
+    return import_ethers3.ethers.keccak256(import_ethers3.ethers.toUtf8Bytes(responseData));
+  }
+};
+
+// src/ClawpassClient.ts
+var ClawpassClient = class {
+  constructor(config) {
+    this.identity = new IdentityRegistryClient(
+      config.identityRegistryAddress,
+      config.providerOrSigner
+    );
+    this.reputation = new ReputationRegistryClient(
+      config.reputationRegistryAddress,
+      config.providerOrSigner
+    );
+    this.validation = new ValidationRegistryClient(
+      config.validationRegistryAddress,
+      config.providerOrSigner
+    );
+  }
+  /**
+   * Verify that reputation and validation registries are linked to the identity registry
+   */
+  async verifyRegistryLinks() {
+    const raw = this.identity["contract"].target;
+    const identityAddress = typeof raw === "string" ? raw : raw.address;
+    const reputationIdentity = await this.reputation.getIdentityRegistry();
+    const validationIdentity = await this.validation.getIdentityRegistry();
+    return reputationIdentity.toLowerCase() === identityAddress.toLowerCase() && validationIdentity.toLowerCase() === identityAddress.toLowerCase();
+  }
+  /**
+   * Get comprehensive agent information
+   */
+  async getAgentInfo(agentId) {
+    const [registrationFile, owner, wallet] = await Promise.all([
+      this.identity.getAgentRegistrationFile(agentId),
+      this.identity.getOwner(agentId),
+      this.identity.getAgentWallet(agentId)
+    ]);
+    return {
+      agentId,
+      owner,
+      wallet,
+      registration: registrationFile
+    };
+  }
+  /**
+   * Get agent reputation summary from trusted clients
+   */
+  async getAgentReputation(agentId, trustedClients, tag1, tag2) {
+    const summary = await this.reputation.getSummary(agentId, trustedClients, tag1, tag2);
+    const allFeedback = await this.reputation.readAllFeedback(agentId, trustedClients, tag1, tag2);
+    return {
+      summary,
+      feedback: allFeedback
+    };
+  }
+  /**
+   * Get agent validation summary
+   */
+  async getAgentValidationSummary(agentId, validatorAddresses, tag) {
+    const summary = await this.validation.getSummary(agentId, validatorAddresses, tag);
+    const validationHashes = await this.validation.getAgentValidations(agentId);
+    return {
+      summary,
+      validationCount: validationHashes.length,
+      validationHashes
+    };
+  }
+};
+
+// src/types/index.ts
+function formatAgentRegistry(registry) {
+  return `${registry.namespace}:${registry.chainId}:${registry.identityRegistry}`;
+}
+function parseAgentRegistry(registryString) {
+  const parts = registryString.split(":");
+  if (parts.length !== 3) {
+    throw new Error("Invalid agent registry format. Expected: namespace:chainId:identityRegistry");
+  }
+  return {
+    namespace: parts[0],
+    chainId: parts[1],
+    identityRegistry: parts[2]
+  };
+}
+
+// src/utils/index.ts
+var import_ethers4 = require("ethers");
+function createDataURI(registrationFile) {
+  const json = JSON.stringify(registrationFile);
+  const base64 = Buffer.from(json).toString("base64");
+  return `data:application/json;base64,${base64}`;
+}
+function parseDataURI(dataURI) {
+  if (!dataURI.startsWith("data:application/json;base64,")) {
+    throw new Error("Invalid data URI format");
+  }
+  const base64Data = dataURI.split(",")[1];
+  const json = Buffer.from(base64Data, "base64").toString("utf-8");
+  return JSON.parse(json);
+}
+function toFixedPoint(value, decimals) {
+  if (decimals < 0 || decimals > 18) {
+    throw new Error("Decimals must be between 0 and 18");
+  }
+  const multiplier = 10 ** decimals;
+  return BigInt(Math.round(value * multiplier));
+}
+function fromFixedPoint(value, decimals) {
+  if (decimals < 0 || decimals > 18) {
+    throw new Error("Decimals must be between 0 and 18");
+  }
+  const divisor = 10 ** decimals;
+  return Number(value) / divisor;
+}
+function createFeedbackFile(agentRegistry, agentId, clientAddress, value, valueDecimals, options) {
+  return {
+    agentRegistry,
+    agentId,
+    clientAddress,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    value,
+    valueDecimals,
+    ...options
+  };
+}
+function calculateHash(content) {
+  return import_ethers4.ethers.keccak256(import_ethers4.ethers.toUtf8Bytes(content));
+}
+function verifyHash(content, hash) {
+  return calculateHash(content) === hash;
+}
+function formatAgentRegistryString(namespace, chainId, identityRegistry) {
+  return `${namespace}:${chainId}:${identityRegistry}`;
+}
+function parseAgentRegistryString(registryString) {
+  const parts = registryString.split(":");
+  if (parts.length !== 3) {
+    throw new Error("Invalid agent registry format");
+  }
+  return {
+    namespace: parts[0],
+    chainId: parts[1],
+    identityRegistry: parts[2]
+  };
+}
+function createIPFSUri(cid) {
+  return `ipfs://${cid}`;
+}
+function extractCIDFromIPFS(ipfsUri) {
+  if (!ipfsUri.startsWith("ipfs://")) {
+    throw new Error("Invalid IPFS URI");
+  }
+  return ipfsUri.replace("ipfs://", "");
+}
+function ipfsToHTTP(ipfsUri, gateway = "https://ipfs.io") {
+  const cid = extractCIDFromIPFS(ipfsUri);
+  return `${gateway}/ipfs/${cid}`;
+}
+function calculateAverageFeedback(feedbackValues) {
+  if (feedbackValues.length === 0) return 0;
+  const total = feedbackValues.reduce((sum, fb) => {
+    return sum + fromFixedPoint(fb.value, fb.decimals);
+  }, 0);
+  return total / feedbackValues.length;
+}
+function encodeMetadata(value) {
+  return import_ethers4.ethers.hexlify(import_ethers4.ethers.toUtf8Bytes(value));
+}
+function decodeMetadata(hexValue) {
+  return import_ethers4.ethers.toUtf8String(hexValue);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentRegistrationFileSchema,
+  AgentRegistrationSchema,
+  AgentServiceSchema,
+  ClawpassClient,
+  FeedbackFileSchema,
+  IdentityRegistryABI,
+  IdentityRegistryClient,
+  ReputationRegistryABI,
+  ReputationRegistryClient,
+  ValidationRegistryABI,
+  ValidationRegistryClient,
+  calculateAverageFeedback,
+  calculateHash,
+  createDataURI,
+  createFeedbackFile,
+  createIPFSUri,
+  decodeMetadata,
+  encodeMetadata,
+  extractCIDFromIPFS,
+  formatAgentRegistry,
+  formatAgentRegistryString,
+  fromFixedPoint,
+  ipfsToHTTP,
+  parseAgentRegistry,
+  parseAgentRegistryString,
+  parseDataURI,
+  toFixedPoint,
+  verifyHash
+});