import { createLaunchpadSDK, createWallet } from '@gala-chain/launchpad-sdk';

// Auto-detect wallet format and create SDK
const sdk = createLaunchpadSDK({
  wallet: 'your-private-key-or-mnemonic' // Auto-detects format!
});

// Direct result access - no wrapper objects!
const pools = await sdk.fetchPools({ type: 'recent' });
console.log(`Found ${pools.total} pools`); // Direct property access
console.log(`Page ${pools.page} of ${pools.totalPages}`); // Clean pagination
console.log(`Has next: ${pools.hasNext}`); // Boolean convenience properties

// Clean typed results everywhere
const balance = await sdk.fetchGalaBalance();
console.log(`Balance: ${balance.balance} GALA`); // Direct balance access
console.log(`Last updated: ${balance.lastUpdated.toISOString()}`); // Date object

// Get pools with direct property access
const pools = await sdk.fetchPools({ type: 'recent' });
console.log(pools.pools); // Direct access to pool array
console.log(pools.total); // Immediate pagination info
console.log(pools.hasNext); // Computed convenience properties

import { createLaunchpadSDK } from '@gala-chain/launchpad-sdk';

const sdk = createLaunchpadSDK({
  wallet: 'your-private-key-or-mnemonic'
});

import { createLaunchpadSDK } from '@gala-chain/launchpad-sdk';

// Auto-detecting SDK creation (easiest method)
const sdk = createLaunchpadSDK({
  wallet: 'your-private-key-or-mnemonic' // Auto-detects format!
});

// Clean, direct result access - All methods use options objects

// Pool Management - Direct result properties
const pools = await sdk.fetchPools({ type: 'recent', limit: 10 });
console.log(`Found ${pools.total} pools across ${pools.totalPages} pages`);
console.log(`Current page: ${pools.page}, Has next: ${pools.hasNext}`);

const badges = await sdk.fetchTokenBadges('dragnrkti');
console.log(`Volume badges: ${badges.volumeBadges.length}`);
console.log(`Engagement badges: ${badges.engagementBadges.length}`);

const details = await sdk.fetchPoolDetails('dragnrkti');
console.log(`Sale status: ${details.saleStatus}`);
console.log(`Native token quantity: ${details.nativeTokenQuantity}`);

// Price Calculations - Direct amount access
const buyAmount = await sdk.calculateBuyAmount({
  tokenName: 'dragnrkti',
  amount: '1', // 1 GALA
  type: 'native'
});
console.log(`Buy amount: ${buyAmount.amount}`);
console.log(`Transaction fee: ${buyAmount.transactionFee}`);

// Trading Operations - Required expectedAmount and slippageToleranceFactor
const buyResult = await sdk.buy({
  tokenName: 'dragnrkti',
  amount: '1',
  type: 'native',
  expectedAmount: buyAmount.amount,  // Required: from calculation
  slippageToleranceFactor: 0.05  // Required: decimal format (5% slippage)
});
console.log(`Transaction ID: ${buyResult.transactionId}`);

// Data & Analytics - Clean pagination
const trades = await sdk.fetchTrades({ tokenName: 'dragnrkti' });
console.log(`Found ${trades.total} trades`);
console.log(`Page ${trades.page} of ${trades.totalPages}`);
trades.trades.forEach(trade => {
  console.log(`Trade: ${trade.tradeType} ${trade.tokenAmount} at ${trade.createdAt.toISOString()}`);
});

const comments = await sdk.fetchComments({ tokenName: 'dragnrkti' });
console.log(`${comments.total} comments found`);

// User Operations - Direct balance access
const galaBalance = await sdk.fetchGalaBalance();
console.log(`GALA Balance: ${galaBalance.balance}`);
console.log(`Last updated: ${galaBalance.lastUpdated.toISOString()}`);

const tokenBalance = await sdk.fetchTokenBalance({
  tokenName: 'dragnrkti',
  address: sdk.getAddress()
});
console.log(`Token balance: ${tokenBalance.quantity}`);
console.log(`USD value: $${tokenBalance.holdingPriceUsd}`);

// Profile - Direct user data
const profile = await sdk.fetchProfile();
console.log(`Profile name: ${profile.fullName || 'Not set'}`);

// URL Utilities - Generate frontend URLs
const tokenUrl = sdk.getUrlByTokenName('dragnrkti');
console.log(`View token: ${tokenUrl}`);
// Output: https://lpad-frontend-test1.defi.gala.com/buy-sell/dragnrkti

import { createLaunchpadSDK } from '@gala-chain/launchpad-sdk';

const sdk = createLaunchpadSDK({
  wallet: 'your-private-key-or-mnemonic'
});

// MODE 1: Single Page (backward compatible)
// Limit <= 20: Single API call
const recent = await sdk.fetchPools({ type: 'recent', limit: 20 });
console.log(`Fetched ${recent.pools.length} pools in one request`);

