// to: BLOCKRUN_LOG_ADDRESS (BlockRun's own address)
// value: 0 ETH
// calldata: encoded payout receipt
{
  v: 1,
  type: "worker_payout",
  worker: "0x...",
  amountMicros: 10000,
  resultCount: 100,
  resultsHash: "0xabc...",   // SHA256 of result IDs
  payoutId: "uuid",
  payoutTxHash: "0x...",
  ts: 1234567890
}

export interface WorkerTask {
  id: string;
  type: "http_check";
  url: string;
  expectedStatus: number;
  timeoutMs: number;
  rewardMicros: number;
  region?: string;
}

export interface WorkerResult {
  taskId: string;
  workerAddress: string;
  timestamp: number;
  success: boolean;
  responseTimeMs: number;
  statusCode?: number;
  error?: string;
  // EIP-191 signature of JSON.stringify({ taskId, workerAddress, timestamp, success })
  signature: string;
}

export interface WorkerStatus {
  address: string;
  completedTasks: number;
  totalEarnedMicros: number;
  lastPollAt?: number;
  busy: boolean;
}

import type { WorkerTask } from "./types.js";

export async function executeHttpCheck(task: WorkerTask): Promise<{
  success: boolean;
  responseTimeMs: number;
  statusCode?: number;
  error?: string;
}> {
  const start = Date.now();
  try {
    const res = await fetch(task.url, {
      method: "GET",
      signal: AbortSignal.timeout(task.timeoutMs),
      redirect: "follow",
      headers: { "User-Agent": "BlockRun-Worker/1.0" },
    });
    return {
      success: res.status === task.expectedStatus,
      responseTimeMs: Date.now() - start,
      statusCode: res.status,
    };
  } catch (err) {
    const isTimeout =
      err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError");
    return {
      success: false,
      responseTimeMs: Date.now() - start,
      error: isTimeout
        ? `Timeout after ${task.timeoutMs}ms`
        : err instanceof Error
          ? err.message
          : String(err),
    };
  }
}

// Must produce identical JSON on both sides for signature verification
export function buildSignableMessage(params: {
  taskId: string;
  workerAddress: string;
  timestamp: number;
  success: boolean;
}): string {
  return JSON.stringify({
    taskId: params.taskId,
    workerAddress: params.workerAddress,
    timestamp: params.timestamp,
    success: params.success,
  });
}

import { privateKeyToAccount } from "viem/accounts";
import type { WorkerTask, WorkerResult, WorkerStatus } from "./types.js";
import { executeHttpCheck, buildSignableMessage } from "./checks.js";

const BLOCKRUN_API = process.env.BLOCKRUN_API_BASE ?? "https://blockrun.ai/api";
const POLL_INTERVAL_MS = 30_000;
const MAX_CONCURRENT = 10;
const REGION = process.env.WORKER_REGION ?? "unknown";

export class WorkerNode {
  private privateKey: `0x${string}`;
  private address: string;
  private apiBase: string;
  private busy = false;
  private status: WorkerStatus;

  constructor(walletKey: string, walletAddress: string, apiBase = BLOCKRUN_API) {
    this.privateKey = walletKey as `0x${string}`;
    this.address = walletAddress;
    this.apiBase = apiBase;
    this.status = { address: walletAddress, completedTasks: 0, totalEarnedMicros: 0, busy: false };
  }

  startPolling(): void {
    console.log(`[Worker] Starting — ${this.address} region=${REGION}`);
    this.poll().catch(console.error);
    setInterval(() => this.poll().catch(console.error), POLL_INTERVAL_MS);
  }

  getStatus(): WorkerStatus {
    return { ...this.status, busy: this.busy };
  }

  private async poll(): Promise<void> {
    if (this.busy) return;
    let tasks: WorkerTask[] = [];
    try {
      tasks = await this.fetchTasks();
    } catch (err) {
      console.error(`[Worker] fetch tasks failed:`, err instanceof Error ? err.message : err);
      return;
    }
    if (tasks.length === 0) return;

    this.busy = true;
    this.status.lastPollAt = Date.now();
    console.log(`[Worker] Executing ${tasks.length} task(s)`);
    try {
      const results = await this.executeBatch(tasks);
      await this.submitResults(results);
    } finally {
      this.busy = false;
    }
  }

