@gala-chain/launchpad-sdk 8.1.0 → 9.0.0-rc.1

package/dist/services/WrapService.d.ts

@@ -1,171 +0,0 @@
-/**
- * WrapService - Cross-channel token wrapping/unwrapping
- *
- * Handles internal GalaChain channel bridges:
- * - Wrap: MUSIC (music channel) → GMUSIC (asset channel)
- * - Unwrap: GMUSIC (asset channel) → MUSIC (music channel)
- *
- * This is different from external bridges (Ethereum/Solana) - wrap/unwrap
- * operates entirely within GalaChain across different channels.
- *
- * @category Services
- * @since 4.0.18
- */
-import type { Wallet } from 'ethers';
-import type { GalaConnectClient } from '../bridge/GalaConnectClient.js';
-import type { GalaChainSigner } from '../signing/signers.js';
-import type { TokenId } from '../types/common.js';
-import type { UnwrapTokenOptions, WrapTokenOptions, WrapUnwrapFeeEstimate, WrapUnwrapResult, WrapUnwrapStatusResult } from '../types/wrappable-token.dto.js';
-import type { Logger } from '../utils/Logger.js';
-import { LoggerBase } from './BaseService.js';
-import type { WrappableTokenService } from './WrappableTokenService.js';
-/**
- * Configuration for WrapService
- */
-export interface WrapServiceConfig {
-    /** GalaConnect client for DEX API platform (same as bridge operations) */
-    galaConnectClient: GalaConnectClient;
-    /** WrappableTokenService for token metadata */
-    wrappableTokenService: WrappableTokenService;
-    /** Optional native GalaChain signer. */
-    signer?: GalaChainSigner;
-    /** Wallet used to create a native signer when signer is omitted. */
-    wallet?: Wallet;
-    /** Wallet address (for sender) */
-    walletAddress?: string;
-    /** Logger instance */
-    logger?: Logger;
-}
-/**
- * WrapService - Cross-channel token wrapping/unwrapping
- *
- * Provides methods to wrap tokens from their native channel to the asset channel
- * (e.g., MUSIC → GMUSIC) and unwrap them back (GMUSIC → MUSIC).
- *
- * @example
- * ```typescript
- * // Wrap MUSIC to GMUSIC for DEX trading
- * const wrapResult = await wrapService.wrapToken({
- *   tokenId: 'MUSIC',
- *   amount: '100',
- * });
- *
- * // Unwrap GMUSIC back to MUSIC
- * const unwrapResult = await wrapService.unwrapToken({
- *   tokenId: 'GMUSIC',
- *   amount: '50',
- * });
- * ```
- */
-export declare class WrapService extends LoggerBase {
-    private readonly galaConnectClient;
-    private readonly wrappableTokenService;
-    private readonly nativeSigner;
-    private readonly walletAddress;
-    constructor(config: WrapServiceConfig);
-    /**
-     * Wrap a token to its asset-channel counterpart
-     *
-     * Transfers a token from its native channel to the asset channel.
-     * Example: MUSIC (music channel) → GMUSIC (asset channel)
-     *
-     * @param options - Wrap options including tokenId and amount
-     * @returns Promise<WrapUnwrapResult> - Transaction result
-     *
-     * @example
-     * ```typescript
-     * const result = await wrapService.wrapToken({
-     *   tokenId: 'MUSIC',
-     *   amount: '100',
-     * });
-     * console.log(`Wrapped ${result.amount} ${result.fromToken} → ${result.toToken}`);
-     * ```
-     *
-     * @throws {ValidationError} If token is not wrappable or already on asset channel
-     */
-    wrapToken(options: WrapTokenOptions): Promise<WrapUnwrapResult>;
-    /**
-     * Unwrap a token back to its native channel
-     *
-     * Transfers a token from the asset channel back to its native channel.
-     * Example: GMUSIC (asset channel) → MUSIC (music channel)
-     *
-     * @param options - Unwrap options including tokenId and amount
-     * @returns Promise<WrapUnwrapResult> - Transaction result
-     *
-     * @example
-     * ```typescript
-     * const result = await wrapService.unwrapToken({
-     *   tokenId: 'GMUSIC',
-     *   amount: '50',
-     * });
-     * console.log(`Unwrapped ${result.amount} ${result.fromToken} → ${result.toToken}`);
-     * ```
-     *
-     * @throws {ValidationError} If token is not unwrappable or not on asset channel
-     */
-    unwrapToken(options: UnwrapTokenOptions): Promise<WrapUnwrapResult>;
-    /**
-     * Estimate fees for a wrap operation
-     *
-     * @param tokenId - Token to wrap
-     * @param amount - Amount to wrap
-     * @returns Promise<WrapUnwrapFeeEstimate> - Fee estimate
-     * @throws ValidationError if tokenId or amount is required but not provided
-     */
-    estimateWrapFee(tokenId: TokenId, _amount: string): Promise<WrapUnwrapFeeEstimate>;
-    /**
-     * Estimate fees for an unwrap operation
-     *
-     * @param tokenId - Token to unwrap
-     * @param amount - Amount to unwrap
-     * @returns Promise<WrapUnwrapFeeEstimate> - Fee estimate
-     * @throws ValidationError if tokenId or amount is required but not provided
-     */
-    estimateUnwrapFee(tokenId: TokenId, _amount: string): Promise<WrapUnwrapFeeEstimate>;
-    /**
-     * Get status of a wrap/unwrap transaction
-     *
-     * Cross-channel wrapping completes immediately (synchronous on-chain).
-     * This method returns the completed status for the given transaction ID.
-     *
-     * @param transactionId - Transaction ID to check
-     * @returns WrapUnwrapStatusResult - Current status (always completed for wrap/unwrap)
-     * @throws ValidationError if transactionId is required but not provided
-     */
-    getWrapStatus(transactionId: string): WrapUnwrapStatusResult;
-    private executeWrapOrUnwrap;
-    private estimateChannelFee;
-    /**
-     * Execute a cross-channel bridge (wrap or unwrap)
-     *
-     * Uses the shared native GalaChain signer for the bridge request.
-     *
-     * @see docs/api-calls/swapBridgeOut.txt for working payload example
-     */
-    private executeChannelBridge;
-    /**
-     * Execute wrap bridge request with comprehensive error handling
-     *
-     * Uses direct try-catch (not withErrorHandling wrapper) because this method
-     * returns structured error responses (WrapUnwrapResult with success: false)
-     * rather than throwing. This is appropriate for a private helper method that
-     * normalizes errors into the return type.
-     */
-    private executeWrapBridgeRequest;
-    /**
-     * Determine channel routing for wrap/unwrap operation
-     *
-     * The destinationChannelId determines where tokens go:
-     * - Wrap: native channel → asset channel (destinationChannelId = ASSET = 1)
-     * - Unwrap: asset channel → native channel (destinationChannelId = MUSIC = 3)
-     */
-    private determineChannelRouting;
-    private getCounterpartOrThrow;
-    private getWrappableTokenOrThrow;
-    /**
-     * Format tokenId for error messages using centralized stringification
-     */
-    private formatTokenId;
-}
-//# sourceMappingURL=WrapService.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"WrapService.d.ts","sourceRoot":"","sources":["../../src/services/WrapService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGrC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EACV,kBAAkB,EAElB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,iCAAiC,CAAC;AAKzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAcxE;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,0EAA0E;IAC1E,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,+CAA+C;IAC/C,qBAAqB,EAAE,qBAAqB,CAAC;IAC7C,wCAAwC;IACxC,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sBAAsB;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AA4CD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,WAAY,SAAQ,UAAU;IACzC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAoB;IACtD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAwB;IAC9D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA8B;IAC3D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;gBAEvC,MAAM,EAAE,iBAAiB;IAarC;;;;;;;;;;;;;;;;;;;OAmBG;IACG,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAIrE;;;;;;;;;;;;;;;;;;;OAmBG;IACG,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAIzE;;;;;;;OAOG;IACG,eAAe,CACnB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,CAAC;IAIjC;;;;;;;OAOG;IACG,iBAAiB,CACrB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,CAAC;IAIjC;;;;;;;;;OASG;IACH,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,sBAAsB;YAsB9C,mBAAmB;YA+BnB,kBAAkB;IAoChC;;;;;;OAMG;YACW,oBAAoB;IA0ElC;;;;;;;OAOG;YACW,wBAAwB;IAqItC;;;;;;OAMG;IACH,OAAO,CAAC,uBAAuB;YAwBjB,qBAAqB;YAYrB,wBAAwB;IAYtC;;OAEG;IACH,OAAO,CAAC,aAAa;CAMtB"}

