@gala-chain/launchpad-sdk 0.4.3 → 3.0.1

package/dist/{helpers → src/helpers}/sdk.d.ts

@@ -6,6 +6,7 @@
  */
 import { Wallet } from 'ethers';
 import { LaunchpadSDK, LaunchpadSDKConfig } from '../LaunchpadSDK';
+import { Environment } from '../types/common';
 /**
  * Creates a fully configured LaunchpadSDK instance with smart defaults
  *
@@ -16,6 +17,7 @@ import { LaunchpadSDK, LaunchpadSDKConfig } from '../LaunchpadSDK';
  *
  * @param options Configuration options
  * @param options.wallet Wallet input (private key string, mnemonic string, or Wallet instance)
+ * @param options.env Environment preset ('PROD' or 'STAGE') for automatic URL configuration
  * @param options.config Additional SDK configuration options
  * @returns Fully configured LaunchpadSDK instance
  *
@@ -23,25 +25,31 @@ import { LaunchpadSDK, LaunchpadSDKConfig } from '../LaunchpadSDK';
  * ```typescript
  * import { createLaunchpadSDK } from '@gala-chain/launchpad-sdk';
  *
- * // Generate new random wallet and create SDK
+ * // Generate new random wallet and create SDK with STAGE environment
  * const sdk = createLaunchpadSDK();
  *
- * // From private key
+ * // From private key with environment
  * const sdkFromPk = createLaunchpadSDK({
- *   wallet: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12'
+ *   wallet: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12',
+ *   env: 'PROD'
  * });
  *
- * // From mnemonic
+ * // From mnemonic with config
  * const sdkFromMnemonic = createLaunchpadSDK({
- *   wallet: 'word1 word2 word3 word4 word5 word6 word7 word8 word9 word10 word11 word12'
+ *   wallet: 'word1 word2 word3 word4 word5 word6 word7 word8 word9 word10 word11 word12',
+ *   env: 'STAGE',
+ *   config: {
+ *     debug: true,
+ *     timeout: 60000
+ *   }
  * });
  *
- * // With additional config
- * const sdkWithConfig = createLaunchpadSDK({
+ * // With URL overrides
+ * const sdkWithOverrides = createLaunchpadSDK({
  *   wallet: process.env.PRIVATE_KEY,
+ *   env: 'PROD',
  *   config: {
- *     debug: true,
- *     timeout: 60000
+ *     galaChainBaseUrl: 'https://custom-gateway.example.com'
  *   }
  * });
  *
@@ -51,6 +59,7 @@ import { LaunchpadSDK, LaunchpadSDKConfig } from '../LaunchpadSDK';
  */
 export declare function createLaunchpadSDK(options?: {
     wallet?: string | Wallet;
+    env?: Environment;
     config?: Partial<LaunchpadSDKConfig>;
 }): LaunchpadSDK;
 /**
@@ -60,16 +69,17 @@ export declare function createLaunchpadSDK(options?: {
  * Uses test-friendly defaults and enables debug mode.
  *
  * @param walletInput Optional wallet input (generates random if not provided)
+ * @param env Optional environment (defaults to STAGE for testing)
  * @returns LaunchpadSDK configured for testing
  *
  * @example
  * ```typescript
- * // Quick test SDK
+ * // Quick test SDK with STAGE environment
  * const testSdk = createTestLaunchpadSDK();
  *
- * // With specific wallet
- * const testSdkWithWallet = createTestLaunchpadSDK('0x1234...');
+ * // With specific wallet and environment
+ * const testSdkWithWallet = createTestLaunchpadSDK('0x1234...', 'PROD');
  * ```
  */
-export declare function createTestLaunchpadSDK(walletInput?: string): LaunchpadSDK;
+export declare function createTestLaunchpadSDK(walletInput?: string, env?: Environment): LaunchpadSDK;
 //# sourceMappingURL=sdk.d.ts.map

