@gala-chain/launchpad 1.0.0

package/src/chaincode/launchpad/createSale.ts

@@ -0,0 +1,157 @@
+/*
+ * 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 { ConflictError, TokenInstanceKey, asValidUserAlias } from "@gala-chain/api";
+import {
+  GalaChainContext,
+  createTokenClass,
+  getObjectByKey,
+  mintTokenWithAllowance,
+  putChainObject,
+  updateTokenClass
+} from "@gala-chain/chaincode";
+import { BigNumber } from "bignumber.js";
+
+import { CreateSaleResDto, CreateTokenSaleDTO, LaunchpadSale, NativeTokenQuantityDto } from "../../api/types";
+import { PreConditionFailedError } from "../../api/utils/error";
+import { buyWithNative } from "./buyWithNative";
+
+BigNumber.config({
+  ROUNDING_MODE: BigNumber.ROUND_UP
+});
+
+/**
+ * Creates a new token sale (Launchpad) in the GalaChain environment.
+ *
+ * This function validates input parameters, creates a token class, mints an initial supply
+ * of tokens, and initializes the Launchpad sale object. If a pre-buy amount is specified,
+ * it simulates a token purchase using native tokens.
+ *
+ * @param ctx - The context object providing access to the GalaChain environment.
+ * @param launchpadDetails - An object containing details for the token sale, including:
+ *   - `tokenName`: The name of the token being created.
+ *   - `tokenSymbol`: The symbol for the token.
+ *   - `tokenDescription`: A description of the token.
+ *   - `tokenImage`: An optional image URL for the token.
+ *   - `preBuyAmount`: The amount of native tokens to use for a pre-buy (optional).
+ *
+ * @returns A promise that resolves to a `CreateSaleResDto` object containing details about
+ *          the created sale, including the vault address and token collection name.
+ *
+ * @throws DefaultError if:
+ *   - Required fields (`tokenName`, `tokenSymbol`, `tokenDescription`) are missing or empty.
+ *   - The token class creation fails (no response key returned).
+ */
+export async function createSale(
+  ctx: GalaChainContext,
+  launchpadDetails: CreateTokenSaleDTO
+): Promise<CreateSaleResDto> {
+  let isSaleFinalized = false;
+  // Validate input parameters
+
+  if (!launchpadDetails.websiteUrl && !launchpadDetails.telegramUrl && !launchpadDetails.twitterUrl) {
+    throw new PreConditionFailedError("Token sale creation requires atleast one social link.");
+  }
+
+  launchpadDetails.tokenSymbol = launchpadDetails.tokenSymbol.toUpperCase();
+
+  // Define the token class key
+  const tokenInstanceKey = new TokenInstanceKey();
+  tokenInstanceKey.collection = `${launchpadDetails.tokenCollection}`;
+  tokenInstanceKey.category = `${launchpadDetails.tokenCategory}`;
+  tokenInstanceKey.type = `${launchpadDetails.tokenSymbol}`;
+  tokenInstanceKey.additionalKey = `${ctx.callingUser.replace(/\|/, ":")}`;
+  tokenInstanceKey.instance = new BigNumber(0);
+
+  // Validate uniqueness of sale and token
+  const vaultAddress = asValidUserAlias(
+    `service|${tokenInstanceKey.getTokenClassKey().toStringKey()}$launchpad`
+  );
+  const key = ctx.stub.createCompositeKey(LaunchpadSale.INDEX_KEY, [vaultAddress]);
+  const sale = await getObjectByKey(ctx, LaunchpadSale, key).catch(() => undefined);
+  if (sale) {
+    throw new ConflictError("This token and a sale associated with it already exists");
+  }
+
+  // Call createTokenClass
+  await createTokenClass(ctx, {
+    network: "GC",
+    tokenClass: tokenInstanceKey.getTokenClassKey(),
+    isNonFungible: false,
+    decimals: 18,
+    name: launchpadDetails.tokenName,
+    symbol: launchpadDetails.tokenSymbol,
+    description: launchpadDetails.tokenDescription,
+    image: launchpadDetails.tokenImage,
+    maxSupply: new BigNumber("2e+7"),
+    maxCapacity: new BigNumber("2e+7"),
+    totalMintAllowance: new BigNumber(0),
+    totalSupply: new BigNumber(0),
+    totalBurned: new BigNumber(0),
+    authorities: [vaultAddress, ctx.callingUser]
+  });
+
+  // Mint tokens using the calling user's allowance
+  await mintTokenWithAllowance(ctx, {
+    tokenClassKey: tokenInstanceKey.getTokenClassKey(),
+    tokenInstance: new BigNumber(0),
+    owner: vaultAddress,
+    quantity: new BigNumber("2e+7")
+  });
+
+  //Update token class to remove the calling user as an authority in the token class
+  await updateTokenClass(ctx, {
+    tokenClass: tokenInstanceKey.getTokenClassKey(),
+    authorities: [vaultAddress]
+  });
+
+  // Create the LaunchpadSale object
+  const launchpad = new LaunchpadSale(
+    vaultAddress,
+    tokenInstanceKey,
+    launchpadDetails.reverseBondingCurveConfiguration?.toChainObject(),
+    ctx.callingUser
+  );
+
+  await putChainObject(ctx, launchpad);
+
+  if (launchpadDetails.preBuyQuantity.isGreaterThan(0)) {
+    const nativeTokenDto = new NativeTokenQuantityDto(
+      asValidUserAlias(launchpad.vaultAddress),
+      launchpadDetails.preBuyQuantity
+    );
+    const tradeStatus = await buyWithNative(ctx, nativeTokenDto);
+    isSaleFinalized = tradeStatus.isFinalized;
+  }
+
+  // Return the response object
+  return {
+    image: launchpadDetails.tokenImage,
+    tokenName: launchpadDetails.tokenName,
+    symbol: launchpadDetails.tokenSymbol,
+    description: launchpadDetails.tokenDescription,
+    websiteUrl: launchpadDetails.websiteUrl ? launchpadDetails.websiteUrl : "",
+    telegramUrl: launchpadDetails.telegramUrl ? launchpadDetails.telegramUrl : "",
+    twitterUrl: launchpadDetails.twitterUrl ? launchpadDetails.twitterUrl : "",
+    initialBuyQuantity: launchpadDetails.preBuyQuantity.toFixed(),
+    vaultAddress: vaultAddress,
+    creatorAddress: ctx.callingUser,
+    collection: launchpadDetails.tokenCollection,
+    category: launchpadDetails.tokenCategory,
+    functionName: "CreateSale",
+    isFinalized: isSaleFinalized,
+    tokenStringKey: tokenInstanceKey.getTokenClassKey().toStringKey(),
+    reverseBondingCurveConfiguration: launchpadDetails.reverseBondingCurveConfiguration
+  } satisfies CreateSaleResDto;
+}