package/dist/services/WrappableTokenCache.d.ts

@@ -1,100 +0,0 @@
-/**
- * Wrappable Token Cache Service
- *
- * Permanent in-memory cache for wrappable tokens fetched from DEX API.
- * Wrappable tokens are GalaChain-internal token pairs that can be
- * wrapped/unwrapped into each other (e.g., MUSIC <-> GMUSIC).
- *
- * ## Cache Architecture
- * - **Primary Index**: Map<tokenId, token> - O(1) by stringifiedTokenClassKey
- * - **Persistence**: Entire SDK lifetime (never expires)
- * - **Memory**: ~500-800 bytes per token (plus ~50 bytes per index entry)
- *
- * ## Caching Strategy
- * - Metadata always cached by fetchWrappableTokens/fetchAllWrappableTokens
- * - Balance methods preheat cache while returning user-specific data
- * - No network separation (wrapping is GalaChain-internal)
- *
- * @category Services
- * @since 4.0.18
- */
-import type { WrappableToken, WrappableTokenCacheStats } from '../types/wrappable-token.dto.js';
-import { BatchedCacheService } from './BatchedCacheService.js';
-/**
- * Wrappable Token Cache
- *
- * High-performance permanent cache for wrappable token data.
- * Tokens are indexed by their stringifiedTokenClassKey for O(1) lookups.
- *
- * @example Basic usage
- * ```typescript
- * const cache = new WrappableTokenCache();
- *
- * // Cache all tokens
- * cache.setAll(wrappableTokens);
- *
- * // Check if cached
- * if (cache.has()) {
- *   const tokens = cache.getAll();
- * }
- *
- * // Get specific token by tokenId
- * const music = cache.getByTokenId('$MUSIC|Unit|none|none');
- * ```
- */
-export declare class WrappableTokenCache extends BatchedCacheService<WrappableToken, WrappableTokenCacheStats> {
-    constructor(debugMode?: boolean);
-    /**
-     * Extract the cache key from a wrappable token
-     *
-     * @param token - Wrappable token
-     * @returns The stringifiedTokenClassKey as the key
-     */
-    protected extractKey(token: WrappableToken): string;
-    /**
-     * Check if cache is populated
-     *
-     * @returns True if cache has tokens
-     */
-    has(): boolean;
-    /**
-     * Get all cached tokens
-     *
-     * @returns Array of wrappable tokens (empty if not cached)
-     */
-    getAll(): WrappableToken[];
-    /**
-     * Get a specific token by stringifiedTokenClassKey (tokenId)
-     *
-     * @param tokenId - Stringified TokenClassKey (e.g., "$MUSIC|Unit|none|none")
-     * @returns Wrappable token or undefined if not found
-     */
-    getByTokenId(tokenId: string): WrappableToken | undefined;
-    /**
-     * Get cache statistics
-     *
-     * @returns Cache statistics including token count and timestamp
-     */
-    getStats(): WrappableTokenCacheStats;
-    /**
-     * Get number of cached tokens
-     *
-     * @returns Number of cached tokens
-     */
-    size(): number;
-    /**
-     * Check if a token is wrappable (exists in cache)
-     *
-     * @param tokenId - Stringified TokenClassKey
-     * @returns True if token is cached
-     */
-    isTokenWrappable(tokenId: string): boolean;
-    /**
-     * Get wrap counterpart for a token
-     *
-     * @param tokenId - Stringified TokenClassKey
-     * @returns Counterpart token or undefined if not found
-     */
-    getWrapCounterpart(tokenId: string): WrappableToken | undefined;
-}
-//# sourceMappingURL=WrappableTokenCache.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"WrappableTokenCache.d.ts","sourceRoot":"","sources":["../../src/services/WrappableTokenCache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAChG,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,mBAAoB,SAAQ,mBAAmB,CAAC,cAAc,EAAE,wBAAwB,CAAC;gBACxF,SAAS,GAAE,OAAe;IAItC;;;;;OAKG;IACH,SAAS,CAAC,UAAU,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAInD;;;;OAIG;IACM,GAAG,IAAI,OAAO;IAIvB;;;;OAIG;IACH,MAAM,IAAI,cAAc,EAAE;IAI1B;;;;;OAKG;IACI,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAIhE;;;;OAIG;IACa,QAAQ,IAAI,wBAAwB;IAQpD;;;;OAIG;IACM,IAAI,IAAI,MAAM;IAIvB;;;;;OAKG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI1C;;;;;OAKG;IACH,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;CAMhE"}