package/dist/src/helpers/sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.d.ts","sourceRoot":"","sources":["../../../src/helpers/sdk.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE;IAC3C,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,GAAG,CAAC,EAAE,WAAW,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC;CACtC,GAAG,YAAY,CAkCf;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,CAAC,EAAE,MAAM,EACpB,GAAG,CAAC,EAAE,WAAW,GAChB,YAAY,CASd"}

package/dist/src/helpers/wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../../src/helpers/wallet.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAe,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,eAAe,CA8B5D;AAmCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG;IAClD,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,aAAa,GAAG,UAAU,GAAG,QAAQ,CAAC;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAwBA"}

package/dist/src/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Gala Launchpad SDK
+ *
+ * A TypeScript SDK for interacting with the Gala Launchpad backend API.
+ * Provides type-safe, authenticated access to all launchpad functionality.
+ *
+ * @packageDocumentation
+ */
+export { LaunchpadSDK, type LaunchpadSDKConfig, WebSocketError, WebSocketTimeoutError, TransactionFailedError } from './LaunchpadSDK';
+export { createLaunchpadSDK } from './helpers/sdk';
+export { createWallet } from './helpers/wallet';
+export { AgentConfig, type AgentSDKConfig, type AgentEnvironment, type SetupValidation, } from './utils/agent-config';
+export { ValidationError } from './utils/validation';
+export { FileValidationError } from './utils/multipart';
+export type { SDKConfig, } from './types/common';
+export type { PoolData, LaunchTokenData, ReverseBondingCurveConfiguration, FetchPoolsOptions, PoolsResult, AmountCalculationResult, GraphDataResult, TokenDistributionResult, TokenBadgesResult, TokenSpotPrice, } from './types/launchpad.dto';
+export type { PoolDetailsData, TradesResult, } from './types/trade.dto';
+export type { UserTokenType, TransferFaucetsData, TokenBalanceInfo, UpdateProfileData, FetchGalaBalanceOptions, FetchTokenBalanceOptions, UploadProfileImageOptions, TokenBalanceResult, UserTokenListResult, } from './types/user.dto';
+export type { CommentsResult, } from './types/comment.dto';
+export type { TransferGalaData, TransferTokenData, TransferError, TransferErrorType, } from './types/transfer.dto';
+export type { FetchVolumeDataOptions, FetchTradesOptions, FetchCommentsOptions, PostCommentOptions, CalculateBuyAmountOptions, CalculateSellAmountOptions, BuyTokenOptions, SellTokenOptions, UploadImageByTokenNameOptions, FetchTokensHeldOptions, FetchTokensCreatedOptions, } from './types/options.dto';
+export type { BaseTransactionResult, TokenLaunchResult, TradeResult, TransferResult, CommentResult, TransactionResult, } from './types/result.types';
+export { SDKTransactionStatus, } from './types/websocket.types';
+export declare const SDK_VERSION = "3.0.1";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACL,YAAY,EACZ,KAAK,kBAAkB,EACvB,cAAc,EACd,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGhD,OAAO,EACL,WAAW,EACX,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACrB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAGxD,YAAY,EACV,SAAS,GACV,MAAM,gBAAgB,CAAC;AAGxB,YAAY,EACV,QAAQ,EACR,eAAe,EACf,gCAAgC,EAEhC,iBAAiB,EAEjB,WAAW,EACX,uBAAuB,EACvB,eAAe,EACf,uBAAuB,EACvB,iBAAiB,EAEjB,cAAc,GACf,MAAM,uBAAuB,CAAC;AAG/B,YAAY,EACV,eAAe,EAEf,YAAY,GACb,MAAM,mBAAmB,CAAC;AAG3B,YAAY,EACV,aAAa,EACb,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EAEjB,uBAAuB,EACvB,wBAAwB,EACxB,yBAAyB,EAEzB,kBAAkB,EAElB,mBAAmB,GACpB,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EAEV,cAAc,GACf,MAAM,qBAAqB,CAAC;AAG7B,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAG9B,YAAY,EACV,sBAAsB,EACtB,kBAAkB,EAClB,oBAAoB,EACpB,kBAAkB,EAClB,yBAAyB,EACzB,0BAA0B,EAC1B,eAAe,EACf,gBAAgB,EAChB,6BAA6B,EAC7B,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,qBAAqB,CAAC;AAG7B,YAAY,EACV,qBAAqB,EACrB,iBAAiB,EACjB,WAAW,EACX,cAAc,EACd,aAAa,EACb,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,oBAAoB,GACrB,MAAM,yBAAyB,CAAC;AAGjC,eAAO,MAAM,WAAW,UAAU,CAAC"}

