arcbounty-mcp 0.6.1 → 0.7.0

package/dist/chunk-PQOQ32ZZ.js

@@ -0,0 +1,96 @@
+import {
+  DEFAULT_SPEND_LIMITS,
+  spendLimitError
+} from "./chunk-Q77POHN7.js";
+
+// src/nad-tools.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { parseUnits } from "viem";
+import { encryptContestEntry, decryptContestEntry } from "arcbounty-agent-sdk";
+var job = z.string().regex(/^\d+$/).describe("On-chain job id");
+var cid = z.string().min(1).max(96).describe("IPFS CID; contest entries must contain sealed-box ciphertext");
+var index = z.number().int().min(0).max(24);
+var score = z.number().int().min(0).max(100);
+var indices = z.array(index).min(1).max(25).refine((a) => new Set(a).size === a.length, "Indices must be distinct");
+var address = z.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var amount = z.string().regex(/^(?:0|[1-9]\d*)(?:\.\d{1,6})?$/);
+function createNadMcpServer({ agent, hasSigner, version, limits = DEFAULT_SPEND_LIMITS }) {
+  const server = new McpServer({ name: "nadbounty", version });
+  const json = (value) => ({ content: [{ type: "text", text: JSON.stringify(value, (_, v) => typeof v === "bigint" ? v.toString() : v, 2) }] });
+  const guarded = (fn) => async (args) => {
+    try {
+      return json(await fn(args));
+    } catch (error) {
+      return { isError: true, content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }] };
+    }
+  };
+  const receipt = (fn) => guarded(async (args) => {
+    const r = await fn(args);
+    return { transactionHash: r.transactionHash, status: r.status, gasUsed: r.gasUsed };
+  });
+  server.tool("network", "Monad network, contract and signing configuration. Gas requires MON; rewards use 6-decimal USDC.", {}, guarded(async () => ({ chainId: agent.network.chainId, adapter: agent.bountyAdapter, usdc: agent.network.usdc, gasToken: "MON", hasSigner, ...hasSigner ? { signer: agent.address } : {} })));
+  server.tool("list_open_bounties", "List open NadBounty V4.8 jobs; paginate with offset.", { category: z.string().max(16).default(""), offset: z.number().int().min(0).default(0), limit: z.number().int().min(1).max(100).default(20) }, guarded(async (a) => {
+    const ids = await agent.getOpenBounties(a.category, BigInt(a.offset), BigInt(a.limit));
+    return Promise.all(ids.map((id) => agent.getBounty(id)));
+  }));
+  server.tool("get_bounty", "Full V4.8 job metadata.", { jobId: job }, guarded((a) => agent.getBounty(BigInt(a.jobId))));
+  server.tool("get_contest", "Contest state, encrypted entry CIDs and challenges.", { jobId: job }, guarded(async (a) => {
+    const id = BigInt(a.jobId);
+    const entries = await agent.getContestEntries(id);
+    return { state: await agent.getContestState(id), entries, challenges: await Promise.all(entries.map((_, i) => agent.getContestChallenge(id, i))) };
+  }));
+  server.tool("get_identity_reputation", "Paid jobs and exact score sum used by the gate; feedback averages are not used to reconstruct totals.", { agentId: job, humanWallet: address.optional() }, guarded((a) => agent.getIdentityReputation(BigInt(a.agentId), a.humanWallet ?? agent.address)));
+  server.tool("encrypt_contest_entry", "Seal plaintext to the poster public key. Pin only the returned ciphertext envelope.", { plaintext: z.string().min(1).max(1e6), posterPublicKey: z.string().min(40).max(64) }, guarded((a) => encryptContestEntry(a.plaintext, a.posterPublicKey)));
+  server.tool("decrypt_contest_entry", "Decrypt locally with your private poster key. Private key is never pinned or sent to an RPC.", { entry: z.object({ version: z.literal(1), algorithm: z.literal("x25519-xsalsa20-poly1305-sealedbox"), recipientPublicKey: z.string(), ciphertext: z.string().max(1400100) }), publicKey: z.string(), privateKey: z.string() }, guarded((a) => decryptContestEntry(a.entry, { publicKey: a.publicKey, privateKey: a.privateKey })));
+  if (!hasSigner) return server;
+  let spent = 0;
+  server.tool("post_bounty", "Fund a single-taker job or encrypted contest. Rewards are USDC; operator spending caps apply.", {
+    rewardUsdc: amount,
+    deadline: job,
+    descriptionCid: cid,
+    category: z.enum(["dev", "design", "content", "data", "other"]),
+    tags: z.array(z.string().min(1).max(32)).max(10).default([]),
+    provider: address.default("0x0000000000000000000000000000000000000000"),
+    agentOnly: z.boolean().default(false),
+    humanOnly: z.boolean().default(false),
+    requireWorkerBond: z.boolean().default(false),
+    contest: z.boolean().default(false),
+    maxEntries: z.number().int().min(1).max(25).default(10),
+    winners: z.number().int().min(1).max(25).default(1),
+    minJobs: job.default("0"),
+    minAvgScore: score.default(0)
+  }, guarded(async (a) => {
+    const reward = parseUnits(a.rewardUsdc, 6);
+    if (reward < 1000000n) throw Error("Minimum reward is 1 USDC");
+    if (a.agentOnly && a.humanOnly) throw Error("Choose agentOnly or humanOnly");
+    if (a.contest && (a.requireWorkerBond || a.winners > a.maxEntries)) throw Error("Invalid contest configuration");
+    const error = spendLimitError(Number(a.rewardUsdc), spent, limits);
+    if (error) throw Error(error);
+    spent += Number(a.rewardUsdc);
+    return agent.createBounty({ provider: a.provider, reward, deadline: BigInt(a.deadline), ipfsDescHash: a.descriptionCid, category: a.category, tags: a.tags, agentOnly: a.agentOnly, humanOnly: a.humanOnly, requireWorkerBond: a.requireWorkerBond, contest: a.contest, maxEntries: a.contest ? a.maxEntries : 0, winners: a.contest ? a.winners : 0, minJobs: BigInt(a.minJobs), minAvgScore: a.minAvgScore });
+  }));
+  server.tool("take_bounty", "Take using the current identity owner or working wallet; bond allowance is handled by SDK.", { jobId: job, agentId: job.default("0") }, receipt((a) => agent.takeBounty(BigInt(a.jobId), BigInt(a.agentId))));
+  server.tool("submit_work", "Submit a single-taker result CID.", { jobId: job, resultCid: cid }, receipt((a) => agent.submitWork(BigInt(a.jobId), a.resultCid)));
+  server.tool("approve_bounty", "Poster approves a single-taker submission and pays its current identity owner.", { jobId: job, score }, receipt((a) => agent.approveBounty(BigInt(a.jobId), a.score)));
+  server.tool("enter_contest", "Enter once per identity with a CID containing only encrypted content.", { jobId: job, agentId: job.default("0"), encryptedCid: cid }, receipt((a) => agent.enterContest(BigInt(a.jobId), BigInt(a.agentId), a.encryptedCid)));
+  server.tool("replace_contest_entry", "Replace your encrypted entry before closure.", { jobId: job, index, encryptedCid: cid }, receipt((a) => agent.replaceContestEntry(BigInt(a.jobId), a.index, a.encryptedCid)));
+  server.tool("pick_contest_winners", "Poster selects distinct entry indices with corresponding scores.", { jobId: job, indices, scores: z.array(score).min(1).max(25) }, receipt((a) => {
+    if (a.indices.length !== a.scores.length) throw Error("One score per winner required");
+    return agent.pickContestWinners(BigInt(a.jobId), a.indices, a.scores);
+  }));
+  server.tool("reject_all_contest_entries", "Poster rejects all entries after closure; opens the 48-hour challenge window.", { jobId: job, reasonCid: cid }, receipt((a) => agent.rejectAllContestEntries(BigInt(a.jobId), a.reasonCid)));
+  server.tool("challenge_contest_rejection", "Challenge your entry rejection with readable evidence CID.", { jobId: job, index, evidenceCid: cid }, receipt((a) => agent.challengeContestRejection(BigInt(a.jobId), a.index, a.evidenceCid)));
+  server.tool("respond_to_contest_challenges", "Poster responds to currently unanswered challenges; each has its own 48-hour deadline.", { jobId: job, responseCid: cid }, receipt((a) => agent.respondToContestChallenges(BigInt(a.jobId), a.responseCid)));
+  server.tool("accept_contest_challengers", "Poster pays selected challengers, including while a dispute is open.", { jobId: job, indices, scores: z.array(score).min(1).max(25) }, receipt((a) => {
+    if (a.indices.length !== a.scores.length) throw Error("One score per challenger required");
+    return agent.acceptContestChallengers(BigInt(a.jobId), a.indices, a.scores);
+  }));
+  const settlements = { auto_approve: "autoApprove", cancel_bounty: "cancelBounty", expire_bounty: "expireBounty", settle_contest_silence: "settleContestSilence", finalize_contest_rejection: "finalizeContestRejection", claim_contest_default: "claimContestDefault", claim_contest_arbitrator_timeout: "claimContestArbitratorTimeout", reconcile_expired_escrow: "reconcileExpiredEscrow" };
+  for (const [name, method] of Object.entries(settlements)) server.tool(name, "Attempt the named settlement; on-chain timing and caller rules apply.", { jobId: job }, receipt((a) => agent[method](BigInt(a.jobId))));
+  return server;
+}
+
+export {
+  createNadMcpServer
+};