package/dist/services/WrappableTokenService.d.ts

@@ -1,130 +0,0 @@
-/**
- * Wrappable Token Service
- *
- * Service for fetching and caching wrappable tokens from the DEX API.
- * Provides methods to query which tokens can be wrapped/unwrapped
- * and retrieves their counterpart tokens dynamically.
- *
- * ## Key Features
- * - Dynamic token discovery (fetches from DEX API)
- * - Permanent caching for token metadata
- * - Separate balance methods for user-specific queries
- *
- * ## Caching Strategy
- * - Token metadata is always cached (fetchWrappableTokens, fetchAllWrappableTokens)
- * - Balance methods never cache (fetchWrappableTokenBalances, fetchAllWrappableTokenBalances)
- * - Cache persists for entire SDK lifetime
- *
- * @category Services
- * @since 4.0.18
- */
-import type { TokenId } from '../types/common.js';
-import type { FetchWrappableTokensOptions, FetchWrappableTokensResult, IsTokenWrappableResult, WrappableToken, WrappableTokenApiResponse, WrappableTokenCacheStats } from '../types/wrappable-token.dto.js';
-import type { HttpClient } from '../utils/http.js';
-import { AbstractTokenFetchService } from './AbstractTokenFetchService.js';
-/**
- * WrappableTokenService
- *
- * Fetches and caches wrappable token information from the DEX API.
- * Provides efficient lookups for wrap/unwrap operations.
- *
- * @example Basic usage
- * ```typescript
- * const service = new WrappableTokenService(dexApiHttp, true);
- *
- * // Fetch all wrappable tokens (cached)
- * const result = await service.fetchAllWrappableTokens();
- * console.log(`Found ${result.tokenCount} tokens`);
- *
- * // Fetch with balance data for a specific address (not cached)
- * const withBalances = await service.fetchAllWrappableTokenBalances('eth|0x1234...');
- * console.log(`Found ${withBalances.tokenCount} tokens with balances`);
- *
- * // Check if a specific token is wrappable (by tokenId)
- * const isWrappable = await service.isTokenWrappable('$MUSIC|Unit|none|none');
- * console.log(`MUSIC wrappable: ${isWrappable.isWrappable}`);
- *
- * // Get wrap counterpart
- * const counterpart = await service.getWrapCounterpart('$MUSIC|Unit|none|none');
- * console.log(`MUSIC counterpart: ${counterpart?.symbol}`); // GMUSIC
- * ```
- */
-export declare class WrappableTokenService extends AbstractTokenFetchService<WrappableTokenApiResponse, WrappableToken> {
-    private readonly cache;
-    constructor(dexApiHttp: HttpClient, debugMode?: boolean);
-    /**
-     * Build API request parameters for wrappable tokens
-     *
-     * @param _context - Unused context parameter (required by base class)
-     * @returns Query parameters with wrappable filter
-     */
-    protected buildApiParams(context?: Record<string, unknown>): Record<string, string | number | boolean>;
-    /**
-     * Transform API response tokens to SDK format
-     *
-     * @param apiTokens - Raw API response tokens
-     * @returns Array of transformed wrappable tokens
-     */
-    protected transformApiResponse(apiTokens: WrappableTokenApiResponse[]): WrappableToken[];
-    /**
-     * Fetch wrappable tokens with pagination (metadata only, cached)
-     *
-     * For user-specific balance data, use fetchWrappableTokenBalances() instead.
-     *
-     * @param options - Fetch options including pagination parameters
-     * @returns Promise resolving to fetch result with tokens array
-     * @throws NetworkError if API request fails
-     */
-    fetchWrappableTokens(options?: FetchWrappableTokensOptions): Promise<FetchWrappableTokensResult>;
-    /**
-     * Fetch ALL wrappable tokens (auto-pagination, cached)
-     *
-     * Returns cached data if available, otherwise fetches from API.
-     * For user-specific balance data, use fetchAllWrappableTokenBalances() instead.
-     *
-     * @returns Promise resolving to fetch result with all tokens
-     * @throws NetworkError if API request fails
-     */
-    fetchAllWrappableTokens(): Promise<FetchWrappableTokensResult>;
-    /**
-     * Get a wrappable token by tokenId
-     *
-     * Uses cache for efficient lookup. If cache not populated, fetches first.
-     *
-     * @param tokenId - Token identifier (pipe-delimited or TokenClassKey)
-     * @returns Promise resolving to wrappable token or undefined
-     */
-    getWrappableToken(tokenId: TokenId): Promise<WrappableToken | undefined>;
-    /**
-     * Get the wrap counterpart for a token
-     *
-     * @param tokenId - Token identifier (pipe-delimited or TokenClassKey)
-     * @returns Promise resolving to counterpart token or undefined
-     *
-     * @example
-     * ```typescript
-     * // Get GMUSIC from MUSIC
-     * const counterpart = await service.getWrapCounterpart('$MUSIC|Unit|none|none');
-     * console.log(counterpart?.symbol); // "GMUSIC"
-     * ```
-     */
-    getWrapCounterpart(tokenId: TokenId): Promise<WrappableToken | undefined>;
-    /**
-     * Check if a token is wrappable
-     *
-     * @param tokenId - Token identifier (pipe-delimited or TokenClassKey)
-     * @returns Promise resolving to wrappability result
-     */
-    isTokenWrappable(tokenId: TokenId): Promise<IsTokenWrappableResult>;
-    /**
-     * Get cache statistics
-     *
-     * @returns Cache statistics including token count and timestamp
-     */
-    getCacheStats(): WrappableTokenCacheStats;
-    /**
-     * Clear cache
-     */
-    clearCache(): void;
-}
-//# sourceMappingURL=WrappableTokenService.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"WrappableTokenService.d.ts","sourceRoot":"","sources":["../../src/services/WrappableTokenService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EACV,2BAA2B,EAC3B,0BAA0B,EAC1B,sBAAsB,EACtB,cAAc,EACd,yBAAyB,EACzB,wBAAwB,EACzB,MAAM,iCAAiC,CAAC;AAGzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAI3E;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,qBAAsB,SAAQ,yBAAyB,CAClE,yBAAyB,EACzB,cAAc,CACf;IACC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsB;gBAEhC,UAAU,EAAE,UAAU,EAAE,SAAS,GAAE,OAAe;IAK9D;;;;;OAKG;IACH,SAAS,CAAC,cAAc,CACtB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IAK5C;;;;;OAKG;IACH,SAAS,CAAC,oBAAoB,CAAC,SAAS,EAAE,yBAAyB,EAAE,GAAG,cAAc,EAAE;IAwCxF;;;;;;;;OAQG;IACG,oBAAoB,CACxB,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,0BAA0B,CAAC;IAoCtC;;;;;;;;OAQG;IACG,uBAAuB,IAAI,OAAO,CAAC,0BAA0B,CAAC;IAqBpE;;;;;;;OAOG;IACG,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAqB9E;;;;;;;;;;;;OAYG;IACG,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAO/E;;;;;OAKG;IACG,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,sBAAsB,CAAC;IA6BzE;;;;OAIG;IACH,aAAa,IAAI,wBAAwB;IAIzC;;OAEG;IACH,UAAU,IAAI,IAAI;CAGnB"}

