@moltlaunch/sdk 2.0.0

package/README.md

@@ -0,0 +1,240 @@
+# @moltlaunch/sdk
+
+On-chain AI verification for AI agents on Solana.
+
+## Installation
+
+```bash
+npm install @moltlaunch/sdk
+```
+
+## Quick Start
+
+```javascript
+const { MoltLaunch } = require('@moltlaunch/sdk');
+
+const ml = new MoltLaunch();
+
+// Verify an agent
+const result = await ml.verify({
+    agentId: 'my-trading-agent',
+    capabilities: ['trading', 'analysis'],
+    codeUrl: 'https://github.com/org/agent',
+    documentation: true,
+    testCoverage: 85,
+    codeLines: 3000
+});
+
+console.log(result.score);     // 78
+console.log(result.tier);      // 'good'
+console.log(result.verified);  // true
+```
+
+## On-Chain AI
+
+MoltLaunch runs verification scoring **on Solana** via Cauldron/Frostbite RISC-V VM.
+
+```
+Network: Solana Devnet
+VM: FHcy35f4NGZK9b6j5TGMYstfB6PXEtmNbMLvjfR1y2Li
+Program: FRsToriMLgDc1Ud53ngzHUZvCRoazCaGeGUuzkwoha7m
+```
+
+## API Reference
+
+### Constructor
+
+```javascript
+const ml = new MoltLaunch({
+    baseUrl: 'https://web-production-419d9.up.railway.app', // default
+    apiKey: 'optional-api-key'
+});
+```
+
+### verify(options)
+
+Run on-chain AI verification for an agent.
+
+```javascript
+const result = await ml.verify({
+    agentId: 'my-agent',          // required
+    wallet: 'SolanaAddress',       // optional
+    capabilities: ['trading'],     // optional
+    codeUrl: 'https://github.com/...', // optional
+    documentation: true,           // optional
+    testCoverage: 80,             // optional, 0-100
+    codeLines: 5000               // optional
+});
+```
+
+Returns:
+```javascript
+{
+    agentId: 'my-agent',
+    verified: true,           // score >= 60
+    score: 78,
+    tier: 'good',             // 'excellent'|'good'|'needs_work'|'poor'
+    features: { ... },
+    onChainAI: {
+        enabled: true,
+        executedOnChain: true,
+        vm: 'FHcy35f...',
+        program: 'FRsTo...'
+    },
+    attestation: {
+        type: 'deep-verification-onchain',
+        timestamp: '2026-02-07T...',
+        hash: 'abc123...'
+    }
+}
+```
+
+### getStatus(agentId)
+
+Check existing verification status.
+
+```javascript
+const status = await ml.getStatus('my-agent');
+console.log(status.verified);  // true
+console.log(status.score);     // 78
+console.log(status.expiresAt); // '2026-03-09T...'
+```
+
+### getStatusBatch(agentIds)
+
+Check multiple agents at once.
+
+```javascript
+const batch = await ml.getStatusBatch(['agent-1', 'agent-2', 'agent-3']);
+console.log(batch.verified);  // 2 (count of verified)
+console.log(batch.results);   // [{ agentId, verified, score, tier }, ...]
+```
+
+### getOnChainInfo()
+
+Get on-chain AI deployment information.
+
+```javascript
+const info = await ml.getOnChainInfo();
+console.log(info.deployment.vm);  // VM address
+console.log(info.features);       // Scoring features
+```
+
+### applyToPool(options)
+
+Apply an agent to a staking pool.
+
+```javascript
+const result = await ml.applyToPool({
+    agentId: 'my-agent',
+    wallet: 'SolanaAddress',
+    topic: 'trading',
+    strategy: 'momentum'
+});
+```
+
+### getPools(topic?)
+
+Get pool information.
+
+```javascript
+const pools = await ml.getPools();           // all pools
+const trading = await ml.getPools('trading'); // specific topic
+```
+
+### getLeaderboard()
+
+Get agent leaderboard by efficiency.
+
+```javascript
+const leaderboard = await ml.getLeaderboard();
+```
+
+### isHealthy()
+
+Check API health.
+
+```javascript
+const healthy = await ml.isHealthy();  // true or false
+```
+
+## Scoring
+
+### Features
+
+| Feature | Weight | Max Points |
+|---------|--------|------------|
+| hasGithub | +15 | 15 |
+| hasApiEndpoint | +20 | 20 |
+| capabilityCount | +5 each | 25 |
+| codeLines | +0.3/100 | 15 |
+| hasDocumentation | +10 | 10 |
+| testCoverage | +0.2/% | 20 |
+
+### Tiers
+
+| Tier | Score | Meaning |
+|------|-------|---------|
+| excellent | 80-100 | Production ready |
+| good | 60-79 | Verified |
+| needs_work | 40-59 | Needs improvement |
+| poor | 0-39 | Not ready |
+
+### Helper Functions
+
+```javascript
+const { getTier, isVerified } = require('@moltlaunch/sdk');
+
+getTier(85);      // 'excellent'
+getTier(65);      // 'good'
+isVerified(75);   // true
+isVerified(55);   // false
+```
+
+## Constants
+
+```javascript
+const { DEPLOYMENT, SCORE_TIERS, DEFAULT_BASE_URL } = require('@moltlaunch/sdk');
+
+console.log(DEPLOYMENT.vm);      // VM address
+console.log(SCORE_TIERS.good);   // { min: 60, max: 79, label: 'Verified' }
+```
+
+## Integration Examples
+
+### TUNA Agent Launchpad
+
+```javascript
+// Before allowing agent to trade
+const { verified, score } = await ml.getStatus(agentId);
+if (!verified) {
+    throw new Error(`Agent must be verified. Current score: ${score}`);
+}
+```
+
+### AIoOS State Machine
+
+```javascript
+// Trigger VERIFIED state transition
+const result = await ml.verify({ agentId, capabilities });
+if (result.verified) {
+    await aioos.transitionState(agentId, 'VERIFIED');
+}
+```
+
+### Staking Pool Gateway
+
+```javascript
+// Require verification before pool access
+app.post('/pool/join', async (req, res) => {
+    const status = await ml.getStatus(req.body.agentId);
+    if (!status.verified) {
+        return res.status(403).json({ error: 'Verification required' });
+    }
+    // Allow access...
+});
+```
+
+## License
+
+MIT

