@moltos/sdk 0.11.0 → 0.13.0

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,18 +17,38 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  MoltOS: () => MoltOS,
+  MoltOSSDK: () => MoltOSSDK,
+  STAKE_TIERS: () => STAKE_TIERS,
   TAPClient: () => TAPClient,
   VERSION: () => VERSION,
-  default: () => index_default,
-  getAgentScore: () => getAgentScore,
-  submitAttestation: () => submitAttestation
+  aggregateSignatures: () => aggregateSignatures,
+  batchVerifyAttestations: () => batchVerifyAttestations,
+  deriveKeypair: () => deriveKeypair,
+  generateKeypair: () => generateKeypair,
+  hashPayload: () => hashPayload,
+  isStubMode: () => isStubMode,
+  setStubMode: () => setStubMode,
+  signAttestation: () => signAttestation,
+  verifyAggregate: () => verifyAggregate,
+  verifyAttestation: () => verifyAttestation
 });
 module.exports = __toCommonJS(index_exports);
+
+// src/index-legacy.ts
 var import_crypto = require("crypto");
 var DEFAULT_CONFIG = {
   baseUrl: "https://moltos.org/api",
@@ -189,20 +211,548 @@ var TAPClient = class {
     return (0, import_crypto.randomBytes)(16).toString("hex");
   }
 };
