@gala-chain/launchpad-sdk 5.0.4-beta.6 → 5.0.4-beta.60

package/dist/utils/SwapEventExtractor.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Swap Event Extractor
+ *
+ * Parses WebSocket event payloads to extract swap transaction data.
+ * Handles recursive payload traversal and multiple swap event formats.
+ *
+ * Follows the same pattern as pool discovery (newPoolsWatch.js) but adapted
+ * for swap events instead of pool creation events.
+ *
+ * @packageDocumentation
+ */
+import type { SwapEventData } from '../types/swap-monitor.dto';
+import { Logger } from './Logger';
+/**
+ * Extracts swap event data from WebSocket payloads
+ *
+ * Recursively walks through event payloads to find swap transaction data
+ * in various possible locations (direct fields, nested objects, etc).
+ *
+ * @internal
+ */
+export declare class SwapEventExtractor {
+    private readonly logger;
+    constructor(logger?: Logger);
+    /**
+     * Recursively walk through a payload to find and extract swap events
+     *
+     * Follows the pattern from newPoolsWatch.js::walkPayload but adapted
+     * for swap events. Returns all newly discovered swaps not in seenTransactions.
+     *
+     * Includes depth limiting to prevent DoS attacks from deeply nested payloads.
+     * Maximum nesting depth is 50 levels.
+     *
+     * @param payload - Event payload to search
+     * @param seenTransactions - Set-like object of transaction IDs already processed
+     * @returns Array of extracted swap events
+     */
+    walkPayloadForSwaps(payload: unknown, seenTransactions: {
+        has(id: string): boolean;
+        add(id: string): unknown;
+    }): SwapEventData[];
+    /**
+     * Try to extract a swap event from an object
+     *
+     * Checks for various swap event structures from the backend:
+     * - functionName === 'Swap' or 'ExecuteSwap'
+     * - Direct swap fields (fromToken, toToken, amount0, amount1, etc)
+     * - Nested swap data in payload.swap or payload.swapData
+     * - Backend WebSocket format: { Data: {...swap fields}, transactionId: "..." }
+     *
+     * @param obj - Object to check
+     * @returns Extracted SwapEventData or null if not a swap event
+     */
+    private extractSwapFromObject;
+    /**
+     * Extract transaction ID from swap event object
+     *
+     * Tries multiple common field names for transaction IDs.
+     *
+     * @param obj - Object to search
+     * @returns Transaction ID or null
+     */
+    private extractTransactionId;
+    /**
+     * Extract token from object, trying multiple field names
+     *
+     * @param obj - Object to search
+     * @param fieldNames - Field names to try in order
+     * @returns Token string or null
+     */
+    private extractToken;
+    /**
+     * Extract amount from object, trying multiple field names
+     *
+     * @param obj - Object to search
+     * @param fieldNames - Field names to try in order
+     * @returns Amount string or null
+     */
+    private extractAmount;
+    /**
+     * Extract fee tier from object
+     *
+     * Tries multiple field names and normalizes the value to basis points.
+     *
+     * @param obj - Object to search
+     * @returns Fee tier in basis points (500, 3000, 10000) or null
+     */
+    private extractFeeTier;
+    /**
+     * Normalize fee value to basis points
+     *
+     * Accepts multiple formats:
+     * - Basis points: 500, 3000, 10000
+     * - Decimal: 0.05, 0.3, 1
+     * - Percentage: "0.05%", "0.3%", "1%"
+     *
+     * @param value - Fee value in any format
+     * @returns Normalized fee in basis points or null
+     */
+    private normalizeFee;
+    /**
+     * Extract timestamp from object
+     *
+     * @param obj - Object to search
+     * @returns Timestamp in milliseconds or current time
+     */
+    private extractTimestamp;
+    /**
+     * Extract user/wallet address from object
+     *
+     * @param obj - Object to search
+     * @returns User address or undefined
+     */
+    private extractUser;
+    /**
+     * Determine swap direction (zeroForOne or oneForZero)
+     *
+     * @param obj - Object to check
+     * @param token0 - First token
+     * @param token1 - Second token
+     * @returns Swap direction
+     */
+    private determineDirection;
+    /**
+     * Determine if swap is exact input or exact output
+     *
+     * Exact input: input amount is fixed, output amount is variable
+     * Exact output: output amount is fixed, input amount is variable
+     *
+     * For zeroForOne direction: exact input if amountIn is specified in event
+     * For oneForZero direction: exact input if amountIn is specified in event
+     *
+     * Defaults to exact input if unable to determine from event structure.
+     *
+     * @param obj - Swap event object
+     * @param direction - Swap direction ('zeroForOne' or 'oneForZero')
+     * @returns true for exact input, false for exact output
+     */
+    private determineExactInput;
+    /**
+     * Build pool key from tokens and fee
+     *
+     * Pool key format: token0|token1|feeTier
+     *
+     * @param token0 - First token
+     * @param token1 - Second token
+     * @param feeTier - Fee tier in basis points
+     * @returns Pool key string
+     */
+    private buildPoolKey;
+}
+//# sourceMappingURL=SwapEventExtractor.d.ts.map

