moltlaunch 2.0.0 → 2.0.2

package/src/lib/agent0.ts

@@ -1,158 +0,0 @@
-// Agent0 SDK wrapper for MANDATE
-// Uses official ERC-8004 SDK: https://github.com/agent0lab/agent0-ts
-
-import { SDK } from "agent0-sdk";
-import { BASE_RPC_URL } from "./constants.js";
-import type { Wallet } from "./types.js";
-
-const BASE_CHAIN_ID = 8453;
-
-/**
- * Get read-only SDK instance (no private key needed)
- */
-export function getReadOnlySDK() {
-  return new SDK({
-    chainId: BASE_CHAIN_ID,
-    rpcUrl: BASE_RPC_URL,
-  });
-}
-
-/**
- * Get SDK instance with signing capability
- */
-export function getSDK(wallet: Wallet) {
-  return new SDK({
-    chainId: BASE_CHAIN_ID,
-    rpcUrl: BASE_RPC_URL,
-    privateKey: wallet.privateKey,
-  });
-}
-
-/**
- * Search for agents on Base
- */
-export async function searchAgents(options?: {
-  name?: string;
-  active?: boolean;
-  x402support?: boolean;
-  limit?: number;
-}) {
-  const sdk = getReadOnlySDK();
-
-  const results = await sdk.searchAgents({
-    name: options?.name,
-    active: options?.active,
-    x402support: options?.x402support,
-  });
-
-  // Limit results
-  const limit = options?.limit || 20;
-  return results.slice(0, limit);
-}
-
-/**
- * Get a single agent by ID
- */
-export async function getAgentById(agentId: string) {
-  const sdk = getReadOnlySDK();
-
-  // Format: chainId:agentId or just agentId (defaults to current chain)
-  const fullId = agentId.includes(":") ? agentId : `${BASE_CHAIN_ID}:${agentId}`;
-
-  return sdk.getAgent(fullId);
-}
-
-/**
- * Register a new agent
- */
-export async function registerAgent(
-  wallet: Wallet,
-  config: {
-    name: string;
-    description: string;
-    image?: string;
-    endpoint?: string; // x402 endpoint
-    skills?: string[];
-    active?: boolean;
-    metadata?: Record<string, string>; // Custom metadata (flaunchToken, priceWei, etc.)
-  }
-) {
-  const sdk = getSDK(wallet);
-
-  // Create agent
-  const agent = sdk.createAgent(
-    config.name,
-    config.description,
-    config.image || ""
-  );
-
-  // Configure x402 support if endpoint provided
-  if (config.endpoint) {
-    // Set as A2A endpoint (x402 compatible)
-    await agent.setA2A(config.endpoint);
-    agent.setTrust(true, false, false); // reputation-based trust
-  }
-
-  // Build metadata object
-  const metadata: Record<string, string> = {};
-
-  // Add skills to metadata
-  if (config.skills && config.skills.length > 0) {
-    metadata.skills = config.skills.join(",");
-  }
-
-  // Add custom metadata (flaunchToken, priceWei, symbol, etc.)
-  if (config.metadata) {
-    Object.assign(metadata, config.metadata);
-  }
-
-  // Set all metadata at once
-  if (Object.keys(metadata).length > 0) {
-    agent.setMetadata(metadata);
-  }
-
-  agent.setActive(config.active ?? true);
-
-  // Register using IPFS (Agent0 SDK handles IPFS upload)
-  // Note: This uses the default IPFS node, configure with pinata for production
-  const txHandle = await agent.registerIPFS();
-
-  // Wait for transaction to be mined
-  const { receipt } = await txHandle.waitMined({ confirmations: 1 });
-
-  // After registration, agent has ID and URI
-  const agentId = agent.agentId;
-  const agentURI = agent.agentURI;
-
-  if (!agentId) {
-    throw new Error("Registration failed: no agent ID returned");
-  }
-
-  return {
-    agentId,
-    agentURI: agentURI || "",
-    txHash: txHandle.hash,
-  };
-}
-
-/**
- * Give feedback to an agent
- */
-export async function giveFeedback(
-  wallet: Wallet,
-  agentId: string,
-  score: number,
-  tag?: string
-): Promise<string> {
-  const sdk = getSDK(wallet);
-
-  const fullId = agentId.includes(":") ? agentId : `${BASE_CHAIN_ID}:${agentId}`;
-
-  // Give feedback (score 0-100)
-  const txHandle = await sdk.giveFeedback(fullId, score, tag || "mandate");
-
-  // Wait for transaction to be mined
-  await txHandle.waitMined({ confirmations: 1 });
-
-  return txHandle.hash;
-}

