100x-sdk 1.0.4 → 1.0.6

package/src/idl/fun100x_main.json

@@ -1,5 +1,5 @@
 {
-  "address": "sGecRTjTZmnqJBmLK4ZMNCzsaMrgkFfNqEcYk1GhRde",
+  "address": "EVNaaiyg9z876PUmLCVQcdc5L5eJukT4pni5GtVJ8P37",
   "metadata": {
     "name": "fun100x",
     "version": "0.1.0",
@@ -3013,271 +3013,281 @@
     },
     {
       "code": 6062,
+      "name": "InsufficientLongPayerBalance",
+      "msg": "Payer wallet balance insufficient for long margin and fees"
+    },
+    {
+      "code": 6063,
+      "name": "InsufficientShortPayerBalance",
+      "msg": "Payer wallet balance insufficient for short margin and fees"
+    },
+    {
+      "code": 6064,
       "name": "InvalidAccountOwner",
       "msg": "Invalid account owner"
     },
     {
-      "code": 6063,
+      "code": 6065,
       "name": "SellAmountExceedsOrderAmount",
       "msg": "Sell amount exceeds order's token holdings"
     },
     {
-      "code": 6064,
+      "code": 6066,
       "name": "OrderNotExpiredMustCloseByOwner",
       "msg": "Non-expired order must be closed by owner"
     },
     {
-      "code": 6065,
+      "code": 6067,
       "name": "SettlementAddressMustBeOwnerAddress",
       "msg": "Settlement address must be owner address"
     },
     {
-      "code": 6066,
+      "code": 6068,
       "name": "BuyAmountExceedsOrderAmount",
       "msg": "Buy amount exceeds order's token holdings"
     },
     {
-      "code": 6067,
+      "code": 6069,
       "name": "InsufficientTradeAmount",
       "msg": "Trade amount below minimum requirement"
     },
     {
-      "code": 6068,
+      "code": 6070,
       "name": "SolAmountTooLarge",
       "msg": "SOL amount exceeds maximum limit (10000000 SOL per transaction)"
     },
     {
-      "code": 6069,
+      "code": 6071,
       "name": "RemainingTokenAmountTooSmall",
       "msg": "Remaining token amount below minimum trade requirement"
     },
     {
-      "code": 6070,
+      "code": 6072,
       "name": "TradeCooldownNotExpired",
       "msg": "Trade cooldown period not expired, please try again later"
     },
     {
-      "code": 6071,
+      "code": 6073,
       "name": "ExceedApprovalAmount",
       "msg": "Sell amount exceeds approved amount, please call approval function first"
     },
     {
-      "code": 6072,
+      "code": 6074,
       "name": "CooldownNotInitialized",
       "msg": "Sell trade requires calling approval or buy function first to initialize cooldown PDA"
     },
     {
-      "code": 6073,
+      "code": 6075,
       "name": "CannotCloseCooldownWithBalance",
       "msg": "Cannot close cooldown PDA with non-zero token balance"
     },
     {
-      "code": 6074,
+      "code": 6076,
       "name": "PriceCalculationError",
       "msg": "Price calculation error"
     },
     {
-      "code": 6075,
+      "code": 6077,
       "name": "InvalidPartnerFeeRecipientAccount",
       "msg": "Invalid partner fee recipient account"
     },
     {
-      "code": 6076,
+      "code": 6078,
       "name": "InvalidBaseFeeRecipientAccount",
       "msg": "Invalid base fee recipient account"
     },
     {
-      "code": 6077,
+      "code": 6079,
       "name": "InvalidOrderbookAddress",
       "msg": "Orderbook address does not match curve account orderbook"
     },
     {
-      "code": 6078,
+      "code": 6080,
       "name": "InvalidFeePercentage",
       "msg": "Fee percentage must be between 0-100"
     },
     {
-      "code": 6079,
+      "code": 6081,
       "name": "InvalidFeeRate",
       "msg": "Fee rate exceeds maximum limit (10%)"
     },
     {
-      "code": 6080,
+      "code": 6082,
       "name": "InvalidCustomFeeRate",
       "msg": "Custom fee rate must be between 1000 (1%) and 5000 (5%)"
     },
     {
-      "code": 6081,
+      "code": 6083,
       "name": "InvalidBorrowDuration",
       "msg": "Borrow duration out of valid range (3-30 days)"
     },
     {
-      "code": 6082,
+      "code": 6084,
       "name": "InvalidStopLossPrice",
       "msg": "Stop loss price does not meet minimum interval requirement"
     },
     {
-      "code": 6083,
+      "code": 6085,
       "name": "NoProfitableFunds",
       "msg": "No profitable funds to transfer"
     },
     {
-      "code": 6084,
+      "code": 6086,
       "name": "InsufficientPoolFunds",
       "msg": "Insufficient pool funds"
     },
     {
-      "code": 6085,
+      "code": 6087,
       "name": "InsufficientPoolBalance",
       "msg": "Pool SOL account balance would fall below minimum required balance"
     },
     {
-      "code": 6086,
+      "code": 6088,
       "name": "OrderBookManagerOverflow",
       "msg": "Math operation overflow"
     },
     {
-      "code": 6087,
+      "code": 6089,
       "name": "OrderBookManagerInvalidSlotIndex",
       "msg": "Invalid slot index"
     },
     {
-      "code": 6088,
+      "code": 6090,
       "name": "OrderBookManagerInvalidAccountData",
       "msg": "Invalid account data"
     },
     {
-      "code": 6089,
+      "code": 6091,
       "name": "OrderBookManagerExceedsMaxCapacity",
       "msg": "New capacity exceeds maximum limit"
     },
     {
-      "code": 6090,
+      "code": 6092,
       "name": "OrderBookManagerExceedsAccountSizeLimit",
       "msg": "Account size exceeds 10MB limit"
     },
     {
-      "code": 6091,
+      "code": 6093,
       "name": "OrderBookManagerOrderIdMismatch",
       "msg": "Order ID mismatch"
     },
     {
-      "code": 6092,
+      "code": 6094,
       "name": "OrderBookManagerEmptyOrderBook",
       "msg": "Order book is empty"
     },
     {
-      "code": 6093,
+      "code": 6095,
       "name": "OrderBookManagerAccountNotWritable",
       "msg": "Account is not writable"
     },
     {
-      "code": 6094,
+      "code": 6096,
       "name": "OrderBookManagerNotRentExempt",
       "msg": "Account not rent-exempt"
     },
     {
-      "code": 6095,
+      "code": 6097,
       "name": "OrderBookManagerInvalidRentBalance",
       "msg": "Invalid rent balance"
     },
     {
-      "code": 6096,
+      "code": 6098,
       "name": "OrderBookManagerInsufficientFunds",
       "msg": "Insufficient funds"
     },
     {
-      "code": 6097,
+      "code": 6099,
       "name": "OrderBookManagerInvalidAccountOwner",
       "msg": "OrderBook account owner mismatch"
     },
     {
-      "code": 6098,
+      "code": 6100,
       "name": "OrderBookManagerDataOutOfBounds",
       "msg": "Data access out of bounds"
     },
     {
-      "code": 6099,
+      "code": 6101,
       "name": "NoValidInsertPosition",
       "msg": "Cannot find valid insert position, all candidates failed due to price range overlap"
     },
     {
-      "code": 6100,
+      "code": 6102,
       "name": "EmptyCloseInsertIndices",
       "msg": "close_insert_indices array cannot be empty"
     },
     {
-      "code": 6101,
+      "code": 6103,
       "name": "TooManyCloseInsertIndices",
       "msg": "close_insert_indices array cannot exceed 20 elements"
     },
     {
-      "code": 6102,
+      "code": 6104,
       "name": "CloseOrderNotFound",
       "msg": "Specified close order not found"
     },
     {
-      "code": 6103,
+      "code": 6105,
       "name": "LinkedListDeleteCountMismatch",
       "msg": "Linked list delete count mismatch: count inconsistent before/after deletion"
     },
     {
-      "code": 6104,
+      "code": 6106,
       "name": "NameTooLong",
       "msg": "Token name too long, max 32 bytes"
     },
     {
-      "code": 6105,
+      "code": 6107,
       "name": "NameEmpty",
       "msg": "Token name cannot be empty"
     },
     {
-      "code": 6106,
+      "code": 6108,
       "name": "SymbolTooLong",
       "msg": "Token symbol too long, max 10 bytes"
     },
     {
-      "code": 6107,
+      "code": 6109,
       "name": "SymbolEmpty",
       "msg": "Token symbol cannot be empty"
     },
     {
-      "code": 6108,
+      "code": 6110,
       "name": "UriTooLong",
       "msg": "URI too long, max 200 bytes"
     },
     {
-      "code": 6109,
+      "code": 6111,
       "name": "UriEmpty",
       "msg": "URI cannot be empty"
     },
     {
-      "code": 6110,
+      "code": 6112,
       "name": "IncompleteAdvancedPoolParams",
       "msg": "Incomplete advanced pool parameters: custom_lp_sol, custom_lp_token, custom_borrow_ratio, custom_borrow_duration must be provided together"
     },
     {
-      "code": 6111,
+      "code": 6113,
       "name": "InvalidInitialVirtualSol",
       "msg": "Initial virtual SOL out of valid range"
     },
     {
-      "code": 6112,
+      "code": 6114,
       "name": "InvalidInitialVirtualToken",
       "msg": "Initial virtual Token out of valid range"
     },
     {
-      "code": 6113,
+      "code": 6115,
       "name": "InvalidBorrowPoolRatio",
       "msg": "Borrow pool ratio out of valid range"
     },
     {
-      "code": 6114,
+      "code": 6116,
       "name": "BorrowTokenCalculationOverflow",
       "msg": "Borrow pool token amount calculation overflow"
     },
     {
-      "code": 6115,
+      "code": 6117,
       "name": "BorrowTokenAmountZero",
       "msg": "Borrow pool token amount cannot be zero"
     }
@@ -3424,8 +3434,10 @@
             "name": "pool_type",
             "docs": [
               "Pool type",
-              "0 = Basic version (uses default parameters, supports fee halving)",
-              "1 = Advanced version (custom parameters, fees never halved)"
+              "0 = Basic version (uses default parameters)",
+              "1 = Advanced version (custom parameters)",
+              "Note: BOTH pool types participate in fee halving milestones",
+              "(dynamic thresholds at 100x/1000x/10000x of the pool's own initial price)"
             ],
             "type": "u8"
           },