package/dist/src/services/BundleService.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Bundle Service for Transaction Processing
+ *
+ * This service handles bundle transaction submission to the launchpad
+ * backend. It formats the request data in the exact structure expected
+ * by the bundle API and provides proper error handling.
+ *
+ * ## Bundle Transaction Format:
+ * ```json
+ * {
+ *   "signedDto": {
+ *     // Signed DTO with signature, types, domain
+ *   },
+ *   "stringsInstructions": [
+ *     // Array of resource tracking strings
+ *   ],
+ *   "method": "BuyWithNative" | "BuyExactToken" | "SellExactToken" | "SellWithNative"
+ * }
+ * ```
+ *
+ * ## Response Handling:
+ * - Success: Returns transaction ID for WebSocket monitoring
+ * - Error: Provides detailed error messages for debugging
+ *
+ * @category Services
+ * @since 2.0.0
+ */
+import { HttpClient } from '../utils/http';
+import type { ApiResponse } from '../types/common';
+import { TokenResolverService } from './TokenResolverService';
+import { BuyTokenOptions, SellTokenOptions } from '../types/options.dto';
+/**
+ * Bundle transaction data structure
+ */
+export interface BundleTransactionData {
+    signedDto: any;
+    stringsInstructions: string[];
+    method: string;
+}
+/**
+ * Service for handling bundle transaction submission and trading operations
+ */
+export declare class BundleService {
+    private httpClient;
+    private tokenResolver;
+    private walletProvider?;
+    private userAddress?;
+    private defaultSlippageToleranceFactor;
+    private readonly bundleEndpoint;
+    private readonly logger;
+    private signatureService?;
+    private tokenKeyService?;
+    constructor(httpClient: HttpClient, tokenResolver: TokenResolverService, debugMode?: boolean, walletProvider?: any | undefined, userAddress?: string | undefined, defaultSlippageToleranceFactor?: number);
+    /**
+     * Submit a bundle transaction to the backend
+     *
+     * @param bundleData - Complete bundle transaction data
+     * @returns API response with transaction ID or error
+     *
+     * @example
+     * ```typescript
+     * const bundleData = {
+     *   signedDto: signedPayload,
+     *   stringsInstructions: [
+     *     '$service$Token$Unit$ANIME$none$launchpad',
+     *     '$tokenBalance$Token$Unit$ANIME$none$vaultAddress',
+     *     // ... more strings
+     *   ],
+     *   method: 'BuyWithNative'
+     * };
+     *
+     * const response = await bundleService.submitTransaction(bundleData);
+     * ```
+     */
+    submitTransaction(bundleData: BundleTransactionData): Promise<ApiResponse>;
+    /**
+     * Validate bundle transaction data
+     */
+    private validateBundleData;
+    /**
+     * Format bundle request for API submission
+     */
+    private formatBundleRequest;
+    /**
+     * Handle bundle API response
+     */
+    private handleBundleResponse;
+    /**
+     * Format error message for consistent error handling
+     */
+    private formatErrorMessage;
+    /**
+     * Get bundle transaction status
+     *
+     * @param transactionId - Transaction ID returned from submitTransaction
+     * @returns Transaction status information
+     */
+    getTransactionStatus(transactionId: string): Promise<ApiResponse>;
+    /**
+     * Cancel a pending bundle transaction
+     *
+     * @param transactionId - Transaction ID to cancel
+     * @returns Cancellation result
+     */
+    cancelTransaction(transactionId: string): Promise<ApiResponse>;
+    /**
+     * Get bundle service health status
+     *
+     * @returns Service health information
+     */
+    getHealthStatus(): Promise<ApiResponse>;
+    /**
+     * Buy tokens with unified, simplified API
+     *
+     * @param options Trading options
+     * @param options.tokenName Token name (e.g., "dragnrkti", "rocketri", "unicornri")
+     * @param options.amount Amount to trade (GALA for 'native', tokens for 'exact')
+     * @param options.type Trading type: 'native' = spend GALA, 'exact' = buy exact tokens
+     * @param options.expectedAmount Expected amount from prior calculation (required)
+     * @param options.slippageToleranceFactor Optional slippage tolerance factor (default: SDK default)
+     * @returns Promise<ApiResponse> Transaction result
+     * @throws ValidationError if parameters are invalid or token not found
+     *
+     * @example
+     * ```typescript
+     * // Buy tokens by spending exactly 100 GALA
+     * const result = await bundleService.buyToken({
+     *   tokenName: "dragnrkti",
+     *   amount: "100",
+     *   type: "native",
+     *   expectedAmount: "1342612.26",
+     *   slippageToleranceFactor: 0.05
+     * });
+     *
+     * // Buy exactly 50 tokens
+     * const result = await bundleService.buyToken({
+     *   tokenName: "dragnrkti",
+     *   amount: "50",
+     *   type: "exact",
+     *   expectedAmount: "3.75",
+     *   slippageToleranceFactor: 0.03
+     * });
+     * ```
+     */
+    buyToken(options: BuyTokenOptions): Promise<ApiResponse>;
+    /**
+     * Sell tokens with unified, simplified API
+     *
+     * @param options Trading options
+     * @param options.tokenName Token name (e.g., "dragnrkti", "rocketri", "unicornri")
+     * @param options.amount Amount to trade (tokens for 'exact', GALA for 'native')
+     * @param options.type Trading type: 'exact' = sell exact tokens, 'native' = receive exact GALA
+     * @param options.expectedAmount Expected amount from prior calculation (required)
+     * @param options.maxAcceptableReverseBondingCurveFee Optional max acceptable reverse bonding curve fee
+     * @param options.slippageToleranceFactor Optional slippage tolerance factor (default: SDK default)
+     * @returns Promise<ApiResponse> Transaction result
+     * @throws ValidationError if parameters are invalid or token not found
+     *
+     * @example
+     * ```typescript
+     * // Sell exactly 50 tokens (with slippage protection)
+     * const result = await bundleService.sellToken({
+     *   tokenName: "dragnrkti",
+     *   amount: "50",
+     *   type: "exact",
+     *   expectedAmount: "3.75",
+     *   slippageToleranceFactor: 0.05
+     * });
+     *
+     * // Sell tokens to receive exactly 25 GALA (with slippage protection)
+     * const result = await bundleService.sellToken({
+     *   tokenName: "dragnrkti",
+     *   amount: "25",
+     *   type: "native",
+     *   expectedAmount: "333.33",
+     *   slippageToleranceFactor: 0.03
+     * });
+     * ```
+     */
+    sellToken(options: SellTokenOptions): Promise<ApiResponse>;
+    /**
+     * Ensure trading services are available
+     */
+    private ensureTradingServicesAvailable;
+    /**
+     * Execute bundle transaction with signature generation
+     */
+    private executeBundleTransaction;
+    /**
+     * Resolves a token name to its vault address using TokenResolverService
+     *
+     * @param tokenName Token name to resolve (e.g., 'dragnrkti', 'rocketri')
+     * @returns Promise<string | null> Vault address if found, null otherwise
+     */
+    private resolveTokenNameToVault;
+}
+//# sourceMappingURL=BundleService.d.ts.map

