@gala-chain/launchpad-sdk 8.0.2 → 9.0.0-rc.0

package/dist/services/GalaChainTokenService.d.ts

@@ -1,23 +1,19 @@
 /**
  * GalaChain Token Service
  *
- * Service responsible for token metadata and class queries from GalaChain.
- * Extracted from GalaChainService for single responsibility.
- *
- * Features:
- * - Token class metadata fetching (symbol, decimals, name, image)
- * - Token supply information queries
- * - Support for both native and wrapped tokens
+ * Token classes from GalaChain (metadata and supply). The reads themselves (`FetchTokenClasses`,
+ * `FetchTokenClassesWithSupply`, the answer's checks) are `@gala-chain/gala-core-sdk`'s
+ * `GatewayReads`; this service keeps launchpad's token-id spellings, results and error contract on
+ * top of it, and sends the reads through the SDK's unauthenticated gateway axios instance exactly
+ * as before.
  *
  * @example
  * ```typescript
  * const tokenService = new GalaChainTokenService(http, debug, publicAxios);
  *
- * // Fetch native GALA token metadata
  * const gala = await tokenService.fetchTokenClassFromChain('GALA|Unit|none|none');
  * console.log(`Symbol: ${gala.symbol}`); // "GALA"
  *
- * // Fetch token supply information
  * const supplies = await tokenService.fetchTokenClassesWithSupply([
  *   { collection: 'GALA', category: 'Unit', type: 'none', additionalKey: 'none' }
  * ]);
@@ -26,10 +22,8 @@
  * @category Services
  * @since 5.15.0
  */
-import type { TokenClass } from '@gala-chain/api';
+import { type GalaChainTokenClass, type GalaChainTokenClassKey } from '@gala-chain/gala-core-sdk';
 import type { AxiosInstance } from 'axios';
-import type { TokenClassKey } from '../types/common';
-import type { TokenClassWithSupply } from '../types/launchpad.dto';
 import type { HttpClient } from '../utils/http';
 import { BaseService } from './BaseService';
 /**
@@ -48,62 +42,40 @@ export declare class GalaChainTokenService extends BaseService {
      */
     constructor(http: HttpClient, debug?: boolean, publicAxios?: AxiosInstance | undefined);
     /**
-     * Fetch token metadata from GalaChain using native FetchTokenClasses API
-     *
-     * Queries the authoritative GalaChain token registry for complete token metadata
-     * including symbol, decimals, name, image, and description. This is the source
-     * of truth for all tokens on GalaChain (both native and wrapped).
-     *
-     * Supports both native tokens (GALA, etc.) and wrapped DEX tokens.
+     * Fetch a token class from GalaChain (`FetchTokenClasses`): the authoritative registry of every
+     * token (native and wrapped), with its symbol, decimals, name, image and description.
      *
-     * @param tokenId Token identifier (string or TokenClassKey format)
-     * @returns Promise<TokenClass> Complete token metadata from GalaChain
+     * @param tokenId Token identifier (pipe string, 4 or 5 parts, or TokenClassKey object)
+     * @returns Promise<GalaChainTokenClass> The token class
      * @throws ValidationError if tokenId validation fails
-     * @throws Error if token fetch fails or token not found
+     * @throws NetworkError if the token is not found (404) or the fetch fails
      *
      * @example
      * ```typescript
-     * // Fetch native GALA token metadata
      * const gala = await tokenService.fetchTokenClassFromChain('GALA|Unit|none|none');
      * console.log(`Symbol: ${gala.symbol}`); // "GALA"
      * console.log(`Decimals: ${gala.decimals}`); // 8
-     *
-     * // Fetch wrapped token metadata
-     * const gusdc = await tokenService.fetchTokenClassFromChain({
-     *   collection: 'GUSDC',
-     *   category: 'Unit',
-     *   type: 'none',
-     *   additionalKey: 'none'
-     * });
-     * console.log(`Symbol: ${gusdc.symbol}`); // "GUSDC"
      * ```
      */