  private async fetchTasks(): Promise<WorkerTask[]> {
    const url = `${this.apiBase}/v1/worker/tasks?address=${this.address}&region=${REGION}`;
    const res = await fetch(url, {
      signal: AbortSignal.timeout(10_000),
      headers: { "User-Agent": "BlockRun-Worker/1.0" },
    });
    if (!res.ok) throw new Error(`tasks endpoint ${res.status}`);
    return res.json() as Promise<WorkerTask[]>;
  }

  private async executeBatch(tasks: WorkerTask[]): Promise<WorkerResult[]> {
    const results: WorkerResult[] = [];
    for (let i = 0; i < tasks.length; i += MAX_CONCURRENT) {
      const chunk = tasks.slice(i, i + MAX_CONCURRENT);
      const done = await Promise.all(chunk.map((t) => this.executeAndSign(t)));
      results.push(...done);
    }
    return results;
  }

  private async executeAndSign(task: WorkerTask): Promise<WorkerResult> {
    const check = await executeHttpCheck(task);
    const timestamp = Date.now();
    const message = buildSignableMessage({
      taskId: task.id,
      workerAddress: this.address,
      timestamp,
      success: check.success,
    });
    const account = privateKeyToAccount(this.privateKey);
    const signature = await account.signMessage({ message });
    return { taskId: task.id, workerAddress: this.address, timestamp, ...check, signature };
  }

  private async submitResults(results: WorkerResult[]): Promise<void> {
    try {
      const res = await fetch(`${this.apiBase}/v1/worker/results`, {
        method: "POST",
        headers: { "Content-Type": "application/json", "User-Agent": "BlockRun-Worker/1.0" },
        body: JSON.stringify(results),
        signal: AbortSignal.timeout(15_000),
      });
      if (!res.ok) {
        console.error(`[Worker] submit failed ${res.status}`);
        return;
      }
      const data = (await res.json()) as { accepted: number; earned: string };
      this.status.completedTasks += data.accepted;
      console.log(`[Worker] ✓ ${data.accepted} result(s) accepted, earned $${data.earned} USDC`);
    } catch (err) {
      console.error(`[Worker] submit error:`, err instanceof Error ? err.message : err);
    }
  }
}

setActiveProxy(proxy);
activeProxyHandle = proxy;

const workerMode = process.env.CLAWROUTER_WORKER === "1" || process.argv.includes("--worker");

if (workerMode) {
  const { WorkerNode } = await import("./worker/index.js");
  const worker = new WorkerNode(walletKey, address);
  worker.startPolling();
  api.logger.info(`[Worker] Mode active — polling every 30s, wallet: ${address}`);
}

export interface WorkerTask {
  id: string;
  type: "http_check";
  url: string;
  expectedStatus: number;
  timeoutMs: number;
  rewardMicros: number;
  region?: string;
}

export const PILOT_TASKS: WorkerTask[] = [
  {
    id: "task_br_health",
    type: "http_check",
    url: "https://blockrun.ai/api/health",
    expectedStatus: 200,
    timeoutMs: 10_000,
    rewardMicros: 100,
  },
  {
    id: "task_br_models",
    type: "http_check",
    url: "https://blockrun.ai/api/v1/models",
    expectedStatus: 200,
    timeoutMs: 10_000,
    rewardMicros: 100,
  },
  {
    id: "task_base_rpc",
    type: "http_check",
    url: "https://mainnet.base.org",
    expectedStatus: 200,
    timeoutMs: 10_000,
    rewardMicros: 150,
  },
];

// Track recent assignments: taskId → [{ workerAddress, assignedAt }]
// Each task assigned to up to 3 workers per cycle. First to submit wins.
const assignments = new Map<string, Array<{ workerAddress: string; assignedAt: number }>>();
const CYCLE_MS = 30_000;
const MAX_PER_TASK = 3;

