@moltos/sdk 0.11.0 → 0.13.0

package/dist/crypto.mjs

@@ -1,137 +1,16 @@
-// src/crypto.ts
-import { createHash, randomBytes } from "crypto";
-var STUB_MODE = true;
-function setStubMode(enabled) {
-  STUB_MODE = enabled;
-}
-function isStubMode() {
-  return STUB_MODE;
-}
-function generateKeypair() {
-  const privateBytes = new Uint8Array(randomBytes(32));
-  const publicBytes = derivePublicKeyBytes(privateBytes);
-  return {
-    privateKey: {
-      bytes: privateBytes,
-      toHex: () => Buffer.from(privateBytes).toString("hex")
-    },
-    publicKey: {
-      type: "BLS12_381",
-      bytes: publicBytes,
-      toHex: () => Buffer.from(publicBytes).toString("hex")
-    },
-    mnemonic: generateMnemonic()
-  };
-}
-function deriveKeypair(mnemonic, path = "m/44'/60'/0'/0/0") {
-  const seed = createHash("sha256").update(mnemonic + path).digest();
-  const privateBytes = new Uint8Array(seed.slice(0, 32));
-  const publicBytes = derivePublicKeyBytes(privateBytes);
-  return {
-    privateKey: {
-      bytes: privateBytes,
-      toHex: () => Buffer.from(privateBytes).toString("hex")
-    },
-    publicKey: {
-      type: "BLS12_381",
-      bytes: publicBytes,
-      toHex: () => Buffer.from(publicBytes).toString("hex")
-    }
-  };
-}
-function hashPayload(payload) {
-  const canonical = JSON.stringify(payload, Object.keys(payload).sort());
-  const hash = createHash("sha256").update(canonical).digest();
-  return new Uint8Array(hash);
-}
-function signAttestation(payload, privateKey) {
-  const messageHash = hashPayload(payload);
-  const sigData = createHash("sha256").update(Buffer.from(messageHash)).update(Buffer.from(privateKey.bytes)).digest();
-  const sigBytes = new Uint8Array(sigData.slice(0, 48));
-  const signature = {
-    type: "BLS12_381",
-    bytes: sigBytes,
-    toHex: () => Buffer.from(sigBytes).toString("hex"),
-    aggregate: (other) => aggregateSignatures([sigBytes, other.bytes])
-  };
-  return {
-    payload,
-    signature,
-    publicKey: derivePublicKey(privateKey),
-    proof: {
-      type: "bls12_381",
-      scheme: "basic"
-    }
-  };
-}
-function verifyAttestation(signed) {
-  if (STUB_MODE) {
-    console.warn("[TAP-SDK] BLS verification running in STUB mode");
-    return true;
-  }
-  throw new Error("Real BLS verification not yet implemented. Use stub mode for testing.");
-}
-function batchVerifyAttestations(attestations) {
-  if (STUB_MODE) {
-    const valid = attestations.map(() => true);
-    return { valid, allValid: true };
-  }
-  throw new Error("Batch verification not yet implemented");
-}
-function aggregateSignatures(signatures) {
-  const bytes = signatures.map((s) => s instanceof Uint8Array ? s : s.bytes);
-  const result = new Uint8Array(48);
-  for (const sig of bytes) {
-    for (let i = 0; i < 48 && i < sig.length; i++) {
-      result[i] ^= sig[i];
-    }
-  }
-  return {
-    type: "BLS12_381",
-    bytes: result,
-    toHex: () => Buffer.from(result).toString("hex"),
-    aggregate: (other) => aggregateSignatures([result, other.bytes])
-  };
-}
-function verifyAggregate(message, aggregateSig, publicKeys) {
-  if (STUB_MODE) {
-    console.warn("[TAP-SDK] Aggregate verification running in STUB mode");
-    return true;
-  }
-  throw new Error("Aggregate verification not yet implemented");
-}
-function derivePublicKeyBytes(privateBytes) {
-  const hash = createHash("sha256").update(privateBytes).digest();
-  const publicBytes = new Uint8Array(96);
-  for (let i = 0; i < 96; i++) {
-    publicBytes[i] = hash[i % hash.length] ^ privateBytes[i % privateBytes.length];
-  }
-  return publicBytes;
-}
-function derivePublicKey(privateKey) {
-  return {
-    type: "BLS12_381",
-    bytes: derivePublicKeyBytes(privateKey.bytes),
-    toHex: () => Buffer.from(derivePublicKeyBytes(privateKey.bytes)).toString("hex")
-  };
-}
-function generateMnemonic() {
-  const words = ["abandon", "ability", "able", "about", "above", "absent", "absorb", "abstract"];
-  const phrase = Array(12).fill(0).map(() => words[Math.floor(Math.random() * words.length)]);
-  return phrase.join(" ");
-}
-var crypto_default = {
-  generateKeypair,
-  deriveKeypair,
-  signAttestation,
-  verifyAttestation,
-  batchVerifyAttestations,
+import {
   aggregateSignatures,
-  verifyAggregate,
+  batchVerifyAttestations,
+  crypto_default,
+  deriveKeypair,
+  generateKeypair,
   hashPayload,
+  isStubMode,
   setStubMode,
-  isStubMode
-};
+  signAttestation,
+  verifyAggregate,
+  verifyAttestation
+} from "./chunk-TIRAZTCQ.mjs";
 export {
   aggregateSignatures,
   batchVerifyAttestations,

package/dist/index.d.mts

@@ -1,3 +1,5 @@
+export { AttestationPayload, BLSPrivateKey, BLSPublicKey, BLSSignature, SignedAttestation, aggregateSignatures, batchVerifyAttestations, deriveKeypair, generateKeypair, hashPayload, isStubMode, setStubMode, signAttestation, verifyAggregate, verifyAttestation } from './crypto.mjs';
+
 /**
  * TAP SDK — Trust and Attestation Protocol
  *
@@ -58,7 +60,7 @@ interface TAPScore {
     attestationsGiven: number;
     lastUpdated: string;
 }
-interface NetworkStats {
+interface NetworkStats$1 {
     totalAgents: number;
     totalAttestations: number;
     averageScore: number;
@@ -107,7 +109,7 @@ declare class TAPClient {
     /**
      * Get network-wide statistics
      */
-    getNetworkStats(): Promise<NetworkStats>;
+    getNetworkStats(): Promise<NetworkStats$1>;
     /**
      * Check Arbitra eligibility
      */
@@ -140,14 +142,434 @@ declare class TAPClient {
     private post;
     private generateNonce;
 }
+
 /**
- * Quick attestation without creating a client
+ * TAP Protocol TypeScript Types
  */
-declare function submitAttestation(apiKey: string, request: AttestationRequest, baseUrl?: string): Promise<AttestationResponse>;
+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;
+}
+
 /**
- * Quick score lookup without creating a client
+ * 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
+ * ```typescript
+ * import { MoltOSSDK } from '@moltos/sdk';
+ *
+ * const sdk = new MoltOSSDK();
+ * await sdk.init('agent-id', 'api-key');
+ *
+ * // Check reputation
+ * const rep = await sdk.getReputation();
+ * console.log(`Reputation: ${rep.score}`);
+ * ```
  */
-declare function getAgentScore(apiKey: string, agentId: string, baseUrl?: string): Promise<TAPScore>;
-declare const VERSION = "0.1.0-alpha.1";
+declare const VERSION = "0.12.0";
 
-export { type ArbitraEligibility, type AttestationRequest, type AttestationResponse, type NetworkStats, TAPClient, type TAPConfig, type TAPScore, VERSION, TAPClient as default, getAgentScore, submitAttestation };
+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 };