@gala-chain/launchpad 1.0.0

package/src/chaincode/launchpad/buyExactToken.ts

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) Gala Games Inc. All rights reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { GalaChainContext, fetchTokenClass, putChainObject, transferToken } from "@gala-chain/chaincode";
+import { BigNumber } from "bignumber.js";
+
+import { ExactTokenQuantityDto, LaunchpadSale, TradeResDto } from "../../api/types";
+import { SlippageToleranceExceededError } from "../../api/utils/error";
+import { fetchAndValidateSale } from "../utils";
+import { callNativeTokenIn } from "./callNativeTokenIn";
+import { finalizeSale } from "./finaliseSale";
+
+BigNumber.config({
+  ROUNDING_MODE: BigNumber.ROUND_UP
+});
+
+/**
+ * Executes the purchase of an exact amount of tokens in a token sale.
+ *
+ * This function validates the sale, calculates the required native tokens,
+ * and performs the token transfer to complete the purchase. If the purchase
+ * consumes all tokens in the sale, the sale is marked as finalized.
+ *
+ * @param ctx - The context object providing access to the GalaChain environment.
+ * @param buyTokenDTO - The data transfer object containing the sale address,
+ *                      token amount to buy, and optional expected native token amount.
+ *
+ * @returns A promise that resolves to a `TradeResDto` containing the updated
+ *          balances of the purchased token and the native token for the buyer.
+ *
+ * @throws DefaultError if the expected native tokens are insufficient to complete the purchase.
+ */
+export async function buyExactToken(
+  ctx: GalaChainContext,
+  buyTokenDTO: ExactTokenQuantityDto
+): Promise<TradeResDto> {
+  let isSaleFinalized = false;
+
+  // Fetch and validate the sale based on the provided vault address
+  const sale = await fetchAndValidateSale(ctx, buyTokenDTO.vaultAddress);
+  const tokenLeftInVault = new BigNumber(sale.sellingTokenQuantity);
+
+  // Calculate the required amount of native tokens to buy the specified token amount
+  const callNativeTokenInResult1 = await callNativeTokenIn(ctx, buyTokenDTO);
+  let nativeTokensToBuy = new BigNumber(callNativeTokenInResult1.calculatedQuantity);
+  const nativeToken = sale.fetchNativeTokenInstanceKey();
+  const memeToken = sale.fetchSellingTokenInstanceKey();
+
+  // If the requested token amount exceeds what's available, adjust it and recalculate native tokens needed
+  if (tokenLeftInVault.lte(buyTokenDTO.tokenQuantity)) {
+    buyTokenDTO.tokenQuantity = tokenLeftInVault;
+    const callNativeTokenInResult2 = await callNativeTokenIn(ctx, buyTokenDTO);
+    nativeTokensToBuy = new BigNumber(callNativeTokenInResult2.calculatedQuantity);
+    isSaleFinalized = true;
+  }
+
+  // Check if the native tokens used exceed the market cap, finalizing the sale if true
+  if (
+    nativeTokensToBuy
+      .plus(new BigNumber(sale.nativeTokenQuantity))
+      .gte(new BigNumber(LaunchpadSale.MARKET_CAP))
+  ) {
+    isSaleFinalized = true;
+  }
+
+  // Ensure the expected native token amount is not less than the actual amount required
+  if (buyTokenDTO.expectedNativeToken && buyTokenDTO.expectedNativeToken.comparedTo(nativeTokensToBuy) < 0) {
+    throw new SlippageToleranceExceededError(
+      "Gala tokens expected to perform this operation are less than the actual amount required."
+    );
+  }
+
+  // Transfer native tokens from the buyer to the vault
+  await transferToken(ctx, {
+    from: ctx.callingUser,
+    to: buyTokenDTO.vaultAddress,
+    tokenInstanceKey: nativeToken,
+    quantity: nativeTokensToBuy,
+    allowancesToUse: [],
+    authorizedOnBehalf: undefined
+  });
+
+  // Transfer meme tokens from the vault to the buyer
+  await transferToken(ctx, {
+    from: buyTokenDTO.vaultAddress,
+    to: ctx.callingUser,
+    tokenInstanceKey: memeToken,
+    quantity: buyTokenDTO.tokenQuantity,
+    allowancesToUse: [],
+    authorizedOnBehalf: {
+      callingOnBehalf: buyTokenDTO.vaultAddress,
+      callingUser: ctx.callingUser
+    }
+  });
+
+  // Update the sale record with the purchased token details
+  sale.buyToken(buyTokenDTO.tokenQuantity, nativeTokensToBuy);
+  await putChainObject(ctx, sale);
+
+  // If the sale is finalized, create a V3 pool and add liquidity
+  if (isSaleFinalized) {
+    await finalizeSale(ctx, sale);
+  }
+
+  // Return the updated balance response
+  const token = await fetchTokenClass(ctx, sale.sellingToken);
+  return {
+    inputQuantity: nativeTokensToBuy.toFixed(),
+    outputQuantity: buyTokenDTO.tokenQuantity.toFixed(),
+    tokenName: token.name,
+    tradeType: "Buy",
+    vaultAddress: buyTokenDTO.vaultAddress,
+    userAddress: ctx.callingUser,
+    isFinalized: isSaleFinalized,
+    functionName: "BuyExactToken"
+  };
+}

