@gala-chain/launchpad-sdk 0.4.2 → 3.0.0

package/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to the Gala Launchpad SDK will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.3] - 2024-09-24
+
+### Documentation Update
+
+- Updated all version references to v0.4.3 across README, documentation files, and source code
+- Fixed npm README display issue with consistent version numbers
+
 ## [0.4.0] - 2024-01-24
 
 ### First Public Release

package/README.md

@@ -1,21 +1,22 @@
-# Gala Launchpad SDK v0.4.0
+# Gala Launchpad SDK v3.0.0
 
 A comprehensive TypeScript SDK for the Gala Launchpad Backend API, providing type-safe authentication, trading, and real-time features for DeFi applications.
 
+> **✨ New in v3.0.0**: Production-ready release with service-based architecture, AgentConfig utilities, and clean result types - zero breaking changes!
+
 [![npm version](https://badge.fury.io/js/@gala-chain%2Flaunchpad-sdk.svg)](https://badge.fury.io/js/@gala-chain%2Flaunchpad-sdk)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![TypeScript](https://img.shields.io/badge/%3C%2F%3E-TypeScript-%230074c1.svg)](http://www.typescriptlang.org/)
 
 ## 🚀 Features
 
-**Wallet Creation with Auto-Detection:**
+**Clean Result Types with No Wrapper Overhead:**
 
-- **Auto-Detection**: Automatically detects private key vs mnemonic input format
-- **Flexible Input**: Supports 12/24-word mnemonics and 64-character hex private keys
-- **SDK Factory Functions**: Simplified SDK initialization with `createLaunchpadSDK()`
-- **Input Validation**: Built-in `validateWalletInput()` for format validation
-- **Test Support**: `createTestLaunchpadSDK()` for testing environments
-- **Flat API Design**: All methods directly on SDK root for simplicity
+- **Direct Result Access**: Get clean, typed results without wrapper objects
+- **Semantic Type Conversion**: Dates as Date objects, numbers as numbers, strings for precision
+- **Comprehensive Type Safety**: Full TypeScript support with precise result interfaces
+- **Zero Wrapper Overhead**: No more `result.data.success` - direct property access
+- **Options Object Pattern**: All methods with 2+ parameters use clean options objects
 
 ### Developer Experience
 
@@ -27,35 +28,46 @@ const sdk = createLaunchpadSDK({
   wallet: 'your-private-key-or-mnemonic' // Auto-detects format!
 });
 
-// Or create wallet separately with auto-detection
-const wallet = createWallet('private-key-or-mnemonic');
-const sdk = createLaunchpadSDK({ wallet });
+// 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
 
-// Test SDK with defaults
-const testSDK = createTestLaunchpadSDK();
+// 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
 ```
 
-## 📊 Flat API Architecture
+## 📊 Clean API Architecture
 
-**All methods directly on SDK root - simple and clean:**
+**Direct result access with no wrapper overhead:**
 
 ```typescript
-// Everything is directly on sdk!
-await sdk.fetchPools({ type: 'recent' });
-await sdk.calculateBuyAmount({ tokenName: 'token', amount: '100', type: 'native' });
-await sdk.buy({ tokenName: 'token', amount: '100', type: 'native' });
-await sdk.fetchGalaBalance();
-await sdk.postComment({ tokenName: 'token', content: 'Great project!' });
+// Before: Wrapper response types
+const result = await sdk.fetchPools({ type: 'recent' });
+if (result.success) {
+  console.log(result.data.pools); // Nested access
+}
+
+// After: Clean direct results
+const pools = await sdk.fetchPools({ type: 'recent' });
+console.log(pools.pools); // Direct access
+console.log(pools.total); // Immediate pagination info
+console.log(pools.hasNext); // Computed convenience properties
 ```
 
 ## 🚀 Key Features
 
 - **Type-Safe API Client**: Full TypeScript support with comprehensive type definitions
+- **Clean Result Types**: Direct property access without wrapper objects
+- **Options Object Pattern**: All multi-parameter methods use clean options objects
 - **Signature Authentication**: Ethereum wallet-based authentication with automatic signature generation
 - **Helper Functions**: Auto-detecting wallet creation and SDK factory functions
-- **Flat API Design**: All methods directly accessible on SDK root
 - **Pool Management**: Create, fetch, and check token pools on the launchpad
 - **Token Trading**: Buy and sell tokens with slippage protection via GalaChain
+- **Token Transfers**: Transfer GALA and launchpad tokens between wallets with EIP-712 signatures
 - **User Operations**: Portfolio management, token balances, and account management
 - **Comment System**: Post and retrieve comments on token pools
 - **Comprehensive Validation**: Input validation and error handling for all operations
@@ -64,13 +76,13 @@ await sdk.postComment({ tokenName: 'token', content: 'Great project!' });
 ## 📦 Installation
 
 ```bash
-npm install @gala-chain/launchpad-sdk@^0.4.0
+npm install @gala-chain/launchpad-sdk@^3.0.0
 ```
 
 Or with yarn:
 
 ```bash
-yarn add @gala-chain/launchpad-sdk@^0.4.0
+yarn add @gala-chain/launchpad-sdk@^3.0.0
 ```
 
 ## 🏁 Quick Start
@@ -85,39 +97,66 @@ const sdk = createLaunchpadSDK({
   wallet: 'your-private-key-or-mnemonic' // Auto-detects format!
 });
 
-// Flat API - All methods directly on SDK root
+// Clean, direct result access - All methods use options objects
 
-// Pool Management
+// 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');
-const details = await sdk.fetchSaleDetails('dragnrkti');
+console.log(`Volume badges: ${badges.volumeBadges.length}`);
+console.log(`Engagement badges: ${badges.engagementBadges.length}`);
 
-// Price Calculations
+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: '1000000000000000000', // 1 GALA
   type: 'native'
 });
+console.log(`Buy amount: ${buyAmount.amount}`);
+console.log(`Transaction fee: ${buyAmount.transactionFee}`);
 
-// Trading Operations
+// Trading Operations - Required expectedAmount and slippageToleranceFactor
 const buyResult = await sdk.buy({
   tokenName: 'dragnrkti',
   amount: '1000000000000000000',
   type: 'native',
-  slippage: 5
+  expectedAmount: buyAmount.amount,  // Required: from calculation
+  slippageToleranceFactor: 0.05  // Required: decimal format (5% slippage)
 });
+console.log(`Transaction ID: ${buyResult.transactionId}`);
 
-// Data & Analytics
+// 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' });
-const balance = await sdk.fetchGalaBalance();
+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()}`);
 
-// User Operations
-const profile = await sdk.fetchProfile();
 const tokenBalance = await sdk.fetchTokenBalance({
   tokenName: 'dragnrkti',
   walletAddress: 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'}`);
 ```
 
 ### Manual SDK Creation (Alternative)
@@ -137,11 +176,12 @@ const sdk = new LaunchpadSDK({
   debug: false
 });
 
-// Same flat API available
+// Same clean API available
 const pools = await sdk.fetchPools({ type: 'recent' });
+console.log(`${pools.total} pools found`);
 ```
 
-## 🎯 Complete Example: Trading Flow
+## 🎯 Complete Example: Trading Flow with Clean Results
 
 ```typescript
 import { createLaunchpadSDK } from '@gala-chain/launchpad-sdk';
@@ -151,86 +191,208 @@ const sdk = createLaunchpadSDK({
   wallet: 'your-private-key-or-mnemonic'
 });
 
-// 2. Check available pools
+// 2. Check available pools - direct access to results
 const pools = await sdk.fetchPools({
   type: 'recent',
   limit: 10
 });
 
-// 3. Get price quote
+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 of tokens will get you: ${quote.outTokenAmount} TINYEVIL`);
+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
+// 4. Execute trade with slippage protection - requires expectedAmount
 const buyResult = await sdk.buy({
   tokenName: 'tinyevil',
   amount: '100',
   type: 'native',
-  slippage: 5 // 5% slippage tolerance
+  expectedAmount: quote.amount,  // Required: from calculation above
+  slippageToleranceFactor: 0.05 // Required: decimal format for 5% slippage
 });
 
-// 5. Check trade history
+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
-await sdk.postComment({
+const comment = await sdk.postComment({
   tokenName: 'tinyevil',
   content: 'Just bought some tokens! Great project!'
 });
 
-// 7. Check your balance
-const balance = await sdk.fetchGalaBalance();
+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',
   walletAddress: sdk.getAddress()
 });
 
-console.log(`GALA Balance: ${balance.balance}`);
-console.log(`TINYEVIL Balance: ${tokenBalance.balance}`);
+console.log(`TINYEVIL Balance: ${tokenBalance.quantity}`);
+console.log(`USD Value: $${tokenBalance.holdingPriceUsd}`);
+console.log(`GALA Value: ${tokenBalance.holdingPriceGala} GALA`);
+console.log(`Finalized: ${tokenBalance.isFinalized}`);
+```
+
+## 💸 Transfer Operations
+
+Transfer GALA and launchpad tokens between wallets with EIP-712 signatures:
+
+```typescript
+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: '1000000000000000000', // 1 GALA in wei
+  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}`);
 ```
 
-## 🎯 Available Methods
+### Transfer Features
+- **EIP-712 Signatures**: Secure blockchain transactions
+- **Address Format Handling**: Supports both `0x` and `eth|` formats
+- **Idempotency**: Optional unique keys prevent duplicate transfers (must use `galaswap-operation-` or `galaconnect-operation-` prefix)
+- **Comprehensive Validation**: Amount limits, address formats, token names, unique key formats
+- **GalaChain Integration**: Direct transfers via GalaChain gateway
+- **Error Handling**: Detailed error types for different failure scenarios
+
+## 🎯 Available Methods & Result Types
 
 ### **Fetch Operations**
-- `fetchPools(options?)` - Get pools (recent, popular, search)
-- `fetchTokenDistribution(tokenName)` - Token holder distribution
-- `fetchTokenBadges(tokenName)` - Volume and engagement badges
-- `fetchSaleDetails(tokenName)` - Token sale information
-- `fetchGraphData(options)` - Price chart data
-- `fetchTrades(options)` - Trade history
-- `fetchGalaBalance(walletAddress?)` - User GALA balance
-- `fetchTokenBalance(options)` - User token balance
-- `fetchComments(options)` - Token comments
-- `fetchProfile(walletAddress?)` - User profile
+
+```typescript
+// 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(walletAddress?): 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(walletAddress?): Promise<UserProfile>
+// Returns: { fullName, profileImage, walletAddress, ... }
+```
 
 ### **Calculate Operations**
-- `calculateBuyAmount(options)` - Calculate GALA cost for tokens
-- `calculateSellAmount(options)` - Calculate GALA received from tokens
-- `calculateInitialBuyAmount(options)` - Pre-mint calculations
+
+```typescript
+// 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 }
+```
 
 ### **Trading Operations**
-- `buy(options)` - Buy tokens with slippage protection
-- `sell(options)` - Sell tokens with slippage protection
+
+```typescript
+// 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, ... }
+```
 
 ### **Content Operations**
-- `postComment(options)` - Post comment on token
-- `createTokenAndPool(data)` - Create new token sale
-- `uploadTokenImage(options)` - Upload token image
-- `updateProfile(data)` - Update user profile
-- `uploadProfileImage(options)` - Upload profile image
+
+```typescript
+// 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, ... }
+```
 
 ### **Validation & Utilities**
-- `isTokenNameAvailable(tokenName)` - Check name availability
-- `isTokenSymbolAvailable(symbol)` - Check symbol availability
-- `getAddress()` - Get backend format address (eth|...)
-- `getEthereumAddress()` - Get Ethereum format address (0x...)
-- `resolveVaultAddress(tokenName)` - Get token vault address
-- `cleanup()` - Cleanup resources
+- `isTokenNameAvailable(tokenName: string): Promise<boolean>`
+- `isTokenSymbolAvailable(symbol: string): Promise<boolean>`
+- `getAddress(): string` - Get backend format address (eth|...)
+- `getEthereumAddress(): string` - Get Ethereum format address (0x...)
+- `resolveVaultAddress(tokenName: string): Promise<string>`
+- `cleanup(): void` - Cleanup resources
 
 ## 🔧 Helper Functions
 
@@ -300,10 +462,131 @@ npm run lint
 ## 📚 Documentation
 
 - [SDK Method Reference](./SDK-METHOD-GRAPH.md) - Complete flat API reference
-- [AI Agent Guide](./docs/AI_AGENT_GUIDE.md) - Integration with AI agents
+- [Clean Result Types Migration Guide](./docs/CLEAN_RESULT_TYPES_MIGRATION.md) - Migration guide for clean result types
+- [Service Architecture Migration Guide](./docs/SERVICE_ARCHITECTURE_MIGRATION.md) - Guide for v3.1.0 service-based architecture
 - [API Documentation](../../API.md) - Detailed API documentation
 - [Examples](./examples/) - Code examples and demos
 
+## 🏗️ Architecture (v3.0.0+)
+
+The SDK uses a **service-based architecture** with backend-aligned services:
+
+### Backend-Aligned Services
+
+```typescript
+// 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';
+```
+
+### Service Responsibilities
+
+**LaunchpadService** - Launchpad Backend Operations
+- Pool management (fetch, create, check)
+- Trade history
+- Comments (post, fetch)
+- User profiles
+- Token images
+- Faucet operations
+
+**GalaChainService** - Blockchain Operations
+- GALA balance queries
+- Token balance queries
+- Token transfers (GALA & launchpad tokens)
+- Pool details from bonding curve contracts
+- Token resolution
+
+**DexService** - Price Queries
+- Spot price fetching
+- Multi-token price queries
+
+**BundleService** - Transaction Bundling
+- Buy token operations
+- Sell token operations
+- Slippage protection
+- Transaction bundling
+
+**WebSocketService** - Real-time Features
+- Transaction monitoring
+- Status updates
+- Connection management
+
+### Benefits of Service Architecture
+
+✅ **Clear Separation**: Each service has a single backend responsibility
+✅ **Type Safety**: Full TypeScript support across all services
+✅ **Testability**: Services can be tested independently
+✅ **Maintainability**: Easy to locate and update backend-specific logic
+✅ **Zero Breaking Changes**: Public API remains unchanged (v3.0.0 is fully backward compatible)
+
+### 🤖 AI Agent Integration
+
+The SDK includes comprehensive utilities for AI agent development:
+
+```typescript
+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}`);
+```
+
+For comprehensive AI agent integration, see:
+- [AI Agent Integration Guide](./docs/AI-AGENT-GUIDE.md) - Complete guide for agent development
+- [MCP Tool Specification](./docs/MCP-TOOL-SPECIFICATION.md) - Blueprint for MCP server creation
+- [Agent Examples](./docs/agent-examples/) - Working code examples
+
+## 🎯 Clean Result Types Architecture
+
+### Key Benefits
+
+✅ **Direct Property Access**: No more `result.data.success` chains
+✅ **Type Safety**: Full TypeScript IntelliSense for all result properties
+✅ **Semantic Types**: Dates as Date objects, numbers as numbers
+✅ **Computed Properties**: `hasNext`, `hasPrevious` for convenience
+✅ **Zero Wrapper Overhead**: Clean, direct access to all result data
+✅ **Options Object Pattern**: All multi-parameter methods use options objects
+
+### Result Type Examples
+
+```typescript
+// 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
+}
+```
+
 ## 🚀 Environment URLs
 
 - **Development**: `https://lpad-backend-dev1.defi.gala.com`

