LaunchLab

Endpoints for creating and managing tokens with bonding curve mechanics for fair launches.

---

POST /launchpad/create-unsigned

Create unsigned transaction for Raydium LaunchLab bonding curve deployment.

Endpoint

POST https://api.vision.meme/launchpad/create-unsigned

Authentication

Required - Include JWT token in Authorization header

Request Body

Field	Type	Required	Description
tokenMint	string	✅	Token mint address
tokenAmount	string	✅	Tokens for bonding curve (base units)
targetMarketCap	string	✅	Target SOL to raise

Request Example

json

{
  "tokenMint": "TokenMint1111111111111111111111111111111",
  "tokenAmount": "800000000000",
  "targetMarketCap": "100000"
}

Example Calculations

Small Launch:

json

{
  "tokenMint": "...",
  "tokenAmount": "600000000000",  // 600M tokens (60% of 1B)
  "targetMarketCap": "25000"      // 25 SOL target
}

Medium Launch:

json

{
  "tokenMint": "...",
  "tokenAmount": "750000000000",  // 750M tokens (75% of 1B)
  "targetMarketCap": "100000"     // 100 SOL target
}

Large Launch:

json

{
  "tokenMint": "...",
  "tokenAmount": "900000000000",  // 900M tokens (90% of 1B)
  "targetMarketCap": "500000"     // 500 SOL target
}

Response (200 OK)

json

{
  "transaction": "AQAAAAAAAAAAAAAA...",
  "bondingCurveId": "bonding_curve_identifier",
  "expectedLaunchTime": "2024-01-15T12:00:00Z",
  "curveParameters": {
    "startPrice": "0.0000001250",
    "endPrice": "0.0000006250",
    "priceMultiplier": 5
  }
}

Response Fields

Field	Type	Description
transaction	string	Base64-encoded unsigned transaction
bondingCurveId	string	Unique bonding curve identifier
expectedLaunchTime	string	Estimated completion time
curveParameters.startPrice	string	Initial token price
curveParameters.endPrice	string	Final token price
curveParameters.priceMultiplier	number	Price increase factor

Code Example

javascript

async function createBondingCurve(tokenMint, tokenAmount, targetMC, authToken, wallet) {
  // Create unsigned transaction
  const response = await fetch('https://api.vision.meme/launchpad/create-unsigned', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${authToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      tokenMint,
      tokenAmount,
      targetMarketCap: targetMC
    })
  });
  
  if (!response.ok) {
    const error = await response.json();
    throw new Error(error.error);
  }
  
  const { transaction, bondingCurveId, curveParameters } = await response.json();
  
  console.log('Bonding Curve Details:');
  console.log('Curve ID:', bondingCurveId);
  console.log('Start Price:', curveParameters.startPrice, 'SOL');
  console.log('End Price:', curveParameters.endPrice, 'SOL');
  console.log('Price Multiplier:', curveParameters.priceMultiplier + 'x');
  
  // Sign transaction
  const txBuffer = Buffer.from(transaction, 'base64');
  const tx = Transaction.from(txBuffer);
  const signedTx = await wallet.signTransaction(tx);
  
  // Send to Solana
  const signature = await connection.sendRawTransaction(
    signedTx.serialize()
  );
  
  await connection.confirmTransaction(signature);
  
  console.log('✅ Bonding curve deployed!');
  console.log('Transaction:', signature);
  console.log('Bonding Curve ID:', bondingCurveId);
  
  return { bondingCurveId, signature };
}

// Usage: Deploy bonding curve for 800M tokens with 100 SOL target
await createBondingCurve(
  mintAddress,
  '800000000000',  // 800M tokens (6 decimals)
  '100000',        // 100 SOL target (in base units: 100000 / 1000 = 100 SOL)
  token,
  wallet
);

Important Notes

• Transaction must be signed and submitted by user

• Bonding curve activates immediately upon deployment

• Target market cap in millionths of SOL (100000 = 100 SOL)

• Price increases automatically with each purchase

• When target reached, liquidity pool created automatically

---

GET /launchpad/:mintAddress/status

Get bonding curve status and progress for a token launch.

Endpoint

GET https://api.vision.meme/launchpad/:mintAddress/status

Authentication

Public - No authentication required

Path Parameters

Parameter	Type	Description
mintAddress	string	Token mint address

Request Example

bash

GET https://api.vision.meme/launchpad/TokenMint1111111111111111111111111111111/status

Response (200 OK)

json

{
  "bondingCurveId": "bonding_curve_identifier",
  "status": "active",
  "currentMarketCap": "45000",
  "targetMarketCap": "100000",
  "progress": 45,
  "tokensSold": "360000000000",
  "totalTokens": "800000000000",
  "solCollected": "45.5",
  "uniqueBuyers": 234,
  "createdAt": "2024-01-01T12:00:00Z",
  "estimatedCompletion": "2024-01-01T18:30:00Z"
}

Response Fields

