@moltlaunch/sdk 2.0.0

package/src/types.ts

@@ -0,0 +1,122 @@
+// MoltLaunch Types
+
+export interface AgentProfile {
+  name: string;
+  symbol: string;
+  description: string;
+  capabilities: string[];
+  apiEndpoint: string;
+  githubRepo?: string;
+  website?: string;
+  twitter?: string;
+  telegram?: string;
+  logo?: string; // URL or file path
+}
+
+export interface LaunchConfig {
+  // Token Economics
+  totalSupply: number;
+  targetRaise: number; // in SOL
+  quoteMint?: string; // default SOL
+  
+  // Bonding Curve
+  curveType: 'linear' | 'exponential' | 'marketcap' | 'custom';
+  initialMarketCap?: number;
+  migrationMarketCap?: number;
+  
+  // Migration
+  migrationTarget: 'damm-v1' | 'damm-v2';
+  migrationFeeOption: 0 | 1 | 2 | 3 | 4 | 5; // 0.25% to 6%
+  
+  // LP Distribution (must total 100%)
+  creatorLpPercentage: number;
+  platformLpPercentage: number;
+  creatorLockedLpPercentage: number;
+  platformLockedLpPercentage: number;
+  
+  // Fees
+  tradingFeeBps: number; // basis points
+  creatorFeeShare: number; // 0-100, percentage of trading fees to creator
+  
+  // Anti-rug features
+  vestingEnabled: boolean;
+  vestingDurationDays?: number;
+  cliffDays?: number;
+}
+
+export interface VerificationResult {
+  passed: boolean;
+  score: number; // 0-100
+  checks: {
+    apiLiveness: boolean;
+    apiResponsive: boolean;
+    githubExists: boolean;
+    capabilitiesVerified: boolean;
+    uniqueIdentity: boolean;
+  };
+  attestation?: string; // On-chain proof
+  timestamp: string;
+}
+
+export interface LaunchApplication {
+  id: string;
+  agent: AgentProfile;
+  config: LaunchConfig;
+  verification: VerificationResult | null;
+  status: 'pending' | 'verifying' | 'verified' | 'rejected' | 'live' | 'graduated';
+  createdAt: string;
+  updatedAt: string;
+  launchAddress?: string;
+  tokenMint?: string;
+}
+
+export interface LaunchResult {
+  success: boolean;
+  transactionId?: string;
+  poolAddress?: string;
+  tokenMint?: string;
+  configKey?: string;
+  error?: string;
+}
+
+export interface SwapParams {
+  tokenMint: string;
+  amountIn: number;
+  isBuy: boolean; // true = buy tokens, false = sell tokens
+  slippageBps: number;
+}
+
+export interface SwapResult {
+  success: boolean;
+  transactionId?: string;
+  amountIn: number;
+  amountOut: number;
+  priceImpact: number;
+  newPrice: number;
+  error?: string;
+}
+
+// Meteora DBC Program ID
+export const DBC_PROGRAM_ID = 'dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN';
+
+// MoltLaunch Platform Config
+export const MOLTLAUNCH_CONFIG = {
+  platformWallet: '82rh4CG9bMfVLFcpWwUXAscVkAgtDqCXgcQ4k2bjuoEx',
+  platformFeePercentage: 20, // 20% of trading fees
+  minVerificationScore: 60, // minimum score to launch
+  defaultLaunchConfig: {
+    totalSupply: 1_000_000_000,
+    curveType: 'linear' as const,
+    migrationTarget: 'damm-v2' as const,
+    migrationFeeOption: 2 as const, // 1%
+    creatorLpPercentage: 40,
+    platformLpPercentage: 50,
+    creatorLockedLpPercentage: 5,
+    platformLockedLpPercentage: 5,
+    tradingFeeBps: 100, // 1%
+    creatorFeeShare: 80, // 80/20 split
+    vestingEnabled: true,
+    vestingDurationDays: 30,
+    cliffDays: 7,
+  }
+};

package/src/verification.ts