package/src/chaincode/launchpad/fees.ts

@@ -0,0 +1,105 @@
+/*
+ * 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 { FeeReceiptStatus } from "@gala-chain/api";
+import {
+  GalaChainContext,
+  getObjectByKey,
+  transferToken,
+  txUnixTimeToDateIndexKeys,
+  writeChannelPaymentReceipt,
+  writeUserPaymentReceipt
+} from "@gala-chain/chaincode";
+import BigNumber from "bignumber.js";
+
+import { LaunchpadFeeConfig, LaunchpadSale } from "../../api/types";
+import { SlippageToleranceExceededError } from "../../api/utils/error";
+
+const REVERSE_BONDING_CURVE_FEE_CODE = "LaunchpadReverseBondingCurveFee";
+const NATIVE_TOKEN_DECIMALS = 8;
+
+export function calculateReverseBondingCurveFee(sale: LaunchpadSale, nativeTokensToReceive: BigNumber) {
+  if (
+    !sale.reverseBondingCurveConfiguration ||
+    sale.reverseBondingCurveConfiguration.maxFeePortion.isZero()
+  ) {
+    return BigNumber(0);
+  }
+
+  const circulatingSupplyProportional = sale.fetchCirculatingSupplyProportional();
+  const { minFeePortion, maxFeePortion } = sale.reverseBondingCurveConfiguration;
+  const feePortionDiff = maxFeePortion.minus(minFeePortion);
+  const portionAboveBaseline = circulatingSupplyProportional.multipliedBy(feePortionDiff);
+  const feePortion = minFeePortion.plus(portionAboveBaseline);
+
+  const feeAmount = nativeTokensToReceive
+    .multipliedBy(feePortion)
+    .decimalPlaces(NATIVE_TOKEN_DECIMALS, BigNumber.ROUND_UP);
+
+  return feeAmount;
+}
+
+export async function payReverseBondingCurveFee(
+  ctx: GalaChainContext,
+  sale: LaunchpadSale,
+  nativeTokensToReceive: BigNumber,
+  maxAcceptableFee?: BigNumber
+) {
+  const feeAmount = await calculateReverseBondingCurveFee(sale, nativeTokensToReceive);
+
+  if (feeAmount.isZero()) {
+    return; // No fee
+  }
+
+  if (maxAcceptableFee && feeAmount.isGreaterThan(maxAcceptableFee)) {
+    throw new SlippageToleranceExceededError("Fee exceeds maximum acceptable amount");
+  }
+
+  const launchpadConfigKey = ctx.stub.createCompositeKey(LaunchpadFeeConfig.INDEX_KEY, []);
+  const launchpadConfig = await getObjectByKey(ctx, LaunchpadFeeConfig, launchpadConfigKey);
+  const nativeToken = sale.fetchNativeTokenInstanceKey();
+  const { year, month, day } = txUnixTimeToDateIndexKeys(ctx.txUnixTime);
+  const txId = ctx.stub.getTxID();
+
+  await writeChannelPaymentReceipt(ctx, {
+    year,
+    month,
+    day,
+    feeCode: REVERSE_BONDING_CURVE_FEE_CODE,
+    paidByUser: ctx.callingUser,
+    txId,
+    quantity: feeAmount,
+    status: FeeReceiptStatus.Settled
+  });
+
+  await writeUserPaymentReceipt(ctx, {
+    paidByUser: ctx.callingUser,
+    year,
+    month,
+    day,
+    feeCode: REVERSE_BONDING_CURVE_FEE_CODE,
+    txId,
+    quantity: feeAmount,
+    status: FeeReceiptStatus.Settled
+  });
+
+  await transferToken(ctx, {
+    to: launchpadConfig.feeAddress,
+    from: ctx.callingUser,
+    tokenInstanceKey: nativeToken,
+    quantity: feeAmount,
+    allowancesToUse: [],
+    authorizedOnBehalf: undefined
+  });
+}

package/src/chaincode/launchpad/fetchLaunchpadAdressConfig.ts

@@ -0,0 +1,38 @@
+/*
+ * 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 { NotFoundError, UnauthorizedError } from "@gala-chain/api";
+import { GalaChainContext } from "@gala-chain/chaincode";
+
+import { LaunchpadFeeConfig } from "../../api/types";
+import { fetchLaunchpadFeeAddress } from "../utils";
+
+export async function fetchLaunchpadFeeConfig(ctx: GalaChainContext): Promise<LaunchpadFeeConfig> {
+  const curatorOrgMsp = process.env.CURATOR_ORG_MSP ?? "CuratorOrg";
+
+  const platformFeeAddress = await fetchLaunchpadFeeAddress(ctx);
+
+  if (ctx.clientIdentity.getMSPID() !== curatorOrgMsp) {
+    throw new UnauthorizedError(`CallingUser ${ctx.callingUser} is not authorized to create or update`);
+  }
+
+  if (!platformFeeAddress) {
+    throw new NotFoundError(
+      "Platform fee configuration has yet to be defined. Platform fee configuration is not defined."
+    );
+  } else if (!platformFeeAddress.authorities.includes(ctx.callingUser)) {
+    throw new UnauthorizedError(`CallingUser ${ctx.callingUser} is not authorized to create or update`);
+  }
+  return platformFeeAddress;
+}

package/src/chaincode/launchpad/fetchSaleDetails.ts

@@ -0,0 +1,53 @@
+/*
+ * 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 { NotFoundError } from "@gala-chain/api";
+import { GalaChainContext, getObjectByKey } from "@gala-chain/chaincode";
+import { BigNumber } from "bignumber.js";
+
+import { FetchSaleDto, LaunchpadSale } from "../../api/types";
+
+BigNumber.config({
+  ROUNDING_MODE: BigNumber.ROUND_UP
+});
+
+/**
+ * Fetches the details of a specific token sale (LaunchpadSale) using its sale address.
+ *
+ * This function retrieves the sale object from the chain using a composite key derived
+ * from the sale address. If the sale record is not found, an error is thrown.
+ *
+ * @param ctx - The context object providing access to the GalaChain environment.
+ * @param fetchSaleDTO - An object containing the sale address:
+ *   - `vaultAddress`: The address of the sale to be fetched.
+ *
+ * @returns A promise that resolves to a `LaunchpadSale` object containing details about
+ *          the specified token sale.
+ *
+ * @throws NotFoundError if no sale record is found for the provided sale address.
+ */
+export async function fetchSaleDetails(
+  ctx: GalaChainContext,
+  fetchSaleDTO: FetchSaleDto
+): Promise<LaunchpadSale> {
+  const key = ctx.stub.createCompositeKey(LaunchpadSale.INDEX_KEY, [fetchSaleDTO.vaultAddress]);
+
+  const sale = await getObjectByKey(ctx, LaunchpadSale, key);
+
+  if (sale === undefined) {
+    throw new NotFoundError("Sale record not found.");
+  }
+
+  return sale;
+}