-    fetchTokenClassFromChain(tokenId: string | TokenClassKey): Promise<TokenClass>;
+    fetchTokenClassFromChain(tokenId: string | GalaChainTokenClassKey): Promise<GalaChainTokenClass>;
     /**
      * Fetch supply information for one or more token classes from GalaChain
+     * (`FetchTokenClassesWithSupply`): total and maximum supply, burned amount, known mint supplies
+     * and the class metadata, one class per key in the order asked.
      *
-     * Queries GalaChain for authoritative token supply data including:
-     * - Total supply and maximum supply
-     * - Total burned amount
-     * - Mint-related supply metrics
-     * - Token metadata (symbol, decimals, name)
-     *
-     * @param tokenClasses - Array of token class keys to query
-     * @returns Promise<TokenClassWithSupply[]> Array of token classes with supply information
+     * @param tokenClasses - Array of token class keys to query (1 to 1000)
+     * @returns Promise<GalaChainTokenClass[]> The token classes with their supply figures
      * @throws {ValidationError} if tokenClasses array is empty
-     * @throws {Error} if network request fails or GalaChain returns error status
-     *
-     * @example
-     * ```typescript
-     * const supplies = await tokenService.fetchTokenClassesWithSupply([
-     *   { collection: 'GALA', category: 'Unit', type: 'none', additionalKey: 'none' },
-     *   { collection: 'GUSDC', category: 'Unit', type: 'none', additionalKey: 'eth:0x...' }
-     * ]);
-     *
-     * console.log(`${supplies[0].symbol}: ${supplies[0].totalSupply}`);
-     * ```
+     * @throws {NetworkError} if a class is not found, the request fails or GalaChain refuses it
+     */
+    fetchTokenClassesWithSupply(tokenClasses: GalaChainTokenClassKey[]): Promise<GalaChainTokenClass[]>;
+    /**
+     * Runs a core read through the public gateway axios instance. When core refuses the gateway's
+     * 2xx answer, `legacyChecks` re-reads that same answer and throws launchpad's own error for it
+     * (the error launchpad has always thrown); should it not, `notFound` (for a missing class) or
+     * core's error stands (fail closed: an answer core refused is never returned).
      */
-    fetchTokenClassesWithSupply(tokenClasses: TokenClassKey[]): Promise<TokenClassWithSupply[]>;
+    private readPublic;
     private handleTokenServiceError;
 }
 //# sourceMappingURL=GalaChainTokenService.d.ts.map