@@ -0,0 +1,228 @@
+// Agent Verification Service
+import axios from 'axios';
+import { AgentProfile, VerificationResult } from './types';
+
+export class AgentVerifier {
+  private timeout: number;
+
+  constructor(timeout: number = 10000) {
+    this.timeout = timeout;
+  }
+
+  /**
+   * Verify an agent's liveness and capabilities
+   */
+  async verify(agent: AgentProfile): Promise<VerificationResult> {
+    const checks = {
+      apiLiveness: false,
+      apiResponsive: false,
+      githubExists: false,
+      capabilitiesVerified: false,
+      uniqueIdentity: false,
+    };
+
+    // 1. API Liveness Check
+    try {
+      const livenessResult = await this.checkApiLiveness(agent.apiEndpoint);
+      checks.apiLiveness = livenessResult.alive;
+      checks.apiResponsive = livenessResult.responseTime < 5000;
+    } catch (error) {
+      console.log('API liveness check failed:', error);
+    }
+
+    // 2. GitHub Check
+    if (agent.githubRepo) {
+      try {
+        checks.githubExists = await this.checkGithubRepo(agent.githubRepo);
+      } catch (error) {
+        console.log('GitHub check failed:', error);
+      }
+    }
+
+    // 3. Capabilities Verification (via API prompt)
+    if (checks.apiLiveness) {
+      try {
+        checks.capabilitiesVerified = await this.verifyCapabilities(
+          agent.apiEndpoint,
+          agent.capabilities
+        );
+      } catch (error) {
+        console.log('Capability verification failed:', error);
+      }
+    }
+
+    // 4. Unique Identity Check (placeholder for SAID/on-chain identity)
+    checks.uniqueIdentity = true; // TODO: Integrate with SAID protocol
+
+    // Calculate score
+    const score = this.calculateScore(checks);
+    const passed = score >= 60;
+
+    return {
+      passed,
+      score,
+      checks,
+      attestation: passed ? this.generateAttestation(agent, score) : undefined,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  /**
+   * Check if agent API is alive and responsive
+   */
+  private async checkApiLiveness(
+    endpoint: string
+  ): Promise<{ alive: boolean; responseTime: number }> {
+    const start = Date.now();
+    
+    try {
+      // Try common health endpoints
+      const healthEndpoints = [
+        endpoint,
+        `${endpoint}/health`,
+        `${endpoint}/api/health`,
+        `${endpoint}/ping`,
+      ];
+
+      for (const url of healthEndpoints) {
+        try {
+          const response = await axios.get(url, { timeout: this.timeout });
+          if (response.status === 200) {
+            return { alive: true, responseTime: Date.now() - start };
+          }
+        } catch {
+          continue;
+        }
+      }
+
+      // Try POST with verification prompt
+      const response = await axios.post(
+        endpoint,
+        {
+          message: 'MoltLaunch verification ping. Please respond with your agent name.',
+        },
+        { timeout: this.timeout }
+      );
+
+      return {
+        alive: response.status === 200,
+        responseTime: Date.now() - start,
+      };
+    } catch (error) {
+      return { alive: false, responseTime: Date.now() - start };
+    }
+  }
+
+  /**
+   * Check if GitHub repository exists and has recent activity
+   */
+  private async checkGithubRepo(repoUrl: string): Promise<boolean> {
+    try {
+      // Extract owner/repo from URL
+      const match = repoUrl.match(/github\.com\/([^\/]+)\/([^\/]+)/);
+      if (!match) return false;
+
+      const [, owner, repo] = match;
+      const apiUrl = `https://api.github.com/repos/${owner}/${repo.replace('.git', '')}`;
+
+      const response = await axios.get(apiUrl, {
+        timeout: this.timeout,
+        headers: { Accept: 'application/vnd.github.v3+json' },
+      });
+
+      // Check for recent activity (updated in last 30 days)
+      const updatedAt = new Date(response.data.updated_at);
+      const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+      
+      return response.status === 200 && updatedAt > thirtyDaysAgo;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Verify agent capabilities through API interaction
+   */
+  private async verifyCapabilities(
+    endpoint: string,
+    capabilities: string[]
+  ): Promise<boolean> {
+    const verificationPrompts: Record<string, string> = {
+      trading: 'What trading pairs do you support? Respond with a list.',
+      analysis: 'Provide a brief market analysis for SOL.',
+      automation: 'Describe one automation task you can perform.',
+      defi: 'What DeFi protocols do you integrate with?',
+      social: 'What social platforms do you monitor?',
+      nft: 'What NFT marketplaces do you support?',
+    };
+
+    let verifiedCount = 0;
+
+    for (const capability of capabilities) {
+      const prompt = verificationPrompts[capability.toLowerCase()];
+      if (!prompt) continue;
+
+      try {
+        const response = await axios.post(
+          endpoint,
+          { message: prompt },
+          { timeout: this.timeout }
+        );
+
+        // Basic check: response should be non-empty and relevant
+        if (
+          response.status === 200 &&
+          response.data &&
+          (typeof response.data === 'string' ? response.data.length > 20 : true)
+        ) {
+          verifiedCount++;
+        }
+      } catch {
+        continue;
+      }
+    }
+
+    // At least 50% of capabilities should be verified
+    return capabilities.length > 0 && verifiedCount / capabilities.length >= 0.5;
+  }
+
+  /**
+   * Calculate verification score (0-100)
+   */
+  private calculateScore(checks: VerificationResult['checks']): number {
+    const weights = {
+      apiLiveness: 30,
+      apiResponsive: 20,
+      githubExists: 15,
+      capabilitiesVerified: 25,
+      uniqueIdentity: 10,
+    };
+
+    let score = 0;
+    for (const [key, passed] of Object.entries(checks)) {
+      if (passed) {
+        score += weights[key as keyof typeof weights] || 0;
+      }
+    }
+
+    return score;
+  }
+
+  /**
+   * Generate verification attestation (placeholder for on-chain)
+   */
+  private generateAttestation(agent: AgentProfile, score: number): string {
+    const data = {
+      agentName: agent.name,
+      symbol: agent.symbol,
+      score,
+      verifiedAt: new Date().toISOString(),
+      verifier: 'MoltLaunch',
+    };
+
+    // TODO: Create actual on-chain attestation
+    return Buffer.from(JSON.stringify(data)).toString('base64');
+  }
+}
+
+export const verifier = new AgentVerifier();

package/test/basic.js

@@ -0,0 +1,71 @@
+/**
+ * Basic SDK tests
+ */
+
+const { MoltLaunch, getTier, isVerified, DEPLOYMENT } = require('../src/index.js');
+
+async function runTests() {
+    console.log('=== MoltLaunch SDK Tests ===\n');
+
+    // Test helper functions
+    console.log('1. Testing helper functions...');
+    console.assert(getTier(85) === 'excellent', 'getTier(85) should be excellent');
+    console.assert(getTier(70) === 'good', 'getTier(70) should be good');
+    console.assert(getTier(50) === 'needs_work', 'getTier(50) should be needs_work');
+    console.assert(getTier(30) === 'poor', 'getTier(30) should be poor');
+    console.assert(isVerified(60) === true, 'isVerified(60) should be true');
+    console.assert(isVerified(59) === false, 'isVerified(59) should be false');
+    console.log('   ✓ Helper functions work correctly\n');
+
+    // Test constants
+    console.log('2. Testing constants...');
+    console.assert(DEPLOYMENT.vm, 'DEPLOYMENT.vm should exist');
+    console.assert(DEPLOYMENT.program, 'DEPLOYMENT.program should exist');
+    console.log('   ✓ Constants are defined\n');
+
+    // Test API (if available)
+    console.log('3. Testing API connection...');
+    const ml = new MoltLaunch();
+    
+    try {
+        const healthy = await ml.isHealthy();
+        console.log(`   API healthy: ${healthy}`);
+        
+        if (healthy) {
+            // Test on-chain info
+            console.log('\n4. Testing getOnChainInfo...');
+            const info = await ml.getOnChainInfo();
+            console.log(`   Model: ${info.model}`);
+            console.log(`   Status: ${info.status}`);
+            console.log(`   VM: ${info.deployment?.vm?.substring(0, 20)}...`);
+            console.log('   ✓ On-chain info retrieved\n');
+
+            // Test verification
+            console.log('5. Testing verify...');
+            const result = await ml.verify({
+                agentId: 'sdk-test-agent-' + Date.now(),
+                capabilities: ['testing'],
+                documentation: true,
+                codeLines: 1000,
+                testCoverage: 50
+            });
+            console.log(`   Score: ${result.score}`);
+            console.log(`   Tier: ${result.tier}`);
+            console.log(`   Verified: ${result.verified}`);
+            console.log(`   On-chain: ${result.onChainAI?.enabled}`);
+            console.log('   ✓ Verification works\n');
+
+            // Test status
+            console.log('6. Testing getStatus...');
+            const status = await ml.getStatus(result.agentId);
+            console.log(`   Cached: ${status.verified}`);
+            console.log('   ✓ Status lookup works\n');
+        }
+    } catch (error) {
+        console.log(`   ✗ API test failed: ${error.message}\n`);
+    }
+
+    console.log('=== Tests Complete ===');
+}
+
+runTests().catch(console.error);

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}