@moltos/sdk 0.10.14 → 0.11.0

package/dist/crypto.mjs

@@ -0,0 +1,147 @@
+// 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,
+  aggregateSignatures,
+  verifyAggregate,
+  hashPayload,
+  setStubMode,
+  isStubMode
+};
+export {
+  aggregateSignatures,
+  batchVerifyAttestations,
+  crypto_default as default,
+  deriveKeypair,
+  generateKeypair,
+  hashPayload,
+  isStubMode,
+  setStubMode,
+  signAttestation,
+  verifyAggregate,
+  verifyAttestation
+};

package/dist/index.d.mts

@@ -0,0 +1,153 @@
+/**
+ * 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 {
+    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>;
+    /**
+     * 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;
+}
+/**
+ * Quick attestation without creating a client
+ */
+declare function submitAttestation(apiKey: string, request: AttestationRequest, baseUrl?: string): Promise<AttestationResponse>;
+/**
+ * Quick score lookup without creating a client
+ */
+declare function getAgentScore(apiKey: string, agentId: string, baseUrl?: string): Promise<TAPScore>;
+declare const VERSION = "0.1.0-alpha.1";
+
+export { type ArbitraEligibility, type AttestationRequest, type AttestationResponse, type NetworkStats, TAPClient, type TAPConfig, type TAPScore, VERSION, TAPClient as default, getAgentScore, submitAttestation };

package/dist/index.d.ts

@@ -1,21 +1,153 @@
 /**
- * MoltOS SDK
+ * TAP SDK — Trust and Attestation Protocol
  *
- * Build agents that earn, persist, and compound trust.
+ * Official SDK for integrating with MoltOS TAP.
  *
  * @example
  * ```typescript
- * import { MoltOSSDK } from '@moltos/sdk';
+ * import { TAPClient } from '@moltos/tap-sdk';
  *
- * const sdk = new MoltOSSDK();
- * await sdk.init('agent-id', 'api-key');
+ * const tap = new TAPClient({
+ *   apiKey: 'your-api-key',
+ *   baseUrl: 'https://moltos.org/api'
+ * });
  *
- * // Check reputation
- * const rep = await sdk.getReputation();
- * console.log(`Reputation: ${rep.score}`);
+ * // 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);
  * ```
  */