package/src/chaincode/launchpad/finaliseSale.ts

@@ -0,0 +1,217 @@
+/*
+ * 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.
+ */
+// TODO: dependencies on DEX
+import { BurnTokenQuantity } from "@gala-chain/api";
+import {
+  GalaChainContext,
+  burnTokens,
+  fetchOrCreateBalance,
+  getObjectByKey,
+  putChainObject,
+  resolveUserAlias,
+  transferToken
+} from "@gala-chain/chaincode";
+import {
+  AddLiquidityDTO,
+  CreatePoolDto,
+  GetAddLiquidityEstimationDto,
+  addLiquidity,
+  createPool,
+  generateKeyFromClassKey,
+  getAddLiquidityEstimation,
+  getPoolData,
+  getSlot0,
+  sortString
+} from "@gala-chain/dex";
+import BigNumber from "bignumber.js";
+import Decimal from "decimal.js";
+
+import { LaunchpadFinalizeFeeAllocation, LaunchpadSale } from "../../api/types";
+import { PreConditionFailedError } from "../../api/utils/error";
+import { fetchLaunchpadFeeAddress, getBondingConstants } from "../utils";
+
+export async function finalizeSale(ctx: GalaChainContext, sale: LaunchpadSale): Promise<void> {
+  const key = ctx.stub.createCompositeKey(LaunchpadFinalizeFeeAllocation.INDEX_KEY, []);
+  const feeAllocation = await getObjectByKey(ctx, LaunchpadFinalizeFeeAllocation, key).catch(() => undefined);
+
+  const platformFeeAddressConfiguration = await fetchLaunchpadFeeAddress(ctx);
+  if (!platformFeeAddressConfiguration) {
+    throw new PreConditionFailedError("Platform fee configuration is yet to be defined.");
+  }
+
+  const platformFeePercentage = feeAllocation ? feeAllocation.platformFeePercentage : 0.1;
+  const ownerAllocationPercentage = feeAllocation ? feeAllocation.ownerAllocationPercentage : 0.6;
+  const liquidityAllocationPercentage = feeAllocation ? feeAllocation.liquidityAllocationPercentage : 0.3;
+
+  const nativeToken = sale.fetchNativeTokenInstanceKey();
+  const memeToken = sale.fetchSellingTokenInstanceKey();
+  const vaultAddressAlias = await resolveUserAlias(ctx, sale.vaultAddress);
+
+  await transferToken(ctx, {
+    from: vaultAddressAlias,
+    to: sale.saleOwner,
+    tokenInstanceKey: nativeToken,
+    quantity: new BigNumber(sale.nativeTokenQuantity)
+      .times(ownerAllocationPercentage)
+      .decimalPlaces(8, BigNumber.ROUND_DOWN),
+    allowancesToUse: [],
+    authorizedOnBehalf: {
+      callingOnBehalf: vaultAddressAlias,
+      callingUser: ctx.callingUser
+    }
+  });
+
+  await transferToken(ctx, {
+    from: vaultAddressAlias,
+    to: platformFeeAddressConfiguration.feeAddress,
+    tokenInstanceKey: nativeToken,
+    quantity: new BigNumber(sale.nativeTokenQuantity)
+      .times(platformFeePercentage)
+      .decimalPlaces(8, BigNumber.ROUND_DOWN),
+    allowancesToUse: [],
+    authorizedOnBehalf: {
+      callingOnBehalf: vaultAddressAlias,
+      callingUser: ctx.callingUser
+    }
+  });
+
+  const sellingTokenClassKey = sale.fetchSellingTokenInstanceKey().getTokenClassKey();
+  const nativeTokenClassKey = sale.fetchNativeTokenInstanceKey().getTokenClassKey();
+
+  const { isChanged: areTokensSorted } = sortString(
+    [sellingTokenClassKey, nativeTokenClassKey].map(generateKeyFromClassKey)
+  );
+
+  const { sqrtPrice, finalPrice } = calculateFinalLaunchpadPrice(sale, areTokensSorted);
+  const poolDTO = new CreatePoolDto(
+    areTokensSorted ? nativeTokenClassKey : sellingTokenClassKey,
+    areTokensSorted ? sellingTokenClassKey : nativeTokenClassKey,
+    3000,
+    sqrtPrice
+  );
+
+  // Check if a pool for this token already exists
+  const pool = await getPoolData(ctx, poolDTO);
+  if (!pool) {
+    await createPool(ctx, poolDTO);
+  }
+  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 expectedNativeTokenRequired = new BigNumber(sale.nativeTokenQuantity).times(
+    liquidityAllocationPercentage
+  );
+  const isPriceGreaterThanExpected = poolInfo.sqrtPrice.isGreaterThan(sqrtPrice);
+  const expectedSaleTokenRequired = expectedNativeTokenRequired.times(finalPrice);
+
+  // Determine token amounts and token ordering
+  const token0 = areTokensSorted ? nativeTokenClassKey : sellingTokenClassKey;
+  const token1 = areTokensSorted ? sellingTokenClassKey : nativeTokenClassKey;
+
+  const liquidityAmount = priceCloseEnough
+    ? expectedNativeTokenRequired
+    : isPriceGreaterThanExpected
+      ? expectedSaleTokenRequired
+      : expectedNativeTokenRequired;
+
+  const zeroForOne = priceCloseEnough
+    ? areTokensSorted
+    : isPriceGreaterThanExpected
+      ? !areTokensSorted
+      : areTokensSorted;
+
+  const expectedTokenDTO = new GetAddLiquidityEstimationDto(
+    token0,
+    token1,
+    3000,
+    liquidityAmount,
+    -887220,
+    887220,
+    zeroForOne
+  );
+
+  const addLiquidityEstimate = await getAddLiquidityEstimation(ctx, expectedTokenDTO);
+
+  const amount0 = new BigNumber(addLiquidityEstimate.amount0.toString());
+  const amount1 = new BigNumber(addLiquidityEstimate.amount1.toString());
+
+  const positionDto = new AddLiquidityDTO(
+    token0,
+    token1,
+    3000,
+    -887220,
+    887220,
+    amount0,
+    amount1,
+    amount0.times(0.9999999),
+    amount1.times(0.9999999),
+    undefined
+  );
+  positionDto.uniqueKey = sale.vaultAddress.toString();
+
+  await addLiquidity(ctx, positionDto, vaultAddressAlias);
+
+  // Burn any extra meme tokens
+  const sellingTokenToBurn = await fetchOrCreateBalance(ctx, vaultAddressAlias, memeToken);
+  const burnSellingTokenQuantity = new BurnTokenQuantity();
+  burnSellingTokenQuantity.tokenInstanceKey = memeToken;
+  burnSellingTokenQuantity.quantity = sellingTokenToBurn.getQuantityTotal();
+
+  await burnTokens(ctx, {
+    owner: vaultAddressAlias,
+    toBurn: [burnSellingTokenQuantity],
+    preValidated: true
+  });
+
+  // Burn any extra GALA
+  const nativeTokenToBurn = await fetchOrCreateBalance(ctx, vaultAddressAlias, nativeToken);
+  const burnNativeTokenQuantity = new BurnTokenQuantity();
+  burnNativeTokenQuantity.tokenInstanceKey = nativeToken;
+  burnNativeTokenQuantity.quantity = nativeTokenToBurn.getQuantityTotal();
+
+  if (burnNativeTokenQuantity.quantity) {
+    await burnTokens(ctx, {
+      owner: vaultAddressAlias,
+      toBurn: [burnNativeTokenQuantity],
+      preValidated: true
+    });
+  }
+
+  // update sale status
+  sale.finalizeSale();
+  await putChainObject(ctx, sale);
+}
+
+function calculateFinalLaunchpadPrice(
+  sale: LaunchpadSale,
+  areTokensSorted: boolean
+): { sqrtPrice: BigNumber; finalPrice: BigNumber } {
+  const totalTokensSold = new Decimal(sale.fetchTokensSold());
+  const basePrice = new Decimal(sale.fetchBasePrice());
+  const { exponentFactor, euler, decimals } = getBondingConstants();
+
+  const exponent = exponentFactor.mul(totalTokensSold).div(decimals);
+  const multiplicand = euler.pow(exponent);
+  const finalPriceDecimal = multiplicand.mul(basePrice).div(decimals);
+
+  const priceDecimal = areTokensSorted ? new Decimal(1).dividedBy(finalPriceDecimal) : finalPriceDecimal;
+  const sqrtPriceDecimal = priceDecimal.pow("0.5");
+
+  return {
+    finalPrice: new BigNumber(new Decimal(1).dividedBy(finalPriceDecimal).toString()),
+    sqrtPrice: new BigNumber(sqrtPriceDecimal.toString())
+  };
+}

