@hivemind-os/collective-indexer 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,287 @@
+import Database from 'better-sqlite3';
+import { AgentCard, Task, TaskStatus, Bid, BidStatus, Dispute, DisputeStatus } from '@hivemind-os/collective-types';
+import pino from 'pino';
+import { MeshSuiClient } from '@hivemind-os/collective-core';
+import { SuiEvent } from '@mysten/sui/client';
+import { Server } from 'node:http';
+import { createSchema } from 'graphql-yoga';
+
+interface IndexerConfig {
+    rpcUrl: string;
+    packageId: string;
+    sqlitePath: string;
+    pollingIntervalMs: number;
+    server: {
+        host: string;
+        port: number;
+    };
+    backfill: {
+        fromCheckpoint?: number;
+    };
+}
+declare function getDefaultIndexerConfig(baseDir?: string): IndexerConfig;
+declare function loadIndexerConfig(overrides?: Partial<IndexerConfig>): IndexerConfig;
+declare function validateIndexerConfig(config: IndexerConfig): void;
+
+interface AgentQueryFilters {
+    capability?: string;
+    minReputation?: number;
+    category?: string;
+    search?: string;
+    limit?: number;
+    offset?: number;
+    sortBy?: 'stake' | 'reputation';
+    activeOnly?: boolean;
+}
+interface TaskQueryFilters {
+    status?: TaskStatus;
+    requester?: string;
+    provider?: string;
+    category?: string;
+    after?: string;
+    limit?: number;
+}
+interface DisputeQueryFilters {
+    status?: DisputeStatus;
+    agent?: string;
+}
+interface StoredEvent {
+    eventId: string;
+    eventType: string;
+    packageId: string;
+    txDigest: string;
+    timestampMs: number;
+    payload: unknown;
+    checkpoint?: number;
+    module?: string;
+}
+interface IndexedTaskTransition {
+    taskId: string;
+    eventType: string;
+    status: TaskStatus;
+    txDigest: string;
+    timestampMs: number;
+    payload: Record<string, unknown>;
+}
+interface IndexedTask extends Task {
+    releasedAt?: number;
+    disputedAt?: number;
+    cancelledAt?: number;
+    bidCount: number;
+    gasCostMistTotal: bigint;
+    transitions?: IndexedTaskTransition[];
+}
+interface ProviderStatsRecord {
+    did: string;
+    owner: string;
+    name: string;
+    completedTasks: number;
+    earningsMist: bigint;
+    disputeCount: number;
+    successRate: number;
+    reputation: number;
+}
+declare class IndexerStore {
+    readonly db: Database.Database;
+    private readonly scoreCalculator;
+    constructor(dbPath: string);
+    close(): void;
+    getCursor(streamKey: string): {
+        txDigest: string;
+        eventSeq: string;
+    } | null;
+    setCursor(streamKey: string, cursor: {
+        txDigest: string;
+        eventSeq: string;
+    }): void;
+    recordEvent(event: StoredEvent): boolean;
+    upsertAgent(agent: AgentCard): void;
+    markAgentInactive(agentId: string): void;
+    getAgentByDid(did: string): AgentCard | null;
+    queryAgents(filters?: AgentQueryFilters): AgentCard[];
+    countAgents(filters?: AgentQueryFilters): number;
+    upsertTask(task: Task, txDigest: string, gasCostMist?: bigint): void;
+    updateTaskStatus(params: {
+        taskId: string;
+        status: TaskStatus;
+        txDigest: string;
+        timestampMs: number;
+        provider?: string;
+        requester?: string;
+        resultBlobId?: string;
+        price?: bigint;
+        paymentScheme?: Task['paymentScheme'];
+        meteredUnits?: number;
+        maxPrice?: bigint;
+        unitPrice?: bigint;
+        verificationHash?: string;
+        gasCostMist?: bigint;
+        eventType: string;
+        payload: Record<string, unknown>;
+    }): void;
+    getTask(taskId: string, includeTransitions?: boolean): IndexedTask | null;
+    queryTasks(filters?: TaskQueryFilters): IndexedTask[];
+    getTaskTransitions(taskId: string): IndexedTaskTransition[];
+    upsertBid(bid: Bid): void;
+    updateBidStatus(bidId: string, status: BidStatus, timestampMs: number): void;
+    getBids(taskId: string, status?: BidStatus): Bid[];
+    upsertDispute(dispute: Dispute): void;
+    updateDispute(params: {
+        disputeId: string;
+        status: DisputeStatus;
+        respondedAt?: number;
+        resolvedAt?: number;
+        providerEvidenceBlob?: string;
+        providerProposedSplit?: bigint;
+        arbitrator?: string;
+        rulingSplit?: bigint;
+    }): void;
+    getDisputes(filters?: DisputeQueryFilters): Dispute[];
+    upsertStake(params: {
+        stakeId: string;
+        owner: string;
+        amountMist?: bigint;
+        stakeType?: 'agent' | 'relay';
+        stakedAt?: number;
+        deactivatedAt?: number;
+        withdrawnAt?: number;
+        slashedAmountMist?: bigint;
+        active?: boolean;
+    }): void;
+    addStakeSlash(stakeId: string, amountMist: bigint): void;
+    upsertReputationAnchor(params: {
+        anchorId: string;
+        author: string;
+        merkleRoot: string;
+        eventCount: number;
+        blobId?: string;
+        fromTimestamp?: number;
+        toTimestamp?: number;
+        createdAt: number;
+        txDigest: string;
+    }): void;
+    getDatabase(): Database.Database;
+    private recordTaskTransition;
+    private syncAgentStake;
+}
+declare function encodeCursor(task: Pick<Task, 'id' | 'createdAt'>): string;
+
+type TimePeriod = 'hour' | 'day' | 'week';
+type ProviderSortField = 'completedTasks' | 'earnings' | 'reputation';
+interface TimeBucket {
+    label: string;
+    count: number;
+    volumeMist: bigint;
+}
+interface GasCostStat {
+    capability: string;
+    averageGasMist: bigint;
+    taskCount: number;
+}
+interface CategoryPopularity {
+    category: string;
+    taskCount: number;
+}
+interface MarketplaceStats {
+    averageBidCount: number;
+    acceptanceRate: number;
+    categoryPopularity: CategoryPopularity[];
+}
+interface ReputationTrend {
+    label: string;
+    completed: number;
+    failed: number;
+    disputed: number;
+    successRate: number;
+}
+interface AnalyticsSummary {
+    totalAgents: number;
+    activeAgents: number;
+    totalTasks: number;
+    completedTasks: number;
+    disputedTasks: number;
+    totalVolumeMist: bigint;
+    averageGasCosts: GasCostStat[];
+    marketplace: MarketplaceStats;
+}
+declare class AnalyticsEngine {
+    private readonly store;
+    constructor(store: IndexerStore);
+    getSummary(): AnalyticsSummary;
+    getTaskVolume(period?: TimePeriod, buckets?: number): TimeBucket[];
+    getAverageGasCostsByTaskType(): GasCostStat[];
+    getMarketplaceStats(): MarketplaceStats;
+    getReputationTrends(agentDid: string, period?: TimePeriod, buckets?: number): ReputationTrend[];
+    getTopProviders(limit?: number, sortBy?: ProviderSortField): ProviderStatsRecord[];
+}
+
+declare const logger: pino.Logger<never, boolean>;
+declare const SUPPORTED_EVENT_TYPES: ("registry::AgentRegistered" | "registry::AgentUpdated" | "registry::AgentDeactivated" | "task::TaskPosted" | "task::TaskAccepted" | "task::TaskCompleted" | "task::TaskPaymentReleased" | "task::TaskDisputed" | "task::TaskCancelled" | "task::TaskExpiredRefunded" | "marketplace::BidPlaced" | "marketplace::BidAccepted" | "marketplace::BidWithdrawn" | "marketplace::BidRejected" | "dispute::DisputeOpened" | "dispute::DisputeResponded" | "dispute::DisputeMutuallyResolved" | "dispute::DisputeArbitrated" | "dispute::DisputeExpired" | "staking::StakeDeposited" | "staking::StakeWithdrawn" | "staking::StakeSlashed" | "staking::DeactivationStarted" | "reputation::AnchorPublished")[];
+interface TransactionMetadata {
+    checkpoint?: number;
+    gasCostMist: bigint;
+}
+interface MeshIndexerOptions {
+    suiClient: MeshSuiClient;
+    store: IndexerStore;
+    packageId: string;
+    pollIntervalMs?: number;
+    startCheckpoint?: number;
+    logger?: Pick<typeof logger, 'info' | 'warn' | 'error'>;
+}
+declare class MeshIndexer {
+    private readonly options;
+    private readonly logger;
+    private readonly txMetadataCache;
+    private running;
+    private timer?;
+    private pollLoopPromise?;
+    constructor(options: MeshIndexerOptions);
+    start(): void;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    backfill(fromCheckpoint?: number | undefined): Promise<number>;
+    pollOnce(): Promise<number>;
+    processEvent(rawEvent: SuiEvent, metadata?: TransactionMetadata): Promise<void>;
+    private pollLoop;
+    private indexAllStreams;
+    private indexEventType;
+    private handleParsedEvent;
+    private handleExtendedEvent;
+    private parseExtendedEvent;
+    private getTransactionMetadata;
+    private loadTransactionMetadata;
+    private fetchDispute;
+    private fetchAnchor;
+}
+
+interface IndexerGraphQLServerOptions {
+    store: IndexerStore;
+    analytics?: AnalyticsEngine;
+    host?: string;
+    port?: number;
+    logger?: {
+        info?: (payload: unknown, message?: string) => void;
+        warn?: (payload: unknown, message?: string) => void;
+    };
+}
+interface IndexerGraphQLServer {
+    schema: ReturnType<typeof createSchema>;
+    server: Server;
+    fetch: typeof fetch;
+    start: () => Promise<string>;
+    stop: () => Promise<void>;
+}
+declare function createIndexerGraphQLServer(options: IndexerGraphQLServerOptions): IndexerGraphQLServer;
+
+declare function startIndexerService(): Promise<{
+    config: IndexerConfig;
+    store: IndexerStore;
+    analytics: AnalyticsEngine;
+    indexer: MeshIndexer;
+    graphql: IndexerGraphQLServer;
+    address: string;
+    stop: () => Promise<void>;
+}>;
+
+export { type AgentQueryFilters, AnalyticsEngine, type AnalyticsSummary, type CategoryPopularity, type DisputeQueryFilters, type GasCostStat, type IndexedTask, type IndexedTaskTransition, type IndexerConfig, type IndexerGraphQLServer, type IndexerGraphQLServerOptions, IndexerStore, type MarketplaceStats, MeshIndexer, type MeshIndexerOptions, type ProviderSortField, type ProviderStatsRecord, type ReputationTrend, SUPPORTED_EVENT_TYPES, type StoredEvent, type TaskQueryFilters, type TimeBucket, type TimePeriod, createIndexerGraphQLServer, encodeCursor, getDefaultIndexerConfig, loadIndexerConfig, startIndexerService, validateIndexerConfig };