moltlaunch 1.2.4 → 2.0.0

package/src/lib/mandate.ts

@@ -0,0 +1,623 @@
+// MANDATE: ERC-8004 Contract Interactions
+// Identity Registry, Reputation Registry
+// Contracts: https://github.com/erc-8004/erc-8004-contracts
+
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  keccak256,
+  toBytes,
+  type Address,
+  type Log,
+  decodeEventLog,
+} from "viem";
+import { base } from "viem/chains";
+import { privateKeyToAccount } from "viem/accounts";
+import { CONTRACTS, METADATA_KEYS, BASE_RPC_URL } from "./constants.js";
+import type { Agent, ReputationSummary, Wallet } from "./types.js";
+
+// ERC-8004 Identity Registry ABI (from official repo)
+const IDENTITY_REGISTRY_ABI = [
+  // Register with URI and metadata
+  {
+    name: "register",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "agentURI", type: "string" },
+      {
+        name: "metadata",
+        type: "tuple[]",
+        components: [
+          { name: "metadataKey", type: "string" },
+          { name: "metadataValue", type: "bytes" },
+        ],
+      },
+    ],
+    outputs: [{ name: "agentId", type: "uint256" }],
+  },
+  // Register with just URI
+  {
+    name: "register",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "agentURI", type: "string" }],
+    outputs: [{ name: "agentId", type: "uint256" }],
+  },
+  // Register empty
+  {
+    name: "register",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: [{ name: "agentId", type: "uint256" }],
+  },
+  {
+    name: "setAgentWallet",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "newWallet", type: "address" },
+      { name: "deadline", type: "uint256" },
+      { name: "signature", type: "bytes" },
+    ],
+    outputs: [],
+  },
+  {
+    name: "getAgentWallet",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }],
+  },
+  {
+    name: "unsetAgentWallet",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [],
+  },
+  {
+    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",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "metadataKey", type: "string" },
+      { name: "metadataValue", type: "bytes" },
+    ],
+    outputs: [],
+  },
+  {
+    name: "setAgentURI",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "newURI", type: "string" },
+    ],
+    outputs: [],
+  },
+  {
+    name: "tokenURI",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "string" }],
+  },
+  {
+    name: "ownerOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }],
+  },
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+  },
+  // Events
+  {
+    name: "Registered",
+    type: "event",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "agentURI", type: "string", indexed: false },
+      { name: "owner", type: "address", indexed: true },
+    ],
+  },
+  {
+    name: "MetadataSet",
+    type: "event",
+    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 },
+    ],
+  },
+] as const;
+
+// ERC-8004 Reputation Registry ABI (from official repo)
+const REPUTATION_REGISTRY_ABI = [
+  {
+    name: "giveFeedback",
+    type: "function",
+    stateMutability: "nonpayable",
+    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: [],
+  },
+  {
+    name: "getSummary",
+    type: "function",
+    stateMutability: "view",
+    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" },
+    ],
+  },
+  {
+    name: "revokeFeedback",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "feedbackIndex", type: "uint64" },
+    ],
+    outputs: [],
+  },
+  {
+    name: "readFeedback",
+    type: "function",
+    stateMutability: "view",
+    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" },
+    ],
+  },
+  {
+    name: "readAllFeedback",
+    type: "function",
+    stateMutability: "view",
+    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[]" },
+    ],
+  },
+  {
+    name: "getClients",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ name: "", type: "address[]" }],
+  },
+  {
+    name: "getLastIndex",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "clientAddress", type: "address" },
+    ],
+    outputs: [{ name: "", type: "uint64" }],
+  },
+  // Events
+  {
+    name: "NewFeedback",
+    type: "event",
+    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 },
+    ],
+  },
+  {
+    name: "FeedbackRevoked",
+    type: "event",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "clientAddress", type: "address", indexed: true },
+      { name: "feedbackIndex", type: "uint64", indexed: true },
+    ],
+  },
+] as const;
+
+function getPublicClient() {
+  return createPublicClient({
+    chain: base,
+    transport: http(BASE_RPC_URL),
+  });
+}
+
+function getWalletClient(wallet: Wallet) {
+  const account = privateKeyToAccount(wallet.privateKey);
+  return createWalletClient({
+    account,
+    chain: base,
+    transport: http(BASE_RPC_URL),
+  });
+}
+
+// Encode string to bytes for metadata
+function encodeString(value: string): `0x${string}` {
+  return `0x${Buffer.from(value, "utf-8").toString("hex")}`;
+}
+
+// Decode bytes to string from metadata
+function decodeString(value: `0x${string}`): string {
+  if (!value || value === "0x") return "";
+  return Buffer.from(value.slice(2), "hex").toString("utf-8");
+}
+
+// Encode bigint to bytes for metadata (32 bytes, big-endian)
+function encodeBigInt(value: bigint): `0x${string}` {
+  return `0x${value.toString(16).padStart(64, "0")}`;
+}
+
+// Decode bytes to bigint from metadata
+function decodeBigInt(value: `0x${string}`): bigint {
+  if (!value || value === "0x") return 0n;
+  return BigInt(value);
+}
+
+/**
+ * Register a new agent in the ERC-8004 Identity Registry
+ */
+export async function registerAgent(
+  wallet: Wallet,
+  agentURI: string,
+  metadata: {
+    skills: string[];
+    endpoint: string;
+    priceWei: bigint;
+    flaunchToken?: `0x${string}`;
+  }
+): Promise<{ agentId: bigint; txHash: `0x${string}` }> {
+  const client = getWalletClient(wallet);
+  const publicClient = getPublicClient();
+
+  const metadataEntries: Array<{ metadataKey: string; metadataValue: `0x${string}` }> = [
+    { metadataKey: METADATA_KEYS.SKILLS, metadataValue: encodeString(metadata.skills.join(",")) },
+    { metadataKey: METADATA_KEYS.ENDPOINT, metadataValue: encodeString(metadata.endpoint) },
+    { metadataKey: METADATA_KEYS.PRICE_WEI, metadataValue: encodeBigInt(metadata.priceWei) },
+  ];
+
+  if (metadata.flaunchToken) {
+    metadataEntries.push({
+      metadataKey: METADATA_KEYS.FLAUNCH_TOKEN,
+      metadataValue: metadata.flaunchToken,
+    });
+  }
+
+  const txHash = await client.writeContract({
+    address: CONTRACTS.IDENTITY_REGISTRY,
+    abi: IDENTITY_REGISTRY_ABI,
+    functionName: "register",
+    args: [agentURI, metadataEntries],
+  });
+
+  const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+
+  // Parse agentId from Registered event
+  let agentId = 0n;
+  for (const log of receipt.logs) {
+    try {
+      const decoded = decodeEventLog({
+        abi: IDENTITY_REGISTRY_ABI,
+        data: log.data,
+        topics: log.topics,
+      });
+      if (decoded.eventName === "Registered") {
+        agentId = (decoded.args as { agentId: bigint }).agentId;
+        break;
+      }
+    } catch {
+      // Not our event, skip
+    }
+  }
+
+  return { agentId, txHash };
+}
+
+/**
+ * Get agent details from ERC-8004 registries
+ */
+export async function getAgent(agentId: bigint): Promise<Agent | null> {
+  const client = getPublicClient();
+
+  try {
+    // Get owner
+    const owner = await client.readContract({
+      address: CONTRACTS.IDENTITY_REGISTRY,
+      abi: IDENTITY_REGISTRY_ABI,
+      functionName: "ownerOf",
+      args: [agentId],
+    });
+
+    // Get agent URI (metadata JSON)
+    const agentURI = await client.readContract({
+      address: CONTRACTS.IDENTITY_REGISTRY,
+      abi: IDENTITY_REGISTRY_ABI,
+      functionName: "tokenURI",
+      args: [agentId],
+    });
+
+    // Get agent wallet (payment address)
+    const agentWallet = await client.readContract({
+      address: CONTRACTS.IDENTITY_REGISTRY,
+      abi: IDENTITY_REGISTRY_ABI,
+      functionName: "getAgentWallet",
+      args: [agentId],
+    });
+
+    // Get MANDATE-specific metadata
+    const [skillsBytes, endpointBytes, priceBytes] = await Promise.all([
+      client.readContract({
+        address: CONTRACTS.IDENTITY_REGISTRY,
+        abi: IDENTITY_REGISTRY_ABI,
+        functionName: "getMetadata",
+        args: [agentId, METADATA_KEYS.SKILLS],
+      }),
+      client.readContract({
+        address: CONTRACTS.IDENTITY_REGISTRY,
+        abi: IDENTITY_REGISTRY_ABI,
+        functionName: "getMetadata",
+        args: [agentId, METADATA_KEYS.ENDPOINT],
+      }),
+      client.readContract({
+        address: CONTRACTS.IDENTITY_REGISTRY,
+        abi: IDENTITY_REGISTRY_ABI,
+        functionName: "getMetadata",
+        args: [agentId, METADATA_KEYS.PRICE_WEI],
+      }),
+    ]);
+
+    // Get reputation summary
+    const [count, summaryValue, summaryValueDecimals] = await client.readContract({
+      address: CONTRACTS.REPUTATION_REGISTRY,
+      abi: REPUTATION_REGISTRY_ABI,
+      functionName: "getSummary",
+      args: [agentId, [], "", ""],
+    });
+
+    // Parse metadata
+    const skills = skillsBytes ? decodeString(skillsBytes as `0x${string}`).split(",").filter(Boolean) : [];
+    const endpoint = endpointBytes ? decodeString(endpointBytes as `0x${string}`) : "";
+    const priceWei = priceBytes ? decodeBigInt(priceBytes as `0x${string}`) : 0n;
+
+    // Parse name/description from agentURI if it's a data URI or fetch from IPFS
+    let name = `Agent #${agentId}`;
+    let description = "";
+
+    if (typeof agentURI === "string" && agentURI.startsWith("data:application/json")) {
+      try {
+        let jsonStr: string;
+        if (agentURI.includes(";base64,")) {
+          // Base64 encoded
+          const base64 = agentURI.split(";base64,")[1];
+          jsonStr = Buffer.from(base64, "base64").toString("utf-8");
+        } else {
+          // URL encoded
+          jsonStr = decodeURIComponent(agentURI.split(",")[1]);
+        }
+        const meta = JSON.parse(jsonStr);
+        name = meta.name || name;
+        description = meta.description || "";
+      } catch {
+        // Couldn't parse, use defaults
+      }
+    }
+
+    const agent: Agent = {
+      agentId,
+      owner: owner as `0x${string}`,
+      agentURI: agentURI as string,
+      agentWallet: (agentWallet as `0x${string}`) || owner,
+      name,
+      description,
+      skills,
+      endpoint,
+      priceWei,
+      reputation: {
+        count,
+        summaryValue,
+        summaryValueDecimals,
+      },
+    };
+
+    return agent;
+  } catch (err) {
+    // Agent doesn't exist or error reading
+    return null;
+  }
+}
+
+/**
+ * Check if a wallet already has a registered agent.
+ * Queries Transfer events from the Identity Registry to find the actual agentId.
+ */
+export async function getAgentByOwner(ownerAddress: `0x${string}`): Promise<bigint | null> {
+  const client = getPublicClient();
+
+  try {
+    const balance = await client.readContract({
+      address: CONTRACTS.IDENTITY_REGISTRY,
+      abi: IDENTITY_REGISTRY_ABI,
+      functionName: "balanceOf",
+      args: [ownerAddress],
+    });
+
+    if (balance === 0n) return null;
+
+    // Query Registered events where owner matches
+    const logs = await client.getLogs({
+      address: CONTRACTS.IDENTITY_REGISTRY,
+      event: {
+        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: 0n,
+      toBlock: "latest",
+    });
+
+    if (logs.length === 0) return null;
+
+    // Return the most recent registration
+    const lastLog = logs[logs.length - 1];
+    return lastLog.args.agentId ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Submit feedback for an agent after hiring
+ * Links feedback to a completed task via feedbackHash (same keccak256 used in escrow)
+ */
+export async function giveFeedback(
+  wallet: Wallet,
+  agentId: bigint,
+  score: number, // 0-100
+  options?: {
+    taskId?: string; // Links feedback to a completed task
+    agentContractAddress?: string; // Agent's contract address (CA) for tag2
+    endpoint?: string;
+  }
+): Promise<`0x${string}`> {
+  const client = getWalletClient(wallet);
+  const publicClient = getPublicClient();
+
+  // Compute feedbackHash from taskId (same hash used in escrow contract)
+  const feedbackHash: `0x${string}` = options?.taskId
+    ? keccak256(toBytes(options.taskId))
+    : "0x0000000000000000000000000000000000000000000000000000000000000000";
+
+  const feedbackURI = options?.taskId
+    ? `moltlaunch:task:${options.taskId}`
+    : "";
+
+  const txHash = await client.writeContract({
+    address: CONTRACTS.REPUTATION_REGISTRY,
+    abi: REPUTATION_REGISTRY_ABI,
+    functionName: "giveFeedback",
+    args: [
+      agentId,
+      BigInt(score),
+      0, // No decimals for 0-100 score
+      "mandate", // tag1: platform identifier
+      options?.agentContractAddress || "", // tag2: agent's contract address
+      options?.endpoint || "",
+      feedbackURI,
+      feedbackHash,
+    ],
+  });
+
+  await publicClient.waitForTransactionReceipt({ hash: txHash });
+
+  return txHash;
+}
+
+/**
+ * Get reputation summary for an agent
+ */
+export async function getReputationSummary(
+  agentId: bigint,
+  tag1?: string,
+  tag2?: string
+): Promise<ReputationSummary> {
+  const client = getPublicClient();
+
+  const [count, summaryValue, summaryValueDecimals] = await client.readContract({
+    address: CONTRACTS.REPUTATION_REGISTRY,
+    abi: REPUTATION_REGISTRY_ABI,
+    functionName: "getSummary",
+    args: [agentId, [], tag1 || "", tag2 || ""],
+  });
+
+  return {
+    count,
+    summaryValue,
+    summaryValueDecimals,
+  };
+}
+
+/**
+ * Get all feedback for an agent
+ */
+export async function getAllFeedback(agentId: bigint) {
+  const client = getPublicClient();
+
+  const result = await client.readContract({
+    address: CONTRACTS.REPUTATION_REGISTRY,
+    abi: REPUTATION_REGISTRY_ABI,
+    functionName: "readAllFeedback",
+    args: [agentId, [], "", "", false],
+  });
+
+  return result;
+}