package/src/chaincode/launchpad/finalizeTokenAllocation.ts

@@ -0,0 +1,47 @@
+/*
+ * 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 { UnauthorizedError } from "@gala-chain/api";
+import { GalaChainContext } from "@gala-chain/chaincode";
+import { getObjectByKey, putChainObject } from "@gala-chain/chaincode";
+
+import { FinalizeTokenAllocationDto, LaunchpadFinalizeFeeAllocation } from "../../api/types";
+import { PreConditionFailedError } from "../../api/utils/error";
+import { fetchLaunchpadFeeAddress } from "../utils";
+
+export async function finalizeTokenAllocation(
+  ctx: GalaChainContext,
+  dto: FinalizeTokenAllocationDto
+): Promise<LaunchpadFinalizeFeeAllocation> {
+  const platformFeeAddress = await fetchLaunchpadFeeAddress(ctx);
+  if (!platformFeeAddress) {
+    throw new PreConditionFailedError(
+      "Platform fee configuration has yet to be defined. Platform fee configuration is not defined."
+    );
+  } else if (!platformFeeAddress.authorities.includes(ctx.callingUser)) {
+    throw new UnauthorizedError(`CallingUser ${ctx.callingUser} is not authorized to create or update`);
+  }
+
+  const key = ctx.stub.createCompositeKey(LaunchpadFinalizeFeeAllocation.INDEX_KEY, []);
+  let feeAllocation = await getObjectByKey(ctx, LaunchpadFinalizeFeeAllocation, key).catch(() => undefined);
+
+  if (!feeAllocation) {
+    feeAllocation = new LaunchpadFinalizeFeeAllocation(dto.platformFeePercentage, dto.ownerFeePercentage);
+  } else {
+    feeAllocation.setAllocation(dto.platformFeePercentage, dto.ownerFeePercentage);
+  }
+
+  await putChainObject(ctx, feeAllocation);
+  return feeAllocation;
+}

package/src/chaincode/launchpad/index.ts

@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+export * from "./buyExactToken";
+export * from "./buyWithNative";
+export * from "./callMemeTokenIn";
+export * from "./callMemeTokenOut";
+export * from "./callNativeTokenIn";
+export * from "./callNativeTokenOut";
+export * from "./createSale";
+export * from "./fetchSaleDetails";
+export * from "./preMintCalculation";
+export * from "./sellExactToken";
+export * from "./finalizeTokenAllocation";
+export * from "./sellWithNative";
+export * from "./configureLaunchpadFeeConfig";
+export * from "./fetchLaunchpadAdressConfig";