export function getTasksForWorker(workerAddress: string, _region?: string): WorkerTask[] {
  const now = Date.now();
  const addr = workerAddress.toLowerCase();

  return PILOT_TASKS.filter((task) => {
    const list = assignments.get(task.id) ?? [];
    const fresh = list.filter((a) => now - a.assignedAt < CYCLE_MS);
    assignments.set(task.id, fresh);

    if (fresh.some((a) => a.workerAddress === addr)) return false;
    if (fresh.length >= MAX_PER_TASK) return false;
    return true;
  });
}

export function markAssigned(taskIds: string[], workerAddress: string): void {
  const addr = workerAddress.toLowerCase();
  const now = Date.now();
  for (const id of taskIds) {
    const list = assignments.get(id) ?? [];
    list.push({ workerAddress: addr, assignedAt: now });
    assignments.set(id, list);
  }
}

export function getTaskById(taskId: string): WorkerTask | undefined {
  return PILOT_TASKS.find((t) => t.id === taskId);
}

import { db } from "@/lib/db"; // your DB client — swap for actual import
import { getReputationMultiplier } from "./worker-reputation";

const PAYOUT_THRESHOLD_MICROS = 10_000; // $0.01

export async function creditWorker(
  workerAddress: string,
  baseRewardMicros: number,
): Promise<{ pendingMicros: number; thresholdReached: boolean }> {
  const multiplier = await getReputationMultiplier(workerAddress);
  const earned = Math.floor(baseRewardMicros * multiplier);

  // Atomic upsert — safe for concurrent Cloud Run instances
  const result = await db.query<{ pending_micros: number }>(
    `
    INSERT INTO worker_credits (address, pending_micros, total_earned, updated_at)
    VALUES ($1, $2, $2, NOW())
    ON CONFLICT (address) DO UPDATE SET
      pending_micros = worker_credits.pending_micros + $2,
      total_earned   = worker_credits.total_earned + $2,
      updated_at     = NOW()
    RETURNING pending_micros
  `,
    [workerAddress.toLowerCase(), earned],
  );

  const pendingMicros = result.rows[0].pending_micros;
  return {
    pendingMicros,
    thresholdReached: pendingMicros >= PAYOUT_THRESHOLD_MICROS,
  };
}

export async function resetPendingCredits(
  workerAddress: string,
  payoutId: string,
  amountMicros: number,
  txHash: string,
): Promise<void> {
  await db.query(
    `
    UPDATE worker_credits SET
      pending_micros = pending_micros - $2,
      total_paid     = total_paid + $2,
      last_payout_at = NOW(),
      last_payout_tx = $3,
      updated_at     = NOW()
    WHERE address = $1
  `,
    [workerAddress.toLowerCase(), amountMicros, txHash],
  );
}

export async function getPendingMicros(workerAddress: string): Promise<number> {
  const result = await db.query<{ pending_micros: number }>(
    `SELECT pending_micros FROM worker_credits WHERE address = $1`,
    [workerAddress.toLowerCase()],
  );
  return result.rows[0]?.pending_micros ?? 0;
}

import { db } from "@/lib/db";

const TIERS = [
  { tier: "platinum", minPaid: 200, multiplier: 2.0 },
  { tier: "gold", minPaid: 50, multiplier: 1.5 },
  { tier: "silver", minPaid: 10, multiplier: 1.2 },
  { tier: "bronze", minPaid: 0, multiplier: 1.0 },
] as const;

const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // refresh daily

export async function getReputationMultiplier(workerAddress: string): Promise<number> {
  const rep = await getReputation(workerAddress);
  return rep.multiplier;
}

