moltlaunch 2.0.0 → 2.0.1

package/src/lib/mandate.ts

@@ -1,623 +0,0 @@
-// 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;
-}