arcbounty-agent-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1029 @@
+// src/ArcBountyAgent.ts
+import {
+  createPublicClient,
+  createWalletClient,
+  decodeEventLog,
+  http,
+  defineChain,
+  isAddress
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+
+// src/abi.ts
+var BOUNTY_META_TUPLE = {
+  name: "",
+  type: "tuple",
+  components: [
+    { name: "jobId", type: "uint256" },
+    { name: "poster", type: "address" },
+    { name: "reward", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "ipfsDescHash", type: "string" },
+    { name: "category", type: "string" },
+    { name: "tags", type: "string[]" },
+    { name: "agentId", type: "uint256" },
+    { name: "agentOnly", type: "bool" },
+    { name: "humanOnly", type: "bool" },
+    { name: "whitelistedProvider", type: "address" },
+    { name: "assignedProvider", type: "address" },
+    { name: "submittedResultHash", type: "string" },
+    { name: "submittedAt", type: "uint256" },
+    { name: "isTaken", type: "bool" },
+    { name: "rejectedAt", type: "uint256" },
+    { name: "rejectionReasonHash", type: "string" },
+    { name: "inDispute", type: "bool" },
+    { name: "resolved", type: "bool" },
+    { name: "disputeInitiator", type: "address" },
+    { name: "disputeRaisedAt", type: "uint256" },
+    { name: "disputeReasonHash", type: "string" },
+    { name: "disputeResponseHash", type: "string" },
+    { name: "disputeRulingHash", type: "string" }
+  ]
+};
+var BOUNTY_ADAPTER_ABI = [
+  // ── Write ──
+  {
+    name: "createBounty",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{
+      name: "p",
+      type: "tuple",
+      components: [
+        { name: "provider", type: "address" },
+        { name: "reward", type: "uint256" },
+        { name: "deadline", type: "uint256" },
+        { name: "ipfsDescHash", type: "string" },
+        { name: "category", type: "string" },
+        { name: "tags", type: "string[]" },
+        { name: "agentOnly", type: "bool" },
+        { name: "humanOnly", type: "bool" }
+      ]
+    }],
+    outputs: [{ name: "jobId", type: "uint256" }]
+  },
+  {
+    name: "takeBounty",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "jobId", type: "uint256" },
+      { name: "agentId", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "submitWork",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "jobId", type: "uint256" },
+      { name: "ipfsResultHash", type: "string" }
+    ],
+    outputs: []
+  },
+  {
+    name: "approveBounty",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "jobId", type: "uint256" },
+      { name: "reputationScore", type: "uint8" }
+    ],
+    outputs: []
+  },
+  {
+    name: "autoApprove",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "jobId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "rejectBounty",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "jobId", type: "uint256" },
+      { name: "ipfsReasonHash", type: "string" }
+    ],
+    outputs: []
+  },
+  {
+    name: "challengeRejection",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "jobId", type: "uint256" },
+      { name: "ipfsReasonHash", type: "string" }
+    ],
+    outputs: []
+  },
+  {
+    name: "finalizeRejection",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "jobId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "cancelBounty",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "jobId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "expireBounty",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "jobId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "disputeBounty",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "jobId", type: "uint256" },
+      { name: "ipfsReasonHash", type: "string" }
+    ],
+    outputs: []
+  },
+  {
+    name: "respondToDispute",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "jobId", type: "uint256" },
+      { name: "ipfsResponseHash", type: "string" }
+    ],
+    outputs: []
+  },
+  {
+    name: "resolveDispute",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "jobId", type: "uint256" },
+      { name: "payProvider", type: "bool" },
+      { name: "ipfsRulingHash", type: "string" },
+      { name: "reputationPenalty", type: "uint8" }
+    ],
+    outputs: []
+  },
+  {
+    name: "claimDefaultRuling",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "jobId", type: "uint256" }],
+    outputs: []
+  },
+  // ── Read ──
+  {
+    name: "getOpenBounties",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "category", type: "string" },
+      { name: "offset", type: "uint256" },
+      { name: "limit", type: "uint256" }
+    ],
+    outputs: [{ name: "result", type: "uint256[]" }]
+  },
+  {
+    name: "getBountyMeta",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "jobId", type: "uint256" }],
+    outputs: [BOUNTY_META_TUPLE]
+  },
+  {
+    name: "getMyPostedBounties",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "poster", type: "address" }],
+    outputs: [{ name: "", type: "uint256[]" }]
+  },
+  {
+    name: "getMyAssignedBounties",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "provider", type: "address" }],
+    outputs: [{ name: "", type: "uint256[]" }]
+  },
+  {
+    name: "getAgentBounties",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256[]" }]
+  },
+  {
+    name: "APPROVAL_TIMEOUT",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "getAgentReputation",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{
+      name: "",
+      type: "tuple",
+      components: [
+        { name: "averageScore", type: "uint256" },
+        { name: "totalFeedbacks", type: "uint256" },
+        { name: "totalJobs", type: "uint256" }
+      ]
+    }]
+  },
+  {
+    name: "totalBounties",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "arbitrator",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "DISPUTE_RESPONSE_WINDOW",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "REJECTION_CHALLENGE_WINDOW",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  // ── Events ──
+  {
+    name: "BountyCreated",
+    type: "event",
+    inputs: [
+      { name: "jobId", type: "uint256", indexed: true },
+      { name: "poster", type: "address", indexed: true },
+      { name: "reward", type: "uint256", indexed: false },
+      { name: "category", type: "string", indexed: false },
+      { name: "deadline", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    name: "BountyTaken",
+    type: "event",
+    inputs: [
+      { name: "jobId", type: "uint256", indexed: true },
+      { name: "provider", type: "address", indexed: true },
+      { name: "agentId", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    name: "WorkSubmitted",
+    type: "event",
+    inputs: [
+      { name: "jobId", type: "uint256", indexed: true },
+      { name: "provider", type: "address", indexed: true },
+      { name: "ipfsResultHash", type: "string", indexed: false }
+    ]
+  },
+  {
+    name: "BountyCompleted",
+    type: "event",
+    inputs: [
+      { name: "jobId", type: "uint256", indexed: true },
+      { name: "agentId", type: "uint256", indexed: false },
+      { name: "reputationScore", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    name: "DisputeRaised",
+    type: "event",
+    inputs: [
+      { name: "jobId", type: "uint256", indexed: true },
+      { name: "initiator", type: "address", indexed: true },
+      { name: "reasonHash", type: "string", indexed: false }
+    ]
+  },
+  {
+    name: "DisputeResponded",
+    type: "event",
+    inputs: [
+      { name: "jobId", type: "uint256", indexed: true },
+      { name: "responder", type: "address", indexed: true },
+      { name: "responseHash", type: "string", indexed: false }
+    ]
+  },
+  {
+    name: "DisputeResolved",
+    type: "event",
+    inputs: [
+      { name: "jobId", type: "uint256", indexed: true },
+      { name: "payProvider", type: "bool", indexed: false },
+      { name: "rulingHash", type: "string", indexed: false },
+      { name: "defaultRuling", type: "bool", indexed: false }
+    ]
+  }
+];
+var IDENTITY_REGISTRY_ABI = [
+  {
+    name: "register",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "metadataURI", type: "string" }],
+    outputs: [{ name: "agentId", type: "uint256" }]
+  },
+  {
+    name: "ownerOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "Transfer",
+    type: "event",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "tokenId", type: "uint256", indexed: true }
+    ]
+  }
+];
+var ERC20_ABI = [
+  {
+    name: "approve",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "allowance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+
+// src/constants.ts
+var ARC_TESTNET_RPC = "https://rpc.testnet.arc.network";
+var ARC_TESTNET_CHAIN_ID = 5042002;
+var CONTRACTS = {
+  AGENTIC_COMMERCE: "0x0747EEf0706327138c69792bF28Cd525089e4583",
+  IDENTITY_REGISTRY: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
+  REPUTATION_REGISTRY: "0x8004B663056A597Dffe9eCcC1965A193B7388713",
+  USDC: "0x3600000000000000000000000000000000000000"
+};
+var USDC_DECIMALS = 6;
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var IPFS_GATEWAYS = [
+  "https://gateway.pinata.cloud/ipfs/",
+  "https://ipfs.io/ipfs/",
+  "https://cloudflare-ipfs.com/ipfs/"
+];
+
+// src/ipfs.ts
+function cidFromUri(uriOrCid) {
+  return uriOrCid.replace(/^ipfs:\/\//, "");
+}
+async function fetchIpfsText(uriOrCid) {
+  const cid = cidFromUri(uriOrCid);
+  for (const gateway of IPFS_GATEWAYS) {
+    try {
+      const res = await fetch(`${gateway}${cid}`);
+      if (res.ok) return res.text();
+    } catch {
+    }
+  }
+  throw new Error(`Failed to fetch IPFS content: ${uriOrCid}`);
+}
+async function fetchIpfsJson(uriOrCid) {
+  const text = await fetchIpfsText(uriOrCid);
+  return JSON.parse(text);
+}
+function isPinningConfigured() {
+  return Boolean(process.env["PINATA_JWT"] || process.env["PINATA_API_KEY"] && process.env["PINATA_SECRET"]);
+}
+async function pinText(content, filename = "result.md") {
+  const jwt = process.env["PINATA_JWT"];
+  const apiKey = process.env["PINATA_API_KEY"];
+  const apiSecret = process.env["PINATA_SECRET"];
+  const blob = new Blob([content], { type: "text/plain" });
+  if (jwt) {
+    const form = new FormData();
+    form.append("file", blob, filename);
+    const res = await fetch("https://api.pinata.cloud/pinning/pinFileToIPFS", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${jwt}` },
+      body: form
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Pinata v2 error ${res.status}: ${text}`);
+    }
+    const data = await res.json();
+    return `ipfs://${data.IpfsHash}`;
+  }
+  if (apiKey && apiSecret) {
+    const form = new FormData();
+    form.append("file", blob, filename);
+    const res = await fetch("https://api.pinata.cloud/pinning/pinFileToIPFS", {
+      method: "POST",
+      headers: {
+        pinata_api_key: apiKey,
+        pinata_secret_api_key: apiSecret
+      },
+      body: form
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Pinata v1 error ${res.status}: ${text}`);
+    }
+    const data = await res.json();
+    return `ipfs://${data.IpfsHash}`;
+  }
+  throw new Error("Set PINATA_JWT (preferred) or PINATA_API_KEY + PINATA_SECRET to pin to IPFS");
+}
+
+// src/ArcBountyAgent.ts
+var arcTestnet = defineChain({
+  id: ARC_TESTNET_CHAIN_ID,
+  name: "Arc Testnet",
+  nativeCurrency: { name: "USD Coin", symbol: "USDC", decimals: 6 },
+  rpcUrls: { default: { http: [ARC_TESTNET_RPC] } }
+});
+var ArcBountyAgent = class {
+  constructor(config) {
+    this._agentId = null;
+    const rpcUrl = config.rpcUrl ?? ARC_TESTNET_RPC;
+    this.chain = defineChain({ ...arcTestnet, rpcUrls: { default: { http: [rpcUrl] } } });
+    this.account = privateKeyToAccount(config.privateKey);
+    this.metadataURI = config.metadataURI ?? "";
+    const rawAdapter = config.bountyAdapterAddress ?? process.env["BOUNTY_ADAPTER_ADDRESS"];
+    if (!rawAdapter) {
+      throw new Error(
+        "ArcBountyAgent: bountyAdapterAddress is required (constructor option or BOUNTY_ADAPTER_ADDRESS env). See agent-sdk/.env.example. Source of truth: contracts/DEPLOYMENTS.md."
+      );
+    }
+    if (!isAddress(rawAdapter) || rawAdapter.toLowerCase() === ZERO_ADDRESS.toLowerCase()) {
+      throw new Error(`ArcBountyAgent: invalid bountyAdapterAddress: ${rawAdapter}`);
+    }
+    this.bountyAdapter = rawAdapter;
+    this.publicClient = createPublicClient({ chain: this.chain, transport: http(rpcUrl) });
+    this.walletClient = createWalletClient({ account: this.account, chain: this.chain, transport: http(rpcUrl) });
+  }
+  get address() {
+    return this.account.address;
+  }
+  // ─── Identity ───────────────────────────────────────────────────────────────
+  async register() {
+    const existing = await this._findExistingAgentId();
+    if (existing !== null) {
+      this._agentId = existing;
+      return existing;
+    }
+    const hash = await this.walletClient.writeContract({
+      address: CONTRACTS.IDENTITY_REGISTRY,
+      abi: IDENTITY_REGISTRY_ABI,
+      functionName: "register",
+      args: [this.metadataURI],
+      chain: null,
+      account: this.account
+    });
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    const agentId = this._agentIdFromReceiptLogs(receipt.logs);
+    if (agentId === null) throw new Error("Registration succeeded but agentId not found in events");
+    this._agentId = agentId;
+    return agentId;
+  }
+  /** Pull the minted tokenId from a Transfer(from=0x0, to=self) log in a receipt. */
+  _agentIdFromReceiptLogs(logs) {
+    const TRANSFER_SIG = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+    const me = this.account.address.toLowerCase().slice(2).padStart(64, "0");
+    for (const log of logs) {
+      if (log.address.toLowerCase() !== CONTRACTS.IDENTITY_REGISTRY.toLowerCase()) continue;
+      if (log.topics.length < 4) continue;
+      if (log.topics[0]?.toLowerCase() !== TRANSFER_SIG) continue;
+      if (log.topics[1]?.toLowerCase() !== "0x" + "0".repeat(64)) continue;
+      if (log.topics[2]?.toLowerCase() !== "0x" + me) continue;
+      return BigInt(log.topics[3]);
+    }
+    return null;
+  }
+  get agentId() {
+    if (this._agentId === null) throw new Error("Agent not registered. Call register() first.");
+    return this._agentId;
+  }
+  setAgentId(id) {
+    this._agentId = id;
+  }
+  // ─── Browse bounties ────────────────────────────────────────────────────────
+  async listOpenBounties(filter = {}) {
+    const {
+      category = "",
+      agentOnly,
+      humanOnly,
+      maxReward,
+      minReward,
+      offset = 0,
+      limit = 50
+    } = filter;
+    const jobIds = await this.publicClient.readContract({
+      address: this.bountyAdapter,
+      abi: BOUNTY_ADAPTER_ABI,
+      functionName: "getOpenBounties",
+      args: [category, BigInt(offset), BigInt(limit)]
+    });
+    const metas = await Promise.all(jobIds.map((jobId) => this.getBounty(jobId)));
+    return metas.filter((m) => {
+      if (agentOnly === true && !m.agentOnly) return false;
+      if (humanOnly === true && !m.humanOnly) return false;
+      if (agentOnly === false && m.agentOnly) return false;
+      if (humanOnly === false && m.humanOnly) return false;
+      if (maxReward !== void 0 && m.reward > this._parseUsdc(maxReward)) return false;
+      if (minReward !== void 0 && m.reward < this._parseUsdc(minReward)) return false;
+      return true;
+    });
+  }
+  async getBounty(jobId) {
+    const raw = await this.publicClient.readContract({
+      address: this.bountyAdapter,
+      abi: BOUNTY_ADAPTER_ABI,
+      functionName: "getBountyMeta",
+      args: [jobId]
+    });
+    return raw;
+  }
+  async getBountyDescription(jobId) {
+    const meta = await this.getBounty(jobId);
+    return fetchIpfsText(meta.ipfsDescHash);
+  }
+  async getMyBounties() {
+    const jobIds = await this.publicClient.readContract({
+      address: this.bountyAdapter,
+      abi: BOUNTY_ADAPTER_ABI,
+      functionName: "getMyAssignedBounties",
+      args: [this.address]
+    });
+    return Promise.all(jobIds.map((id) => this.getBounty(id)));
+  }
+  async getPostedBounties() {
+    const jobIds = await this.publicClient.readContract({
+      address: this.bountyAdapter,
+      abi: BOUNTY_ADAPTER_ABI,
+      functionName: "getMyPostedBounties",
+      args: [this.address]
+    });
+    return Promise.all(jobIds.map((id) => this.getBounty(id)));
+  }
+  // ─── Post a bounty ──────────────────────────────────────────────────────────
+  async createBounty(opts) {
+    if (opts.agentOnly && opts.humanOnly) {
+      throw new Error("agentOnly and humanOnly are mutually exclusive");
+    }
+    if (!opts.descriptionCid && !opts.descriptionText) {
+      throw new Error("Provide either descriptionCid or descriptionText");
+    }
+    const reward = this._parseUsdc(opts.rewardUsdc);
+    const deadline = this._resolveDeadline(opts.deadline);
+    const descCid = opts.descriptionCid ?? await pinText(opts.descriptionText);
+    await this._ensureUsdcAllowance(reward);
+    const hash = await this.walletClient.writeContract({
+      address: this.bountyAdapter,
+      abi: BOUNTY_ADAPTER_ABI,
+      functionName: "createBounty",
+      args: [{
+        provider: opts.provider ?? ZERO_ADDRESS,
+        reward,
+        deadline,
+        ipfsDescHash: descCid,
+        category: opts.category,
+        tags: opts.tags ?? [],
+        agentOnly: opts.agentOnly ?? false,
+        humanOnly: opts.humanOnly ?? false
+      }],
+      chain: null,
+      account: this.account
+    });
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    let jobId;
+    for (const log of receipt.logs) {
+      if (log.address.toLowerCase() !== this.bountyAdapter.toLowerCase()) continue;
+      try {
+        const decoded = decodeEventLog({
+          abi: BOUNTY_ADAPTER_ABI,
+          data: log.data,
+          topics: log.topics
+        });
+        if (decoded.eventName === "BountyCreated") {
+          jobId = decoded.args.jobId;
+          break;
+        }
+      } catch {
+      }
+    }
+    return { hash, jobId };
+  }
+  // ─── Take / submit ──────────────────────────────────────────────────────────
+  async takeBounty(jobId) {
+    const agentId = this._agentId ?? 0n;
+    const hash = await this.walletClient.writeContract({
+      address: this.bountyAdapter,
+      abi: BOUNTY_ADAPTER_ABI,
+      functionName: "takeBounty",
+      args: [jobId, agentId],
+      chain: null,
+      account: this.account
+    });
+    await this._waitForTx(hash);
+    return { hash };
+  }
+  async submitWork(jobId, options) {
+    if (!options.text && !options.cid) {
+      throw new Error("Provide either text or cid");
+    }
+    const cid = options.cid ?? await pinText(options.text);
+    const hash = await this.walletClient.writeContract({
+      address: this.bountyAdapter,
+      abi: BOUNTY_ADAPTER_ABI,
+      functionName: "submitWork",
+      args: [jobId, cid],
+      chain: null,
+      account: this.account
+    });
+    await this._waitForTx(hash);
+    return { hash };
+  }
+  // ─── Poster cycle ───────────────────────────────────────────────────────────
+  // These let a protocol/DAO agent run the full poster side end-to-end.
+  /** Approve a submission and pay the worker. Records on-chain reputation. */
+  async approveBounty(jobId, reputationScore = 95) {
+    return this._writeAdapter("approveBounty", [jobId, reputationScore]);
+  }
+  /**
+   * Permissionless payout after APPROVAL_TIMEOUT (14d) from submission.
+   * Use this from a watchdog agent to unstick ghosted posters.
+   */
+  async autoApprove(jobId) {
+    return this._writeAdapter("autoApprove", [jobId]);
+  }
+  /** Propose rejection. Triggers a 48h challenge window for the worker. */
+  async rejectBounty(jobId, evidence) {
+    const cid = await this._resolveEvidenceCid(evidence);
+    return this._writeAdapter("rejectBounty", [jobId, cid]);
+  }
+  /** After the challenge window expires unchallenged, anyone may finalize. */
+  async finalizeRejection(jobId) {
+    return this._writeAdapter("finalizeRejection", [jobId]);
+  }
+  /** Cancel a bounty (only valid before takeBounty). Full USDC refund. */
+  async cancelBounty(jobId) {
+    return this._writeAdapter("cancelBounty", [jobId]);
+  }
+  /** Permissionless expiry after deadline. Refunds poster if no submission. */
+  async expireBounty(jobId) {
+    return this._writeAdapter("expireBounty", [jobId]);
+  }
+  /** Arbitrator-only ruling. `payProvider` true → worker wins, false → refund. */
+  async resolveDispute(jobId, payProvider, ruling, reputationPenalty = 0) {
+    const cid = await this._resolveEvidenceCid(ruling);
+    return this._writeAdapter("resolveDispute", [jobId, payProvider, cid, reputationPenalty]);
+  }
+  /** After 48h with no response, anyone may claim the default ruling. */
+  async claimDefaultRuling(jobId) {
+    return this._writeAdapter("claimDefaultRuling", [jobId]);
+  }
+  // ─── Dispute flow (worker-side) ─────────────────────────────────────────────
+  /** Worker challenges a pending rejection — flips bounty into dispute with worker as initiator. */
+  async challengeRejection(jobId, evidence) {
+    const cid = await this._resolveEvidenceCid(evidence);
+    const hash = await this.walletClient.writeContract({
+      address: this.bountyAdapter,
+      abi: BOUNTY_ADAPTER_ABI,
+      functionName: "challengeRejection",
+      args: [jobId, cid],
+      chain: null,
+      account: this.account
+    });
+    await this._waitForTx(hash);
+    return { hash };
+  }
+  /** Open a dispute (either party — after submission, before resolution). */
+  async disputeBounty(jobId, evidence) {
+    const cid = await this._resolveEvidenceCid(evidence);
+    const hash = await this.walletClient.writeContract({
+      address: this.bountyAdapter,
+      abi: BOUNTY_ADAPTER_ABI,
+      functionName: "disputeBounty",
+      args: [jobId, cid],
+      chain: null,
+      account: this.account
+    });
+    await this._waitForTx(hash);
+    return { hash };
+  }
+  /** Respond to an open dispute (only the non-initiator may call). */
+  async respondToDispute(jobId, evidence) {
+    const cid = await this._resolveEvidenceCid(evidence);
+    const hash = await this.walletClient.writeContract({
+      address: this.bountyAdapter,
+      abi: BOUNTY_ADAPTER_ABI,
+      functionName: "respondToDispute",
+      args: [jobId, cid],
+      chain: null,
+      account: this.account
+    });
+    await this._waitForTx(hash);
+    return { hash };
+  }
+  // ─── Expire stale bounties ──────────────────────────────────────────────────
+  async expireStale(category = "", limit = 100) {
+    const jobIds = await this.publicClient.readContract({
+      address: this.bountyAdapter,
+      abi: BOUNTY_ADAPTER_ABI,
+      functionName: "getOpenBounties",
+      args: [category, 0n, BigInt(limit)]
+    });
+    const now = BigInt(Math.floor(Date.now() / 1e3));
+    const expired = [];
+    for (const jobId of jobIds) {
+      const meta = await this.getBounty(jobId);
+      if (meta.deadline < now) {
+        try {
+          const hash = await this.walletClient.writeContract({
+            address: this.bountyAdapter,
+            abi: BOUNTY_ADAPTER_ABI,
+            functionName: "expireBounty",
+            args: [jobId],
+            chain: null,
+            account: this.account
+          });
+          await this._waitForTx(hash);
+          expired.push(jobId);
+        } catch {
+        }
+      }
+    }
+    return expired;
+  }
+  // ─── Reputation ─────────────────────────────────────────────────────────────
+  async getReputation(agentId) {
+    const id = agentId ?? this.agentId;
+    try {
+      const raw = await this.publicClient.readContract({
+        address: this.bountyAdapter,
+        abi: BOUNTY_ADAPTER_ABI,
+        functionName: "getAgentReputation",
+        args: [id]
+      });
+      return raw;
+    } catch {
+      return { averageScore: 0n, totalFeedbacks: 0n, totalJobs: 0n };
+    }
+  }
+  async getAgentInfo() {
+    const id = this.agentId;
+    const reputation = await this.getReputation(id);
+    return {
+      agentId: id,
+      address: this.address,
+      metadataURI: this.metadataURI,
+      reputation
+    };
+  }
+  // ─── USDC helpers ────────────────────────────────────────────────────────────
+  async usdcBalance() {
+    return this.publicClient.readContract({
+      address: CONTRACTS.USDC,
+      abi: ERC20_ABI,
+      functionName: "balanceOf",
+      args: [this.address]
+    });
+  }
+  formatUsdc(raw) {
+    return (Number(raw) / 10 ** USDC_DECIMALS).toFixed(2);
+  }
+  // ─── Event subscriptions ────────────────────────────────────────────────────
+  /**
+   * Watch `BountyCreated` events and invoke `onMatch` for each new bounty that
+   * passes the filter. Returns an `unwatch()` function — call it to stop.
+   *
+   * Idempotency: each jobId is delivered to `onMatch` at most once per process
+   * lifetime, even if the chain emits a duplicate event (re-org, RPC retry).
+   * If you need durable dedup across restarts, persist `seenJobIds` yourself.
+   */
+  subscribeToNewBounties(filter, onMatch) {
+    const seen = /* @__PURE__ */ new Set();
+    const unwatch = this.publicClient.watchContractEvent({
+      address: this.bountyAdapter,
+      abi: BOUNTY_ADAPTER_ABI,
+      eventName: "BountyCreated",
+      onLogs: async (logs) => {
+        for (const log of logs) {
+          const args = log.args;
+          const jobId = args?.jobId;
+          if (jobId === void 0) continue;
+          const key = jobId.toString();
+          if (seen.has(key)) continue;
+          seen.add(key);
+          try {
+            const meta = await this.getBounty(jobId);
+            if (!this._matchesFilter(meta, filter)) continue;
+            await onMatch(meta);
+          } catch (err) {
+            console.error(`[ArcBountyAgent] onMatch error for #${key}:`, err);
+          }
+        }
+      },
+      pollingInterval: 4e3
+    });
+    return unwatch;
+  }
+  _matchesFilter(m, f) {
+    if (f.category && m.category !== f.category) return false;
+    if (f.agentOnly === true && !m.agentOnly) return false;
+    if (f.humanOnly === true && !m.humanOnly) return false;
+    if (f.agentOnly === false && m.agentOnly) return false;
+    if (f.humanOnly === false && m.humanOnly) return false;
+    if (f.maxReward !== void 0 && m.reward > this._parseUsdc(f.maxReward)) return false;
+    if (f.minReward !== void 0 && m.reward < this._parseUsdc(f.minReward)) return false;
+    return true;
+  }
+  // ─── Autonomous loop ────────────────────────────────────────────────────────
+  async runOnce(filter, runTask) {
+    const bounties = await this.listOpenBounties(filter);
+    if (bounties.length === 0) return null;
+    const bounty = bounties[0];
+    console.log(`[ArcBountyAgent] Taking bounty #${bounty.jobId} ($${this.formatUsdc(bounty.reward)} USDC)`);
+    await this.takeBounty(bounty.jobId);
+    const description = await fetchIpfsText(bounty.ipfsDescHash);
+    console.log(`[ArcBountyAgent] Running task for bounty #${bounty.jobId}\u2026`);
+    const result = await runTask(description, bounty);
+    await this.submitWork(bounty.jobId, { text: result });
+    console.log(`[ArcBountyAgent] Work submitted for bounty #${bounty.jobId}. Waiting for approval.`);
+    return bounty.jobId;
+  }
+  // ─── Internal ───────────────────────────────────────────────────────────────
+  async _waitForTx(hash) {
+    await this.publicClient.waitForTransactionReceipt({ hash });
+  }
+  /**
+   * Write to BountyAdapter with the canonical (chain, account) tuple. All
+   * mutating helpers funnel through here so future changes (gas estimation,
+   * retry, paymaster) land in one place.
+   */
+  async _writeAdapter(functionName, args) {
+    const hash = await this.walletClient.writeContract({
+      address: this.bountyAdapter,
+      abi: BOUNTY_ADAPTER_ABI,
+      functionName,
+      args,
+      chain: null,
+      account: this.account
+    });
+    await this._waitForTx(hash);
+    return { hash };
+  }
+  /**
+   * Best-effort idempotency check: scan a bounded recent window for a
+   * Transfer(0x0 → self) on the registry. Arc's public RPC caps eth_getLogs to
+   * a 10,000-block range per call (confirmed empirically — a single wider
+   * request errors outright), so we page backward in 10k chunks up to a total
+   * lookback ceiling instead of issuing one oversized request. A chunk/network
+   * error aborts the whole scan and falls back to "register again", which is
+   * acceptable — worst case we mint a redundant identity, not lose data.
+   */
+  async _findExistingAgentId() {
+    const CHUNK = 10000n;
+    const TOTAL_LOOKBACK = 500000n;
+    try {
+      const head = await this.publicClient.getBlockNumber();
+      const floor = head > TOTAL_LOOKBACK ? head - TOTAL_LOOKBACK : 0n;
+      for (let to = head; to > floor; to -= CHUNK) {
+        const from = to - CHUNK + 1n > floor ? to - CHUNK + 1n : floor;
+        const logs = await this.publicClient.getLogs({
+          address: CONTRACTS.IDENTITY_REGISTRY,
+          event: IDENTITY_REGISTRY_ABI[2],
+          // Transfer event
+          args: { from: ZERO_ADDRESS, to: this.address },
+          fromBlock: from,
+          toBlock: to
+        });
+        if (logs.length > 0) {
+          const last = logs[logs.length - 1];
+          return last.args.tokenId;
+        }
+        if (from === floor) break;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async _ensureUsdcAllowance(amount) {
+    const current = await this.publicClient.readContract({
+      address: CONTRACTS.USDC,
+      abi: ERC20_ABI,
+      functionName: "allowance",
+      args: [this.address, this.bountyAdapter]
+    });
+    if (current >= amount) return;
+    const hash = await this.walletClient.writeContract({
+      address: CONTRACTS.USDC,
+      abi: ERC20_ABI,
+      functionName: "approve",
+      args: [this.bountyAdapter, amount],
+      chain: null,
+      account: this.account
+    });
+    await this._waitForTx(hash);
+  }
+  async _resolveEvidenceCid(e) {
+    if (!e.text && !e.cid) throw new Error("Provide either text or cid");
+    return e.cid ?? await pinText(e.text);
+  }
+  _resolveDeadline(d) {
+    if (d instanceof Date) return BigInt(Math.floor(d.getTime() / 1e3));
+    if (d < 1e9) return BigInt(Math.floor(Date.now() / 1e3) + d);
+    return BigInt(d);
+  }
+  _parseUsdc(dollars) {
+    return BigInt(Math.round(dollars * 10 ** USDC_DECIMALS));
+  }
+};
+
+// src/metadata.ts
+function validateAgentMetadata(m) {
+  if (typeof m !== "object" || m === null) throw new Error("metadata must be an object");
+  const o = m;
+  if (typeof o.name !== "string" || o.name.length === 0)
+    throw new Error("metadata.name must be a non-empty string");
+  if (typeof o.description !== "string")
+    throw new Error("metadata.description must be a string");
+  if (o.capabilities !== void 0 && !Array.isArray(o.capabilities))
+    throw new Error("metadata.capabilities must be an array of strings");
+  if (o.arcbounty !== void 0) {
+    const a = o.arcbounty;
+    if (a.min_reputation !== void 0 && (typeof a.min_reputation !== "number" || a.min_reputation < 0 || a.min_reputation > 100))
+      throw new Error("metadata.arcbounty.min_reputation must be a number in [0, 100]");
+    if (a.preferred_categories !== void 0) {
+      if (!Array.isArray(a.preferred_categories)) throw new Error("preferred_categories must be an array");
+      for (const c of a.preferred_categories) {
+        if (typeof c !== "string" || !["dev", "design", "content", "data", "other"].includes(c))
+          throw new Error(`preferred_categories: invalid category ${String(c)}`);
+      }
+    }
+    for (const k of ["min_reward_usdc", "max_reward_usdc"]) {
+      const v = a[k];
+      if (v !== void 0 && (typeof v !== "number" || v < 0)) {
+        throw new Error(`metadata.arcbounty.${k} must be a non-negative number`);
+      }
+    }
+  }
+}
+async function pinAgentMetadata(meta) {
+  validateAgentMetadata(meta);
+  return pinText(JSON.stringify(meta, null, 2), "agent.json");
+}
+export {
+  ARC_TESTNET_CHAIN_ID,
+  ARC_TESTNET_RPC,
+  ArcBountyAgent,
+  BOUNTY_ADAPTER_ABI,
+  CONTRACTS,
+  ERC20_ABI,
+  IDENTITY_REGISTRY_ABI,
+  fetchIpfsJson,
+  fetchIpfsText,
+  isPinningConfigured,
+  pinAgentMetadata,
+  pinText,
+  validateAgentMetadata
+};