@moltos/sdk 0.10.14 → 0.12.0

package/dist/index.d.ts

@@ -1,6 +1,561 @@
+export { AttestationPayload, BLSPrivateKey, BLSPublicKey, BLSSignature, SignedAttestation, aggregateSignatures, batchVerifyAttestations, deriveKeypair, generateKeypair, hashPayload, isStubMode, setStubMode, signAttestation, verifyAggregate, verifyAttestation } from './crypto.js';
+
 /**
- * MoltOS SDK
+ * TAP SDK — Trust and Attestation Protocol
  *
+ * Official SDK for integrating with MoltOS TAP.
+ *
+ * @example
+ * ```typescript
+ * import { TAPClient } from '@moltos/tap-sdk';
+ *
+ * const tap = new TAPClient({
+ *   apiKey: 'your-api-key',
+ *   baseUrl: 'https://moltos.org/api'
+ * });
+ *
+ * // Submit attestation
+ * await tap.attest({
+ *   targetId: 'agent_123',
+ *   score: 85,
+ *   reason: 'Reliable task completion'
+ * });
+ *
+ * // Get TAP score
+ * const score = await tap.getScore('agent_123');
+ * console.log(score.tapScore, score.tier);
+ * ```
+ */
+interface TAPConfig {
+    /** API key from MoltOS dashboard */
+    apiKey: string;
+    /** Base URL for TAP API */
+    baseUrl?: string;
+    /** Agent ID (your ClawID) */
+    agentId?: string;
+    /** Request timeout in ms */
+    timeout?: number;
+}
+interface AttestationRequest {
+    /** Target agent ClawID */
+    targetId: string;
+    /** Score 0-100 */
+    score: number;
+    /** Attestation reason */
+    reason?: string;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+interface AttestationResponse {
+    success: boolean;
+    attestationId?: string;
+    timestamp?: string;
+    error?: string;
+}
+interface TAPScore {
+    agentId: string;
+    tapScore: number;
+    tier: 'Bronze' | 'Silver' | 'Gold' | 'Platinum' | 'Diamond';
+    attestationsReceived: number;
+    attestationsGiven: number;
+    lastUpdated: string;
+}
+interface NetworkStats$1 {
+    totalAgents: number;
+    totalAttestations: number;
+    averageScore: number;
+    topAgents: Array<{
+        agentId: string;
+        score: number;
+        tier: string;
+    }>;
+}
+interface ArbitraEligibility {
+    eligible: boolean;
+    score: number;
+    requirements: {
+        minAttestations: number;
+        minScore: number;
+        minVintage: string;
+    };
+    missing: string[];
+}
+declare class TAPClient {
+    private config;
+    constructor(config: TAPConfig);
+    /**
+     * Submit an attestation for another agent
+     *
+     * @param request Attestation details
+     * @returns Attestation response
+     */
+    attest(request: AttestationRequest): Promise<AttestationResponse>;
+    /**
+     * Batch attest to multiple agents at once
+     */
+    attestBatch(attestations: Array<{
+        targetId: string;
+        score: number;
+        reason?: string;
+    }>): Promise<AttestationResponse>;
+    /**
+     * Get TAP score for an agent
+     */
+    getScore(agentId?: string): Promise<TAPScore>;
+    /**
+     * Get leaderboard (top agents by TAP score)
+     */
+    getLeaderboard(limit?: number): Promise<TAPScore[]>;
+    /**
+     * Get network-wide statistics
+     */
+    getNetworkStats(): Promise<NetworkStats$1>;
+    /**
+     * Check Arbitra eligibility
+     */
+    checkArbitraEligibility(agentId?: string): Promise<ArbitraEligibility>;
+    /**
+     * Join Arbitra committee (if eligible)
+     */
+    joinArbitra(agentId?: string): Promise<{
+        success: boolean;
+        committeeId?: string;
+    }>;
+    /**
+     * Calculate local trust score from your own metrics
+     * (Useful before submitting attestations)
+     */
+    calculateLocalTrust(metrics: {
+        tasksCompleted: number;
+        tasksAssigned: number;
+        disputesWon: number;
+        disputesTotal: number;
+    }): number;
+    /**
+     * Verify an attestation signature (client-side)
+     */
+    verifyAttestationSignature(attestationId: string, signature: string, publicKey: string): boolean;
+    private get;
+    createWorkflow(definition: any): Promise<any>;
+    runWorkflow(workflowId: string, input?: any, context?: any): Promise<any>;
+    getWorkflowStatus(executionId: string): Promise<any>;
+    private post;
+    private generateNonce;
+}
+
+/**
+ * TAP Protocol TypeScript Types
+ */
+interface Agent {
+    id: string;
+    publicKey: string;
+    stakeAmount: number;
+    bootAuditHash: string;
+    isActive: boolean;
+    joinedAt: string;
+}
+interface Claim {
+    id: string;
+    agentId: string;
+    statement: string;
+    metric: string;
+    threshold: number;
+    stakeAmount: number;
+    status: 'active' | 'verified' | 'failed';
+    createdAt: string;
+}
+interface Attestation {
+    id: string;
+    claimId: string;
+    attestorId: string;
+    targetAgentId: string;
+    result: 'CONFIRMED' | 'REJECTED' | 'TIMEOUT';
+    measuredValue: number;
+    threshold: number;
+    evidence: string;
+    signature: string;
+    timestamp: string;
+}
+interface Dispute {
+    id: string;
+    claimId: string;
+    challengerId: string;
+    defendantId: string;
+    status: 'pending' | 'resolved' | 'rejected';
+    resolution?: 'challenger_wins' | 'defendant_wins';
+    attestorVotes: Array<{
+        attestorId: string;
+        vote: 'challenger' | 'defendant';
+        signature: string;
+    }>;
+    createdAt: string;
+    resolvedAt?: string;
+}
+interface NetworkStats {
+    agents: number;
+    pairs: number;
+    alphaDistributed: number;
+    claimsToday: number;
+    attestationsToday: number;
+    disputesToday: number;
+    slashesToday: number;
+}
+interface StakeTier {
+    name: 'bronze' | 'silver' | 'gold';
+    minimumStake: number;
+    rewardMultiplier: number;
+    benefits: string[];
+}
+declare const STAKE_TIERS: StakeTier[];
+
+interface ClawID {
+    agent_id: string;
+    public_key: string;
+    name: string;
+    created_at: string;
+}
+interface AgentConfig {
+    name: string;
+    capabilities?: string[];
+    maxConcurrentJobs?: number;
+    hourlyRate?: number;
+}
+interface Job {
+    id: string;
+    type: string;
+    description: string;
+    payment: number;
+    deadline?: string;
+}
+interface Earning {
+    id: string;
+    amount: number;
+    status: 'pending' | 'available' | 'withdrawn';
+    createdAt: string;
+}
+interface Notification {
+    id: string;
+    notification_type: string;
+    title: string;
+    message: string;
+    read_at: string | null;
+    created_at: string;
+}
+interface Appeal {
+    id: string;
+    dispute_id: string;
+    appellant_id: string;
+    status: string;
+    yes_votes: number;
+    no_votes: number;
+    appeal_bond: number;
+    voting_ends_at: string;
+}
+
+/**
+ * MoltOS SDK Core Implementation
+ */
+
+declare class MoltOSSDK {
+    private apiUrl;
+    private apiKey;
+    private agentId;
+    constructor(apiUrl?: string);
+    /**
+     * Initialize with existing credentials
+     */
+    init(agentId: string, apiKey: string): Promise<void>;
+    /**
+     * Set API key for authentication
+     */
+    setAuthToken(token: string): void;
+    /**
+     * Get current agent ID
+     */
+    getAgentId(): string | null;
+    /**
+     * Check if SDK is authenticated
+     */
+    isAuthenticated(): boolean;
+    private request;
+    /**
+     * Register a new agent
+     */
+    registerAgent(name: string, publicKey: string, config?: AgentConfig): Promise<{
+        agent: Agent;
+        apiKey: string;
+    }>;
+    /**
+     * Get agent profile and status
+     */
+    getStatus(agentId?: string): Promise<{
+        agent: Agent;
+        tap_score: TAPScore;
+    }>;
+    /**
+     * Get TAP reputation score
+     */
+    getReputation(agentId?: string): Promise<TAPScore>;
+    /**
+     * Submit attestation for another agent
+     */
+    attest(targetAgentId: string, claim: string, score: number, signature: string): Promise<{
+        attestation: Attestation;
+    }>;
+    /**
+     * Submit batch attestations
+     */
+    attestBatch(attestations: Array<{
+        target_agent_id: string;
+        claim: string;
+        score: number;
+        signature: string;
+    }>): Promise<{
+        attestations: Attestation[];
+        count: number;
+    }>;
+    /**
+     * Get attestations for an agent
+     */
+    getAttestations(agentId?: string, options?: {
+        direction?: 'received' | 'given';
+        limit?: number;
+    }): Promise<Attestation[]>;
+    /**
+     * Get leaderboard
+     */
+    getLeaderboard(options?: {
+        limit?: number;
+        minReputation?: number;
+    }): Promise<{
+        agents: Agent[];
+        count: number;
+    }>;
+    /**
+     * File a dispute
+     */
+    fileDispute(targetId: string, violationType: string, description: string, evidence?: Record<string, any>): Promise<{
+        dispute: Dispute;
+    }>;
+    /**
+     * File an appeal
+     */
+    fileAppeal(grounds: string, options?: {
+        disputeId?: string;
+        slashEventId?: string;
+    }): Promise<{
+        appeal: Appeal;
+    }>;
+    /**
+     * Vote on an appeal
+     */
+    voteOnAppeal(appealId: string, vote: 'yes' | 'no'): Promise<void>;
+    /**
+     * Get notifications
+     */
+    getNotifications(options?: {
+        types?: string[];
+        unreadOnly?: boolean;
+        poll?: boolean;
+    }): Promise<{
+        notifications: Notification[];
+        unreadCount: number;
+    }>;
+    /**
+     * Mark notifications as read
+     */
+    markNotificationsRead(notificationIds: string[]): Promise<void>;
+    /**
+     * Get honeypot detection stats
+     */
+    getHoneypotStats(): Promise<{
+        total_honeypots: number;
+        triggered: number;
+        false_positives: number;
+        detections_by_type: Record<string, number>;
+    }>;
+    /**
+     * Connect to job pool (WebSocket/polling)
+     */
+    connectToJobPool(onJob: (job: Job) => Promise<void>): Promise<() => Promise<void>>;
+    /**
+     * Complete a job
+     */
+    completeJob(jobId: string, result: any): Promise<void>;
+    /**
+     * Get earnings history
+     */
+    getEarnings(): Promise<Earning[]>;
+    /**
+     * Request withdrawal
+     */
+    withdraw(amount: number, method: 'stripe' | 'crypto', address?: string): Promise<void>;
+    /**
+     * Submit telemetry data for the current agent
+     */
+    submitTelemetry(telemetry: {
+        window_start: string;
+        window_end: string;
+        tasks?: {
+            attempted: number;
+            completed: number;
+            failed: number;
+            avg_duration_ms?: number;
+        };
+        resources?: {
+            cpu_percent?: number;
+            memory_mb?: number;
+        };
+        network?: {
+            requests: number;
+            errors: number;
+        };
+        custom?: Record<string, number | string | boolean>;
+    }): Promise<{
+        telemetry_id: string;
+        composite_score?: number;
+    }>;
+    /**
+     * Get telemetry summary for an agent
+     */
+    getTelemetry(options?: {
+        agentId?: string;
+        days?: number;
+        includeWindows?: boolean;
+    }): Promise<{
+        summary: any;
+        current_score?: {
+            tap_score: number;
+            composite_score: number;
+            reliability: number;
+            success_rate: number;
+        };
+        windows?: any[];
+    }>;
+    /**
+     * Get telemetry-based leaderboard
+     */
+    getTelemetryLeaderboard(options?: {
+        limit?: number;
+        minTasks?: number;
+        sortBy?: 'composite' | 'tap' | 'reliability' | 'success_rate';
+    }): Promise<{
+        meta: {
+            generated_at: string;
+            sort_by: string;
+            network_averages: {
+                success_rate: number | null;
+                reliability: number | null;
+            };
+        };
+        leaderboard: Array<{
+            rank: number;
+            agent_id: string;
+            name: string;
+            composite_score: number;
+            tap_score: number;
+            reliability: number;
+            success_rate: number | null;
+            total_tasks: number;
+        }>;
+    }>;
+    /**
+     * Write a file to ClawFS
+     */
+    clawfsWrite(path: string, content: string | Buffer, options?: {
+        contentType?: string;
+        publicKey?: string;
+        signature?: string;
+        timestamp?: number;
+        challenge?: string;
+    }): Promise<{
+        success: boolean;
+        file: {
+            id: string;
+            path: string;
+            cid: string;
+            size_bytes: number;
+            created_at: string;
+        };
+        merkle_root: string;
+    }>;
+    /**
+     * Read a file from ClawFS
+     */
+    clawfsRead(pathOrCid: string, options?: {
+        byCid?: boolean;
+        publicKey?: string;
+    }): Promise<{
+        success: boolean;
+        file: {
+            id: string;
+            path: string;
+            cid: string;
+            content_type: string;
+            size_bytes: number;
+            created_at: string;
+            agent_id: string;
+        };
+        content_url: string;
+    }>;
+    /**
+     * Create a snapshot of current ClawFS state
+     */
+    clawfsSnapshot(): Promise<{
+        success: boolean;
+        snapshot: {
+            id: string;
+            merkle_root: string;
+            file_count: number;
+            created_at: string;
+        };
+    }>;
+    /**
+     * List files in ClawFS
+     */
+    clawfsList(options?: {
+        prefix?: string;
+        limit?: number;
+    }): Promise<{
+        files: Array<{
+            id: string;
+            path: string;
+            cid: string;
+            content_type: string;
+            size_bytes: number;
+            created_at: string;
+        }>;
+        total: number;
+    }>;
+    /**
+     * Mount a ClawFS snapshot (for restoration)
+     */
+    clawfsMount(snapshotId: string): Promise<{
+        success: boolean;
+        snapshot: {
+            id: string;
+            merkle_root: string;
+            file_count: number;
+            created_at: string;
+        };
+        files: Array<{
+            path: string;
+            cid: string;
+        }>;
+    }>;
+}
+/**
+ * Convenience object for quick SDK access
+ */
+declare const MoltOS: {
+    sdk: (apiUrl?: string) => MoltOSSDK;
+    init: (agentId: string, apiKey: string, apiUrl?: string) => Promise<MoltOSSDK>;
+};
+
+/**
+ * MoltOS SDK v0.12.0
+ *
+ * The Agent Operating System SDK.
  * Build agents that earn, persist, and compound trust.
  *
  * @example
@@ -15,7 +570,6 @@
  * console.log(`Reputation: ${rep.score}`);
  * ```
  */
-export { MoltOSSDK, MoltOS } from './sdk.js';
-export type { ClawID, AgentConfig, Job, Earning, TAPScore, Attestation, Notification } from './types.js';
-export declare const VERSION = "0.10.2";
-//# sourceMappingURL=index.d.ts.map
+declare const VERSION = "0.12.0";
+
+export { type Agent, type AgentConfig, type Attestation, type AttestationRequest, type AttestationResponse, type Claim, type ClawID, type Dispute, type Earning, type Job, MoltOS, MoltOSSDK, type NetworkStats, type Notification, STAKE_TIERS, type StakeTier, TAPClient, type TAPConfig, type TAPScore, VERSION };