package/dist/chunk-Q77POHN7.js

@@ -0,0 +1,32 @@
+// src/limits.ts
+var DEFAULT_SPEND_LIMITS = { maxRewardUsdc: 20, maxSpendUsdc: 50 };
+function readCap(env, name, fallback) {
+  const raw = env[name]?.trim();
+  if (!raw) return fallback;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${name}="${raw}" is not a positive number of USDC`);
+  }
+  return value;
+}
+function readSpendLimits(env) {
+  return {
+    maxRewardUsdc: readCap(env, "ARCBOUNTY_MAX_REWARD_USDC", DEFAULT_SPEND_LIMITS.maxRewardUsdc),
+    maxSpendUsdc: readCap(env, "ARCBOUNTY_MAX_SPEND_USDC", DEFAULT_SPEND_LIMITS.maxSpendUsdc)
+  };
+}
+function spendLimitError(rewardUsdc, spentUsdc, limits) {
+  if (rewardUsdc > limits.maxRewardUsdc) {
+    return `A ${rewardUsdc} USDC reward is above this server's per-bounty cap of ${limits.maxRewardUsdc} USDC (ARCBOUNTY_MAX_REWARD_USDC). Only the operator can raise it, in the server's configuration.`;
+  }
+  if (spentUsdc + rewardUsdc > limits.maxSpendUsdc) {
+    return `This server has posted ${spentUsdc} USDC in rewards so far; ${rewardUsdc} more would pass its cap of ${limits.maxSpendUsdc} USDC per run (ARCBOUNTY_MAX_SPEND_USDC). Only the operator can raise it or restart the server.`;
+  }
+  return null;
+}
+
+export {
+  DEFAULT_SPEND_LIMITS,
+  readSpendLimits,
+  spendLimitError
+};

package/dist/{chunk-GY2C2YXQ.js → chunk-YUJRSACG.js}

@@ -1,3 +1,8 @@
+import {
+  DEFAULT_SPEND_LIMITS,
+  spendLimitError
+} from "./chunk-Q77POHN7.js";
+
 // src/tools.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
@@ -6,35 +11,6 @@ import {
   pinAgentMetadata,
   workerBondFor
 } from "arcbounty-agent-sdk";
-
-// src/limits.ts
-var DEFAULT_SPEND_LIMITS = { maxRewardUsdc: 20, maxSpendUsdc: 50 };
-function readCap(env, name, fallback) {
-  const raw = env[name]?.trim();
-  if (!raw) return fallback;
-  const value = Number(raw);
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new Error(`${name}="${raw}" is not a positive number of USDC`);
-  }
-  return value;
-}
-function readSpendLimits(env) {
-  return {
-    maxRewardUsdc: readCap(env, "ARCBOUNTY_MAX_REWARD_USDC", DEFAULT_SPEND_LIMITS.maxRewardUsdc),
-    maxSpendUsdc: readCap(env, "ARCBOUNTY_MAX_SPEND_USDC", DEFAULT_SPEND_LIMITS.maxSpendUsdc)
-  };
-}
-function spendLimitError(rewardUsdc, spentUsdc, limits) {
-  if (rewardUsdc > limits.maxRewardUsdc) {
-    return `A ${rewardUsdc} USDC reward is above this server's per-bounty cap of ${limits.maxRewardUsdc} USDC (ARCBOUNTY_MAX_REWARD_USDC). Only the operator can raise it, in the server's configuration.`;
-  }
-  if (spentUsdc + rewardUsdc > limits.maxSpendUsdc) {
-    return `This server has posted ${spentUsdc} USDC in rewards so far; ${rewardUsdc} more would pass its cap of ${limits.maxSpendUsdc} USDC per run (ARCBOUNTY_MAX_SPEND_USDC). Only the operator can raise it or restart the server.`;
-  }
-  return null;
-}
-
-// src/tools.ts
 function createMcpServer({
   agent,
   hasSigner,
@@ -329,7 +305,7 @@ function createMcpServer({
     server.registerTool(
       "post_bounty",
       {
-        description: `Post a new bounty on ${BRAND} from this server's configured wallet, paying the reward in USDC into escrow. Humans and AI agents can then take it; you review the work with get_bounty and pay with approve_bounty (if you stay silent for 14 days after a submission, it pays out anyway). The reward leaves this wallet now: on ${net.name} that is ${net.testnet ? "test money" : "real money"}. This server refuses a reward over ${limits.maxRewardUsdc} USDC and stops after ${limits.maxSpendUsdc} USDC per run (ARCBOUNTY_MAX_REWARD_USDC / ARCBOUNTY_MAX_SPEND_USDC, set by the operator). Write a description a stranger can finish without asking you anything: the task, the acceptance checks, and what to submit.` + GAS_NOTE,
+        description: `Post a new bounty on ${BRAND} from this server's configured wallet, paying the reward in USDC into escrow. Humans and AI agents can then take it; you review the work with get_bounty and pay with approve_bounty (if you stay silent for 14 days after a submission, it pays out anyway). The reward leaves this wallet now: on ${net.name} that is ${net.testnet ? "test money" : "real money"}. This server refuses a reward over ${limits.maxRewardUsdc} USDC and stops after ${limits.maxSpendUsdc} USDC per run (ARCBOUNTY_MAX_REWARD_USDC / ARCBOUNTY_MAX_SPEND_USDC, set by the operator). Write a description a stranger can finish without asking you anything: the task, the acceptance checks, and what to submit. To hire one specific agent or person, set provider to their wallet: nobody else can take it.` + GAS_NOTE,
         inputSchema: z.object({
           title: z.string().min(1).max(140).describe("One line, shown as the bounty's heading."),
           description: z.string().min(1).describe("Markdown body: what to do, how the result will be judged, and what to submit."),
@@ -338,10 +314,11 @@ function createMcpServer({
           category: z.enum(["dev", "design", "content", "data", "other"]),
           tags: z.array(z.string()).max(10).optional(),
           agent_only: z.boolean().optional().describe("Only ERC-8004 registered agents may take it."),
-          human_only: z.boolean().optional().describe("Only wallets without an agent identity may take it.")
+          human_only: z.boolean().optional().describe("Only wallets without an agent identity may take it."),
+          provider: z.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be a 0x wallet address").optional().describe("Reserve the bounty for this one wallet: only it can take the job. Leave empty for an open bounty.")
         })
       },
-      async ({ title, description, reward_usdc, deadline_days, category, tags, agent_only, human_only }) => {
+      async ({ title, description, reward_usdc, deadline_days, category, tags, agent_only, human_only, provider }) => {
         if (agent_only && human_only) {
           return errorResult("agent_only and human_only exclude each other: set at most one of them.");
         }
@@ -363,7 +340,8 @@ ${description}`,
             category,
             tags: tags ?? [],
             agentOnly: agent_only ?? false,
-            humanOnly: human_only ?? false
+            humanOnly: human_only ?? false,
+            ...provider ? { provider } : {}
           });
           spentUsdc = Math.round((spentUsdc + reward_usdc) * 1e6) / 1e6;
           const jobId = result.jobId?.toString() ?? null;
@@ -454,6 +432,5 @@ ${description}`,
 }
 
 export {
-  readSpendLimits,
   createMcpServer
 };

package/dist/index.js

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 import {
-  createMcpServer,
+  createMcpServer
+} from "./chunk-YUJRSACG.js";
+import {
   readSpendLimits
-} from "./chunk-GY2C2YXQ.js";
+} from "./chunk-Q77POHN7.js";
 
 // src/index.ts
 import { createRequire } from "module";

package/dist/limits-BI-elTc1.d.ts

@@ -0,0 +1,8 @@
+type SpendLimits = {
+    /** Largest single reward post_bounty accepts, in USDC. */
+    maxRewardUsdc: number;
+    /** Most post_bounty may post in total during one run of this server, in USDC. */
+    maxSpendUsdc: number;
+};
+
+export type { SpendLimits as S };

package/dist/nad-cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/nad-cli.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import {
+  createNadMcpServer
+} from "./chunk-PQOQ32ZZ.js";
+import {
+  readSpendLimits
+} from "./chunk-Q77POHN7.js";
+
+// src/nad-cli.ts
+import { createRequire } from "module";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { NadBountyAgent, MONAD_NETWORKS } from "arcbounty-agent-sdk";
+import { createPublicClient, http, isAddress } from "viem";
+var pkg = createRequire(import.meta.url)("../package.json");
+async function main() {
+  const network = process.env.NAD_NETWORK ?? "monad-testnet";
+  if (!Object.hasOwn(MONAD_NETWORKS, network)) throw Error("NAD_NETWORK must be monad-testnet or monad-mainnet");
+  const raw = process.env.NAD_BOUNTY_ADAPTER_ADDRESS ?? (network === "monad-testnet" ? "0xf88B980B3AB1CD5A2Befd9c0B88B70196f215020" : void 0);
+  if (!raw || !isAddress(raw)) throw Error("Configure NAD_BOUNTY_ADAPTER_ADDRESS for the selected Monad network");
+  const config = MONAD_NETWORKS[network], rpcUrl = process.env.NAD_RPC_URL ?? config.rpcUrl;
+  if (await createPublicClient({ transport: http(rpcUrl) }).getChainId() !== config.chainId) throw Error("Monad RPC chain mismatch");
+  const privateKey = process.env.NAD_PRIVATE_KEY;
+  const agent = new NadBountyAgent({ network, bountyAdapterAddress: raw, rpcUrl, privateKey });
+  const limits = readSpendLimits({ ...process.env, ARCBOUNTY_MAX_REWARD_USDC: process.env.NAD_MAX_REWARD_USDC, ARCBOUNTY_MAX_SPEND_USDC: process.env.NAD_MAX_SPEND_USDC });
+  const server = createNadMcpServer({ agent, hasSigner: !!privateKey, version: pkg.version, limits });
+  await server.connect(new StdioServerTransport());
+  console.error(`[nadbounty] ${network}, adapter ${raw}, ${privateKey ? `signing as ${agent.address}` : "read-only"}. Gas: MON.`);
+}
+main().catch(() => {
+  console.error("[nadbounty] Startup failed. Check NAD_NETWORK, NAD_BOUNTY_ADAPTER_ADDRESS, NAD_RPC_URL and NAD_PRIVATE_KEY.");
+  process.exitCode = 1;
+});

package/dist/nad-tools.d.ts

@@ -0,0 +1,13 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { NadBountyAgent } from 'arcbounty-agent-sdk';
+import { S as SpendLimits } from './limits-BI-elTc1.js';
+
+/** Independent V4.8 surface: legacy Arc/Base tools retain their V4.7 ABI. */
+declare function createNadMcpServer({ agent, hasSigner, version, limits }: {
+    agent: NadBountyAgent;
+    hasSigner: boolean;
+    version: string;
+    limits?: SpendLimits;
+}): McpServer;
+
+export { createNadMcpServer };

package/dist/nad-tools.js

@@ -0,0 +1,7 @@
+import {
+  createNadMcpServer
+} from "./chunk-PQOQ32ZZ.js";
+import "./chunk-Q77POHN7.js";
+export {
+  createNadMcpServer
+};

package/dist/tools.d.ts

@@ -1,12 +1,6 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { ArcBountyAgent } from 'arcbounty-agent-sdk';
-
-type SpendLimits = {
-    /** Largest single reward post_bounty accepts, in USDC. */
-    maxRewardUsdc: number;
-    /** Most post_bounty may post in total during one run of this server, in USDC. */
-    maxSpendUsdc: number;
-};
+import { S as SpendLimits } from './limits-BI-elTc1.js';
 
 /**
  * Build the MCP server for one already-configured agent.

package/dist/tools.js

@@ -1,6 +1,7 @@
 import {
   createMcpServer
-} from "./chunk-GY2C2YXQ.js";
+} from "./chunk-YUJRSACG.js";
+import "./chunk-Q77POHN7.js";
 export {
   createMcpServer
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcbounty-mcp",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "mcpName": "io.github.Sofiia7/arcbounty-mcp",
   "description": "Put an AI agent to work for USDC, or let it hire. MCP server for a live on-chain bounty board where agents and humans take the same jobs: browsing needs no credentials; with a signing key the agent takes a job, submits the work and is paid into its own wallet through canonical ERC-8183 escrow, earning ERC-8004 on-chain reputation, or posts bounties of its own, reviews the delivery and pays for it, within operator-set spending caps. One package, two networks: Arc (ArcBounty) and Base (BaseBounty).",
   "type": "module",
@@ -23,7 +23,7 @@
     "url": "https://github.com/Sofiia7/ARC/issues"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/tools.ts --format esm --dts --clean",
+    "build": "tsup src/index.ts src/tools.ts src/nad-cli.ts src/nad-tools.ts --format esm --dts --clean",
     "dev": "tsx src/index.ts",
     "typecheck": "tsc --noEmit",
     "start": "node dist/index.js",
@@ -52,7 +52,7 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "arcbounty-agent-sdk": "^0.9.1",
+    "arcbounty-agent-sdk": "^0.10.0",
     "viem": "^2.0.0",
     "zod": "^3.23.0"
   },
@@ -67,6 +67,8 @@
     ".": "./dist/index.js",
     "./server": "./dist/tools.js",
     "./dist/*": "./dist/*",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./nad-cli": "./dist/nad-cli.js",
+    "./nad-server": "./dist/nad-tools.js"
   }
 }