arcbounty-agent-sdk 0.1.0 → 0.3.0

package/dist/index.mjs

@@ -1,13 +1,11 @@
 // src/ArcBountyAgent.ts
 import {
   createPublicClient,
-  createWalletClient,
   decodeEventLog,
-  http,
+  http as http2,
   defineChain,
   isAddress
 } from "viem";
-import { privateKeyToAccount } from "viem/accounts";
 
 // src/abi.ts
 var BOUNTY_META_TUPLE = {
@@ -37,7 +35,9 @@ var BOUNTY_META_TUPLE = {
     { name: "disputeRaisedAt", type: "uint256" },
     { name: "disputeReasonHash", type: "string" },
     { name: "disputeResponseHash", type: "string" },
-    { name: "disputeRulingHash", type: "string" }
+    { name: "disputeRulingHash", type: "string" },
+    { name: "requireWorkerBond", type: "bool" },
+    { name: "workerBond", type: "uint256" }
   ]
 };
 var BOUNTY_ADAPTER_ABI = [
@@ -57,7 +57,8 @@ var BOUNTY_ADAPTER_ABI = [
         { name: "category", type: "string" },
         { name: "tags", type: "string[]" },
         { name: "agentOnly", type: "bool" },
-        { name: "humanOnly", type: "bool" }
+        { name: "humanOnly", type: "bool" },
+        { name: "requireWorkerBond", type: "bool" }
       ]
     }],
     outputs: [{ name: "jobId", type: "uint256" }]
@@ -179,7 +180,27 @@ var BOUNTY_ADAPTER_ABI = [
     inputs: [{ name: "jobId", type: "uint256" }],
     outputs: []
   },
+  {
+    // V3.3 — permissionless neutral 50/50 split if the arbitrator never rules
+    // after both parties have submitted evidence (claimDefaultRuling doesn't
+    // apply once a response exists). See ARBITRATOR_TIMEOUT (30d).
+    name: "claimArbitratorTimeout",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "jobId", type: "uint256" }],
+    outputs: []
+  },
   // ── Read ──