// MODE 2: Multi-Page Auto-Fetch
// Limit > 20: Automatic concurrent multi-page fetching
const large = await sdk.fetchPools({ type: 'popular', limit: 100 });
console.log(`Fetched ${large.pools.length} pools across multiple pages`);
// Internally fetches 5 pages concurrently: 20+20+20+20+20 = 100 pools

// MODE 3: Infinite Fetch
// Limit = 0: Fetches ALL available pools
const all = await sdk.fetchPools({ limit: 0 });
console.log(`Fetched all ${all.pools.length} pools from the platform`);

// Convenience method for "fetch all" pattern
const allRecent = await sdk.fetchAllPools({ type: 'recent' });
console.log(`Total pools: ${allRecent.total}`);

import { MAX_CONCURRENT_POOL_FETCHES } from '@gala-chain/launchpad-sdk';

console.log(`SDK fetches up to ${MAX_CONCURRENT_POOL_FETCHES} pages concurrently`);
// Output: "SDK fetches up to 5 pages concurrently"

async function scanEntireMarket() {
  // Fetch all pools at once (auto-pagination handles everything)
  const allPools = await sdk.fetchAllPools({ type: 'popular' });

  console.log(`Scanning ${allPools.total} pools...`);

  // Filter for interesting opportunities
  const highVolume = allPools.pools.filter(pool =>
    parseFloat(pool.volumeGala) > 10000
  );

  console.log(`Found ${highVolume.length} high-volume pools`);

  return highVolume;
}

// Fetch all recent pools
const allRecent = await sdk.fetchAllPools({ type: 'recent' });

// Fetch all pools matching search
const dragons = await sdk.fetchAllPools({ search: 'dragon' });

// Fetch specific token across all results
const specific = await sdk.fetchAllPools({ tokenName: 'anime' });

// Equivalent to fetchPools({ limit: 0 })
const all = await sdk.fetchAllPools();

import { Wallet } from 'ethers';
import { LaunchpadSDK } from '@gala-chain/launchpad-sdk';

// Create wallet manually
const wallet = new Wallet(process.env.PRIVATE_KEY);

// Initialize SDK
const sdk = new LaunchpadSDK({
  wallet: wallet,
  baseUrl: 'https://lpad-backend-dev1.defi.gala.com',
  timeout: 30000,
  debug: false
});

// Same clean API available
const pools = await sdk.fetchPools({ type: 'recent' });
console.log(`${pools.total} pools found`);

import { createLaunchpadSDK } from '@gala-chain/launchpad-sdk';

// 1. Create SDK with auto-detection
const sdk = createLaunchpadSDK({
  wallet: 'your-private-key-or-mnemonic'
});

// 2. Check available pools - direct access to results
const pools = await sdk.fetchPools({
  type: 'recent',
  limit: 10
});

console.log(`Found ${pools.total} pools across ${pools.totalPages} pages`);
pools.pools.forEach(pool => {
  console.log(`Pool: ${pool.tokenName} created at ${pool.createdAt}`);
});

// 3. Get price quote - direct amount access
const quote = await sdk.calculateBuyAmount({
  tokenName: 'tinyevil',
  amount: '100',
  type: 'native'
});

console.log(`Buying 100 GALA worth will get you: ${quote.amount} TINYEVIL`);
console.log(`Transaction fee: ${quote.transactionFee} GALA`);
console.log(`Reverse bonding curve fee: ${quote.reverseBondingCurveFee} GALA`);

// 4. Execute trade with slippage protection - requires expectedAmount
const buyResult = await sdk.buy({
  tokenName: 'tinyevil',
  amount: '100',
  type: 'native',
  expectedAmount: quote.amount,  // Required: from calculation above
  slippageToleranceFactor: 0.05 // Required: decimal format for 5% slippage
});

console.log(`Transaction submitted: ${buyResult.transactionId}`);

// 5. Check trade history - clean pagination
const trades = await sdk.fetchTrades({ tokenName: 'tinyevil' });
console.log(`Found ${trades.total} trades on page ${trades.page}`);
console.log(`Has more pages: ${trades.hasNext}`);

trades.trades.forEach(trade => {
  console.log(`${trade.tradeType}: ${trade.tokenAmount} at ${trade.createdAt.toISOString()}`);
});

// 6. Post a comment about your trade
const comment = await sdk.postComment({
  tokenName: 'tinyevil',
  content: 'Just bought some tokens! Great project!'
});

console.log(`Comment posted with ID: ${comment.id}`);

// 7. Check your balance - direct balance access
const galaBalance = await sdk.fetchGalaBalance();
console.log(`GALA Balance: ${galaBalance.balance}`);
console.log(`Decimals: ${galaBalance.decimals}`);
console.log(`Last updated: ${galaBalance.lastUpdated.toISOString()}`);

