@moltlaunch/sdk 2.0.0

package/src/index.js

@@ -0,0 +1,289 @@
+/**
+ * MoltLaunch SDK
+ * On-chain AI verification for AI agents
+ * 
+ * @example
+ * const { MoltLaunch } = require('@moltlaunch/sdk');
+ * const ml = new MoltLaunch();
+ * const result = await ml.verify({ agentId: 'my-agent', capabilities: ['trading'] });
+ */
+
+const DEFAULT_BASE_URL = 'https://web-production-419d9.up.railway.app';
+
+class MoltLaunch {
+    /**
+     * Create a MoltLaunch client
+     * @param {Object} options - Configuration options
+     * @param {string} [options.baseUrl] - API base URL (default: production)
+     * @param {string} [options.apiKey] - Optional API key for premium features
+     */
+    constructor(options = {}) {
+        this.baseUrl = options.baseUrl || DEFAULT_BASE_URL;
+        this.apiKey = options.apiKey || null;
+    }
+
+    /**
+     * Get on-chain AI deployment info
+     * @returns {Promise<OnChainInfo>}
+     */
+    async getOnChainInfo() {
+        const res = await fetch(`${this.baseUrl}/api/onchain-ai`);
+        if (!res.ok) throw new Error(`API error: ${res.status}`);
+        return res.json();
+    }
+
+    /**
+     * Verify an agent using on-chain AI
+     * @param {VerifyOptions} options - Verification options
+     * @returns {Promise<VerificationResult>}
+     */
+    /**
+     * Generate a random nonce for replay protection
+     * @returns {string}
+     */
+    generateNonce() {
+        const bytes = new Uint8Array(16);
+        if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+            crypto.getRandomValues(bytes);
+        } else {
+            // Node.js fallback
+            const nodeCrypto = require('crypto');
+            const buf = nodeCrypto.randomBytes(16);
+            bytes.set(buf);
+        }
+        return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+
+    /**
+     * Verify an agent using on-chain AI (v3.0 with security features)
+     * @param {VerifyOptions} options - Verification options
+     * @returns {Promise<VerificationResult>}
+     */
+    async verify(options) {
+        const {
+            agentId,
+            wallet,
+            capabilities = [],
+            codeUrl,
+            documentation = false,
+            testCoverage = 0,
+            codeLines = 0,
+            apiEndpoint,
+            // v3.0 security options
+            secureMode = false,
+            nonce,
+            timestamp,
+            signature,
+            validityDays = 30
+        } = options;
+
+        if (!agentId) throw new Error('agentId is required');
+
+        // Build request body
+        const body = {
+            agentId,
+            wallet,
+            capabilities,
+            codeUrl,
+            documentation,
+            testCoverage,
+            codeLines,
+            apiEndpoint
+        };
+
+        // Add v3.0 security fields if secure mode
+        if (secureMode) {
+            body.nonce = nonce || this.generateNonce();
+            body.timestamp = timestamp || Math.floor(Date.now() / 1000);
+            body.validityDays = validityDays;
+            if (signature) body.signature = signature;
+        }
+
+        const res = await fetch(`${this.baseUrl}/api/verify/deep`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.apiKey && { 'Authorization': `Bearer ${this.apiKey}` })
+            },
+            body: JSON.stringify(body)
+        });
+
+        if (!res.ok) {
+            const error = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(error.error || `API error: ${res.status}`);
+        }
+
+        const data = await res.json();
+        
+        return {
+            agentId: data.agentId,
+            verified: data.score >= 60,
+            passed: data.passed,
+            score: data.score,
+            tier: data.scoreTier,
+            features: data.features,
+            onChainAI: data.onChainAI,
+            attestation: data.attestation,
+            security: data.security,
+            raw: data
+        };
+    }
+
+    /**
+     * Verify with secure mode enabled (replay-protected)
+     * @param {VerifyOptions} options - Verification options
+     * @returns {Promise<VerificationResult>}
+     */
+    async verifySecure(options) {
+        return this.verify({ ...options, secureMode: true });
+    }
+
+    /**
+     * Check if an attestation is revoked
+     * @param {string} attestationHash - Attestation hash
+     * @returns {Promise<{revoked: boolean, checkedAt: string}>}
+     */
+    async checkRevocation(attestationHash) {
+        const res = await fetch(`${this.baseUrl}/api/verify/revoked/${attestationHash}`);
+        if (!res.ok) throw new Error(`API error: ${res.status}`);
+        return res.json();
+    }
+
+    /**
+     * Renew verification before expiry
+     * @param {string} agentId - Agent ID
+     * @param {object} options - Additional options
+     * @returns {Promise<VerificationResult>}
+     */
+    async renew(agentId, options = {}) {
+        const res = await fetch(`${this.baseUrl}/api/verify/renew/${agentId}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(options)
+        });
+        if (!res.ok) {
+            const error = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(error.error || `API error: ${res.status}`);
+        }
+        return res.json();
+    }
+
+    /**
+     * Get verification status for an agent
+     * @param {string} agentId - Agent ID
+     * @returns {Promise<StatusResult>}
+     */
+    async getStatus(agentId) {
+        const res = await fetch(`${this.baseUrl}/api/verify/status/${encodeURIComponent(agentId)}`);
+        if (!res.ok) throw new Error(`API error: ${res.status}`);
+        return res.json();
+    }
+
+    /**
+     * Get verification status for multiple agents
+     * @param {string[]} agentIds - Array of agent IDs
+     * @returns {Promise<BatchStatusResult>}
+     */
+    async getStatusBatch(agentIds) {
+        const res = await fetch(`${this.baseUrl}/api/verify/status/batch`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ agentIds })
+        });
+        if (!res.ok) throw new Error(`API error: ${res.status}`);
+        return res.json();
+    }
+
+    /**
+     * Apply agent to a staking pool
+     * @param {PoolApplyOptions} options - Pool application options
+     * @returns {Promise<PoolApplyResult>}
+     */
+    async applyToPool(options) {
+        const { agentId, wallet, topic, strategy } = options;
+        
+        const res = await fetch(`${this.baseUrl}/api/pool/apply`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ agentId, wallet, topic, strategy })
+        });
+
+        if (!res.ok) {
+            const error = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(error.error || `API error: ${res.status}`);
+        }
+
+        return res.json();
+    }
+
+    /**
+     * Get pool information
+     * @param {string} [topic] - Optional topic filter
+     * @returns {Promise<PoolInfo>}
+     */
+    async getPools(topic) {
+        const url = topic 
+            ? `${this.baseUrl}/api/pools/${encodeURIComponent(topic)}`
+            : `${this.baseUrl}/api/pools`;
+        const res = await fetch(url);
+        if (!res.ok) throw new Error(`API error: ${res.status}`);
+        return res.json();
+    }
+
+    /**
+     * Get leaderboard
+     * @returns {Promise<LeaderboardResult>}
+     */
+    async getLeaderboard() {
+        const res = await fetch(`${this.baseUrl}/api/pools/leaderboard`);
+        if (!res.ok) throw new Error(`API error: ${res.status}`);
+        return res.json();
+    }
+
+    /**
+     * Check API health
+     * @returns {Promise<boolean>}
+     */
+    async isHealthy() {
+        try {
+            const res = await fetch(`${this.baseUrl}/api/health`);
+            return res.ok;
+        } catch {
+            return false;
+        }
+    }
+}
+
+// Scoring helpers
+const SCORE_TIERS = {
+    excellent: { min: 80, max: 100, label: 'Production Ready' },
+    good: { min: 60, max: 79, label: 'Verified' },
+    needs_work: { min: 40, max: 59, label: 'Needs Improvement' },
+    poor: { min: 0, max: 39, label: 'Not Ready' }
+};
+
+const getTier = (score) => {
+    if (score >= 80) return 'excellent';
+    if (score >= 60) return 'good';
+    if (score >= 40) return 'needs_work';
+    return 'poor';
+};
+
+const isVerified = (score) => score >= 60;
+
+// On-chain AI deployment info
+const DEPLOYMENT = {
+    network: 'solana-devnet',
+    vm: 'FHcy35f4NGZK9b6j5TGMYstfB6PXEtmNbMLvjfR1y2Li',
+    weights: 'GnSxMWbZEa538vJ9Pf3veDrKP1LkzPiaaVmC4mRnM91N',
+    program: 'FRsToriMLgDc1Ud53ngzHUZvCRoazCaGeGUuzkwoha7m'
+};
+
+module.exports = {
+    MoltLaunch,
+    SCORE_TIERS,
+    DEPLOYMENT,
+    getTier,
+    isVerified,
+    DEFAULT_BASE_URL
+};

package/src/index.ts

@@ -0,0 +1,68 @@
+// MoltLaunch SDK - AI Agent Token Launches on Solana
+// Built on Meteora Dynamic Bonding Curve (DBC)
+
+export * from './types';
+export * from './verification';
+export * from './launcher';
+
+import { MoltLauncher, LaunchOptions, quickLaunch } from './launcher';
+import { AgentVerifier, verifier } from './verification';
+import {
+  AgentProfile,
+  LaunchConfig,
+  VerificationResult,
+  LaunchResult,
+  MOLTLAUNCH_CONFIG,
+  DBC_PROGRAM_ID,
+} from './types';
+
+/**
+ * MoltLaunch SDK
+ * 
+ * The first dedicated launchpad for AI agent token sales on Solana.
+ * Built on Meteora's Dynamic Bonding Curve for fair, transparent launches.
+ * 
+ * Features:
+ * - Proof-of-Agent verification before launch
+ * - Customizable bonding curves (linear, exponential, market cap)
+ * - Automatic graduation to Meteora AMM
+ * - Milestone-based team vesting
+ * - 80/20 fee split (creator/platform)
+ * 
+ * Quick Start:
+ * ```typescript
+ * import { MoltLauncher, AgentProfile } from '@moltlaunch/sdk';
+ * 
+ * const agent: AgentProfile = {
+ *   name: 'TradingBot Pro',
+ *   symbol: 'TBP',
+ *   description: 'Autonomous trading agent with proven alpha generation',
+ *   capabilities: ['trading', 'analysis', 'automation'],
+ *   apiEndpoint: 'https://tradingbot.example.com/api',
+ *   githubRepo: 'https://github.com/example/tradingbot',
+ * };
+ * 
+ * const launcher = new MoltLauncher({
+ *   rpcUrl: 'https://api.devnet.solana.com',
+ *   payer: yourKeypair,
+ *   dryRun: true,
+ * });
+ * 
+ * const result = await launcher.launchAgent(agent, {
+ *   targetRaise: 500, // SOL
+ *   curveType: 'exponential',
+ * });
+ * ```
+ */
+
+export default {
+  MoltLauncher,
+  AgentVerifier,
+  quickLaunch,
+  verifier,
+  config: MOLTLAUNCH_CONFIG,
+  programId: DBC_PROGRAM_ID,
+};
+
+// Version
+export const VERSION = '1.0.0';

package/src/launcher.ts

@@ -0,0 +1,263 @@
+// MoltLaunch - Token Launch on Meteora DBC
+import {
+  Connection,
+  Keypair,
+  PublicKey,
+  TransactionInstruction,
+  VersionedTransaction,
+  TransactionMessage,
+  LAMPORTS_PER_SOL,
+} from '@solana/web3.js';
+import {
+  AgentProfile,
+  LaunchConfig,
+  LaunchResult,
+  SwapParams,
+  SwapResult,
+  DBC_PROGRAM_ID,
+  MOLTLAUNCH_CONFIG,
+} from './types';
+import { AgentVerifier } from './verification';
+
+export interface LaunchOptions {
+  rpcUrl: string;
+  payer: Keypair;
+  dryRun?: boolean;
+}
+
+export class MoltLauncher {
+  private connection: Connection;
+  private payer: Keypair;
+  private dryRun: boolean;
+  private verifier: AgentVerifier;
+
+  constructor(options: LaunchOptions) {
+    this.connection = new Connection(options.rpcUrl, 'confirmed');
+    this.payer = options.payer;
+    this.dryRun = options.dryRun ?? false;
+    this.verifier = new AgentVerifier();
+  }
+
+  /**
+   * Full launch flow: verify agent -> create DBC config -> create pool
+   */
+  async launchAgent(
+    agent: AgentProfile,
+    config: Partial<LaunchConfig> = {}
+  ): Promise<LaunchResult> {
+    console.log(`\n🚀 Starting launch for ${agent.name} ($${agent.symbol})\n`);
+
+    // 1. Verify agent
+    console.log('📋 Step 1: Verifying agent...');
+    const verification = await this.verifier.verify(agent);
+    
+    if (!verification.passed) {
+      return {
+        success: false,
+        error: `Verification failed with score ${verification.score}/100. Minimum required: ${MOLTLAUNCH_CONFIG.minVerificationScore}`,
+      };
+    }
+    console.log(`✅ Verification passed! Score: ${verification.score}/100\n`);
+
+    // 2. Merge with default config
+    const launchConfig: LaunchConfig = {
+      ...MOLTLAUNCH_CONFIG.defaultLaunchConfig,
+      targetRaise: 100, // Default 100 SOL
+      ...config,
+    };
+
+    // 3. Generate DBC configuration
+    console.log('⚙️ Step 2: Generating DBC configuration...');
+    const dbcConfig = this.generateDbcConfig(agent, launchConfig);
+    console.log(`   Curve Type: ${launchConfig.curveType}`);
+    console.log(`   Target Raise: ${launchConfig.targetRaise} SOL`);
+    console.log(`   Migration: ${launchConfig.migrationTarget}\n`);
+
+    if (this.dryRun) {
+      console.log('🔍 DRY RUN MODE - No transactions will be sent\n');
+      console.log('Generated DBC Config:', JSON.stringify(dbcConfig, null, 2));
+      return {
+        success: true,
+        transactionId: 'dry-run-no-tx',
+        poolAddress: 'dry-run-pool-address',
+        tokenMint: 'dry-run-token-mint',
+        configKey: 'dry-run-config-key',
+      };
+    }
+
+    // 4. Create DBC Config (on-chain)
+    console.log('📝 Step 3: Creating DBC config on-chain...');
+    // TODO: Implement actual DBC config creation using Meteora SDK
+    // This would use the @mercurial-finance/dynamic-amm-sdk or similar
+    
+    // For now, we return a placeholder
+    console.log('⚠️ Note: Full DBC integration requires Meteora SDK\n');
+    
+    return {
+      success: true,
+      transactionId: 'pending-integration',
+      poolAddress: 'pending-integration',
+      tokenMint: 'pending-integration',
+      configKey: 'pending-integration',
+    };
+  }
+
+  /**
+   * Generate DBC-compatible configuration from MoltLaunch config
+   */
+  private generateDbcConfig(agent: AgentProfile, config: LaunchConfig) {
+    // Map our config to Meteora DBC format
+    const buildCurveMode = {
+      linear: 0,
+      exponential: 1,
+      marketcap: 1,
+      custom: 3,
+    }[config.curveType];
+
+    return {
+      // Network
+      rpcUrl: this.connection.rpcEndpoint,
+      dryRun: this.dryRun,
+      computeUnitPriceMicroLamports: 100000,
+      quoteMint: config.quoteMint || 'So11111111111111111111111111111111111111112', // SOL
+
+      // DBC Config
+      dbcConfig: {
+        buildCurveMode,
+        
+        // Supply & Migration
+        totalTokenSupply: config.totalSupply,
+        migrationQuoteThreshold: config.targetRaise,
+        percentageSupplyOnMigration: 20,
+        
+        // For marketcap mode
+        ...(config.curveType === 'marketcap' && {
+          initialMarketCap: config.initialMarketCap || config.targetRaise * 0.1,
+          migrationMarketCap: config.migrationMarketCap || config.targetRaise * 5,
+        }),
+
+        // Migration settings
+        migrationOption: config.migrationTarget === 'damm-v2' ? 1 : 0,
+        migrationFeeOption: config.migrationFeeOption,
+        
+        // Token settings
+        tokenBaseDecimal: 6,
+        tokenQuoteDecimal: 9,
+        tokenType: 0, // SPL Token
+        tokenUpdateAuthority: 1, // Immutable
+
+        // Fee structure
+        baseFeeParams: {
+          baseFeeMode: 0,
+          feeSchedulerParam: {
+            startingFeeBps: config.tradingFeeBps,
+            endingFeeBps: config.tradingFeeBps,
+            numberOfPeriod: 0,
+            totalDuration: 0,
+          },
+        },
+        dynamicFeeEnabled: true,
+        collectFeeMode: 0, // Quote token only
+        activationType: 1, // Timestamp
+
+        // LP Distribution
+        partnerLiquidityPercentage: config.platformLpPercentage,
+        creatorLiquidityPercentage: config.creatorLpPercentage,
+        partnerPermanentLockedLiquidityPercentage: config.platformLockedLpPercentage,
+        creatorPermanentLockedLiquidityPercentage: config.creatorLockedLpPercentage,
+        creatorTradingFeePercentage: config.creatorFeeShare,
+
+        // Vesting (if enabled)
+        lockedVestingParams: config.vestingEnabled
+          ? {
+              totalLockedVestingAmount: 0,
+              numberOfVestingPeriod: Math.ceil((config.vestingDurationDays || 30) / 7),
+              cliffUnlockAmount: 0,
+              totalVestingDuration: (config.vestingDurationDays || 30) * 24 * 60 * 60,
+              cliffDurationFromMigrationTime: (config.cliffDays || 7) * 24 * 60 * 60,
+            }
+          : {
+              totalLockedVestingAmount: 0,
+              numberOfVestingPeriod: 0,
+              cliffUnlockAmount: 0,
+              totalVestingDuration: 0,
+              cliffDurationFromMigrationTime: 0,
+            },
+
+        // Addresses
+        leftover: 0,
+        leftoverReceiver: MOLTLAUNCH_CONFIG.platformWallet,
+        feeClaimer: MOLTLAUNCH_CONFIG.platformWallet,
+        
+        // Migration fee
+        migrationFee: {
+          feePercentage: 0,
+          creatorFeePercentage: 0,
+        },
+        poolCreationFee: 0,
+      },
+
+      // Pool creation
+      dbcPool: {
+        creator: this.payer.publicKey.toBase58(),
+        name: agent.name,
+        symbol: agent.symbol,
+        metadata: {
+          description: agent.description,
+          website: agent.website,
+          twitter: agent.twitter,
+          telegram: agent.telegram,
+          image: agent.logo,
+        },
+      },
+    };
+  }
+
+  /**
+   * Get current pool status
+   */
+  async getPoolStatus(tokenMint: string): Promise<{
+    exists: boolean;
+    currentRaise: number;
+    targetRaise: number;
+    progress: number;
+    currentPrice: number;
+    graduated: boolean;
+  } | null> {
+    // TODO: Query DBC program for pool state
+    return null;
+  }
+
+  /**
+   * Buy/sell tokens on bonding curve
+   */
+  async swap(params: SwapParams): Promise<SwapResult> {
+    // TODO: Implement swap via DBC program
+    return {
+      success: false,
+      error: 'Swap not yet implemented - requires Meteora DBC SDK integration',
+      amountIn: params.amountIn,
+      amountOut: 0,
+      priceImpact: 0,
+      newPrice: 0,
+    };
+  }
+}
+
+/**
+ * Quick launch helper function
+ */
+export async function quickLaunch(
+  agent: AgentProfile,
+  payerSecretKey: Uint8Array,
+  rpcUrl: string = 'https://api.devnet.solana.com',
+  config: Partial<LaunchConfig> = {}
+): Promise<LaunchResult> {
+  const launcher = new MoltLauncher({
+    rpcUrl,
+    payer: Keypair.fromSecretKey(payerSecretKey),
+    dryRun: true, // Default to dry run for safety
+  });
+
+  return launcher.launchAgent(agent, config);
+}