@flashnet/sdk 0.3.3 → 0.3.6

package/dist/esm/src/client/FlashnetClient.js

@@ -1,12 +1,13 @@
 import { ApiClient } from '../api/client.js';
 import { TypedAmmApi } from '../api/typed-endpoints.js';
-import { getNetworkConfig, BTC_ASSET_PUBKEY } from '../config/index.js';
-import { Network } from '../types/index.js';
+import { getClientEnvironmentName, validateNetworkCombination, resolveClientNetworkConfig, getClientNetworkConfig, BTC_ASSET_PUBKEY } from '../config/index.js';
+import { getSparkNetworkFromLegacy, getClientEnvironmentFromLegacy, Network } from '../types/index.js';
 import { generateNonce } from '../utils/index.js';
 import { AuthManager } from '../utils/auth.js';
 import { generateConstantProductPoolInitializationIntentMessage, generatePoolInitializationIntentMessage, generatePoolConfirmInitialDepositIntentMessage, generatePoolSwapIntentMessage, generateRouteSwapIntentMessage, generateAddLiquidityIntentMessage, generateRemoveLiquidityIntentMessage, generateRegisterHostIntentMessage, generateWithdrawHostFeesIntentMessage, generateWithdrawIntegratorFeesIntentMessage } from '../utils/intents.js';
 import { createWalletSigner } from '../utils/signer.js';