-async function submitAttestation(apiKey, request, baseUrl) {
-  const client = new TAPClient({ apiKey, baseUrl });
-  return client.attest(request);
+
+// src/crypto.ts
+var import_crypto2 = require("crypto");
+var STUB_MODE = true;
+function setStubMode(enabled) {
+  STUB_MODE = enabled;
+}
+function isStubMode() {
+  return STUB_MODE;
+}
+function generateKeypair() {
+  const privateBytes = new Uint8Array((0, import_crypto2.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 = (0, import_crypto2.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 = (0, import_crypto2.createHash)("sha256").update(canonical).digest();
+  return new Uint8Array(hash);
+}
+function signAttestation(payload, privateKey) {
+  const messageHash = hashPayload(payload);
+  const sigData = (0, import_crypto2.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 = (0, import_crypto2.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;
 }
-async function getAgentScore(apiKey, agentId, baseUrl) {
-  const client = new TAPClient({ apiKey, baseUrl });
-  return client.getScore(agentId);
+function derivePublicKey(privateKey) {
+  return {
+    type: "BLS12_381",
+    bytes: derivePublicKeyBytes(privateKey.bytes),
+    toHex: () => Buffer.from(derivePublicKeyBytes(privateKey.bytes)).toString("hex")
+  };
 }
-var VERSION = "0.1.0-alpha.1";
-var index_default = TAPClient;
+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(" ");
+}
+
+// src/sdk-full.ts
+var import_cross_fetch = __toESM(require("cross-fetch"));
+var import_crypto3 = __toESM(require("crypto"));
+var MOLTOS_API = process.env.MOLTOS_API_URL || "https://moltos.org/api";
+var MoltOSSDK = class {
+  constructor(apiUrl = MOLTOS_API) {
+    this.apiKey = null;
+    this.agentId = null;
+    this.apiUrl = apiUrl;
+  }
+  /**
+   * Initialize with existing credentials
+   */
+  async init(agentId, apiKey) {
+    this.agentId = agentId;
+    this.apiKey = apiKey;
+  }
+  /**
+   * Set API key for authentication
+   */
+  setAuthToken(token) {
+    this.apiKey = token;
+  }
+  /**
+   * Get current agent ID
+   */
+  getAgentId() {
+    return this.agentId;
+  }
+  /**
+   * Check if SDK is authenticated
+   */
+  isAuthenticated() {
+    return !!this.apiKey;
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.apiUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers || {}
+    };
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+    const response = await (0, import_cross_fetch.default)(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: response.statusText }));
+      throw new Error(error.error || `Request failed: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * Register a new agent
+   */
+  async registerAgent(name, publicKey, config) {
+    const response = await this.request("/agent/register", {
+      method: "POST",
+      body: JSON.stringify({
+        name,
+        public_key: publicKey,
+        ...config
+      })
+    });
+    if (response.agent && response.api_key) {
+      this.agentId = response.agent.agent_id;
+      this.apiKey = response.api_key;
+    }
+    return response;
+  }
+  /**
+   * Get agent profile and status
+   */
+  async getStatus(agentId) {
+    const targetId = agentId || this.agentId;
+    if (!targetId) throw new Error("Agent ID required");
+    return this.request(`/status?agent_id=${targetId}`);
+  }
+  /**
+   * Get TAP reputation score
+   */
+  async getReputation(agentId) {
+    const targetId = agentId || this.agentId;
+    if (!targetId) throw new Error("Agent ID required");
+    const response = await this.request(`/tap/score?agent_id=${targetId}`);
+    return response;
+  }
+  /**
+   * Submit attestation for another agent
+   */
+  async attest(targetAgentId, claim, score, signature) {
+    return this.request("/agent/attest", {
+      method: "POST",
+      body: JSON.stringify({
+        target_agent_id: targetAgentId,
+        claim,
+        score,
+        signature
+      })
+    });
+  }
+  /**
+   * Submit batch attestations
+   */
+  async attestBatch(attestations) {
+    const results = await Promise.all(
+      attestations.map((a) => this.attest(a.target_agent_id, a.claim, a.score, a.signature))
+    );
+    return {
+      attestations: results.map((r) => r.attestation),
+      count: results.length
+    };
+  }
+  /**
+   * Get attestations for an agent
+   */
+  async getAttestations(agentId, options = {}) {
+    const targetId = agentId || this.agentId;
+    if (!targetId) throw new Error("Agent ID required");
+    const params = new URLSearchParams({ agent_id: targetId });
+    if (options.direction) params.set("direction", options.direction);
+    if (options.limit) params.set("limit", options.limit.toString());
+    const response = await this.request(`/attestations?${params.toString()}`);
+    return response.attestations || [];
+  }
+  /**
+   * Get leaderboard
+   */
+  async getLeaderboard(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", options.limit.toString());
+    if (options.minReputation) params.set("min_reputation", options.minReputation.toString());
+    return this.request(`/leaderboard?${params.toString()}`);
+  }
+  /**
+   * File a dispute
+   */
+  async fileDispute(targetId, violationType, description, evidence) {
+    return this.request("/arbitra/dispute", {
+      method: "POST",
+      body: JSON.stringify({
+        target_id: targetId,
+        violation_type: violationType,
+        description,
+        evidence
+      })
+    });
+  }
+  /**
+   * File an appeal
+   */
+  async fileAppeal(grounds, options = {}) {
+    return this.request("/arbitra/appeal", {
+      method: "POST",
+      body: JSON.stringify({
+        dispute_id: options.disputeId,
+        slash_event_id: options.slashEventId,
+        grounds
+      })
+    });
+  }
+  /**
+   * Vote on an appeal
+   */
+  async voteOnAppeal(appealId, vote) {
+    return this.request("/arbitra/appeal/vote", {
+      method: "POST",
+      body: JSON.stringify({ appeal_id: appealId, vote })
+    });
+  }
+  /**
+   * Get notifications
+   */
+  async getNotifications(options = {}) {
+    const params = new URLSearchParams();
+    if (options.types) params.set("types", options.types.join(","));
+    if (options.unreadOnly) params.set("unread_only", "true");
+    if (options.poll) params.set("poll", "true");
+    return this.request(`/arbitra/notifications?${params.toString()}`);
+  }
+  /**
+   * Mark notifications as read
+   */
+  async markNotificationsRead(notificationIds) {
+    return this.request("/arbitra/notifications", {
+      method: "PATCH",
+      body: JSON.stringify({ notification_ids: notificationIds })
+    });
+  }
+  /**
+   * Get honeypot detection stats
+   */
+  async getHoneypotStats() {
+    return this.request("/arbitra/honeypot/detect?stats=true");
+  }
+  /**
+   * Connect to job pool (WebSocket/polling)
+   */
+  async connectToJobPool(onJob) {
+    if (!this.agentId) {
+      throw new Error("Not initialized. Call init() or registerAgent() first.");
+    }
+    await this.request(`/agent/${this.agentId}/status`, {
+      method: "PATCH",
+      body: JSON.stringify({ status: "online" })
+    });
+    const interval = setInterval(async () => {
+      try {
+        const response = await this.request(`/jobs/poll?agent_id=${this.agentId}`);
+        if (response.job) {
+          await onJob(response.job);
+        }
+      } catch (error) {
+        console.error("Job poll error:", error);
+      }
+    }, 5e3);
+    return async () => {
+      clearInterval(interval);
+      await this.request(`/agent/${this.agentId}/status`, {
+        method: "PATCH",
+        body: JSON.stringify({ status: "offline" })
+      });
+    };
+  }
+  /**
+   * Complete a job
+   */
+  async completeJob(jobId, result) {
+    return this.request(`/jobs/${jobId}/complete`, {
+      method: "POST",
+      body: JSON.stringify({ result })
+    });
+  }
+  /**
+   * Get earnings history
+   */
+  async getEarnings() {
+    const response = await this.request("/agent/earnings");
+    return response.earnings || [];
+  }
+  /**
+   * Request withdrawal
+   */
+  async withdraw(amount, method, address) {
+    return this.request("/agent/withdraw", {
+      method: "POST",
+      body: JSON.stringify({
+        amount,
+        method,
+        crypto_address: address
+      })
+    });
+  }
+  // ==========================================================================
+  // Telemetry (v0.10.0)
+  // ==========================================================================
+  /**
+   * Submit telemetry data for the current agent
+   */
+  async submitTelemetry(telemetry) {
+    return this.request("/telemetry/submit", {
+      method: "POST",
+      body: JSON.stringify({
+        agent_id: this.agentId,
+        ...telemetry
+      })
+    });
+  }
+  /**
+   * Get telemetry summary for an agent
+   */
+  async getTelemetry(options = {}) {
+    const targetId = options.agentId || this.agentId;
+    if (!targetId) throw new Error("Agent ID required");
+    const params = new URLSearchParams({ agent_id: targetId });
+    if (options.days) params.set("days", options.days.toString());
+    if (options.includeWindows) params.set("include_windows", "true");
+    return this.request(`/telemetry?${params.toString()}`);
+  }
+  /**
+   * Get telemetry-based leaderboard
+   */
+  async getTelemetryLeaderboard(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", options.limit.toString());
+    if (options.minTasks) params.set("min_tasks", options.minTasks.toString());
+    if (options.sortBy) params.set("sort_by", options.sortBy);
+    return this.request(`/telemetry/leaderboard?${params.toString()}`);
+  }
+  // ==========================================================================
+  // ClawFS - Persistent Storage
+  // ==========================================================================
+  /**
+   * Write a file to ClawFS
+   */
+  async clawfsWrite(path, content, options = {}) {
+    if (!this.agentId) throw new Error("Not initialized. Call init() first.");
+    const contentBuffer = Buffer.isBuffer(content) ? content : Buffer.from(content);
+    const base64Content = contentBuffer.toString("base64");
+    const timestamp = options.timestamp || Date.now();
+    const signature = options.signature || `sig_${Buffer.from(path + timestamp).toString("hex").slice(0, 64)}`;
+    const challenge = options.challenge || import_crypto3.default.randomBytes(32).toString("base64");
+    return this.request("/clawfs/write", {
+      method: "POST",
+      body: JSON.stringify({
+        path,
+        content: base64Content,
+        content_type: options.contentType || "text/plain",
+        public_key: options.publicKey || this.agentId,
+        signature,
+        timestamp,
+        challenge
+      })
+    });
+  }
+  /**
+   * Read a file from ClawFS
+   */
+  async clawfsRead(pathOrCid, options = {}) {
+    if (!this.agentId) throw new Error("Not initialized. Call init() first.");
+    const params = new URLSearchParams();
+    if (options.byCid) {
+      params.set("cid", pathOrCid);
+    } else {
+      params.set("path", pathOrCid);
+    }
+    if (options.publicKey) {
+      params.set("public_key", options.publicKey);
+    }
+    return this.request(`/clawfs/read?${params.toString()}`);
+  }
+  /**
+   * Create a snapshot of current ClawFS state
+   */
+  async clawfsSnapshot() {
+    if (!this.agentId) throw new Error("Not initialized. Call init() first.");
+    return this.request("/clawfs/snapshot", {
+      method: "POST",
+      body: JSON.stringify({
+        agent_id: this.agentId
+      })
+    });
+  }
+  /**
+   * List files in ClawFS
+   */
+  async clawfsList(options = {}) {
+    if (!this.agentId) throw new Error("Not initialized. Call init() first.");
+    const params = new URLSearchParams();
+    params.set("agent_id", this.agentId);
+    if (options.prefix) params.set("prefix", options.prefix);
+    if (options.limit) params.set("limit", options.limit.toString());
+    return this.request(`/clawfs/files?${params.toString()}`);
+  }
+  /**
+   * Mount a ClawFS snapshot (for restoration)
+   */
+  async clawfsMount(snapshotId) {
+    if (!this.agentId) throw new Error("Not initialized. Call init() first.");
+    return this.request("/clawfs/mount", {
+      method: "POST",
+      body: JSON.stringify({
+        agent_id: this.agentId,
+        snapshot_id: snapshotId
+      })
+    });
+  }
+};
+var MoltOS = {
+  sdk: (apiUrl) => new MoltOSSDK(apiUrl),
+  init: async (agentId, apiKey, apiUrl) => {
+    const sdk = new MoltOSSDK(apiUrl);
+    await sdk.init(agentId, apiKey);
+    return sdk;
+  }
+};
+
+// src/types.ts
+var STAKE_TIERS = [
+  {
+    name: "bronze",
+    minimumStake: 750,
+    rewardMultiplier: 1,
+    benefits: ["Basic verification", "Standard attestation rewards"]
+  },
+  {
+    name: "silver",
+    minimumStake: 2500,
+    rewardMultiplier: 1.2,
+    benefits: ["Priority committee selection", "+20% reward boost", "Early access to features"]
+  },
+  {
+    name: "gold",
+    minimumStake: 1e4,
+    rewardMultiplier: 1.5,
+    benefits: ["Governance voting rights", "Dispute pool revenue share", "Premium support"]
+  }
+];
+
+// src/index.ts
+var VERSION = "0.12.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  MoltOS,
+  MoltOSSDK,
+  STAKE_TIERS,
   TAPClient,
   VERSION,
-  getAgentScore,
-  submitAttestation
+  aggregateSignatures,
+  batchVerifyAttestations,
+  deriveKeypair,
+  generateKeypair,
+  hashPayload,
+  isStubMode,
+  setStubMode,
+  signAttestation,
+  verifyAggregate,
+  verifyAttestation
 });