package/dist/services/GalaChainTokenService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GalaChainTokenService.d.ts","sourceRoot":"","sources":["../../src/services/GalaChainTokenService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAEV,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAIhC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;;;GAIG;AACH,qBAAa,qBAAsB,SAAQ,WAAW;IAWlD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;IAV/B;;;;;;OAMG;gBAED,IAAI,EAAE,UAAU,EAChB,KAAK,GAAE,OAAe,EACL,WAAW,CAAC,EAAE,aAAa,YAAA;IAK9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACG,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC;IA4DpF;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,2BAA2B,CAC/B,YAAY,EAAE,aAAa,EAAE,GAC5B,OAAO,CAAC,oBAAoB,EAAE,CAAC;IAyClC,OAAO,CAAC,uBAAuB;CAuBhC"}
+{"version":3,"file":"GalaChainTokenService.d.ts","sourceRoot":"","sources":["../../src/services/GalaChainTokenService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAGL,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC5B,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAK3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAgB5C;;;;GAIG;AACH,qBAAa,qBAAsB,SAAQ,WAAW;IAWlD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;IAV/B;;;;;;OAMG;gBAED,IAAI,EAAE,UAAU,EAChB,KAAK,GAAE,OAAe,EACL,WAAW,CAAC,EAAE,aAAa,YAAA;IAK9C;;;;;;;;;;;;;;;OAeG;IACG,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,sBAAsB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAsBtG;;;;;;;;;OASG;IACG,2BAA2B,CAC/B,YAAY,EAAE,sBAAsB,EAAE,GACrC,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAoBjC;;;;;OAKG;YACW,UAAU;IAwBxB,OAAO,CAAC,uBAAuB;CAuBhC"}

package/dist/services/GalaChainTransferService.d.ts

@@ -4,8 +4,12 @@
  * Service responsible for token transfer and burn operations on GalaChain.
  * Extracted from GalaChainService for single responsibility.
  *
+ * The writes themselves are `@gala-chain/gala-core-sdk`'s `GatewayWrites` (DTO, signature, the
+ * POST and the reading of GalaChain's answer); this service keeps the launchpad API on top of it:
+ * its input checks, launchpad token-name resolution, its result shapes and its error classes.
+ *
  * Features:
- * - GALA transfers with EIP-712 signatures
+ * - GALA transfers
  * - Generic token transfers (launchpad and standard tokens)
  * - Token burning (irreversible)
  * - Token class key resolution
@@ -36,43 +40,28 @@
  * @category Services
  * @since 5.15.0
  */
-import type { Wallet } from 'ethers';
+import { type GalaChainTokenClassKey } from '@gala-chain/gala-core-sdk';
 import type { BurnTokensData, BurnTokensResult } from '../types/burn.dto';
-import type { TokenClassKey } from '../types/common';
 import type { GalaChainTransferReceipt, TransferGalaData, TransferTokenData } from '../types/transfer.dto';
-import type { HttpClient } from '../utils/http';
-import { BaseService } from './BaseService';
-import type { TokenResolverService } from './TokenResolverService';
+import { GatewayWriteService } from './gateway-writes';
 /**
  * GalaChain Transfer Service
  *
  * Handles all token transfer and burn operations on GalaChain.
  */
-export declare class GalaChainTransferService extends BaseService {
-    private readonly wallet;
-    private readonly tokenResolver;
-    private readonly nativeSigner;
-    /**
-     * Initialize GalaChain Transfer Service
-     *
-     * @param http - HTTP client configured for GalaChain gateway
-     * @param wallet - Ethers wallet for signing transactions (optional for read-only operations)
-     * @param tokenResolver - Token resolver service for vault address resolution
-     * @param debug - Enable debug logging (default: false)
-     */
-    constructor(http: HttpClient, wallet: Wallet | undefined, tokenResolver: TokenResolverService, debug?: boolean);
+export declare class GalaChainTransferService extends GatewayWriteService {
     /**
      * Transfer GALA tokens between wallets
      *
-     * Creates and signs a TransferToken transaction for GALA using native
-     * GalaChain signing and submits it to the GalaChain gateway.
+     * Signs a TransferToken write for GALA with the wallet's key (native GalaChain signing) and
+     * submits it to the GalaChain gateway.
      *
      * @param data - Transfer data including recipient and amount
-     * @returns Promise<string> Transaction ID from successful transfer
+     * @returns The receipt: the chain transaction id and, when the gateway sends it, the block
      *
      * @example
      * ```typescript
-     * const transactionId = await transferService.transferGala({
+     * const { transactionId } = await transferService.transferGala({
      *   recipientAddress: 'eth|1234567890abcdef1234567890abcdef12345678',
      *   amount: '1' // 1 GALA
      * });
@@ -86,15 +75,15 @@ export declare class GalaChainTransferService extends BaseService {
     /**
      * Transfer launchpad tokens between wallets
      *
-     * Creates and signs a TransferToken transaction for launchpad tokens using
-     * native GalaChain signing and submits it to the GalaChain gateway.
+     * Signs a TransferToken write with the wallet's key (native GalaChain signing) 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
+     * @returns The receipt: the chain transaction id and, when the gateway sends it, the block
      *
      * @example
      * ```typescript
-     * const transactionId = await transferService.transferToken({
+     * const { transactionId } = await transferService.transferToken({
      *   to: 'eth|9876543210fedcba9876543210fedcba98765432',
      *   tokenName: 'tinyevil',
      *   amount: '100000000'
@@ -130,7 +119,7 @@ export declare class GalaChainTransferService extends BaseService {
      *
      * @throws {TransferError} When token name cannot be resolved
      */
-    resolveTokenClassKey(tokenName: string): Promise<TokenClassKey>;
+    resolveTokenClassKey(tokenName: string): Promise<GalaChainTokenClassKey>;
     /**
      * Permanently burn tokens on GalaChain
      *
@@ -141,7 +130,7 @@ export declare class GalaChainTransferService extends BaseService {
      * Supports batch burning of multiple token types in a single transaction.
      *
      * @param data - Burn data containing tokens array with amounts
-     * @returns Result with transaction ID and burned token details
+     * @returns Result with transaction ID, block (when the gateway sends it) and burned token details
      * @throws {BurnError} When validation fails or burn operation is rejected
      *
      * @example
@@ -173,33 +162,45 @@ export declare class GalaChainTransferService extends BaseService {
      * Validate burn tokens data
      */
     private validateBurnTokensData;
+    /**
+     * The token instance a launchpad input names: `tokenId` (string, class key or instance key)
+     * first, else `tokenName` through the launchpad resolver, else `missing()`.
+     */
+    private tokenInstanceOf;
     /**
      * Resolve token name to tokenInstance object for transfers
      * Uses TokenResolverService to get vault address, then parses it to extract tokenInstance components
      */
     private resolveTokenInstance;
     /**
-     * Extract transfer result from gateway body + response headers.
+     * The launchpad receipt of a transfer, from the gateway's answer (and core's receipt, when core
+     * accepted it). Called with no receipt when core refused the answer: it then throws the error
+     * this service has always thrown for that answer.
      *
      * If the body carries GalaChain's `{ Status, Data }` envelope, `Status` is checked FIRST and
-     * throws on anything but success (1) -- before the `x-transaction-id` header or any body field
-     * is trusted. A gateway proxy can set that header independent of whether the chain call
-     * actually succeeded, so it must never be treated as its own success signal.
+     * throws on anything but success (1) -- before any transaction id is trusted. A gateway proxy can
+     * set `x-transaction-id` independent of whether the chain call actually succeeded, so it must
+     * never be treated as its own success signal. Checked on `Status` alone, NOT `Status` + `Data`:
+     * GalaChain's error envelope (`{ Status, Message, ErrorCode, ErrorKey, ErrorPayload }`) has no
+     * `Data`.
      *
      * Priority for transactionId once Status (if present) has passed:
-     * 1. Header `x-transaction-id` (real chain hash — use for Chainmeter)
-     * 2. Body.transactionId (legacy)
-     * 3. Body.Data[].transactionId / txnId / etc.
-     * 4. Operation success stub only if Status:1 with no hash (should be rare)
+     * 1. core's: the `x-transaction-id` header (the real chain hash -- use for Chainmeter), else a
+     *    top-level `transactionId` of the body (legacy)
+     * 2. Body.Data[].transactionId / txnId / etc.
+     * 3. Operation success stub only if Status:1 with no hash (should be rare)
      *
-     * blockNumber from header `x-block-number` when present.
+     * blockNumber from the gateway's `x-block-number` header when present.
      *
      * @private
      */
     private extractTransferResult;
-    /** Read a header case-insensitively (headers are already lowercased by HttpClient). */
-    private readHeaderValue;
-    private readBlockNumberHeader;
+    /**
+     * The launchpad result of a burn, from the gateway's answer (and core's receipt, when core
+     * accepted it). Called with no receipt when core refused the answer: it then throws the error
+     * this service has always thrown for that answer.
+     */
+    private burnResultOf;
     /**
      * Extract burn result from GalaChain response
      */

package/dist/services/GalaChainTransferService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GalaChainTransferService.d.ts","sourceRoot":"","sources":["../../src/services/GalaChainTransferService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAKrC,OAAO,KAAK,EACV,cAAc,EACd,gBAAgB,EACuB,MAAM,mBAAmB,CAAC;AAMnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAKrD,OAAO,KAAK,EAGV,wBAAwB,EACxB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAW/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAOhD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AA4BnE;;;;GAIG;AACH,qBAAa,wBAAyB,SAAQ,WAAW;IAarD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAbhC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA+B;IAE5D;;;;;;;OAOG;gBAED,IAAI,EAAE,UAAU,EACC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,aAAa,EAAE,oBAAoB,EACpD,KAAK,GAAE,OAAe;IAUxB;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IA+D7E;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,aAAa,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAiG/E;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IA8BrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACG,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAoGjE;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAuBhC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAkDjC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA6C9B;;;OAGG;YACW,oBAAoB;IA+BlC;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,qBAAqB;IAoG7B,uFAAuF;IACvF,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,qBAAqB;IAO7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAuCzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAqE3B;;OAEG;IACH,OAAO,CAAC,eAAe;CAgCxB"}
+{"version":3,"file":"GalaChainTransferService.d.ts","sourceRoot":"","sources":["../../src/services/GalaChainTransferService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,EAAkE,KAAK,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAExI,OAAO,KAAK,EACV,cAAc,EACd,gBAAgB,EAGjB,MAAM,mBAAmB,CAAC;AAI3B,OAAO,KAAK,EACV,wBAAwB,EACxB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAsB/B,OAAO,EAEL,mBAAmB,EAIpB,MAAM,kBAAkB,CAAC;AA2B1B;;;;GAIG;AACH,qBAAa,wBAAyB,SAAQ,mBAAmB;IAO/D;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAgC7E;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,aAAa,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAqC/E;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC;IA8B9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACG,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAuCjE;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAuBhC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAkDjC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA6C9B;;;OAGG;YACW,eAAe;IAmB7B;;;OAGG;YACW,oBAAoB;IAyBlC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,qBAAqB;IA8E7B;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAqBpB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAwCzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA2E3B;;OAEG;IACH,OAAO,CAAC,eAAe;CAyCxB"}

package/dist/services/LaunchpadPriceService.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Launchpad token USD spot price.
+ *
+ * The one price launchpad-sdk computes itself: a launchpad token's USD price, from the launchpad
+ * backend's bonding curve (tokens per 1 GALA) and GALA's USD price, or, once the token graduated,
+ * its USD price on the swap backend. The swap backend (dex-backend) `GET /market/price` read here is
+ * launchpad-backend-adjacent and deliberately thin: GALA's price and a graduated launchpad token's
+ * price, nothing else. Every other DEX price (any token by class key, GALA on its own, price series)
+ * is gswap-sdk's `gSwap.market` (`getPrice`, `getPrices`, `getPriceSeries`).
+ */
+import type { GalaChainTokenDetails } from '@gala-chain/gala-core-sdk';
+import type { AmountCalculationResult, TokenSpotPrice } from '../types/launchpad.dto';
+import type { CalculateBuyAmountOptions } from '../types/options.dto';
+import type { HttpClient } from '../utils/http';
+import { LoggerBase } from './BaseService';
+import type { TokenMetadataCache } from './TokenMetadataCache';
+/**
+ * Computes launchpad token USD spot prices (bonding curve, or the swap backend once graduated).
+ *
+ * @category Services
+ */
+export declare class LaunchpadPriceService extends LoggerBase {
+    private readonly dexBackendHttp?;
+    private readonly cache?;
+    private readonly fetchTokenDetails?;
+    /**
+     * @param dexBackendHttp The swap backend client (`GET /market/price`)
+     * @param cache Token symbols already known
+     * @param fetchTokenDetails Reads a token's GalaChain token class details (its symbol), at call time
+     * @param debugMode Debug logging
+     */
+    constructor(dexBackendHttp?: HttpClient | undefined, cache?: TokenMetadataCache | undefined, fetchTokenDetails?: ((tokenId: string) => Promise<GalaChainTokenDetails>) | undefined, debugMode?: boolean);
+    /**
+     * A launchpad token's USD spot price.
+     *
+     * - Graduated (`isGraduated` from `fetchPoolDetails`): the token's price on the swap backend.
+     * - Otherwise (or when graduation cannot be read): `GALA USD price / tokens bought with 1 GALA`
+     *   on the bonding curve.
+     *
+     * @param tokenName Launchpad token name (e.g. 'anime')
+     * @param calculateBuyAmount The bonding-curve buy calculation (tokens for 1 GALA)
+     * @param fetchPoolDetails Optional pool read used to detect graduation
+     * @returns The token's symbol and USD price
+     * @throws ValidationError if `tokenName` is empty
+     * @throws NetworkError if the calculation or a price read fails
+     *
+     * @example
+     * ```typescript
+     * const price = await service.fetchLaunchpadTokenSpotPrice('anime', calculateBuyAmount, fetchPoolDetails);
+     * console.log(`${price.symbol}: $${price.price}`);
+     * ```
+     */
+    fetchLaunchpadTokenSpotPrice(tokenName: string, calculateBuyAmount: (options: CalculateBuyAmountOptions) => Promise<AmountCalculationResult>, fetchPoolDetails?: (tokenName: string) => Promise<unknown>): Promise<TokenSpotPrice>;
+    /**
+     * The symbol of a token, from the token metadata cache or the GalaChain token class; never
+     * derived from the class key. GALA's is fixed.
+     */
+    private resolveAuthoritativeSymbol;
+    /**
+     * A token's USD price on the swap backend (`GET /market/price?assetIds=<$ key>`), with its
+     * authoritative symbol. The backend answers each asset under its symbol and under the id asked
+     * for (recorded on prod and stage); one asset is asked for, so a sole entry is its entry.
+     */
+    private fetchMarketUsdPrice;
+}
+//# sourceMappingURL=LaunchpadPriceService.d.ts.map

package/dist/services/LaunchpadPriceService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LaunchpadPriceService.d.ts","sourceRoot":"","sources":["../../src/services/LaunchpadPriceService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAA0B,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAG/F,OAAO,KAAK,EAAE,uBAAuB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACtF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAItE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAMhD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAK/D;;;;GAIG;AACH,qBAAa,qBAAsB,SAAQ,UAAU;IAQjD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;IACvB,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC;IATrC;;;;;OAKG;gBAEgB,cAAc,CAAC,EAAE,UAAU,YAAA,EAC3B,KAAK,CAAC,EAAE,kBAAkB,YAAA,EAC1B,iBAAiB,CAAC,GAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,aAAA,EACxF,SAAS,GAAE,OAAe;IAK5B;;;;;;;;;;;;;;;;;;;OAmBG;IACG,4BAA4B,CAChC,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,CAAC,OAAO,EAAE,yBAAyB,KAAK,OAAO,CAAC,uBAAuB,CAAC,EAC5F,gBAAgB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GACzD,OAAO,CAAC,cAAc,CAAC;IA2D1B;;;OAGG;YACW,0BAA0B;IA8BxC;;;;OAIG;YACW,mBAAmB;CA4ClC"}

package/dist/services/NftCollectionService.d.ts

@@ -7,6 +7,11 @@
  * - Minting NFTs
  * - Fetching NFT data and balances
  *
+ * The reads (collection authorizations, a collection's token classes, an owner's NFT balances) are
+ * `@gala-chain/gala-core-sdk`'s `GatewayReads`, sent through the SDK's gateway `HttpClient`. The
+ * writes (claim, create class, mint) do not reach GalaChain yet: they build their DTO and return a
+ * locally made transaction id with status `pending`.
+ *
  * @category Services
  * @since 5.12.0
  */
@@ -73,14 +78,19 @@ export declare class NftCollectionService extends BaseService {
      */
     claimCollection(params: ClaimCollectionParams): Promise<ClaimCollectionResult>;
     /**
-     * Fetch all NFT collections authorized to a user
+     * Fetch all NFT collections authorized to a user: every collection authorization on GalaChain
+     * (`FetchNftCollectionAuthorizationsWithPagination`, page by page, bounded) whose authorized users
+     * include `walletAddress`.
      *
-     * @param walletAddress - Wallet address to fetch collections for
+     * @param walletAddress - Wallet address to fetch collections for (`eth|<40 hex>`)
      * @returns List of authorized collections
+     * @throws Error for an address that is not `eth|<40 hex>`; the read's errors otherwise
      */
     fetchUserCollections(walletAddress: string): Promise<NftCollectionAuthorization[]>;
     /**
-     * Check if an NFT collection name is available
+     * Check if an NFT collection name is available: no collection authorization on GalaChain names
+     * it. A read that fails (or a set of authorizations larger than the read's page bound) throws:
+     * it is never reported as "available".
      *
      * @param collectionName - Collection name to check
      * @returns True if available, false if already claimed
@@ -95,7 +105,8 @@ export declare class NftCollectionService extends BaseService {
      */
     createTokenClass(params: CreateTokenClassParams): Promise<CreateTokenClassResult>;
     /**
-     * Fetch token classes for a collection
+     * Fetch the token classes of a collection (`FetchTokenClassesWithPagination`, page by page,
+     * bounded), optionally narrowed by type and category.
      *
      * @param params - Query parameters (collection, type, category)
      * @returns List of token classes with supply info
@@ -110,12 +121,17 @@ export declare class NftCollectionService extends BaseService {
      */
     mintNft(params: MintNftParams): Promise<MintNftResult>;
     /**
-     * Fetch NFT balances for an owner
+     * Fetch NFT balances for an owner: the owner's GalaChain balance records (`FetchBalances`) that
+     * hold at least one token instance, optionally of one collection.
      *
-     * @param ownerAddress - Owner wallet address
+     * @param ownerAddress - Owner wallet address (`eth|<40 hex>`)
      * @param collectionFilter - Optional collection name to filter by
      * @returns List of NFT balances
      */
     fetchNftBalances(ownerAddress: string, collectionFilter?: string): Promise<NftBalance[]>;
+    /** Core gateway reads over this service's gateway client (one per read: nothing is shared). */
+    private reads;
+    /** Every collection authorization on GalaChain (bounded: more pages than allowed throws). */
+    private allAuthorizations;
 }
 //# sourceMappingURL=NftCollectionService.d.ts.map

package/dist/services/NftCollectionService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NftCollectionService.d.ts","sourceRoot":"","sources":["../../src/services/NftCollectionService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,aAAa,EACb,aAAa,EACb,UAAU,EACV,0BAA0B,EAC1B,cAAc,EACd,uBAAuB,EACxB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAShD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,oBAAqB,SAAQ,WAAW;gBACvC,UAAU,EAAE,UAAU;IAQlC;;;OAGG;IACH,qBAAqB,IAAI,MAAM;IAI/B;;;OAGG;IACH,sBAAsB,IAAI,MAAM;IAIhC;;;;;;OAMG;IAEG,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC;IA8BrE;;;;;OAKG;IACH,wBAAwB,CAAC,MAAM,EAAE,qBAAqB,GAAG,cAAc;IA8BvE;;;;;;OAMG;IACG,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA0CpF;;;;;OAKG;IAEG,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,0BAA0B,EAAE,CAAC;IAoBxF;;;;;OAKG;IAEG,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAwBrE;;;;;;OAMG;IAEG,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IA+DvF;;;;;OAKG;IAEG,iBAAiB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAwB5F;;;;;;OAMG;IAEG,OAAO,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;IAsE5D;;;;;;OAMG;IAEG,gBAAgB,CACpB,YAAY,EAAE,MAAM,EACpB,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,UAAU,EAAE,CAAC;CAoBzB"}
+{"version":3,"file":"NftCollectionService.d.ts","sourceRoot":"","sources":["../../src/services/NftCollectionService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,aAAa,EACb,aAAa,EACb,UAAU,EACV,0BAA0B,EAC1B,cAAc,EACd,uBAAuB,EACxB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAShD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAM5C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,oBAAqB,SAAQ,WAAW;gBACvC,UAAU,EAAE,UAAU;IAQlC;;;OAGG;IACH,qBAAqB,IAAI,MAAM;IAI/B;;;OAGG;IACH,sBAAsB,IAAI,MAAM;IAIhC;;;;;;OAMG;IAEG,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC;IA8BrE;;;;;OAKG;IACH,wBAAwB,CAAC,MAAM,EAAE,qBAAqB,GAAG,cAAc;IA8BvE;;;;;;OAMG;IACG,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA0CpF;;;;;;;;OAQG;IACG,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,0BAA0B,EAAE,CAAC;IAsBxF;;;;;;;OAOG;IACG,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAwBrE;;;;;;OAMG;IAEG,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IA+DvF;;;;;;OAMG;IACG,iBAAiB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAwC5F;;;;;;OAMG;IAEG,OAAO,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;IAsE5D;;;;;;;OAOG;IACG,gBAAgB,CACpB,YAAY,EAAE,MAAM,EACpB,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,UAAU,EAAE,CAAC;IA4BxB,+FAA+F;IAC/F,OAAO,CAAC,KAAK;IAKb,6FAA6F;IAC7F,OAAO,CAAC,iBAAiB;CAG1B"}

package/dist/services/TokenResolverService.d.ts

@@ -42,7 +42,7 @@
  *
  * @packageDocumentation
  */
-import type { TokenClassKey } from '../types/common';
+import type { GalaChainTokenClassKey } from '@gala-chain/gala-core-sdk';
 import { LoggerBase } from './BaseService';
 import type { PoolService } from './PoolService';
 /**
@@ -55,7 +55,7 @@ export interface TokenResolutionEntry {
     /** GalaChain vault address (immutable after token creation) */
     vaultAddress: string;
     /** Parsed TokenClassKey from the vault address */
-    tokenClassKey: TokenClassKey;
+    tokenClassKey: GalaChainTokenClassKey;
     /** Unix timestamp (ms) when this entry was cached */
     cachedAt: number;
 }
@@ -218,7 +218,7 @@ export declare class TokenResolverService extends LoggerBase {
      * };
      * ```
      */
-    resolveTokenClassKey(tokenName: string): Promise<TokenClassKey>;
+    resolveTokenClassKey(tokenName: string): Promise<GalaChainTokenClassKey>;
     /**
      * Gets cached vault address for a token name
      *
@@ -275,7 +275,7 @@ export declare class TokenResolverService extends LoggerBase {
      * @param tokenName Token name to lookup (case-insensitive)
      * @returns Cached TokenClassKey or null if not in cache
      */
-    getCachedTokenClassKey(tokenName: string): TokenClassKey | null;
+    getCachedTokenClassKey(tokenName: string): GalaChainTokenClassKey | null;
     /**
      * Pre-warms the cache with known tokenName → vaultAddress mappings
      *
@@ -319,7 +319,7 @@ export declare class TokenResolverService extends LoggerBase {
     preWarmWithTokenClassKey(mappings: Array<{
         tokenName: string;
         vaultAddress: string;
-        tokenClassKey: TokenClassKey;
+        tokenClassKey: GalaChainTokenClassKey;
     }>): void;
     /**
      * Parses a vault address string to extract TokenClassKey components

package/dist/services/TokenResolverService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TokenResolverService.d.ts","sourceRoot":"","sources":["../../src/services/TokenResolverService.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"TokenResolverService.d.ts","sourceRoot":"","sources":["../../src/services/TokenResolverService.ts"],"names":[],"mappings":"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"}

package/dist/services/TradingQuotesService.d.ts

@@ -5,8 +5,8 @@
  * Uses local bonding curve math on the backend for instant quotes without GalaChain calls.
  *
  * **Key distinctions from existing services:**
- * - `fetchLaunchpadFee()` → backend proxy (cached 1h) vs `GalaChainService.fetchLaunchTokenFee()` → chain direct
- * - `fetchSaleDetails(tokenName)` → backend proxy (cached 10s, tokenName only) vs `GalaChainService.fetchPoolDetails()` → chain (vaultAddress required)
+ * - `fetchLaunchpadFee()` → backend proxy (cached 1h); backs `sdk.fetchLaunchTokenFee()`
+ * - `fetchSaleDetails(tokenName)` → backend proxy (cached 10s, tokenName only)
  * - `getTradeQuote(params)` → backend local math (instant) vs `calculateBuyAmountExternal()` → chain call
  * - `getPremintQuote(amount)` → backend local math (supply=0) — no existing equivalent
  *
@@ -58,8 +58,7 @@ export declare class TradingQuotesService extends BaseService {
     /**
      * Fetches the current launchpad fee via the backend proxy (cached 1 hour).
      *
-     * Distinct from `GalaChainService.fetchLaunchTokenFee()` which calls the chain
-     * directly. This version is faster due to backend caching.
+     * Backs `sdk.fetchLaunchTokenFee()`; cached by the backend.
      *
      * @returns Promise resolving to the fee amount in GALA (number)
      * @throws {ValidationError} If the backend returns an error response
@@ -77,7 +76,6 @@ export declare class TradingQuotesService extends BaseService {
     /**
      * Fetches sale details (supply, status) for a token via backend proxy (cached 10 seconds).
      *
-     * Distinct from `GalaChainService.fetchPoolDetails()` which requires a vaultAddress.
      * The backend resolves the vaultAddress internally using the tokenName.
      *
      * @param tokenName Token name to fetch sale details for (e.g. 'anime')

package/dist/services/TradingQuotesService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TradingQuotesService.d.ts","sourceRoot":"","sources":["../../src/services/TradingQuotesService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC3G,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAa5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,oBAAqB,SAAQ,WAAW;IACnD;;;;;OAKG;gBACS,IAAI,EAAE,UAAU,EAAE,SAAS,GAAE,OAAe;IAIxD;;;;;;;;;;;;;;;;;OAiBG;IACG,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IAO1C;;;;;;;;;;;;;;;;;;;OAmBG;IACG,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAUrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACG,aAAa,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAe/E;;;;;;;;;;;;;;;;;;;OAmBG;IACG,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC;CASxE"}
+{"version":3,"file":"TradingQuotesService.d.ts","sourceRoot":"","sources":["../../src/services/TradingQuotesService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC3G,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAa5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,oBAAqB,SAAQ,WAAW;IACnD;;;;;OAKG;gBACS,IAAI,EAAE,UAAU,EAAE,SAAS,GAAE,OAAe;IAIxD;;;;;;;;;;;;;;;;OAgBG;IACG,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IAO1C;;;;;;;;;;;;;;;;;;OAkBG;IACG,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAUrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACG,aAAa,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAgB/E;;;;;;;;;;;;;;;;;;;OAmBG;IACG,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC;CAUxE"}

package/dist/services/gateway-transport.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The launchpad side of the transport of `@gala-chain/gala-core-sdk`'s gateway reads and writes.
+ *
+ * Core is handed an `HttpRequestor` that sends its request through one of the SDK's own HTTP
+ * clients (the gateway `HttpClient` with its interceptors and `Sign` header, or the public gateway
+ * axios instance), so the requests launchpad makes are exactly the ones it made before the reads and
+ * writes moved to core: same client, same headers (core's own headers are not forwarded), same
+ * errors (a client rejection, an HTTP error or a network failure, reaches the caller unchanged:
+ * core passes an app requestor's rejection through). Paths are relative: the base URL is the
+ * client's. Core arms no timer (`requestTimeoutMs: Infinity`); the client owns request lifetimes.
+ */
+import type { HttpRequestor } from '@gala-chain/gala-core-sdk';
+/** What one of the SDK's HTTP clients answered: the body and, when the client reports them, status and headers. */
+export interface ClientAnswer {
+    readonly data: unknown;
+    readonly status?: number | undefined;
+    readonly headers?: Record<string, string | undefined> | undefined;
+}
+/** Sends a JSON POST through one of the SDK's HTTP clients. */
+export type ClientPost = (url: string, body: unknown) => Promise<ClientAnswer>;
+/** A core requestor over `post`, and the body of the last answer it read. */
+export interface CapturingRequestor {
+    readonly requestor: HttpRequestor;
+    /** The body the client returned for the request (`undefined` until it answered). */
+    readonly answer: () => unknown;
+}
+/**
+ * A core `HttpRequestor` over one of the SDK's HTTP clients, keeping the answer it read. Make one
+ * per operation, so the answer it keeps can never be another concurrent operation's.
+ */
+export declare function capturingRequestor(post: ClientPost): CapturingRequestor;
+//# sourceMappingURL=gateway-transport.d.ts.map

package/dist/services/gateway-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-transport.d.ts","sourceRoot":"","sources":["../../src/services/gateway-transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAgB,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE7E,mHAAmH;AACnH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC;CACnE;AAED,+DAA+D;AAC/D,MAAM,MAAM,UAAU,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;AAE/E,6EAA6E;AAC7E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,oFAAoF;IACpF,QAAQ,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC;CAChC;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,kBAAkB,CAmBvE"}