const tokenBalance = await sdk.fetchTokenBalance({
  tokenName: 'tinyevil',
  address: sdk.getAddress()
});

console.log(`TINYEVIL Balance: ${tokenBalance.quantity}`);
console.log(`USD Value: $${tokenBalance.holdingPriceUsd}`);
console.log(`GALA Value: ${tokenBalance.holdingPriceGala} GALA`);
console.log(`Finalized: ${tokenBalance.isFinalized}`);

import { createLaunchpadSDK } from '@gala-chain/launchpad-sdk';

const sdk = createLaunchpadSDK({
  wallet: 'your-private-key-or-mnemonic'
});

// Transfer GALA tokens - direct result access
const galaTransfer = await sdk.transferGala({
  recipientAddress: 'eth|1234567890abcdef1234567890abcdef12345678', // or 0x format
  amount: '1', // 1 GALA
  uniqueKey: 'galaconnect-operation-my-transfer-123' // Optional for idempotency
});

console.log(`GALA Transfer ID: ${galaTransfer.transactionId}`);
console.log(`Status: ${galaTransfer.status}`);

// Transfer launchpad tokens - direct result access
const tokenTransfer = await sdk.transferToken({
  to: '0x9876543210fedcba9876543210fedcba98765432', // or eth| format
  tokenName: 'tinyevil',
  amount: '1000000', // Token amount in smallest unit
  uniqueKey: 'galaconnect-operation-token-transfer-456' // Optional for idempotency
});

console.log(`Token Transfer ID: ${tokenTransfer.transactionId}`);
console.log(`Status: ${tokenTransfer.status}`);

import { createLaunchpadSDK } from '@gala-chain/launchpad-sdk';

// Create SDK with your main wallet
const sdk = createLaunchpadSDK({
  wallet: 'your-main-private-key'
});

// Different wallet's private key (must be in '0x' + 64 hex format)
const busterPrivateKey = '0x1234567890abcdef...'; // Buster's wallet

// 1. Send GALA from main wallet to Buster
await sdk.transferGala({
  recipientAddress: '0xBusterAddress...',
  amount: '1000'
  // Uses main SDK wallet (no privateKey override)
});

// 2. Have Buster buy tokens using his own wallet
const buyResult = await sdk.buy({
  tokenName: 'tinyevil',
  amount: '100',
  type: 'native',
  expectedAmount: '500000',
  slippageToleranceFactor: 0.05,
  privateKey: busterPrivateKey // Override to use Buster's wallet
});

// 3. Have Buster post a comment
await sdk.postComment({
  tokenName: 'tinyevil',
  content: 'Great buy!',
  privateKey: busterPrivateKey // Buster posts the comment
});

// 4. Main wallet continues operations normally
const mainWalletBalance = await sdk.fetchGalaBalance();
// Uses main SDK wallet address

import { createLaunchpadSDK, createWallet } from '@gala-chain/launchpad-sdk';

// Main SDK instance
const sdk = createLaunchpadSDK({
  wallet: 'your-main-private-key'
});

// Create a test wallet for "Buster"
const busterWallet = createWallet(); // Random wallet
const busterPrivateKey = busterWallet.privateKey;
const busterAddress = busterWallet.address;

console.log(`Buster's address: ${busterAddress}`);

// 1. Fund Buster with GALA from main wallet
await sdk.transferGala({
  recipientAddress: busterAddress,
  amount: '1000'
});

// 2. Send Buster some tokens from main wallet
await sdk.transferToken({
  to: busterAddress,
  tokenName: 'tinyevil',
  amount: '10000'
});

// 3. Have Buster send some tokens back to main wallet
await sdk.transferToken({
  to: sdk.getEthereumAddress(), // Main wallet address
  tokenName: 'tinyevil',
  amount: '5000',
  privateKey: busterPrivateKey // Buster's wallet signs
});

// 4. Have Buster buy more tokens
const buyQuote = await sdk.calculateBuyAmount({
  tokenName: 'tinyevil',
  amount: '100',
  type: 'native'
});

await sdk.buy({
  tokenName: 'tinyevil',
  amount: '100',
  type: 'native',
  expectedAmount: buyQuote.amount,
  slippageToleranceFactor: 0.05,
  privateKey: busterPrivateKey // Buster buys
});

// 5. Have Buster sell some tokens
const sellQuote = await sdk.calculateSellAmount({
  tokenName: 'tinyevil',
  amount: '50',
  type: 'native'
});

await sdk.sell({
  tokenName: 'tinyevil',
  amount: '50',
  type: 'native',
  expectedAmount: sellQuote.amount,
  slippageToleranceFactor: 0.05,
  privateKey: busterPrivateKey // Buster sells
});