package/src/lib/auth.ts

@@ -1,25 +0,0 @@
-// CLI-side message signing for authenticated API calls
-// Signs EIP-191 personal messages: moltlaunch:<action>:<taskId>:<timestamp>:<nonce>
-
-import { randomUUID } from "crypto";
-import { privateKeyToAccount } from "viem/accounts";
-import type { Wallet } from "./types.js";
-
-/** Build the message that must be signed (must match worker/src/auth.ts) */
-export function buildAuthMessage(action: string, taskId: string, timestamp: number, nonce: string): string {
-  return `moltlaunch:${action}:${taskId}:${timestamp}:${nonce}`;
-}
-
-/** Sign an action with the wallet's private key. Includes a random nonce for replay protection. */
-export async function signAction(
-  wallet: Wallet,
-  action: string,
-  taskId: string,
-): Promise<{ signature: string; timestamp: number; nonce: string }> {
-  const timestamp = Math.floor(Date.now() / 1000);
-  const nonce = randomUUID();
-  const message = buildAuthMessage(action, taskId, timestamp, nonce);
-  const account = privateKeyToAccount(wallet.privateKey);
-  const signature = await account.signMessage({ message });
-  return { signature, timestamp, nonce };
-}

package/src/lib/constants.ts

@@ -1,55 +0,0 @@
-// MANDATE: Molt's Autonomous Network for Distributed Agent Task Execution
-// Chain: Base Mainnet
-
-export const CHAIN_ID = 8453;
-
-export const CONTRACTS = {
-  // ERC-8004 Registries (Base Mainnet) - https://github.com/erc-8004/erc-8004-contracts
-  IDENTITY_REGISTRY: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432" as `0x${string}`,
-  REPUTATION_REGISTRY: "0x8004BAa17C55a88189AE136b182e5fdA19dE9b63" as `0x${string}`,
-  // Note: Validation Registry not yet deployed (optional in spec)
-
-  // Flaunch (existing)
-  FLAUNCH_FACTORY: "0x6A53F8b799bE11a2A3264eF0bfF183dCB12d9571" as `0x${string}`,
-  POSITION_MANAGER: "0x51Bba15255406Cfe7099a42183302640ba7dAFDC" as `0x${string}`,
-
-  // Base
-  WETH: "0x4200000000000000000000000000000000000006" as `0x${string}`,
-  MULTICALL3: "0xcA11bde05977b3631167028862bE2a173976CA11" as `0x${string}`,
-} as const;
-
-// Revenue Manager - collects 10% protocol fees from token trading
-export const REVENUE_MANAGER_ADDRESS = "0x3Bc08524d9DaaDEC9d1Af87818d809611F0fD669" as `0x${string}`;
-
-export const APIS = {
-  FLAUNCH: "https://web2-api.flaunch.gg",
-  FLAUNCH_DATA: "https://api.flayerlabs.xyz",
-  MANDATE: "https://api.moltlaunch.com",
-} as const;
-
-export const CHAIN = {
-  id: 8453,
-  name: "Base",
-  network: "base",
-  explorer: "https://basescan.org",
-  flaunchUrl: "https://flaunch.gg/base",
-} as const;
-
-// Flaunch polling config
-export const POLL_INTERVAL_MS = 2_000;
-export const POLL_TIMEOUT_MS = 120_000;
-export const MAX_IMAGE_SIZE_BYTES = 5 * 1024 * 1024; // 5MB
-
-// RPC endpoint - use env var for reliability (Alchemy, QuickNode, etc.)
-// Fallback to public Base RPC (may be rate limited)
-export const BASE_RPC_URL = process.env.BASE_RPC_URL || "https://mainnet.base.org";
-
-export const WALLET_PATH = ".moltlaunch/wallet.json";
-
-// Agent metadata keys (stored in ERC-8004 identity registry)
-export const METADATA_KEYS = {
-  FLAUNCH_TOKEN: "flaunchToken", // Link to Flaunch token address
-  SKILLS: "skills", // Comma-separated skill list
-  ENDPOINT: "endpoint", // x402 hire endpoint
-  PRICE_WEI: "priceWei", // Base price per hire in wei
-} as const;