package/dist/src/services/BundleService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BundleService.d.ts","sourceRoot":"","sources":["../../../src/services/BundleService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAInD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAMzE;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,GAAG,CAAC;IACf,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;CAChB;AAYD;;GAEG;AACH,qBAAa,aAAa;IAOtB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,aAAa;IAErB,OAAO,CAAC,cAAc,CAAC;IACvB,OAAO,CAAC,WAAW,CAAC;IACpB,OAAO,CAAC,8BAA8B;IAXxC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAa;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,gBAAgB,CAAC,CAAmB;IAC5C,OAAO,CAAC,eAAe,CAAC,CAAuB;gBAGrC,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,oBAAoB,EAC3C,SAAS,GAAE,OAAe,EAClB,cAAc,CAAC,EAAE,GAAG,YAAA,EACpB,WAAW,CAAC,EAAE,MAAM,YAAA,EACpB,8BAA8B,GAAE,MAAa;IAYvD;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,iBAAiB,CACrB,UAAU,EAAE,qBAAqB,GAChC,OAAO,CAAC,WAAW,CAAC;IA4CvB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAmD1B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAQ3B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAwB5B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAoB1B;;;;;OAKG;IACG,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IA8BvE;;;;;OAKG;IACG,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IA8BpE;;;;OAIG;IACG,eAAe,IAAI,OAAO,CAAC,WAAW,CAAC;IA6B7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACG,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IA6F9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACG,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,CAAC;IAgHhE;;OAEG;IACH,OAAO,CAAC,8BAA8B;IAYtC;;OAEG;YACW,wBAAwB;IA2DtC;;;;;OAKG;YAEW,uBAAuB;CAKtC"}