// 6. Check final balances for both wallets
const mainBalance = await sdk.fetchGalaBalance(); // Main wallet
const busterBalance = await sdk.fetchGalaBalance(busterAddress); // Buster's wallet

console.log(`Main wallet: ${mainBalance.balance} GALA`);
console.log(`Buster wallet: ${busterBalance.balance} GALA`);

// ✅ Valid private key formats
const validKey1 = '0x' + 'a'.repeat(64); // Correct format
const validKey2 = wallet.privateKey; // From ethers.js Wallet

// ❌ Invalid formats (will throw validation error)
const invalidKey1 = 'a'.repeat(64); // Missing '0x' prefix
const invalidKey2 = 'word1 word2 ... word24'; // Mnemonic not accepted
const invalidKey3 = '0x123'; // Too short

// Pool Management
fetchPools(options?): Promise<PoolsResult>
// Returns: { pools, page, limit, total, totalPages, hasNext, hasPrevious }
// Supports auto-pagination: limit <= 20 (single page), limit > 20 (multi-page), limit = 0 (all pools)

fetchAllPools(options?): Promise<PoolsResult>
// Returns: { pools, page, limit, total, totalPages, hasNext, hasPrevious }
// Convenience method that fetches ALL pools (equivalent to fetchPools({ limit: 0 }))

fetchTokenDistribution(tokenName): Promise<TokenDistributionResult>
// Returns: { holders, totalSupply, totalHolders, lastUpdated }

fetchTokenBadges(tokenName): Promise<TokenBadgesResult>
// Returns: { volumeBadges, engagementBadges }

fetchPoolDetails(tokenName): Promise<PoolDetailsData>
// Returns: { basePrice, maxSupply, saleStatus, nativeTokenQuantity, ... }

fetchVolumeData(options): Promise<GraphDataResult>
// Returns: { dataPoints }

// Trade & User Data
fetchTrades(options): Promise<TradesResult>
// Returns: { trades, page, limit, total, totalPages, hasNext, hasPrevious }

fetchGalaBalance(address?): Promise<GalaBalanceInfo>
// Returns: { userAddress, balance, decimals, lastUpdated }

fetchTokenBalance(options): Promise<TokenBalanceInfo>
// Returns: { quantity, holdingPriceUsd, holdingPriceGala, isFinalized, ... }

fetchComments(options): Promise<CommentsResult>
// Returns: { comments, page, limit, total, totalPages, hasNext, hasPrevious }

fetchProfile(address?): Promise<UserProfile>
// Returns: { fullName, profileImage, address, ... }

fetchLaunchTokenFee(): Promise<number>
// Returns: Current GALA fee required to launch a new token (e.g., 0.001)

// Price Calculations
calculateBuyAmount(options): Promise<AmountCalculationResult>
// Returns: { amount, reverseBondingCurveFee, transactionFee }

calculateSellAmount(options): Promise<AmountCalculationResult>
// Returns: { amount, reverseBondingCurveFee, transactionFee }

calculateInitialBuyAmount(options): Promise<AmountCalculationResult>
// Returns: { amount, reverseBondingCurveFee, transactionFee }

calculateBuyAmountForGraduation(tokenName): Promise<AmountCalculationResult>
// Returns: { amount, reverseBondingCurveFee, transactionFee }
// Calculates exact GALA cost to buy all remaining tokens and graduate pool

// Local Calculations (Client-Side, No Network)
calculateBuyAmountLocal(options): Promise<AmountCalculationResult>
// Options: { tokenName, amount, type: 'native' | 'exact' }
// Returns: { amount, reverseBondingCurveFee: '0', transactionFee, gasFee }
// Instant buy calculation using local bonding curve formulas

calculateSellAmountLocal(options): Promise<AmountCalculationResult>
// Options: { tokenName, amount, type: 'native' | 'exact', maxSupply, minFeePortion, maxFeePortion }
// Returns: { amount, reverseBondingCurveFee, transactionFee, gasFee }
// Instant sell calculation with reverse bonding curve fees

// External Calculations (GalaChain Network)
calculateBuyAmountExternal(options): Promise<AmountCalculationResult>
// Explicit external calculation wrapper (same as calculateBuyAmount)

calculateSellAmountExternal(options): Promise<AmountCalculationResult>
// Explicit external calculation wrapper (same as calculateSellAmount)

// Note: Pass `calculateAmountMode: 'local' | 'external'` to override SDK default mode

// Price History Operations (MySQL-based, Node.js only)
fetchPriceHistory(options): Promise<PriceHistoryResult>
// Options: { tokenId, from?, to?, sortOrder?, page?, limit? }
// Returns: { snapshots, page, limit, total, totalPages, hasNext, hasPrevious }
// Fetches paginated historical price snapshots from MySQL database

fetchAllPriceHistory(options): Promise<PriceHistoryResult>
// Options: { tokenId, from?, to?, sortOrder? } (no pagination params)
// Returns: All matching snapshots with total count
// Convenience method with automatic pagination (returns ALL snapshots)