package/dist/utils/SwapEventExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwapEventExtractor.d.ts","sourceRoot":"","sources":["../../src/utils/SwapEventExtractor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAKlC;;;;;;;GAOG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,MAAM,CAAC,EAAE,MAAM;IAI3B;;;;;;;;;;;;OAYG;IACH,mBAAmB,CACjB,OAAO,EAAE,OAAO,EAChB,gBAAgB,EAAE;QAAE,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;QAAC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GACvE,aAAa,EAAE;IA2ClB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,qBAAqB;IAgE7B;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAoB5B;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IAUpB;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAerB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAqBtB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,YAAY;IAmCpB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAanB;;;;;;;OAOG;IACH,OAAO,CAAC,kBAAkB;IAwC1B;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,mBAAmB;IAqC3B;;;;;;;;;OASG;IACH,OAAO,CAAC,YAAY;CAGrB"}

package/dist/utils/adapters.d.ts

@@ -0,0 +1,111 @@
+import type { PaginationParams } from '../types/common';
+/**
+ * Type adapters to handle backend quirks and inconsistencies
+ *
+ * The backend has some type inconsistencies (strings vs numbers) that we need
+ * to handle transparently while providing clean interfaces to SDK users.
+ */
+/**
+ * Converts clean pagination parameters to backend's expected string format
+ *
+ * Backend expects page and pageSize as strings, but SDK users should use numbers
+ *
+ * @param pagination Clean pagination parameters
+ * @returns Backend-compatible query parameters
+ */
+export declare function adaptPagination(pagination: PaginationParams): Record<string, string>;
+/**
+ * Converts clean query parameters to backend's expected format
+ *
+ * Handles various type conversions the backend expects:
+ * - Numbers to strings
+ * - Booleans to strings
+ * - Arrays to comma-separated strings
+ * - Removes undefined/null values
+ *
+ * @param params Clean query parameters
+ * @returns Backend-compatible query parameters
+ */
+export declare function adaptQueryParams(params: unknown): Record<string, string>;
+/**
+ * Adapts request data for backend consumption
+ *
+ * Handles common transformations:
+ * - Converts camelCase to snake_case for all fields
+ * - Ensures address formats are correct
+ * - Handles date/timestamp conversions
+ * - Recursively processes nested objects and arrays
+ *
+ * @param data Request data
+ * @param visited Set to track circular references
+ * @returns Backend-compatible request data
+ */
+export declare function adaptRequestData(data: unknown, visited?: WeakSet<object>): unknown;
+/**
+ * Adapts backend response data to clean SDK format
+ *
+ * Handles common transformations:
+ * - Converts snake_case to camelCase for all fields
+ * - Parses string numbers back to numbers where appropriate
+ * - Standardizes date formats
+ * - Recursively processes nested objects and arrays
+ *
+ * @param data Backend response data
+ * @param visited Set to track circular references
+ * @returns Clean SDK-compatible data
+ */
+export declare function adaptResponseData<T = any>(data: unknown, visited?: WeakSet<object>): T;
+/**
+ * Known backend type quirks and their handling
+ *
+ * This documents the specific inconsistencies we've discovered:
+ */
+export declare const BACKEND_TYPE_QUIRKS: {
+    /**
+     * Pagination parameters must be sent as strings
+     * Clean interface: { page: number, limit: number }
+     * Backend expects: { page: string, limit: string }
+     */
+    readonly PAGINATION_AS_STRINGS: true;
+    /**
+     * Some numeric fields are returned as strings
+     * We convert them back to numbers for clean interfaces
+     */
+    readonly NUMERIC_FIELDS_AS_STRINGS: "numeric-strings";
+    /**
+     * Date fields use inconsistent naming
+     * created_at vs createdAt, updated_at vs updatedAt
+     */
+    readonly INCONSISTENT_DATE_NAMING: "date-naming";
+    /**
+     * Array filters may need to be comma-separated strings
+     * Clean interface: string[]
+     * Backend expects: string (comma-separated)
+     */
+    readonly ARRAYS_AS_CSV: "arrays-csv";
+    /**
+     * Backend expects snake_case field names
+     * SDK uses camelCase for clean interfaces
+     */
+    readonly SNAKE_CASE_FIELDS: true;
+    /**
+     * Type parameter handling varies by endpoint
+     */
+    readonly TYPE_PARAMETER_HANDLING: {
+        readonly TOKEN_LIST_ENDPOINT: {
+            readonly includesType: true;
+        };
+        readonly TOKEN_HELD_ENDPOINT: {
+            readonly includesType: false;
+        };
+    };
+};
+/**
+ * Validates that an adapted value matches expected format
+ *
+ * @param adapted The adapted value
+ * @param formatType The expected format ('request' for snake_case, 'response' for camelCase)
+ * @throws Error if format is mixed or incorrect
+ */
+export declare function validateAdaptedFormat(adapted: unknown, formatType: 'request' | 'response'): void;
+//# sourceMappingURL=adapters.d.ts.map

