arc402-cli 0.2.0

package/src/daemon/job-lifecycle.ts

@@ -0,0 +1,215 @@
+/**
+ * ARC-402 Job Lifecycle — Post-delivery processing.
+ *
+ * Handles everything that happens after a worker completes a job:
+ *   1. Execution receipt generation
+ *   2. Learning extraction from completed work
+ *   3. Worker memory update
+ *   4. Per-agreement job directory management
+ *
+ * These functions are called by the daemon after a successful delivery.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as crypto from "crypto";
+import { readUsageReport, type AggregatedTokenUsage } from "./token-metering";
+
+const ARC402_DIR = path.join(os.homedir(), ".arc402");
+const RECEIPTS_DIR = path.join(ARC402_DIR, "receipts");
+const WORKER_DIR = path.join(ARC402_DIR, "worker");
+const WORKER_MEMORY_DIR = path.join(WORKER_DIR, "memory");
+const WORKER_CONFIG = path.join(WORKER_DIR, "config.json");
+const JOBS_DIR = path.join(ARC402_DIR, "jobs");
+
+// ─── Execution Receipt ────────────────────────────────────────────────────────
+
+export interface ExecutionReceipt {
+  schema: "arc402.execution-receipt.v1";
+  agreement_id: string;
+  workroom_policy_hash: string;
+  started_at: string;
+  completed_at: string;
+  deliverable_hash: string;
+  worker_address: string;
+  metrics: {
+    wall_clock_seconds: number;
+    network_hosts_contacted: string[];
+    policy_violations_attempted: number;
+  };
+  token_usage: AggregatedTokenUsage | null;
+  receipt_hash: string;
+}
+
+/**
+ * Generate and persist an execution receipt after job delivery.
+ */
+export function generateReceipt(params: {
+  agreementId: string;
+  deliverableHash: string;
+  walletAddress: string;
+  startedAt: string;
+  completedAt: string;
+  policyFilePath?: string;
+  networkHosts?: string[];
+}): ExecutionReceipt {
+  fs.mkdirSync(RECEIPTS_DIR, { recursive: true });
+
+  // Compute policy hash
+  let policyHash = "0x0";
+  const policyPath = params.policyFilePath ?? path.join(ARC402_DIR, "openshell-policy.yaml");
+  if (fs.existsSync(policyPath)) {
+    const content = fs.readFileSync(policyPath, "utf-8");
+    policyHash = "0x" + crypto.createHash("sha256").update(content).digest("hex");
+  }
+
+  // Calculate wall clock time
+  const started = new Date(params.startedAt).getTime();
+  const completed = new Date(params.completedAt).getTime();
+  const wallClockSeconds = Math.max(0, Math.floor((completed - started) / 1000));
+
+  // Read token usage report (if the worker wrote one)
+  const tokenUsage = readUsageReport(params.agreementId);
+
+  const receipt: ExecutionReceipt = {
+    schema: "arc402.execution-receipt.v1",
+    agreement_id: params.agreementId,
+    workroom_policy_hash: policyHash,
+    started_at: params.startedAt,
+    completed_at: params.completedAt,
+    deliverable_hash: params.deliverableHash,
+    worker_address: params.walletAddress,
+    metrics: {
+      wall_clock_seconds: wallClockSeconds,
+      network_hosts_contacted: params.networkHosts ?? [],
+      policy_violations_attempted: 0,
+    },
+    token_usage: tokenUsage,
+    receipt_hash: "", // filled below
+  };
+
+  // Receipt hash = SHA-256 of the receipt content (without the hash field)
+  const hashInput = JSON.stringify({ ...receipt, receipt_hash: undefined });
+  receipt.receipt_hash = "0x" + crypto.createHash("sha256").update(hashInput).digest("hex");
+
+  // Persist
+  const receiptPath = path.join(RECEIPTS_DIR, `${params.agreementId}.json`);
+  fs.writeFileSync(receiptPath, JSON.stringify(receipt, null, 2));
+
+  return receipt;
+}
+
+// ─── Learning Extraction ──────────────────────────────────────────────────────
+
+/**
+ * Extract learnings from a completed job and update worker memory.
+ *
+ * This creates:
+ *   1. A per-job memory file: memory/job-<id>.md
+ *   2. Updates the cumulative learnings.md
+ *   3. Updates the worker config (job count, earnings)
+ */
+export function extractLearnings(params: {
+  agreementId: string;
+  taskDescription: string;
+  deliverableHash: string;
+  priceEth: string;
+  capability: string;
+  wallClockSeconds: number;
+  success: boolean;
+}): void {
+  fs.mkdirSync(WORKER_MEMORY_DIR, { recursive: true });
+
+  const now = new Date().toISOString();
+  const dateStr = now.split("T")[0];
+
+  // 1. Per-job memory file
+  const jobMemory = `# Job: ${params.agreementId}
+*Completed: ${now}*
+*Capability: ${params.capability}*
+*Price: ${params.priceEth} ETH*
+*Duration: ${params.wallClockSeconds}s*
+*Outcome: ${params.success ? "delivered" : "failed"}*
+
+## Task
+${params.taskDescription}
+
+## Deliverable
+Hash: ${params.deliverableHash}
+
+## Learnings
+- Completed ${params.capability} task in ${params.wallClockSeconds}s
+- ${params.success ? "Delivered successfully" : "Delivery failed — review required"}
+`;
+
+  const jobFile = path.join(WORKER_MEMORY_DIR, `job-${params.agreementId}.md`);
+  fs.writeFileSync(jobFile, jobMemory);
+
+  // 2. Update cumulative learnings.md
+  const learningsPath = path.join(WORKER_MEMORY_DIR, "learnings.md");
+  let learnings = "";
+  if (fs.existsSync(learningsPath)) {
+    learnings = fs.readFileSync(learningsPath, "utf-8");
+  }
+
+  const newEntry = `\n### ${dateStr} — ${params.capability} (${params.agreementId.slice(0, 8)}...)
+- Duration: ${params.wallClockSeconds}s | Price: ${params.priceEth} ETH | Outcome: ${params.success ? "✓" : "✗"}
+`;
+
+  // Append to learnings
+  if (learnings.includes("No learnings yet")) {
+    learnings = `# Accumulated Learnings\n\n*Auto-updated after each completed job.*\n${newEntry}`;
+  } else {
+    learnings += newEntry;
+  }
+  fs.writeFileSync(learningsPath, learnings);
+
+  // 3. Update worker config
+  if (fs.existsSync(WORKER_CONFIG)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(WORKER_CONFIG, "utf-8"));
+      config.job_count = (config.job_count || 0) + 1;
+      const currentEarnings = parseFloat(config.total_earned_eth || "0");
+      const jobEarnings = parseFloat(params.priceEth || "0");
+      config.total_earned_eth = (currentEarnings + jobEarnings).toFixed(6);
+      config.last_job_at = now;
+      fs.writeFileSync(WORKER_CONFIG, JSON.stringify(config, null, 2));
+    } catch { /* non-fatal — config may be malformed */ }
+  }
+}
+
+// ─── Per-Agreement Job Directory ──────────────────────────────────────────────
+
+/**
+ * Create an isolated job directory for a specific agreement.
+ * Returns the path to the job workspace.
+ */
+export function createJobDirectory(agreementId: string): string {
+  const jobDir = path.join(JOBS_DIR, `agreement-${agreementId}`);
+  fs.mkdirSync(jobDir, { recursive: true });
+  return jobDir;
+}
+
+/**
+ * Clean up a job directory after settlement.
+ * Preserves the receipt and job memory — only removes working files.
+ */
+export function cleanJobDirectory(agreementId: string): void {
+  const jobDir = path.join(JOBS_DIR, `agreement-${agreementId}`);
+  if (fs.existsSync(jobDir)) {
+    fs.rmSync(jobDir, { recursive: true, force: true });
+  }
+}
+
+// ─── Policy Hash ──────────────────────────────────────────────────────────────
+
+/**
+ * Compute the SHA-256 hash of the current workroom policy.
+ * This hash can be registered in AgentRegistry for verifiability.
+ */
+export function computePolicyHash(policyFilePath?: string): string {
+  const policyPath = policyFilePath ?? path.join(ARC402_DIR, "openshell-policy.yaml");
+  if (!fs.existsSync(policyPath)) return "0x0";
+  const content = fs.readFileSync(policyPath, "utf-8");
+  return "0x" + crypto.createHash("sha256").update(content).digest("hex");
+}