package/src/chaincode/launchpad/buyWithNative.ts

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) Gala Games Inc. All rights reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { GalaChainContext, fetchTokenClass, putChainObject, transferToken } from "@gala-chain/chaincode";
+import { BigNumber } from "bignumber.js";
+
+import { ExactTokenQuantityDto, LaunchpadSale, NativeTokenQuantityDto, TradeResDto } from "../../api/types";
+import { SlippageToleranceExceededError } from "../../api/utils/error";
+import { fetchAndValidateSale } from "../utils";
+import { callMemeTokenOut } from "./callMemeTokenOut";
+import { callNativeTokenIn } from "./callNativeTokenIn";
+import { finalizeSale } from "./finaliseSale";
+
+BigNumber.config({
+  ROUNDING_MODE: BigNumber.ROUND_UP
+});
+
+/**
+ * Executes the purchase of tokens using a specified amount of native tokens.
+ *
+ * This function validates the sale, calculates the amount of tokens that can
+ * be purchased with the provided native tokens, and performs the token transfer
+ * to complete the purchase. If the purchase consumes all tokens in the sale,
+ * the sale is marked as finalized.
+ *
+ * @param ctx - The context object providing access to the GalaChain environment.
+ * @param buyTokenDTO - The data transfer object containing the sale address,
+ *                      native token amount to spend, and optional expected token amount.
+ *
+ * @returns A promise that resolves to a `TradeResDto` containing the updated
+ *          balances of the purchased token and the native token for the buyer.
+ *
+ * @throws DefaultError if the expected tokens to be received are less than the
+ *                      actual amount provided by the operation.
+ */
+export async function buyWithNative(
+  ctx: GalaChainContext,
+  buyTokenDTO: NativeTokenQuantityDto
+): Promise<TradeResDto> {
+  let isSaleFinalized = false;
+  const sale = await fetchAndValidateSale(ctx, buyTokenDTO.vaultAddress);
+  const tokensLeftInVault = new BigNumber(sale.sellingTokenQuantity);
+  const callMemeTokenOutResult = await callMemeTokenOut(ctx, buyTokenDTO);
+  let tokensToBuy = new BigNumber(callMemeTokenOutResult.calculatedQuantity);
+
+  const nativeToken = sale.fetchNativeTokenInstanceKey();
+  const memeToken = sale.fetchSellingTokenInstanceKey();
+
+  if (tokensLeftInVault.comparedTo(tokensToBuy) <= 0) {
+    tokensToBuy = tokensLeftInVault;
+    const nativeTokensrequiredToBuyDto = new ExactTokenQuantityDto(buyTokenDTO.vaultAddress, tokensToBuy);
+    const callNativeTokenInResult = await callNativeTokenIn(ctx, nativeTokensrequiredToBuyDto);
+    buyTokenDTO.nativeTokenQuantity = new BigNumber(callNativeTokenInResult.calculatedQuantity);
+    isSaleFinalized = true;
+  }
+
+  if (
+    buyTokenDTO.nativeTokenQuantity
+      .plus(new BigNumber(sale.nativeTokenQuantity))
+      .gte(new BigNumber(LaunchpadSale.MARKET_CAP))
+  )
+    isSaleFinalized = true;
+
+  if (buyTokenDTO.expectedToken && buyTokenDTO.expectedToken.comparedTo(tokensToBuy) > 0) {
+    throw new SlippageToleranceExceededError(
+      "Tokens expected from this operation are more than the the actual amount that will be provided."
+    );
+  }
+
+  await transferToken(ctx, {
+    from: ctx.callingUser,
+    to: buyTokenDTO.vaultAddress,
+    tokenInstanceKey: nativeToken,
+    quantity: buyTokenDTO.nativeTokenQuantity,
+    allowancesToUse: [],
+    authorizedOnBehalf: undefined
+  });
+
+  await transferToken(ctx, {
+    from: buyTokenDTO.vaultAddress,
+    to: ctx.callingUser,
+    tokenInstanceKey: memeToken,
+    quantity: tokensToBuy,
+    allowancesToUse: [],
+    authorizedOnBehalf: {
+      callingOnBehalf: buyTokenDTO.vaultAddress,
+      callingUser: ctx.callingUser
+    }
+  });
+
+  sale.buyToken(tokensToBuy, buyTokenDTO.nativeTokenQuantity);
+  await putChainObject(ctx, sale);
+
+  if (isSaleFinalized) {
+    await finalizeSale(ctx, sale);
+  }
+
+  const token = await fetchTokenClass(ctx, sale.sellingToken);
+  return {
+    inputQuantity: buyTokenDTO.nativeTokenQuantity.toFixed(),
+    outputQuantity: tokensToBuy.toFixed(),
+    tokenName: token.name,
+    tradeType: "Buy",
+    vaultAddress: buyTokenDTO.vaultAddress,
+    userAddress: ctx.callingUser,
+    isFinalized: isSaleFinalized,
+    functionName: "BuyWithNative"
+  };
+}