-import { getNetworkFromAddress, encodeSparkAddress } from '../utils/spark-address.js';
+import { getSparkNetworkFromAddress, encodeSparkAddressNew } from '../utils/spark-address.js';
+import { encodeSparkHumanReadableTokenIdentifier, decodeSparkHumanReadableTokenIdentifier, encodeHumanReadableTokenIdentifier, decodeHumanReadableTokenIdentifier } from '../utils/tokenAddress.js';
 
 /**
  * FlashnetClient - A comprehensive client for interacting with Flashnet AMM
@@ -23,7 +24,8 @@ class FlashnetClient {
     apiClient;
     typedApi;
     authManager;
-    network;
+    sparkNetwork;
+    clientEnvironment;
     publicKey = "";
     sparkAddress = "";
     isAuthenticated = false;
@@ -34,10 +36,27 @@ class FlashnetClient {
         return this._wallet;
     }
     /**
+     * Get the Spark network type (for blockchain operations)
+     */
+    get sparkNetworkType() {
+        return this.sparkNetwork;
+    }
+    /**
+     * Get the client environment (for API configuration)
+     */
+    get clientEnvironmentType() {
+        return this.clientEnvironment;
+    }
+    /**
+     * @deprecated Use sparkNetworkType instead
      * Get the network type
      */
     get networkType() {
-        return this.network;
+        // Map Spark network back to legacy network type
+        // This is for backward compatibility
+        return this.sparkNetwork === "REGTEST" && this.clientEnvironment === "local"
+            ? "LOCAL"
+            : this.sparkNetwork;
     }
     /**
      * Get the wallet's public key
@@ -51,24 +70,87 @@ class FlashnetClient {
     get address() {
         return this.sparkAddress;
     }
-    /**
-     * Create a new FlashnetClient instance
-     * @param wallet - The SparkWallet to use
-     * @param options - Client options
-     */
-    constructor(wallet, _options = {}) {
+    constructor(wallet, configOrOptions) {
         this._wallet = wallet;
-        // We'll initialize these in the init method
-        // @ts-expect-error - wallet.config is protected
-        const networkEnum = wallet.config.getNetwork();
-        const networkName = Network[networkEnum];
-        this.network = networkName === "MAINNET" ? "MAINNET" : "REGTEST";
-        // panic if mainnet for now
-        if (networkName === "MAINNET") {
+        // Determine configuration type and extract values
+        const isLegacyConfig = !configOrOptions || 'network' in configOrOptions ||
+            (!('sparkNetworkType' in configOrOptions));
+        if (isLegacyConfig) {
+            // Legacy configuration system - derive from wallet or options
+            const legacyConfig = configOrOptions;
+            if (legacyConfig?.network) {
+                // Use provided legacy network
+                this.sparkNetwork = getSparkNetworkFromLegacy(legacyConfig.network);
+                this.clientEnvironment = getClientEnvironmentFromLegacy(legacyConfig.network);
+            }
+            else {
+                // Auto-detect from wallet (existing behavior)
+                // @ts-expect-error - wallet.config is protected
+                const networkEnum = wallet.config.getNetwork();
+                const networkName = Network[networkEnum];
+                const detectedNetwork = networkName === "MAINNET" ? "MAINNET" : "REGTEST";
+                this.sparkNetwork = getSparkNetworkFromLegacy(detectedNetwork);
+                this.clientEnvironment = getClientEnvironmentFromLegacy(detectedNetwork);
+            }
+        }
+        else {
+            // New configuration system
+            const config = configOrOptions;
+            this.sparkNetwork = config.sparkNetworkType;
+            // Determine client configuration based on the specific config type
+            let clientConfig;
+            if ('clientConfig' in config) {
+                // FlashnetClientConfig - can be either environment or custom config
+                clientConfig = config.clientConfig;
+            }
+            else if ('clientNetworkConfig' in config) {
+                // FlashnetClientCustomConfig - custom configuration
+                clientConfig = config.clientNetworkConfig;
+            }
+            else if ('clientEnvironment' in config) {
+                // FlashnetClientEnvironmentConfig - predefined environment
+                clientConfig = config.clientEnvironment;
+            }
+            else {
+                throw new Error('Invalid configuration: must specify clientConfig, clientNetworkConfig, or clientEnvironment');
+            }
+            // Resolve the client environment name for internal tracking
+            const environmentName = getClientEnvironmentName(clientConfig);
+            this.clientEnvironment = environmentName === 'custom' ? 'local' : environmentName;
+            // Validate Spark network and client environment combination
+            const validation = validateNetworkCombination(this.sparkNetwork, this.clientEnvironment);
+            if (!validation.valid) {
+                throw new Error(`Invalid network combination: ${validation.error}`);
+            }
+        }
+        // Panic if mainnet for now
+        if (this.sparkNetwork === "MAINNET") {
             throw new Error("Mainnet is not supported yet");
         }
-        const config = getNetworkConfig(this.network);
-        this.apiClient = new ApiClient(config);
+        // Initialize API client with resolved client configuration
+        let resolvedClientConfig;
+        if (!isLegacyConfig) {
+            const config = configOrOptions;
+            let clientConfigParam;
+            if ('clientConfig' in config) {
+                clientConfigParam = config.clientConfig;
+            }
+            else if ('clientNetworkConfig' in config) {
+                clientConfigParam = config.clientNetworkConfig;
+            }
+            else if ('clientEnvironment' in config) {
+                clientConfigParam = config.clientEnvironment;
+            }
+            else {
+                throw new Error('Invalid configuration');
+            }
+            resolvedClientConfig = resolveClientNetworkConfig(clientConfigParam);
+        }
+        else {
+            // Use legacy resolution
+            resolvedClientConfig = getClientNetworkConfig(this.clientEnvironment);
+        }
+        this.apiClient = new ApiClient(resolvedClientConfig);
         this.typedApi = new TypedAmmApi(this.apiClient);
         this.authManager = new AuthManager(this.apiClient, "", wallet);
     }
@@ -83,20 +165,21 @@ class FlashnetClient {
         // Get wallet details
         this.publicKey = await this._wallet.getIdentityPublicKey();
         this.sparkAddress = await this._wallet.getSparkAddress();
-        // Deduce network from spark address
-        const detectedNetwork = getNetworkFromAddress(this.sparkAddress);
-        if (!detectedNetwork) {
-            throw new Error(`Unable to determine network from spark address: ${this.sparkAddress}`);
-        }
-        this.network = detectedNetwork;
-        // panic if mainnet for now
-        if (detectedNetwork === "MAINNET") {
+        // Deduce Spark network from spark address and validate consistency
+        const detectedSparkNetwork = getSparkNetworkFromAddress(this.sparkAddress);
+        if (!detectedSparkNetwork) {
+            throw new Error(`Unable to determine Spark network from spark address: ${this.sparkAddress}`);
+        }
+        // Warn if configured Spark network doesn't match detected network
+        if (this.sparkNetwork !== detectedSparkNetwork) {
+            console.warn(`Warning: Configured Spark network (${this.sparkNetwork}) doesn't match detected network from address (${detectedSparkNetwork}). Using detected network.`);
+            this.sparkNetwork = detectedSparkNetwork;
+        }
+        // Panic if mainnet for now
+        if (this.sparkNetwork === "MAINNET") {
             throw new Error("Mainnet is not supported yet");
         }
-        // Reinitialize API client with correct network
-        const config = getNetworkConfig(this.network);
-        this.apiClient = new ApiClient(config);
-        this.typedApi = new TypedAmmApi(this.apiClient);
+        // Re-initialize auth manager with correct public key
         this.authManager = new AuthManager(this.apiClient, this.publicKey, createWalletSigner(this._wallet));
         // Authenticate
         const token = await this.authManager.authenticate();
@@ -111,6 +194,34 @@ class FlashnetClient {
             await this.initialize();
         }
     }
+    /**
+     * Ensure a token identifier is in human-readable (Bech32m) form expected by the Spark SDK.
+     * If the identifier is already human-readable or it is the BTC constant, it is returned unchanged.
+     * Otherwise, it is encoded from the raw hex form using the client's Spark network.
+     */
+    toHumanReadableTokenIdentifier(tokenIdentifier) {
+        if (tokenIdentifier === BTC_ASSET_PUBKEY) {
+            return tokenIdentifier;
+        }
+        if (tokenIdentifier.startsWith("btkn")) {
+            return tokenIdentifier;
+        }
+        return encodeSparkHumanReadableTokenIdentifier(tokenIdentifier, this.sparkNetwork);
+    }
+    /**
+     * Convert a token identifier into the raw hex string form expected by the Flashnet backend.
+     * If the identifier is the BTC constant or already a hex string, it is returned unchanged.
+     * If it is in Bech32m human-readable form, it is decoded to hex.
+     */
+    toHexTokenIdentifier(tokenIdentifier) {
+        if (tokenIdentifier === BTC_ASSET_PUBKEY) {
+            return tokenIdentifier;
+        }
+        if (tokenIdentifier.startsWith("btkn")) {
+            return decodeSparkHumanReadableTokenIdentifier(tokenIdentifier, this.sparkNetwork).tokenIdentifier;
+        }
+        return tokenIdentifier;
+    }
     /**
      * Get wallet balance including BTC and token balances
      */
@@ -120,14 +231,17 @@ class FlashnetClient {
         const tokenBalances = new Map();
         if (balance.tokenBalances) {
             for (const [tokenPubkey, tokenData] of balance.tokenBalances.entries()) {
+                const info = "tokenInfo" in tokenData
+                    ? tokenData.tokenInfo
+                    : tokenData.tokenMetadata;
                 tokenBalances.set(tokenPubkey, {
                     balance: BigInt(tokenData.balance),
                     tokenInfo: {
-                        tokenPublicKey: tokenData.tokenInfo.tokenPublicKey,
-                        tokenName: tokenData.tokenInfo.tokenName,
-                        tokenSymbol: tokenData.tokenInfo.tokenSymbol,
-                        tokenDecimals: tokenData.tokenInfo.tokenDecimals,
-                        maxSupply: tokenData.tokenInfo.maxSupply,
+                        tokenPublicKey: info.tokenPublicKey,
+                        tokenName: info.tokenName,
+                        tokenSymbol: (info.tokenSymbol || info.tokenTicker),
+                        tokenDecimals: (info.tokenDecimals ?? info.decimals),
+                        maxSupply: info.maxSupply,
                     },
                 });
             }
@@ -152,8 +266,10 @@ class FlashnetClient {
         // Check token balances
         if (requirements.tokens) {
             for (const [tokenPubkey, requiredAmount,] of requirements.tokens.entries()) {
-                const tokenBalance = balance.tokenBalances.get(tokenPubkey);
-                const available = tokenBalance?.balance ?? 0n;
+                // If direct lookup fails (possible representation mismatch), try the human-readable form
+                const hrKey = this.toHumanReadableTokenIdentifier(tokenPubkey);
+                const effectiveTokenBalance = balance.tokenBalances.get(tokenPubkey) ?? balance.tokenBalances.get(hrKey);
+                const available = effectiveTokenBalance?.balance ?? 0n;
                 if (available < requiredAmount) {
                     return {
                         sufficient: false,
@@ -187,6 +303,13 @@ class FlashnetClient {
         const provider = providerPublicKey || this.publicKey;
         return this.typedApi.getLpPosition(poolId, provider);
     }
+    /**
+    * Get LP position details for a provider in a pool
+    */
+    async getAllLpPositions() {
+        await this.ensureInitialized();
+        return this.typedApi.getAllLpPositions();
+    }
     /**
      * Create a constant product pool
      */
@@ -219,8 +342,8 @@ class FlashnetClient {
         const nonce = generateNonce();
         const intentMessage = generateConstantProductPoolInitializationIntentMessage({
             poolOwnerPublicKey: this.publicKey,
-            assetAAddress: params.assetAAddress,
-            assetBAddress: params.assetBAddress,
+            assetAAddress: this.toHexTokenIdentifier(params.assetAAddress),
+            assetBAddress: this.toHexTokenIdentifier(params.assetBAddress),
             lpFeeRateBps: params.lpFeeRateBps.toString(),
             totalHostFeeRateBps: params.totalHostFeeRateBps.toString(),
             nonce,
@@ -231,8 +354,8 @@ class FlashnetClient {
         // Create pool
         const request = {
             poolOwnerPublicKey: this.publicKey,
-            assetAAddress: params.assetAAddress,
-            assetBAddress: params.assetBAddress,
+            assetAAddress: this.toHexTokenIdentifier(params.assetAAddress),
+            assetBAddress: this.toHexTokenIdentifier(params.assetBAddress),
             lpFeeRateBps: params.lpFeeRateBps.toString(),
             totalHostFeeRateBps: params.totalHostFeeRateBps.toString(),
             hostNamespace: params.hostNamespace || "",
@@ -242,7 +365,7 @@ class FlashnetClient {
         const response = await this.typedApi.createConstantProductPool(request);
         // Add initial liquidity if specified
         if (params.initialLiquidity && response.poolId) {
-            await this.addInitialLiquidity(response.poolId, params.assetAAddress, params.assetBAddress, params.initialLiquidity.assetAAmount, params.initialLiquidity.assetBAmount);
+            await this.addInitialLiquidity(response.poolId, params.assetAAddress, params.assetBAddress, params.initialLiquidity.assetAAmount.toString(), params.initialLiquidity.assetBAmount.toString());
         }
         return response;
     }
@@ -280,8 +403,8 @@ class FlashnetClient {
         const nonce = generateNonce();
         const intentMessage = generatePoolInitializationIntentMessage({
             poolOwnerPublicKey: this.publicKey,
-            assetAAddress: params.assetAAddress,
-            assetBAddress: params.assetBAddress,
+            assetAAddress: this.toHexTokenIdentifier(params.assetAAddress),
+            assetBAddress: this.toHexTokenIdentifier(params.assetBAddress),
             assetAInitialReserve: params.assetAInitialReserve,
             graduationThresholdPct: params.assetAPctSoldAtGraduation.toString(),
             targetBRaisedAtGraduation: params.targetBRaisedAtGraduation,
@@ -294,8 +417,8 @@ class FlashnetClient {
         // Create pool
         const request = {
             poolOwnerPublicKey: this.publicKey,
-            assetAAddress: params.assetAAddress,
-            assetBAddress: params.assetBAddress,
+            assetAAddress: this.toHexTokenIdentifier(params.assetAAddress),
+            assetBAddress: this.toHexTokenIdentifier(params.assetBAddress),
             assetAInitialReserve: params.assetAInitialReserve,
             graduationThresholdPct: params.assetAPctSoldAtGraduation,
             targetBRaisedAtGraduation: params.targetBRaisedAtGraduation,
@@ -309,10 +432,10 @@ class FlashnetClient {
         // If pool creation was successful, handle the initial deposit
         if (createResponse.poolId) {
             try {
-                // Transfer initial reserve to the pool
-                const lpSparkAddress = encodeSparkAddress({
+                // Transfer initial reserve to the pool using new address encoding
+                const lpSparkAddress = encodeSparkAddressNew({
                     identityPublicKey: createResponse.poolId,
-                    network: this.network,
+                    network: this.sparkNetwork,
                 });
                 let assetATransferId;
                 if (params.assetAAddress === BTC_ASSET_PUBKEY) {
@@ -324,7 +447,7 @@ class FlashnetClient {
                 }
                 else {
                     assetATransferId = await this._wallet.transferTokens({
-                        tokenPublicKey: params.assetAAddress,
+                        tokenIdentifier: this.toHumanReadableTokenIdentifier(params.assetAAddress),
                         tokenAmount: BigInt(params.assetAInitialReserve),
                         receiverSparkAddress: lpSparkAddress,
                     });
@@ -411,10 +534,10 @@ class FlashnetClient {
         if (!balanceCheck.sufficient) {
             throw new Error(`Insufficient balance for swap: ${balanceCheck.message}`);
         }
-        // Transfer assets to pool
-        const lpSparkAddress = encodeSparkAddress({
+        // Transfer assets to pool using new address encoding
+        const lpSparkAddress = encodeSparkAddressNew({
             identityPublicKey: params.poolId,
-            network: this.network,
+            network: this.sparkNetwork,
         });
         let transferId;
         if (params.assetInAddress === BTC_ASSET_PUBKEY) {
@@ -426,7 +549,7 @@ class FlashnetClient {
         }
         else {
             transferId = await this._wallet.transferTokens({
-                tokenPublicKey: params.assetInAddress,
+                tokenIdentifier: this.toHumanReadableTokenIdentifier(params.assetInAddress),
                 tokenAmount: BigInt(params.amountIn),
                 receiverSparkAddress: lpSparkAddress,
             });
@@ -437,8 +560,8 @@ class FlashnetClient {
             userPublicKey: this.publicKey,
             lpIdentityPublicKey: params.poolId,
             assetInSparkTransferId: transferId,
-            assetInTokenPublicKey: params.assetInAddress,
-            assetOutTokenPublicKey: params.assetOutAddress,
+            assetInTokenPublicKey: this.toHexTokenIdentifier(params.assetInAddress),
+            assetOutTokenPublicKey: this.toHexTokenIdentifier(params.assetOutAddress),
             amountIn: params.amountIn.toString(),
             maxSlippageBps: params.maxSlippageBps.toString(),
             minAmountOut: params.minAmountOut,
@@ -451,8 +574,8 @@ class FlashnetClient {
         const request = {
             userPublicKey: this.publicKey,
             poolId: params.poolId,
-            assetInAddress: params.assetInAddress,
-            assetOutAddress: params.assetOutAddress,
+            assetInAddress: this.toHexTokenIdentifier(params.assetInAddress),
+            assetOutAddress: this.toHexTokenIdentifier(params.assetOutAddress),
             amountIn: params.amountIn.toString(),
             maxSlippageBps: params.maxSlippageBps?.toString(),
             minAmountOut: params.minAmountOut,
@@ -503,14 +626,14 @@ class FlashnetClient {
         if (!params.hops.length) {
             throw new Error("Route swap requires at least one hop");
         }
-        // Transfer initial asset to first pool
+        // Transfer initial asset to first pool using new address encoding
         const firstPoolId = params.hops[0]?.poolId;
         if (!firstPoolId) {
             throw new Error("First pool ID is required");
         }
-        const lpSparkAddress = encodeSparkAddress({
+        const lpSparkAddress = encodeSparkAddressNew({
             identityPublicKey: firstPoolId,
-            network: this.network,
+            network: this.sparkNetwork,
         });
         let initialTransferId;
         if (params.initialAssetAddress === BTC_ASSET_PUBKEY) {
@@ -522,7 +645,7 @@ class FlashnetClient {
         }
         else {
             initialTransferId = await this._wallet.transferTokens({
-                tokenPublicKey: params.initialAssetAddress,
+                tokenIdentifier: this.toHumanReadableTokenIdentifier(params.initialAssetAddress),
                 tokenAmount: BigInt(params.inputAmount),
                 receiverSparkAddress: lpSparkAddress,
             });
@@ -530,8 +653,8 @@ class FlashnetClient {
         // Prepare hops for validation
         const hops = params.hops.map((hop) => ({
             lpIdentityPublicKey: hop.poolId,
-            inputAssetPublicKey: hop.assetInAddress,
-            outputAssetPublicKey: hop.assetOutAddress,
+            inputAssetPublicKey: this.toHexTokenIdentifier(hop.assetInAddress),
+            outputAssetPublicKey: this.toHexTokenIdentifier(hop.assetOutAddress),
             hopIntegratorFeeRateBps: hop.hopIntegratorFeeRateBps !== undefined &&
                 hop.hopIntegratorFeeRateBps !== null
                 ? hop.hopIntegratorFeeRateBps.toString()
@@ -540,8 +663,8 @@ class FlashnetClient {
         // Convert hops and ensure integrator fee is always present
         const requestHops = params.hops.map((hop) => ({
             poolId: hop.poolId,
-            assetInAddress: hop.assetInAddress,
-            assetOutAddress: hop.assetOutAddress,
+            assetInAddress: this.toHexTokenIdentifier(hop.assetInAddress),
+            assetOutAddress: this.toHexTokenIdentifier(hop.assetOutAddress),
             hopIntegratorFeeRateBps: hop.hopIntegratorFeeRateBps !== undefined &&
                 hop.hopIntegratorFeeRateBps !== null
                 ? hop.hopIntegratorFeeRateBps.toString()
@@ -610,25 +733,25 @@ class FlashnetClient {
             tokens: new Map(),
         };
         if (pool.assetAAddress === BTC_ASSET_PUBKEY) {
-            requirements.btc = params.assetAAmount;
+            requirements.btc = BigInt(params.assetAAmount);
         }
         else {
-            requirements.tokens?.set(pool.assetAAddress, params.assetAAmount);
+            requirements.tokens?.set(pool.assetAAddress, BigInt(params.assetAAmount));
         }
         if (pool.assetBAddress === BTC_ASSET_PUBKEY) {
-            requirements.btc = (requirements.btc || 0n) + params.assetBAmount;
+            requirements.btc = (requirements.btc || 0n) + BigInt(params.assetBAmount);
         }
         else {
-            requirements.tokens?.set(pool.assetBAddress, params.assetBAmount);
+            requirements.tokens?.set(pool.assetBAddress, BigInt(params.assetBAmount));
         }
         const balanceCheck = await this.checkBalance(requirements);
         if (!balanceCheck.sufficient) {
             throw new Error(`Insufficient balance for adding liquidity: ${balanceCheck.message}`);
         }
-        // Transfer assets to pool
-        const lpSparkAddress = encodeSparkAddress({
+        // Transfer assets to pool using new address encoding
+        const lpSparkAddress = encodeSparkAddressNew({
             identityPublicKey: params.poolId,
-            network: this.network,
+            network: this.sparkNetwork,
         });
         // Transfer asset A
         let assetATransferId;
@@ -641,8 +764,8 @@ class FlashnetClient {
         }
         else {
             assetATransferId = await this._wallet.transferTokens({
-                tokenPublicKey: pool.assetAAddress,
-                tokenAmount: params.assetAAmount,
+                tokenIdentifier: this.toHumanReadableTokenIdentifier(pool.assetAAddress),
+                tokenAmount: BigInt(params.assetAAmount),
                 receiverSparkAddress: lpSparkAddress,
             });
         }
@@ -657,8 +780,8 @@ class FlashnetClient {
         }
         else {
             assetBTransferId = await this._wallet.transferTokens({
-                tokenPublicKey: pool.assetBAddress,
-                tokenAmount: params.assetBAmount,
+                tokenIdentifier: this.toHumanReadableTokenIdentifier(pool.assetBAddress),
+                tokenAmount: BigInt(params.assetBAmount),
                 receiverSparkAddress: lpSparkAddress,
             });
         }
@@ -886,6 +1009,41 @@ class FlashnetClient {
         const user = userPublicKey || this.publicKey;
         return this.typedApi.getUserSwaps(user, query);
     }
+    // ===== Token Address Operations =====
+    /**
+     * Encode a token identifier into a human-readable token address using the client's Spark network
+     * @param tokenIdentifier - Token identifier as hex string or Uint8Array
+     * @returns Human-readable token address
+     */
+    encodeTokenAddress(tokenIdentifier) {
+        return encodeSparkHumanReadableTokenIdentifier(tokenIdentifier, this.sparkNetwork);
+    }
+    /**
+     * Decode a human-readable token address back to its identifier
+     * @param address - Human-readable token address
+     * @returns Object containing the token identifier (as hex string) and Spark network
+     */
+    decodeTokenAddress(address) {
+        return decodeSparkHumanReadableTokenIdentifier(address, this.sparkNetwork);
+    }
+    /**
+     * @deprecated Use encodeTokenAddress instead - this method uses legacy types
+     * Encode a token identifier into a human-readable token address using legacy types
+     * @param tokenIdentifier - Token identifier as hex string or Uint8Array
+     * @returns Human-readable token address
+     */
+    encodeLegacyTokenAddress(tokenIdentifier) {
+        return encodeHumanReadableTokenIdentifier(tokenIdentifier, this.sparkNetwork);
+    }
+    /**
+     * @deprecated Use decodeTokenAddress instead - this method uses legacy types
+     * Decode a human-readable token address back to its identifier using legacy types
+     * @param address - Human-readable token address
+     * @returns Object containing the token identifier (as hex string) and network
+     */
+    decodeLegacyTokenAddress(address) {
+        return decodeHumanReadableTokenIdentifier(address, this.sparkNetwork);
+    }
     // ===== Status =====
     /**
      * Ping the settlement service
@@ -899,9 +1057,9 @@ class FlashnetClient {
      * Helper method to add initial liquidity after pool creation
      */
     async addInitialLiquidity(poolId, assetATokenPublicKey, assetBTokenPublicKey, assetAAmount, assetBAmount) {
-        const lpSparkAddress = encodeSparkAddress({
+        const lpSparkAddress = encodeSparkAddressNew({
             identityPublicKey: poolId,
-            network: this.network,
+            network: this.sparkNetwork,
         });
         // Transfer asset A
         let assetATransferId;
@@ -914,8 +1072,8 @@ class FlashnetClient {
         }
         else {
             assetATransferId = await this._wallet.transferTokens({
-                tokenPublicKey: assetATokenPublicKey,
-                tokenAmount: assetAAmount,
+                tokenIdentifier: this.toHumanReadableTokenIdentifier(assetATokenPublicKey),
+                tokenAmount: BigInt(assetAAmount),
                 receiverSparkAddress: lpSparkAddress,
             });
         }
@@ -930,8 +1088,8 @@ class FlashnetClient {
         }
         else {
             assetBTransferId = await this._wallet.transferTokens({
-                tokenPublicKey: assetBTokenPublicKey,
-                tokenAmount: assetBAmount,
+                tokenIdentifier: this.toHumanReadableTokenIdentifier(assetBTokenPublicKey),
+                tokenAmount: BigInt(assetBAmount),
                 receiverSparkAddress: lpSparkAddress,
             });
         }