package/dist/src/services/DexService.d.ts

@@ -0,0 +1,84 @@
+/**
+ * DEX API Service
+ *
+ * This service handles DEX API spot price operations for tokens.
+ * It provides methods to fetch current USD spot prices for DEX tokens
+ * and calculate spot prices for launchpad tokens.
+ */
+import { HttpClient } from '../utils/http';
+import { TokenSpotPrice } from '../types/launchpad.dto';
+import { CalculateBuyAmountOptions } from '../types/options.dto';
+import { AmountCalculationResult } from '../types/launchpad.dto';
+/**
+ * DexService handles DEX API spot price operations
+ *
+ * This service provides access to token pricing information from the DEX API.
+ * It supports both single and multiple token price queries, as well as
+ * calculated spot prices for launchpad tokens.
+ *
+ * @category Services
+ * @since 1.0.0
+ */
+export declare class DexService {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Fetch current USD spot prices for one or more DEX token symbols
+     *
+     * Uses the DEX API to retrieve current pricing information for tokens.
+     * Supports both single symbol and multiple symbol requests with comma-separated format.
+     *
+     * @param symbols Single symbol string or array of symbols (e.g., 'GALA', ['GALA', 'SILK'])
+     * @returns Promise<TokenSpotPrice[]> Array of simplified token spot prices
+     *
+     * @example Single token price
+     * ```typescript
+     * const prices = await dexService.fetchTokenSpotPrice('GALA');
+     * console.log(prices[0].price); // 0.01463269
+     * console.log(prices[0].symbol); // 'GALA'
+     * ```
+     *
+     * @example Multiple token prices
+     * ```typescript
+     * const prices = await dexService.fetchTokenSpotPrice(['GALA', 'SILK', 'MUSIC']);
+     * prices.forEach(price => {
+     *   console.log(`${price.symbol}: $${price.price}`);
+     * });
+     * ```
+     *
+     * @throws Error if no valid symbols provided
+     * @throws Error if API request fails
+     */
+    fetchTokenSpotPrice(symbols: string | string[]): Promise<TokenSpotPrice[]>;
+    /**
+     * Calculate spot price for a launchpad token in USD
+     *
+     * Calculates the USD price of a launchpad token by:
+     * 1. Determining how many tokens you get for 1 GALA using calculateBuyAmount
+     * 2. Getting the current GALA price in USD
+     * 3. Computing: GALA_price_USD / tokens_per_GALA
+     *
+     * **Note**: This method requires a reference to the LaunchpadAPI's calculateBuyAmount
+     * method to work. It should be called from the LaunchpadAPI context.
+     *
+     * @param tokenName Token name (e.g., 'dragnrkti', 'rocketri', 'unicornri')
+     * @param calculateBuyAmount Reference to LaunchpadAPI's calculateBuyAmount method
+     * @returns Promise<TokenSpotPrice> Spot price with symbol and USD price
+     *
+     * @example
+     * ```typescript
+     * const price = await dexService.fetchLaunchpadTokenSpotPrice(
+     *   'dragnrkti',
+     *   (opts) => launchpadAPI.calculateBuyAmount(opts)
+     * );
+     * console.log(`${price.symbol}: $${price.price.toFixed(6)}`);
+     * // Output: DRAGNRKTI: $0.000123
+     * ```
+     *
+     * @throws Error if token not found
+     * @throws Error if price calculation fails
+     * @throws Error if GALA price unavailable
+     */
+    fetchLaunchpadTokenSpotPrice(tokenName: string, calculateBuyAmount: (options: CalculateBuyAmountOptions) => Promise<AmountCalculationResult>): Promise<TokenSpotPrice>;
+}
+//# sourceMappingURL=DexService.d.ts.map