Field	Type	Description
bondingCurveId	string	Curve identifier
status	string	"active", "completed", or "cancelled"
currentMarketCap	string	SOL collected so far
targetMarketCap	string	Target SOL to raise
progress	number	Percentage completed (0-100)
tokensSold	string	Tokens sold from curve
totalTokens	string	Total tokens on curve
solCollected	string	SOL collected (human-readable)
uniqueBuyers	number	Number of unique wallets
createdAt	string	When curve was created
estimatedCompletion	string	Estimated finish time

Status Values

• active - Bonding curve is currently accepting purchases

• completed - Target reached, liquidity pool created

• cancelled - Launch cancelled by creator

Code Example

javascript

async function checkBondingStatus(mintAddress) {
  const response = await fetch(
    `https://api.vision.meme/launchpad/${mintAddress}/status`
  );
  
  if (response.status === 404) {
    console.log('No bonding curve found for this token');
    return null;
  }
  
  const status = await response.json();
  
  console.log('Bonding Curve Status:');
  console.log('Status:', status.status);
  console.log('Progress:', status.progress + '%');
  console.log('SOL Collected:', status.solCollected, '/', status.targetMarketCap / 1000);
  console.log('Tokens Sold:', parseInt(status.tokensSold) / 1e6, 'M');
  console.log('Unique Buyers:', status.uniqueBuyers);
  
  if (status.status === 'active') {
    console.log('Estimated Completion:', status.estimatedCompletion);
  } else if (status.status === 'completed') {
    console.log('✅ Bonding curve completed! Trading is now live.');
  }
  
  return status;
}

// Usage
const status = await checkBondingStatus(mintAddress);

Monitoring Progress

javascript

async function monitorBondingProgress(mintAddress, onUpdate) {
  let lastProgress = 0;
  
  const checkStatus = async () => {
    const status = await fetch(
      `https://api.vision.meme/launchpad/${mintAddress}/status`
    ).then(r => r.json());
    
    // Call update callback if progress changed
    if (status.progress !== lastProgress) {
      lastProgress = status.progress;
      onUpdate(status);
    }
    
    // Stop monitoring if completed
    if (status.status === 'completed') {
      console.log('✅ Bonding curve completed!');
      clearInterval(intervalId);
      return;
    }
  };
  
  // Check immediately
  await checkStatus();
  
  // Then check every 10 seconds
  const intervalId = setInterval(checkStatus, 10000);
  
  return () => clearInterval(intervalId); // Return cleanup function
}

// Usage
const stopMonitoring = await monitorBondingProgress(
  mintAddress,
  (status) => {
    console.log(`Progress: ${status.progress}%`);
    console.log(`SOL: ${status.solCollected} / ${status.targetMarketCap / 1000}`);
    updateUI(status); // Update your UI
  }
);

// Later: stop monitoring
stopMonitoring();

---

GET /launchpad/:mintAddress/price

Get current price quote for purchasing from bonding curve.

Endpoint

GET https://api.vision.meme/launchpad/:mintAddress/price

Authentication

Public - No authentication required

Query Parameters

Parameter	Type	Required	Description
amount	string	✅	Token amount to purchase (base units)

Request Example

bash

GET https://api.vision.meme/launchpad/TokenMint1111.../price?amount=1000000000

Response (200 OK)

json

{
  "tokenAmount": "1000000000",
  "solCost": "1.234",
  "currentPrice": "0.000001234",
  "priceImpact": 2.5,
  "nextPrice": "0.000001265"
}

Response Fields

Field	Type	Description
tokenAmount	string	Requested token amount
solCost	string	Cost in SOL (human-readable)
currentPrice	string	Current price per token
priceImpact	number	Price increase % from this purchase
nextPrice	string	Price after this purchase

Code Example

javascript

async function getBondingPrice(mintAddress, tokenAmount) {
  const response = await fetch(
    `https://api.vision.meme/launchpad/${mintAddress}/price?amount=${tokenAmount}`
  );
  
  const price = await response.json();
  
  console.log('Price Quote:');
  console.log('Tokens:', parseInt(price.tokenAmount) / 1e6, 'M');
  console.log('Cost:', price.solCost, 'SOL');
  console.log('Current Price:', price.currentPrice, 'SOL per token');
  console.log('Price Impact:', price.priceImpact + '%');
  console.log('Next Price:', price.nextPrice, 'SOL per token');
  
  return price;
}

// Usage: Get price for 1M tokens
await getBondingPrice(mintAddress, '1000000000');

Calculate Purchase Amount

javascript

async function calculatePurchase(mintAddress, solAmount) {
  // Binary search to find token amount for desired SOL amount
  let low = 1000000; // 1 token (6 decimals)
  let high = 1000000000000; // 1M tokens
  let bestAmount = 0;
  
  while (low <= high) {
    const mid = Math.floor((low + high) / 2);
    const price = await fetch(
      `https://api.vision.meme/launchpad/${mintAddress}/price?amount=${mid}`
    ).then(r => r.json());
    
    const cost = parseFloat(price.solCost);
    
    if (Math.abs(cost - solAmount) < 0.001) {
      bestAmount = mid;
      break;
    }
    
    if (cost < solAmount) {
      bestAmount = mid;
      low = mid + 1;
    } else {
      high = mid - 1;
    }
  }
  
  const finalPrice = await fetch(
    `https://api.vision.meme/launchpad/${mintAddress}/price?amount=${bestAmount}`
  ).then(r => r.json());
  
  console.log(`For ${solAmount} SOL, you can buy:`);
  console.log('Tokens:', parseInt(finalPrice.tokenAmount) / 1e6, 'M');
  console.log('Exact Cost:', finalPrice.solCost, 'SOL');
  
  return finalPrice;
}