package/dist/setup.d.ts

@@ -1,8 +0,0 @@
-/**
- * Vitest setup file for test environment configuration
- *
- * This file is placed in src/ to satisfy TypeScript's rootDir configuration
- * while remaining in the test environment setup pipeline via vitest.config.ts
- */
-export {};
-//# sourceMappingURL=setup.d.ts.map

package/dist/setup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../src/setup.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/tokens/transfers.d.ts

@@ -1,95 +0,0 @@
-import type { GalaChainSigner } from '../signing/signers.js';
-import type { HttpRequestor } from '../launchpad/bundle-submission.js';
-/** A four-part GalaChain token class key. */
-export interface TokenClassKey {
-    collection: string;
-    category: string;
-    type: string;
-    additionalKey: string;
-}
-/** Token identifier accepted by token writes. */
-export type TokenIdentifier = TokenClassKey | string;
-/** Common input for a single token mutation. */
-export interface TokenAmountInput {
-    /**
-     * The token's explicit class key: an object, or a `|`- / `$`-delimited string. A symbol is
-     * never accepted: a class key cannot be derived from a symbol. Resolve a launchpad token name
-     * with `sdk.resolveTokenClassKey(tokenName)` first.
-     */
-    tokenClassKey: TokenIdentifier;
-    quantity: string;
-    instance?: string;
-    uniqueKey?: string;
-}
-/** Input for a token transfer. */
-export interface TransferInput extends TokenAmountInput {
-    to: string;
-}
-/** Lock-specific token write input. */
-export interface LockInput extends TokenAmountInput {
-    lockAuthority?: string;
-    expires?: number;
-    name?: string;
-}
-/** Result returned by direct gateway token writes. */
-export interface ChainResult<T = unknown> {
-    status: 'PROCESSED';
-    data: T;
-    transactionId?: string;
-    blockNumber?: number;
-}
-/** Native-signed token-contract write client. */
-export declare class TokenWrites {
-    private readonly gatewayBaseUrl;
-    private readonly signer;
-    private readonly walletAddress;
-    private readonly requestor;
-    /** Create a token write client with a native signer and injectable HTTP. */
-    constructor(options: {
-        gatewayBaseUrl: string;
-        dexBackendBaseUrl: string;
-        signer: GalaChainSigner;
-        walletAddress: string;
-        httpRequestor?: HttpRequestor;
-    });
-    /**
-     * Transfer a token through the direct token-contract gateway endpoint.
-     * @example
-     * ```typescript
-     * const result = await sdk.tokens.transfer({ to: 'client|recipient', tokenClassKey: 'GALA|Unit|none|none', quantity: '1' });
-     * console.log(result.transactionId, result.blockNumber);
-     * ```
-     */
-    transfer(input: TransferInput): Promise<ChainResult>;
-    /**
-     * Burn tokens through the direct public gateway endpoint.
-     * @example
-     * ```typescript
-     * const result = await sdk.tokens.burn({ tokenClassKey: 'GALA|Unit|none|none', quantity: '1' });
-     * console.log(result.status);
-     * ```
-     */
-    burn(input: TokenAmountInput): Promise<ChainResult>;
-    /**
-     * Lock tokens through the direct public gateway endpoint.
-     * @example
-     * ```typescript
-     * await sdk.tokens.lock({ tokenClassKey: 'GALA|Unit|none|none', quantity: '1' });
-     * ```
-     */
-    lock(input: LockInput): Promise<ChainResult>;
-    /**
-     * Unlock tokens through the direct public gateway endpoint.
-     * @example
-     * ```typescript
-     * await sdk.tokens.unlock({ tokenClassKey: 'GALA|Unit|none|none', quantity: '1' });
-     * ```
-     */
-    unlock(input: TokenAmountInput & {
-        name?: string;
-    }): Promise<ChainResult>;
-    private direct;
-    private post;
-    private signNative;
-}
-//# sourceMappingURL=transfers.d.ts.map