package/dist/src/services/DexService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DexService.d.ts","sourceRoot":"","sources":["../../../src/services/DexService.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EACL,cAAc,EAEf,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAEjE;;;;;;;;;GASG;AACH,qBAAa,UAAU;IACT,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,UAAU;IAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAsChF;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACG,4BAA4B,CAChC,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,CAAC,OAAO,EAAE,yBAAyB,KAAK,OAAO,CAAC,uBAAuB,CAAC,GAC3F,OAAO,CAAC,cAAc,CAAC;CA4C3B"}

package/dist/src/services/GalaChainService.d.ts

@@ -0,0 +1,254 @@
+/**
+ * GalaChain Service
+ *
+ * Consolidated service for all GalaChain gateway operations.
+ * This service encapsulates direct interactions with the GalaChain gateway,
+ * providing a clean separation of concerns between backend API calls and
+ * blockchain operations.
+ *
+ * Features:
+ * - Pool details fetching (for bonding curves)
+ * - GALA balance queries
+ * - Token balance queries
+ * - GALA transfers with EIP-712 signatures
+ * - Token transfers with EIP-712 signatures
+ *
+ * @example
+ * ```typescript
+ * const galaChainService = new GalaChainService(galaChainHttp, wallet);
+ *
+ * // Fetch pool details for bonding curve
+ * const poolDetails = await galaChainService.fetchPoolDetails({
+ *   vaultAddress: "service|Token$Unit$MYSYMBOL$address$launchpad"
+ * });
+ *
+ * // Get GALA balance
+ * const balance = await galaChainService.fetchGalaBalance({
+ *   owner: "eth|1234567890abcdef1234567890abcdef12345678",
+ *   collection: "GALA",
+ *   category: "Unit",
+ *   additionalKey: "none",
+ *   type: "none",
+ *   instance: "0"
+ * });
+ *
+ * // Transfer tokens
+ * const txId = await galaChainService.transferToken({
+ *   from: "eth|sender...",
+ *   to: "eth|recipient...",
+ *   quantity: "100",
+ *   tokenInstance: {...},
+ *   signedPayload: {...}
+ * });
+ * ```
+ */
+import { HttpClient } from '../utils/http';
+import { TokenResolverService } from './TokenResolverService';
+import { TokenClassKey } from '../types/common';
+import { Wallet } from 'ethers';
+import { FetchPoolDetailsData, InternalFetchPoolDetailsResponse } from '../types/trade.dto';
+import { TokenBalanceResult } from '../types/user.dto';
+import { TransferGalaData, TransferTokenData } from '../types/transfer.dto';
+/**
+ * GalaChain Service for blockchain operations
+ */
+export declare class GalaChainService {
+    private readonly http;
+    private readonly wallet;
+    private readonly tokenResolver;
+    private readonly signatureHelper;
+    private readonly logger;
+    /**
+     * Initialize GalaChain Service
+     *
+     * @param http - HTTP client configured for GalaChain gateway
+     * @param wallet - Ethers wallet for signing transactions
+     * @param tokenResolver - Token resolver service for vault address resolution
+     * @param debug - Enable debug logging (default: false)
+     */
+    constructor(http: HttpClient, wallet: Wallet, tokenResolver: TokenResolverService, debug?: boolean);
+    /**
+     * Fetches pool details by vault address from GalaChain
+     *
+     * Internal method for fetching pool details by vault address
+     * Used internally after vault resolution
+     *
+     * @param data Fetch pool details data with vault address
+     * @returns Promise<InternalFetchPoolDetailsResponse> Current trading pool state
+     * @throws ValidationError if input validation fails
+     * @throws Error if pool details fetch fails
+     *
+     * @example
+     * ```typescript
+     * const poolDetails = await galaChainService.fetchPoolDetails({
+     *   vaultAddress: "service|Token$Unit$MYSYMBOL$eth:address$launchpad"
+     * });
+     * console.log('GALA in vault:', poolDetails.Data.nativeTokenQuantity);
+     * ```
+     */
+    fetchPoolDetails(data: FetchPoolDetailsData): Promise<InternalFetchPoolDetailsResponse>;
+    /**
+     * Validates fetch pool details data
+     */
+    private validateFetchPoolDetailsData;
+    /**
+     * Fetches GALA balance for a user from GalaChain
+     *
+     * Uses the GalaChain FetchBalances endpoint with GALA token parameters.
+     *
+     * @param requestBody Balance query parameters
+     * @returns Promise<TokenBalanceResult | null> Clean balance information or null if not held
+     * @throws Error if balance fetch fails
+     *
+     * @example
+     * ```typescript
+     * const balance = await galaChainService.fetchGalaBalance({
+     *   owner: "eth|1234567890abcdef1234567890abcdef12345678",
+     *   collection: "GALA",
+     *   category: "Unit",
+     *   additionalKey: "none",
+     *   type: "none",
+     *   instance: "0"
+     * });
+     * ```
+     */
+    fetchGalaBalance(requestBody: {
+        owner: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+        type: string;
+        instance: string;
+    }): Promise<TokenBalanceResult | null>;
+    /**
+     * Fetches token balance for any token from GalaChain
+     *
+     * Generic method for querying token balances using the GalaChain FetchBalances endpoint.
+     *
+     * @param requestBody Balance query parameters
+     * @returns Promise<TokenBalanceResult | null> Clean balance information or null if not held
+     * @throws Error if balance fetch fails
+     *
+     * @example
+     * ```typescript
+     * const balance = await galaChainService.fetchTokenBalance({
+     *   owner: "eth|1234567890abcdef1234567890abcdef12345678",
+     *   collection: "ANIME",
+     *   category: "Unit",
+     *   additionalKey: "none",
+     *   type: "none",
+     *   instance: "0"
+     * });
+     * ```
+     */
+    fetchTokenBalance(requestBody: {
+        owner: string;
+        collection: string;
+        category: string;
+        additionalKey: string;
+        type: string;
+        instance: string;
+    }): Promise<TokenBalanceResult | null>;
+    /**
+     * Transfer GALA tokens between wallets
+     *
+     * Creates and signs a TransferToken transaction for GALA using EIP-712
+     * signatures and submits it to the GalaChain gateway.
+     *
+     * @param data - Transfer data including recipient and amount
+     * @returns Promise<string> Transaction ID from successful transfer
+     *
+     * @example
+     * ```typescript
+     * const transactionId = await galaChainService.transferGala({
+     *   recipientAddress: 'eth|1234567890abcdef1234567890abcdef12345678',
+     *   amount: '1' // 1 GALA
+     * });
+     *
+     * console.log('GALA transfer successful:', transactionId);
+     * ```
+     *
+     * @throws {TransferError} When validation fails or transfer is rejected
+     */
+    transferGala(data: TransferGalaData): Promise<string>;
+    /**
+     * Transfer launchpad tokens between wallets
+     *
+     * Creates and signs a TransferToken transaction for launchpad tokens using
+     * EIP-712 signatures and submits it to the GalaChain gateway.
+     *
+     * @param data - Transfer data including recipient, token name, and amount
+     * @returns Promise<string> Transaction ID from successful transfer
+     *
+     * @example
+     * ```typescript
+     * const transactionId = await galaChainService.transferToken({
+     *   to: 'eth|9876543210fedcba9876543210fedcba98765432',
+     *   tokenName: 'tinyevil',
+     *   amount: '100000000'
+     * });
+     *
+     * console.log('Token transfer successful:', transactionId);
+     * ```
+     *
+     * @throws {TransferError} When validation fails or transfer is rejected
+     */
+    transferToken(data: TransferTokenData): Promise<string>;
+    /**
+     * Resolve token class key from token name
+     *
+     * Public method to resolve a token name to its tokenClassKey for caching or optimization patterns.
+     * Uses the same resolution logic as transferToken internally.
+     *
+     * @param tokenName - Token name to resolve (e.g., 'unicorn', 'tinyevil')
+     * @returns Promise<TokenClassKey> The resolved token class key object
+     *
+     * @example
+     * ```typescript
+     * const tokenClassKey = await galaChainService.resolveTokenClassKey('unicorn');
+     * // Returns: { collection: "Token", category: "Unit", type: "UNI", additionalKey: "eth:..." }
+     *
+     * // Can be cached and used later for direct transfers
+     * await galaChainService.transferToken({
+     *   to: 'eth|...',
+     *   tokenId: tokenClassKey, // Direct, no lookup
+     *   amount: '1'
+     * });
+     * ```
+     *
+     * @throws {TransferError} When token name cannot be resolved
+     */
+    resolveTokenClassKey(tokenName: string): Promise<TokenClassKey>;
+    /**
+     * Validate GALA transfer data
+     */
+    private validateTransferGalaData;
+    /**
+     * Validate token transfer data
+     */
+    private validateTransferTokenData;
+    /**
+     * Check if an address is in valid format (eth| or 0x)
+     */
+    private isValidAddress;
+    /**
+     * Convert address to backend format (eth|40hex)
+     */
+    private formatAddressForBackend;
+    /**
+     * Resolve token name to tokenInstance object for transfers
+     * Uses TokenResolverService to get vault address, then parses it to extract tokenInstance components
+     */
+    private resolveTokenInstance;
+    /**
+     * Parse vault address and extract token instance components
+     * Vault format: service|Token$Unit$UNI$eth:9401b171307bE656f00F9e18DF756643FD3a91dE$launchpad
+     * Returns structured tokenInstance object like transferGala uses
+     */
+    private resolveTokenInstanceFromVaultAddress;
+    /**
+     * Handle transfer errors with proper typing and context
+     */
+    private handleTransferError;
+}
+//# sourceMappingURL=GalaChainService.d.ts.map