package/src/lib/escrow.ts

@@ -1,374 +0,0 @@
-// Escrow contract interactions (V4 with dispute mechanism)
-
-import {
-  createPublicClient,
-  createWalletClient,
-  http,
-  keccak256,
-  toBytes,
-  parseAbi,
-} from "viem";
-import { privateKeyToAccount } from "viem/accounts";
-import { base } from "viem/chains";
-import { BASE_RPC_URL } from "./constants.js";
-import type { Wallet } from "./types.js";
-
-export enum EscrowStatus {
-  Active = 0,
-  Submitted = 1,
-  Disputed = 2,
-  Resolved = 3,
-  Released = 4,
-  Refunded = 5,
-}
-
-const ESCROW_ADDRESS = (process.env.ESCROW_ADDRESS ||
-  "0x2c46054b4577b4fcdde28cb613dc2ba4b1127b0c") as `0x${string}`;
-
-const ESCROW_ABI = parseAbi([
-  // Write functions
-  "function deposit(bytes32 taskId, address agent, address token) external payable",
-  "function markSubmitted(bytes32 taskId) external",
-  "function release(bytes32 taskId) external",
-  "function refund(bytes32 taskId) external",
-  "function releaseAfterTimeout(bytes32 taskId) external",
-  "function dispute(bytes32 taskId) external payable",
-  "function resolveDispute(bytes32 taskId, bool clientWins) external",
-  "function setDisputeFeeBps(uint256 bps) external",
-  // View functions
-  "function isPending(bytes32 taskId) external view returns (bool)",
-  "function isTimedOut(bytes32 taskId) external view returns (bool)",
-  "function isDisputed(bytes32 taskId) external view returns (bool)",
-  "function timeUntilTimeout(bytes32 taskId) external view returns (uint256)",
-  "function getEscrow(bytes32 taskId) external view returns (address client, address agent, address token, uint256 amount, uint256 depositedAt, uint256 submittedAt, uint256 disputeFee, uint8 status)",
-  "function getDisputeFee(bytes32 taskId) external view returns (uint256)",
-  "function getStatus(bytes32 taskId) external view returns (uint8)",
-  "function disputeFeeBps() external view returns (uint256)",
-  "function TIMEOUT() external view returns (uint256)",
-  // Events
-  "event Deposited(bytes32 indexed taskId, address indexed client, address indexed token, uint256 amount)",
-  "event Submitted(bytes32 indexed taskId, address indexed agent, uint256 deadline)",
-  "event Disputed(bytes32 indexed taskId, address indexed client, uint256 disputeFee)",
-  "event DisputeResolved(bytes32 indexed taskId, bool clientWins)",
-  "event BuybackBurned(bytes32 indexed taskId, address indexed token, uint256 ethAmount)",
-  "event Refunded(bytes32 indexed taskId, address indexed client, uint256 amount)",
-  "event FallbackToAgent(bytes32 indexed taskId, address indexed agent, uint256 amount)",
-]);
-
-/**
- * Convert task ID string to bytes32 for contract
- */
-export function taskIdToBytes32(taskId: string): `0x${string}` {
-  return keccak256(toBytes(taskId));
-}
-
-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),
-  });
-}
-
-/**
- * Deposit funds into escrow when client accepts a quote
- * V3: Now includes token address for buyback-and-burn
- */
-export async function depositEscrow(
-  wallet: Wallet,
-  taskId: string,
-  agentAddress: string,
-  tokenAddress: string,
-  amountWei: bigint
-): Promise<string> {
-  const walletClient = getWalletClient(wallet);
-  const taskIdBytes = taskIdToBytes32(taskId);
-
-  const hash = await walletClient.writeContract({
-    address: ESCROW_ADDRESS,
-    abi: ESCROW_ABI,
-    functionName: "deposit",
-    args: [taskIdBytes, agentAddress as `0x${string}`, tokenAddress as `0x${string}`],
-    value: amountWei,
-  });
-
-  return hash;
-}
-
-/**
- * Agent marks work as submitted (starts 24h timeout countdown)
- */
-export async function markSubmitted(
-  wallet: Wallet,
-  taskId: string
-): Promise<string> {
-  const walletClient = getWalletClient(wallet);
-  const taskIdBytes = taskIdToBytes32(taskId);
-
-  const hash = await walletClient.writeContract({
-    address: ESCROW_ADDRESS,
-    abi: ESCROW_ABI,
-    functionName: "markSubmitted",
-    args: [taskIdBytes],
-  });
-
-  return hash;
-}
-
-/**
- * Release funds from escrow to agent when client approves work
- */
-export async function releaseEscrow(
-  wallet: Wallet,
-  taskId: string
-): Promise<string> {
-  const walletClient = getWalletClient(wallet);
-  const taskIdBytes = taskIdToBytes32(taskId);
-
-  const hash = await walletClient.writeContract({
-    address: ESCROW_ADDRESS,
-    abi: ESCROW_ABI,
-    functionName: "release",
-    args: [taskIdBytes],
-    gas: 1_000_000n, // Buyback swap needs ~750K gas
-  });
-
-  return hash;
-}
-
-/**
- * Refund funds from escrow back to client (only before submission)
- */
-export async function refundEscrow(
-  wallet: Wallet,
-  taskId: string
-): Promise<string> {
-  const walletClient = getWalletClient(wallet);
-  const taskIdBytes = taskIdToBytes32(taskId);
-
-  const hash = await walletClient.writeContract({
-    address: ESCROW_ADDRESS,
-    abi: ESCROW_ABI,
-    functionName: "refund",
-    args: [taskIdBytes],
-  });
-
-  return hash;
-}
-
-/**
- * Release funds after timeout (anyone can call, agent protection)
- */
-export async function releaseAfterTimeout(
-  wallet: Wallet,
-  taskId: string
-): Promise<string> {
-  const walletClient = getWalletClient(wallet);
-  const taskIdBytes = taskIdToBytes32(taskId);
-
-  const hash = await walletClient.writeContract({
-    address: ESCROW_ADDRESS,
-    abi: ESCROW_ABI,
-    functionName: "releaseAfterTimeout",
-    args: [taskIdBytes],
-  });
-
-  return hash;
-}
-
-/**
- * Check if escrow exists and is pending for a task
- */
-export async function isEscrowPending(taskId: string): Promise<boolean> {
-  const publicClient = getPublicClient();
-  const taskIdBytes = taskIdToBytes32(taskId);
-
-  const pending = await publicClient.readContract({
-    address: ESCROW_ADDRESS,
-    abi: ESCROW_ABI,
-    functionName: "isPending",
-    args: [taskIdBytes],
-  });
-
-  return pending as boolean;
-}
-
-/**
- * Check if timeout has been reached
- */
-export async function isEscrowTimedOut(taskId: string): Promise<boolean> {
-  const publicClient = getPublicClient();
-  const taskIdBytes = taskIdToBytes32(taskId);
-
-  const timedOut = await publicClient.readContract({
-    address: ESCROW_ADDRESS,
-    abi: ESCROW_ABI,
-    functionName: "isTimedOut",
-    args: [taskIdBytes],
-  });
-
-  return timedOut as boolean;
-}
-
-/**
- * Get seconds until timeout (0 if already timed out or not submitted)
- */
-export async function getTimeUntilTimeout(taskId: string): Promise<bigint> {
-  const publicClient = getPublicClient();
-  const taskIdBytes = taskIdToBytes32(taskId);
-
-  const time = await publicClient.readContract({
-    address: ESCROW_ADDRESS,
-    abi: ESCROW_ABI,
-    functionName: "timeUntilTimeout",
-    args: [taskIdBytes],
-  });
-
-  return time as bigint;
-}
-
-/**
- * Get escrow details for a task
- * V4: Includes disputeFee and status enum
- */
-export async function getEscrowDetails(taskId: string): Promise<{
-  client: string;
-  agent: string;
-  token: string;
-  amount: bigint;
-  depositedAt: bigint;
-  submittedAt: bigint;
-  disputeFee: bigint;
-  status: EscrowStatus;
-} | null> {
-  const publicClient = getPublicClient();
-  const taskIdBytes = taskIdToBytes32(taskId);
-
-  const result = await publicClient.readContract({
-    address: ESCROW_ADDRESS,
-    abi: ESCROW_ABI,
-    functionName: "getEscrow",
-    args: [taskIdBytes],
-  });
-
-  const [client, agent, token, amount, depositedAt, submittedAt, disputeFee, status] = result as [
-    string,
-    string,
-    string,
-    bigint,
-    bigint,
-    bigint,
-    bigint,
-    number
-  ];
-
-  if (amount === BigInt(0)) return null;
-
-  return { client, agent, token, amount, depositedAt, submittedAt, disputeFee, status: status as EscrowStatus };
-}
-
-/**
- * Client disputes submitted work (must pay fee)
- */
-export async function disputeEscrow(
-  wallet: Wallet,
-  taskId: string,
-  feeWei: bigint
-): Promise<string> {
-  const walletClient = getWalletClient(wallet);
-  const taskIdBytes = taskIdToBytes32(taskId);
-
-  const hash = await walletClient.writeContract({
-    address: ESCROW_ADDRESS,
-    abi: ESCROW_ABI,
-    functionName: "dispute",
-    args: [taskIdBytes],
-    value: feeWei,
-  });
-
-  return hash;
-}
-
-/**
- * Get the required dispute fee for a task
- */
-export async function getDisputeFee(taskId: string): Promise<bigint> {
-  const publicClient = getPublicClient();
-  const taskIdBytes = taskIdToBytes32(taskId);
-
-  const fee = await publicClient.readContract({
-    address: ESCROW_ADDRESS,
-    abi: ESCROW_ABI,
-    functionName: "getDisputeFee",
-    args: [taskIdBytes],
-  });
-
-  return fee as bigint;
-}
-
-/**
- * Check if escrow is in disputed state
- */
-export async function isEscrowDisputed(taskId: string): Promise<boolean> {
-  const publicClient = getPublicClient();
-  const taskIdBytes = taskIdToBytes32(taskId);
-
-  const disputed = await publicClient.readContract({
-    address: ESCROW_ADDRESS,
-    abi: ESCROW_ABI,
-    functionName: "isDisputed",
-    args: [taskIdBytes],
-  });
-
-  return disputed as boolean;
-}
-
-/**
- * Get current escrow status
- */
-export async function getEscrowStatus(taskId: string): Promise<EscrowStatus> {
-  const publicClient = getPublicClient();
-  const taskIdBytes = taskIdToBytes32(taskId);
-
-  const status = await publicClient.readContract({
-    address: ESCROW_ADDRESS,
-    abi: ESCROW_ABI,
-    functionName: "getStatus",
-    args: [taskIdBytes],
-  });
-
-  return (status as number) as EscrowStatus;
-}
-
-/**
- * Admin resolves a disputed escrow
- */
-export async function resolveEscrowDispute(
-  wallet: Wallet,
-  taskId: string,
-  clientWins: boolean,
-): Promise<string> {
-  const walletClient = getWalletClient(wallet);
-  const publicClient = getPublicClient();
-  const taskIdBytes = taskIdToBytes32(taskId);
-
-  const hash = await walletClient.writeContract({
-    address: ESCROW_ADDRESS,
-    abi: ESCROW_ABI,
-    functionName: "resolveDispute",
-    args: [taskIdBytes, clientWins],
-  });
-
-  await publicClient.waitForTransactionReceipt({ hash });
-  return hash;
-}
-
-export { ESCROW_ADDRESS };