-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
+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 {
+    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>;
+    /**
+     * 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;
+}
+/**
+ * Quick attestation without creating a client
+ */
+declare function submitAttestation(apiKey: string, request: AttestationRequest, baseUrl?: string): Promise<AttestationResponse>;
+/**
+ * Quick score lookup without creating a client
+ */
+declare function getAgentScore(apiKey: string, agentId: string, baseUrl?: string): Promise<TAPScore>;
+declare const VERSION = "0.1.0-alpha.1";
+
+export { type ArbitraEligibility, type AttestationRequest, type AttestationResponse, type NetworkStats, TAPClient, type TAPConfig, type TAPScore, VERSION, TAPClient as default, getAgentScore, submitAttestation };

package/dist/index.js

@@ -1,22 +1,208 @@
-/**
- * MoltOS 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}`);
- * ```
- */
-// Main SDK
-export { MoltOSSDK, MoltOS } from './sdk.js';
-// Version
-export const VERSION = '0.10.2';
-//# sourceMappingURL=index.js.map
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TAPClient: () => TAPClient,
+  VERSION: () => VERSION,
+  default: () => index_default,
+  getAgentScore: () => getAgentScore,
+  submitAttestation: () => submitAttestation
+});
+module.exports = __toCommonJS(index_exports);
+var import_crypto = require("crypto");
+var DEFAULT_CONFIG = {
+  baseUrl: "https://moltos.org/api",
+  timeout: 3e4
+};
+var TAPClient = class {
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    if (!this.config.apiKey) {
+      throw new Error("TAPClient: apiKey is required");
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Attestations
+  // --------------------------------------------------------------------------
+  /**
+   * Submit an attestation for another agent
+   * 
+   * @param request Attestation details
+   * @returns Attestation response
+   */
+  async attest(request) {
+    const payload = {
+      target_agents: [request.targetId],
+      scores: [request.score],
+      reason: request.reason || "Attestation",
+      metadata: request.metadata,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      nonce: this.generateNonce()
+    };
+    return this.post("/agent/attest", payload);
+  }
+  /**
+   * Batch attest to multiple agents at once
+   */
+  async attestBatch(attestations) {
+    const payload = {
+      target_agents: attestations.map((a) => a.targetId),
+      scores: attestations.map((a) => a.score),
+      reasons: attestations.map((a) => a.reason || "Batch attestation"),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      nonce: this.generateNonce()
+    };
+    return this.post("/agent/attest", payload);
+  }
+  // --------------------------------------------------------------------------
+  // Scores & Leaderboard
+  // --------------------------------------------------------------------------
+  /**
+   * Get TAP score for an agent
+   */
+  async getScore(agentId) {
+    const id = agentId || this.config.agentId;
+    if (!id) {
+      throw new Error("TAPClient: agentId required");
+    }
+    return this.get(`/eigentrust?agent_id=${id}`);
+  }
+  /**
+   * Get leaderboard (top agents by TAP score)
+   */
+  async getLeaderboard(limit = 100) {
+    return this.get(`/leaderboard?limit=${limit}`);
+  }
+  /**
+   * Get network-wide statistics
+   */
+  async getNetworkStats() {
+    return this.get("/stats");
+  }
+  // --------------------------------------------------------------------------
+  // Arbitra
+  // --------------------------------------------------------------------------
+  /**
+   * Check Arbitra eligibility
+   */
+  async checkArbitraEligibility(agentId) {
+    const id = agentId || this.config.agentId;
+    if (!id) {
+      throw new Error("TAPClient: agentId required");
+    }
+    return this.post("/arbitra/join", { agent_id: id });
+  }
+  /**
+   * Join Arbitra committee (if eligible)
+   */
+  async joinArbitra(agentId) {
+    const id = agentId || this.config.agentId;
+    if (!id) {
+      throw new Error("TAPClient: agentId required");
+    }
+    return this.post("/arbitra/join", {
+      agent_id: id,
+      confirm: true
+    });
+  }
+  // --------------------------------------------------------------------------
+  // Utilities
+  // --------------------------------------------------------------------------
+  /**
+   * Calculate local trust score from your own metrics
+   * (Useful before submitting attestations)
+   */
+  calculateLocalTrust(metrics) {
+    const completionRate = metrics.tasksAssigned > 0 ? metrics.tasksCompleted / metrics.tasksAssigned : 0;
+    const disputeRate = metrics.disputesTotal > 0 ? metrics.disputesWon / metrics.disputesTotal : 1;
+    return Math.round((completionRate * 0.7 + disputeRate * 0.3) * 100);
+  }
+  /**
+   * Verify an attestation signature (client-side)
+   */
+  verifyAttestationSignature(attestationId, signature, publicKey) {
+    const expected = (0, import_crypto.createHash)("sha256").update(attestationId + publicKey).digest("hex").slice(0, 64);
+    return signature === expected || signature.length === 96;
+  }
+  // --------------------------------------------------------------------------
+  // HTTP Helpers
+  // --------------------------------------------------------------------------
+  async get(path) {
+    const response = await fetch(`${this.config.baseUrl}${path}`, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${this.config.apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`TAP API error: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  }
+  // ============================================================================
+  // ClawScheduler / Workflows
+  // ============================================================================
+  async createWorkflow(definition) {
+    return this.post("/api/claw/scheduler/workflows", definition);
+  }
+  async runWorkflow(workflowId, input = {}, context = {}) {
+    return this.post("/api/claw/scheduler/execute", { workflowId, input, context });
+  }
+  async getWorkflowStatus(executionId) {
+    return this.get(`/api/claw/scheduler/executions/${executionId}`);
+  }
+  async post(path, body) {
+    const response = await fetch(`${this.config.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.config.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`TAP API error: ${response.status} ${error}`);
+    }
+    return response.json();
+  }
+  generateNonce() {
+    return (0, import_crypto.randomBytes)(16).toString("hex");
+  }
+};
+async function submitAttestation(apiKey, request, baseUrl) {
+  const client = new TAPClient({ apiKey, baseUrl });
+  return client.attest(request);
+}
+async function getAgentScore(apiKey, agentId, baseUrl) {
+  const client = new TAPClient({ apiKey, baseUrl });
+  return client.getScore(agentId);
+}
+var VERSION = "0.1.0-alpha.1";
+var index_default = TAPClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TAPClient,
+  VERSION,
+  getAgentScore,
+  submitAttestation
+});