package/src/chaincode/launchpad/callMemeTokenIn.ts

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) Gala Games Inc. All rights reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ValidationFailedError } from "@gala-chain/api";
+import { GalaChainContext } from "@gala-chain/chaincode";
+import { BigNumber } from "bignumber.js";
+import Decimal from "decimal.js";
+
+import { LaunchpadSale, NativeTokenQuantityDto } from "../../api/types";
+import { fetchAndValidateSale, getBondingConstants } from "../utils";
+import { calculateReverseBondingCurveFee } from "./fees";
+
+BigNumber.config({
+  ROUNDING_MODE: BigNumber.ROUND_UP
+});
+
+function calculateMemeTokensRequired(sale: LaunchpadSale, requestedNativeTokenQuantity: BigNumber) {
+  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
+  const { exponentFactor, euler, decimals } = getBondingConstants();
+
+  const nativeTokenInVault = new Decimal(sale.nativeTokenQuantity);
+  if (nativeTokens.greaterThan(nativeTokenInVault)) {
+    nativeTokens = nativeTokenInVault;
+  }
+
+  const exponent = exponentFactor.mul(totalTokensSold).div(decimals);
+  const exp1 = euler.pow(exponent);
+  const constantFactor = nativeTokens.mul(exponentFactor).div(basePrice);
+
+  if (exp1.lte(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);
+
+  return roundedTokenSent.toFixed();
+}
+
+/**
+ * Calculates the number of tokens that can be sold in exchange for a specified amount
+ * of native tokens using a bonding curve mechanism.
+ *
+ * This function retrieves the sale details and applies the bonding curve formula
+ * to determine the number of tokens the user can sell based on the provided native token amount.
+ *
+ * @param ctx - The context object that provides access to the GalaChain environment.
+ * @param sellTokenDTO - An object containing the sale details:
+ *   - `vaultAddress`: The address of the sale.
+ *   - `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.
+ *
+ * @throws Error if the calculation results in an invalid amount (e.g., `InvalidAmountError`).
+ */
+export async function callMemeTokenIn(ctx: GalaChainContext, sellTokenDTO: NativeTokenQuantityDto) {
+  const sale = await fetchAndValidateSale(ctx, sellTokenDTO.vaultAddress);
+
+  return {
+    calculatedQuantity: calculateMemeTokensRequired(sale, sellTokenDTO.nativeTokenQuantity),
+    extraFees: {
+      reverseBondingCurve: calculateReverseBondingCurveFee(sale, sellTokenDTO.nativeTokenQuantity).toString()
+    }
+  };
+}

package/src/chaincode/launchpad/callMemeTokenOut.ts

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Gala Games Inc. All rights reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { GalaChainContext } from "@gala-chain/chaincode";
+import { BigNumber } from "bignumber.js";
+import Decimal from "decimal.js";
+
+import { LaunchpadSale, NativeTokenQuantityDto } from "../../api/types";
+import { fetchAndValidateSale, getBondingConstants } from "../utils";
+
+BigNumber.config({
+  ROUNDING_MODE: BigNumber.ROUND_UP
+});
+
+/**
+ * Calculates the number of tokens that can be purchased using a specified amount
+ * of native tokens based on a bonding curve mechanism.
+ *
+ * This function retrieves the sale details and applies the bonding curve formula
+ * to determine the number of tokens the user can buy with the provided native token amount.
+ *
+ * @param ctx - The context object providing access to the GalaChain environment.
+ * @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.
+ *
+ * @throws Error if the calculation results in an invalid state.
+ */
+export async function callMemeTokenOut(ctx: GalaChainContext, buyTokenDTO: NativeTokenQuantityDto) {
+  const sale = await fetchAndValidateSale(ctx, buyTokenDTO.vaultAddress);
+  const totalTokensSold = new Decimal(sale.fetchTokensSold()); // current tokens sold / x
+  let nativeTokens = new Decimal(buyTokenDTO.nativeTokenQuantity.toString()); // native tokens used to buy / y
+  const basePrice = new Decimal(sale.fetchBasePrice()); // base price / a
+  const { exponentFactor, euler, decimals } = getBondingConstants();
+
+  if (
+    nativeTokens.add(new Decimal(sale.nativeTokenQuantity)).greaterThan(new Decimal(LaunchpadSale.MARKET_CAP))
+  ) {
+    nativeTokens = new Decimal(LaunchpadSale.MARKET_CAP).minus(new Decimal(sale.nativeTokenQuantity));
+  }
+
+  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);
+
+  if (roundedResult.add(totalTokensSold).greaterThan(new Decimal("1e+7"))) {
+    roundedResult = new Decimal("1e+7").minus(new Decimal(totalTokensSold));
+  }
+
+  return {
+    calculatedQuantity: roundedResult.toFixed(),
+    extraFees: {
+      reverseBondingCurve: "0"
+    }
+  };
+}