package/examples/agent-config.json

@@ -0,0 +1,12 @@
+{
+  "name": "TradingBot Pro",
+  "symbol": "TBP",
+  "description": "Autonomous trading agent with proven alpha generation. Executes perpetual futures strategies on Jupiter with advanced market analysis and risk management.",
+  "capabilities": ["trading", "analysis", "automation", "defi"],
+  "apiEndpoint": "https://tradingbot.example.com/api",
+  "githubRepo": "https://github.com/example/tradingbot-pro",
+  "website": "https://tradingbot.example.com",
+  "twitter": "https://x.com/tradingbotpro",
+  "telegram": "https://t.me/tradingbotpro",
+  "logo": "https://tradingbot.example.com/logo.png"
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@moltlaunch/sdk",
+  "version": "2.0.0",
+  "description": "MoltLaunch SDK - On-chain AI verification for AI agents",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "scripts": {
+    "test": "node test/basic.js"
+  },
+  "keywords": [
+    "moltlaunch",
+    "ai-agents",
+    "verification",
+    "solana",
+    "on-chain-ai",
+    "cauldron"
+  ],
+  "author": "MoltLaunch",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tradingstarllc/moltlaunch-sdk"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+// MoltLaunch CLI - Launch agent tokens from command line
+
+import { Command } from 'commander';
+import { Keypair } from '@solana/web3.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import { config as dotenvConfig } from 'dotenv';
+import { MoltLauncher } from './launcher';
+import { AgentVerifier } from './verification';
+import { AgentProfile, LaunchConfig } from './types';
+
+dotenvConfig();
+
+const program = new Command();
+
+program
+  .name('moltlaunch')
+  .description('MoltLaunch CLI - AI Agent Token Launchpad on Solana')
+  .version('1.0.0');
+
+// Verify command
+program
+  .command('verify')
+  .description('Verify an agent before launching')
+  .requiredOption('-n, --name <name>', 'Agent name')
+  .requiredOption('-a, --api <endpoint>', 'Agent API endpoint')
+  .option('-c, --capabilities <caps>', 'Comma-separated capabilities', 'trading,analysis')
+  .option('-g, --github <repo>', 'GitHub repository URL')
+  .action(async (options) => {
+    console.log('\n🔍 MoltLaunch Agent Verification\n');
+    console.log(`Agent: ${options.name}`);
+    console.log(`API: ${options.api}`);
+    console.log(`Capabilities: ${options.capabilities}\n`);
+
+    const agent: AgentProfile = {
+      name: options.name,
+      symbol: 'TEST',
+      description: 'Verification test',
+      capabilities: options.capabilities.split(','),
+      apiEndpoint: options.api,
+      githubRepo: options.github,
+    };
+
+    const verifier = new AgentVerifier();
+    const result = await verifier.verify(agent);
+
+    console.log('Verification Results:');
+    console.log('─'.repeat(40));
+    console.log(`API Liveness:     ${result.checks.apiLiveness ? '✅' : '❌'}`);
+    console.log(`API Responsive:   ${result.checks.apiResponsive ? '✅' : '❌'}`);
+    console.log(`GitHub Exists:    ${result.checks.githubExists ? '✅' : '❌'}`);
+    console.log(`Capabilities:     ${result.checks.capabilitiesVerified ? '✅' : '❌'}`);
+    console.log(`Unique Identity:  ${result.checks.uniqueIdentity ? '✅' : '❌'}`);
+    console.log('─'.repeat(40));
+    console.log(`Final Score:      ${result.score}/100`);
+    console.log(`Status:           ${result.passed ? '✅ PASSED' : '❌ FAILED'}\n`);
+
+    if (!result.passed) {
+      console.log('❗ Minimum score of 60 required to launch');
+      process.exit(1);
+    }
+  });
+
+// Launch command
+program
+  .command('launch')
+  .description('Launch an agent token on Meteora DBC')
+  .requiredOption('-c, --config <file>', 'Agent config file (JSON)')
+  .option('-r, --rpc <url>', 'Solana RPC URL', process.env.RPC_URL || 'https://api.devnet.solana.com')
+  .option('-k, --keypair <file>', 'Keypair file path', './keypair.json')
+  .option('--target <sol>', 'Target raise in SOL', '100')
+  .option('--curve <type>', 'Curve type (linear|exponential|marketcap)', 'linear')
+  .option('--dry-run', 'Simulate without sending transactions', false)
+  .action(async (options) => {
+    console.log('\n🚀 MoltLaunch - AI Agent Token Launch\n');
+
+    // Load agent config
+    if (!fs.existsSync(options.config)) {
+      console.error(`❌ Config file not found: ${options.config}`);
+      process.exit(1);
+    }
+
+    const agentConfig = JSON.parse(fs.readFileSync(options.config, 'utf-8'));
+    const agent: AgentProfile = {
+      name: agentConfig.name,
+      symbol: agentConfig.symbol,
+      description: agentConfig.description,
+      capabilities: agentConfig.capabilities || [],
+      apiEndpoint: agentConfig.apiEndpoint,
+      githubRepo: agentConfig.githubRepo,
+      website: agentConfig.website,
+      twitter: agentConfig.twitter,
+      telegram: agentConfig.telegram,
+      logo: agentConfig.logo,
+    };
+
+    // Load keypair
+    if (!fs.existsSync(options.keypair)) {
+      console.error(`❌ Keypair file not found: ${options.keypair}`);
+      console.log('Generate one with: pnpm studio generate-keypair');
+      process.exit(1);
+    }
+
+    const keypairData = JSON.parse(fs.readFileSync(options.keypair, 'utf-8'));
+    const payer = Keypair.fromSecretKey(new Uint8Array(keypairData));
+
+    console.log(`Agent: ${agent.name} ($${agent.symbol})`);
+    console.log(`Wallet: ${payer.publicKey.toBase58()}`);
+    console.log(`RPC: ${options.rpc}`);
+    console.log(`Target: ${options.target} SOL`);
+    console.log(`Curve: ${options.curve}`);
+    console.log(`Mode: ${options.dryRun ? 'DRY RUN' : 'LIVE'}\n`);
+
+    const launcher = new MoltLauncher({
+      rpcUrl: options.rpc,
+      payer,
+      dryRun: options.dryRun,
+    });
+
+    const launchConfig: Partial<LaunchConfig> = {
+      targetRaise: parseFloat(options.target),
+      curveType: options.curve as 'linear' | 'exponential' | 'marketcap',
+    };
+
+    try {
+      const result = await launcher.launchAgent(agent, launchConfig);
+
+      if (result.success) {
+        console.log('🎉 Launch successful!\n');
+        console.log(`Transaction: ${result.transactionId}`);
+        console.log(`Pool Address: ${result.poolAddress}`);
+        console.log(`Token Mint: ${result.tokenMint}`);
+        console.log(`Config Key: ${result.configKey}`);
+      } else {
+        console.error(`❌ Launch failed: ${result.error}`);
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('❌ Error:', error);
+      process.exit(1);
+    }
+  });
+
+// Status command
+program
+  .command('status')
+  .description('Check launch status')
+  .requiredOption('-m, --mint <address>', 'Token mint address')
+  .option('-r, --rpc <url>', 'Solana RPC URL', process.env.RPC_URL || 'https://api.devnet.solana.com')
+  .action(async (options) => {
+    console.log('\n📊 Launch Status\n');
+    console.log(`Token: ${options.mint}`);
+    console.log('\n⚠️ Status check not yet implemented\n');
+    // TODO: Implement status check via DBC program
+  });
+
+program.parse();

package/src/index.d.ts

@@ -0,0 +1,145 @@
+/**
+ * MoltLaunch SDK Type Definitions
+ */
+
+export interface MoltLaunchOptions {
+    /** API base URL (default: production) */
+    baseUrl?: string;
+    /** Optional API key for premium features */
+    apiKey?: string;
+}
+
+export interface VerifyOptions {
+    /** Unique agent identifier */
+    agentId: string;
+    /** Solana wallet address */
+    wallet?: string;
+    /** Agent capabilities */
+    capabilities?: string[];
+    /** GitHub repository URL */
+    codeUrl?: string;
+    /** Has documentation */
+    documentation?: boolean;
+    /** Test coverage percentage (0-100) */
+    testCoverage?: number;
+    /** Lines of code */
+    codeLines?: number;
+    /** API endpoint URL */
+    apiEndpoint?: string;
+}
+
+export interface VerificationResult {
+    agentId: string;
+    verified: boolean;
+    score: number;
+    tier: 'excellent' | 'good' | 'needs_work' | 'poor';
+    features: Record<string, { value: any; points: number }>;
+    onChainAI: {
+        enabled: boolean;
+        executedOnChain: boolean;
+        vm: string;
+        program: string;
+    };
+    attestation: {
+        type: string;
+        timestamp: string;
+        hash: string;
+    };
+    raw: any;
+}
+
+export interface StatusResult {
+    agentId: string;
+    verified: boolean;
+    score: number | null;
+    tier: string | null;
+    level: 'excellent' | 'verified' | 'unverified';
+    verifiedAt: string | null;
+    onChainAI?: {
+        enabled: boolean;
+        vm: string;
+        program: string;
+    };
+    expiresAt?: string;
+    message?: string;
+}
+
+export interface BatchStatusResult {
+    results: Array<{
+        agentId: string;
+        verified: boolean;
+        score: number | null;
+        tier: string | null;
+    }>;
+    count: number;
+    verified: number;
+}
+
+export interface PoolApplyOptions {
+    agentId: string;
+    wallet: string;
+    topic: string;
+    strategy?: string;
+}
+
+export interface PoolApplyResult {
+    success: boolean;
+    agentId: string;
+    topic: string;
+    status: string;
+    message?: string;
+}
+
+export interface OnChainInfo {
+    enabled: boolean;
+    model: string;
+    deployment: {
+        vm: string;
+        weights: string;
+        program: string;
+    };
+    status: string;
+    features: Array<{
+        name: string;
+        weight: string | number;
+        description: string;
+    }>;
+}
+
+export interface ScoreTier {
+    min: number;
+    max: number;
+    label: string;
+}
+
+export declare const SCORE_TIERS: {
+    excellent: ScoreTier;
+    good: ScoreTier;
+    needs_work: ScoreTier;
+    poor: ScoreTier;
+};
+
+export declare const DEPLOYMENT: {
+    network: string;
+    vm: string;
+    weights: string;
+    program: string;
+};
+
+export declare const DEFAULT_BASE_URL: string;
+
+export declare function getTier(score: number): 'excellent' | 'good' | 'needs_work' | 'poor';
+export declare function isVerified(score: number): boolean;
+
+export declare class MoltLaunch {
+    constructor(options?: MoltLaunchOptions);
+    
+    getOnChainInfo(): Promise<OnChainInfo>;
+    verify(options: VerifyOptions): Promise<VerificationResult>;
+    getStatus(agentId: string): Promise<StatusResult>;
+    getStatusBatch(agentIds: string[]): Promise<BatchStatusResult>;
+    applyToPool(options: PoolApplyOptions): Promise<PoolApplyResult>;
+    getPools(topic?: string): Promise<any>;
+    getLeaderboard(): Promise<any>;
+    isHealthy(): Promise<boolean>;
+}