AI Agent 支付兜底：USDC Escrow 智能合约设计

为什么代理间的工作需要 Escrow

当 AI Agent 提供服务时——比如「0.03 美元总结 PDF」——调用方无法保证 Agent 真的会运行模型并返回有用结果。反之，Agent 需要确保在消耗算力后能获得报酬。传统 API 通过信誉评分、SLA 或中心化账单来解决这一问题，但这些机制重新引入了信任节点，违背了真正自主、抗审查市场的初衷。

无信任 Escrow 合约通过将支付方的 USDC 锁定在智能合约中，直到满足可验证条件（如加密工作证明）来消除中间人需求。如果在超时前未满足条件，资金可被追回；如果条件满足，Agent 可提取资金。模式很简单，但魔鬼在细节中：gas 成本、预言机可靠性以及争议处理。

以下是一个极简的、可直接用于生产的 Escrow 设计，可以直接嵌入 Agent 服务脚手架。

1. 核心合约 – USDCiraEscrow.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

/**
 * @notice Simple escrow for USDC payments between a requester and an agent.
 * @dev Funds are deposited by the requester. The agent can claim them only
 *      after presenting a valid off‑chain proof verified by the `verify`
 *      external function (implementation left to the integrator). A timeout
 *      allows the requester to recover funds if the agent never proves completion.
 */
contract USDCiraEscrow is ReentrancyGuard {
    IERC20 public immutable usdc;          // USDC on Base (0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913)
    address public immutable requester;
    address public agent;                  // set upon first deposit
    uint256 public amount;                 // escrowed USDC (6 decimals)
    uint256 public deadline;               // block.timestamp after which requester can refund
    bool public claimed;                   // prevents double‑withdraw

    // Event for off‑chain indexing / debugging
    event Deposit(address indexed requester, address indexed agent, uint256 amount, uint256 deadline);
    event Claimed(address indexed agent, uint256 amount);
    event Refunded(address indexed requester, uint256 amount);

    /**
     * @param _usdc   Address of the USDC token contract (must be ERC‑20 compliant)
     * @param _timeout Seconds after which the requester can reclaim funds
     */
    constructor(address _usdc, uint256 _timeout) {
        require(_usdc != address(0), "Zero USDC");
        usdc = IERC20(_usdc);
        requester = msg.sender;
        // agent stays address(0) until first deposit
    }

    /**
     * @notice Fund the escrow. Caller must approve the contract to pull USDC.
     * @param _agent  The agent address that will eventually earn the funds.
     * @param _amt    Amount of USDC (in base units, i.e. 6 decimals) to escrow.
     */
    function deposit(address _agent, uint256 _amt) external nonReentrant {
        require(msg.sender == requester, "Only requester can deposit");
        require(_agent != address(0), "Agent zero address");
        require(_amt > 0, "Zero amount");
        require(agent == address(0), "Agent already set"); // enforce one‑to‑one mapping

        agent = _agent;
        amount = _amt;
        deadline = block.timestamp + _timeout;

        // Pull funds from requester
        usdc.transferFrom(msg.sender, address(this), _amt);

        emit Deposit(requester, agent, amount, deadline);
    }

    /**
     * @notice Agent calls this after performing work and generating a proof.
     * @dev The `verify` function is a hook; implementers must replace it with
     *      their own verification logic (e.g., zk‑SNARK, optimistic challenge, or
     *      a trusted oracle signature). It must return `true` only if the work
     *      is provably complete.
     * @param proof   Arbitrary calldata supplied by the agent for verification.
     */
    function claim(bytes calldata proof) external nonReentrant {
        require(msg.sender == agent, "Only agent can claim");
        require(!claimed, "Already claimed");
        require(block.timestamp <= deadline, "Expired; requester can refund");
        require(_verify(proof), "Invalid proof");

        claimed = true;
        usdc.transfer(agent, amount);
        emit Claimed(agent, amount);
    }

    /**
     * @notice Requester retrieves funds if the agent never proves completion.
     */
    function refund() external nonReentrant {
        require(msg.sender == requester, "Only requester can refund");
        require(block.timestamp > deadline, "Still within deadline");
        require(!claimed, "Already claimed");

        usdc.transfer(requester, amount);
        emit Refunded(requester, amount);
    }

    /**
     * @dev Placeholder for proof verification. Replace with your own logic.
     *      Must be pure or view (no st

合约能做什么（以及不能做什么）

2. 链下 Agent 工作流（TypeScript + ethers.js）

以下是一个自主 Agent 如何与 Base 上的 Escrow 合约交互的简洁示例。假设 Agent 具备以下条件：

• 一个私钥（或来自 AWS KMS 的签名者）用于支付 gas
• 访问 Base 上的 USDC 合约地址（0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913）
• Escrow 合约地址（每个 Job 部署一次或通过工厂复用）

ts
// agent-worker.ts
import { ethers } from "ethers";
import escrowAbi from "./USDCiraEscrow.json"; // ABI generated via solc or hardhat

// ==== CONFIGURATION ====
const RPC_URL = "https://mainnet.base.org"; // public Base RPC (or your own Infura/Alchemy)
const USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const ESCROW_ADDRESS = "0xEscrowDeployedHere"; // replace with actual
const PRIVATE_KEY = process.env.AGENT_PRIVATE_KEY!; // never commit this
const JOB_TIMEOUT = 2 * 60 * 60; // 2 h window to finish + prove work
// =======================

const provider = new ethers.JsonRpcProvider(RPC_URL);
const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
const usdc = new ethers.Contract(USDC_ADDRESS, ["function approve(address spender, uint256 amount) returns (bool)"], wallet);
const escrow = new ethers.Contract(ESCROW_ADDRESS, escrowAbi, wallet);

/**
 * Called by the orchestrator when a job is posted.
 * @param requester The address that deposited funds.
 * @param amountUSDC Amount (in USDC, 6 decimals) to escrow.
 */
async function handleJob(requester: string, amountUSDC: number) {
  // 1️⃣ Approve escrow to pull USDC