package/src/daemon/notify.ts

@@ -0,0 +1,157 @@
+/**
+ * Telegram notification module for daemon events.
+ * Uses Telegram Bot API — no external dependencies.
+ */
+import * as https from "https";
+import * as http from "http";
+
+export type NotifyEvent =
+  | "hire_request"
+  | "hire_accepted"
+  | "hire_rejected"
+  | "delivery"
+  | "dispute"
+  | "channel_challenge"
+  | "low_balance"
+  | "daemon_started"
+  | "daemon_stopped";
+
+export interface TelegramConfig {
+  botToken: string;
+  chatId: string;
+}
+
+function telegramPost(botToken: string, method: string, body: object): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const payload = JSON.stringify(body);
+    const options: https.RequestOptions = {
+      hostname: "api.telegram.org",
+      port: 443,
+      path: `/bot${botToken}/${method}`,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(payload),
+      },
+    };
+    const req = https.request(options, (res) => {
+      let data = "";
+      res.on("data", (c: Buffer) => { data += c.toString(); });
+      res.on("end", () => {
+        const parsed = JSON.parse(data) as { ok: boolean; description?: string };
+        if (!parsed.ok) {
+          reject(new Error(`Telegram API error: ${parsed.description}`));
+        } else {
+          resolve();
+        }
+      });
+    });
+    req.on("error", reject);
+    req.write(payload);
+    req.end();
+  });
+}
+
+export class Notifier {
+  private config: TelegramConfig | null;
+  private notifyFlags: Record<NotifyEvent, boolean>;
+
+  constructor(
+    botToken: string,
+    chatId: string,
+    flags: Partial<Record<NotifyEvent, boolean>> = {}
+  ) {
+    this.config = botToken && chatId ? { botToken, chatId } : null;
+    this.notifyFlags = {
+      hire_request: flags.hire_request ?? true,
+      hire_accepted: flags.hire_accepted ?? true,
+      hire_rejected: flags.hire_rejected ?? true,
+      delivery: flags.delivery ?? true,
+      dispute: flags.dispute ?? true,
+      channel_challenge: flags.channel_challenge ?? true,
+      low_balance: flags.low_balance ?? true,
+      daemon_started: true,
+      daemon_stopped: true,
+    };
+  }
+
+  isEnabled(): boolean {
+    return this.config !== null;
+  }
+
+  async send(event: NotifyEvent, message: string): Promise<void> {
+    if (!this.config) return;
+    if (!this.notifyFlags[event]) return;
+    try {
+      await telegramPost(this.config.botToken, "sendMessage", {
+        chat_id: this.config.chatId,
+        text: message,
+        parse_mode: "HTML",
+      });
+    } catch (err) {
+      // Non-fatal — log and continue
+      process.stderr.write(`[notify] Telegram send failed: ${err}\n`);
+    }
+  }
+
+  async notifyHireRequest(hireId: string, hirerAddress: string, priceEth: string, capability: string): Promise<void> {
+    const short = hirerAddress.slice(0, 10);
+    const msg = [
+      `⚡ <b>Hire Request</b>`,
+      `ID: <code>${hireId}</code>`,
+      `From: <code>${short}...</code>`,
+      `Capability: ${capability || "unspecified"}`,
+      `Price: ${priceEth} ETH`,
+      ``,
+      `Approve: <code>arc402 daemon approve ${hireId}</code>`,
+      `Reject:  <code>arc402 daemon reject ${hireId}</code>`,
+    ].join("\n");
+    await this.send("hire_request", msg);
+  }
+
+  async notifyHireAccepted(hireId: string, agreementId: string): Promise<void> {
+    await this.send("hire_accepted",
+      `✅ <b>Hire Accepted</b>\nID: <code>${hireId}</code>\nAgreement: <code>${agreementId}</code>`
+    );
+  }
+
+  async notifyHireRejected(hireId: string, reason: string): Promise<void> {
+    await this.send("hire_rejected",
+      `❌ <b>Hire Rejected</b>\nID: <code>${hireId}</code>\nReason: ${reason}`
+    );
+  }
+
+  async notifyDelivery(agreementId: string, deliveryHash: string, userOpHash: string): Promise<void> {
+    await this.send("delivery",
+      `📦 <b>Delivery Submitted</b>\nAgreement: <code>${agreementId}</code>\nDelivery hash: <code>${deliveryHash.slice(0, 16)}...</code>\nUserOp: <code>${userOpHash.slice(0, 16)}...</code>`
+    );
+  }
+
+  async notifyDispute(agreementId: string, raisedBy: string): Promise<void> {
+    await this.send("dispute",
+      `⚠️ <b>Dispute Raised</b>\nAgreement: <code>${agreementId}</code>\nBy: <code>${raisedBy}</code>`
+    );
+  }
+
+  async notifyChannelChallenge(channelId: string, txHash: string): Promise<void> {
+    await this.send("channel_challenge",
+      `🔔 <b>Channel Challenged</b>\nChannel: <code>${channelId.slice(0, 16)}...</code>\nTx: <code>${txHash.slice(0, 16)}...</code>`
+    );
+  }
+
+  async notifyLowBalance(balanceEth: string, thresholdEth: string): Promise<void> {
+    await this.send("low_balance",
+      `💸 <b>Low Balance Alert</b>\nCurrent: ${balanceEth} ETH\nThreshold: ${thresholdEth} ETH`
+    );
+  }
+
+  async notifyStarted(walletAddress: string, subsystems: string[]): Promise<void> {
+    await this.send("daemon_started",
+      `🟢 <b>ARC-402 Daemon Started</b>\nWallet: <code>${walletAddress}</code>\nSubsystems: ${subsystems.join(", ")}`
+    );
+  }
+
+  async notifyStopped(): Promise<void> {
+    await this.send("daemon_stopped", `🔴 <b>ARC-402 Daemon Stopped</b>`);
+  }
+}