+  {
+    // Public array getter — needed to scan the full bounty set (expireStale,
+    // keeper-style scripts). Not paginated on-chain; callers should bound
+    // their own scan via totalBounties().
+    name: "allJobIds",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
   {
     name: "getOpenBounties",
     type: "function",
@@ -269,6 +290,34 @@ var BOUNTY_ADAPTER_ABI = [
     inputs: [],
     outputs: [{ name: "", type: "uint256" }]
   },
+  {
+    name: "ARBITRATOR_TIMEOUT",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "uniquePosterCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "WORKER_BOND_BPS",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "MIN_WORKER_BOND",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
   // ── Events ──
   {
     name: "BountyCreated",
@@ -335,6 +384,42 @@ var BOUNTY_ADAPTER_ABI = [
       { name: "rulingHash", type: "string", indexed: false },
       { name: "defaultRuling", type: "bool", indexed: false }
     ]
+  },
+  {
+    name: "ArbitratorTimeoutClaimed",
+    type: "event",
+    inputs: [
+      { name: "jobId", type: "uint256", indexed: true },
+      { name: "posterAmount", type: "uint256", indexed: false },
+      { name: "providerAmount", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    name: "WorkerBondPosted",
+    type: "event",
+    inputs: [
+      { name: "jobId", type: "uint256", indexed: true },
+      { name: "worker", type: "address", indexed: true },
+      { name: "amount", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    name: "WorkerBondRefunded",
+    type: "event",
+    inputs: [
+      { name: "jobId", type: "uint256", indexed: true },
+      { name: "worker", type: "address", indexed: true },
+      { name: "amount", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    name: "WorkerBondForfeited",
+    type: "event",
+    inputs: [
+      { name: "jobId", type: "uint256", indexed: true },
+      { name: "poster", type: "address", indexed: true },
+      { name: "amount", type: "uint256", indexed: false }
+    ]
   }
 ];
 var IDENTITY_REGISTRY_ABI = [
@@ -392,6 +477,61 @@ var ERC20_ABI = [
   }
 ];
 
+// src/signers/viemSigner.ts
+import { createWalletClient, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+var ViemSigner = class {
+  constructor(privateKey, chain, rpcUrl) {
+    this.account = privateKeyToAccount(privateKey);
+    this.address = this.account.address;
+    this.walletClient = createWalletClient({ account: this.account, chain, transport: http(rpcUrl) });
+  }
+  async writeContract(params) {
+    return this.walletClient.writeContract({
+      address: params.address,
+      abi: params.abi,
+      functionName: params.functionName,
+      args: params.args,
+      chain: null,
+      account: this.account
+    });
+  }
+};
+
+// src/signers/circleSigner.ts
+import { encodeFunctionData } from "viem";
+import { initiateDeveloperControlledWalletsClient } from "@circle-fin/developer-controlled-wallets";
+var CircleSigner = class {
+  constructor(config) {
+    this.address = config.address;
+    this.walletId = config.walletId;
+    this.client = initiateDeveloperControlledWalletsClient({
+      apiKey: config.apiKey,
+      entitySecret: config.entitySecret,
+      baseUrl: config.baseUrl
+    });
+  }
+  async writeContract(params) {
+    const callData = encodeFunctionData({
+      abi: params.abi,
+      functionName: params.functionName,
+      args: params.args
+    });
+    const created = await this.client.createContractExecutionTransaction({
+      walletId: this.walletId,
+      contractAddress: params.address,
+      callData,
+      fee: { type: "level", config: { feeLevel: "MEDIUM" } }
+    });
+    const txId = created.data?.id;
+    if (!txId) {
+      throw new Error("CircleSigner: createContractExecutionTransaction did not return a transaction id");
+    }
+    const result = await this.client.getTransaction({ id: txId, waitForTxHash: true });
+    return result.data.transaction.txHash;
+  }
+};
+
 // src/constants.ts
 var ARC_TESTNET_RPC = "https://rpc.testnet.arc.network";
 var ARC_TESTNET_CHAIN_ID = 5042002;
@@ -472,6 +612,40 @@ async function pinText(content, filename = "result.md") {
   throw new Error("Set PINATA_JWT (preferred) or PINATA_API_KEY + PINATA_SECRET to pin to IPFS");
 }
 
+// src/logic.ts
+function parseUsdc(dollars) {
+  return BigInt(Math.round(dollars * 10 ** USDC_DECIMALS));
+}
+function resolveDeadline(d, nowSec = Math.floor(Date.now() / 1e3)) {
+  if (d instanceof Date) return BigInt(Math.floor(d.getTime() / 1e3));
+  if (d < 1e9) return BigInt(nowSec + d);
+  return BigInt(d);
+}
+function matchesBountyFilter(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 > parseUsdc(f.maxReward)) return false;
+  if (f.minReward !== void 0 && m.reward < parseUsdc(f.minReward)) return false;
+  return true;
+}
+var TRANSFER_SIG = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+var ZERO_TOPIC = "0x" + "0".repeat(64);
+function agentIdFromReceiptLogs(logs, registryAddress, selfAddress) {
+  const me = selfAddress.toLowerCase().slice(2).padStart(64, "0");
+  for (const log of logs) {
+    if (log.address.toLowerCase() !== registryAddress.toLowerCase()) continue;
+    if (log.topics.length < 4) continue;
+    if (log.topics[0]?.toLowerCase() !== TRANSFER_SIG) continue;
+    if (log.topics[1]?.toLowerCase() !== ZERO_TOPIC) continue;
+    if (log.topics[2]?.toLowerCase() !== "0x" + me) continue;
+    return BigInt(log.topics[3]);
+  }
+  return null;
+}
+
 // src/ArcBountyAgent.ts
 var arcTestnet = defineChain({
   id: ARC_TESTNET_CHAIN_ID,
@@ -484,7 +658,7 @@ var ArcBountyAgent = class {
     this._agentId = null;
     const rpcUrl = config.rpcUrl ?? ARC_TESTNET_RPC;
     this.chain = defineChain({ ...arcTestnet, rpcUrls: { default: { http: [rpcUrl] } } });
-    this.account = privateKeyToAccount(config.privateKey);
+    this.signer = config.circleWallet ? new CircleSigner(config.circleWallet) : new ViemSigner(config.privateKey, this.chain, rpcUrl);
     this.metadataURI = config.metadataURI ?? "";
     const rawAdapter = config.bountyAdapterAddress ?? process.env["BOUNTY_ADAPTER_ADDRESS"];
     if (!rawAdapter) {
@@ -496,11 +670,10 @@ var ArcBountyAgent = class {
       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) });
+    this.publicClient = createPublicClient({ chain: this.chain, transport: http2(rpcUrl) });
   }
   get address() {
-    return this.account.address;
+    return this.signer.address;
   }
   // ─── Identity ───────────────────────────────────────────────────────────────
   async register() {
@@ -509,34 +682,18 @@ var ArcBountyAgent = class {
       this._agentId = existing;
       return existing;
     }
-    const hash = await this.walletClient.writeContract({
+    const hash = await this.signer.writeContract({
       address: CONTRACTS.IDENTITY_REGISTRY,
       abi: IDENTITY_REGISTRY_ABI,
       functionName: "register",
-      args: [this.metadataURI],
-      chain: null,
-      account: this.account
+      args: [this.metadataURI]
     });
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
-    const agentId = this._agentIdFromReceiptLogs(receipt.logs);
+    const agentId = agentIdFromReceiptLogs(receipt.logs, CONTRACTS.IDENTITY_REGISTRY, this.signer.address);
     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;
@@ -562,15 +719,7 @@ var ArcBountyAgent = class {
       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;
-    });
+    return metas.filter((m) => matchesBountyFilter(m, { agentOnly, humanOnly, maxReward, minReward }));
   }
   async getBounty(jobId) {
     const raw = await this.publicClient.readContract({
@@ -611,11 +760,11 @@ var ArcBountyAgent = class {
     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 reward = parseUsdc(opts.rewardUsdc);
+    const deadline = resolveDeadline(opts.deadline);
     const descCid = opts.descriptionCid ?? await pinText(opts.descriptionText);
     await this._ensureUsdcAllowance(reward);
-    const hash = await this.walletClient.writeContract({
+    const hash = await this.signer.writeContract({
       address: this.bountyAdapter,
       abi: BOUNTY_ADAPTER_ABI,
       functionName: "createBounty",
@@ -627,10 +776,9 @@ var ArcBountyAgent = class {
         category: opts.category,
         tags: opts.tags ?? [],
         agentOnly: opts.agentOnly ?? false,
-        humanOnly: opts.humanOnly ?? false
-      }],
-      chain: null,
-      account: this.account
+        humanOnly: opts.humanOnly ?? false,
+        requireWorkerBond: opts.requireWorkerBond ?? false
+      }]
     });
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
     let jobId;
@@ -654,32 +802,14 @@ var ArcBountyAgent = class {
   // ─── 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 };
+    return this._writeAdapter("takeBounty", [jobId, agentId]);
   }
   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 };
+    return this._writeAdapter("submitWork", [jobId, cid]);
   }
   // ─── Poster cycle ───────────────────────────────────────────────────────────
   // These let a protocol/DAO agent run the full poster side end-to-end.
@@ -720,75 +850,67 @@ var ArcBountyAgent = class {
   async claimDefaultRuling(jobId) {
     return this._writeAdapter("claimDefaultRuling", [jobId]);
   }
+  /**
+   * V3.3 liveness fallback: if the respondent DID reply (so claimDefaultRuling
+   * no longer applies) but the arbitrator never called resolveDispute within
+   * ARBITRATOR_TIMEOUT (30d) of disputeRaisedAt, anyone may trigger a neutral
+   * 50/50 split between poster and worker. No reputation penalty either way.
+   */
+  async claimArbitratorTimeout(jobId) {
+    return this._writeAdapter("claimArbitratorTimeout", [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 };
+    return this._writeAdapter("challengeRejection", [jobId, cid]);
   }
   /** 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 };
+    return this._writeAdapter("disputeBounty", [jobId, cid]);
   }
   /** 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 };
+    return this._writeAdapter("respondToDispute", [jobId, cid]);
   }
   // ─── Expire stale bounties ──────────────────────────────────────────────────
+  /**
+   * Scans the full bounty set and calls expireBounty() on anything past its
+   * deadline with no submission and not yet resolved. Stops after finding
+   * `limit` candidates to expire.
+   *
+   * NOTE: `getOpenBounties` (used pre-V3.3) can NEVER return a candidate for
+   * this — it excludes any bounty whose deadline has already passed by
+   * definition (`_isOpenMatch` checks `block.timestamp <= deadline`). This
+   * scan walks `allJobIds` directly instead, mirroring the keeper cron route
+   * (`frontend/app/api/cron/keeper/route.ts`).
+   */
   async expireStale(category = "", limit = 100) {
-    const jobIds = await this.publicClient.readContract({
+    const total = await this.publicClient.readContract({
       address: this.bountyAdapter,
       abi: BOUNTY_ADAPTER_ABI,
-      functionName: "getOpenBounties",
-      args: [category, 0n, BigInt(limit)]
+      functionName: "totalBounties"
     });
     const now = BigInt(Math.floor(Date.now() / 1e3));
     const expired = [];
-    for (const jobId of jobIds) {
+    for (let i = 0n; i < total && expired.length < limit; i++) {
+      const jobId = await this.publicClient.readContract({
+        address: this.bountyAdapter,
+        abi: BOUNTY_ADAPTER_ABI,
+        functionName: "allJobIds",
+        args: [i]
+      });
       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 {
-        }
+      if (meta.resolved) continue;
+      if (meta.submittedResultHash.length > 0) continue;
+      if (category && meta.category !== category) continue;
+      if (meta.deadline >= now) continue;
+      try {
+        await this._writeAdapter("expireBounty", [jobId]);
+        expired.push(jobId);
+      } catch {
       }
     }
     return expired;
@@ -808,6 +930,21 @@ var ArcBountyAgent = class {
       return { averageScore: 0n, totalFeedbacks: 0n, totalJobs: 0n };
     }
   }
+  /**
+   * V4 anti-Sybil signal: count of distinct posters who've actually paid out
+   * a completed bounty to this agent. Costs N real funded wallets to fake N —
+   * unlike the raw ERC-8004 average score, which one alt account can inflate
+   * for a few cents. See V4_DESIGN_ANTI_SYBIL.md.
+   */
+  async getUniquePosterCount(agentId) {
+    const id = agentId ?? this.agentId;
+    return this.publicClient.readContract({
+      address: this.bountyAdapter,
+      abi: BOUNTY_ADAPTER_ABI,
+      functionName: "uniquePosterCount",
+      args: [id]
+    });
+  }
   async getAgentInfo() {
     const id = this.agentId;
     const reputation = await this.getReputation(id);
@@ -855,7 +992,7 @@ var ArcBountyAgent = class {
           seen.add(key);
           try {
             const meta = await this.getBounty(jobId);
-            if (!this._matchesFilter(meta, filter)) continue;
+            if (!matchesBountyFilter(meta, filter)) continue;
             await onMatch(meta);
           } catch (err) {
             console.error(`[ArcBountyAgent] onMatch error for #${key}:`, err);
@@ -866,15 +1003,110 @@ var ArcBountyAgent = class {
     });
     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;
+  // ─── Dispute watchdog (self-protection) ─────────────────────────────────────
+  /**
+   * Background watchdog over this agent's own assigned bounties. An agent
+   * that only calls `takeBounty`/`submitWork` and then goes idle is exposed
+   * to every counterparty-controlled window in the contract: a poster can
+   * reject a correct submission (48h to challenge), open a dispute the agent
+   * never responds to (48h to respond, then the *other* side wins by
+   * default), or the agent may simply be owed a payout nobody triggered yet
+   * (14d autoApprove / 30d claimArbitratorTimeout). `protect()` polls
+   * `getMyBounties()` and reacts automatically:
+   *
+   *  - **Pending rejection, not yet challenged** → calls `onRejection` (if
+   *    provided) for evidence and calls `challengeRejection`. Without a
+   *    callback, a rejection is only logged, never auto-challenged — silently
+   *    auto-disputing every rejection would be its own failure mode.
+   *  - **Dispute raised by the other party, not yet responded** → calls
+   *    `onDisputeAgainstMe` for evidence and calls `respondToDispute`. Same
+   *    caveat: no callback means log-only.
+   *  - **Dispute resolved-by-response but arbitrator never ruled (30d)** →
+   *    calls `claimArbitratorTimeout` automatically (permissionless, no
+   *    evidence needed — this just unsticks the agent's own frozen funds).
+   *  - **Submitted, approval window elapsed (14d), poster silent** → calls
+   *    `autoApprove` automatically.
+   *
+   * Returns an `unwatch()` function. Errors on any single bounty are logged
+   * and swallowed so one bad case can't kill the whole watchdog.
+   */
+  protect(options = {}) {
+    const pollingIntervalMs = options.pollingIntervalMs ?? 6e4;
+    let stopped = false;
+    const tick = async () => {
+      if (stopped) return;
+      try {
+        await this._protectOnce(options);
+      } catch (err) {
+        console.error("[ArcBountyAgent.protect] tick error:", err);
+      }
+      if (!stopped) timer = setTimeout(tick, pollingIntervalMs);
+    };
+    let timer = setTimeout(tick, 0);
+    return () => {
+      stopped = true;
+      clearTimeout(timer);
+    };
+  }
+  async _protectOnce(options) {
+    const [rejectionWindow, disputeWindow, approvalTimeout, arbitratorTimeout] = await Promise.all([
+      this.publicClient.readContract({
+        address: this.bountyAdapter,
+        abi: BOUNTY_ADAPTER_ABI,
+        functionName: "REJECTION_CHALLENGE_WINDOW"
+      }),
+      this.publicClient.readContract({
+        address: this.bountyAdapter,
+        abi: BOUNTY_ADAPTER_ABI,
+        functionName: "DISPUTE_RESPONSE_WINDOW"
+      }),
+      this.publicClient.readContract({
+        address: this.bountyAdapter,
+        abi: BOUNTY_ADAPTER_ABI,
+        functionName: "APPROVAL_TIMEOUT"
+      }),
+      this.publicClient.readContract({
+        address: this.bountyAdapter,
+        abi: BOUNTY_ADAPTER_ABI,
+        functionName: "ARBITRATOR_TIMEOUT"
+      })
+    ]);
+    const now = BigInt(Math.floor(Date.now() / 1e3));
+    const mine = await this.getMyBounties();
+    for (const meta of mine) {
+      if (meta.resolved) continue;
+      try {
+        if (meta.rejectedAt > 0n && !meta.inDispute && now <= meta.rejectedAt + rejectionWindow) {
+          options.onEvent?.("rejection_pending", meta);
+          if (options.onRejection) {
+            const evidence = await options.onRejection(meta);
+            await this.challengeRejection(meta.jobId, evidence);
+            options.onEvent?.("rejection_challenged", meta);
+          }
+          continue;
+        }
+        if (meta.inDispute && meta.disputeResponseHash.length === 0 && meta.disputeInitiator.toLowerCase() !== this.address.toLowerCase() && now <= meta.disputeRaisedAt + disputeWindow) {
+          options.onEvent?.("dispute_needs_response", meta);
+          if (options.onDisputeAgainstMe) {
+            const evidence = await options.onDisputeAgainstMe(meta);
+            await this.respondToDispute(meta.jobId, evidence);
+            options.onEvent?.("dispute_responded", meta);
+          }
+          continue;
+        }
+        if (meta.inDispute && meta.disputeResponseHash.length > 0 && now > meta.disputeRaisedAt + arbitratorTimeout) {
+          await this.claimArbitratorTimeout(meta.jobId);
+          options.onEvent?.("arbitrator_timeout_claimed", meta);
+          continue;
+        }
+        if (meta.submittedAt > 0n && meta.rejectedAt === 0n && !meta.inDispute && now > meta.submittedAt + approvalTimeout) {
+          await this.autoApprove(meta.jobId);
+          options.onEvent?.("auto_approved", meta);
+        }
+      } catch (err) {
+        console.error(`[ArcBountyAgent.protect] error handling bounty #${meta.jobId}:`, err);
+      }
+    }
   }
   // ─── Autonomous loop ────────────────────────────────────────────────────────
   async runOnce(filter, runTask) {
@@ -900,13 +1132,11 @@ var ArcBountyAgent = class {
    * retry, paymaster) land in one place.
    */
   async _writeAdapter(functionName, args) {
-    const hash = await this.walletClient.writeContract({
+    const hash = await this.signer.writeContract({
       address: this.bountyAdapter,
       abi: BOUNTY_ADAPTER_ABI,
       functionName,
-      args,
-      chain: null,
-      account: this.account
+      args
     });
     await this._waitForTx(hash);
     return { hash };
@@ -955,13 +1185,11 @@ var ArcBountyAgent = class {
       args: [this.address, this.bountyAdapter]
     });
     if (current >= amount) return;
-    const hash = await this.walletClient.writeContract({
+    const hash = await this.signer.writeContract({
       address: CONTRACTS.USDC,
       abi: ERC20_ABI,
       functionName: "approve",
-      args: [this.bountyAdapter, amount],
-      chain: null,
-      account: this.account
+      args: [this.bountyAdapter, amount]
     });
     await this._waitForTx(hash);
   }
@@ -969,14 +1197,6 @@ var ArcBountyAgent = class {
     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