package/dist/tokens/transfers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transfers.d.ts","sourceRoot":"","sources":["../../src/tokens/transfers.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,mCAAmC,CAAC;AAGrF,6CAA6C;AAC7C,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,iDAAiD;AACjD,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG,MAAM,CAAC;AAErD,gDAAgD;AAChD,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,aAAa,EAAE,eAAe,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,kCAAkC;AAClC,MAAM,WAAW,aAAc,SAAQ,gBAAgB;IACrD,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,uCAAuC;AACvC,MAAM,WAAW,SAAU,SAAQ,gBAAgB;IACjD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,sDAAsD;AACtD,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,OAAO;IACtC,MAAM,EAAE,WAAW,CAAC;IACpB,IAAI,EAAE,CAAC,CAAC;IACR,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAcD,iDAAiD;AACjD,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;IACzC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;IAE1C,4EAA4E;gBACzD,OAAO,EAAE;QAC1B,cAAc,EAAE,MAAM,CAAC;QACvB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,MAAM,EAAE,eAAe,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,CAAC,EAAE,aAAa,CAAC;KAC/B;IAOD;;;;;;;OAOG;IACI,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC;IAY3D;;;;;;;OAOG;IACI,IAAI,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,CAAC;IAQ1D;;;;;;OAMG;IACI,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC;IAenD;;;;;;OAMG;IACI,MAAM,CAAC,KAAK,EAAE,gBAAgB,GAAG;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,WAAW,CAAC;YAalE,MAAM;IA4BpB,OAAO,CAAC,IAAI;YAUE,UAAU;CASzB"}