fetchPrices(options?): Promise<PricesResult>
// Options: { page?, limit?, sortByType? }
// Returns: { snapshots, page, limit, total, totalPages, hasNext, hasPrevious }
// Fetches latest price for each unique token (paginated)

fetchAllPrices(): Promise<PricesResult>
// No parameters
// Returns: All latest prices combined in single result
// Convenience method with automatic pagination (returns ALL latest prices)

// Note: Price history methods require MySQL connection string in SDK config
// See MySQL Configuration section below for setup details

import { createLaunchpadSDK, CALCULATION_MODES } from '@gala-chain/launchpad-sdk';

const sdk = createLaunchpadSDK({
  wallet: 'your-private-key-or-mnemonic'
});

// Use type-safe calculation mode constants
console.log(CALCULATION_MODES.LOCAL);    // 'local'
console.log(CALCULATION_MODES.EXTERNAL); // 'external'

import { createLaunchpadSDK, CALCULATION_MODES } from '@gala-chain/launchpad-sdk';

const sdk = createLaunchpadSDK({
  wallet: 'your-private-key-or-mnemonic'
});

const tokenName = 'tinyevil';

// ❌ WITHOUT OPTIMIZATION (3 network calls)
const spotPrice1 = await sdk.fetchLaunchpadTokenSpotPrice(tokenName);
// → Fetches pool details internally (call #1)

const graduation1 = await sdk.calculateBuyAmountForGraduation(tokenName);
// → Fetches pool details internally (call #2)

const graduationResult1 = await sdk.graduateToken({ tokenName });
// → Fetches pool details internally (call #3)

// ✅ WITH OPTIMIZATION (1 network call + instant local calculations)
// Step 1: Fetch pool details once
const poolDetails = await sdk.fetchPoolDetailsForCalculation(tokenName);
const currentSupply = poolDetails.currentSupply; // Pre-computed with full precision

// Step 2: Reuse currentSupply for instant local calculations
const spotPrice2 = await sdk.fetchLaunchpadTokenSpotPrice({
  tokenName,
  calculateAmountMode: CALCULATION_MODES.LOCAL,
  currentSupply
});
// → Uses local bonding curve formulas (instant, no network call)

const graduation2 = await sdk.calculateBuyAmountForGraduation({
  tokenName,
  calculateAmountMode: CALCULATION_MODES.LOCAL,
  currentSupply
});
// → Uses local calculation (instant, no network call)

// Step 3: Graduate with optimized calculation
const graduationResult2 = await sdk.graduateToken({
  tokenName,
  calculateAmountMode: CALCULATION_MODES.LOCAL,
  currentSupply,
  slippageToleranceFactor: 0.01
});
// → Skips redundant pool fetch, uses local calculation

import { createLaunchpadSDK, CALCULATION_MODES } from '@gala-chain/launchpad-sdk';

const sdk = createLaunchpadSDK({
  wallet: 'your-private-key-or-mnemonic'
});

async function optimizedPoolAnalysis(tokenName: string) {
  console.time('Optimized Analysis');

  // 1. Fetch pool details once (only network call needed)
  const poolDetails = await sdk.fetchPoolDetailsForCalculation(tokenName);
  const {
    currentSupply,
    maxSupply,
    reverseBondingCurveMinFeeFactor,
    reverseBondingCurveMaxFeeFactor
  } = poolDetails;

  // 2. Get spot price with local calculation (instant)
  const spotPrice = await sdk.fetchLaunchpadTokenSpotPrice({
    tokenName,
    calculateAmountMode: CALCULATION_MODES.LOCAL,
    currentSupply
  });
  console.log(`Spot price: $${spotPrice.usdPrice.toFixed(6)}`);

  // 3. Calculate graduation cost with local calculation (instant)
  const graduationCost = await sdk.calculateBuyAmountForGraduation({
    tokenName,
    calculateAmountMode: CALCULATION_MODES.LOCAL,
    currentSupply
  });
  console.log(`Graduation cost: ${graduationCost.amount} GALA`);

  // 4. Simulate multiple buy scenarios (all instant)
  const buyAmounts = ['10', '100', '1000'];
  for (const amount of buyAmounts) {
    const buyCalc = await sdk.calculateBuyAmount({
      tokenName,
      amount,
      type: 'native',
      mode: CALCULATION_MODES.LOCAL, // Can also use 'mode' alias
      currentSupply
    });
    console.log(`Buying ${amount} GALA gets you: ${buyCalc.amount} tokens`);
  }

  // 5. Simulate multiple sell scenarios (all instant)
  const sellAmounts = ['10', '100', '1000'];
  for (const amount of sellAmounts) {
    const sellCalc = await sdk.calculateSellAmountLocal({
      tokenName,
      amount,
      type: 'native',
      maxSupply,
      reverseBondingCurveMinFeeFactor,
      reverseBondingCurveMaxFeeFactor
    });
    console.log(`Selling ${amount} GALA worth gets you: ${sellCalc.amount} GALA`);
  }

  console.timeEnd('Optimized Analysis');
  // Output: Optimized Analysis: ~200-300ms (vs ~2-3 seconds without optimization)
}

