@gala-chain/launchpad 1.0.13 → 1.0.14

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.");
   }
 

package/src/chaincode/launchpad/createSale.ts

@@ -85,7 +85,7 @@ export async function createSale(
     network: "GC",
     tokenClass: tokenInstanceKey.getTokenClassKey(),
     isNonFungible: false,
-    decimals: 18,
+    decimals: LaunchpadSale.SELLING_TOKEN_DECIMALS,
     name: launchpadDetails.tokenName,
     symbol: launchpadDetails.tokenSymbol,
     description: launchpadDetails.tokenDescription,

package/src/chaincode/launchpad/fees.ts

@@ -12,9 +12,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { FeeReceiptStatus } from "@gala-chain/api";
+import { FeeReceiptStatus, ValidationFailedError } from "@gala-chain/api";
 import {
   GalaChainContext,
+  fetchOrCreateBalance,
   transferToken,
   txUnixTimeToDateIndexKeys,
   writeChannelPaymentReceipt,
@@ -27,7 +28,7 @@ import { SlippageToleranceExceededError } from "../../api/utils/error";
 import { fetchLaunchpadFeeAddress } from "../utils";
 
 const REVERSE_BONDING_CURVE_FEE_CODE = "LaunchpadReverseBondingCurveFee";
-const NATIVE_TOKEN_DECIMALS = 8;
+const NATIVE_TOKEN_DECIMALS = LaunchpadSale.NATIVE_TOKEN_DECIMALS;
 
 export function calculateReverseBondingCurveFee(sale: LaunchpadSale, nativeTokensToReceive: BigNumber) {
   if (
@@ -104,5 +105,56 @@ export async function payReverseBondingCurveFee(
 }
 
 export function calculateTransactionFee(tokensBeingTraded: BigNumber, feeAmount?: number) {
-  return tokensBeingTraded.multipliedBy(feeAmount ?? 0).toFixed(8, BigNumber.ROUND_UP);
+  return tokensBeingTraded.multipliedBy(feeAmount ?? 0).toFixed(NATIVE_TOKEN_DECIMALS, BigNumber.ROUND_UP);
+}
+
+/**
+ * Transfers transaction fees to the launchpad fee address if applicable.
+ * Optionally validates that the user has sufficient balance when nativeTokensRequired is provided.
+ *
+ * @param ctx - The context object providing access to the GalaChain environment.
+ * @param sale - The launchpad sale object.
+ * @param transactionFees - The transaction fees amount (as BigNumber or string).
+ * @param nativeToken - The native token instance key (returned from sale.fetchNativeTokenInstanceKey()).
+ * @param nativeTokensRequired - Optional. If provided, validates user has sufficient balance for fees + required tokens.
+ */
+export async function transferTransactionFees(
+  ctx: GalaChainContext,
+  sale: LaunchpadSale,
+  transactionFees: BigNumber | string,
+  nativeToken: ReturnType<LaunchpadSale["fetchNativeTokenInstanceKey"]>,
+  nativeTokensRequired?: BigNumber
+): Promise<void> {
+  const launchpadFeeAddressConfiguration = await fetchLaunchpadFeeAddress(ctx);
+  const transactionFeesBn =
+    typeof transactionFees === "string" ? new BigNumber(transactionFees) : transactionFees;
+
+  // Check if transaction fees is greater than 0 and if the launchpad fee address configuration where
+  // the fees are sent to is defined
+  if (!launchpadFeeAddressConfiguration || !transactionFeesBn.isGreaterThan(0)) {
+    return;
+  }
+
+  // If nativeTokensRequired is provided, validate user has sufficient balance
+  if (nativeTokensRequired) {
+    const totalRequired = nativeTokensRequired.plus(transactionFeesBn);
+    const buyerBalance = await fetchOrCreateBalance(ctx, ctx.callingUser, sale.nativeToken);
+
+    // Check if the buyer has sufficient balance to pay the transaction fees
+    if (buyerBalance.getQuantityTotal().isLessThan(totalRequired)) {
+      throw new ValidationFailedError(
+        `Insufficient balance: Total amount required including fee is ${totalRequired}`
+      );
+    }
+  }
+
+  // Transfer transaction fees to the launchpad fee address
+  await transferToken(ctx, {
+    from: ctx.callingUser,
+    to: launchpadFeeAddressConfiguration.feeAddress,
+    tokenInstanceKey: nativeToken,
+    quantity: transactionFeesBn,
+    allowancesToUse: [],
+    authorizedOnBehalf: undefined
+  });
 }

package/src/chaincode/launchpad/finaliseSale.ts

@@ -65,7 +65,7 @@ export async function finalizeSale(ctx: GalaChainContext, sale: LaunchpadSale):
     tokenInstanceKey: nativeToken,
     quantity: new BigNumber(sale.nativeTokenQuantity)
       .times(ownerAllocationPercentage)
-      .decimalPlaces(8, BigNumber.ROUND_DOWN),
+      .decimalPlaces(LaunchpadSale.NATIVE_TOKEN_DECIMALS, BigNumber.ROUND_DOWN),
     allowancesToUse: [],
     authorizedOnBehalf: {
       callingOnBehalf: vaultAddressAlias,
@@ -79,7 +79,7 @@ export async function finalizeSale(ctx: GalaChainContext, sale: LaunchpadSale):
     tokenInstanceKey: nativeToken,
     quantity: new BigNumber(sale.nativeTokenQuantity)
       .times(platformFeePercentage)
-      .decimalPlaces(8, BigNumber.ROUND_DOWN),
+      .decimalPlaces(LaunchpadSale.NATIVE_TOKEN_DECIMALS, BigNumber.ROUND_DOWN),
     allowancesToUse: [],
     authorizedOnBehalf: {
       callingOnBehalf: vaultAddressAlias,
@@ -110,7 +110,10 @@ export async function finalizeSale(ctx: GalaChainContext, sale: LaunchpadSale):
   const poolInfo = await getSlot0(ctx, poolDTO);
 
   // Proceed normally if price in the pool is within an acceptable range
-  const priceCloseEnough = sqrtPrice.minus(poolInfo.sqrtPrice).abs().lte(sqrtPrice.multipliedBy(0.05));
+  const priceCloseEnough = sqrtPrice
+    .minus(poolInfo.sqrtPrice)
+    .abs()
+    .isLessThanOrEqualTo(sqrtPrice.multipliedBy(0.05));
   const expectedNativeTokenRequired = new BigNumber(sale.nativeTokenQuantity).times(
     liquidityAllocationPercentage
   );
@@ -200,7 +203,7 @@ function calculateFinalLaunchpadPrice(
   areTokensSorted: boolean
 ): { sqrtPrice: BigNumber; finalPrice: BigNumber } {
   const totalTokensSold = new Decimal(sale.fetchTokensSold());
-  const basePrice = new Decimal(sale.fetchBasePrice());
+  const basePrice = new Decimal(LaunchpadSale.BASE_PRICE);
   const { exponentFactor, euler, decimals } = getBondingConstants();
 
   const exponent = exponentFactor.mul(totalTokensSold).div(decimals);