export async function getReputation(workerAddress: string): Promise<{
  tier: string;
  totalPaidUsd: number;
  multiplier: number;
}> {
  const addr = workerAddress.toLowerCase();

  const cached = await db.query<{
    tier: string;
    total_paid_usd: number;
    multiplier: number;
    refreshed_at: Date;
  }>(
    `SELECT tier, total_paid_usd, multiplier, refreshed_at
     FROM wallet_reputation WHERE address = $1`,
    [addr],
  );

  if (cached.rows.length > 0) {
    const row = cached.rows[0];
    const age = Date.now() - new Date(row.refreshed_at).getTime();
    if (age < CACHE_TTL_MS) {
      return {
        tier: row.tier,
        totalPaidUsd: Number(row.total_paid_usd),
        multiplier: Number(row.multiplier),
      };
    }
  }

  // Cache miss or stale — recompute from GCS logs
  // NOTE: In production this should be a background job, not per-request
  const totalPaidUsd = await computeTotalPaidFromGCS(addr);
  const tierEntry = TIERS.find((t) => totalPaidUsd >= t.minPaid) ?? TIERS[TIERS.length - 1];

  await db.query(
    `
    INSERT INTO wallet_reputation (address, total_paid_usd, tier, multiplier, refreshed_at)
    VALUES ($1, $2, $3, $4, NOW())
    ON CONFLICT (address) DO UPDATE SET
      total_paid_usd = $2, tier = $3, multiplier = $4, refreshed_at = NOW()
  `,
    [addr, totalPaidUsd, tierEntry.tier, tierEntry.multiplier],
  );

  return { tier: tierEntry.tier, totalPaidUsd, multiplier: tierEntry.multiplier };
}

// Aggregate total USDC paid by this wallet from GCS LLM call logs
// This reads BlockRun's own data — no third-party reputation service needed
async function computeTotalPaidFromGCS(walletAddress: string): Promise<number> {
  // TODO (V2): read gs://blockrun-prod-2026-logs/llm-calls/YYYY-MM-DD.jsonl
  // Filter by wallet, sum cost field
  // Pilot: return 0 (all workers start at Bronze)
  return 0;
}

import { createHash } from "crypto";
import { createWalletClient, http } from "viem";
import { base, baseSepolia } from "viem/chains";
import { privateKeyToAccount, signTypedData } from "viem/accounts";
import { getCurrentNetworkConfig } from "./network-config";
import { settlePaymentWithRetry } from "./x402";
import { db } from "@/lib/db";
import { resetPendingCredits } from "./worker-credits";

const PAYOUT_THRESHOLD_MICROS = 10_000;

