@moltos/sdk 0.10.14 → 0.12.0

package/dist/crypto.js

@@ -0,0 +1,181 @@
+"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/crypto.ts
+var crypto_exports = {};
+__export(crypto_exports, {
+  aggregateSignatures: () => aggregateSignatures,
+  batchVerifyAttestations: () => batchVerifyAttestations,
+  default: () => crypto_default,
+  deriveKeypair: () => deriveKeypair,
+  generateKeypair: () => generateKeypair,
+  hashPayload: () => hashPayload,
+  isStubMode: () => isStubMode,
+  setStubMode: () => setStubMode,
+  signAttestation: () => signAttestation,
+  verifyAggregate: () => verifyAggregate,
+  verifyAttestation: () => verifyAttestation
+});
+module.exports = __toCommonJS(crypto_exports);
+var import_crypto = 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_crypto.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_crypto.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_crypto.createHash)("sha256").update(canonical).digest();
+  return new Uint8Array(hash);
+}
+function signAttestation(payload, privateKey) {
+  const messageHash = hashPayload(payload);
+  const sigData = (0, import_crypto.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_crypto.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
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  aggregateSignatures,
+  batchVerifyAttestations,
+  deriveKeypair,
+  generateKeypair,
+  hashPayload,
+  isStubMode,
+  setStubMode,
+  signAttestation,
+  verifyAggregate,
+  verifyAttestation
+});

package/dist/crypto.mjs

@@ -0,0 +1,26 @@
+import {
+  aggregateSignatures,
+  batchVerifyAttestations,
+  crypto_default,
+  deriveKeypair,
+  generateKeypair,
+  hashPayload,
+  isStubMode,
+  setStubMode,
+  signAttestation,
+  verifyAggregate,
+  verifyAttestation
+} from "./chunk-TIRAZTCQ.mjs";
+export {
+  aggregateSignatures,
+  batchVerifyAttestations,
+  crypto_default as default,
+  deriveKeypair,
+  generateKeypair,
+  hashPayload,
+  isStubMode,
+  setStubMode,
+  signAttestation,
+  verifyAggregate,
+  verifyAttestation
+};

package/dist/{sdk.d.ts → index.d.mts}

@@ -1,8 +1,262 @@
+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
+ *
+ * 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
  */
-import type { Agent, AgentConfig, Job, Earning, TAPScore, Attestation, Notification, Dispute, Appeal } from './types.js';
-export declare class MoltOSSDK {
+
+declare class MoltOSSDK {
     private apiUrl;
     private apiKey;
     private agentId;
@@ -293,9 +547,29 @@ export declare class MoltOSSDK {
 /**
  * Convenience object for quick SDK access
  */
-export declare const MoltOS: {
+declare const MoltOS: {
     sdk: (apiUrl?: string) => MoltOSSDK;
     init: (agentId: string, apiKey: string, apiUrl?: string) => Promise<MoltOSSDK>;
 };
-export default MoltOSSDK;
-//# sourceMappingURL=sdk.d.ts.map
+
+/**
+ * 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 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 };