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';

// 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-dev1.defi.gala.com/buy-sell/dragnrkti

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 }

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, ... }

// 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 }

// 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, ... }

// 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 { 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'
});

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)
}

// 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
├── 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
}