@gala-chain/launchpad 1.0.13 → 1.0.15

package/src/chaincode/launchpad/buyWithNative.ts

@@ -12,22 +12,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { TokenClass, ValidationFailedError } from "@gala-chain/api";
-import {
-  GalaChainContext,
-  fetchOrCreateBalance,
-  fetchTokenClass,
-  getObjectByKey,
-  putChainObject,
-  transferToken
-} from "@gala-chain/chaincode";
+import { GalaChainContext, fetchTokenClass, putChainObject, transferToken } from "@gala-chain/chaincode";
 import BigNumber from "bignumber.js";
 
-import { ExactTokenQuantityDto, LaunchpadSale, NativeTokenQuantityDto, TradeResDto } from "../../api/types";
+import { LaunchpadSale, NativeTokenQuantityDto, TradeResDto } from "../../api/types";
 import { SlippageToleranceExceededError } from "../../api/utils/error";
-import { fetchAndValidateSale, fetchLaunchpadFeeAddress } from "../utils";
+import { fetchAndValidateSale } from "../utils";
 import { callMemeTokenOut } from "./callMemeTokenOut";
-import { callNativeTokenIn } from "./callNativeTokenIn";
+import { transferTransactionFees } from "./fees";
 import { finalizeSale } from "./finaliseSale";
 
 /**
@@ -56,83 +48,41 @@ export async function buyWithNative(
 
   // Fetch and validate sale state
   const sale = await fetchAndValidateSale(ctx, buyTokenDTO.vaultAddress);
-  const tokensLeftInVault = new BigNumber(sale.sellingTokenQuantity);
 
   // Calculate how many tokens the user can buy and fee info
   const callMemeTokenOutResult = await callMemeTokenOut(ctx, buyTokenDTO);
-  let transactionFees = callMemeTokenOutResult.extraFees.transactionFees;
-  let tokensToBuy = new BigNumber(callMemeTokenOutResult.calculatedQuantity);
+  const transactionFees = new BigNumber(callMemeTokenOutResult.extraFees.transactionFees); // transaction fees
+  const nativeTokensRequired = new BigNumber(callMemeTokenOutResult.originalQuantity); // number of native tokens user wants to spend
+  const tokensToBuy = new BigNumber(callMemeTokenOutResult.calculatedQuantity); // number of tokens user will be buying
 
   const nativeToken = sale.fetchNativeTokenInstanceKey();
   const memeToken = sale.fetchSellingTokenInstanceKey();
 
-  // Round tokensToBuy based on decimals property of sellToken TokenClass entry,
-  // because otherwise `transferToken()` call below will fail with
-  // an INVALID_DECIMALS error.
-  const { collection, category, type, additionalKey } = sale.sellingToken;
-
-  const memeTokenClass = await getObjectByKey(
-    ctx,
-    TokenClass,
-    TokenClass.getCompositeKeyFromParts(TokenClass.INDEX_KEY, [collection, category, type, additionalKey])
-  );
-
-  tokensToBuy = tokensToBuy.decimalPlaces(memeTokenClass.decimals);
-
-  // If vault has fewer tokens than what user wants to buy, cap the purchase
-  if (tokensLeftInVault.comparedTo(tokensToBuy) <= 0) {
-    tokensToBuy = tokensLeftInVault.decimalPlaces(memeTokenClass.decimals);
-    const nativeTokensRequiredToBuyDto = new ExactTokenQuantityDto(buyTokenDTO.vaultAddress, tokensToBuy);
-    const callNativeTokenInResult = await callNativeTokenIn(ctx, nativeTokensRequiredToBuyDto);
-    transactionFees = callMemeTokenOutResult.extraFees.transactionFees;
-    buyTokenDTO.nativeTokenQuantity = new BigNumber(callNativeTokenInResult.calculatedQuantity);
-    isSaleFinalized = true;
-  }
-
-  // Finalize sale if market cap is reached
+  // If native tokens required exceeds the market cap, the sale can be finalized
   if (
     buyTokenDTO.nativeTokenQuantity
       .plus(new BigNumber(sale.nativeTokenQuantity))
-      .gte(new BigNumber(LaunchpadSale.MARKET_CAP))
+      .isGreaterThanOrEqualTo(new BigNumber(LaunchpadSale.MARKET_CAP))
   ) {
     isSaleFinalized = true;
   }
 
   // Check for slippage condition
-  if (buyTokenDTO.expectedToken && buyTokenDTO.expectedToken.comparedTo(tokensToBuy) > 0) {
+  if (buyTokenDTO.expectedToken && buyTokenDTO.expectedToken.isGreaterThan(tokensToBuy)) {
     throw new SlippageToleranceExceededError(
       `expected ${buyTokenDTO.expectedToken.toString()}, but only ${tokensToBuy.toString()} tokens can be provided. Reduce the expected amount or adjust your slippage tolerance.`
     );
   }
 
   // Transfer transaction fees to launchpad fee address
-  const launchpadFeeAddressConfiguration = await fetchLaunchpadFeeAddress(ctx);
-  if (launchpadFeeAddressConfiguration && transactionFees) {
-    const totalRequired = new BigNumber(buyTokenDTO.nativeTokenQuantity).plus(transactionFees);
-
-    const buyerBalance = await fetchOrCreateBalance(ctx, ctx.callingUser, sale.nativeToken);
-    if (buyerBalance.getQuantityTotal().lt(totalRequired)) {
-      throw new ValidationFailedError(
-        `Insufficient balance: Total amount required including fee is ${totalRequired}`
-      );
-    }
-
-    await transferToken(ctx, {
-      from: ctx.callingUser,
-      to: launchpadFeeAddressConfiguration.feeAddress,
-      tokenInstanceKey: nativeToken,
-      quantity: new BigNumber(transactionFees),
-      allowancesToUse: [],
-      authorizedOnBehalf: undefined
-    });
-  }
+  await transferTransactionFees(ctx, sale, transactionFees, nativeToken, nativeTokensRequired);
 
   // Transfer native tokens from buyer to vault
   await transferToken(ctx, {
     from: ctx.callingUser,
     to: buyTokenDTO.vaultAddress,
     tokenInstanceKey: nativeToken,
-    quantity: buyTokenDTO.nativeTokenQuantity,
+    quantity: nativeTokensRequired,
     allowancesToUse: [],
     authorizedOnBehalf: undefined
   });
@@ -151,7 +101,7 @@ export async function buyWithNative(
   });
 
   // Update sale object with purchase data
-  sale.buyToken(tokensToBuy, buyTokenDTO.nativeTokenQuantity);
+  sale.buyToken(tokensToBuy, nativeTokensRequired);
   await putChainObject(ctx, sale);
 
   // Finalize sale if it's complete
@@ -161,8 +111,8 @@ export async function buyWithNative(
 
   const token = await fetchTokenClass(ctx, sale.sellingToken);
   return {
-    inputQuantity: buyTokenDTO.nativeTokenQuantity.toFixed(),
-    totalFees: transactionFees,
+    inputQuantity: nativeTokensRequired.toFixed(),
+    totalFees: transactionFees.toFixed(),
     outputQuantity: tokensToBuy.toFixed(),
     tokenName: token.name,
     tradeType: "Buy",

package/src/chaincode/launchpad/callMemeTokenIn.ts

@@ -17,14 +17,27 @@ import { GalaChainContext } from "@gala-chain/chaincode";
 import BigNumber from "bignumber.js";
 import Decimal from "decimal.js";
 
-import { LaunchpadSale, NativeTokenQuantityDto } from "../../api/types";
-import { fetchAndValidateSale, fetchLaunchpadFeeAddress, getBondingConstants } from "../utils";
+import { LaunchpadSale, NativeTokenQuantityDto, TradeCalculationResDto } from "../../api/types";
+import {
+  fetchAndValidateSale,
+  fetchLaunchpadFeeAddress,
+  fetchTokenDecimals,
+  getBondingConstants
+} from "../utils";
 import { calculateReverseBondingCurveFee, calculateTransactionFee } from "./fees";
 
-function calculateMemeTokensRequired(sale: LaunchpadSale, requestedNativeTokenQuantity: BigNumber) {
+function calculateMemeTokensRequired(
+  sale: LaunchpadSale,
+  requestedNativeTokenQuantity: BigNumber,
+  nativeTokenDecimals: number,
+  sellingTokenDecimals: number
+): [string, string] {
   const totalTokensSold = new Decimal(sale.fetchTokensSold()); // current tokens sold / x
-  let nativeTokens = new Decimal(requestedNativeTokenQuantity.toString()); // native tokens used to buy / y
-  const basePrice = new Decimal(sale.fetchBasePrice()); // base price / a
+  let nativeTokens = new Decimal(requestedNativeTokenQuantity.toString()).toDecimalPlaces(
+    nativeTokenDecimals,
+    Decimal.ROUND_DOWN
+  );
+  const basePrice = new Decimal(LaunchpadSale.BASE_PRICE); // base price / a
   const { exponentFactor, euler, decimals } = getBondingConstants();
 
   const nativeTokenInVault = new Decimal(sale.nativeTokenQuantity);
@@ -36,16 +49,16 @@ function calculateMemeTokensRequired(sale: LaunchpadSale, requestedNativeTokenQu
   const exp1 = euler.pow(exponent);
   const constantFactor = nativeTokens.mul(exponentFactor).div(basePrice);
 
-  if (exp1.lte(constantFactor)) {
+  if (exp1.lessThanOrEqualTo(constantFactor)) {
     throw new ValidationFailedError("Cannot sell more tokens than have been bought in this sale.");
   }
 
   const adjustedExp = exp1.minus(constantFactor);
   const lnAdjustedExp = adjustedExp.ln();
   const tokensSent = totalTokensSold.minus(lnAdjustedExp.mul(decimals).div(exponentFactor));
-  const roundedTokenSent = tokensSent.toDecimalPlaces(18, Decimal.ROUND_UP);
+  const roundedTokenSent = tokensSent.toDecimalPlaces(sellingTokenDecimals, Decimal.ROUND_UP);
 
-  return roundedTokenSent.toFixed();
+  return [nativeTokens.toFixed(), roundedTokenSent.toFixed()];
 }
 
 /**
@@ -61,17 +74,28 @@ function calculateMemeTokensRequired(sale: LaunchpadSale, requestedNativeTokenQu
  *   - `nativeTokenAmount`: The amount of native tokens to be recieved from sale.
  *   - `expectedToken` (optional): The expected amount of tokens to be sold.
  *
- * @returns A promise that resolves to a string representing the calculated amount of
- *          tokens to be sent, rounded up to 18 decimal places.
+ * @returns A promise that resolves to a TradeCalculationResDto object containing the calculated
+ * quantity of tokens to be sent, the original quantity of native tokens used, and extra fees.
  *
  * @throws Error if the calculation results in an invalid amount (e.g., `InvalidAmountError`).
  */