package/src/lib/files.ts

@@ -1,87 +0,0 @@
-// CLI helpers for uploading/downloading task files via Worker proxy
-
-import { readFileSync, statSync } from "fs";
-import { basename } from "path";
-import { APIS } from "./constants.js";
-import { signAction } from "./auth.js";
-import type { Wallet, TaskFile } from "./types.js";
-
-const API_BASE = APIS.MANDATE;
-
-/** Upload a single file to the task's R2 storage */
-export async function uploadFile(
-  wallet: Wallet,
-  taskId: string,
-  filePath: string,
-): Promise<TaskFile> {
-  const { signature, timestamp, nonce } = await signAction(wallet, "upload", taskId);
-  const filename = basename(filePath);
-  const stat = statSync(filePath);
-  const body = readFileSync(filePath);
-
-  const params = new URLSearchParams({
-    signature,
-    timestamp: String(timestamp),
-    nonce,
-    filename,
-  });
-
-  const response = await fetch(
-    `${API_BASE}/api/tasks/${taskId}/upload?${params.toString()}`,
-    {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/octet-stream",
-        "Content-Length": String(stat.size),
-      },
-      body,
-    },
-  );
-
-  if (!response.ok) {
-    const error = (await response.json()) as { error: string };
-    throw new Error(error.error || `Upload failed: HTTP ${response.status}`);
-  }
-
-  const data = (await response.json()) as { file: TaskFile };
-  return data.file;
-}
-
-/** Upload multiple files, return all file metadata */
-export async function uploadFiles(
-  wallet: Wallet,
-  taskId: string,
-  filePaths: string[],
-): Promise<TaskFile[]> {
-  const results: TaskFile[] = [];
-  for (const filePath of filePaths) {
-    const file = await uploadFile(wallet, taskId, filePath);
-    results.push(file);
-  }
-  return results;
-}
-
-/** Download a file from a task's R2 storage */
-export async function downloadTaskFile(
-  taskId: string,
-  fileKey: string,
-): Promise<{ data: ArrayBuffer; contentType: string; filename: string }> {
-  const response = await fetch(
-    `${API_BASE}/api/tasks/${taskId}/files/${encodeURIComponent(fileKey)}`,
-  );
-
-  if (!response.ok) {
-    const error = (await response.json()) as { error: string };
-    throw new Error(error.error || `Download failed: HTTP ${response.status}`);
-  }
-
-  const disposition = response.headers.get("Content-Disposition") || "";
-  const filenameMatch = disposition.match(/filename="(.+)"/);
-  const filename = filenameMatch ? filenameMatch[1] : "file";
-
-  return {
-    data: await response.arrayBuffer(),
-    contentType: response.headers.get("Content-Type") || "application/octet-stream",
-    filename,
-  };
-}