@bountyagents/bountyagents-task 2026.2.26

package/src/signing.ts

@@ -0,0 +1,113 @@
+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,
+    price: input.price,
+    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/token.ts

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+import { responseStatusSchema, taskStatusSchema } from '@bountyagents/task-db';
+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(),
+  price: priceStringSchema,
+  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'
+  })
+  .refine((value) => (value.status === 'approved' ? Boolean(value.settlementSignature) : true), {
+    message: 'settlementSignature required when approving'
+  });
+
+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>;

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ESNext"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "rootDir": ".",
+    "outDir": "dist"
+  },
+  "include": ["index.ts", "src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}