export async function tryPayout(
  workerAddress: string,
  pendingMicros: number,
  resultIds: string[],
): Promise<{ paid: boolean; txHash?: string; logTxHash?: string }> {
  if (pendingMicros < PAYOUT_THRESHOLD_MICROS) return { paid: false };

  const payoutKey = process.env.WORKER_PAYOUT_WALLET_KEY;
  if (!payoutKey?.startsWith("0x")) throw new Error("WORKER_PAYOUT_WALLET_KEY not set");

  const networkConfig = getCurrentNetworkConfig();
  const payoutAccount = privateKeyToAccount(payoutKey as `0x${string}`);

  // 1. Insert payout record (pending)
  const resultsHash = createHash("sha256").update(resultIds.sort().join(",")).digest("hex");
  const payoutResult = await db.query<{ id: string }>(
    `
    INSERT INTO worker_payouts (worker_address, amount_micros, result_count, results_hash, status)
    VALUES ($1, $2, $3, $4, 'pending')
    RETURNING id
  `,
    [workerAddress.toLowerCase(), pendingMicros, resultIds.length, resultsHash],
  );
  const payoutId = payoutResult.rows[0].id;

  // 2. Sign TransferWithAuthorization: BlockRun treasury → worker
  const validAfter = BigInt(0);
  const validBefore = BigInt(Math.floor(Date.now() / 1000) + 3600);
  const nonceBytes = crypto.getRandomValues(new Uint8Array(32));
  const nonce = `0x${Buffer.from(nonceBytes).toString("hex")}` as `0x${string}`;

  const signature = await signTypedData({
    privateKey: payoutKey as `0x${string}`,
    domain: {
      name: networkConfig.usdcDomainName,
      version: "2",
      chainId: networkConfig.chainId,
      verifyingContract: networkConfig.usdc,
    },
    types: {
      TransferWithAuthorization: [
        { name: "from", type: "address" },
        { name: "to", type: "address" },
        { name: "value", type: "uint256" },
        { name: "validAfter", type: "uint256" },
        { name: "validBefore", type: "uint256" },
        { name: "nonce", type: "bytes32" },
      ],
    },
    primaryType: "TransferWithAuthorization",
    message: {
      from: payoutAccount.address,
      to: workerAddress as `0x${string}`,
      value: BigInt(pendingMicros),
      validAfter,
      validBefore,
      nonce,
    },
  });

  // 3. Build x402 payment payload (same format as incoming payments)
  const paymentPayload = {
    x402Version: 1,
    scheme: "exact",
    network: networkConfig.network,
    payload: {
      signature,
      authorization: {
        from: payoutAccount.address,
        to: workerAddress,
        value: String(pendingMicros),
        validAfter: String(validAfter),
        validBefore: String(validBefore),
        nonce,
      },
    },
  };
  const paymentHeader = Buffer.from(JSON.stringify(paymentPayload)).toString("base64");

  const requirements = {
    scheme: "exact",
    network: networkConfig.network,
    maxAmountRequired: String(pendingMicros),
    resource: `worker-payout:${workerAddress}`,
    description: "Worker node payout",
    mimeType: "application/json",
    payTo: workerAddress,
    maxTimeoutSeconds: 3600,
    asset: networkConfig.usdc,
    outputSchema: null,
    extra: null,
  };

  // 4. Settle USDC transfer via CDP facilitator
  const settled = await settlePaymentWithRetry(paymentHeader, requirements as never);
  if (!settled.success) throw new Error(`Settlement failed: ${settled.error}`);

  const txHash = settled.txHash!;

  // 5. Write calldata log tx to Base (audit trail — failure does NOT block payout)
  const logTxHash = await writeCalldataLog({
    workerAddress,
    amountMicros: pendingMicros,
    resultCount: resultIds.length,
    resultsHash,
    payoutId,
    payoutTxHash: txHash,
    payoutKey,
    networkConfig,
  });

  // 6. Update DB: mark payout confirmed, reset credits, mark results paid
  await Promise.all([
    db.query(
      `UPDATE worker_payouts SET status='confirmed', tx_hash=$1, log_tx_hash=$2 WHERE id=$3`,
      [txHash, logTxHash, payoutId],
    ),
    resetPendingCredits(workerAddress, payoutId, pendingMicros, txHash),
    db.query(`UPDATE worker_results SET paid=TRUE, payout_id=$1 WHERE id = ANY($2::uuid[])`, [
      payoutId,
      resultIds,
    ]),
  ]);

  return { paid: true, txHash, logTxHash };
}

async function writeCalldataLog(params: {
  workerAddress: string;
  amountMicros: number;
  resultCount: number;
  resultsHash: string;
  payoutId: string;
  payoutTxHash: string;
  payoutKey: string;
  networkConfig: ReturnType<typeof getCurrentNetworkConfig>;
}): Promise<string | undefined> {
  const logAddress = process.env.BLOCKRUN_LOG_ADDRESS as `0x${string}` | undefined;
  if (!logAddress) return undefined;

  try {
    const chain = params.networkConfig.network === "eip155:8453" ? base : baseSepolia;
    const account = privateKeyToAccount(params.payoutKey as `0x${string}`);

    const walletClient = createWalletClient({ account, chain, transport: http() });

    const data = Buffer.from(
      JSON.stringify({
        v: 1,
        type: "worker_payout",
        worker: params.workerAddress,
        amountMicros: params.amountMicros,
        resultCount: params.resultCount,
        resultsHash: params.resultsHash,
        payoutId: params.payoutId,
        payoutTxHash: params.payoutTxHash,
        ts: Date.now(),
      }),
    ).toString("hex");

    return await walletClient.sendTransaction({
      to: logAddress,
      value: BigInt(0),
      data: `0x${data}` as `0x${string}`,
    });
  } catch (err) {
    console.error("[Worker Payout] calldata log tx failed:", err);
    return undefined;
  }
}

