@bountyagents/bountyagents-task 2026.2.277 → 2026.2.278

package/index.ts

@@ -1,94 +1,51 @@
-import { BountyAgentsPublisherPlugin } from "./src/index.js";
-import { PrivateKeySigner } from "./src/signers.js";
-import crypto from "node:crypto";
-import { Type } from "@sinclair/typebox";
+import { registerPublisherTools } from "./src/publisher.js";
 
 export default function register(api: any) {
-  api.registerCommand({
-    name: "task",
-    description: "Bounty Agents Task commands",
-    acceptsArgs: true,
-    handler: async (ctx: any) => {
-      const args = ctx.args?.trim() ?? "";
-      const tokens = args.split(/\s+/).filter(Boolean);
-      const action = (tokens[0] ?? "status").toLowerCase();
+  // api.registerCommand({
+  //   name: "task",
+  //   description: "Bounty Agents Task commands",
+  //   acceptsArgs: true,
+  //   handler: async (ctx: any) => {
+  //     const args = ctx.args?.trim() ?? "";
+  //     const tokens = args.split(/\s+/).filter(Boolean);
+  //     const action = (tokens[0] ?? "status").toLowerCase();
 
-      if (action === "create") {
-        const signer = new PrivateKeySigner(
-          "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
-        );
-        const plugin = new BountyAgentsPublisherPlugin(signer, {
-          serviceUrl: "http://localhost:3000",
-          contractAddress: "0x55D45aFA265d0381C8A81328FfeA408D2Dd45F40",
-        });
+  //     if (action === "create") {
+  //       const signer = new PrivateKeySigner(
+  //         "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+  //       );
+  //       const plugin = new BountyAgentsPublisherPlugin(signer, {
+  //         serviceUrl: "http://localhost:3000",
+  //         contractAddress: "0x55D45aFA265d0381C8A81328FfeA408D2Dd45F40",
+  //       });
 
-        try {
-          const task = (await plugin.executeTool(
-            "bountyagents.publisher.task.create",
-            {
-              id: crypto.randomUUID(),
-              title: "Test Task from CLI",
-              content: "This is a test task created via the CLI tool.",
-            }
-          )) as any;
-          console.log("Task created successfully:", task);
-          return {
-            text: `Task created successfully: ${task.id}`,
-          };
-        } catch (error) {
-          console.error("Failed to create task:", error);
-          return {
-            text: "Failed to create task:",
-            error: error,
-          };
-        }
-      }
+  //       try {
+  //         const task = (await plugin.executeTool(
+  //           "bountyagents.publisher.task.create",
+  //           {
+  //             id: crypto.randomUUID(),
+  //             title: "Test Task from CLI",
+  //             content: "This is a test task created via the CLI tool.",
+  //           }
+  //         )) as any;
+  //         console.log("Task created successfully:", task);
+  //         return {
+  //           text: `Task created successfully: ${task.id}`,
+  //         };
+  //       } catch (error) {
+  //         console.error("Failed to create task:", error);
+  //         return {
+  //           text: "Failed to create task:",
+  //           error: error,
+  //         };
+  //       }
+  //     }
 
-      return {
-        text: ["Bounty Agents Task commands:", "", "/task create"].join("\n"),
-      };
-    },
-  });
+  //     return {
+  //       text: ["Bounty Agents Task commands:", "", "/task create"].join("\n"),
+  //     };
+  //   },
+  // });
 
-  api.registerTool({
-    name: "create_bounty_task",
-    description:
-      "Create a draft bounty task for an agent based on user request, tell user to give title and content of the task, and return the created task id to user if successful",
-    parameters: Type.Object({
-      title: Type.String(),
-      content: Type.String(),
-    }),
-    async execute(_id: string, params: any) {
-      const signer = new PrivateKeySigner(
-        "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
-      );
-      const plugin = new BountyAgentsPublisherPlugin(signer, {
-        serviceUrl: "http://localhost:3000",
-        contractAddress: "0x55D45aFA265d0381C8A81328FfeA408D2Dd45F40",
-      });
-
-      try {
-        const task = (await plugin.executeTool(
-          "bountyagents.publisher.task.create",
-          {
-            id: crypto.randomUUID(),
-            title: params.title,
-            content: params.content,
-          }
-        )) as any;
-        return {
-          content: [
-            { type: "text", text: `Task created successfully! ID: ${task.id}` },
-          ],
-        };
-      } catch (error: any) {
-        return {
-          content: [
-            { type: "text", text: `Failed to create task: ${error.message}` },
-          ],
-          isError: true,
-        };
-      }
-    },
-  });
+ registerPublisherTools(api);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bountyagents/bountyagents-task",
-  "version": "2026.2.277",
+  "version": "2026.2.278",
   "description": "BountyAgents Task Plugin for OpenClaw",
   "type": "module",
   "main": "dist/index.js",

package/src/helper.ts

@@ -0,0 +1,6 @@
+export function json(data: unknown) {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
+    details: data,
+  };
+}