@@ -3433,8 +3445,8 @@
             "name": "borrow_pool_ratio",
             "docs": [
               "Borrow pool token ratio (recorded only for information display)",
-              "Actual value range: 5-30 (represents 5%-30%)",
-              "Basic version fixed at 20"
+              "Actual value range: 2-8 (represents 2%-8%, deducted from total supply)",
+              "Basic version fixed at 4"
             ],
             "type": "u8"
           }

package/src/modules/simulator/buy_sell_token.js

@@ -1,6 +1,7 @@
 
 
 const { calcLiqTokenBuy, calcLiqTokenSell } = require('./calcLiq');
+const { formatRatio } = require('./precision');
 
 /**
  * Simulate token buy transaction - calculate if target token amount can be purchased
@@ -95,8 +96,7 @@ async function simulateTokenBuy(mint, buyTokenAmount, passOrder = null, lastPric
     if (freeTokenAmount >= buyTokenAmountBig) {
       completionPercentage = "100.0";
     } else {
-      const percentage = Math.floor((Number(freeTokenAmount) / Number(buyTokenAmountBig)) * 1000) / 10;
-      completionPercentage = percentage.toFixed(1);
+      completionPercentage = formatRatio(freeTokenAmount, buyTokenAmountBig, 1, 100n);
     }
 
     // 2. Calculate slippage percentage and get final SOL amount
@@ -107,8 +107,7 @@ async function simulateTokenBuy(mint, buyTokenAmount, passOrder = null, lastPric
     if (realSolAmount > 0n) {
       // Normal case: calculate slippage
       const diff = idealSolAmount > realSolAmount ? idealSolAmount - realSolAmount : realSolAmount - idealSolAmount;
-      const slippage = Math.floor((Number(diff) / Number(idealSolAmount)) * 1000) / 10;
-      slippagePercentage = slippage.toFixed(1);
+      slippagePercentage = formatRatio(diff, idealSolAmount, 1, 100n);
     } else {
       // Special case: real SOL amount is 0, need to recalculate with suggested liquidity
       const suggestedAmount = (freeTokenAmount * BigInt(this.sdk.SUGGEST_LIQ_RATIO)) / 1000n;
@@ -133,8 +132,7 @@ async function simulateTokenBuy(mint, buyTokenAmount, passOrder = null, lastPric
       finalRealSolAmount = recalcRealSol;
       
       const diff = recalcIdealSol > recalcRealSol ? recalcIdealSol - recalcRealSol : recalcRealSol - recalcIdealSol;
-      const slippage = Math.floor((Number(diff) / Number(recalcIdealSol)) * 1000) / 10;
-      slippagePercentage = slippage.toFixed(1);
+      slippagePercentage = formatRatio(diff, recalcIdealSol, 1, 100n);
     }
 
     // 3. Calculate suggested liquidity
@@ -253,8 +251,7 @@ async function simulateTokenSell(mint, sellTokenAmount, passOrder = null, lastPr
     if (freeTokenAmount >= sellTokenAmountBig) {
       completionPercentage = "100.0";
     } else {
-      const percentage = Math.floor((Number(freeTokenAmount) / Number(sellTokenAmountBig)) * 1000) / 10;
-      completionPercentage = percentage.toFixed(1);
+      completionPercentage = formatRatio(freeTokenAmount, sellTokenAmountBig, 1, 100n);
     }
 
     // 2. Calculate slippage percentage and get final SOL amount
@@ -265,8 +262,7 @@ async function simulateTokenSell(mint, sellTokenAmount, passOrder = null, lastPr
     if (realSolAmount > 0n) {
       // Normal case: calculate slippage
       const diff = idealSolAmount > realSolAmount ? idealSolAmount - realSolAmount : realSolAmount - idealSolAmount;
-      const slippage = Math.floor((Number(diff) / Number(idealSolAmount)) * 1000) / 10;
-      slippagePercentage = slippage.toFixed(1);
+      slippagePercentage = formatRatio(diff, idealSolAmount, 1, 100n);
     } else {
       // Special case: real SOL amount is 0, need to recalculate with suggested liquidity
       const suggestedAmount = (freeTokenAmount * BigInt(this.sdk.SUGGEST_LIQ_RATIO)) / 1000n;
@@ -291,8 +287,7 @@ async function simulateTokenSell(mint, sellTokenAmount, passOrder = null, lastPr
       finalRealSolAmount = recalcRealSol;
       
       const diff = recalcIdealSol > recalcRealSol ? recalcIdealSol - recalcRealSol : recalcRealSol - recalcIdealSol;
-      const slippage = Math.floor((Number(diff) / Number(recalcIdealSol)) * 1000) / 10;
-      slippagePercentage = slippage.toFixed(1);
+      slippagePercentage = formatRatio(diff, recalcIdealSol, 1, 100n);
     }
 
     // 3. Calculate suggested liquidity

package/src/modules/simulator/long_shrot_stop.js

@@ -4,6 +4,7 @@ const CurveAMM = require('../../utils/curve_amm');
 const {transformOrdersData , checkPriceRangeOverlap} = require('./stop_loss_utils')
 const { PRICE_ADJUSTMENT_PERCENTAGE, MIN_STOP_LOSS_PERCENT } = require('./utils');
 const JSONbig = require('json-bigint')({ storeAsString: false });
+const { formatRatio, ceilDiv } = require('./precision');
 
 /**
  * Simulate long position stop loss calculation
@@ -35,10 +36,11 @@ const JSONbig = require('json-bigint')({ storeAsString: false });
  *   - For example: 3.5 means the stop loss price is 3.5% lower than the current price
  *   - For a long position this value should be positive (stop loss price below current price)
  *
- * @returns {number} returns.leverage - Leverage ratio
+ * @returns {number} returns.leverage - Leverage ratio (existing four-decimal downward truncation)
  *   - Formula: currentPrice / (currentPrice - executableStopLossPrice)
  *   - For example: 28.57 means about 28.57x leverage
  *   - The higher the leverage, the higher the risk, but also the higher the potential return
+ * @returns {string} returns.leverageDisplay - Rounded display value derived from the executable stop-loss price; not a maximum leverage limit
  *
  * @returns {bigint} returns.currentPrice - Current price (u128 format)
  *   - The current token price used in the calculation
@@ -272,10 +274,17 @@ async function simulateLongStopLoss(mint, buyTokenAmount, stopLossPrice, lastPri
         // Calculate stop loss percentage
         let stopLossPercentage = 0;
         let leverage = 1;
+        let leverageDisplay = '1';
 
         if (currentPrice !== executableStopLossPrice) {
-            stopLossPercentage = Number((BigInt(10000) * (currentPrice - executableStopLossPrice)) / currentPrice) / 100;
-            leverage = Number((BigInt(10000) * currentPrice) / (currentPrice - executableStopLossPrice)) / 10000;
+            const priceDiff = currentPrice - executableStopLossPrice;
+            stopLossPercentage = priceDiff >= 0n
+                ? Number(formatRatio(priceDiff, currentPrice, 2, 100n))
+                : Number((10000n * priceDiff) / currentPrice) / 100;
+            leverage = Number((10000n * currentPrice) / priceDiff) / 10000;
+            leverageDisplay = priceDiff > 0n
+                ? formatRatio(currentPrice, priceDiff, 2, 1n, 'half-up', true)
+                : String(leverage);
         }
 
         // Calculate margin requirement
@@ -311,6 +320,7 @@ async function simulateLongStopLoss(mint, buyTokenAmount, stopLossPrice, lastPri
             tradeAmount: finalTradeAmount, // SOL output amount
             stopLossPercentage: stopLossPercentage, // Stop loss percentage relative to current price
             leverage: leverage, // Leverage ratio
+            leverageDisplay: leverageDisplay, // Rounded display value; leverage keeps its existing meaning
             currentPrice: currentPrice, // Current price
             iterations: iteration, // Number of adjustments
             originalStopLossPrice: BigInt(stopLossPrice), // Original stop loss price
@@ -355,10 +365,11 @@ async function simulateLongStopLoss(mint, buyTokenAmount, stopLossPrice, lastPri
  *   - For example: 3.5 means the stop loss price is 3.5% higher than the current price
  *   - For a short position this value should be positive (stop loss price above current price)
  *
- * @returns {number} returns.leverage - Leverage ratio
+ * @returns {number} returns.leverage - Leverage ratio (existing four-decimal downward truncation)
  *   - Formula: currentPrice / (executableStopLossPrice - currentPrice)
  *   - For example: 28.57 means about 28.57x leverage
  *   - The higher the leverage, the higher the risk, but also the higher the potential return
+ * @returns {string} returns.leverageDisplay - Rounded display value derived from the executable stop-loss price; not a maximum leverage limit
  *
  * @returns {bigint} returns.currentPrice - Current price (u128 format)
  *   - The current token price used in the calculation
@@ -584,11 +595,17 @@ async function simulateShortStopLoss(mint, sellTokenAmount, stopLossPrice, lastP
 
         // Calculate stop loss percentage
         // For short position, stop loss price is higher than current price, so it's a positive percentage
-        const stopLossPercentage = Number((BigInt(10000) * (executableStopLossPrice - currentPrice)) / currentPrice) / 100;
+        const priceDiff = executableStopLossPrice - currentPrice;
+        const stopLossPercentage = priceDiff >= 0n
+            ? Number(formatRatio(priceDiff, currentPrice, 2, 100n))
+            : Number((10000n * priceDiff) / currentPrice) / 100;
 
         // Calculate leverage ratio
         // For short position, leverage = current price / (stop loss price - current price)
-        const leverage = Number((BigInt(10000) * currentPrice) / (executableStopLossPrice - currentPrice)) / 10000;
+        const leverage = Number((10000n * currentPrice) / priceDiff) / 10000;
+        const leverageDisplay = priceDiff > 0n
+            ? formatRatio(currentPrice, priceDiff, 2, 1n, 'half-up', true)
+            : String(leverage);
 
         // Calculate margin requirement
         // Consistent with the contract formula (long_short.rs lines 890-894):
@@ -628,6 +645,7 @@ async function simulateShortStopLoss(mint, sellTokenAmount, stopLossPrice, lastP
             tradeAmount: finalTradeAmount, // SOL input amount (SOL needed to buy back tokens at close)
             stopLossPercentage: stopLossPercentage, // Stop loss percentage relative to current price
             leverage: leverage, // Leverage ratio
+            leverageDisplay: leverageDisplay, // Rounded display value; leverage keeps its existing meaning
             currentPrice: currentPrice, // Current price
             iterations: iteration, // Number of adjustments
             originalStopLossPrice: BigInt(stopLossPrice), // Original stop loss price
@@ -755,8 +773,9 @@ async function simulateLongSolStopLoss(mint, buySolAmount, stopLossPrice, lastPr
         // Calculate dynamic binary search upper bound based on leverage
         const stopLossPriceBigInt = BigInt(stopLossPrice);
         const priceDiff = currentPrice - stopLossPriceBigInt;
-        const estimatedLeverage = priceDiff > 0n ? Number(currentPrice * 10000n / priceDiff) / 10000 : 10;
-        const safeMultiplier = BigInt(Math.ceil(estimatedLeverage * 3)); // 3x safety factor
+        // Keep the original four-decimal leverage truncation used to size the search range.
+        const scaledLeverage = priceDiff > 0n ? currentPrice * 10000n / priceDiff : 100000n;
+        const safeMultiplier = ceilDiv(scaledLeverage * 3n, 10000n); // 3x safety factor
         const multiplier = safeMultiplier > 10n ? safeMultiplier : 10n; // minimum 10x
 
         // Use a binary search algorithm to find the maximum estimatedMargin that is less than buySolAmount
@@ -941,8 +960,9 @@ async function simulateShortSolStopLoss(mint, sellSolAmount, stopLossPrice, last
         // Calculate dynamic binary search upper bound based on leverage
         const stopLossPriceBigInt = BigInt(stopLossPrice);
         const priceDiff = stopLossPriceBigInt - currentPrice;
-        const estimatedLeverage = priceDiff > 0n ? Number(currentPrice * 10000n / priceDiff) / 10000 : 10;
-        const safeMultiplier = BigInt(Math.ceil(estimatedLeverage * 3)); // 3x safety factor
+        // Keep the original four-decimal leverage truncation used to size the search range.
+        const scaledLeverage = priceDiff > 0n ? currentPrice * 10000n / priceDiff : 100000n;
+        const safeMultiplier = ceilDiv(scaledLeverage * 3n, 10000n); // 3x safety factor
         const multiplier = safeMultiplier > 10n ? safeMultiplier : 10n; // minimum 10x
 
         // Use a binary search algorithm to find the maximum estimatedMargin that is less than sellSolAmount

package/src/modules/simulator/precision.js

@@ -0,0 +1,32 @@
+/** Format a non-negative integer ratio without converting its operands to Number. */
+function formatRatio(numerator, denominator, decimals, multiplier = 1n, rounding = 'down', trim = false) {
+  numerator = BigInt(numerator);
+  denominator = BigInt(denominator);
+  if (numerator < 0n || denominator <= 0n || !Number.isInteger(decimals) || decimals < 0) {
+    throw new RangeError('Invalid ratio');
+  }
+
+  const factor = 10n ** BigInt(decimals);
+  const scaledNumerator = numerator * multiplier * factor;
+  let quotient = scaledNumerator / denominator;
+  if (rounding === 'half-up') {
+    if ((scaledNumerator % denominator) * 2n >= denominator) quotient++;
+  } else if (rounding !== 'down') {
+    throw new RangeError('Invalid rounding mode');
+  }
+
+  if (decimals === 0) return quotient.toString();
+  const integer = quotient / factor;
+  const fraction = (quotient % factor).toString().padStart(decimals, '0');
+  const value = `${integer}.${fraction}`;
+  return trim ? value.replace(/\.?0+$/, '') : value;
+}
+
+function ceilDiv(numerator, denominator) {
+  numerator = BigInt(numerator);
+  denominator = BigInt(denominator);
+  if (numerator < 0n || denominator <= 0n) throw new RangeError('Invalid division');
+  return (numerator + denominator - 1n) / denominator;
+}
+
+module.exports = { formatRatio, ceilDiv };