optimizedPoolAnalysis('tinyevil');

// Local mode (client-side, instant, <0.01% difference from external)
const localCalc = await sdk.calculateBuyAmount({
  tokenName: 'tinyevil',
  amount: '100',
  type: 'native',
  mode: CALCULATION_MODES.LOCAL,
  currentSupply: poolDetails.currentSupply
});

// External mode (GalaChain network, real-time, slower)
const externalCalc = await sdk.calculateBuyAmount({
  tokenName: 'tinyevil',
  amount: '100',
  type: 'native',
  mode: CALCULATION_MODES.EXTERNAL // or omit to use SDK default
});

// Accuracy comparison
const difference = Math.abs(
  parseFloat(localCalc.amount) - parseFloat(externalCalc.amount)
);
const percentDiff = (difference / parseFloat(externalCalc.amount)) * 100;
console.log(`Difference: ${percentDiff.toFixed(4)}%`); // Typically < 0.01%

import { createLaunchpadSDK, CALCULATION_MODES } from '@gala-chain/launchpad-sdk';

// Configure SDK to use local calculations by default
const sdk = createLaunchpadSDK({
  wallet: 'your-private-key-or-mnemonic',
  config: {
    calculateAmountMode: CALCULATION_MODES.LOCAL // Default to local mode
  }
});

// All calculations will use local mode by default
const calc1 = await sdk.calculateBuyAmount({
  tokenName: 'tinyevil',
  amount: '100',
  type: 'native'
  // Uses LOCAL mode from SDK config
});

// Override per-call if needed
const calc2 = await sdk.calculateBuyAmount({
  tokenName: 'tinyevil',
  amount: '100',
  type: 'native',
  mode: CALCULATION_MODES.EXTERNAL // Override to external for this call
});

import { createLaunchpadSDK } from '@gala-chain/launchpad-sdk';

const sdk = createLaunchpadSDK({
  wallet: 'your-private-key-or-mnemonic'
});

// Before fetching - cache is empty
let cacheInfo = sdk.getCacheInfo();
console.log('Cached tokens:', cacheInfo.totalTokens); // 0

// Fetch pools - automatically warms cache with RBC fees and vault addresses
await sdk.fetchPools({ type: 'recent', limit: 20 });

// After fetching - cache is warmed with 20 tokens
cacheInfo = sdk.getCacheInfo();
console.log('Cached tokens:', cacheInfo.totalTokens); // 20
console.log('Cache size:', (cacheInfo.cacheSize / 1024).toFixed(2), 'KB');

// Now local calculations are instant (no network calls required)
const calc = await sdk.calculateBuyAmountLocal({
  tokenName: 'anime',
  amount: '100',
  type: 'native',
  currentSupply: '500000'
});
console.log('Instant result:', calc.amount); // <1ms, used cached RBC fees

// Cache automatically manages size
await sdk.fetchPools({ limit: 100 }); // Warms cache with 100 tokens
await sdk.fetchPools({ limit: 100 }); // Warms with 100 more tokens
await sdk.fetchPools({ limit: 100 }); // ... continues

// When 10,000 limit reached, oldest tokens are evicted automatically
const stats = sdk.getCacheInfo();
console.log('Total tokens:', stats.totalTokens); // Never exceeds 10,000
console.log('Oldest entry:', new Date(stats.oldestEntry).toISOString());

const stats = sdk.getCacheInfo();
console.log('Total tokens cached:', stats.totalTokens);
console.log('Memory usage:', stats.cacheSize, 'bytes');
console.log('Average per entry:', (stats.cacheSize / stats.totalTokens).toFixed(0), 'bytes');
console.log('Oldest entry:', new Date(stats.oldestEntry).toISOString());

// Clear specific token
sdk.clearCache('anime');
console.log('Cleared anime from cache');

// Clear all tokens
sdk.clearCache();
console.log('Cleared entire cache');

// Verify cache is empty
const stats = sdk.getCacheInfo();
console.log('Tokens remaining:', stats.totalTokens); // 0

// Manually warm cache from pool data (useful for custom caching scenarios)
sdk.warmCacheFromPoolData('mytoken', {
  vaultAddress: 'service|Token$Unit$MYTOKEN$...',
  reverseBondingCurveMinFeeFactor: 0.0,
  reverseBondingCurveMaxFeeFactor: 0.5
});