package/dist/examples/complete-sdk-demo.d.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env tsx
+/**
+ * 🚀 GALA LAUNCHPAD SDK - COMPLETE DEMONSTRATION
+ *
+ * This is the ONLY demo you need! It covers every feature of the SDK:
+ *
+ * ✅ Token Creation & Management
+ * ✅ All Trading Operations (buy/sell with native/exact amounts)
+ * ✅ User Profile & Social Features
+ * ✅ Transfer Operations (GALA & Tokens)
+ * ✅ Data Fetching (pools, balances, history)
+ * ✅ Automatic Transaction Confirmation (WebSocket internal)
+ * ✅ Error Handling & Recovery
+ *
+ * Run with: npx tsx examples/complete-sdk-demo.ts
+ */
+/**
+ * 🎯 Main demo function
+ */
+declare function runCompleteSDKDemo(): Promise<void>;
+export { runCompleteSDKDemo };
+//# sourceMappingURL=complete-sdk-demo.d.ts.map

package/dist/examples/complete-sdk-demo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complete-sdk-demo.d.ts","sourceRoot":"","sources":["../../examples/complete-sdk-demo.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;GAcG;AAiNH;;GAEG;AACH,iBAAe,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CA6+BjD;AAYD,OAAO,EAAE,kBAAkB,EAAE,CAAC"}