-export async function callMemeTokenIn(ctx: GalaChainContext, sellTokenDTO: NativeTokenQuantityDto) {
+export async function callMemeTokenIn(
+  ctx: GalaChainContext,
+  sellTokenDTO: NativeTokenQuantityDto
+): Promise<TradeCalculationResDto> {
   const sale = await fetchAndValidateSale(ctx, sellTokenDTO.vaultAddress);
   const launchpadFeeAddressConfiguration = await fetchLaunchpadFeeAddress(ctx);
+  const { nativeTokenDecimals, sellingTokenDecimals } = await fetchTokenDecimals(ctx, sale);
+  const [originalQuantity, calculatedQuantity] = calculateMemeTokensRequired(
+    sale,
+    sellTokenDTO.nativeTokenQuantity,
+    nativeTokenDecimals,
+    sellingTokenDecimals
+  );
 
   return {
-    calculatedQuantity: calculateMemeTokensRequired(sale, sellTokenDTO.nativeTokenQuantity),
+    originalQuantity: originalQuantity,
+    calculatedQuantity: calculatedQuantity,
     extraFees: {
       reverseBondingCurve: calculateReverseBondingCurveFee(sale, sellTokenDTO.nativeTokenQuantity).toString(),
       transactionFees: calculateTransactionFee(

package/src/chaincode/launchpad/callMemeTokenOut.spec.ts

@@ -111,7 +111,7 @@ describe("callMemeTokenOut", () => {
 
     // // Then
     expect(response.Data).toMatchObject({
-      calculatedQuantity: "58497.530004606452819",
+      calculatedQuantity: "58497.5300046064",
       extraFees: { reverseBondingCurve: "0", transactionFees: "0.00000000" }
     });
   });
@@ -143,7 +143,7 @@ describe("callMemeTokenOut", () => {
 
     // Then
     expect(response.Data).toMatchObject({
-      calculatedQuantity: "458291.30295364487969",
+      calculatedQuantity: "458291.302953644",
       extraFees: { reverseBondingCurve: "0", transactionFees: "0.00000000" }
     });
   });

package/src/chaincode/launchpad/callMemeTokenOut.ts

@@ -16,10 +16,53 @@ import { GalaChainContext } from "@gala-chain/chaincode";
 import BigNumber from "bignumber.js";
 import Decimal from "decimal.js";
 
-import { LaunchpadSale, NativeTokenQuantityDto } from "../../api/types";
-import { fetchAndValidateSale, fetchLaunchpadFeeAddress, getBondingConstants } from "../utils";
+import { LaunchpadSale, NativeTokenQuantityDto, TradeCalculationResDto } from "../../api/types";
+import {
+  fetchAndValidateSale,
+  fetchLaunchpadFeeAddress,
+  fetchTokenDecimals,
+  getBondingConstants
+} from "../utils";
 import { calculateTransactionFee } from "./fees";
 
+function calculateTokensPurchasable(
+  nativeTokens: Decimal,
+  totalTokensSold: Decimal,
+  nativeTokenDecimals: number,
+  sellingTokenDecimals: number
+): [string, string] {
+  const basePrice = new Decimal(LaunchpadSale.BASE_PRICE);
+  const { exponentFactor, euler, decimals } = getBondingConstants();
+
+  // Round native tokens, then calculate tokens based on that rounded amount
+  const roundedNativeTokens = nativeTokens.toDecimalPlaces(nativeTokenDecimals, Decimal.ROUND_UP);
+
+  // Calculate tokens purchasable: newTokens = (decimals / exponentFactor) * ln((nativeTokens * exponentFactor / basePrice) + e^(exponentFactor * totalTokensSold / decimals)) - totalTokensSold
+  // Where:
+  //   constant = nativeTokens * exponentFactor / basePrice
+  //   exponent1 = exponentFactor * totalTokensSold / decimals
+  //   eResult1 = e^(exponent1) = e^(exponentFactor * totalTokensSold / decimals)
+  //   ethScaled = constant + eResult1 = (nativeTokens * exponentFactor / basePrice) + e^(exponentFactor * totalTokensSold / decimals)
+  //   lnEthScaled = ln(ethScaled) * decimals
+  //   lnEthScaledBase = lnEthScaled / exponentFactor = (decimals / exponentFactor) * ln(ethScaled)
+  //   result = lnEthScaledBase - totalTokensSold
+  const constant = roundedNativeTokens.mul(exponentFactor).div(basePrice);
+  const exponent1 = exponentFactor.mul(totalTokensSold).div(decimals);
+  const eResult1 = euler.pow(exponent1);
+  const ethScaled = constant.add(eResult1);
+  const lnEthScaled = ethScaled.ln().mul(decimals);
+  const lnEthScaledBase = lnEthScaled.div(exponentFactor);
+  const result = lnEthScaledBase.minus(totalTokensSold);
+  let roundedResult = result.toDecimalPlaces(sellingTokenDecimals, Decimal.ROUND_DOWN);
+
+  // Cap total supply to 10 million
+  if (roundedResult.add(totalTokensSold).greaterThan(new Decimal("1e+7"))) {
+    roundedResult = new Decimal("1e+7").minus(new Decimal(totalTokensSold));
+  }
+
+  return [roundedNativeTokens.toFixed(), roundedResult.toFixed()];
+}
+
 /**
  * Calculates the number of tokens that can be purchased using a specified amount
  * of native tokens based on a bonding curve mechanism.
@@ -31,12 +74,15 @@ import { calculateTransactionFee } from "./fees";
  * @param buyTokenDTO - The data transfer object containing the sale address
  *                      and the amount of native tokens to spend for the purchase.
  *
- * @returns A promise that resolves to a string representing the calculated amount of
- *          tokens to be received, rounded down to 18 decimal places.
+ * @returns A promise that resolves to a TradeCalculationResDto object containing the calculated
+ * quantity of tokens to be received, the original quantity of native tokens used, and extra fees.
  *
  * @throws Error if the calculation results in an invalid state.
  */
-export async function callMemeTokenOut(ctx: GalaChainContext, buyTokenDTO: NativeTokenQuantityDto) {
+export async function callMemeTokenOut(
+  ctx: GalaChainContext,
+  buyTokenDTO: NativeTokenQuantityDto
+): Promise<TradeCalculationResDto> {
   // Convert input amount to Decimal
   let nativeTokens = new Decimal(buyTokenDTO.nativeTokenQuantity.toString());
 
@@ -44,11 +90,13 @@ export async function callMemeTokenOut(ctx: GalaChainContext, buyTokenDTO: Nativ
   let totalTokensSold = new Decimal(0);
 
   // Fetch sale details and update parameters if this is not a sale premint calculation
+  let sale: LaunchpadSale | undefined;
   if (!buyTokenDTO.IsPreMint) {
-    const sale = await fetchAndValidateSale(ctx, buyTokenDTO.vaultAddress);
+    sale = await fetchAndValidateSale(ctx, buyTokenDTO.vaultAddress);
     totalTokensSold = new Decimal(sale.fetchTokensSold());
 
-    // Enforce market cap limit
+    // Enforce market cap limit, adjust number of native tokens that will be used in the transaction
+    // if total GALA tokens will exceed the market cap
     if (
       nativeTokens
         .add(new Decimal(sale.nativeTokenQuantity))
@@ -58,34 +106,32 @@ export async function callMemeTokenOut(ctx: GalaChainContext, buyTokenDTO: Nativ
     }
   }
 
-  // Load bonding curve constants
-  const basePrice = new Decimal(LaunchpadSale.BASE_PRICE);
-  const { exponentFactor, euler, decimals } = getBondingConstants();
+  // Get token decimals for rounding
+  const { nativeTokenDecimals, sellingTokenDecimals } = sale
+    ? await fetchTokenDecimals(ctx, sale)
+    : {
+        nativeTokenDecimals: LaunchpadSale.NATIVE_TOKEN_DECIMALS,
+        sellingTokenDecimals: LaunchpadSale.SELLING_TOKEN_DECIMALS
+      };
 
-  // Apply bonding curve math
-  const constant = nativeTokens.mul(exponentFactor).div(basePrice);
-  const exponent1 = exponentFactor.mul(totalTokensSold).div(decimals);
-  const eResult1 = euler.pow(exponent1);
-  const ethScaled = constant.add(eResult1);
-  const lnEthScaled = ethScaled.ln().mul(decimals);
-  const lnEthScaledBase = lnEthScaled.div(exponentFactor);
-  const result = lnEthScaledBase.minus(totalTokensSold);
-  let roundedResult = result.toDecimalPlaces(18, Decimal.ROUND_DOWN);
-
-  // Cap total supply to 10 million
-  if (roundedResult.add(totalTokensSold).greaterThan(new Decimal("1e+7"))) {
-    roundedResult = new Decimal("1e+7").minus(new Decimal(totalTokensSold));
-  }
+  // Calculate tokens purchasable using bonding curve math
+  const [originalQuantity, calculatedQuantity] = calculateTokensPurchasable(
+    nativeTokens,
+    totalTokensSold,
+    nativeTokenDecimals,
+    sellingTokenDecimals
+  );
 
   // Fetch fee configuration and return result
   const launchpadFeeAddressConfiguration = await fetchLaunchpadFeeAddress(ctx);
 
   return {
-    calculatedQuantity: roundedResult.toFixed(),
+    originalQuantity: originalQuantity,
+    calculatedQuantity: calculatedQuantity,
     extraFees: {
       reverseBondingCurve: "0",
       transactionFees: calculateTransactionFee(
-        BigNumber(nativeTokens.toFixed()),
+        BigNumber(originalQuantity),
         launchpadFeeAddressConfiguration?.feeAmount
       )
     }

package/src/chaincode/launchpad/callNativeTokenIn.ts

@@ -16,10 +16,51 @@ import { GalaChainContext } from "@gala-chain/chaincode";
 import BigNumber from "bignumber.js";
 import Decimal from "decimal.js";
 
-import { ExactTokenQuantityDto } from "../../api/types";
-import { fetchAndValidateSale, fetchLaunchpadFeeAddress, getBondingConstants } from "../utils";
+import { ExactTokenQuantityDto, LaunchpadSale, TradeCalculationResDto } from "../../api/types";
+import {
+  fetchAndValidateSale,
+  fetchLaunchpadFeeAddress,
+  fetchTokenDecimals,
+  getBondingConstants
+} from "../utils";
 import { calculateTransactionFee } from "./fees";
 
+function calculateNativeTokensRequired(
+  tokensToBuy: Decimal,
+  totalTokensSold: Decimal,
+  sellingTokenDecimals: number,
+  nativeTokenDecimals: number
+): [string, string] {
+  const basePrice = new Decimal(LaunchpadSale.BASE_PRICE);
+  const { exponentFactor, euler, decimals } = getBondingConstants();
+
+  // Round tokens first, then calculate native tokens based on that rounded amount
+  const roundedTokensToBuy = tokensToBuy.toDecimalPlaces(sellingTokenDecimals, Decimal.ROUND_DOWN);
+
+  // Calculate native tokens required: price = (basePrice / exponentFactor) * (e^(exponentFactor * (totalTokensSold + tokensToBuy) / decimals) - e^(exponentFactor * totalTokensSold / decimals))
+  // Where:
+  //   exponent1 = exponentFactor * (totalTokensSold + tokensToBuy) / decimals
+  //   exponent2 = exponentFactor * totalTokensSold / decimals
+  //   eResult1 = e^(exponent1) = e^(exponentFactor * (totalTokensSold + tokensToBuy) / decimals)
+  //   eResult2 = e^(exponent2) = e^(exponentFactor * totalTokensSold / decimals)
+  //   constantFactor = basePrice / exponentFactor
+  //   differenceOfExponentials = eResult1 - eResult2
+  //   price = constantFactor * differenceOfExponentials
+  const exponent1 = exponentFactor.mul(totalTokensSold.add(roundedTokensToBuy)).div(decimals);
+  const exponent2 = exponentFactor.mul(totalTokensSold).div(decimals);
+
+  const eResult1 = euler.pow(exponent1);
+  const eResult2 = euler.pow(exponent2);
+
+  const constantFactor = basePrice.div(exponentFactor);
+  const differenceOfExponentials = eResult1.minus(eResult2);
+
+  const price = constantFactor.mul(differenceOfExponentials);
+  const roundedPrice = price.toDecimalPlaces(nativeTokenDecimals, Decimal.ROUND_UP);
+
+  return [roundedTokensToBuy.toFixed(), roundedPrice.toFixed()];
+}
+
 /**
  * Calculates the amount of native tokens required to purchase a specified amount
  * of tokens using a bonding curve mechanism.
@@ -31,43 +72,45 @@ import { calculateTransactionFee } from "./fees";
  * @param buyTokenDTO - The data transfer object containing the sale address
  *                      and the exact amount of tokens to be purchased.
  *
- * @returns A promise that resolves to a string representing the calculated amount of
- *          native tokens required for the purchase, rounded up to 8 decimal places.
+ * @returns A promise that resolves to a TradeCalculationResDto object containing the calculated
+ * quantity of native tokens required for the purchase, the original quantity of tokens used, and extra fees.
  *
  * @throws Error if the calculation encounters an invalid state or data.
  */
-export async function callNativeTokenIn(ctx: GalaChainContext, buyTokenDTO: ExactTokenQuantityDto) {
+export async function callNativeTokenIn(
+  ctx: GalaChainContext,
+  buyTokenDTO: ExactTokenQuantityDto
+): Promise<TradeCalculationResDto> {
   const sale = await fetchAndValidateSale(ctx, buyTokenDTO.vaultAddress);
   const totalTokensSold = new Decimal(sale.fetchTokensSold());
 
   let tokensToBuy = new Decimal(buyTokenDTO.tokenQuantity.toString());
-  const basePrice = new Decimal(sale.fetchBasePrice());
-  const { exponentFactor, euler, decimals } = getBondingConstants();
 
+  // Adjust tokensToBuy if user is trying to buy more tokens than the total supply
   if (tokensToBuy.add(totalTokensSold).greaterThan(new Decimal("1e+7"))) {
     tokensToBuy = new Decimal(sale.sellingTokenQuantity);
   }
 
-  const exponent1 = exponentFactor.mul(totalTokensSold.add(tokensToBuy)).div(decimals);
-  const exponent2 = exponentFactor.mul(totalTokensSold).div(decimals);
-
-  const eResult1 = euler.pow(exponent1);
-  const eResult2 = euler.pow(exponent2);
-
-  const constantFactor = basePrice.div(exponentFactor);
-  const differenceOfExponentials = eResult1.minus(eResult2);
+  // Get token decimals for rounding
+  const { nativeTokenDecimals, sellingTokenDecimals } = await fetchTokenDecimals(ctx, sale);
 
-  const price = constantFactor.mul(differenceOfExponentials);
+  // Calculate native tokens required using bonding curve math
+  const [originalQuantity, calculatedQuantity] = calculateNativeTokensRequired(
+    tokensToBuy,
+    totalTokensSold,
+    sellingTokenDecimals,
+    nativeTokenDecimals
+  );
 
   const launchpadFeeAddressConfiguration = await fetchLaunchpadFeeAddress(ctx);
 
-  const roundedPrice = price.toDecimalPlaces(8, Decimal.ROUND_UP).toFixed();
   return {
-    calculatedQuantity: roundedPrice,
+    originalQuantity: originalQuantity,
+    calculatedQuantity: calculatedQuantity,
     extraFees: {
       reverseBondingCurve: "0",
       transactionFees: calculateTransactionFee(
-        BigNumber(roundedPrice),
+        BigNumber(calculatedQuantity),
         launchpadFeeAddressConfiguration?.feeAmount
       )
     }

package/src/chaincode/launchpad/callNativeTokenOut.ts

@@ -16,25 +16,38 @@ import { GalaChainContext } from "@gala-chain/chaincode";
 import BigNumber from "bignumber.js";
 import Decimal from "decimal.js";
 
-import { ExactTokenQuantityDto, LaunchpadSale } from "../../api/types";
-import { fetchAndValidateSale, fetchLaunchpadFeeAddress, getBondingConstants } from "../utils";
+import { ExactTokenQuantityDto, LaunchpadSale, TradeCalculationResDto } from "../../api/types";
+import {
+  fetchAndValidateSale,
+  fetchLaunchpadFeeAddress,
+  fetchTokenDecimals,
+  getBondingConstants
+} from "../utils";
 import { calculateReverseBondingCurveFee, calculateTransactionFee } from "./fees";
 
-function calculateNativeTokensReceived(sale: LaunchpadSale, tokensToSellBn: BigNumber) {
+function calculateNativeTokensReceived(
+  sale: LaunchpadSale,
+  tokensToSellBn: BigNumber,
+  sellingTokenDecimals: number,
+  nativeTokenDecimals: number
+): [string, string] {
   const totalTokensSold = new Decimal(sale.fetchTokensSold());
 
   let tokensToSell = new Decimal(tokensToSellBn.toString());
-  const basePrice = new Decimal(sale.fetchBasePrice());
+  const basePrice = new Decimal(LaunchpadSale.BASE_PRICE);
   const { exponentFactor, euler, decimals } = getBondingConstants();
 
   let newTotalTokensSold = totalTokensSold.minus(tokensToSell);
 
-  if (newTotalTokensSold.comparedTo(0) < 0) {
+  if (newTotalTokensSold.lessThan(0)) {
     tokensToSell = totalTokensSold;
     newTotalTokensSold = new Decimal(0);
   }
 
-  const exponent1 = exponentFactor.mul(newTotalTokensSold.add(tokensToSell)).div(decimals);
+  // Round tokens first, then calculate native tokens based on that rounded amount
+  const roundedTokensToSell = tokensToSell.toDecimalPlaces(sellingTokenDecimals, Decimal.ROUND_UP);
+
+  const exponent1 = exponentFactor.mul(newTotalTokensSold.add(roundedTokensToSell)).div(decimals);
   const exponent2 = exponentFactor.mul(newTotalTokensSold).div(decimals);
 
   const eResult1 = euler.pow(exponent1);
@@ -43,9 +56,9 @@ function calculateNativeTokensReceived(sale: LaunchpadSale, tokensToSellBn: BigN
   const constantFactor = basePrice.div(exponentFactor);
   const differenceOfExponentials = eResult1.minus(eResult2);
   const price = constantFactor.mul(differenceOfExponentials);
-  const roundedPrice = price.toDecimalPlaces(8, Decimal.ROUND_DOWN);
+  const roundedPrice = price.toDecimalPlaces(nativeTokenDecimals, Decimal.ROUND_DOWN);
 
-  return roundedPrice.toFixed();
+  return [roundedTokensToSell.toFixed(), roundedPrice.toFixed()];
 }
 
 /**
@@ -59,23 +72,33 @@ function calculateNativeTokensReceived(sale: LaunchpadSale, tokensToSellBn: BigN
  * @param sellTokenDTO - The data transfer object containing the sale address
  *                       and the exact amount of tokens to be sold.
  *
- * @returns A promise that resolves to a string representing the calculated amount of
- *          native tokens to be received, rounded down to 8 decimal places.
+ * @returns A promise that resolves to a TradeCalculationResDto object containing the calculated
+ * quantity of native tokens received, the quantity of tokens required, and extra fees.
  *
  * @throws DefaultError if the calculated new total tokens sold is less than zero
  *                      or if the input amount is invalid.
  */
-export async function callNativeTokenOut(ctx: GalaChainContext, sellTokenDTO: ExactTokenQuantityDto) {
+export async function callNativeTokenOut(
+  ctx: GalaChainContext,
+  sellTokenDTO: ExactTokenQuantityDto
+): Promise<TradeCalculationResDto> {
   const sale = await fetchAndValidateSale(ctx, sellTokenDTO.vaultAddress);
-  const nativeTokensReceived = calculateNativeTokensReceived(sale, sellTokenDTO.tokenQuantity);
+  const { nativeTokenDecimals, sellingTokenDecimals } = await fetchTokenDecimals(ctx, sale);
+  const [originalQuantity, calculatedQuantity] = calculateNativeTokensReceived(
+    sale,
+    sellTokenDTO.tokenQuantity,
+    sellingTokenDecimals,
+    nativeTokenDecimals
+  );
   const launchpadFeeAddressConfiguration = await fetchLaunchpadFeeAddress(ctx);
 
   return {
-    calculatedQuantity: nativeTokensReceived,
+    originalQuantity: originalQuantity,
+    calculatedQuantity: calculatedQuantity,
     extraFees: {
-      reverseBondingCurve: calculateReverseBondingCurveFee(sale, BigNumber(nativeTokensReceived)).toString(),
+      reverseBondingCurve: calculateReverseBondingCurveFee(sale, BigNumber(calculatedQuantity)).toString(),
       transactionFees: calculateTransactionFee(
-        BigNumber(nativeTokensReceived),
+        BigNumber(calculatedQuantity),
         launchpadFeeAddressConfiguration?.feeAmount
       )
     }

package/src/chaincode/launchpad/configureLaunchpadFeeConfig.spec.ts

@@ -155,7 +155,6 @@ describe("configureLaunchpadFeeAddress", () => {
 
     // Update with zero fee amount
     const configDto = new ConfigureLaunchpadFeeAddressDto();
-    configDto.newPlatformFeeAddress = asValidUserAlias("client|feeAddress"); // Keep same address
     configDto.newFeeAmount = 0;
     configDto.uniqueKey = randomUniqueKey();
     const signedDto = configDto.signed(users.admin.privateKey);

package/src/chaincode/launchpad/configureLaunchpadFeeConfig.ts

@@ -35,7 +35,7 @@ export async function configureLaunchpadFeeAddress(
   dto: ConfigureLaunchpadFeeAddressDto
 ): Promise<LaunchpadFeeConfig> {
   // Validate input: at least one field must be present
-  if (!dto.newPlatformFeeAddress && !dto.newAuthorities?.length && !dto.newFeeAmount) {
+  if (!dto.newPlatformFeeAddress && !dto.newAuthorities?.length && dto.newFeeAmount === undefined) {
     throw new ValidationFailedError("None of the input fields are present.");
   }