package/src/daemon/token-metering.ts

@@ -0,0 +1,183 @@
+/**
+ * ARC-402 Token Usage Metering
+ *
+ * Tracks LLM token consumption per agreement. The worker writes a usage report
+ * file during execution; the daemon reads it after delivery and includes the
+ * data in the execution receipt.
+ *
+ * Architecture:
+ *   - Before execution: daemon creates a usage report path for the agreement
+ *   - During execution: worker appends usage entries as it calls LLM APIs
+ *   - After execution: daemon reads the report, aggregates totals, includes in receipt
+ *
+ * The worker writes entries in JSON Lines format to:
+ *   /workroom/jobs/agreement-<id>/token-usage.jsonl
+ *
+ * Each line:
+ *   {"model":"claude-sonnet-4-6","provider":"anthropic","input":1200,"output":450,"ts":"..."}
+ *
+ * This is non-invasive — no proxy, no network interception. The worker
+ * is responsible for reporting its own usage. OpenClaw agents can do this
+ * natively via session metadata.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+const ARC402_DIR = path.join(os.homedir(), ".arc402");
+const JOBS_DIR = path.join(ARC402_DIR, "jobs");
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export interface TokenUsageEntry {
+  model: string;
+  provider: string;
+  input: number;
+  output: number;
+  ts: string;
+  cost_usd?: number;
+}
+
+export interface AggregatedTokenUsage {
+  total_input: number;
+  total_output: number;
+  total_tokens: number;
+  estimated_cost_usd: number;
+  models_used: string[];
+  entries: number;
+  by_model: Record<string, {
+    input: number;
+    output: number;
+    calls: number;
+    cost_usd: number;
+  }>;
+}
+
+// ─── Known model pricing (USD per 1M tokens, as of 2026-03) ──────────────────
+
+const MODEL_PRICING: Record<string, { input: number; output: number }> = {
+  // Anthropic
+  "claude-opus-4-6":     { input: 15.0,  output: 75.0  },
+  "claude-sonnet-4-6":   { input: 3.0,   output: 15.0  },
+  "claude-haiku-4-5":    { input: 0.8,   output: 4.0   },
+  // OpenAI
+  "gpt-5.4":             { input: 2.5,   output: 10.0  },
+  "gpt-5.3-codex":       { input: 2.5,   output: 10.0  },
+  "gpt-4o":              { input: 2.5,   output: 10.0  },
+  "gpt-4o-mini":         { input: 0.15,  output: 0.6   },
+  // Google
+  "gemini-2.5-pro":      { input: 1.25,  output: 10.0  },
+  "gemini-2.5-flash":    { input: 0.15,  output: 0.6   },
+  // Defaults
+  "default":             { input: 2.0,   output: 8.0   },
+};
+
+function estimateCost(model: string, inputTokens: number, outputTokens: number): number {
+  const pricing = MODEL_PRICING[model] ?? MODEL_PRICING["default"];
+  return (inputTokens * pricing.input + outputTokens * pricing.output) / 1_000_000;
+}
+
+// ─── Usage report path ────────────────────────────────────────────────────────
+
+/**
+ * Get the path where the worker should write token usage for an agreement.
+ * The daemon sets this as an env var before calling exec_command.
+ */
+export function getUsageReportPath(agreementId: string): string {
+  return path.join(JOBS_DIR, `agreement-${agreementId}`, "token-usage.jsonl");
+}
+
+/**
+ * Create the parent directory and return the path.
+ * Called by the daemon before spawning the worker.
+ */
+export function prepareUsageReport(agreementId: string): string {
+  const reportPath = getUsageReportPath(agreementId);
+  fs.mkdirSync(path.dirname(reportPath), { recursive: true });
+  return reportPath;
+}
+
+// ─── Read and aggregate ───────────────────────────────────────────────────────
+
+/**
+ * Read the token usage report for an agreement and aggregate totals.
+ * Returns null if no report exists.
+ */
+export function readUsageReport(agreementId: string): AggregatedTokenUsage | null {
+  const reportPath = getUsageReportPath(agreementId);
+
+  if (!fs.existsSync(reportPath)) return null;
+
+  const content = fs.readFileSync(reportPath, "utf-8").trim();
+  if (!content) return null;
+
+  const lines = content.split("\n").filter(Boolean);
+  const entries: TokenUsageEntry[] = [];
+
+  for (const line of lines) {
+    try {
+      entries.push(JSON.parse(line) as TokenUsageEntry);
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  if (entries.length === 0) return null;
+
+  // Aggregate
+  const byModel: Record<string, { input: number; output: number; calls: number; cost_usd: number }> = {};
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalCost = 0;
+
+  for (const entry of entries) {
+    totalInput += entry.input;
+    totalOutput += entry.output;
+
+    const model = entry.model || "unknown";
+    if (!byModel[model]) {
+      byModel[model] = { input: 0, output: 0, calls: 0, cost_usd: 0 };
+    }
+    byModel[model].input += entry.input;
+    byModel[model].output += entry.output;
+    byModel[model].calls += 1;
+
+    const cost = entry.cost_usd ?? estimateCost(model, entry.input, entry.output);
+    byModel[model].cost_usd += cost;
+    totalCost += cost;
+  }
+
+  return {
+    total_input: totalInput,
+    total_output: totalOutput,
+    total_tokens: totalInput + totalOutput,
+    estimated_cost_usd: Math.round(totalCost * 10000) / 10000, // 4 decimal places
+    models_used: Object.keys(byModel),
+    entries: entries.length,
+    by_model: byModel,
+  };
+}
+
+// ─── CLI display helper ───────────────────────────────────────────────────────
+
+/**
+ * Format token usage for CLI display.
+ */
+export function formatUsageReport(usage: AggregatedTokenUsage): string {
+  const lines: string[] = [];
+  lines.push(`Token Usage`);
+  lines.push(`───────────`);
+  lines.push(`Total tokens:  ${usage.total_tokens.toLocaleString()} (${usage.total_input.toLocaleString()} in / ${usage.total_output.toLocaleString()} out)`);
+  lines.push(`Est. cost:     $${usage.estimated_cost_usd.toFixed(4)}`);
+  lines.push(`LLM calls:     ${usage.entries}`);
+  lines.push(``);
+
+  if (Object.keys(usage.by_model).length > 1) {
+    lines.push(`By model:`);
+    for (const [model, data] of Object.entries(usage.by_model)) {
+      lines.push(`  ${model.padEnd(24)} ${data.calls} calls  ${(data.input + data.output).toLocaleString()} tokens  $${data.cost_usd.toFixed(4)}`);
+    }
+  }
+
+  return lines.join("\n");
+}

package/src/daemon/userops.ts

@@ -0,0 +1,119 @@
+/**
+ * UserOperation builder and submitter for the ARC-402 daemon.
+ * Wraps protocol calls (accept, fulfill) into ERC-4337 UserOperations.
+ */
+import { ethers } from "ethers";
+import { BundlerClient } from "../bundler";
+import type { UserOperation } from "../bundler";
+import type { DaemonConfig } from "./config";
+import { ARC402_WALLET_EXECUTE_ABI } from "../abis";
+
+// ServiceAgreement calldata encoders
+const SA_IFACE = new ethers.Interface([
+  "function accept(uint256 agreementId) external",
+  "function fulfill(uint256 agreementId, bytes32 actualDeliverablesHash) external",
+]);
+
+// ARC402Wallet.executeContractCall param type
+const WALLET_EXEC_IFACE = new ethers.Interface(ARC402_WALLET_EXECUTE_ABI as unknown as string[]);
+
+export function encodeWalletCall(
+  target: string,
+  innerCalldata: string,
+  value = BigInt(0)
+): string {
+  return WALLET_EXEC_IFACE.encodeFunctionData("executeContractCall", [{
+    target,
+    data: innerCalldata,
+    value,
+    minReturnValue: BigInt(0),
+    maxApprovalAmount: BigInt(0),
+    approvalToken: ethers.ZeroAddress,
+  }]);
+}
+
+export function buildAcceptCalldata(
+  serviceAgreementAddress: string,
+  agreementId: string,
+  walletAddress: string
+): string {
+  const inner = SA_IFACE.encodeFunctionData("accept", [BigInt(agreementId)]);
+  return encodeWalletCall(serviceAgreementAddress, inner);
+}
+
+export function buildFulfillCalldata(
+  serviceAgreementAddress: string,
+  agreementId: string,
+  deliveryHash: string,
+  walletAddress: string
+): string {
+  const inner = SA_IFACE.encodeFunctionData("fulfill", [BigInt(agreementId), deliveryHash]);
+  return encodeWalletCall(serviceAgreementAddress, inner);
+}
+
+export class UserOpsManager {
+  private bundlerClient: BundlerClient;
+  private provider: ethers.Provider;
+  private config: DaemonConfig;
+
+  constructor(config: DaemonConfig, provider: ethers.Provider) {
+    this.config = config;
+    this.provider = provider;
+
+    const bundlerUrl =
+      config.bundler.endpoint || "https://api.pimlico.io/v2/base/rpc";
+    this.bundlerClient = new BundlerClient(
+      bundlerUrl,
+      config.network.entry_point,
+      config.network.chain_id
+    );
+  }
+
+  async buildUserOp(callData: string, senderWallet: string): Promise<UserOperation> {
+    const entryPointContract = new ethers.Contract(
+      this.config.network.entry_point,
+      ["function getNonce(address sender, uint192 key) external view returns (uint256)"],
+      this.provider
+    );
+    const nonce: bigint = await entryPointContract.getNonce(senderWallet, 0);
+    const feeData = await this.provider.getFeeData();
+    const maxFeePerGas = feeData.maxFeePerGas ?? BigInt(1_000_000_000);
+    const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas ?? BigInt(100_000_000);
+
+    return {
+      sender: senderWallet,
+      nonce: ethers.toBeHex(nonce),
+      callData,
+      callGasLimit: ethers.toBeHex(300_000),
+      verificationGasLimit: ethers.toBeHex(150_000),
+      preVerificationGas: ethers.toBeHex(50_000),
+      maxFeePerGas: ethers.toBeHex(maxFeePerGas),
+      maxPriorityFeePerGas: ethers.toBeHex(maxPriorityFeePerGas),
+      signature: "0x",
+    };
+  }
+
+  async submit(callData: string, senderWallet: string): Promise<string> {
+    const userOp = await this.buildUserOp(callData, senderWallet);
+    return this.bundlerClient.sendUserOperation(userOp);
+  }
+
+  async waitForInclusion(userOpHash: string): Promise<void> {
+    await this.bundlerClient.getUserOperationReceipt(userOpHash);
+  }
+
+  async pingBundler(): Promise<boolean> {
+    try {
+      const bundlerUrl = this.config.bundler.endpoint || "https://api.pimlico.io/v2/base/rpc";
+      const response = await fetch(bundlerUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_chainId", params: [] }),
+        signal: AbortSignal.timeout(5000),
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+}