package/src/modules/simulator.js

@@ -339,9 +339,9 @@ class SimulatorModule {
             const tokenSellResult = await this.simulateTokenSell(mint, tokenAmountBigInt, null, priceResult, ordersResult);
 
             // Estimate ideal SOL amount
-            const priceDecimal = CurveAMM.u128ToDecimal(currentPrice);
-            const tokenInDecimal = Number(tokenAmountBigInt) / 1e9; // Convert token lamports to tokens (9-digit precision)
-            const estimatedSolAmount = BigInt(Math.floor((tokenInDecimal * priceDecimal) * 1e9)); // Convert to SOL lamports
+            // Token and SOL both use 9 decimals, so their unit conversions cancel out.
+            const priceScale = BigInt(CurveAMM.PRICE_PRECISION_FACTOR_DECIMAL.toFixed(0));
+            const estimatedSolAmount = tokenAmountBigInt * currentPrice / priceScale;
 
             // Transform result to match simulateSell format
             return {

package/src/types/index.d.ts

@@ -187,6 +187,26 @@ export interface SimulationResult {
   suggestedSolAmount: string;
 }
 
+/** The leverage implied by the executable stop-loss price, not a maximum limit. */
+export interface StopLossSimulationResult {
+  executableStopLossPrice: bigint;
+  tradeAmount: bigint;
+  stopLossPercentage: number;
+  /** Existing four-decimal, downward-truncated value. */
+  leverage: number;
+  /** Rounded to two decimals from the original price ratio, with trailing zeros removed. Display only. */
+  leverageDisplay: string;
+  currentPrice: bigint;
+  iterations: number;
+  originalStopLossPrice: bigint;
+  close_insert_indices: number[];
+  estimatedMargin: bigint;
+  rawSellSol?: bigint;
+  buyTokenAmount?: bigint;
+  sellTokenAmount?: bigint;
+  adjustmentIterations?: number;
+}
+
 // ========================= Utility Related Types =========================
 
 export interface FindPrevNextResult {
@@ -238,8 +258,10 @@ export interface ParamModule {
 export interface SimulatorModule {
   simulateTokenBuy(mint: string, buyTokenAmount: bigint | string | number, passOrder?: string | null): Promise<SimulationResult>;
   simulateTokenSell(mint: string, sellTokenAmount: bigint | string | number, passOrder?: string | null): Promise<SimulationResult>;
-  simulateLongStopLoss(mint: string, buyTokenAmount: bigint | string | number, stopLossPrice: bigint | string | number, lastPrice?: any, ordersData?: any): Promise<any>;
-  simulateSellStopLoss(mint: string, sellTokenAmount: bigint | string | number, stopLossPrice: bigint | string | number, lastPrice?: any, ordersData?: any): Promise<any>;
+  simulateLongStopLoss(mint: string, buyTokenAmount: bigint | string | number, stopLossPrice: bigint | string | number, lastPrice?: any, ordersData?: any, borrowFee?: number | null): Promise<StopLossSimulationResult>;
+  simulateShortStopLoss(mint: string, sellTokenAmount: bigint | string | number, stopLossPrice: bigint | string | number, lastPrice?: any, ordersData?: any, borrowFee?: number | null): Promise<StopLossSimulationResult>;
+  simulateLongSolStopLoss(mint: string, buySolAmount: bigint | string | number, stopLossPrice: bigint | string | number, lastPrice?: any, ordersData?: any, borrowFee?: number | null, initialVirtualSol?: string | number | null, initialVirtualToken?: string | number | null, curveAccount?: any): Promise<StopLossSimulationResult>;
+  simulateShortSolStopLoss(mint: string, sellSolAmount: bigint | string | number, stopLossPrice: bigint | string | number, lastPrice?: any, ordersData?: any, borrowFee?: number | null, initialVirtualSol?: string | number | null, initialVirtualToken?: string | number | null, curveAccount?: any): Promise<StopLossSimulationResult>;
 }
 
 // ========================= Data Interface Types =========================