package/src/chaincode/launchpad/callNativeTokenIn.ts

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) Gala Games Inc. All rights reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { GalaChainContext } from "@gala-chain/chaincode";
+import { BigNumber } from "bignumber.js";
+import Decimal from "decimal.js";
+
+import { ExactTokenQuantityDto } from "../../api/types";
+import { fetchAndValidateSale, getBondingConstants } from "../utils";
+
+BigNumber.config({
+  ROUNDING_MODE: BigNumber.ROUND_UP
+});
+
+/**
+ * Calculates the amount of native tokens required to purchase a specified amount
+ * of tokens using a bonding curve mechanism.
+ *
+ * This function retrieves the sale details and applies the bonding curve formula
+ * to determine the cost in native tokens for the given token amount.
+ *
+ * @param ctx - The context object providing access to the GalaChain environment.
+ * @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.
+ *
+ * @throws Error if the calculation encounters an invalid state or data.
+ */
+export async function callNativeTokenIn(ctx: GalaChainContext, buyTokenDTO: ExactTokenQuantityDto) {
+  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();
+
+  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);
+
+  const price = constantFactor.mul(differenceOfExponentials);
+
+  return {
+    calculatedQuantity: price.toDecimalPlaces(8, Decimal.ROUND_UP).toFixed(),
+    extraFees: {
+      reverseBondingCurve: "0"
+    }
+  };
+}