// Cache is now warmed for local calculations
const calc = await sdk.calculateBuyAmountLocal({
  tokenName: 'mytoken',
  amount: '100',
  type: 'native',
  currentSupply: '1000000'
});

import { createLaunchpadSDK, CALCULATION_MODES } from '@gala-chain/launchpad-sdk';

const sdk = createLaunchpadSDK({
  wallet: 'your-private-key-or-mnemonic'
});

// 1. Warm cache by fetching pools
console.log('Warming cache...');
await sdk.fetchPools({ type: 'popular', limit: 50 });

// 2. Check cache statistics
const stats = sdk.getCacheInfo();
console.log(`Cache warmed with ${stats.totalTokens} tokens`);
console.log(`Memory: ${(stats.cacheSize / 1024).toFixed(2)} KB`);

// 3. Perform instant calculations using cached metadata
const tokens = ['anime', 'dragnrkti', 'rocketri'];

console.log('\nCalculating spot prices (instant, no network calls):');
console.time('Batch Calculations');

for (const token of tokens) {
  // Get pool details once for this token
  const poolDetails = await sdk.fetchPoolDetailsForCalculation(token);

  // Multiple instant calculations using cached data
  const [buy10, buy100, buy1000] = await Promise.all([
    sdk.calculateBuyAmountLocal({
      tokenName: token,
      amount: '10',
      type: 'native',
      currentSupply: poolDetails.currentSupply
    }),
    sdk.calculateBuyAmountLocal({
      tokenName: token,
      amount: '100',
      type: 'native',
      currentSupply: poolDetails.currentSupply
    }),
    sdk.calculateBuyAmountLocal({
      tokenName: token,
      amount: '1000',
      type: 'native',
      currentSupply: poolDetails.currentSupply
    })
  ]);

  console.log(`${token}:`);
  console.log(`  10 GALA → ${buy10.amount} tokens`);
  console.log(`  100 GALA → ${buy100.amount} tokens`);
  console.log(`  1000 GALA → ${buy1000.amount} tokens`);
}

console.timeEnd('Batch Calculations');
// Output: Batch Calculations: ~50-100ms (vs ~3-5 seconds without cache)

// 4. Clear cache when done (optional)
sdk.clearCache();
console.log('\nCache cleared');

// Buy/Sell Tokens
buy(options): Promise<TransactionResult>
// Options: { tokenName, amount, type, expectedAmount, slippageToleranceFactor }
// Returns: { transactionId, status, ... }

sell(options): Promise<TransactionResult>
// Options: { tokenName, amount, type, expectedAmount, slippageToleranceFactor }
// Returns: { transactionId, status, ... }

graduateToken(options): Promise<TransactionResult>
// Options: { tokenName, slippageToleranceFactor?, maxAcceptableReverseBondingCurveFeeSlippageFactor?, privateKey? }
// Returns: { transactionId, status, ... }
// One-step pool graduation: calculates cost and buys all remaining tokens

// Comments & Content
postComment(options): Promise<CommentResult>
// Returns: { id, content, createdAt, ... }

// Token Creation & Management
launchToken(data): Promise<LaunchTokenResult>
// Returns: { transactionId, status, ... }

uploadTokenImage(options): Promise<ImageUploadResult>
// Returns: { imageUrl, success, ... }

// Profile Management
updateProfile(data): Promise<ProfileUpdateResult>
// Returns: { success, data, ... }

uploadProfileImage(options): Promise<ImageUploadResult>
// Returns: { imageUrl, success, ... }

import { MAX_CONCURRENT_POOL_FETCHES } from '@gala-chain/launchpad-sdk';

console.log(`SDK fetches up to ${MAX_CONCURRENT_POOL_FETCHES} pages concurrently`);
// Output: "SDK fetches up to 5 pages concurrently"

interface LaunchpadSDKConfig {
  wallet: Wallet;                      // ethers.js Wallet instance
  baseUrl?: string;                    // Backend URL (default: dev environment)
  galaChainBaseUrl?: string;           // GalaChain gateway URL
  bundleBaseUrl?: string;              // Bundle service URL
  webSocketUrl?: string;               // WebSocket URL for monitoring
  timeout?: number;                    // Request timeout (default: 30000ms)
  debug?: boolean;                     // Enable debug logging
  maxRetries?: number;                 // Retry attempts (default: 3)
  retryDelay?: number;                 // Retry delay (default: 1000ms)
  mysqlConnectionString?: string;      // MySQL connection string for price history (Node.js only)
                                       // Format: mysql://user:password@host:port/database
}

import { createLaunchpadSDK } from '@gala-chain/launchpad-sdk';

const sdk = createLaunchpadSDK({
  wallet: 'your-private-key',
  config: {
    baseUrl: 'https://lpad-backend-dev1.defi.gala.com',
    mysqlConnectionString: 'mysql://user:password@localhost:3306/galachain'
  }
});

