@hivemind-os/collective-indexer 0.2.0

package/dist/index.js

@@ -0,0 +1,2429 @@
+// src/index.ts
+import { mkdir } from "fs/promises";
+import { dirname } from "path";
+import { pathToFileURL } from "url";
+import pino2 from "pino";
+import { MeshSuiClient as MeshSuiClient2 } from "@hivemind-os/collective-core";
+
+// src/analytics.ts
+import { BidStatus } from "@hivemind-os/collective-types";
+var AnalyticsEngine = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  getSummary() {
+    const db = this.store.getDatabase();
+    const totals = db.prepare(
+      `SELECT
+           COUNT(*) AS total_agents,
+           SUM(CASE WHEN active = 1 THEN 1 ELSE 0 END) AS active_agents,
+           COALESCE((SELECT COUNT(*) FROM tasks), 0) AS total_tasks,
+           COALESCE((SELECT SUM(CASE WHEN completed_at IS NOT NULL THEN 1 ELSE 0 END) FROM tasks), 0) AS completed_tasks,
+           COALESCE((SELECT SUM(CASE WHEN disputed_at IS NOT NULL THEN 1 ELSE 0 END) FROM tasks), 0) AS disputed_tasks
+         FROM agents`
+    ).get();
+    return {
+      totalAgents: Number(totals.total_agents ?? 0),
+      activeAgents: Number(totals.active_agents ?? 0),
+      totalTasks: Number(totals.total_tasks ?? 0),
+      completedTasks: Number(totals.completed_tasks ?? 0),
+      disputedTasks: Number(totals.disputed_tasks ?? 0),
+      totalVolumeMist: sumBigIntRows(db.prepare("SELECT price FROM tasks").all()),
+      averageGasCosts: this.getAverageGasCostsByTaskType(),
+      marketplace: this.getMarketplaceStats()
+    };
+  }
+  getTaskVolume(period = "day", buckets = 14) {
+    const db = this.store.getDatabase();
+    const rows = db.prepare(
+      `SELECT ${bucketSql(period)} AS label, created_at, price
+         FROM tasks
+         ORDER BY created_at DESC`
+    ).all();
+    const grouped = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const current = grouped.get(row.label) ?? { count: 0, volumeMist: 0n, createdAt: Number(row.created_at) };
+      current.count += 1;
+      current.volumeMist += toBigInt(row.price);
+      current.createdAt = Math.min(current.createdAt, Number(row.created_at));
+      grouped.set(row.label, current);
+    }
+    return [...grouped.entries()].sort((left, right) => right[1].createdAt - left[1].createdAt).slice(0, normalizeBucketCount(buckets)).reverse().map(([label, row]) => ({
+      label,
+      count: row.count,
+      volumeMist: row.volumeMist
+    }));
+  }
+  getAverageGasCostsByTaskType() {
+    const db = this.store.getDatabase();
+    const rows = db.prepare(
+      `SELECT capability, gas_cost_mist_total
+         FROM tasks
+         ORDER BY capability ASC`
+    ).all();
+    const grouped = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const current = grouped.get(row.capability) ?? { total: 0n, count: 0 };
+      current.total += toBigInt(row.gas_cost_mist_total);
+      current.count += 1;
+      grouped.set(row.capability, current);
+    }
+    return [...grouped.entries()].map(([capability, stats]) => ({
+      capability,
+      averageGasMist: stats.count === 0 ? 0n : stats.total / BigInt(stats.count),
+      taskCount: stats.count
+    })).sort((left, right) => compareNumber(right.taskCount, left.taskCount) || left.capability.localeCompare(right.capability));
+  }
+  getMarketplaceStats() {
+    const db = this.store.getDatabase();
+    const aggregates = db.prepare(
+      `SELECT
+           COALESCE(AVG(bid_count), 0) AS average_bid_count,
+           COALESCE((SELECT CAST(SUM(CASE WHEN status = ? THEN 1 ELSE 0 END) AS REAL) / NULLIF(COUNT(*), 0) FROM bids), 0) AS acceptance_rate
+         FROM tasks`
+    ).get(BidStatus.ACCEPTED);
+    const categories = db.prepare("SELECT category, COUNT(*) AS task_count FROM tasks GROUP BY category ORDER BY task_count DESC, category ASC").all();
+    return {
+      averageBidCount: Number(aggregates.average_bid_count ?? 0),
+      acceptanceRate: Number(aggregates.acceptance_rate ?? 0),
+      categoryPopularity: categories.map((row) => ({ category: row.category, taskCount: Number(row.task_count) }))
+    };
+  }
+  getReputationTrends(agentDid, period = "day", buckets = 12) {
+    const agent = this.store.getAgentByDid(agentDid);
+    if (!agent) {
+      return [];
+    }
+    const db = this.store.getDatabase();
+    const rows = db.prepare(
+      `SELECT
+           ${bucketSql(period)} AS label,
+           created_at,
+           completed_at,
+           disputed_at
+         FROM tasks
+         WHERE provider = ?
+         ORDER BY created_at DESC`
+    ).all(agent.owner);
+    const grouped = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const current = grouped.get(row.label) ?? { completed: 0, failed: 0, disputed: 0, createdAt: Number(row.created_at) };
+      if (row.disputed_at != null) {
+        current.failed += 1;
+        current.disputed += 1;
+      } else if (row.completed_at != null) {
+        current.completed += 1;
+      }
+      current.createdAt = Math.min(current.createdAt, Number(row.created_at));
+      grouped.set(row.label, current);
+    }
+    return [...grouped.entries()].sort((left, right) => right[1].createdAt - left[1].createdAt).slice(0, normalizeBucketCount(buckets)).reverse().map(([label, row]) => ({
+      label,
+      completed: row.completed,
+      failed: row.failed,
+      disputed: row.disputed,
+      successRate: row.completed + row.failed === 0 ? 0 : row.completed / (row.completed + row.failed)
+    }));
+  }
+  getTopProviders(limit = 10, sortBy = "completedTasks") {
+    const db = this.store.getDatabase();
+    const rows = db.prepare(
+      `SELECT
+           did,
+           owner,
+           name,
+           COALESCE(total_tasks_completed, 0) AS completed_tasks,
+           COALESCE(total_tasks_failed, 0) AS failed_tasks,
+           COALESCE(total_tasks_disputed, 0) AS dispute_count,
+           COALESCE(total_earnings_mist, '0') AS earnings_mist
+         FROM agents
+         WHERE active = 1
+         ORDER BY updated_at DESC`
+    ).all();
+    const scored = rows.map((row) => {
+      const completedTasks = Number(row.completed_tasks ?? 0);
+      const failedTasks = Number(row.failed_tasks ?? 0);
+      const disputeCount = Number(row.dispute_count ?? 0);
+      const earningsMist = BigInt(row.earnings_mist ?? "0");
+      const successRate = completedTasks + failedTasks === 0 ? 0 : completedTasks / (completedTasks + failedTasks);
+      const reputation = successRate * 100 + completedTasks + Number(earningsMist > 0n ? 1n : 0n) - disputeCount;
+      return {
+        did: row.did,
+        owner: row.owner,
+        name: row.name,
+        completedTasks,
+        earningsMist,
+        disputeCount,
+        successRate,
+        reputation
+      };
+    });
+    return [...scored].sort((left, right) => {
+      if (sortBy === "earnings") {
+        return compareBigInt(right.earningsMist, left.earningsMist) || compareNumber(right.completedTasks, left.completedTasks);
+      }
+      if (sortBy === "reputation") {
+        return compareNumber(right.reputation, left.reputation) || compareNumber(right.completedTasks, left.completedTasks);
+      }
+      return compareNumber(right.completedTasks, left.completedTasks) || compareBigInt(right.earningsMist, left.earningsMist);
+    }).slice(0, Math.max(1, Math.floor(limit)));
+  }
+};
+function normalizeBucketCount(buckets) {
+  return Number.isFinite(buckets) ? Math.max(1, Math.floor(buckets)) : 14;
+}
+function bucketSql(period) {
+  switch (period) {
+    case "hour":
+      return "strftime('%Y-%m-%dT%H:00:00Z', created_at / 1000, 'unixepoch')";
+    case "week":
+      return "strftime('%Y-W%W', created_at / 1000, 'unixepoch')";
+    case "day":
+    default:
+      return "strftime('%Y-%m-%d', created_at / 1000, 'unixepoch')";
+  }
+}
+function compareNumber(left, right) {
+  if (left === right) {
+    return 0;
+  }
+  return left > right ? 1 : -1;
+}
+function compareBigInt(left, right) {
+  if (left === right) {
+    return 0;
+  }
+  return left > right ? 1 : -1;
+}
+function sumBigIntRows(rows) {
+  return rows.reduce((sum, row) => sum + toBigInt(row.price), 0n);
+}
+function toBigInt(value) {
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return BigInt(value);
+  }
+  if (typeof value === "string" && value.length > 0) {
+    return BigInt(value);
+  }
+  return 0n;
+}
+
+// src/config.ts
+import { homedir } from "os";
+import { join, resolve } from "path";
+function getDefaultIndexerConfig(baseDir = resolve(homedir(), ".hivemind-os/collective", "indexer")) {
+  return {
+    rpcUrl: "http://127.0.0.1:9000",
+    packageId: "",
+    sqlitePath: join(baseDir, "indexer.sqlite"),
+    pollingIntervalMs: 5e3,
+    server: {
+      host: "0.0.0.0",
+      port: 4e3
+    },
+    backfill: {}
+  };
+}
+function loadIndexerConfig(overrides = {}) {
+  const baseDir = process.env.COLLECTIVE_INDEXER_DATA_DIR ? resolve(process.env.COLLECTIVE_INDEXER_DATA_DIR) : void 0;
+  const defaults = getDefaultIndexerConfig(baseDir);
+  const config = {
+    rpcUrl: process.env.COLLECTIVE_RPC_URL ?? process.env.COLLECTIVE_INDEXER_RPC_URL ?? overrides.rpcUrl ?? defaults.rpcUrl,
+    packageId: process.env.COLLECTIVE_PACKAGE_ID ?? process.env.COLLECTIVE_INDEXER_PACKAGE_ID ?? overrides.packageId ?? defaults.packageId,
+    sqlitePath: resolve(overrides.sqlitePath ?? process.env.COLLECTIVE_INDEXER_SQLITE_PATH ?? defaults.sqlitePath),
+    pollingIntervalMs: readNumber(process.env.COLLECTIVE_INDEXER_POLLING_INTERVAL_MS) ?? overrides.pollingIntervalMs ?? defaults.pollingIntervalMs,
+    server: {
+      host: overrides.server?.host ?? process.env.COLLECTIVE_INDEXER_HOST ?? defaults.server.host,
+      port: readNumber(process.env.COLLECTIVE_INDEXER_PORT) ?? overrides.server?.port ?? defaults.server.port
+    },
+    backfill: overrides.backfill || process.env.COLLECTIVE_INDEXER_START_CHECKPOINT ? {
+      fromCheckpoint: overrides.backfill?.fromCheckpoint ?? readNumber(process.env.COLLECTIVE_INDEXER_START_CHECKPOINT)
+    } : defaults.backfill
+  };
+  validateIndexerConfig(config);
+  return config;
+}
+function validateIndexerConfig(config) {
+  if (!config.rpcUrl) {
+    throw new Error("Indexer rpcUrl is required.");
+  }
+  if (!Number.isInteger(config.pollingIntervalMs) || config.pollingIntervalMs <= 0) {
+    throw new Error("Indexer polling interval must be a positive integer.");
+  }
+  if (!config.server.host) {
+    throw new Error("Indexer server host is required.");
+  }
+  if (!Number.isInteger(config.server.port) || config.server.port <= 0) {
+    throw new Error("Indexer server port must be a positive integer.");
+  }
+  if (!config.sqlitePath) {
+    throw new Error("Indexer sqlitePath is required.");
+  }
+}
+function readNumber(value) {
+  if (!value) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+
+// src/graphql/server.ts
+import { createServer } from "http";
+import { createSchema, createYoga } from "graphql-yoga";
+import { BidStatus as BidStatus3, DisputeStatus as DisputeStatus2, PaymentScheme as PaymentScheme2, TaskStatus as TaskStatus2 } from "@hivemind-os/collective-types";
+
+// src/store.ts
+import Database from "better-sqlite3";
+import { ReputationScoreCalculator } from "@hivemind-os/collective-core";
+import { BidStatus as BidStatus2, PaymentScheme, TaskStatus } from "@hivemind-os/collective-types";
+var IndexerStore = class {
+  db;
+  scoreCalculator = new ReputationScoreCalculator();
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+    this.db.defaultSafeIntegers(true);
+    this.db.function("add_bigint", { deterministic: true }, (left, right) => {
+      return (toBigInt2(left) + toBigInt2(right)).toString();
+    });
+    this.db.function("subtract_bigint", { deterministic: true }, (left, right) => {
+      const value = toBigInt2(left) - toBigInt2(right);
+      return value < 0n ? "0" : value.toString();
+    });
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS indexer_cursors (
+        stream_key TEXT PRIMARY KEY,
+        cursor_json TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS events (
+        event_id TEXT PRIMARY KEY,
+        event_type TEXT NOT NULL,
+        package_id TEXT NOT NULL,
+        tx_digest TEXT NOT NULL,
+        module_name TEXT,
+        checkpoint INTEGER,
+        timestamp_ms INTEGER NOT NULL,
+        payload_json TEXT NOT NULL,
+        indexed_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS events_type_timestamp_idx ON events (event_type, timestamp_ms DESC);
+      CREATE INDEX IF NOT EXISTS events_tx_digest_idx ON events (tx_digest);
+
+      CREATE TABLE IF NOT EXISTS agents (
+        id TEXT PRIMARY KEY,
+        owner TEXT NOT NULL,
+        did TEXT UNIQUE NOT NULL,
+        name TEXT NOT NULL,
+        description TEXT,
+        capabilities_json TEXT,
+        capabilities_text TEXT,
+        endpoint TEXT,
+        encryption_public_key TEXT,
+        active INTEGER NOT NULL DEFAULT 1,
+        version INTEGER NOT NULL DEFAULT 1,
+        registered_at INTEGER,
+        updated_at INTEGER,
+        total_tasks_completed INTEGER,
+        total_tasks_failed INTEGER,
+        total_tasks_disputed INTEGER,
+        total_earnings_mist TEXT,
+        has_stake INTEGER,
+        stake_mist TEXT,
+        stake_type TEXT
+      );
+      CREATE INDEX IF NOT EXISTS agents_owner_idx ON agents (owner);
+      CREATE INDEX IF NOT EXISTS agents_did_idx ON agents (did);
+      CREATE VIRTUAL TABLE IF NOT EXISTS agents_fts USING fts5(agent_id UNINDEXED, name, description, capabilities_text);
+
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        requester TEXT NOT NULL,
+        provider TEXT,
+        capability TEXT NOT NULL,
+        category TEXT NOT NULL,
+        input_blob_id TEXT NOT NULL,
+        result_blob_id TEXT,
+        price TEXT NOT NULL,
+        payment_scheme TEXT,
+        max_price TEXT,
+        metered_units INTEGER,
+        unit_price TEXT,
+        verification_hash TEXT,
+        status INTEGER NOT NULL,
+        dispute_window_ms INTEGER,
+        created_at INTEGER NOT NULL,
+        accepted_at INTEGER,
+        completed_at INTEGER,
+        released_at INTEGER,
+        disputed_at INTEGER,
+        cancelled_at INTEGER,
+        expires_at INTEGER NOT NULL,
+        agreement_hash TEXT,
+        posted_tx_digest TEXT,
+        accepted_tx_digest TEXT,
+        completed_tx_digest TEXT,
+        released_tx_digest TEXT,
+        disputed_tx_digest TEXT,
+        cancelled_tx_digest TEXT,
+        gas_cost_mist_total TEXT DEFAULT '0',
+        bid_count INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE INDEX IF NOT EXISTS tasks_status_created_idx ON tasks (status, created_at DESC);
+      CREATE INDEX IF NOT EXISTS tasks_provider_created_idx ON tasks (provider, created_at DESC);
+      CREATE INDEX IF NOT EXISTS tasks_requester_created_idx ON tasks (requester, created_at DESC);
+      CREATE INDEX IF NOT EXISTS tasks_category_created_idx ON tasks (category, created_at DESC);
+      CREATE INDEX IF NOT EXISTS tasks_capability_created_idx ON tasks (capability, created_at DESC);
+      CREATE INDEX IF NOT EXISTS tasks_created_cursor_idx ON tasks (created_at DESC, id DESC);
+
+      CREATE TABLE IF NOT EXISTS task_transitions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL,
+        event_type TEXT NOT NULL,
+        status INTEGER NOT NULL,
+        tx_digest TEXT NOT NULL,
+        timestamp_ms INTEGER NOT NULL,
+        payload_json TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS task_transitions_task_idx ON task_transitions (task_id, timestamp_ms ASC, id ASC);
+
+      CREATE TABLE IF NOT EXISTS bids (
+        id TEXT PRIMARY KEY,
+        task_id TEXT NOT NULL,
+        bidder TEXT NOT NULL,
+        bid_price TEXT NOT NULL,
+        reputation_score TEXT NOT NULL,
+        evidence_blob TEXT,
+        created_at INTEGER NOT NULL,
+        accepted_at INTEGER,
+        rejected_at INTEGER,
+        withdrawn_at INTEGER,
+        status INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS bids_task_idx ON bids (task_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS bids_status_idx ON bids (status);
+
+      CREATE TABLE IF NOT EXISTS disputes (
+        id TEXT PRIMARY KEY,
+        task_id TEXT NOT NULL,
+        requester TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        escrow_amount TEXT NOT NULL,
+        status INTEGER NOT NULL,
+        requester_evidence_blob TEXT NOT NULL,
+        provider_evidence_blob TEXT,
+        requester_proposed_split TEXT NOT NULL,
+        provider_proposed_split TEXT NOT NULL,
+        arbitrator TEXT,
+        ruling_split TEXT NOT NULL,
+        opened_at INTEGER NOT NULL,
+        responded_at INTEGER,
+        resolved_at INTEGER,
+        resolution_deadline INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS disputes_task_idx ON disputes (task_id);
+      CREATE INDEX IF NOT EXISTS disputes_status_idx ON disputes (status);
+
+      CREATE TABLE IF NOT EXISTS stakes (
+        id TEXT PRIMARY KEY,
+        owner TEXT NOT NULL,
+        amount_mist TEXT NOT NULL DEFAULT '0',
+        active INTEGER NOT NULL DEFAULT 1,
+        stake_type TEXT,
+        staked_at INTEGER,
+        deactivated_at INTEGER,
+        withdrawn_at INTEGER,
+        slashed_amount_mist TEXT NOT NULL DEFAULT '0',
+        last_updated_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS stakes_owner_idx ON stakes (owner);
+
+      CREATE TABLE IF NOT EXISTS reputation_anchors (
+        anchor_id TEXT PRIMARY KEY,
+        author TEXT NOT NULL,
+        merkle_root TEXT NOT NULL,
+        event_count INTEGER NOT NULL,
+        blob_id TEXT,
+        from_timestamp INTEGER,
+        to_timestamp INTEGER,
+        created_at INTEGER NOT NULL,
+        tx_digest TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS reputation_anchors_author_idx ON reputation_anchors (author, created_at DESC);
+    `);
+    ensureTaskColumns(this.db);
+  }
+  close() {
+    this.db.close();
+  }
+  getCursor(streamKey) {
+    const row = this.db.prepare("SELECT cursor_json FROM indexer_cursors WHERE stream_key = ?").get(streamKey);
+    if (!row) {
+      return null;
+    }
+    try {
+      return JSON.parse(row.cursor_json);
+    } catch {
+      return null;
+    }
+  }
+  setCursor(streamKey, cursor) {
+    this.db.prepare(
+      `INSERT INTO indexer_cursors (stream_key, cursor_json, updated_at)
+         VALUES (?, ?, ?)
+         ON CONFLICT(stream_key)
+         DO UPDATE SET cursor_json = excluded.cursor_json, updated_at = excluded.updated_at`
+    ).run(streamKey, JSON.stringify(cursor), Date.now());
+  }
+  recordEvent(event) {
+    const result = this.db.prepare(
+      `INSERT OR IGNORE INTO events (
+          event_id, event_type, package_id, tx_digest, module_name, checkpoint, timestamp_ms, payload_json, indexed_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      event.eventId,
+      event.eventType,
+      event.packageId,
+      event.txDigest,
+      event.module ?? null,
+      event.checkpoint ?? null,
+      event.timestampMs,
+      JSON.stringify(event.payload, bigintReplacer),
+      Date.now()
+    );
+    return result.changes > 0;
+  }
+  upsertAgent(agent) {
+    const capabilitiesJson = JSON.stringify(agent.capabilities, bigintReplacer);
+    const capabilitiesText = buildCapabilitiesText(agent.capabilities);
+    this.db.prepare(
+      `INSERT INTO agents (
+          id, owner, did, name, description, capabilities_json, capabilities_text, endpoint,
+          encryption_public_key, active, version, registered_at, updated_at,
+          total_tasks_completed, total_tasks_failed, total_tasks_disputed, total_earnings_mist,
+          has_stake, stake_mist, stake_type
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          owner = excluded.owner,
+          did = excluded.did,
+          name = excluded.name,
+          description = excluded.description,
+          capabilities_json = excluded.capabilities_json,
+          capabilities_text = excluded.capabilities_text,
+          endpoint = excluded.endpoint,
+          encryption_public_key = excluded.encryption_public_key,
+          active = excluded.active,
+          version = excluded.version,
+          registered_at = excluded.registered_at,
+          updated_at = excluded.updated_at,
+          total_tasks_completed = COALESCE(excluded.total_tasks_completed, agents.total_tasks_completed),
+          total_tasks_failed = COALESCE(excluded.total_tasks_failed, agents.total_tasks_failed),
+          total_tasks_disputed = COALESCE(excluded.total_tasks_disputed, agents.total_tasks_disputed),
+          total_earnings_mist = COALESCE(excluded.total_earnings_mist, agents.total_earnings_mist),
+          has_stake = COALESCE(excluded.has_stake, agents.has_stake),
+          stake_mist = COALESCE(excluded.stake_mist, agents.stake_mist),
+          stake_type = COALESCE(excluded.stake_type, agents.stake_type)`
+    ).run(
+      agent.id,
+      agent.owner,
+      agent.did,
+      agent.name,
+      agent.description,
+      capabilitiesJson,
+      capabilitiesText,
+      agent.endpoint ?? null,
+      agent.encryptionPublicKey ?? null,
+      agent.active ? 1 : 0,
+      agent.version,
+      agent.registeredAt,
+      agent.updatedAt,
+      agent.totalTasksCompleted ?? null,
+      agent.totalTasksFailed ?? null,
+      agent.totalTasksDisputed ?? null,
+      agent.totalEarningsMist?.toString() ?? null,
+      agent.hasStake == null ? null : agent.hasStake ? 1 : 0,
+      agent.stakeMist?.toString() ?? null,
+      agent.stakeType ?? null
+    );
+    this.db.prepare("DELETE FROM agents_fts WHERE agent_id = ?").run(agent.id);
+    this.db.prepare("INSERT INTO agents_fts (agent_id, name, description, capabilities_text) VALUES (?, ?, ?, ?)").run(agent.id, agent.name, agent.description, capabilitiesText);
+  }
+  markAgentInactive(agentId) {
+    this.db.prepare("UPDATE agents SET active = 0 WHERE id = ?").run(agentId);
+  }
+  getAgentByDid(did) {
+    const row = this.db.prepare("SELECT rowid, * FROM agents WHERE did = ?").get(did);
+    return row ? mapAgentRow(row) : null;
+  }
+  queryAgents(filters = {}) {
+    const limit = normalizeLimit(filters.limit, 20);
+    const offset = normalizeOffset(filters.offset);
+    const clauses = [];
+    const values = [];
+    if (filters.activeOnly !== false) {
+      clauses.push("a.active = 1");
+    }
+    if (filters.category) {
+      clauses.push("EXISTS (SELECT 1 FROM tasks t WHERE t.provider = a.owner AND t.category = ?)");
+      values.push(filters.category);
+    }
+    const search = filters.search?.trim();
+    const capability = filters.capability?.trim();
+    const searchQuery = search ?? capability;
+    let rows = [];
+    if (searchQuery) {
+      const ftsQuery = buildFtsQuery(searchQuery);
+      const where = clauses.length > 0 ? `AND ${clauses.join(" AND ")}` : "";
+      try {
+        rows = this.db.prepare(
+          `SELECT a.rowid, a.*
+             FROM agents_fts
+             JOIN agents a ON a.id = agents_fts.agent_id
+             WHERE agents_fts MATCH ? ${where}
+             LIMIT ? OFFSET ?`
+        ).all(ftsQuery, ...values, Math.max(limit * 4, 50), offset);
+      } catch {
+        const like = `%${searchQuery}%`;
+        const whereClause = clauses.length > 0 ? `AND ${clauses.join(" AND ")}` : "";
+        rows = this.db.prepare(
+          `SELECT rowid, * FROM agents a
+             WHERE (a.name LIKE ? OR a.description LIKE ? OR a.capabilities_text LIKE ? OR a.capabilities_json LIKE ?)
+             ${whereClause}
+             LIMIT ? OFFSET ?`
+        ).all(like, like, like, like, ...values, Math.max(limit * 4, 50), offset);
+      }
+    } else {
+      const whereClause = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+      rows = this.db.prepare(`SELECT rowid, * FROM agents a ${whereClause} ORDER BY updated_at DESC LIMIT ? OFFSET ?`).all(Math.max(limit * 4, 50), offset);
+    }
+    let agents = rows.map(mapAgentRow);
+    if (capability) {
+      agents = agents.filter((agent) => agent.capabilities.some((entry) => equalsIgnoreCase(entry.name, capability)));
+    }
+    if (search) {
+      const searchLower = search.toLowerCase();
+      agents = agents.filter((agent) => matchesSearch(agent, searchLower));
+    }
+    const scores = new Map(agents.map((agent) => [agent.did, this.scoreCalculator.computeScore(agent, [])]));
+    const minReputation = typeof filters.minReputation === "number" ? filters.minReputation : void 0;
+    if (minReputation !== void 0) {
+      agents = agents.filter((agent) => (scores.get(agent.did)?.successRate ?? 0) >= minReputation);
+    }
+    const ranked = filters.sortBy === "reputation" ? this.scoreCalculator.rankByReputation(agents, scores) : [...agents].sort(compareStakePreference);
+    return ranked.slice(0, limit);
+  }
+  countAgents(filters = {}) {
+    return this.queryAgents({ ...filters, limit: 1e4, offset: 0 }).length;
+  }
+  upsertTask(task, txDigest, gasCostMist = 0n) {
+    this.db.prepare(
+      `INSERT INTO tasks (
+          id, requester, provider, capability, category, input_blob_id, result_blob_id, price,
+          payment_scheme, max_price, metered_units, unit_price, verification_hash,
+          status, dispute_window_ms, created_at, accepted_at, completed_at, released_at, disputed_at, cancelled_at,
+          expires_at, agreement_hash, posted_tx_digest, gas_cost_mist_total, bid_count
+        ) VALUES (
+          ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
+          ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
+          COALESCE((SELECT bid_count FROM tasks WHERE id = ?), 0)
+        )
+        ON CONFLICT(id) DO UPDATE SET
+          requester = excluded.requester,
+          provider = COALESCE(excluded.provider, tasks.provider),
+          capability = excluded.capability,
+          category = excluded.category,
+          input_blob_id = excluded.input_blob_id,
+          result_blob_id = COALESCE(excluded.result_blob_id, tasks.result_blob_id),
+          price = excluded.price,
+          payment_scheme = COALESCE(excluded.payment_scheme, tasks.payment_scheme),
+          max_price = COALESCE(excluded.max_price, tasks.max_price),
+          metered_units = COALESCE(excluded.metered_units, tasks.metered_units),
+          unit_price = COALESCE(excluded.unit_price, tasks.unit_price),
+          verification_hash = COALESCE(excluded.verification_hash, tasks.verification_hash),
+          status = excluded.status,
+          dispute_window_ms = excluded.dispute_window_ms,
+          created_at = excluded.created_at,
+          accepted_at = COALESCE(excluded.accepted_at, tasks.accepted_at),
+          completed_at = COALESCE(excluded.completed_at, tasks.completed_at),
+          expires_at = excluded.expires_at,
+          agreement_hash = COALESCE(excluded.agreement_hash, tasks.agreement_hash),
+          posted_tx_digest = COALESCE(excluded.posted_tx_digest, tasks.posted_tx_digest),
+          gas_cost_mist_total = add_bigint(tasks.gas_cost_mist_total, excluded.gas_cost_mist_total)`
+    ).run(
+      task.id,
+      task.requester,
+      task.provider ?? null,
+      task.capability,
+      task.category,
+      task.inputBlobId,
+      task.resultBlobId ?? null,
+      task.price.toString(),
+      task.paymentScheme ?? null,
+      task.maxPrice?.toString() ?? null,
+      task.meteredUnits ?? null,
+      task.unitPrice?.toString() ?? null,
+      task.verificationHash ?? null,
+      task.status,
+      task.disputeWindowMs,
+      task.createdAt,
+      task.acceptedAt ?? null,
+      task.completedAt ?? null,
+      null,
+      null,
+      null,
+      task.expiresAt,
+      task.agreementHash ?? null,
+      txDigest,
+      gasCostMist.toString(),
+      task.id
+    );
+    this.recordTaskTransition(task.id, "task.posted", TaskStatus.OPEN, txDigest, task.createdAt, task);
+  }
+  updateTaskStatus(params) {
+    const gasCost = params.gasCostMist?.toString() ?? "0";
+    const columnUpdates = ["status = ?", "provider = COALESCE(?, provider)", "gas_cost_mist_total = add_bigint(gas_cost_mist_total, ?)"];
+    const values = [params.status, params.provider ?? null, gasCost];
+    if (params.requester !== void 0) {
+      columnUpdates.push("requester = COALESCE(?, requester)");
+      values.push(params.requester || null);
+    }
+    if (params.resultBlobId !== void 0) {
+      columnUpdates.push("result_blob_id = COALESCE(?, result_blob_id)");
+      values.push(params.resultBlobId || null);
+    }
+    if (params.price !== void 0) {
+      columnUpdates.push("price = COALESCE(?, price)");
+      values.push(params.price?.toString() ?? null);
+    }
+    if (params.paymentScheme !== void 0) {
+      columnUpdates.push("payment_scheme = COALESCE(?, payment_scheme)");
+      values.push(params.paymentScheme ?? null);
+    }
+    if (params.meteredUnits !== void 0) {
+      columnUpdates.push("metered_units = COALESCE(?, metered_units)");
+      values.push(params.meteredUnits);
+    }
+    if (params.maxPrice !== void 0) {
+      columnUpdates.push("max_price = COALESCE(?, max_price)");
+      values.push(params.maxPrice?.toString() ?? null);
+    }
+    if (params.unitPrice !== void 0) {
+      columnUpdates.push("unit_price = COALESCE(?, unit_price)");
+      values.push(params.unitPrice?.toString() ?? null);
+    }
+    if (params.verificationHash !== void 0) {
+      columnUpdates.push("verification_hash = COALESCE(?, verification_hash)");
+      values.push(params.verificationHash || null);
+    }
+    switch (params.status) {
+      case TaskStatus.ACCEPTED:
+        columnUpdates.push("accepted_at = ?", "accepted_tx_digest = ?");
+        values.push(params.timestampMs, params.txDigest);
+        break;
+      case TaskStatus.COMPLETED:
+        columnUpdates.push("completed_at = ?", "completed_tx_digest = ?");
+        values.push(params.timestampMs, params.txDigest);
+        break;
+      case TaskStatus.RELEASED:
+        columnUpdates.push("released_at = ?", "released_tx_digest = ?");
+        values.push(params.timestampMs, params.txDigest);
+        break;
+      case TaskStatus.DISPUTED:
+        columnUpdates.push("disputed_at = ?", "disputed_tx_digest = ?");
+        values.push(params.timestampMs, params.txDigest);
+        break;
+      case TaskStatus.CANCELLED:
+        columnUpdates.push("cancelled_at = ?", "cancelled_tx_digest = ?");
+        values.push(params.timestampMs, params.txDigest);
+        break;
+      default:
+        break;
+    }
+    this.db.prepare(`UPDATE tasks SET ${columnUpdates.join(", ")} WHERE id = ?`).run(...values, params.taskId);
+    this.recordTaskTransition(params.taskId, params.eventType, params.status, params.txDigest, params.timestampMs, params.payload);
+  }
+  getTask(taskId, includeTransitions = true) {
+    const row = this.db.prepare("SELECT * FROM tasks WHERE id = ?").get(taskId);
+    if (!row) {
+      return null;
+    }
+    return mapTaskRow(row, includeTransitions ? this.getTaskTransitions(taskId) : void 0);
+  }
+  queryTasks(filters = {}) {
+    const limit = normalizeLimit(filters.limit, 20);
+    const clauses = [];
+    const values = [];
+    if (filters.status !== void 0) {
+      clauses.push("status = ?");
+      values.push(filters.status);
+    }
+    if (filters.requester) {
+      clauses.push("requester = ?");
+      values.push(filters.requester);
+    }
+    if (filters.provider) {
+      clauses.push("provider = ?");
+      values.push(filters.provider);
+    }
+    if (filters.category) {
+      clauses.push("category = ?");
+      values.push(filters.category);
+    }
+    const cursor = decodeCursor(filters.after);
+    if (cursor) {
+      clauses.push("(created_at < ? OR (created_at = ? AND id < ?))");
+      values.push(cursor.createdAt, cursor.createdAt, cursor.id);
+    }
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = this.db.prepare(`SELECT * FROM tasks ${where} ORDER BY created_at DESC, id DESC LIMIT ?`).all(...values, limit);
+    return rows.map((row) => mapTaskRow(row));
+  }
+  getTaskTransitions(taskId) {
+    const rows = this.db.prepare(
+      "SELECT task_id, event_type, status, tx_digest, timestamp_ms, payload_json FROM task_transitions WHERE task_id = ? ORDER BY timestamp_ms ASC, id ASC"
+    ).all(taskId);
+    return rows.map((row) => ({
+      taskId: row.task_id,
+      eventType: row.event_type,
+      status: Number(row.status),
+      txDigest: row.tx_digest,
+      timestampMs: Number(row.timestamp_ms),
+      payload: JSON.parse(row.payload_json)
+    }));
+  }
+  upsertBid(bid) {
+    const existing = this.db.prepare("SELECT 1 FROM bids WHERE id = ?").get(bid.id);
+    this.db.prepare(
+      `INSERT INTO bids (
+          id, task_id, bidder, bid_price, reputation_score, evidence_blob, created_at, accepted_at, rejected_at, withdrawn_at, status
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          task_id = excluded.task_id,
+          bidder = excluded.bidder,
+          bid_price = excluded.bid_price,
+          reputation_score = excluded.reputation_score,
+          evidence_blob = excluded.evidence_blob,
+          created_at = excluded.created_at,
+          status = excluded.status`
+    ).run(
+      bid.id,
+      bid.taskId,
+      bid.bidder,
+      bid.bidPrice.toString(),
+      bid.reputationScore.toString(),
+      bid.evidenceBlob ?? null,
+      bid.createdAt,
+      null,
+      null,
+      null,
+      bid.status
+    );
+    if (!existing) {
+      this.db.prepare("UPDATE tasks SET bid_count = bid_count + 1 WHERE id = ?").run(bid.taskId);
+    }
+  }
+  updateBidStatus(bidId, status, timestampMs) {
+    const columns = ["status = ?"];
+    const values = [status];
+    if (status === BidStatus2.ACCEPTED) {
+      columns.push("accepted_at = ?");
+      values.push(timestampMs);
+    } else if (status === BidStatus2.REJECTED) {
+      columns.push("rejected_at = ?");
+      values.push(timestampMs);
+    } else if (status === BidStatus2.WITHDRAWN) {
+      columns.push("withdrawn_at = ?");
+      values.push(timestampMs);
+    }
+    this.db.prepare(`UPDATE bids SET ${columns.join(", ")} WHERE id = ?`).run(...values, bidId);
+  }
+  getBids(taskId, status) {
+    const rows = status === void 0 ? this.db.prepare("SELECT * FROM bids WHERE task_id = ? ORDER BY created_at DESC").all(taskId) : this.db.prepare("SELECT * FROM bids WHERE task_id = ? AND status = ? ORDER BY created_at DESC").all(taskId, status);
+    return rows.map(mapBidRow);
+  }
+  upsertDispute(dispute) {
+    this.db.prepare(
+      `INSERT INTO disputes (
+          id, task_id, requester, provider, escrow_amount, status, requester_evidence_blob,
+          provider_evidence_blob, requester_proposed_split, provider_proposed_split, arbitrator,
+          ruling_split, opened_at, responded_at, resolved_at, resolution_deadline
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          task_id = excluded.task_id,
+          requester = excluded.requester,
+          provider = excluded.provider,
+          escrow_amount = excluded.escrow_amount,
+          status = excluded.status,
+          requester_evidence_blob = excluded.requester_evidence_blob,
+          provider_evidence_blob = COALESCE(excluded.provider_evidence_blob, disputes.provider_evidence_blob),
+          requester_proposed_split = excluded.requester_proposed_split,
+          provider_proposed_split = COALESCE(excluded.provider_proposed_split, disputes.provider_proposed_split),
+          arbitrator = COALESCE(excluded.arbitrator, disputes.arbitrator),
+          ruling_split = COALESCE(excluded.ruling_split, disputes.ruling_split),
+          opened_at = excluded.opened_at,
+          responded_at = COALESCE(excluded.responded_at, disputes.responded_at),
+          resolved_at = COALESCE(excluded.resolved_at, disputes.resolved_at),
+          resolution_deadline = excluded.resolution_deadline`
+    ).run(
+      dispute.id,
+      dispute.taskId,
+      dispute.requester,
+      dispute.provider,
+      dispute.escrowAmount.toString(),
+      dispute.status,
+      dispute.requesterEvidenceBlob,
+      dispute.providerEvidenceBlob ?? null,
+      dispute.requesterProposedSplit.toString(),
+      dispute.providerProposedSplit.toString(),
+      dispute.arbitrator ?? null,
+      dispute.rulingSplit.toString(),
+      dispute.openedAt,
+      dispute.respondedAt ?? null,
+      dispute.resolvedAt ?? null,
+      dispute.resolutionDeadline
+    );
+  }
+  updateDispute(params) {
+    const clauses = ["status = ?"];
+    const values = [params.status];
+    if (params.respondedAt !== void 0) {
+      clauses.push("responded_at = ?");
+      values.push(params.respondedAt);
+    }
+    if (params.resolvedAt !== void 0) {
+      clauses.push("resolved_at = ?");
+      values.push(params.resolvedAt);
+    }
+    if (params.providerEvidenceBlob !== void 0) {
+      clauses.push("provider_evidence_blob = ?");
+      values.push(params.providerEvidenceBlob);
+    }
+    if (params.providerProposedSplit !== void 0) {
+      clauses.push("provider_proposed_split = ?");
+      values.push(params.providerProposedSplit.toString());
+    }
+    if (params.arbitrator !== void 0) {
+      clauses.push("arbitrator = ?");
+      values.push(params.arbitrator);
+    }
+    if (params.rulingSplit !== void 0) {
+      clauses.push("ruling_split = ?");
+      values.push(params.rulingSplit.toString());
+    }
+    this.db.prepare(`UPDATE disputes SET ${clauses.join(", ")} WHERE id = ?`).run(...values, params.disputeId);
+  }
+  getDisputes(filters = {}) {
+    const clauses = [];
+    const values = [];
+    if (filters.status !== void 0) {
+      clauses.push("status = ?");
+      values.push(filters.status);
+    }
+    if (filters.agent) {
+      clauses.push("(requester = ? OR provider = ? OR arbitrator = ?)");
+      values.push(filters.agent, filters.agent, filters.agent);
+    }
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = this.db.prepare(`SELECT * FROM disputes ${where} ORDER BY opened_at DESC`).all(...values);
+    return rows.map(mapDisputeRow);
+  }
+  upsertStake(params) {
+    this.db.prepare(
+      `INSERT INTO stakes (
+          id, owner, amount_mist, active, stake_type, staked_at, deactivated_at, withdrawn_at, slashed_amount_mist, last_updated_at
+        ) VALUES (?, ?, COALESCE(?, (SELECT amount_mist FROM stakes WHERE id = ?), '0'), ?, ?, ?, ?, ?, COALESCE(?, (SELECT slashed_amount_mist FROM stakes WHERE id = ?), '0'), ?)
+        ON CONFLICT(id) DO UPDATE SET
+          owner = excluded.owner,
+          amount_mist = COALESCE(excluded.amount_mist, stakes.amount_mist),
+          active = excluded.active,
+          stake_type = COALESCE(excluded.stake_type, stakes.stake_type),
+          staked_at = COALESCE(excluded.staked_at, stakes.staked_at),
+          deactivated_at = COALESCE(excluded.deactivated_at, stakes.deactivated_at),
+          withdrawn_at = COALESCE(excluded.withdrawn_at, stakes.withdrawn_at),
+          slashed_amount_mist = COALESCE(excluded.slashed_amount_mist, stakes.slashed_amount_mist),
+          last_updated_at = excluded.last_updated_at`
+    ).run(
+      params.stakeId,
+      params.owner,
+      params.amountMist?.toString() ?? null,
+      params.stakeId,
+      params.active === false ? 0 : 1,
+      params.stakeType ?? null,
+      params.stakedAt ?? null,
+      params.deactivatedAt ?? null,
+      params.withdrawnAt ?? null,
+      params.slashedAmountMist?.toString() ?? null,
+      params.stakeId,
+      Date.now()
+    );
+    this.syncAgentStake(params.owner);
+  }
+  addStakeSlash(stakeId, amountMist) {
+    this.db.prepare(
+      `UPDATE stakes
+         SET slashed_amount_mist = add_bigint(slashed_amount_mist, ?),
+             amount_mist = subtract_bigint(amount_mist, ?),
+             last_updated_at = ?
+         WHERE id = ?`
+    ).run(amountMist.toString(), amountMist.toString(), Date.now(), stakeId);
+    const owner = this.db.prepare("SELECT owner FROM stakes WHERE id = ?").get(stakeId);
+    if (owner) {
+      this.syncAgentStake(owner.owner);
+    }
+  }
+  upsertReputationAnchor(params) {
+    this.db.prepare(
+      `INSERT OR REPLACE INTO reputation_anchors (
+          anchor_id, author, merkle_root, event_count, blob_id, from_timestamp, to_timestamp, created_at, tx_digest
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      params.anchorId,
+      params.author,
+      params.merkleRoot,
+      params.eventCount,
+      params.blobId ?? null,
+      params.fromTimestamp ?? null,
+      params.toTimestamp ?? null,
+      params.createdAt,
+      params.txDigest
+    );
+  }
+  getDatabase() {
+    return this.db;
+  }
+  recordTaskTransition(taskId, eventType, status, txDigest, timestampMs, payload) {
+    const exists = this.db.prepare("SELECT 1 FROM task_transitions WHERE task_id = ? AND event_type = ? AND tx_digest = ? LIMIT 1").get(taskId, eventType, txDigest);
+    if (exists) {
+      return;
+    }
+    this.db.prepare(
+      "INSERT INTO task_transitions (task_id, event_type, status, tx_digest, timestamp_ms, payload_json) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(taskId, eventType, status, txDigest, timestampMs, JSON.stringify(payload, bigintReplacer));
+  }
+  syncAgentStake(owner) {
+    const stake = this.db.prepare("SELECT amount_mist, active, stake_type FROM stakes WHERE owner = ? ORDER BY last_updated_at DESC LIMIT 1").get(owner);
+    if (!stake) {
+      this.db.prepare("UPDATE agents SET has_stake = 0, stake_mist = NULL, stake_type = NULL WHERE owner = ?").run(owner);
+      return;
+    }
+    this.db.prepare("UPDATE agents SET has_stake = ?, stake_mist = ?, stake_type = ? WHERE owner = ?").run(Number(stake.active) === 1 ? 1 : 0, stake.amount_mist, stake.stake_type, owner);
+  }
+};
+function encodeCursor(task) {
+  return Buffer.from(JSON.stringify({ id: task.id, createdAt: task.createdAt })).toString("base64url");
+}
+function decodeCursor(cursor) {
+  if (!cursor) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    return typeof parsed.id === "string" && typeof parsed.createdAt === "number" ? { id: parsed.id, createdAt: parsed.createdAt } : null;
+  } catch {
+    return null;
+  }
+}
+function mapAgentRow(row) {
+  return {
+    id: row.id,
+    owner: row.owner,
+    did: row.did,
+    name: row.name,
+    description: row.description ?? "",
+    capabilities: parseCapabilities(row.capabilities_json),
+    endpoint: row.endpoint ?? void 0,
+    encryptionPublicKey: row.encryption_public_key ?? void 0,
+    active: Number(row.active) === 1,
+    version: Number(row.version),
+    registeredAt: Number(row.registered_at ?? 0),
+    updatedAt: Number(row.updated_at ?? 0),
+    totalTasksCompleted: row.total_tasks_completed == null ? void 0 : Number(row.total_tasks_completed),
+    totalTasksFailed: row.total_tasks_failed == null ? void 0 : Number(row.total_tasks_failed),
+    totalTasksDisputed: row.total_tasks_disputed == null ? void 0 : Number(row.total_tasks_disputed),
+    totalEarningsMist: row.total_earnings_mist == null ? void 0 : BigInt(row.total_earnings_mist),
+    hasStake: row.has_stake == null ? void 0 : Number(row.has_stake) === 1,
+    stakeMist: row.stake_mist == null ? void 0 : BigInt(row.stake_mist),
+    stakeType: row.stake_type === "agent" || row.stake_type === "relay" ? row.stake_type : void 0
+  };
+}
+function mapTaskRow(row, transitions) {
+  return {
+    id: row.id,
+    requester: row.requester,
+    provider: row.provider ?? void 0,
+    capability: row.capability,
+    category: row.category,
+    inputBlobId: row.input_blob_id,
+    resultBlobId: row.result_blob_id ?? void 0,
+    price: BigInt(row.price),
+    paymentScheme: normalizePaymentScheme(row.payment_scheme),
+    maxPrice: row.max_price == null ? void 0 : BigInt(row.max_price),
+    meteredUnits: row.metered_units == null ? void 0 : Number(row.metered_units),
+    unitPrice: row.unit_price == null ? void 0 : BigInt(row.unit_price),
+    verificationHash: row.verification_hash ?? void 0,
+    status: Number(row.status),
+    disputeWindowMs: Number(row.dispute_window_ms ?? 0),
+    createdAt: Number(row.created_at),
+    acceptedAt: row.accepted_at == null ? void 0 : Number(row.accepted_at),
+    completedAt: row.completed_at == null ? void 0 : Number(row.completed_at),
+    releasedAt: row.released_at == null ? void 0 : Number(row.released_at),
+    disputedAt: row.disputed_at == null ? void 0 : Number(row.disputed_at),
+    cancelledAt: row.cancelled_at == null ? void 0 : Number(row.cancelled_at),
+    expiresAt: Number(row.expires_at),
+    agreementHash: row.agreement_hash ?? void 0,
+    bidCount: Number(row.bid_count ?? 0),
+    gasCostMistTotal: BigInt(row.gas_cost_mist_total ?? "0"),
+    transitions
+  };
+}
+function mapBidRow(row) {
+  return {
+    id: row.id,
+    taskId: row.task_id,
+    bidder: row.bidder,
+    bidPrice: BigInt(row.bid_price),
+    reputationScore: BigInt(row.reputation_score),
+    evidenceBlob: row.evidence_blob ?? void 0,
+    createdAt: Number(row.created_at),
+    status: Number(row.status)
+  };
+}
+function mapDisputeRow(row) {
+  return {
+    id: row.id,
+    taskId: row.task_id,
+    requester: row.requester,
+    provider: row.provider,
+    escrowAmount: BigInt(row.escrow_amount),
+    status: Number(row.status),
+    requesterEvidenceBlob: row.requester_evidence_blob,
+    providerEvidenceBlob: row.provider_evidence_blob ?? void 0,
+    requesterProposedSplit: BigInt(row.requester_proposed_split),
+    providerProposedSplit: BigInt(row.provider_proposed_split),
+    arbitrator: row.arbitrator ?? void 0,
+    rulingSplit: BigInt(row.ruling_split),
+    openedAt: Number(row.opened_at),
+    respondedAt: row.responded_at == null ? void 0 : Number(row.responded_at),
+    resolvedAt: row.resolved_at == null ? void 0 : Number(row.resolved_at),
+    resolutionDeadline: Number(row.resolution_deadline)
+  };
+}
+function parseCapabilities(value) {
+  if (!value) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(value);
+    return parsed.map((entry) => ({
+      ...entry,
+      pricing: {
+        ...entry.pricing,
+        amount: BigInt(entry.pricing.amount)
+      }
+    }));
+  } catch {
+    return [];
+  }
+}
+function buildCapabilitiesText(capabilities) {
+  return capabilities.map((entry) => `${entry.name} ${entry.description} ${entry.version}`).join(" ");
+}
+function buildFtsQuery(query) {
+  return query.trim().split(/\s+/).map((term) => term.replace(/[^\p{L}\p{N}_-]/gu, "")).filter(Boolean).map((term) => `"${term}"*`).join(" OR ");
+}
+function normalizeLimit(limit, fallback) {
+  if (typeof limit !== "number" || Number.isNaN(limit)) {
+    return fallback;
+  }
+  return Math.max(1, Math.floor(limit));
+}
+function normalizeOffset(offset) {
+  if (typeof offset !== "number" || Number.isNaN(offset)) {
+    return 0;
+  }
+  return Math.max(0, Math.floor(offset));
+}
+function compareStakePreference(left, right) {
+  return compareBoolean(left.hasStake ?? false, right.hasStake ?? false) || compareBigInt2(left.stakeMist ?? 0n, right.stakeMist ?? 0n) || compareNumber2(left.updatedAt, right.updatedAt);
+}
+function compareBoolean(left, right) {
+  if (left === right) {
+    return 0;
+  }
+  return left ? -1 : 1;
+}
+function compareBigInt2(left, right) {
+  if (left === right) {
+    return 0;
+  }
+  return left > right ? -1 : 1;
+}
+function compareNumber2(left, right) {
+  if (left === right) {
+    return 0;
+  }
+  return left > right ? -1 : 1;
+}
+function equalsIgnoreCase(left, right) {
+  return left.toLowerCase() === right.toLowerCase();
+}
+function matchesSearch(agent, searchLower) {
+  return agent.name.toLowerCase().includes(searchLower) || agent.description.toLowerCase().includes(searchLower) || agent.capabilities.some(
+    (entry) => entry.name.toLowerCase().includes(searchLower) || entry.description.toLowerCase().includes(searchLower) || entry.version.toLowerCase().includes(searchLower)
+  );
+}
+function bigintReplacer(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+function toBigInt2(value) {
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return BigInt(value);
+  }
+  if (typeof value === "string" && value.length > 0) {
+    return BigInt(value);
+  }
+  return 0n;
+}
+function normalizePaymentScheme(value) {
+  switch (value) {
+    case PaymentScheme.EXACT:
+      return PaymentScheme.EXACT;
+    case PaymentScheme.UPTO:
+      return PaymentScheme.UPTO;
+    case PaymentScheme.STREAM:
+      return PaymentScheme.STREAM;
+    default:
+      return void 0;
+  }
+}
+function ensureTaskColumns(db) {
+  const rows = db.prepare("PRAGMA table_info(tasks)").all();
+  const existing = new Set(rows.map((row) => row.name).filter((name) => typeof name === "string"));
+  const missingColumns = [
+    ["payment_scheme", "TEXT"],
+    ["max_price", "TEXT"],
+    ["metered_units", "INTEGER"],
+    ["unit_price", "TEXT"],
+    ["verification_hash", "TEXT"]
+  ];
+  for (const [column, type] of missingColumns) {
+    if (!existing.has(column)) {
+      db.exec(`ALTER TABLE tasks ADD COLUMN ${column} ${type}`);
+    }
+  }
+}
+
+// src/graphql/server.ts
+var MAX_PAGE_SIZE = 100;
+function createIndexerGraphQLServer(options) {
+  const analytics = options.analytics ?? new AnalyticsEngine(options.store);
+  const schema = createSchema({
+    typeDefs: (
+      /* GraphQL */
+      `
+      enum TaskStatus {
+        OPEN
+        ACCEPTED
+        COMPLETED
+        RELEASED
+        DISPUTED
+        CANCELLED
+      }
+
+      enum PaymentScheme {
+        EXACT
+        UPTO
+        STREAM
+      }
+
+      enum BidStatus {
+        ACTIVE
+        ACCEPTED
+        REJECTED
+        WITHDRAWN
+      }
+
+      enum DisputeStatus {
+        OPEN
+        RESPONDED
+        MUTUAL_RESOLVED
+        ARBITRATED
+        EXPIRED
+      }
+
+      enum TimePeriod {
+        HOUR
+        DAY
+        WEEK
+      }
+
+      enum ProviderSortField {
+        COMPLETED_TASKS
+        EARNINGS
+        REPUTATION
+      }
+
+      type PageInfo {
+        hasNextPage: Boolean!
+        endCursor: String
+      }
+
+      type AgentConnection {
+        nodes: [Agent!]!
+        totalCount: Int!
+        pageInfo: PageInfo!
+      }
+
+      type TaskConnection {
+        nodes: [Task!]!
+        pageInfo: PageInfo!
+      }
+
+      type PricingInfo {
+        rail: String!
+        amount: String!
+        currency: String!
+      }
+
+      type Capability {
+        name: String!
+        description: String!
+        version: String!
+        pricing: PricingInfo!
+        executionMode: String
+        paymentRails: [String!]!
+      }
+
+      type AgentReputation {
+        successRate: Float!
+        totalTasks: Int!
+        totalDisputes: Int!
+        totalEarningsMist: String!
+        stakeAmountMist: String!
+      }
+
+      type Agent {
+        id: ID!
+        owner: String!
+        did: String!
+        name: String!
+        description: String!
+        endpoint: String
+        active: Boolean!
+        version: Int!
+        registeredAt: String!
+        updatedAt: String!
+        capabilities: [Capability!]!
+        totalTasksCompleted: Int!
+        totalTasksFailed: Int!
+        totalTasksDisputed: Int!
+        totalEarningsMist: String!
+        hasStake: Boolean!
+        stakeMist: String
+        stakeType: String
+        categories: [String!]!
+        reputation: AgentReputation!
+      }
+
+      type TaskTransition {
+        eventType: String!
+        status: TaskStatus!
+        txDigest: String!
+        timestampMs: String!
+      }
+
+      type Task {
+        id: ID!
+        requester: String!
+        provider: String
+        capability: String!
+        category: String!
+        inputBlobId: String!
+        resultBlobId: String
+        price: String!
+        paymentScheme: PaymentScheme
+        maxPrice: String
+        meteredUnits: Int
+        unitPrice: String
+        verificationHash: String
+        status: TaskStatus!
+        disputeWindowMs: Int!
+        createdAt: String!
+        acceptedAt: String
+        completedAt: String
+        releasedAt: String
+        disputedAt: String
+        cancelledAt: String
+        expiresAt: String!
+        agreementHash: String
+        bidCount: Int!
+        gasCostMistTotal: String!
+        transitions: [TaskTransition!]!
+      }
+
+      type Bid {
+        id: ID!
+        taskId: String!
+        bidder: String!
+        bidPrice: String!
+        reputationScore: String!
+        evidenceBlob: String
+        createdAt: String!
+        status: BidStatus!
+      }
+
+      type Dispute {
+        id: ID!
+        taskId: String!
+        requester: String!
+        provider: String!
+        escrowAmount: String!
+        status: DisputeStatus!
+        requesterEvidenceBlob: String!
+        providerEvidenceBlob: String
+        requesterProposedSplit: String!
+        providerProposedSplit: String!
+        arbitrator: String
+        rulingSplit: String!
+        openedAt: String!
+        respondedAt: String
+        resolvedAt: String
+        resolutionDeadline: String!
+      }
+
+      type GasCostStat {
+        capability: String!
+        averageGasMist: String!
+        taskCount: Int!
+      }
+
+      type CategoryStat {
+        category: String!
+        taskCount: Int!
+      }
+
+      type MarketplaceStats {
+        averageBidCount: Float!
+        acceptanceRate: Float!
+        categoryPopularity: [CategoryStat!]!
+      }
+
+      type Analytics {
+        totalAgents: Int!
+        activeAgents: Int!
+        totalTasks: Int!
+        completedTasks: Int!
+        disputedTasks: Int!
+        totalVolumeMist: String!
+        averageGasCosts: [GasCostStat!]!
+        marketplace: MarketplaceStats!
+      }
+
+      type TimeBucket {
+        label: String!
+        count: Int!
+        volumeMist: String!
+      }
+
+      type ProviderStats {
+        did: String!
+        owner: String!
+        name: String!
+        completedTasks: Int!
+        earningsMist: String!
+        disputeCount: Int!
+        successRate: Float!
+        reputation: Float!
+      }
+
+      type Query {
+        agents(capability: String, minReputation: Float, category: String, limit: Int, offset: Int): AgentConnection!
+        agent(did: String!): Agent
+        tasks(status: TaskStatus, requester: String, provider: String, category: String, after: String, limit: Int): TaskConnection!
+        task(id: String!): Task
+        bids(taskId: String!, status: BidStatus): [Bid!]!
+        disputes(status: DisputeStatus, agent: String): [Dispute!]!
+        analytics: Analytics!
+        taskVolume(period: TimePeriod!, buckets: Int): [TimeBucket!]!
+        topProviders(limit: Int, sortBy: ProviderSortField): [ProviderStats!]!
+      }
+    `
+    ),
+    resolvers: {
+      TaskStatus: {
+        OPEN: TaskStatus2.OPEN,
+        ACCEPTED: TaskStatus2.ACCEPTED,
+        COMPLETED: TaskStatus2.COMPLETED,
+        RELEASED: TaskStatus2.RELEASED,
+        DISPUTED: TaskStatus2.DISPUTED,
+        CANCELLED: TaskStatus2.CANCELLED
+      },
+      BidStatus: {
+        ACTIVE: BidStatus3.ACTIVE,
+        ACCEPTED: BidStatus3.ACCEPTED,
+        REJECTED: BidStatus3.REJECTED,
+        WITHDRAWN: BidStatus3.WITHDRAWN
+      },
+      PaymentScheme: {
+        EXACT: PaymentScheme2.EXACT,
+        UPTO: PaymentScheme2.UPTO,
+        STREAM: PaymentScheme2.STREAM
+      },
+      DisputeStatus: {
+        OPEN: DisputeStatus2.OPEN,
+        RESPONDED: DisputeStatus2.RESPONDED,
+        MUTUAL_RESOLVED: DisputeStatus2.MUTUAL_RESOLVED,
+        ARBITRATED: DisputeStatus2.ARBITRATED,
+        EXPIRED: DisputeStatus2.EXPIRED
+      },
+      TimePeriod: {
+        HOUR: "hour",
+        DAY: "day",
+        WEEK: "week"
+      },
+      ProviderSortField: {
+        COMPLETED_TASKS: "completedTasks",
+        EARNINGS: "earnings",
+        REPUTATION: "reputation"
+      },
+      Query: {
+        agents: (_root, args) => {
+          const limit = normalizeLimit2(args.limit, 20);
+          const offset = normalizeOffset2(args.offset);
+          const capability = trimOptional(args.capability);
+          const category = trimOptional(args.category);
+          const nodes = options.store.queryAgents({
+            capability,
+            minReputation: normalizeOptionalFloat(args.minReputation, "minReputation"),
+            category,
+            limit,
+            offset,
+            sortBy: "reputation"
+          });
+          const totalCount = options.store.countAgents({
+            capability,
+            minReputation: normalizeOptionalFloat(args.minReputation, "minReputation"),
+            category,
+            sortBy: "reputation"
+          });
+          return {
+            nodes,
+            totalCount,
+            pageInfo: {
+              hasNextPage: offset + nodes.length < totalCount,
+              endCursor: nodes.length > 0 ? Buffer.from(String(offset + nodes.length)).toString("base64url") : null
+            }
+          };
+        },
+        agent: (_root, args) => options.store.getAgentByDid(requireNonEmpty(args.did, "did")),
+        tasks: (_root, args) => {
+          const limit = normalizeLimit2(args.limit, 20);
+          const rows = options.store.queryTasks({
+            status: args.status,
+            requester: trimOptional(args.requester),
+            provider: trimOptional(args.provider),
+            category: trimOptional(args.category),
+            after: trimOptional(args.after),
+            limit: limit + 1
+          });
+          const nodes = rows.slice(0, limit);
+          const endCursor = nodes.length > 0 ? encodeCursor(nodes[nodes.length - 1]) : null;
+          return {
+            nodes,
+            pageInfo: {
+              hasNextPage: rows.length > limit,
+              endCursor
+            }
+          };
+        },
+        task: (_root, args) => options.store.getTask(requireNonEmpty(args.id, "id")),
+        bids: (_root, args) => options.store.getBids(requireNonEmpty(args.taskId, "taskId"), args.status),
+        disputes: (_root, args) => options.store.getDisputes({ status: args.status, agent: trimOptional(args.agent) }),
+        analytics: () => analytics.getSummary(),
+        taskVolume: (_root, args) => analytics.getTaskVolume(args.period, args.buckets),
+        topProviders: (_root, args) => analytics.getTopProviders(normalizeLimit2(args.limit, 10), args.sortBy)
+      },
+      Agent: {
+        registeredAt: (agent) => String(agent.registeredAt),
+        updatedAt: (agent) => String(agent.updatedAt),
+        totalTasksCompleted: (agent) => agent.totalTasksCompleted ?? 0,
+        totalTasksFailed: (agent) => agent.totalTasksFailed ?? 0,
+        totalTasksDisputed: (agent) => agent.totalTasksDisputed ?? 0,
+        totalEarningsMist: (agent) => (agent.totalEarningsMist ?? 0n).toString(),
+        hasStake: (agent) => Boolean(agent.hasStake),
+        stakeMist: (agent) => agent.stakeMist?.toString() ?? null,
+        categories: (agent) => listAgentCategories(options.store, agent.owner),
+        reputation: (agent) => buildAgentReputation(agent)
+      },
+      Capability: {
+        paymentRails: (capability) => capability.paymentRails ?? []
+      },
+      PricingInfo: {
+        amount: (pricing) => pricing.amount.toString()
+      },
+      Task: {
+        price: (task) => task.price.toString(),
+        maxPrice: (task) => task.maxPrice?.toString() ?? null,
+        meteredUnits: (task) => task.meteredUnits ?? null,
+        unitPrice: (task) => task.unitPrice?.toString() ?? null,
+        verificationHash: (task) => task.verificationHash ?? null,
+        createdAt: (task) => String(task.createdAt),
+        acceptedAt: (task) => nullableString(task.acceptedAt),
+        completedAt: (task) => nullableString(task.completedAt),
+        releasedAt: (task) => nullableString(task.releasedAt),
+        disputedAt: (task) => nullableString(task.disputedAt),
+        cancelledAt: (task) => nullableString(task.cancelledAt),
+        expiresAt: (task) => String(task.expiresAt),
+        gasCostMistTotal: (task) => task.gasCostMistTotal.toString(),
+        transitions: (task) => task.transitions ?? options.store.getTaskTransitions(task.id)
+      },
+      TaskTransition: {
+        timestampMs: (transition) => String(transition.timestampMs)
+      },
+      Bid: {
+        taskId: (bid) => bid.taskId,
+        bidPrice: (bid) => bid.bidPrice.toString(),
+        reputationScore: (bid) => bid.reputationScore.toString(),
+        createdAt: (bid) => String(bid.createdAt)
+      },
+      Dispute: {
+        taskId: (dispute) => dispute.taskId,
+        escrowAmount: (dispute) => dispute.escrowAmount.toString(),
+        requesterProposedSplit: (dispute) => dispute.requesterProposedSplit.toString(),
+        providerProposedSplit: (dispute) => dispute.providerProposedSplit.toString(),
+        rulingSplit: (dispute) => dispute.rulingSplit.toString(),
+        openedAt: (dispute) => String(dispute.openedAt),
+        respondedAt: (dispute) => nullableString(dispute.respondedAt),
+        resolvedAt: (dispute) => nullableString(dispute.resolvedAt),
+        resolutionDeadline: (dispute) => String(dispute.resolutionDeadline)
+      },
+      GasCostStat: {
+        averageGasMist: (row) => row.averageGasMist.toString()
+      },
+      Analytics: {
+        totalVolumeMist: (summary) => summary.totalVolumeMist.toString()
+      },
+      TimeBucket: {
+        volumeMist: (bucket) => bucket.volumeMist.toString()
+      },
+      ProviderStats: {
+        earningsMist: (row) => row.earningsMist.toString()
+      }
+    }
+  });
+  const yoga = createYoga({
+    schema,
+    graphqlEndpoint: "/graphql",
+    maskedErrors: true
+  });
+  const server = createServer(yoga);
+  return {
+    schema,
+    server,
+    fetch: yoga.fetch.bind(yoga),
+    start: async () => await startServer(server, options.host ?? "0.0.0.0", options.port ?? 4e3, options.logger),
+    stop: async () => {
+      if (!server.listening) {
+        return;
+      }
+      await new Promise((resolvePromise, reject) => {
+        server.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolvePromise();
+        });
+      });
+    }
+  };
+}
+function listAgentCategories(store, owner) {
+  const rows = store.getDatabase().prepare("SELECT DISTINCT category FROM tasks WHERE provider = ? ORDER BY category ASC").all(owner);
+  return rows.map((row) => row.category);
+}
+function buildAgentReputation(agent) {
+  const completed = agent.totalTasksCompleted ?? 0;
+  const failed = agent.totalTasksFailed ?? 0;
+  const totalTasks = completed + failed;
+  return {
+    successRate: totalTasks === 0 ? 0 : completed / totalTasks,
+    totalTasks,
+    totalDisputes: agent.totalTasksDisputed ?? 0,
+    totalEarningsMist: (agent.totalEarningsMist ?? 0n).toString(),
+    stakeAmountMist: (agent.stakeMist ?? 0n).toString()
+  };
+}
+function nullableString(value) {
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : null;
+}
+async function startServer(server, host, port, logger2) {
+  const address = await new Promise((resolvePromise, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => {
+      server.off("error", reject);
+      const boundAddress = server.address();
+      const resolvedPort = typeof boundAddress === "object" && boundAddress ? boundAddress.port : port;
+      resolvePromise(`http://${host}:${resolvedPort}/graphql`);
+    });
+  });
+  logger2?.info?.({ address }, "Indexer GraphQL server started");
+  return address;
+}
+function normalizeLimit2(limit, fallback) {
+  return typeof limit === "number" && Number.isFinite(limit) ? Math.min(MAX_PAGE_SIZE, Math.max(1, Math.floor(limit))) : Math.min(MAX_PAGE_SIZE, fallback);
+}
+function normalizeOffset2(offset) {
+  return typeof offset === "number" && Number.isFinite(offset) ? Math.max(0, Math.floor(offset)) : 0;
+}
+function normalizeOptionalFloat(value, field) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`${field} must be a non-negative finite number.`);
+  }
+  return value;
+}
+function trimOptional(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+function requireNonEmpty(value, field) {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`${field} must be a non-empty string.`);
+  }
+  return normalized;
+}
+
+// src/indexer.ts
+import pino from "pino";
+import { parseRawEvent } from "@hivemind-os/collective-core";
+import { DisputeStatus as DisputeStatus3, TaskStatus as TaskStatus3 } from "@hivemind-os/collective-types";
+var logger = pino({ name: "@hivemind-os/collective-indexer" });
+var EVENT_NAMES = {
+  agentRegistered: "registry::AgentRegistered",
+  agentUpdated: "registry::AgentUpdated",
+  agentDeactivated: "registry::AgentDeactivated",
+  taskPosted: "task::TaskPosted",
+  taskAccepted: "task::TaskAccepted",
+  taskCompleted: "task::TaskCompleted",
+  taskReleased: "task::TaskPaymentReleased",
+  taskDisputed: "task::TaskDisputed",
+  taskCancelled: "task::TaskCancelled",
+  taskExpiredRefunded: "task::TaskExpiredRefunded",
+  bidPlaced: "marketplace::BidPlaced",
+  bidAccepted: "marketplace::BidAccepted",
+  bidWithdrawn: "marketplace::BidWithdrawn",
+  bidRejected: "marketplace::BidRejected",
+  disputeOpened: "dispute::DisputeOpened",
+  disputeResponded: "dispute::DisputeResponded",
+  disputeMutuallyResolved: "dispute::DisputeMutuallyResolved",
+  disputeArbitrated: "dispute::DisputeArbitrated",
+  disputeExpired: "dispute::DisputeExpired",
+  stakeDeposited: "staking::StakeDeposited",
+  stakeWithdrawn: "staking::StakeWithdrawn",
+  stakeSlashed: "staking::StakeSlashed",
+  deactivationStarted: "staking::DeactivationStarted",
+  anchorPublished: "reputation::AnchorPublished"
+};
+var SUPPORTED_EVENT_TYPES = Object.values(EVENT_NAMES);
+var MeshIndexer = class {
+  constructor(options) {
+    this.options = options;
+    this.logger = options.logger ?? logger;
+  }
+  options;
+  logger;
+  txMetadataCache = /* @__PURE__ */ new Map();
+  running = false;
+  timer;
+  pollLoopPromise;
+  start() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    this.pollLoopPromise = this.pollLoop().finally(() => {
+      this.pollLoopPromise = void 0;
+    });
+  }
+  async stop() {
+    this.running = false;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    await this.pollLoopPromise?.catch(() => void 0);
+  }
+  isRunning() {
+    return this.running;
+  }
+  async backfill(fromCheckpoint = this.options.startCheckpoint) {
+    return await this.indexAllStreams(fromCheckpoint);
+  }
+  async pollOnce() {
+    return await this.indexAllStreams(this.options.startCheckpoint);
+  }
+  async processEvent(rawEvent, metadata) {
+    const txMetadata = metadata ?? await this.getTransactionMetadata(rawEvent.id.txDigest);
+    const wasInserted = this.options.store.recordEvent({
+      eventId: formatEventId(rawEvent),
+      eventType: rawEvent.type,
+      packageId: this.options.packageId,
+      txDigest: rawEvent.id.txDigest,
+      timestampMs: readNumber2(rawEvent.timestampMs),
+      payload: normalizeMoveValue(rawEvent.parsedJson),
+      checkpoint: txMetadata.checkpoint,
+      module: rawEvent.transactionModule
+    });
+    if (!wasInserted) {
+      return;
+    }
+    const parsed = parseRawEvent(rawEvent, this.options.packageId);
+    if (parsed) {
+      this.handleParsedEvent(parsed, txMetadata);
+      return;
+    }
+    const extended = await this.parseExtendedEvent(rawEvent);
+    if (extended) {
+      this.handleExtendedEvent(extended, txMetadata);
+    }
+  }
+  async pollLoop() {
+    if (!this.running) {
+      return;
+    }
+    let nextDelay = this.options.pollIntervalMs ?? 5e3;
+    try {
+      const processed = await this.pollOnce();
+      if (processed > 0) {
+        nextDelay = 0;
+      }
+    } catch (error) {
+      this.logger.error({ err: error }, "Indexer polling failed.");
+    }
+    if (this.running) {
+      this.timer = setTimeout(() => {
+        void this.pollLoop();
+      }, nextDelay);
+    }
+  }
+  async indexAllStreams(fromCheckpoint) {
+    let processed = 0;
+    for (const suffix of SUPPORTED_EVENT_TYPES) {
+      processed += await this.indexEventType(`${this.options.packageId}::${suffix}`, fromCheckpoint);
+    }
+    return processed;
+  }
+  async indexEventType(eventType, fromCheckpoint) {
+    const cursorKey = `event:${eventType}`;
+    let cursor = this.options.store.getCursor(cursorKey);
+    let processed = 0;
+    while (true) {
+      const page = await this.options.suiClient.queryEvents(eventType, cursor, 100);
+      for (const event of page.events) {
+        const metadata = await this.getTransactionMetadata(event.id.txDigest);
+        if (typeof fromCheckpoint === "number" && typeof metadata.checkpoint === "number" && metadata.checkpoint < fromCheckpoint) {
+          cursor = event.id;
+          this.options.store.setCursor(cursorKey, event.id);
+          continue;
+        }
+        await this.processEvent(event, metadata);
+        cursor = event.id;
+        this.options.store.setCursor(cursorKey, event.id);
+        processed += 1;
+      }
+      if (!page.hasMore || !page.nextCursor) {
+        break;
+      }
+      cursor = page.nextCursor;
+    }
+    return processed;
+  }
+  handleParsedEvent(event, metadata) {
+    switch (event.type) {
+      case "agent.registered":
+      case "agent.updated":
+        this.options.store.upsertAgent(event.agent);
+        break;
+      case "agent.deactivated":
+        this.options.store.markAgentInactive(event.agentId);
+        break;
+      case "task.posted":
+        this.options.store.upsertTask(event.task, event.txDigest, metadata.gasCostMist);
+        break;
+      case "task.accepted":
+        this.options.store.updateTaskStatus({
+          taskId: event.taskId,
+          status: event.status,
+          txDigest: event.txDigest,
+          timestampMs: event.acceptedAt,
+          provider: event.provider,
+          requester: event.requester,
+          price: event.price,
+          gasCostMist: metadata.gasCostMist,
+          eventType: event.type,
+          payload: event
+        });
+        break;
+      case "task.completed":
+        this.options.store.updateTaskStatus({
+          taskId: event.taskId,
+          status: event.status,
+          txDigest: event.txDigest,
+          timestampMs: event.completedAt,
+          provider: event.provider,
+          resultBlobId: event.resultBlobId,
+          price: event.price,
+          paymentScheme: event.paymentScheme,
+          meteredUnits: event.meteredUnits,
+          verificationHash: event.verificationHash,
+          gasCostMist: metadata.gasCostMist,
+          eventType: event.type,
+          payload: event
+        });
+        break;
+      case "task.released":
+        this.options.store.updateTaskStatus({
+          taskId: event.taskId,
+          status: event.status,
+          txDigest: event.txDigest,
+          timestampMs: event.releasedAt,
+          provider: event.provider,
+          requester: event.requester,
+          price: event.price,
+          gasCostMist: metadata.gasCostMist,
+          eventType: event.type,
+          payload: event
+        });
+        break;
+      case "task.disputed":
+        this.options.store.updateTaskStatus({
+          taskId: event.taskId,
+          status: event.status,
+          txDigest: event.txDigest,
+          timestampMs: event.disputedAt,
+          provider: event.provider,
+          requester: event.requester,
+          gasCostMist: metadata.gasCostMist,
+          eventType: event.type,
+          payload: event
+        });
+        break;
+      case "task.cancelled":
+        this.options.store.updateTaskStatus({
+          taskId: event.taskId,
+          status: event.status,
+          txDigest: event.txDigest,
+          timestampMs: event.cancelledAt,
+          requester: event.requester,
+          gasCostMist: metadata.gasCostMist,
+          eventType: event.type,
+          payload: event
+        });
+        break;
+      case "bid.placed":
+        this.options.store.upsertBid(event.bid);
+        break;
+      case "bid.accepted":
+        this.options.store.updateBidStatus(event.bidId, event.status, event.acceptedAt);
+        break;
+      case "bid.withdrawn":
+        this.options.store.updateBidStatus(event.bidId, event.status, event.withdrawnAt);
+        break;
+      case "bid.rejected":
+        this.options.store.updateBidStatus(event.bidId, event.status, event.rejectedAt);
+        break;
+      default:
+        break;
+    }
+  }
+  handleExtendedEvent(event, metadata) {
+    switch (event.type) {
+      case "dispute.opened":
+        this.options.store.upsertDispute(event.dispute);
+        break;
+      case "dispute.updated": {
+        const dispute = event.dispute;
+        if (dispute) {
+          this.options.store.upsertDispute(dispute);
+        } else {
+          this.options.store.updateDispute({
+            disputeId: event.disputeId,
+            status: event.status,
+            respondedAt: event.status === DisputeStatus3.RESPONDED ? event.timestampMs : void 0,
+            resolvedAt: event.status !== DisputeStatus3.RESPONDED ? event.timestampMs : void 0,
+            providerEvidenceBlob: event.providerEvidenceBlob,
+            providerProposedSplit: event.providerProposedSplit,
+            arbitrator: event.arbitrator,
+            rulingSplit: event.rulingSplit
+          });
+        }
+        if (event.status !== DisputeStatus3.RESPONDED) {
+          const taskId = dispute?.taskId;
+          if (taskId) {
+            this.options.store.updateTaskStatus({
+              taskId,
+              status: TaskStatus3.RELEASED,
+              txDigest: event.txDigest,
+              timestampMs: event.timestampMs,
+              requester: dispute.requester,
+              provider: dispute.provider,
+              gasCostMist: metadata.gasCostMist,
+              eventType: `task.released_after_${event.type}`,
+              payload: event
+            });
+          }
+        }
+        break;
+      }
+      case "stake.deposited":
+        this.options.store.upsertStake({
+          stakeId: event.stakeId,
+          owner: event.owner,
+          amountMist: event.amountMist,
+          stakeType: event.stakeType,
+          stakedAt: event.timestampMs,
+          active: true
+        });
+        break;
+      case "stake.withdrawn":
+        this.options.store.upsertStake({
+          stakeId: event.stakeId,
+          owner: event.owner,
+          amountMist: 0n,
+          withdrawnAt: event.timestampMs,
+          active: false
+        });
+        break;
+      case "stake.slashed":
+        this.options.store.addStakeSlash(event.stakeId, event.amountMist);
+        break;
+      case "stake.deactivation_started":
+        this.options.store.upsertStake({
+          stakeId: event.stakeId,
+          owner: event.owner,
+          deactivatedAt: event.timestampMs,
+          active: false
+        });
+        break;
+      case "reputation.anchor_published":
+        this.options.store.upsertReputationAnchor({
+          anchorId: event.anchor.anchorId,
+          author: event.anchor.author,
+          merkleRoot: event.anchor.merkleRoot,
+          eventCount: event.anchor.eventCount,
+          blobId: event.anchor.blobId,
+          fromTimestamp: event.anchor.fromTimestamp,
+          toTimestamp: event.anchor.toTimestamp,
+          createdAt: event.timestampMs,
+          txDigest: event.txDigest
+        });
+        break;
+      default:
+        break;
+    }
+  }
+  async parseExtendedEvent(rawEvent) {
+    const payload = toRecord(normalizeMoveValue(rawEvent.parsedJson)) ?? {};
+    const base = {
+      txDigest: rawEvent.id.txDigest,
+      timestampMs: readNumber2(rawEvent.timestampMs)
+    };
+    switch (rawEvent.type) {
+      case `${this.options.packageId}::${EVENT_NAMES.disputeOpened}`: {
+        const disputeId = readString(payload.dispute_id, payload.disputeId);
+        const dispute = await this.fetchDispute(disputeId) ?? buildFallbackDispute(payload, disputeId, base.timestampMs);
+        return { ...base, type: "dispute.opened", disputeId, dispute };
+      }
+      case `${this.options.packageId}::${EVENT_NAMES.disputeResponded}`: {
+        const disputeId = readString(payload.dispute_id, payload.disputeId);
+        return {
+          ...base,
+          type: "dispute.updated",
+          disputeId,
+          dispute: await this.fetchDispute(disputeId),
+          status: DisputeStatus3.RESPONDED,
+          providerEvidenceBlob: readBytes(payload.provider_evidence_blob, payload.providerEvidenceBlob)
+        };
+      }
+      case `${this.options.packageId}::${EVENT_NAMES.disputeMutuallyResolved}`: {
+        const disputeId = readString(payload.dispute_id, payload.disputeId);
+        return {
+          ...base,
+          type: "dispute.updated",
+          disputeId,
+          dispute: await this.fetchDispute(disputeId),
+          status: DisputeStatus3.MUTUAL_RESOLVED,
+          rulingSplit: readBigInt(payload.provider_amount, payload.providerAmount)
+        };
+      }
+      case `${this.options.packageId}::${EVENT_NAMES.disputeArbitrated}`: {
+        const disputeId = readString(payload.dispute_id, payload.disputeId);
+        return {
+          ...base,
+          type: "dispute.updated",
+          disputeId,
+          dispute: await this.fetchDispute(disputeId),
+          status: DisputeStatus3.ARBITRATED,
+          arbitrator: readString(payload.arbitrator),
+          rulingSplit: readBigInt(payload.provider_amount, payload.providerAmount)
+        };
+      }
+      case `${this.options.packageId}::${EVENT_NAMES.disputeExpired}`: {
+        const disputeId = readString(payload.dispute_id, payload.disputeId);
+        return {
+          ...base,
+          type: "dispute.updated",
+          disputeId,
+          dispute: await this.fetchDispute(disputeId),
+          status: DisputeStatus3.EXPIRED
+        };
+      }
+      case `${this.options.packageId}::${EVENT_NAMES.stakeDeposited}`:
+        return {
+          ...base,
+          type: "stake.deposited",
+          stakeId: readString(payload.stake_id, payload.stakeId),
+          owner: readString(payload.owner),
+          amountMist: readBigInt(payload.amount),
+          stakeType: normalizeStakeType(payload.stake_type, payload.stakeType)
+        };
+      case `${this.options.packageId}::${EVENT_NAMES.stakeWithdrawn}`:
+        return {
+          ...base,
+          type: "stake.withdrawn",
+          stakeId: readString(payload.stake_id, payload.stakeId),
+          owner: readString(payload.owner),
+          amountMist: readBigInt(payload.amount)
+        };
+      case `${this.options.packageId}::${EVENT_NAMES.stakeSlashed}`:
+        return {
+          ...base,
+          type: "stake.slashed",
+          stakeId: readString(payload.stake_id, payload.stakeId),
+          target: readString(payload.target),
+          amountMist: readBigInt(payload.amount),
+          taskId: readString(payload.task_id, payload.taskId)
+        };
+      case `${this.options.packageId}::${EVENT_NAMES.deactivationStarted}`:
+        return {
+          ...base,
+          type: "stake.deactivation_started",
+          stakeId: readString(payload.stake_id, payload.stakeId),
+          owner: readString(payload.owner),
+          cooldownEndsAt: readNumber2(payload.cooldown_ends_at, payload.cooldownEndsAt)
+        };
+      case `${this.options.packageId}::${EVENT_NAMES.anchorPublished}`: {
+        const anchorId = readString(payload.anchor_id, payload.anchorId);
+        const anchor = await this.fetchAnchor(anchorId) ?? {
+          anchorId,
+          author: readString(payload.author),
+          merkleRoot: readHex(payload.merkle_root, payload.merkleRoot),
+          eventCount: readNumber2(payload.event_count, payload.eventCount),
+          blobId: "",
+          fromTimestamp: 0,
+          toTimestamp: 0
+        };
+        return { ...base, type: "reputation.anchor_published", anchor };
+      }
+      default:
+        return null;
+    }
+  }
+  async getTransactionMetadata(txDigest) {
+    const cached = this.txMetadataCache.get(txDigest);
+    if (cached) {
+      return await cached;
+    }
+    const pending = this.loadTransactionMetadata(txDigest);
+    this.txMetadataCache.set(txDigest, pending);
+    pending.finally(() => {
+      if (this.txMetadataCache.get(txDigest) === pending) {
+        this.txMetadataCache.delete(txDigest);
+      }
+    });
+    return await pending;
+  }
+  async loadTransactionMetadata(txDigest) {
+    try {
+      const response = await this.options.suiClient.client.getTransactionBlock({
+        digest: txDigest,
+        options: { showEffects: true }
+      });
+      return {
+        checkpoint: response.checkpoint == null ? void 0 : Number(response.checkpoint),
+        gasCostMist: computeGasCost(response)
+      };
+    } catch (error) {
+      this.logger.warn({ err: error, txDigest }, "Failed to load transaction metadata.");
+      return { gasCostMist: 0n };
+    }
+  }
+  async fetchDispute(disputeId) {
+    if (!disputeId) {
+      return void 0;
+    }
+    try {
+      const object = await this.options.suiClient.getObject(disputeId);
+      return parseDisputeObject(object, disputeId);
+    } catch {
+      return void 0;
+    }
+  }
+  async fetchAnchor(anchorId) {
+    if (!anchorId) {
+      return void 0;
+    }
+    try {
+      const object = await this.options.suiClient.getObject(anchorId);
+      return {
+        anchorId,
+        author: readString(object.author),
+        merkleRoot: readHex(object.merkle_root, object.merkleRoot),
+        eventCount: readNumber2(object.event_count, object.eventCount),
+        blobId: readBytes(object.blob_id, object.blobId),
+        fromTimestamp: readNumber2(object.from_timestamp, object.fromTimestamp),
+        toTimestamp: readNumber2(object.to_timestamp, object.toTimestamp)
+      };
+    } catch {
+      return void 0;
+    }
+  }
+};
+function buildFallbackDispute(payload, disputeId, timestampMs) {
+  return {
+    id: disputeId,
+    taskId: readString(payload.task_id, payload.taskId),
+    requester: readString(payload.requester),
+    provider: readString(payload.provider),
+    escrowAmount: readBigInt(payload.escrow_amount, payload.escrowAmount),
+    status: DisputeStatus3.OPEN,
+    requesterEvidenceBlob: "",
+    providerEvidenceBlob: void 0,
+    requesterProposedSplit: 0n,
+    providerProposedSplit: 0n,
+    arbitrator: void 0,
+    rulingSplit: 0n,
+    openedAt: timestampMs,
+    respondedAt: void 0,
+    resolvedAt: void 0,
+    resolutionDeadline: timestampMs
+  };
+}
+function parseDisputeObject(object, disputeId) {
+  const respondedAt = readNumber2(object.responded_at, object.respondedAt);
+  const resolvedAt = readNumber2(object.resolved_at, object.resolvedAt);
+  return {
+    id: disputeId,
+    taskId: readString(object.task_id, object.taskId),
+    requester: readString(object.requester),
+    provider: readString(object.provider),
+    escrowAmount: readBigInt(object.escrow_amount, object.escrowAmount),
+    status: readNumber2(object.status),
+    requesterEvidenceBlob: readBytes(object.requester_evidence_blob, object.requesterEvidenceBlob),
+    providerEvidenceBlob: readBytes(object.provider_evidence_blob, object.providerEvidenceBlob) || void 0,
+    requesterProposedSplit: readBigInt(object.requester_proposed_split, object.requesterProposedSplit),
+    providerProposedSplit: readBigInt(object.provider_proposed_split, object.providerProposedSplit),
+    arbitrator: readString(object.arbitrator) || void 0,
+    rulingSplit: readBigInt(object.ruling_split, object.rulingSplit),
+    openedAt: readNumber2(object.opened_at, object.openedAt),
+    respondedAt: respondedAt > 0 ? respondedAt : void 0,
+    resolvedAt: resolvedAt > 0 ? resolvedAt : void 0,
+    resolutionDeadline: readNumber2(object.resolution_deadline, object.resolutionDeadline)
+  };
+}
+function formatEventId(event) {
+  return `${event.id.txDigest}:${event.id.eventSeq}`;
+}
+function computeGasCost(response) {
+  const gasUsed = response.effects?.gasUsed;
+  if (!gasUsed) {
+    return 0n;
+  }
+  const computationCost = readBigInt(gasUsed.computationCost);
+  const storageCost = readBigInt(gasUsed.storageCost);
+  const storageRebate = readBigInt(gasUsed.storageRebate);
+  const nonRefundable = readBigInt(gasUsed.nonRefundableStorageFee);
+  const total = computationCost + storageCost + nonRefundable - storageRebate;
+  return total > 0n ? total : 0n;
+}
+function normalizeMoveValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeMoveValue(entry));
+  }
+  if (!toRecord(value)) {
+    return value;
+  }
+  if (typeof value.id === "string" && Object.keys(value).length === 1) {
+    return value.id;
+  }
+  if (toRecord(value.fields)) {
+    return normalizeMoveValue(value.fields);
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [key, normalizeMoveValue(entry)])
+  );
+}
+function toRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function readString(...values) {
+  const match = values.find((value) => typeof value === "string");
+  return typeof match === "string" ? match : "";
+}
+function readBytes(...values) {
+  for (const value of values) {
+    if (typeof value === "string") {
+      return value;
+    }
+    if (value instanceof Uint8Array) {
+      return new TextDecoder().decode(value);
+    }
+    if (Array.isArray(value) && value.every((entry) => typeof entry === "number")) {
+      return new TextDecoder().decode(new Uint8Array(value));
+    }
+  }
+  return "";
+}
+function readHex(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && /^[a-f0-9]+$/i.test(value)) {
+      return value;
+    }
+    if (value instanceof Uint8Array) {
+      return Buffer.from(value).toString("hex");
+    }
+    if (Array.isArray(value) && value.every((entry) => typeof entry === "number")) {
+      return Buffer.from(value).toString("hex");
+    }
+  }
+  return "";
+}
+function readNumber2(...values) {
+  for (const value of values) {
+    if (typeof value === "number") {
+      return value;
+    }
+    if (typeof value === "bigint") {
+      return Number(value);
+    }
+    if (typeof value === "string" && value.length > 0) {
+      return Number(value);
+    }
+  }
+  return 0;
+}
+function readBigInt(...values) {
+  for (const value of values) {
+    if (typeof value === "bigint") {
+      return value;
+    }
+    if (typeof value === "number") {
+      return BigInt(value);
+    }
+    if (typeof value === "string" && value.length > 0) {
+      return BigInt(value);
+    }
+  }
+  return 0n;
+}
+function normalizeStakeType(...values) {
+  const value = values.find((entry) => entry !== void 0);
+  if (value === "agent" || value === 0 || value === "0") {
+    return "agent";
+  }
+  if (value === "relay" || value === 1 || value === "1") {
+    return "relay";
+  }
+  return void 0;
+}
+
+// src/index.ts
+async function startIndexerService() {
+  const config = loadIndexerConfig();
+  const logger2 = pino2({ name: "@hivemind-os/collective-indexer", level: "info" });
+  await mkdir(dirname(config.sqlitePath), { recursive: true });
+  const store = new IndexerStore(config.sqlitePath);
+  const analytics = new AnalyticsEngine(store);
+  const suiClient = new MeshSuiClient2({
+    rpcUrl: config.rpcUrl,
+    faucetUrl: "",
+    packageId: config.packageId,
+    registryId: ""
+  });
+  const indexer = new MeshIndexer({
+    suiClient,
+    store,
+    packageId: config.packageId,
+    pollIntervalMs: config.pollingIntervalMs,
+    startCheckpoint: config.backfill.fromCheckpoint,
+    logger: logger2
+  });
+  const graphql = createIndexerGraphQLServer({
+    store,
+    analytics,
+    host: config.server.host,
+    port: config.server.port,
+    logger: logger2
+  });
+  await indexer.backfill(config.backfill.fromCheckpoint);
+  indexer.start();
+  const address = await graphql.start();
+  const stop = async () => {
+    await indexer.stop();
+    await graphql.stop();
+    store.close();
+  };
+  return {
+    config,
+    store,
+    analytics,
+    indexer,
+    graphql,
+    address,
+    stop
+  };
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  try {
+    const service = await startIndexerService();
+    console.log(service.address);
+    const shutdown = async () => {
+      await service.stop();
+      process.exit(0);
+    };
+    process.once("SIGINT", () => {
+      void shutdown();
+    });
+    process.once("SIGTERM", () => {
+      void shutdown();
+    });
+  } catch (error) {
+    console.error(error);
+    process.exitCode = 1;
+  }
+}
+export {
+  AnalyticsEngine,
+  IndexerStore,
+  MeshIndexer,
+  SUPPORTED_EVENT_TYPES,
+  createIndexerGraphQLServer,
+  encodeCursor,
+  getDefaultIndexerConfig,
+  loadIndexerConfig,
+  startIndexerService,
+  validateIndexerConfig
+};
+//# sourceMappingURL=index.js.map