package/dist/src/services/GalaChainService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GalaChainService.d.ts","sourceRoot":"","sources":["../../../src/services/GalaChainService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EACL,oBAAoB,EACpB,gCAAgC,EAEjC,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAEL,kBAAkB,EACnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EAQlB,MAAM,uBAAuB,CAAC;AAE/B;;GAEG;AACH,qBAAa,gBAAgB;IAazB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAdhC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAEhC;;;;;;;OAOG;gBAEgB,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,oBAAoB,EACpD,KAAK,GAAE,OAAe;IAUxB;;;;;;;;;;;;;;;;;;OAkBG;IACG,gBAAgB,CACpB,IAAI,EAAE,oBAAoB,GACzB,OAAO,CAAC,gCAAgC,CAAC;IAqB5C;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAiCpC;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,gBAAgB,CAAC,WAAW,EAAE;QAClC,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,aAAa,EAAE,MAAM,CAAC;QACtB,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAItC;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,iBAAiB,CAAC,WAAW,EAAE;QACnC,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,aAAa,EAAE,MAAM,CAAC;QACtB,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAsDtC;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC;IA6E3D;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,aAAa,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAwG7D;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IA2BrE;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAgDhC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAqEjC;;OAEG;IACH,OAAO,CAAC,cAAc;IAOtB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAO/B;;;OAGG;YACW,oBAAoB;IA0ClC;;;;OAIG;IACH,OAAO,CAAC,oCAAoC;IA2C5C;;OAEG;IACH,OAAO,CAAC,mBAAmB;CAqD5B"}