@flaunch/sdk 0.9.7 → 0.9.8

package/dist/index.esm.js

@@ -1,5 +1,5 @@
 import { createDrift as createDrift$1 } from '@delvtech/drift';
-import { zeroAddress, parseEther, encodeAbiParameters as encodeAbiParameters$1, maxUint256 as maxUint256$1, encodeFunctionData, maxUint160, maxUint48, parseUnits, hexToBigInt as hexToBigInt$1, pad as pad$1, keccak256 as keccak256$1, encodePacked, stringToHex as stringToHex$1, zeroHash, formatUnits as formatUnits$1, parseEventLogs, concat as concat$1, toHex as toHex$1, formatEther, erc721Abi, erc20Abi, parseAbi, createWalletClient, http, decodeFunctionData } from 'viem';
+import { zeroAddress, parseEther, encodeAbiParameters as encodeAbiParameters$1, maxUint256 as maxUint256$1, encodeFunctionData, maxUint160, maxUint48, parseUnits, hexToBigInt as hexToBigInt$1, pad as pad$1, keccak256 as keccak256$1, encodePacked, stringToHex as stringToHex$1, zeroHash, formatUnits as formatUnits$1, parseEventLogs, concat as concat$1, toHex as toHex$1, erc721Abi, erc20Abi, parseAbi, createWalletClient, http, decodeFunctionData } from 'viem';
 import axios from 'axios';
 import { viemAdapter } from '@delvtech/drift-viem';
 
@@ -26931,7 +26931,8 @@ class ReadFlaunchSDK {
             memecoin.totalSupply(),
             memecoin.decimals(),
         ]);
-        return { totalSupply, decimals };
+        const formattedTotalSupplyInDecimals = parseFloat(formatUnits$1(totalSupply, decimals));
+        return { totalSupply, decimals, formattedTotalSupplyInDecimals };
     }
     /**
      * Gets market context information needed for tick calculations
@@ -26953,8 +26954,8 @@ class ReadFlaunchSDK {
     /**
      * Converts market cap in USD to token price in ETH
      */