package/src/chaincode/launchpad/callNativeTokenOut.ts

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) Gala Games Inc. All rights reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { GalaChainContext } from "@gala-chain/chaincode";
+import { BigNumber } from "bignumber.js";
+import Decimal from "decimal.js";
+
+import { ExactTokenQuantityDto, LaunchpadSale } from "../../api/types";
+import { fetchAndValidateSale, getBondingConstants } from "../utils";
+import { calculateReverseBondingCurveFee } from "./fees";
+
+BigNumber.config({
+  ROUNDING_MODE: BigNumber.ROUND_UP
+});
+
+function calculateNativeTokensReceived(sale: LaunchpadSale, tokensToSellBn: BigNumber) {
+  const totalTokensSold = new Decimal(sale.fetchTokensSold());
+
+  let tokensToSell = new Decimal(tokensToSellBn.toString());
+  const basePrice = new Decimal(sale.fetchBasePrice());
+  const { exponentFactor, euler, decimals } = getBondingConstants();
+
+  let newTotalTokensSold = totalTokensSold.minus(tokensToSell);
+
+  if (newTotalTokensSold.comparedTo(0) < 0) {
+    tokensToSell = totalTokensSold;
+    newTotalTokensSold = new Decimal(0);
+  }
+
+  const exponent1 = exponentFactor.mul(newTotalTokensSold.add(tokensToSell)).div(decimals);
+  const exponent2 = exponentFactor.mul(newTotalTokensSold).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(8, Decimal.ROUND_DOWN);
+
+  return roundedPrice.toFixed();
+}
+
+/**
+ * Calculates the amount of native tokens a user would receive when selling
+ * a specified amount of tokens based on a bonding curve mechanism.
+ *
+ * This function retrieves the sale details and applies the bonding curve formula
+ * to determine the value in native tokens for the given token amount.
+ *
+ * @param ctx - The context object providing access to the GalaChain environment.
+ * @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.
+ *
+ * @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) {
+  const sale = await fetchAndValidateSale(ctx, sellTokenDTO.vaultAddress);
+  const nativeTokensReceived = calculateNativeTokensReceived(sale, sellTokenDTO.tokenQuantity);
+  return {
+    calculatedQuantity: nativeTokensReceived,
+    extraFees: {
+      reverseBondingCurve: calculateReverseBondingCurveFee(sale, BigNumber(nativeTokensReceived)).toString()
+    }
+  };
+}

package/src/chaincode/launchpad/configureLaunchpadFeeConfig.ts

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) Gala Games Inc. All rights reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ChainError, ErrorCode, UnauthorizedError, ValidationFailedError } from "@gala-chain/api";
+import { GalaChainContext } from "@gala-chain/chaincode";
+import { getObjectByKey, putChainObject } from "@gala-chain/chaincode";
+
+import { ConfigureLaunchpadFeeAddressDto, LaunchpadFeeConfig } from "../../api/types";
+
+export async function configureLaunchpadFeeAddress(
+  ctx: GalaChainContext,
+  dto: ConfigureLaunchpadFeeAddressDto
+): Promise<LaunchpadFeeConfig> {
+  if (!dto.newPlatformFeeAddress && !dto.newAuthorities?.length) {
+    throw new ValidationFailedError("None of the input fields are present.");
+  }
+
+  const curatorOrgMsp = process.env.CURATOR_ORG_MSP ?? "CuratorOrg";
+
+  const key = ctx.stub.createCompositeKey(LaunchpadFeeConfig.INDEX_KEY, []);
+  let platformFeeAddress = await getObjectByKey(ctx, LaunchpadFeeConfig, key).catch((e) => {
+    const chainError = ChainError.from(e);
+    if (chainError.matches(ErrorCode.NOT_FOUND)) {
+      return undefined;
+    } else {
+      throw chainError;
+    }
+  });
+
+  if (ctx.clientIdentity.getMSPID() !== curatorOrgMsp) {
+    if (!platformFeeAddress || !platformFeeAddress.authorities.includes(ctx.callingUser)) {
+      throw new UnauthorizedError(`CallingUser ${ctx.callingUser} is not authorized to create or update`);
+    }
+  }
+
+  if (!platformFeeAddress) {
+    if (!dto.newPlatformFeeAddress) {
+      throw new ValidationFailedError(
+        "Must provide a platform fee address in the initial setup of the configuration."
+      );
+    }
+    platformFeeAddress = new LaunchpadFeeConfig(
+      dto.newPlatformFeeAddress,
+      dto.newAuthorities ?? [ctx.callingUser]
+    );
+  } else if (platformFeeAddress && platformFeeAddress.authorities.includes(ctx.callingUser)) {
+    platformFeeAddress.setNewFeeAddress(
+      dto.newPlatformFeeAddress ?? platformFeeAddress.feeAddress,
+      dto.newAuthorities ?? platformFeeAddress.authorities
+    );
+  } else {
+    throw new UnauthorizedError(`CallingUser ${ctx.callingUser} is not authorized to create or update`);
+  }
+
+  await putChainObject(ctx, platformFeeAddress);
+
+  return platformFeeAddress;
+}