@moltos/sdk 0.10.14 → 0.12.0

package/dist/index.js

@@ -1,22 +1,758 @@
-/**
- * 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 __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)
+    __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 __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,
+  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",
+  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");
+  }
+};
+
+// 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;
+}
+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(" ");
+}
+
+// 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,
+  aggregateSignatures,
+  batchVerifyAttestations,
+  deriveKeypair,
+  generateKeypair,
+  hashPayload,
+  isStubMode,
+  setStubMode,
+  signAttestation,
+  verifyAggregate,
+  verifyAttestation
+});