// 1. Fetch historical price snapshots (paginated)
const priceHistory = await sdk.fetchPriceHistory({
  tokenId: 'Token|Unit|GUSDC|eth:9401b171307bE656f00F9e18DF756643FD3a91dE', // String format
  from: new Date('2024-01-01'),
  to: new Date('2024-01-31'),
  sortOrder: 'DESC',
  page: 1,
  limit: 20
});

console.log(`Found ${priceHistory.snapshots.length} snapshots`);
console.log(`Total: ${priceHistory.total}, Page ${priceHistory.page} of ${priceHistory.totalPages}`);

// 2. Fetch ALL historical price snapshots (auto-paginated)
const allHistory = await sdk.fetchAllPriceHistory({
  tokenId: { // Object format also supported
    collection: 'Token',
    category: 'Unit',
    type: 'GUSDC',
    additionalKey: 'eth:9401b171307bE656f00F9e18DF756643FD3a91dE'
  },
  from: new Date('2024-01-01'),
  to: new Date('2024-01-31')
});

console.log(`Total snapshots: ${allHistory.total}`);

// 3. Fetch latest prices for all tokens (paginated)
const latestPrices = await sdk.fetchPrices({
  page: 1,
  limit: 20,
  sortByType: 'ASC' // Optional: sort alphabetically by token type
});

console.log(`Found ${latestPrices.snapshots.length} tokens with prices`);

// 4. Fetch all latest prices (auto-paginated)
const allLatestPrices = await sdk.fetchAllPrices();

console.log(`Total tokens with prices: ${allLatestPrices.total}`);

// String format (pipe-delimited) - simpler
tokenId: 'Token|Unit|GUSDC|eth:9401b171307bE656f00F9e18DF756643FD3a91dE'

// Object format (explicit) - for clarity
tokenId: {
  collection: 'Token',
  category: 'Unit',
  type: 'GUSDC',
  additionalKey: 'eth:9401b171307bE656f00F9e18DF756643FD3a91dE'
}

import { createWallet, validateWalletInput } from '@gala-chain/launchpad-sdk';

// Auto-detect format and create wallet
const wallet = createWallet('private-key-or-24-word-mnemonic');
const randomWallet = createWallet(); // Generate random wallet

// Validate input format without creating wallet
const isValid = validateWalletInput('0x1234...'); // boolean

import { createLaunchpadSDK, createTestLaunchpadSDK } from '@gala-chain/launchpad-sdk';

// Main factory with auto-detection
const sdk = createLaunchpadSDK({
  wallet: 'your-private-key-or-mnemonic',
  config: {
    baseUrl: 'https://lpad-backend-dev1.defi.gala.com',
    debug: true
  }
});

// Test-optimized SDK
const testSDK = createTestLaunchpadSDK({
  wallet: 'test-private-key'
});

// Each service maps 1:1 to a specific backend
import {
  LaunchpadService,  // → launchpad-backend (pools, trades, comments, profiles)
  GalaChainService,  // → galachain-gateway (balances, transfers, pool details)
  DexService,        // → dex-api (spot prices)
  BundleService,     // → bundle-backend (transaction bundling, trading)
  WebSocketService   // → WebSocket endpoint (real-time monitoring)
} from '@gala-chain/launchpad-sdk';

// Internal architecture (v3.6.0+)
LaunchpadService (facade)
├── PoolService - Pool queries, distribution, badges, volume data
│   ├── fetchPools() - Supports auto-pagination (v3.11.0+)
│   ├── fetchAllPools() - Convenience method for limit: 0
│   └── ...other pool operations
├── TradeService - Trade history and queries
├── CommentService - Comments with vault resolution
├── UserService - Profile management and token lists
├── ImageService - Image upload operations
└── FaucetService - Faucet transfer operations

import { AgentConfig } from '@gala-chain/launchpad-sdk';

// Quick setup with intelligent defaults
const { sdk, validation } = await AgentConfig.quickSetup({
  environment: 'development',
  autoValidate: true
});

console.log(`Ready: ${validation.ready}`);
console.log(`Can trade: ${validation.capabilities.canTrade}`);

// Pool results with pagination
interface PoolsResult {
  pools: PoolData[];           // Direct pool array
  page: number;                // Current page
  total: number;               // Total items
  hasNext: boolean;            // Computed convenience
  // ... more properties
}

// Token balance with typed values
interface TokenBalanceInfo {
  quantity: string;            // Token amount (string for precision)
  holdingPriceUsd: number;     // USD value (number for math)
  lastUpdated: Date;           // Date object (not string)
  isFinalized: boolean;        // Boolean flag
  // ... more properties
}

// Trading results
interface AmountCalculationResult {
  amount: string;              // Calculated amount
  transactionFee: string;      // Fee breakdown
  reverseBondingCurveFee: string; // RBC fee
  // Direct access to all calculation data
}