// Usage: Calculate tokens for 10 SOL
await calculatePurchase(mintAddress, 10);

---

Complete Bonding Curve Flow

javascript

class BondingCurveLauncher {
  constructor(tokenMint, authToken, wallet, connection) {
    this.tokenMint = tokenMint;
    this.authToken = authToken;
    this.wallet = wallet;
    this.connection = connection;
    this.bondingCurveId = null;
  }
  
  async deploy(tokenAmount, targetMarketCap) {
    console.log('Deploying bonding curve...');
    
    // Create unsigned transaction
    const response = await fetch('https://api.vision.meme/launchpad/create-unsigned', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.authToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        tokenMint: this.tokenMint,
        tokenAmount,
        targetMarketCap
      })
    });
    
    const { transaction, bondingCurveId, curveParameters } = await response.json();
    this.bondingCurveId = bondingCurveId;
    
    console.log('Curve Parameters:', curveParameters);
    
    // Sign and submit
    const txBuffer = Buffer.from(transaction, 'base64');
    const tx = Transaction.from(txBuffer);
    const signedTx = await this.wallet.signTransaction(tx);
    const signature = await this.connection.sendRawTransaction(
      signedTx.serialize()
    );
    
    await this.connection.confirmTransaction(signature);
    
    console.log('✅ Bonding curve deployed!');
    console.log('Signature:', signature);
    
    return { bondingCurveId, signature };
  }
  
  async getStatus() {
    const response = await fetch(
      `https://api.vision.meme/launchpad/${this.tokenMint}/status`
    );
    return await response.json();
  }
  
  async getPrice(tokenAmount) {
    const response = await fetch(
      `https://api.vision.meme/launchpad/${this.tokenMint}/price?amount=${tokenAmount}`
    );
    return await response.json();
  }
  
  async monitorProgress(onUpdate, interval = 10000) {
    const checkStatus = async () => {
      const status = await this.getStatus();
      onUpdate(status);
      
      if (status.status === 'completed') {
        console.log('✅ Bonding curve completed!');
        clearInterval(intervalId);
      }
    };
    
    await checkStatus();
    const intervalId = setInterval(checkStatus, interval);
    
    return () => clearInterval(intervalId);
  }
}

// Usage
const launcher = new BondingCurveLauncher(
  mintAddress,
  authToken,
  wallet,
  connection
);

// Deploy bonding curve
await launcher.deploy(
  '800000000000',  // 800M tokens
  '100000'         // 100 SOL target
);

// Monitor progress
await launcher.monitorProgress((status) => {
  console.log(`Progress: ${status.progress}%`);
  console.log(`Buyers: ${status.uniqueBuyers}`);
  updateDashboard(status);
});

// Get current price
const price = await launcher.getPrice('1000000000');
console.log('Price for 1M tokens:', price.solCost, 'SOL');

---

Best Practices

Setting Target Market Cap

javascript

function calculateRecommendedTarget(communitySize) {
  // Small community: 50-200 members
  if (communitySize < 200) {
    return '25000'; // 25 SOL
  }
  
  // Medium community: 200-1000 members
  if (communitySize < 1000) {
    return '100000'; // 100 SOL
  }
  
  // Large community: 1000+ members
  return '250000'; // 250 SOL
}

const target = calculateRecommendedTarget(500);
console.log('Recommended target:', parseInt(target) / 1000, 'SOL');

Token Allocation

javascript

function calculateTokenAllocation(totalSupply) {
  // Recommended: 70-80% on bonding curve
  const bondingAmount = Math.floor(totalSupply * 0.75);
  const creatorAmount = totalSupply - bondingAmount;
  
  console.log('Recommended Allocation:');
  console.log('Bonding Curve:', bondingAmount / 1e6, 'M tokens (75%)');
  console.log('Creator:', creatorAmount / 1e6, 'M tokens (25%)');
  
  return {
    bonding: bondingAmount.toString(),
    creator: creatorAmount.toString()
  };
}

const allocation = calculateTokenAllocation(1000000000000); // 1B tokens

---

Rate Limits

Endpoint	Limit
POST /launchpad/create-unsigned	10 per hour
GET /launchpad/:mintAddress/status	100 per 15 min
GET /launchpad/:mintAddress/price	100 per 15 min

---

Next Steps

• Token Endpoints - Create tokens first

• Distribution Settings - Configure after graduation

• DEX Integration - Alternative to bonding

---

© 2025 Vision.meme. All rights reserved.