package/src/publisher.ts

@@ -0,0 +1,241 @@
+import { Type } from "@sinclair/typebox";
+import { createPublicClient, createWalletClient, http, parseUnits } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { bscTestnet } from "viem/chains";
+import { taskDepositKey } from "./escrow.js";
+import { json } from "./helper.js";
+import { BountyAgentsPublisherPlugin } from "./index.js";
+import { PrivateKeySigner } from "./signers.js";
+
+const SERVICE_URL = "http://localhost:3000";
+const CONTRACT_ADDRESS = "0x55D45aFA265d0381C8A81328FfeA408D2Dd45F40";
+const PRIVATE_KEY =
+  "0x289f92dd30c36ff24b75b48623c70dea2b428dabac7a52c5ca810bcda64d861b";
+const TEST_TOKEN_ADDRESS = "0x56DA32693A4e6dDd0eDC932b295cb00372f37f8b";
+
+const AGENT_ESCROW_ABI = [
+  {
+    inputs: [
+      { name: "key", type: "bytes32" },
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" },
+    ],
+    name: "deposit",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [{ name: "key", type: "bytes32" }],
+    name: "getDeposit",
+    outputs: [
+      {
+        components: [
+          { name: "owner", type: "address" },
+          { name: "token", type: "address" },
+          { name: "amountLocked", type: "uint256" },
+          { name: "released", type: "bool" },
+        ],
+        name: "",
+        type: "tuple",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const;
+
+const ERC20_ABI = [
+  {
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" },
+    ],
+    name: "approve",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "decimals",
+    outputs: [{ name: "", type: "uint8" }],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const;
+
+export async function createBountyTask(params: {
+  title: string;
+  content: string;
+}) {
+  const signer = new PrivateKeySigner(PRIVATE_KEY);
+  const plugin = new BountyAgentsPublisherPlugin(signer, {
+    serviceUrl: SERVICE_URL,
+    contractAddress: CONTRACT_ADDRESS,
+  });
+
+  const task = (await plugin.executeTool("bountyagents.publisher.task.create", {
+    id: crypto.randomUUID(),
+    title: params.title,
+    content: params.content,
+  })) as any;
+  return task;
+}
+
+export async function fundBountyTask(params: {
+  taskId: string;
+  price: string;
+  token: string;
+}) {
+  const signer = new PrivateKeySigner(PRIVATE_KEY);
+  const plugin = new BountyAgentsPublisherPlugin(signer, {
+    serviceUrl: SERVICE_URL,
+    contractAddress: CONTRACT_ADDRESS,
+  });
+
+  const task = (await plugin.executeTool("bountyagents.publisher.task.fund", {
+    taskId: params.taskId,
+    price: params.price,
+    token: params.token,
+  })) as any;
+  return task;
+}
+
+export async function depositToken(params: {
+  taskId: string;
+  amount?: string;
+}) {
+  const account = privateKeyToAccount(PRIVATE_KEY);
+  const chain = bscTestnet;
+  const transport = http();
+
+  const walletClient = createWalletClient({
+    account,
+    chain,
+    transport,
+  });
+
+  const publicClient = createPublicClient({
+    chain,
+    transport,
+  });
+
+  // Fetch decimals from the token contract
+  console.log(`Fetching decimals for token ${TEST_TOKEN_ADDRESS}...`);
+  const decimals = await publicClient.readContract({
+    address: TEST_TOKEN_ADDRESS as `0x${string}`,
+    abi: ERC20_ABI,
+    functionName: "decimals",
+  });
+  console.log(`Token decimals: ${decimals}`);
+
+  const amount = parseUnits(params.amount || "100", decimals);
+
+  const depositKey = taskDepositKey(params.taskId);
+  console.log(`Deposit key: ${depositKey}`);
+
+  // 1. Approve
+  console.log(`Approving ${params.amount || "100"} tokens...`);
+  const approveHash = await walletClient.writeContract({
+    address: TEST_TOKEN_ADDRESS as `0x${string}`,
+    abi: ERC20_ABI,
+    functionName: "approve",
+    args: [CONTRACT_ADDRESS as `0x${string}`, amount],
+  });
+  console.log(`Approve transaction sent: ${approveHash}`);
+  console.log(`Waiting for confirmation...`);
+  await publicClient.waitForTransactionReceipt({ hash: approveHash });
+  console.log(`Approve confirmed!`);
+
+  // 2. Deposit
+  console.log(`Depositing tokens into AgentEscrow...`);
+  const depositHash = await walletClient.writeContract({
+    address: CONTRACT_ADDRESS as `0x${string}`,
+    abi: AGENT_ESCROW_ABI,
+    functionName: "deposit",
+    args: [depositKey, TEST_TOKEN_ADDRESS as `0x${string}`, amount],
+  });
+
+  await publicClient.waitForTransactionReceipt({ hash: depositHash });
+  console.log(`Deposit confirmed!`);
+
+  const depositInfo = await publicClient.readContract({
+    address: CONTRACT_ADDRESS as `0x${string}`,
+    abi: AGENT_ESCROW_ABI,
+    functionName: "getDeposit",
+    args: [depositKey],
+  });
+
+  return {
+    message: `Successfully deposited ${params.amount || "100"} test tokens`,
+    taskId: params.taskId,
+    approveTransactionHash: approveHash,
+    depositTransactionHash: depositHash,
+    rawAmount: amount.toString(),
+    rawLockedAmount: depositInfo.amountLocked.toString(),
+  };
+}
+
+export function registerPublisherTools(api: any) {
+  api.registerTool({
+    name: "create_bounty_task",
+    description:
+      "Create a draft bounty task for an agent based on user request, tell user to give title and content of the task, and return the created task id to user if successful",
+    parameters: Type.Object({
+      title: Type.String(),
+      content: Type.String(),
+    }),
+    async execute(_id: string, params: any) {
+      try {
+        const result = await createBountyTask(params);
+        return json(result);
+      } catch (error: any) {
+        return json({
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    },
+  });
+
+  api.registerTool({
+    name: "deposit_token",
+    description:
+      "Deposit test tokens into the AgentEscrow contract for a specific task.",
+    parameters: Type.Object({
+      taskId: Type.String(),
+      amount: Type.Optional(Type.String()),
+    }),
+    async execute(_id: string, params: any) {
+      try {
+        const result = await depositToken(params);
+        return json(result);
+      } catch (error: any) {
+        return json({
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    },
+  });
+
+  api.registerTool({
+    name: "fund_bounty_task",
+    description:
+      "Fund a draft bounty task, attaching price and token metadata to it. The token must be in the format 'network:address'.",
+    parameters: Type.Object({
+      taskId: Type.String(),
+      price: Type.String(),
+      token: Type.String(),
+    }),
+    async execute(_id: string, params: any) {
+      try {
+        const result = await fundBountyTask(params);
+        return json(result);
+      } catch (error: any) {
+        return json({
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    },
+  });
+}

package/test-plugin.ts

@@ -0,0 +1,39 @@
+import { depositToken, createBountyTask, fundBountyTask } from "./src/publisher.js";
+
+async function testCreateAndDeposit() {
+  const testId = "test-" + Date.now();
+  console.log(`\n--- Testing createBountyTask ---`);
+  
+  try {
+    const taskResult = await createBountyTask({
+      title: `Test Task ${testId}`,
+      content: "This is a test task content created via standalone function."
+    });
+    console.log("Task creation successful!");
+    console.log(JSON.stringify(taskResult, null, 2));
+
+    const createdTaskId = taskResult.id;
+    console.log(`\n--- Testing depositToken with taskId: ${createdTaskId} ---`);
+    
+    const depositResult = await depositToken({ 
+      taskId: createdTaskId,
+      amount: "100" 
+    });
+    console.log("Deposit successful!");
+    console.log(JSON.stringify(depositResult, null, 2));
+
+    console.log(`\n--- Testing fundBountyTask with taskId: ${createdTaskId} ---`);
+    const fundResult = await fundBountyTask({
+      taskId: createdTaskId,
+      price: depositResult.rawLockedAmount,
+      token: "bsc-testnet:0x56DA32693A4e6dDd0eDC932b295cb00372f37f8b"
+    });
+    console.log("Fund task successful!");
+    console.log(JSON.stringify(fundResult, null, 2));
+  } catch (error) {
+    console.error("Test failed:");
+    console.error(error);
+  }
+}
+
+testCreateAndDeposit();