@moltlaunch/sdk 2.4.0 → 3.0.0

package/src/index.ts

@@ -1,68 +0,0 @@
-// 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

@@ -1,263 +0,0 @@
-// 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);
-}

package/src/types.ts

@@ -1,122 +0,0 @@
-// 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

@@ -1,228 +0,0 @@
-// 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();