@bountyagents/bountyagents-task 2026.3.100 → 2026.3.102

package/src/publisher.ts

@@ -1,322 +0,0 @@
-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, getPrivateKey } from "./helper.js";
-import { BountyAgentsPublisherPlugin } from "./index.js";
-import { PrivateKeySigner } from "./signers.js";
-
-const SERVICE_URL = "http://localhost:3000";
-const CONTRACT_ADDRESS = "0x55D45aFA265d0381C8A81328FfeA408D2Dd45F40";
-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(getPrivateKey());
-  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;
-  token: string;
-}) {
-  const signer = new PrivateKeySigner(getPrivateKey());
-  const plugin = new BountyAgentsPublisherPlugin(signer, {
-    serviceUrl: SERVICE_URL,
-    contractAddress: CONTRACT_ADDRESS,
-  });
-
-  const task = (await plugin.executeTool("bountyagents.publisher.task.fund", {
-    taskId: params.taskId,
-    token: params.token,
-  })) as any;
-  return task;
-}
-
-export async function depositToken(params: {
-  taskId: string;
-  amount?: string;
-}) {
-  const account = privateKeyToAccount(getPrivateKey());
-  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 async function decideOnResponse(params: {
-  responseId: string;
-  workerAddress: string;
-  price: string;
-  status: "approved" | "rejected";
-}) {
-  const signer = new PrivateKeySigner(getPrivateKey());
-  const plugin = new BountyAgentsPublisherPlugin(signer, {
-    serviceUrl: SERVICE_URL,
-    contractAddress: CONTRACT_ADDRESS,
-  });
-
-  const response = (await plugin.executeTool(
-    "bountyagents.publisher.task.decision",
-    params
-  )) as any;
-  return response;
-}
-
-export async function openUpclawDashboard() {
-  const signer = new PrivateKeySigner(getPrivateKey());
-  const message = `login-${Date.now()}`;
-  const signature = await signer.signMessage(message);
-
-  const response = await fetch(`${SERVICE_URL}/request-token`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({
-      address: signer.address,
-      message,
-      signature,
-    }),
-  });
-
-  if (!response.ok) {
-    const errorText = await response.text();
-    throw new Error(`Failed to request token: ${errorText}`);
-  }
-
-  const { token } = await response.json() as { token: string };
-  return { url: `http://localhost:6006/?token=${token}` };
-}
-
-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 tokens into the AgentEscrow contract for a specific task. The token must be in the format 'network:address'.",
-    parameters: Type.Object({
-      taskId: Type.String(),
-      token: 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 token metadata to it. The token must be in the format 'network:address'.",
-    parameters: Type.Object({
-      taskId: 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),
-        });
-      }
-    },
-  });
-
-  api.registerTool({
-    name: "decide_on_response",
-    description: "Approve or reject a task response.",
-    parameters: Type.Object({
-      responseId: Type.String(),
-      workerAddress: Type.String(),
-      price: Type.String(),
-      status: Type.Union([
-        Type.Literal("approved"),
-        Type.Literal("rejected"),
-      ]),
-    }),
-    async execute(_id: string, params: any) {
-      try {
-        const result = await decideOnResponse(params);
-        return json(result);
-      } catch (error: any) {
-        return json({
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-    },
-  });
-
-  api.registerTool({
-    name: "get_bounty_dashboard_url",
-    description: "Get the bounty dashboard URL with a pre-authenticated token in the URL param",
-    parameters: Type.Object({}),
-    async execute(_id: string, _params: any) {
-      try {
-        const result = await openUpclawDashboard();
-        return json(result);
-      } catch (error: any) {
-        return json({
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-    },
-  });
-}

package/src/signers.ts

@@ -1,36 +0,0 @@
-import { Account, Address, Hex, hexToBytes } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-
-export interface Signer {
-  readonly address: Address;
-  signMessage(message: string): Promise<Hex>;
-  signDigest(digest: Hex): Promise<Hex>;
-}
-
-export class PrivateKeySigner implements Signer {
-  private readonly account: Account;
-
-  constructor(privateKey: Hex) {
-    this.account = privateKeyToAccount(privateKey);
-  }
-
-  get address(): Address {
-    return this.account.address;
-  }
-
-  signMessage(message: string): Promise<Hex> {
-    const signMessageFn = this.account.signMessage;
-    if (!signMessageFn) {
-      throw new Error('Account does not support signMessage');
-    }
-    return signMessageFn({ message });
-  }
-
-  signDigest(digest: Hex): Promise<Hex> {
-    const signMessageFn = this.account.signMessage;
-    if (!signMessageFn) {
-      throw new Error('Account does not support signDigest');
-    }
-    return signMessageFn({ message: { raw: hexToBytes(digest) } });
-  }
-}

package/src/signing.ts

@@ -1,112 +0,0 @@
-import {
-  CancelTaskPayload,
-  CreateTaskPayload,
-  DecisionPayload,
-  FundTaskPayload,
-  SettleTaskPayload,
-  SubmitResponsePayload,
-  TaskResponsesQueryPayload,
-  WorkerResponsesQueryPayload
-} from './types.js';
-
-type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
-
-type CanonicalInput = JsonValue | Record<string, unknown> | undefined;
-
-const canonicalize = (value: CanonicalInput): JsonValue => {
-  if (value === null || value === undefined) {
-    return null;
-  }
-
-  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-    return value;
-  }
-
-  if (Array.isArray(value)) {
-    return value.map((item) => canonicalize(item)) as JsonValue;
-  }
-
-  const entries = Object.entries(value as Record<string, CanonicalInput>)
-    .filter(([, v]) => v !== undefined)
-    .sort(([a], [b]) => a.localeCompare(b));
-  const normalized: Record<string, JsonValue> = {};
-  for (const [key, val] of entries) {
-    normalized[key] = canonicalize(val);
-  }
-  return normalized;
-};
-
-export const canonicalStringify = (payload: CanonicalInput): string =>
-  JSON.stringify(canonicalize(payload));
-
-export const taskSignaturePayload = (input: CreateTaskPayload): string =>
-  canonicalStringify({
-    kind: 'task:create',
-    title: input.title,
-    content: input.content,
-    id: input.id
-  });
-
-export const taskFundSignaturePayload = (input: FundTaskPayload): string =>
-  canonicalStringify({
-    kind: 'task:fund',
-    taskId: input.taskId,
-    token: input.token
-  });
-
-export const responseSignaturePayload = (input: SubmitResponsePayload): string =>
-  canonicalStringify({
-    kind: 'task:response',
-    taskId: input.taskId,
-    payload: input.payload,
-    id: input.id ?? null
-  });
-
-export const decisionSignaturePayload = (input: DecisionPayload): string =>
-  canonicalStringify({
-    kind: 'task:decision',
-    responseId: input.responseId,
-    workerAddress: input.workerAddress,
-    price: input.price,
-    status: input.status,
-    settlementSignature: input.settlementSignature ?? null
-  });
-
-export const cancelTaskSignaturePayload = (input: CancelTaskPayload): string =>
-  canonicalStringify({
-    kind: 'task:cancel',
-    taskId: input.taskId
-  });
-
-export const taskSettleSignaturePayload = (
-  input: SettleTaskPayload & { workerAddress: string }
-): string =>
-  canonicalStringify({
-    kind: 'task:settle',
-    taskId: input.taskId,
-    responseId: input.responseId,
-    workerAddress: input.workerAddress
-  });
-
-export const taskResponsesQuerySignaturePayload = (
-  input: TaskResponsesQueryPayload & { ownerAddress: string }
-): string =>
-  canonicalStringify({
-    kind: 'task:response:query',
-    taskId: input.taskId,
-    ownerAddress: input.ownerAddress,
-    workerAddress: input.workerAddress ?? null,
-    pageSize: input.pageSize ?? 50,
-    pageNum: input.pageNum ?? 0
-  });
-
-export const workerResponsesQuerySignaturePayload = (
-  input: WorkerResponsesQueryPayload & { workerAddress: string }
-): string =>
-  canonicalStringify({
-    kind: 'worker:response:query',
-    workerAddress: input.workerAddress,
-    taskId: input.taskId ?? null,
-    pageSize: input.pageSize ?? 50,
-    pageNum: input.pageNum ?? 0
-  });

package/src/task-db-types.ts

@@ -1,70 +0,0 @@
-import { z } from 'zod';
-
-export const taskStatusSchema = z.enum(["finished", "draft", "active", "closed", "pending_review"]);
-export type TaskStatus = z.infer<typeof taskStatusSchema>;
-
-export const responseStatusSchema = z.enum(["pending", "approved", "rejected"]);
-export type ResponseStatus = z.infer<typeof responseStatusSchema>;
-
-export const taskRecordSchema = z.object({
-  id: z.string().uuid(),
-  title: z.string(),
-  content: z.string(),
-  owner: z.string(),
-  created_at: z.number(),
-  status: taskStatusSchema,
-  price: z.string(),
-  token: z.string().nullable(),
-  withdraw_signature: z.string().nullable()
-});
-export type TaskRecord = z.infer<typeof taskRecordSchema>;
-
-export const responseRecordSchema = z.object({
-  id: z.string().uuid(),
-  task_id: z.string().uuid(),
-  payload: z.string(),
-  worker: z.string(),
-  status: responseStatusSchema,
-  created_at: z.number(),
-  settlement: z.string().nullable(),
-  settlement_signature: z.string().nullable()
-});
-export type ResponseRecord = z.infer<typeof responseRecordSchema>;
-
-export type NewTaskInput = Omit<TaskRecord, 'created_at' | 'status'> & {
-  status?: TaskStatus;
-  created_at?: number;
-};
-
-export type NewResponseInput = Omit<ResponseRecord, 'created_at' | 'status' | 'settlement'> & {
-  status?: ResponseStatus;
-  created_at?: number;
-  settlement?: string | null;
-  settlement_signature?: string | null;
-};
-
-export type TaskSortKey = 'price' | 'created_at';
-
-export interface TaskQueryFilters {
-  publisher?: string | null;
-  createdAfter?: number | null;
-  createdBefore?: number | null;
-  status?: TaskStatus | null;
-  keyword?: string | null;
-  minPrice?: number;
-  sortBy?: TaskSortKey;
-  pageSize?: number;
-  pageNum?: number;
-}
-
-export interface TaskResponsesPageOptions {
-  worker?: string;
-  pageSize?: number;
-  pageNum?: number;
-}
-
-export interface WorkerResponsesPageOptions {
-  taskId?: string;
-  pageSize?: number;
-  pageNum?: number;
-}

package/src/token.ts

@@ -1,17 +0,0 @@
-import { getAddress } from 'viem';
-
-export interface ParsedTokenIdentifier {
-  network: string;
-  address: `0x${string}`;
-}
-
-export const parseTokenIdentifier = (token: string): ParsedTokenIdentifier => {
-  const [networkRaw, address] = token.split(':');
-  if (!networkRaw || !address) {
-    throw new Error('Invalid token identifier');
-  }
-  return {
-    network: networkRaw.toLowerCase(),
-    address: getAddress(address as `0x${string}`)
-  };
-};

package/src/types.ts

@@ -1,97 +0,0 @@
-import { z } from 'zod';
-import { responseStatusSchema, taskStatusSchema } from './task-db-types.js';
-import { getAddress, isAddress } from 'viem';
-
-const addressSchema = z
-  .string()
-  .refine((value) => isAddress(value as `0x${string}`), {
-    message: 'Invalid address'
-  })
-  .transform((value) => getAddress(value as `0x${string}`));
-
-const tokenSchema = z.string().regex(/^[a-z0-9-]+:0x[a-fA-F0-9]{40}$/);
-
-const priceStringSchema = z.string().regex(/^[0-9]+$/).refine((val) => BigInt(val) > 0n, {
-  message: 'price must be greater than zero'
-});
-
-const signatureSchema = z.string().regex(/^0x[a-fA-F0-9]{130}$/, { message: 'Invalid signature' });
-
-export const createTaskPayloadSchema = z.object({
-  id: z.string().uuid(),
-  title: z.string().min(4),
-  content: z.string().min(1)
-});
-
-export const fundTaskPayloadSchema = z.object({
-  taskId: z.string().uuid(),
-  token: tokenSchema
-});
-
-export const submitResponsePayloadSchema = z.object({
-  id: z.string().uuid().optional(),
-  taskId: z.string().uuid(),
-  payload: z.string().min(1)
-});
-
-export const decisionPayloadSchema = z
-  .object({
-    responseId: z.string().uuid(),
-    workerAddress: addressSchema,
-    price: z.string(),
-    status: responseStatusSchema,
-    settlementSignature: signatureSchema.optional()
-  })
-  .refine((value) => value.status !== 'pending', {
-    message: 'Status must be approved or rejected'
-  });
-
-export const cancelTaskPayloadSchema = z.object({
-  taskId: z.string().uuid()
-});
-
-export const settleTaskPayloadSchema = z.object({
-  taskId: z.string().uuid(),
-  responseId: z.string().uuid()
-});
-
-const createdRangeSchema = z.tuple([z.number().nonnegative(), z.number().nonnegative()]).optional();
-
-export const taskQueryPayloadSchema = z.object({
-  filter: z
-    .object({
-      publisher: addressSchema.optional(),
-      created_at: createdRangeSchema,
-      status: taskStatusSchema.optional(),
-      minPrice: z.number().int().nonnegative().optional(),
-      keyword: z.string().min(2).max(256).optional()
-    })
-    .default({}),
-  sortBy: z.enum(['price', 'created_at']).optional().default('created_at'),
-  pageSize: z.number().int().min(1).max(200).optional().default(50),
-  pageNum: z.number().int().min(0).optional().default(0)
-});
-
-export const taskResponsesQueryPayloadSchema = z.object({
-  taskId: z.string().uuid(),
-  workerAddress: addressSchema.optional(),
-  pageSize: z.number().int().min(1).max(200).optional().default(50),
-  pageNum: z.number().int().min(0).optional().default(0)
-});
-
-export const workerResponsesQueryPayloadSchema = z.object({
-  taskId: z.string().uuid().optional(),
-  pageSize: z.number().int().min(1).max(200).optional().default(50),
-  pageNum: z.number().int().min(0).optional().default(0)
-});
-
-export type AddressString = z.infer<typeof addressSchema>;
-export type CreateTaskPayload = z.infer<typeof createTaskPayloadSchema>;
-export type FundTaskPayload = z.infer<typeof fundTaskPayloadSchema>;
-export type SubmitResponsePayload = z.infer<typeof submitResponsePayloadSchema>;
-export type DecisionPayload = z.infer<typeof decisionPayloadSchema>;
-export type CancelTaskPayload = z.infer<typeof cancelTaskPayloadSchema>;
-export type SettleTaskPayload = z.infer<typeof settleTaskPayloadSchema>;
-export type TaskQueryPayload = z.infer<typeof taskQueryPayloadSchema>;
-export type TaskResponsesQueryPayload = z.infer<typeof taskResponsesQueryPayloadSchema>;
-export type WorkerResponsesQueryPayload = z.infer<typeof workerResponsesQueryPayloadSchema>;