import { NextRequest, NextResponse } from "next/server";
import { getTasksForWorker, markAssigned } from "@/lib/worker-tasks";

export const runtime = "nodejs";

export async function GET(request: NextRequest) {
  const { searchParams } = new URL(request.url);
  const address = searchParams.get("address");
  const region = searchParams.get("region") ?? undefined;

  if (!address?.startsWith("0x")) {
    return NextResponse.json({ error: "address required" }, { status: 400 });
  }

  const tasks = getTasksForWorker(address, region);
  markAssigned(
    tasks.map((t) => t.id),
    address,
  );

  return NextResponse.json(tasks);
}

import { NextRequest, NextResponse } from "next/server";
import { recoverMessageAddress } from "viem";
import { getTaskById } from "@/lib/worker-tasks";
import { creditWorker } from "@/lib/worker-credits";
import { tryPayout } from "@/lib/worker-payouts";
import { db } from "@/lib/db";

export const runtime = "nodejs";

interface WorkerResult {
  taskId: string;
  workerAddress: string;
  timestamp: number;
  success: boolean;
  responseTimeMs: number;
  statusCode?: number;
  error?: string;
  signature: string;
}

export async function POST(request: NextRequest) {
  let results: WorkerResult[];
  try {
    results = await request.json();
  } catch {
    return NextResponse.json({ error: "invalid JSON" }, { status: 400 });
  }

  if (!Array.isArray(results) || results.length === 0 || results.length > 50) {
    return NextResponse.json({ error: "results must be array of 1–50" }, { status: 400 });
  }

  let accepted = 0;
  let totalEarnedMicros = 0;
  const errors: string[] = [];
  const acceptedResultIds: string[] = [];

  for (const result of results) {
    try {
      const task = getTaskById(result.taskId);
      if (!task) {
        errors.push(`${result.taskId}: unknown task`);
        continue;
      }

      // Verify EIP-191 signature
      const message = JSON.stringify({
        taskId: result.taskId,
        workerAddress: result.workerAddress,
        timestamp: result.timestamp,
        success: result.success,
      });
      const recovered = await recoverMessageAddress({
        message,
        signature: result.signature as `0x${string}`,
      });
      if (recovered.toLowerCase() !== result.workerAddress.toLowerCase()) {
        errors.push(`${result.taskId}: invalid signature`);
        continue;
      }

      // Freshness check (5 min max)
      if (Date.now() - result.timestamp > 5 * 60 * 1000) {
        errors.push(`${result.taskId}: result too old`);
        continue;
      }

      // Write result to DB
      const insertResult = await db.query<{ id: string }>(
        `
        INSERT INTO worker_results
          (task_id, worker_address, timestamp, success, response_time_ms, status_code, reward_micros)
        VALUES ($1, $2, $3, $4, $5, $6, $7)
        RETURNING id
      `,
        [
          result.taskId,
          result.workerAddress.toLowerCase(),
          result.timestamp,
          result.success,
          result.responseTimeMs,
          result.statusCode ?? null,
          task.rewardMicros,
        ],
      );
      acceptedResultIds.push(insertResult.rows[0].id);

      // Credit worker (with reputation multiplier)
      const { pendingMicros, thresholdReached } = await creditWorker(
        result.workerAddress,
        task.rewardMicros,
      );

      // Trigger payout if threshold reached (fire and forget)
      if (thresholdReached) {
        tryPayout(result.workerAddress, pendingMicros, acceptedResultIds).catch((err) =>
          console.error(`[Worker Payout] failed for ${result.workerAddress}:`, err),
        );
      }

      accepted++;
      totalEarnedMicros += task.rewardMicros;
    } catch (err) {
      errors.push(`${result.taskId}: ${err instanceof Error ? err.message : String(err)}`);
    }
  }

  return NextResponse.json({
    accepted,
    earned: (totalEarnedMicros / 1_000_000).toFixed(6),
    errors: errors.length > 0 ? errors : undefined,
  });
}