package/dist/utils/adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../../src/utils/adapters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGxD;;;;;GAKG;AAEH;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,gBAAgB,GAC3B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAQxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,OAAO,GACd,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgCxB;AAWD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,OAAO,EACb,OAAO,kBAAgB,GACtB,OAAO,CAoDT;AAWD;;;;;;;;;;;;GAYG;AAEH,wBAAgB,iBAAiB,CAAC,CAAC,GAAG,GAAG,EACvC,IAAI,EAAE,OAAO,EACb,OAAO,kBAAgB,GACtB,CAAC,CAqEH;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;OAEG;;;;;;;;;CASK,CAAC;AAEX;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,SAAS,GAAG,UAAU,GACjC,IAAI,CAoCN"}

package/dist/utils/address-formatter.d.ts

@@ -0,0 +1,318 @@
+/**
+ * AddressFormatter - Consolidated address format conversion utilities
+ *
+ * Consolidates address formatting logic scattered across multiple files:
+ * - validation.ts: `toBackendAddressFormat()`, `fromBackendAddressFormat()`, `normalizeAddressInput()`
+ * - validation-helpers.ts: `formatAddressForBackend()`, `isValidAddress()`, `assertValidWalletAddress()`
+ * - Multiple services: Duplicate address parsing and normalization
+ *
+ * ## Problem Solved
+ *
+ * Address formatting was duplicated with inconsistent patterns:
+ * - Ethereum format: "0x1234..."
+ * - Backend format: "eth|1234..."
+ * - Client format: "client|abc123"
+ * - Different validation patterns in different files
+ * - Inconsistent error messages
+ *
+ * This utility provides a cohesive, well-documented interface for all address operations.
+ *
+ * @category Utilities
+ * @since 6.5.0
+ */
+import { stripHexPrefix as bridgeStripHexPrefix } from '../bridge/utils/address-formatter';
+import type { AddressFormat } from '../types/common';
+/**
+ * Address format types
+ */
+export type AddressFormatType = 'ethereum' | 'backend' | 'client';
+/**
+ * AddressFormatter - Unified address format operations
+ *
+ * Provides consistent, well-documented address formatting and validation
+ * across all services that work with wallet addresses.
+ *
+ * ## Supported Formats
+ *
+ * - **Ethereum**: `0x1234567890abcdef...` (40 hex chars with 0x prefix)
+ * - **Backend**: `eth|1234567890abcdef...` (40 hex chars without 0x)
+ * - **Client**: `client|identifier` (arbitrary client identifiers)
+ *
+ * ## Usage Examples
+ *
+ * ### Format conversion
+ * ```typescript
+ * const formatter = new AddressFormatter();
+ *
+ * // Ethereum to backend
+ * formatter.toBackendFormat('0x1234...abc');
+ * // Returns: 'eth|1234...abc'
+ *
+ * // Backend to Ethereum
+ * formatter.toEthereumFormat('eth|1234...abc');
+ * // Returns: '0x1234...abc'
+ *
+ * // Auto-detect and convert
+ * const format = formatter.normalizeInput('0x1234...abc');
+ * // Returns: 'eth|1234...abc' (backend format)
+ * ```
+ *
+ * ### Validation
+ * ```typescript
+ * const formatter = new AddressFormatter();
+ *
+ * // Check validity (no throw)
+ * if (formatter.isValid('0x1234...abc')) {
+ *   // Process address
+ * }
+ *
+ * // Validate with throw
+ * formatter.assertValid(address, 'userAddress');
+ * // Safe to use
+ * ```
+ *
+ * @since 6.5.0
+ */
+export declare class AddressFormatter {
+    /**
+     * Convert Ethereum address to backend format
+     *
+     * Accepts Ethereum format (with or without 0x prefix) and returns backend format.
+     * Always returns EIP-55 checksummed addresses (required by GalaChain validators).
+     *
+     * @param address Ethereum address (0x... or plain 40 hex)
+     * @returns Backend format address (eth|...) with EIP-55 checksummed address
+     * @throws ValidationError if address format is invalid
+     *
+     * @example
+     * ```typescript
+     * const formatter = new AddressFormatter();
+     *
+     * formatter.toBackendFormat('0x1234567890abcdef1234567890abcdef12345678');
+     * // Returns: 'eth|1234567890aBcdEf1234567890abCdef12345678' (checksummed)
+     *
+     * formatter.toBackendFormat('1234567890abcdef1234567890abcdef12345678');
+     * // Returns: 'eth|1234567890aBcdEf1234567890abCdef12345678' (checksummed)
+     * ```
+     */
+    toBackendFormat(address: string): string;
+    /**
+     * Convert backend address format to Ethereum format
+     *
+     * Converts backend format (eth|...) to standard Ethereum format (0x...).
+     * Preserves the original case of the address portion (including EIP-55 checksummed addresses).
+     *
+     * @param address Backend format address (eth|...)
+     * @returns Ethereum format address (0x...)
+     * @throws ValidationError if address format is invalid
+     *
+     * @example
+     * ```typescript
+     * const formatter = new AddressFormatter();
+     *
+     * formatter.toEthereumFormat('eth|1234567890abcdef...abcdef');
+     * // Returns: '0x1234567890abcdef...abcdef'
+     *
+     * formatter.toEthereumFormat('eth|5aAeb6053f3E94C9b9A09f33669435E7Ef1BeAed');
+     * // Returns: '0x5aAeb6053f3E94C9b9A09f33669435E7Ef1BeAed' (preserves checksum case)
+     * ```
+     */
+    toEthereumFormat(address: string): string;
+    /**
+     * Smart address parser - accepts both Ethereum and backend formats
+     *
+     * Automatically detects format and converts to backend format required by SDK.
+     * Handles both "0x..." and "eth|..." formats seamlessly.
+     *
+     * @param address Address in either Ethereum or backend format
+     * @returns Backend format address (eth|...)
+     * @throws ValidationError if address format is invalid
+     *
+     * @example
+     * ```typescript
+     * const formatter = new AddressFormatter();
+     *
+     * // Ethereum format input
+     * formatter.normalizeInput('0x1234...abc');
+     * // Returns: 'eth|1234...abc'
+     *
+     * // Backend format input
+     * formatter.normalizeInput('eth|1234...abc');
+     * // Returns: 'eth|1234...abc' (unchanged)
+     *
+     * // Plain hex (with or without 0x)
+     * formatter.normalizeInput('1234...abc');
+     * // Returns: 'eth|1234...abc'
+     * ```
+     */
+    normalizeInput(address: string | undefined): AddressFormat | undefined;
+    /**
+     * Check if an address is valid (without throwing)
+     *
+     * Returns true if address is in valid Ethereum or backend format.
+     *
+     * @param address Address to check
+     * @returns true if valid, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const formatter = new AddressFormatter();
+     *
+     * if (formatter.isValid('0x1234...abc')) {
+     *   // Process address
+     * }
+     * ```
+     */
+    isValid(address: string | undefined | null): address is string;
+    /**
+     * Validate address format, throwing on invalid
+     *
+     * @param address Address to validate
+     * @param fieldName Field name for error messages (default: 'address')
+     * @throws ValidationError if address is invalid
+     *
+     * @example
+     * ```typescript
+     * const formatter = new AddressFormatter();
+     *
+     * formatter.assertValid(userAddress, 'userAddress');
+     * // Safe to use userAddress
+     * ```
+     */
+    assertValid(address: string | undefined, fieldName?: string): void;
+    /**
+     * Detect the format of an address string
+     *
+     * @param address Address string to check
+     * @returns Format type ('ethereum', 'backend', 'client') or null if invalid
+     *
+     * @example
+     * ```typescript
+     * const formatter = new AddressFormatter();
+     *
+     * formatter.detectFormat('0x1234...abc');     // 'ethereum'
+     * formatter.detectFormat('eth|1234...abc');   // 'backend'
+     * formatter.detectFormat('client|xyz');       // 'client'
+     * formatter.detectFormat('invalid');          // null
+     * ```
+     */
+    detectFormat(address: string | undefined): AddressFormatType | null;
+    /**
+     * Normalize address casing (lowercase for consistency)
+     *
+     * Ethereum addresses can be checksummed, but we normalize to lowercase
+     * for consistency in comparisons and storage.
+     *
+     * @param address Address to normalize
+     * @returns Lowercase address
+     *
+     * @example
+     * ```typescript
+     * const formatter = new AddressFormatter();
+     *
+     * formatter.normalize('0xABCD...DCBA');
+     * // Returns: '0xabcd...dcba'
+     *
+     * formatter.normalize('ETH|ABCD...DCBA');
+     * // Returns: 'eth|abcd...dcba'
+     * ```
+     */
+    normalize(address: string | undefined): string | undefined;
+    /**
+     * Extract hex address from either format
+     *
+     * Returns just the 40-character hex portion without any prefix.
+     *
+     * @param address Ethereum or backend format address
+     * @returns 40-character hex string (lowercase)
+     * @throws ValidationError if address format is invalid
+     *
+     * @example
+     * ```typescript
+     * const formatter = new AddressFormatter();
+     *
+     * formatter.extractHex('0x1234...abc');
+     * // Returns: '1234...abc'
+     *
+     * formatter.extractHex('eth|1234...abc');
+     * // Returns: '1234...abc'
+     * ```
+     */
+    extractHex(address: string): string;
+}
+export declare const stripHexPrefix: typeof bridgeStripHexPrefix;
+/**
+ * Convert Ethereum address to backend format (function style)
+ *
+ * @param address Ethereum address
+ * @returns Backend format
+ * @throws ValidationError if invalid
+ */
+export declare function toBackendAddressFormat(address: string): string;
+/**
+ * Convert backend address to Ethereum format (function style)
+ *
+ * @param address Backend format address
+ * @returns Ethereum format
+ * @throws ValidationError if invalid
+ */
+export declare function fromBackendAddressFormat(address: string): string;
+/**
+ * Smart address parser (function style)
+ *
+ * @param address Address to normalize
+ * @returns Backend format or undefined
+ */
+export declare function normalizeAddressInput(address: string | undefined): AddressFormat | undefined;
+/**
+ * Check if address is valid (function style)
+ *
+ * @param address Address to check
+ * @returns true if valid
+ */
+export declare function isValidAddress(address: string | undefined): address is string;
+/**
+ * Validate address and throw (function style)
+ *
+ * @param address Address to validate
+ * @param fieldName Field name for errors
+ * @throws ValidationError if invalid
+ */
+export declare function assertValidWalletAddress(address: string | undefined, fieldName?: string): void;
+/**
+ * Convert Ethereum address object (from ethers Wallet) to backend format
+ *
+ * Provides a convenient one-step conversion from ethers Wallet addresses to backend format.
+ * Handles both Wallet objects and plain addresses.
+ *
+ * @param ethAddress Ethereum address with or without 0x prefix, or ethers Wallet object
+ * @returns Backend format address (eth|...)
+ * @throws ValidationError if address format is invalid
+ *
+ * @example
+ * ```typescript
+ * import { Wallet } from 'ethers';
+ * import { toBackendAddressFromEthers } from '@/utils/address-formatter';
+ *
+ * const wallet = new Wallet(privateKey);
+ * const backendAddr = toBackendAddressFromEthers(wallet.address);
+ * // Returns: 'eth|1234567890abcdef...abcdef'
+ *
+ * // Also works with plain addresses
+ * const result = toBackendAddressFromEthers('0x1234...abc');
+ * // Returns: 'eth|1234...abc'
+ * ```
+ *
+ * @since 6.6.0
+ */
+export declare function toBackendAddressFromEthers(ethAddress: string | {
+    address: string;
+}): string;
+/**
+ * Detect the format of an address string (function style)
+ *
+ * @param address Address to check
+ * @returns Format type ('ethereum', 'backend', 'client') or null if invalid
+ */
+export declare function detectFormat(address: string | undefined): AddressFormatType | null;
+//# sourceMappingURL=address-formatter.d.ts.map

package/dist/utils/address-formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address-formatter.d.ts","sourceRoot":"","sources":["../../src/utils/address-formatter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,EAAE,cAAc,IAAI,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAC3F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIrD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;AAwBlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,qBAAa,gBAAgB;IAC3B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IA8CxC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAgCzC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS;IAkCtE;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,IAAI,MAAM;IA4B9D;;;;;;;;;;;;;;OAcG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,GAAE,MAAkB,GAAG,IAAI;IAU7E;;;;;;;;;;;;;;;OAeG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,iBAAiB,GAAG,IAAI;IAwBnE;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS;IAQ1D;;;;;;;;;;;;;;;;;;;OAmBG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;CAoBpC;AAQD,eAAO,MAAM,cAAc,6BAAuB,CAAC;AAEnD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,CAE5F;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,IAAI,MAAM,CAE7E;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,GAAE,MAAkB,GAAG,IAAI,CAEzG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAG3F;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,iBAAiB,GAAG,IAAI,CAElF"}