@t402/erc8004 2.7.0

package/dist/cjs/index.cjs

@@ -0,0 +1,704 @@
+"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, {
+  ERC8004_EXTENSION_KEY: () => ERC8004_EXTENSION_KEY,
+  FEEDBACK_TAGS: () => FEEDBACK_TAGS,
+  IDENTITY_REGISTRIES: () => IDENTITY_REGISTRIES,
+  IDENTITY_REGISTRY_DOMAIN: () => IDENTITY_REGISTRY_DOMAIN,
+  REPUTATION_REGISTRIES: () => REPUTATION_REGISTRIES,
+  SET_AGENT_WALLET_TYPES: () => SET_AGENT_WALLET_TYPES,
+  VALIDATION_REGISTRIES: () => VALIDATION_REGISTRIES,
+  buildFeedbackFile: () => buildFeedbackFile,
+  createERC8004PayloadExtension: () => createERC8004PayloadExtension,
+  declareERC8004Extension: () => declareERC8004Extension,
+  erc8004IdentityCheck: () => erc8004IdentityCheck,
+  erc8004ReputationCheck: () => erc8004ReputationCheck,
+  erc8004ResourceServerExtension: () => erc8004ResourceServerExtension,
+  erc8004ServerIdentityCheck: () => erc8004ServerIdentityCheck,
+  erc8004SubmitFeedback: () => erc8004SubmitFeedback,
+  fetchRegistrationFile: () => fetchRegistrationFile,
+  getAgentIdentity: () => getAgentIdentity,
+  getERC8004Extension: () => getERC8004Extension,
+  getReputationSummary: () => getReputationSummary,
+  getValidationStatus: () => getValidationStatus,
+  getValidationSummary: () => getValidationSummary,
+  identityRegistryAbi: () => identityRegistryAbi,
+  parseAgentRegistry: () => parseAgentRegistry,
+  reputationRegistryAbi: () => reputationRegistryAbi,
+  resolveAgent: () => resolveAgent,
+  submitFeedback: () => submitFeedback,
+  submitValidationRequest: () => submitValidationRequest,
+  validationRegistryAbi: () => validationRegistryAbi,
+  verifyAgentIdentity: () => verifyAgentIdentity,
+  verifyAgentIdentityFromTask: () => verifyAgentIdentityFromTask,
+  verifyPayToMatchesAgent: () => verifyPayToMatchesAgent
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/constants.ts
+var IDENTITY_REGISTRIES = {};
+var REPUTATION_REGISTRIES = {};
+var VALIDATION_REGISTRIES = {};
+var ERC8004_EXTENSION_KEY = "erc8004";
+var FEEDBACK_TAGS = {
+  /** tag1: Payment completed successfully */
+  PAYMENT_SUCCESS: "paymentSuccess",
+  /** tag1: Payment verification failed */
+  PAYMENT_FAILED: "paymentFailed",
+  /** tag1: Service quality rating */
+  SERVICE_QUALITY: "starred",
+  /** tag2: Response time measurement */
+  RESPONSE_TIME: "responseTime",
+  /** tag2: Uptime measurement */
+  UPTIME: "uptime"
+};
+var IDENTITY_REGISTRY_DOMAIN = {
+  name: "IdentityRegistry",
+  version: "1"
+};
+var SET_AGENT_WALLET_TYPES = {
+  SetAgentWallet: [
+    { name: "agentId", type: "uint256" },
+    { name: "newWallet", type: "address" },
+    { name: "deadline", type: "uint256" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+
+// src/abis.ts
+var identityRegistryAbi = [
+  {
+    type: "function",
+    name: "register",
+    inputs: [
+      { name: "agentURI", type: "string" },
+      {
+        name: "metadata",
+        type: "tuple[]",
+        components: [
+          { name: "metadataKey", type: "string" },
+          { name: "metadataValue", type: "bytes" }
+        ]
+      }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getAgentWallet",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "tokenURI",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "ownerOf",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getMetadata",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "metadataKey", type: "string" }
+    ],
+    outputs: [{ type: "bytes" }],
+    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: "event",
+    name: "Registered",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "agentURI", type: "string", indexed: false },
+      { name: "owner", type: "address", indexed: true }
+    ]
+  }
+];
+var reputationRegistryAbi = [
+  {
+    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: "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: "revokeFeedback",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "feedbackIndex", type: "uint64" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getClients",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ type: "address[]" }],
+    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 }
+    ]
+  }
+];
+var validationRegistryAbi = [
+  {
+    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: "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/identity.ts
+function parseAgentRegistry(registryId) {
+  const parts = registryId.split(":");
+  if (parts.length < 3) {
+    throw new Error(
+      `Invalid agent registry ID: ${registryId}. Expected format: namespace:chainId:address`
+    );
+  }
+  const namespace = parts[0];
+  const chainId = parts[1];
+  const address = parts.slice(2).join(":");
+  if (!namespace || !chainId || !address) {
+    throw new Error(
+      `Invalid agent registry ID: ${registryId}. All parts must be non-empty`
+    );
+  }
+  return { namespace, chainId, address, id: registryId };
+}
+async function getAgentIdentity(client, identityRegistry, agentId, registryId) {
+  const [agentWallet, owner, agentURI] = await Promise.all([
+    client.readContract({
+      address: identityRegistry,
+      abi: identityRegistryAbi,
+      functionName: "getAgentWallet",
+      args: [agentId]
+    }),
+    client.readContract({
+      address: identityRegistry,
+      abi: identityRegistryAbi,
+      functionName: "ownerOf",
+      args: [agentId]
+    }),
+    client.readContract({
+      address: identityRegistry,
+      abi: identityRegistryAbi,
+      functionName: "tokenURI",
+      args: [agentId]
+    })
+  ]);
+  return {
+    agentId,
+    owner,
+    agentURI,
+    agentWallet,
+    registry: parseAgentRegistry(registryId)
+  };
+}
+async function fetchRegistrationFile(agentURI) {
+  const response = await fetch(agentURI);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch registration file from ${agentURI}: ${response.status}`
+    );
+  }
+  return response.json();
+}
+async function resolveAgent(client, identityRegistry, agentId, registryId) {
+  const identity = await getAgentIdentity(
+    client,
+    identityRegistry,
+    agentId,
+    registryId
+  );
+  const registration = await fetchRegistrationFile(identity.agentURI);
+  return { ...identity, registration };
+}
+async function verifyPayToMatchesAgent(client, identityRegistry, agentId, payTo) {
+  const agentWallet = await client.readContract({
+    address: identityRegistry,
+    abi: identityRegistryAbi,
+    functionName: "getAgentWallet",
+    args: [agentId]
+  });
+  return agentWallet.toLowerCase() === payTo.toLowerCase();
+}
+
+// src/reputation.ts
+async function getReputationSummary(client, reputationRegistry, agentId, trustedReviewers, tag1 = "", tag2 = "") {
+  const result = await client.readContract({
+    address: reputationRegistry,
+    abi: reputationRegistryAbi,
+    functionName: "getSummary",
+    args: [agentId, trustedReviewers, tag1, tag2]
+  });
+  const [count, summaryValue, summaryValueDecimals] = result;
+  const divisor = 10 ** summaryValueDecimals;
+  const normalizedScore = count > 0n ? Math.min(100, Math.max(0, Number(summaryValue) / divisor)) : 0;
+  return {
+    agentId,
+    count,
+    summaryValue,
+    summaryValueDecimals,
+    normalizedScore
+  };
+}
+function buildFeedbackFile(agentId, agentRegistry, clientAddress, value, valueDecimals, tag1, tag2, proofOfPayment) {
+  return {
+    agentRegistry,
+    agentId,
+    clientAddress,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    value,
+    valueDecimals,
+    tag1,
+    tag2,
+    ...proofOfPayment && { proofOfPayment }
+  };
+}
+async function submitFeedback(client, reputationRegistry, params) {
+  return client.writeContract({
+    address: reputationRegistry,
+    abi: reputationRegistryAbi,
+    functionName: "giveFeedback",
+    args: [
+      params.agentId,
+      params.value,
+      params.valueDecimals,
+      params.tag1,
+      params.tag2,
+      params.endpoint ?? "",
+      params.feedbackURI ?? "",
+      params.feedbackHash ?? "0x" + "0".repeat(64)
+    ]
+  });
+}
+
+// src/validation.ts
+async function submitValidationRequest(client, validationRegistry, params) {
+  return client.writeContract({
+    address: validationRegistry,
+    abi: validationRegistryAbi,
+    functionName: "validationRequest",
+    args: [
+      params.validatorAddress,
+      params.agentId,
+      params.requestURI,
+      params.requestHash
+    ]
+  });
+}
+async function getValidationStatus(client, validationRegistry, requestHash) {
+  const result = await client.readContract({
+    address: validationRegistry,
+    abi: validationRegistryAbi,
+    functionName: "getValidationStatus",
+    args: [requestHash]
+  });
+  return {
+    validatorAddress: result[0],
+    agentId: result[1],
+    response: result[2],
+    responseHash: result[3],
+    tag: result[4],
+    lastUpdate: result[5]
+  };
+}
+async function getValidationSummary(client, validationRegistry, agentId, validatorAddresses, tag = "") {
+  const result = await client.readContract({
+    address: validationRegistry,
+    abi: validationRegistryAbi,
+    functionName: "getSummary",
+    args: [agentId, validatorAddresses, tag]
+  });
+  return {
+    count: result[0],
+    averageResponse: result[1]
+  };
+}
+
+// src/extension.ts
+function declareERC8004Extension(agentId, agentRegistry, agentWallet) {
+  return {
+    agentId,
+    agentRegistry,
+    ...agentWallet && { agentWallet }
+  };
+}
+function getERC8004Extension(paymentRequired) {
+  return paymentRequired.extensions?.[ERC8004_EXTENSION_KEY];
+}
+function createERC8004PayloadExtension(agentId, agentRegistry, verified) {
+  return {
+    identityVerified: verified,
+    agentId,
+    agentRegistry
+  };
+}
+async function verifyAgentIdentity(client, paymentRequired) {
+  const ext = getERC8004Extension(paymentRequired);
+  if (!ext) return false;
+  const registry = ext.agentRegistry.split(":");
+  const registryAddress = registry.slice(2).join(":");
+  for (const accept of paymentRequired.accepts) {
+    const matches = await verifyPayToMatchesAgent(
+      client,
+      registryAddress,
+      BigInt(ext.agentId),
+      accept.payTo
+    );
+    if (!matches) return false;
+  }
+  return true;
+}
+function erc8004ResourceServerExtension(config) {
+  return {
+    key: ERC8004_EXTENSION_KEY,
+    enrichDeclaration: async (declaration) => {
+      let enriched = declaration;
+      if (config.reputationRegistry && config.trustedReviewers?.length) {
+        const summary = await getReputationSummary(
+          config.client,
+          config.reputationRegistry,
+          BigInt(enriched.agentId),
+          config.trustedReviewers
+        );
+        enriched = {
+          ...enriched,
+          reputationScore: summary.normalizedScore,
+          feedbackCount: Number(summary.count)
+        };
+      }
+      if (config.validationRegistry && config.trustedValidators?.length) {
+        const summary = await getValidationSummary(
+          config.client,
+          config.validationRegistry,
+          BigInt(enriched.agentId),
+          config.trustedValidators
+        );
+        enriched = {
+          ...enriched,
+          validationScore: summary.averageResponse
+        };
+      }
+      return enriched;
+    }
+  };
+}
+
+// src/hooks.ts
+var import_types = require("@t402/core/types");
+function erc8004IdentityCheck(client, options = {}) {
+  const { abortOnFailure = true, abortOnMissing = false } = options;
+  return async (context) => {
+    const ext = getERC8004Extension(context.paymentRequired);
+    if (!ext) {
+      if (abortOnMissing) {
+        return {
+          abort: true,
+          reason: "ERC-8004 extension not present in payment requirements"
+        };
+      }
+      return;
+    }
+    const verified = await verifyAgentIdentity(
+      client,
+      context.paymentRequired
+    );
+    if (!verified && abortOnFailure) {
+      return {
+        abort: true,
+        reason: `ERC-8004 identity verification failed for agent ${ext.agentId} on registry ${ext.agentRegistry}`
+      };
+    }
+  };
+}
+async function verifyAgentIdentityFromTask(client, task) {
+  const paymentRequired = (0, import_types.getPaymentRequired)(task);
+  if (!paymentRequired) return false;
+  return verifyAgentIdentity(client, paymentRequired);
+}
+function getPayloadExtension(context) {
+  return context.paymentPayload.extensions?.[ERC8004_EXTENSION_KEY];
+}
+function erc8004ReputationCheck(client, reputationRegistry, config) {
+  return async (context) => {
+    const ext = getPayloadExtension(context);
+    if (!ext) return;
+    const summary = await getReputationSummary(
+      client,
+      reputationRegistry,
+      BigInt(ext.agentId),
+      config.trustedReviewers,
+      config.tag1 ?? "",
+      config.tag2 ?? ""
+    );
+    if (summary.normalizedScore < config.minScore) {
+      const action = config.onBelowThreshold ?? "reject";
+      if (action === "reject") {
+        return {
+          abort: true,
+          reason: `Agent ${ext.agentId} reputation score ${summary.normalizedScore} is below minimum ${config.minScore}`
+        };
+      }
+      console.warn(
+        `[erc8004] Agent ${ext.agentId} reputation score ${summary.normalizedScore} is below minimum ${config.minScore}`
+      );
+    }
+  };
+}
+function erc8004ServerIdentityCheck(client) {
+  return async (context) => {
+    const ext = getPayloadExtension(context);
+    if (!ext) return;
+    const registry = ext.agentRegistry.split(":");
+    const registryAddress = registry.slice(2).join(":");
+    const matches = await verifyPayToMatchesAgent(
+      client,
+      registryAddress,
+      BigInt(ext.agentId),
+      context.requirements.payTo
+    );
+    if (!matches) {
+      return {
+        abort: true,
+        reason: `payTo address ${context.requirements.payTo} does not match on-chain agentWallet for agent ${ext.agentId}`
+      };
+    }
+  };
+}
+function erc8004SubmitFeedback(writeClient, reputationRegistry, config = {}) {
+  return async (context) => {
+    const ext = getPayloadExtension(context);
+    if (!ext) return;
+    if (!context.result.success) return;
+    const tag1 = config.tag1 ?? FEEDBACK_TAGS.PAYMENT_SUCCESS;
+    const tag2 = config.tag2 ?? "";
+    let feedbackURI = "";
+    const feedbackHash = "0x" + "0".repeat(64);
+    if (config.includeProofOfPayment && context.result.transaction) {
+      buildFeedbackFile(
+        ext.agentId,
+        ext.agentRegistry,
+        context.result.payer ?? "",
+        100,
+        0,
+        tag1,
+        tag2,
+        {
+          fromAddress: context.result.payer ?? "",
+          toAddress: context.requirements.payTo,
+          chainId: context.requirements.network,
+          txHash: context.result.transaction
+        }
+      );
+      if (config.feedbackBaseURI) {
+        feedbackURI = `${config.feedbackBaseURI}/${context.result.transaction}.json`;
+      }
+    }
+    submitFeedback(writeClient, reputationRegistry, {
+      agentId: BigInt(ext.agentId),
+      value: 100n,
+      valueDecimals: 0,
+      tag1,
+      tag2,
+      endpoint: context.paymentPayload.resource?.url,
+      feedbackURI,
+      feedbackHash
+    }).catch((err) => {
+      console.warn(
+        `[erc8004] Failed to submit feedback for agent ${ext.agentId}:`,
+        err
+      );
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ERC8004_EXTENSION_KEY,
+  FEEDBACK_TAGS,
+  IDENTITY_REGISTRIES,
+  IDENTITY_REGISTRY_DOMAIN,
+  REPUTATION_REGISTRIES,
+  SET_AGENT_WALLET_TYPES,
+  VALIDATION_REGISTRIES,
+  buildFeedbackFile,
+  createERC8004PayloadExtension,
+  declareERC8004Extension,
+  erc8004IdentityCheck,
+  erc8004ReputationCheck,
+  erc8004ResourceServerExtension,
+  erc8004ServerIdentityCheck,
+  erc8004SubmitFeedback,
+  fetchRegistrationFile,
+  getAgentIdentity,
+  getERC8004Extension,
+  getReputationSummary,
+  getValidationStatus,
+  getValidationSummary,
+  identityRegistryAbi,
+  parseAgentRegistry,
+  reputationRegistryAbi,
+  resolveAgent,
+  submitFeedback,
+  submitValidationRequest,
+  validationRegistryAbi,
+  verifyAgentIdentity,
+  verifyAgentIdentityFromTask,
+  verifyPayToMatchesAgent
+});