-    marketCapToTokenPriceEth(marketCapUsd, totalSupplyDecimal, ethUsdPrice) {
-        const tokenPriceUsd = marketCapUsd / totalSupplyDecimal;
+    marketCapToTokenPriceEth(marketCapUsd, formattedTotalSupplyInDecimals, ethUsdPrice) {
+        const tokenPriceUsd = marketCapUsd / formattedTotalSupplyInDecimals;
         return tokenPriceUsd / ethUsdPrice;
     }
     /**
@@ -26972,24 +26973,22 @@ class ReadFlaunchSDK {
     /**
      * Calculates current tick from market cap if provided
      */
-    calculateCurrentTickFromMarketCap(currentMarketCap, totalSupplyDecimal, marketContext) {
+    calculateCurrentTickFromMarketCap(currentMarketCap, formattedTotalSupplyInDecimals, marketContext) {
         if (!currentMarketCap) {
             return undefined;
         }
         const currentMarketCapNum = parseFloat(currentMarketCap);
-        const currentTokenPriceEth = this.marketCapToTokenPriceEth(currentMarketCapNum, totalSupplyDecimal, marketContext.ethUsdPrice);
+        const currentTokenPriceEth = this.marketCapToTokenPriceEth(currentMarketCapNum, formattedTotalSupplyInDecimals, marketContext.ethUsdPrice);
         return this.convertPriceToTick(currentTokenPriceEth, marketContext.isFlethZero, marketContext.decimals0, marketContext.decimals1);
     }
     async calculateAddLiquidityTicks({ coinAddress, liquidityMode, minMarketCap, maxMarketCap, currentMarketCap, }) {
         // Get coin information
-        const { totalSupply: coinTotalSupply, decimals: coinDecimals } = await this.getCoinInfo(coinAddress);
-        // Convert total supply to decimal format
-        const totalSupplyDecimal = parseFloat(formatEther(coinTotalSupply));
+        const { totalSupply: coinTotalSupply, decimals: coinDecimals, formattedTotalSupplyInDecimals, } = await this.getCoinInfo(coinAddress);
         if (liquidityMode === LiquidityMode.FULL_RANGE) {
             let currentTick;
             if (currentMarketCap) {
                 const marketContext = await this.getMarketContext(coinAddress, coinDecimals);
-                currentTick = this.calculateCurrentTickFromMarketCap(currentMarketCap, totalSupplyDecimal, marketContext);
+                currentTick = this.calculateCurrentTickFromMarketCap(currentMarketCap, formattedTotalSupplyInDecimals, marketContext);
             }
             return {
                 tickLower: getNearestUsableTick({
@@ -27016,13 +27015,13 @@ class ReadFlaunchSDK {
                 throw new Error("[ReadFlaunchSDK.addLiquidityCalculateTicks]: Invalid market cap range");
             }
             // Convert market caps to token prices in ETH
-            const minTokenPriceEth = this.marketCapToTokenPriceEth(minMarketCapNum, totalSupplyDecimal, marketContext.ethUsdPrice);
-            const maxTokenPriceEth = this.marketCapToTokenPriceEth(maxMarketCapNum, totalSupplyDecimal, marketContext.ethUsdPrice);
+            const minTokenPriceEth = this.marketCapToTokenPriceEth(minMarketCapNum, formattedTotalSupplyInDecimals, marketContext.ethUsdPrice);
+            const maxTokenPriceEth = this.marketCapToTokenPriceEth(maxMarketCapNum, formattedTotalSupplyInDecimals, marketContext.ethUsdPrice);
             // Convert to ticks
             const minTick = this.convertPriceToTick(minTokenPriceEth, marketContext.isFlethZero, marketContext.decimals0, marketContext.decimals1);
             const maxTick = this.convertPriceToTick(maxTokenPriceEth, marketContext.isFlethZero, marketContext.decimals0, marketContext.decimals1);
             // Calculate current tick if provided
-            const currentTick = this.calculateCurrentTickFromMarketCap(currentMarketCap, totalSupplyDecimal, marketContext);
+            const currentTick = this.calculateCurrentTickFromMarketCap(currentMarketCap, formattedTotalSupplyInDecimals, marketContext);
             return {
                 tickLower: Math.min(minTick, maxTick),
                 tickUpper: Math.max(minTick, maxTick),
@@ -27043,12 +27042,11 @@ class ReadFlaunchSDK {
             currentMarketCap = params.currentMarketCap;
         }
         else {
-            const { totalSupply, decimals } = await this.getCoinInfo(coinAddress);
-            const formattedTotalSupply = parseFloat(formatUnits$1(totalSupply, decimals));
-            minMarketCap = (parseFloat(params.minPriceUSD) * formattedTotalSupply).toString();
-            maxMarketCap = (parseFloat(params.maxPriceUSD) * formattedTotalSupply).toString();
+            const { formattedTotalSupplyInDecimals } = await this.getCoinInfo(coinAddress);
+            minMarketCap = (parseFloat(params.minPriceUSD) * formattedTotalSupplyInDecimals).toString();
+            maxMarketCap = (parseFloat(params.maxPriceUSD) * formattedTotalSupplyInDecimals).toString();
             if (params.currentPriceUSD) {
-                currentMarketCap = (params.currentPriceUSD * formattedTotalSupply).toString();
+                currentMarketCap = (params.currentPriceUSD * formattedTotalSupplyInDecimals).toString();
             }
         }
         let { tickLower, tickUpper, currentTick } = await this.calculateAddLiquidityTicks({
@@ -27119,12 +27117,11 @@ class ReadFlaunchSDK {
             currentMarketCap = params.currentMarketCap;
         }
         else {
-            const { totalSupply, decimals } = await this.getCoinInfo(coinAddress);
-            const formattedTotalSupply = parseFloat(formatUnits$1(totalSupply, decimals));
-            minMarketCap = (parseFloat(params.minPriceUSD) * formattedTotalSupply).toString();
-            maxMarketCap = (parseFloat(params.maxPriceUSD) * formattedTotalSupply).toString();
+            const { formattedTotalSupplyInDecimals } = await this.getCoinInfo(coinAddress);
+            minMarketCap = (parseFloat(params.minPriceUSD) * formattedTotalSupplyInDecimals).toString();
+            maxMarketCap = (parseFloat(params.maxPriceUSD) * formattedTotalSupplyInDecimals).toString();
             if (params.currentPriceUSD) {
-                currentMarketCap = (params.currentPriceUSD * formattedTotalSupply).toString();
+                currentMarketCap = (params.currentPriceUSD * formattedTotalSupplyInDecimals).toString();
             }
         }
         let { tickLower, tickUpper, currentTick } = await this.calculateAddLiquidityTicks({
@@ -27788,12 +27785,12 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
                 initialMarketCapUSD = params.initialMarketCapUSD;
             }
             else {
-                const { totalSupply, decimals } = await this.getCoinInfo(coinAddress);
-                const formattedTotalSupply = parseFloat(formatUnits$1(totalSupply, decimals));
-                minMarketCap = (parseFloat(params.minPriceUSD) * formattedTotalSupply).toString();
-                maxMarketCap = (parseFloat(params.maxPriceUSD) * formattedTotalSupply).toString();
+                const { formattedTotalSupplyInDecimals } = await this.getCoinInfo(coinAddress);
+                minMarketCap = (parseFloat(params.minPriceUSD) * formattedTotalSupplyInDecimals).toString();
+                maxMarketCap = (parseFloat(params.maxPriceUSD) * formattedTotalSupplyInDecimals).toString();
                 if (params.initialPriceUSD) {
-                    initialMarketCapUSD = params.initialPriceUSD * formattedTotalSupply;
+                    initialMarketCapUSD =
+                        params.initialPriceUSD * formattedTotalSupplyInDecimals;
                 }
             }
             const calculated = await this.calculateAddLiquidityAmounts({
@@ -27963,18 +27960,27 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
         calls.push(this.createLiquidityCall(poolKey, tickLower, tickUpper, finalLiquidity, finalAmount0, finalAmount1, userAddress));
         return calls;
     }
-    /**
-     * Gets the calls needed to import a memecoin to Flaunch and add liquidity to AnyPositionManager as a batch
-     * @param params - Parameters for importing and adding liquidity
-     * @returns Array of calls with descriptions
-     */
+    // Implementation with union type for internal use
     async getImportAndAddLiquidityCalls(params) {
-        const importParams = await this.readWriteTokenImporter.getInitializeParams({
-            coinAddress: params.coinAddress,
-            creatorFeeAllocationPercent: params.creatorFeeAllocationPercent,
-            initialMarketCapUSD: params.initialMarketCapUSD,
-            verifier: params.verifier,
-        });
+        let importParams;
+        if ("initialMarketCapUSD" in params) {
+            const paramsWithMarketCap = params;
+            importParams = await this.readWriteTokenImporter.getInitializeParams({
+                coinAddress: paramsWithMarketCap.coinAddress,
+                creatorFeeAllocationPercent: paramsWithMarketCap.creatorFeeAllocationPercent,
+                initialMarketCapUSD: paramsWithMarketCap.initialMarketCapUSD,
+                verifier: paramsWithMarketCap.verifier,
+            });
+        }
+        else {
+            const paramsWithPrice = params;
+            importParams = await this.readWriteTokenImporter.getInitializeParams({
+                coinAddress: paramsWithPrice.coinAddress,
+                creatorFeeAllocationPercent: paramsWithPrice.creatorFeeAllocationPercent,
+                initialPriceUSD: paramsWithPrice.initialPriceUSD,
+                verifier: paramsWithPrice.verifier,
+            });
+        }
         const addLiquidityCalls = await this.getAddLiquidityCalls({
             ...params,
             version: FlaunchVersion.ANY, // optimize to avoid fetching if not passed
@@ -27997,11 +28003,38 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
         const { coinAddress, coinAmount } = params;
         const version = await this.determineCoinVersion(coinAddress, params.version);
         const poolKey = this.createPoolKey(coinAddress, version);
-        // get the current tick from the pool
-        const poolState = await this.readStateView.poolSlot0({
-            poolId: getPoolId(poolKey),
-        });
-        const currentTick = poolState.tick;
+        let currentTick;
+        // if initial marketcap or price is provided, it means that the pool is not initialized yet
+        // so determining the currentTick
+        if (("initialMarketCapUSD" in params && params.initialMarketCapUSD) ||
+            ("initialPriceUSD" in params && params.initialPriceUSD)) {
+            const { decimals: coinDecimals, formattedTotalSupplyInDecimals } = await this.getCoinInfo(coinAddress);
+            // Determine market cap based on provided parameter
+            let initialMarketCapUSD;
+            if ("initialMarketCapUSD" in params && params.initialMarketCapUSD) {
+                initialMarketCapUSD = params.initialMarketCapUSD;
+            }
+            else if ("initialPriceUSD" in params && params.initialPriceUSD) {
+                initialMarketCapUSD =
+                    params.initialPriceUSD * formattedTotalSupplyInDecimals;
+            }
+            else {
+                throw new Error("Either initialMarketCapUSD or initialPriceUSD must be provided");
+            }
+            const marketContext = await this.getMarketContext(coinAddress, coinDecimals);
+            const calculatedTick = this.calculateCurrentTickFromMarketCap(initialMarketCapUSD.toString(), formattedTotalSupplyInDecimals, marketContext);
+            if (calculatedTick === undefined) {
+                throw new Error("Failed to calculate current tick from market cap");
+            }
+            currentTick = calculatedTick;
+        }
+        else {
+            // the pool is already initialized, get the current tick from the pool
+            const poolState = await this.readStateView.poolSlot0({
+                poolId: getPoolId(poolKey),
+            });
+            currentTick = poolState.tick;
+        }
         // We want to add liquidity from current price to infinity (as coin appreciates vs flETH)
         // This means providing single-sided coin liquidity that becomes active as coin price increases
         const isFLETHZero = this.flETHIsCurrencyZero(coinAddress);
@@ -28114,6 +28147,43 @@ class ReadWriteFlaunchSDK extends ReadFlaunchSDK {
         calls.push(this.createLiquidityCall(poolKey, tickLower, tickUpper, finalLiquidity, finalAmount0, finalAmount1, userAddress));
         return calls;
     }
+    // Implementation with union type for internal use
+    async getImportAndSingleSidedCoinAddLiquidityCalls(params) {
+        let importParams;
+        if ("initialMarketCapUSD" in params) {
+            const paramsWithMarketCap = params;
+            importParams = await this.readWriteTokenImporter.getInitializeParams({
+                coinAddress: paramsWithMarketCap.coinAddress,
+                creatorFeeAllocationPercent: paramsWithMarketCap.creatorFeeAllocationPercent,
+                initialMarketCapUSD: paramsWithMarketCap.initialMarketCapUSD,
+                verifier: paramsWithMarketCap.verifier,
+            });
+        }
+        else {
+            const paramsWithPrice = params;
+            importParams = await this.readWriteTokenImporter.getInitializeParams({
+                coinAddress: paramsWithPrice.coinAddress,
+                creatorFeeAllocationPercent: paramsWithPrice.creatorFeeAllocationPercent,
+                initialPriceUSD: paramsWithPrice.initialPriceUSD,
+                verifier: paramsWithPrice.verifier,
+            });
+        }
+        const addLiquidityCalls = await this.getSingleSidedCoinAddLiquidityCalls({
+            ...params,
+            version: FlaunchVersion.ANY, // optimize to avoid fetching if not passed
+        });
+        return [
+            {
+                to: this.readWriteTokenImporter.contract.address,
+                data: this.readWriteTokenImporter.contract.encodeFunctionData("initialize", importParams),
+                description: "Import Memecoin to Flaunch",
+            },
+            ...addLiquidityCalls,
+        ];
+    }
+    /**
+     * === Private helper functions ===
+     */
     /**
      * Calculates and constrains liquidity amounts for a position
      * @param currentTick - Current pool tick