@gala-chain/launchpad 1.0.1 → 1.0.3

package/src/chaincode/launchpad/configureLaunchpadFeeConfig.ts

@@ -18,19 +18,35 @@ import { getObjectByKey, putChainObject } from "@gala-chain/chaincode";
 
 import { ConfigureLaunchpadFeeAddressDto, LaunchpadFeeConfig } from "../../api/types";
 
+/**
+ * Configures or updates the Launchpad platform fee settings.
+ *
+ * This function initializes or modifies the fee address, fee amount, and list of authorities
+ * responsible for managing Launchpad platform fees. Only users from the designated curator
+ * organization or authorized addresses are permitted to make these changes.
+ *
+ * @param ctx - The context object providing access to the GalaChain environment.
+ * @param dto - The data transfer object containing the new fee address, fee amount,
+ *              and optional list of new authorities.
+ * @returns A promise that resolves to the updated or newly created `LaunchpadFeeConfig` object.
+ */
 export async function configureLaunchpadFeeAddress(
   ctx: GalaChainContext,
   dto: ConfigureLaunchpadFeeAddressDto
 ): Promise<LaunchpadFeeConfig> {
-  if (!dto.newPlatformFeeAddress && !dto.newAuthorities?.length) {
+  // Validate input: at least one field must be present
+  if (!dto.newPlatformFeeAddress && !dto.newAuthorities?.length && !dto.newFeeAmount) {
     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, []);
+
+  // Attempt to fetch existing config from the chain
   let platformFeeAddress = await getObjectByKey(ctx, LaunchpadFeeConfig, key).catch((e) => {
     const chainError = ChainError.from(e);
+    // Handle case where config doesn't exist yet
     if (chainError.matches(ErrorCode.NOT_FOUND)) {
       return undefined;
     } else {
@@ -38,25 +54,32 @@ export async function configureLaunchpadFeeAddress(
     }
   });
 
+  // Authorization check
   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 no existing config, this is the initial setup
   if (!platformFeeAddress) {
-    if (!dto.newPlatformFeeAddress) {
+    // Require both address and fee amount on initial setup
+    if (!dto.newPlatformFeeAddress || !dto.newFeeAmount) {
       throw new ValidationFailedError(
-        "Must provide a platform fee address in the initial setup of the configuration."
+        "Must provide a launchpad platform fee address and fee amount in the initial setup of the configuration."
       );
     }
+    // Create new configuration
     platformFeeAddress = new LaunchpadFeeConfig(
       dto.newPlatformFeeAddress,
+      dto.newFeeAmount,
       dto.newAuthorities ?? [ctx.callingUser]
     );
   } else if (platformFeeAddress && platformFeeAddress.authorities.includes(ctx.callingUser)) {
-    platformFeeAddress.setNewFeeAddress(
+    // Caller is authorized and updating the existing config
+    platformFeeAddress.updateFeeConfig(
       dto.newPlatformFeeAddress ?? platformFeeAddress.feeAddress,
+      dto.newFeeAmount ?? platformFeeAddress.feeAmount,
       dto.newAuthorities ?? platformFeeAddress.authorities
     );
   } else {

package/src/chaincode/launchpad/createSale.ts

@@ -21,16 +21,12 @@ import {
   putChainObject,
   updateTokenClass
 } from "@gala-chain/chaincode";
-import { BigNumber } from "bignumber.js";
+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.
  *

package/src/chaincode/launchpad/fees.ts

@@ -56,7 +56,7 @@ export async function payReverseBondingCurveFee(
   nativeTokensToReceive: BigNumber,
   maxAcceptableFee?: BigNumber
 ) {
-  const feeAmount = await calculateReverseBondingCurveFee(sale, nativeTokensToReceive);
+  const feeAmount = calculateReverseBondingCurveFee(sale, nativeTokensToReceive);
 
   if (feeAmount.isZero()) {
     return; // No fee
@@ -103,3 +103,7 @@ export async function payReverseBondingCurveFee(
     authorizedOnBehalf: undefined
   });
 }
+
+export function calculateTransactionFee(tokensBeingTraded: BigNumber, feeAmount?: number) {
+  return tokensBeingTraded.multipliedBy(feeAmount ?? 0).toFixed(8, BigNumber.ROUND_UP);
+}

package/src/chaincode/launchpad/fetchSaleDetails.ts

@@ -14,14 +14,9 @@
  */
 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.
  *

package/src/chaincode/launchpad/finaliseSale.ts

@@ -46,8 +46,8 @@ export async function finalizeSale(ctx: GalaChainContext, sale: LaunchpadSale):
   const key = ctx.stub.createCompositeKey(LaunchpadFinalizeFeeAllocation.INDEX_KEY, []);
   const feeAllocation = await getObjectByKey(ctx, LaunchpadFinalizeFeeAllocation, key).catch(() => undefined);
 
-  const platformFeeAddressConfiguration = await fetchLaunchpadFeeAddress(ctx);
-  if (!platformFeeAddressConfiguration) {
+  const launchpadFeeAddressConfiguration = await fetchLaunchpadFeeAddress(ctx);
+  if (!launchpadFeeAddressConfiguration) {
     throw new PreConditionFailedError("Platform fee configuration is yet to be defined.");
   }
 
@@ -75,7 +75,7 @@ export async function finalizeSale(ctx: GalaChainContext, sale: LaunchpadSale):
 
   await transferToken(ctx, {
     from: vaultAddressAlias,
-    to: platformFeeAddressConfiguration.feeAddress,
+    to: launchpadFeeAddressConfiguration.feeAddress,
     tokenInstanceKey: nativeToken,
     quantity: new BigNumber(sale.nativeTokenQuantity)
       .times(platformFeePercentage)

package/src/chaincode/launchpad/index.ts

@@ -26,3 +26,4 @@ export * from "./finalizeTokenAllocation";
 export * from "./sellWithNative";
 export * from "./configureLaunchpadFeeConfig";
 export * from "./fetchLaunchpadAdressConfig";
+export * from "./launchpadBatchSubmitAuthorizations";

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

@@ -0,0 +1,185 @@
+/*
+ * 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, putChainObject } from "@gala-chain/chaincode";
+
+import {
+  AuthorizeBatchSubmitterDto,
+  BatchSubmitAuthoritiesResDto,
+  DeauthorizeBatchSubmitterDto,
+  FetchBatchSubmitAuthoritiesDto,
+  LaunchpadBatchSubmitAuthorities
+} from "../../api/types";
+import {
+  authorizeLaunchpadBatchSubmitter,
+  deauthorizeLaunchpadBatchSubmitter,
+  fetchLaunchpadBatchSubmitAuthorities,
+  getLaunchpadBatchSubmitAuthorities
+} from "./launchpadBatchSubmitAuthorizations";
+
+jest.mock("@gala-chain/chaincode", () => ({
+  ...jest.requireActual("@gala-chain/chaincode"),
+  getObjectByKey: jest.fn(),
+  putChainObject: jest.fn()
+}));
+
+// Mock context for testing
+const createMockContext = (callingUser: string): GalaChainContext => {
+  const mockStub = {
+    createCompositeKey: (indexKey: string, attributes: string[]) => {
+      return `${indexKey}${attributes.join("|")}`;
+    },
+    getState: jest.fn(),
+    putState: jest.fn()
+  };
+
+  return {
+    callingUser,
+    stub: mockStub as any,
+    clientIdentity: {
+      getMSPID: () => "CuratorOrg"
+    } as any
+  } as GalaChainContext;
+};
+
+describe("BatchSubmitAuthorizations", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("BatchSubmitAuthorizations chain object", () => {
+    it("should create with initial authorities", () => {
+      const auth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+      expect(auth.authorities).toEqual(["user1", "user2"]);
+    });
+
+    it("should add authority", () => {
+      const auth = new LaunchpadBatchSubmitAuthorities(["user1"]);
+      auth.addAuthority("user2");
+      expect(auth.authorities).toEqual(["user1", "user2"]);
+    });
+
+    it("should not add duplicate authority", () => {
+      const auth = new LaunchpadBatchSubmitAuthorities(["user1"]);
+      auth.addAuthority("user1");
+      expect(auth.authorities).toEqual(["user1"]);
+    });
+
+    it("should remove authority", () => {
+      const auth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+      auth.removeAuthority("user1");
+      expect(auth.authorities).toEqual(["user2"]);
+    });
+
+    it("should check if user is authorized", () => {
+      const auth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+      expect(auth.isAuthorized("user1")).toBe(true);
+      expect(auth.isAuthorized("user3")).toBe(false);
+    });
+
+    it("should get authorized authorities", () => {
+      const auth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+      const authorities = auth.getAuthorities();
+      expect(authorities).toEqual(["user1", "user2"]);
+      // Should return a copy, not the original array
+      authorities.push("user3");
+      expect(auth.authorities).toEqual(["user1", "user2"]);
+    });
+  });
+
+  describe("fetchBatchSubmitAuthorizations", () => {
+    it("should return existing authorizations", async () => {
+      const ctx = createMockContext("user1");
+      const existingAuth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+
+      (getObjectByKey as jest.Mock).mockResolvedValue(existingAuth);
+      (putChainObject as jest.Mock).mockResolvedValue(undefined);
+
+      const result = await fetchLaunchpadBatchSubmitAuthorities(ctx);
+
+      expect(result).toBe(existingAuth);
+    });
+  });
+
+  describe("authorizeBatchSubmitter", () => {
+    it("should authorize new users when caller is authorized", async () => {
+      const ctx = createMockContext("user1");
+      const existingAuth = new LaunchpadBatchSubmitAuthorities(["user1"]);
+      (putChainObject as jest.Mock).mockResolvedValue(existingAuth);
+      (putChainObject as jest.Mock).mockResolvedValue(undefined);
+
+      const dto = new AuthorizeBatchSubmitterDto();
+      dto.authorities = ["user2", "user3"];
+
+      const result = await authorizeLaunchpadBatchSubmitter(ctx, dto);
+
+      expect(result).toBeInstanceOf(BatchSubmitAuthoritiesResDto);
+      expect(result.authorities).toContain("user1");
+      expect(result.authorities).toContain("user2");
+      expect(result.authorities).toContain("user3");
+    });
+
+    it("should create new authorities object when none exists", async () => {
+      const ctx = createMockContext("user1");
+
+      (getObjectByKey as jest.Mock).mockRejectedValue(new NotFoundError("Not found"));
+      (putChainObject as jest.Mock).mockResolvedValue(undefined);
+
+      const dto = new AuthorizeBatchSubmitterDto();
+      dto.authorities = ["user1", "user2"];
+
+      const result = await authorizeLaunchpadBatchSubmitter(ctx, dto);
+
+      expect(result).toBeInstanceOf(BatchSubmitAuthoritiesResDto);
+      expect(result.authorities).toContain("user1");
+      expect(result.authorities).toContain("user2");
+      expect(putChainObject).toHaveBeenCalled();
+    });
+  });
+
+  describe("deauthorizeBatchSubmitter", () => {
+    it("should deauthorize user when caller is authorized", async () => {
+      const ctx = createMockContext("user1");
+      const existingAuth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+
+      (getObjectByKey as jest.Mock).mockResolvedValue(existingAuth);
+      (putChainObject as jest.Mock).mockResolvedValue(undefined);
+
+      const dto = new DeauthorizeBatchSubmitterDto();
+      dto.authority = "user2";
+
+      const result = await deauthorizeLaunchpadBatchSubmitter(ctx, dto);
+
+      expect(result).toBeInstanceOf(BatchSubmitAuthoritiesResDto);
+      expect(result.authorities).toContain("user1");
+      expect(result.authorities).not.toContain("user2");
+    });
+  });
+
+  describe("getBatchSubmitAuthorizations", () => {
+    it("should return current authorizations", async () => {
+      const ctx = createMockContext("user1");
+      const existingAuth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+
+      (getObjectByKey as jest.Mock).mockResolvedValue(existingAuth);
+
+      const dto = new FetchBatchSubmitAuthoritiesDto();
+      const result = await getLaunchpadBatchSubmitAuthorities(ctx, dto);
+
+      expect(result).toBeInstanceOf(BatchSubmitAuthoritiesResDto);
+      expect(result.authorities).toEqual(["user1", "user2"]);
+    });
+  });
+});

package/src/chaincode/launchpad/launchpadBatchSubmitAuthorizations.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 { ChainError } from "@gala-chain/api";
+import { GalaChainContext, getObjectByKey, putChainObject } from "@gala-chain/chaincode";
+
+import {
+  AuthorizeBatchSubmitterDto,
+  BatchSubmitAuthoritiesResDto,
+  DeauthorizeBatchSubmitterDto,
+  ErrorCode,
+  FetchBatchSubmitAuthoritiesDto,
+  LaunchpadBatchSubmitAuthorities
+} from "../../api";
+
+/**
+ * Fetches the batch submit authorities from the chain.
+ */
+export async function fetchLaunchpadBatchSubmitAuthorities(
+  ctx: GalaChainContext
+): Promise<LaunchpadBatchSubmitAuthorities> {
+  const key = ctx.stub.createCompositeKey(LaunchpadBatchSubmitAuthorities.INDEX_KEY, []);
+
+  return await getObjectByKey(ctx, LaunchpadBatchSubmitAuthorities, key);
+}
+
+/**
+ * Authorizes users to call BatchSubmit operations.
+ * Only existing authorized users can add new authorizations.
+ */
+export async function authorizeLaunchpadBatchSubmitter(
+  ctx: GalaChainContext,
+  dto: AuthorizeBatchSubmitterDto
+): Promise<BatchSubmitAuthoritiesResDto> {
+  const key = ctx.stub.createCompositeKey(LaunchpadBatchSubmitAuthorities.INDEX_KEY, []);
+  const authorities = await getObjectByKey(ctx, LaunchpadBatchSubmitAuthorities, key).catch((e) => {
+    const chainError = ChainError.from(e);
+    if (chainError.matches(ErrorCode.NOT_FOUND)) {
+      return new LaunchpadBatchSubmitAuthorities([]);
+    } else {
+      throw chainError;
+    }
+  });
+
+  // Add new authorities
+  for (const authority of dto.authorities) {
+    authorities.addAuthority(authority);
+  }
+
+  await putChainObject(ctx, authorities);
+
+  const result = new BatchSubmitAuthoritiesResDto();
+  result.authorities = authorities.getAuthorities();
+  return result;
+}
+
+/**
+ * Deauthorizes a user from calling BatchSubmit operations.
+ */
+export async function deauthorizeLaunchpadBatchSubmitter(
+  ctx: GalaChainContext,
+  dto: DeauthorizeBatchSubmitterDto
+): Promise<BatchSubmitAuthoritiesResDto> {
+  const authorities = await fetchLaunchpadBatchSubmitAuthorities(ctx);
+
+  authorities.removeAuthority(dto.authority);
+  await putChainObject(ctx, authorities);
+
+  const result = new BatchSubmitAuthoritiesResDto();
+  result.authorities = authorities.getAuthorities();
+  return result;
+}
+
+/**
+ * Fetches the current batch submit authorizations.
+ */
+export async function getLaunchpadBatchSubmitAuthorities(
+  ctx: GalaChainContext,
+  dto: FetchBatchSubmitAuthoritiesDto
+): Promise<BatchSubmitAuthoritiesResDto> {
+  const authorities = await fetchLaunchpadBatchSubmitAuthorities(ctx);
+  const result = new BatchSubmitAuthoritiesResDto();
+
+  result.authorities = authorities.getAuthorities();
+  return result;
+}
+
+/**
+ * Checks if the calling user is authorized to perform batch submit operations.
+ */
+export async function isAuthorizedForLaunchpadBatchSubmit(ctx: GalaChainContext): Promise<boolean> {
+  const authorities = await fetchLaunchpadBatchSubmitAuthorities(ctx);
+  return authorities.isAuthorized(ctx.callingUser);
+}

package/src/chaincode/launchpad/preMintCalculation.ts

@@ -12,16 +12,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { BigNumber } from "bignumber.js";
 import Decimal from "decimal.js";
 
 import { LaunchpadSale, PreMintCalculationDto } from "../../api/types";
 import { 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.

package/src/chaincode/launchpad/sellExactToken.ts

@@ -12,20 +12,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { ValidationFailedError } from "@gala-chain/api";
 import { GalaChainContext, fetchTokenClass, putChainObject, transferToken } from "@gala-chain/chaincode";
 import { BigNumber } from "bignumber.js";
 
-import { ExactTokenQuantityDto, NativeTokenQuantityDto, TradeResDto } from "../../api/types";
+import { ExactTokenQuantityDto, TradeResDto } from "../../api/types";
 import { SlippageToleranceExceededError } from "../../api/utils/error";
-import { fetchAndValidateSale } from "../utils";
-import { callMemeTokenIn } from "./callMemeTokenIn";
+import { fetchAndValidateSale, fetchLaunchpadFeeAddress } from "../utils";
 import { callNativeTokenOut } from "./callNativeTokenOut";
 import { payReverseBondingCurveFee } from "./fees";
 
-BigNumber.config({
-  ROUNDING_MODE: BigNumber.ROUND_UP
-});
-
 /**
  * Executes the sale of an exact amount of tokens for native tokens (e.g., GALA).
  *
@@ -48,24 +44,24 @@ export async function sellExactToken(
   ctx: GalaChainContext,
   sellTokenDTO: ExactTokenQuantityDto
 ): Promise<TradeResDto> {
+  // Fetch and validate the current sale object
   const sale = await fetchAndValidateSale(ctx, sellTokenDTO.vaultAddress);
 
+  // Determine how much native token (e.g., GALA) the user will receive for the exact token quantity
   const callNativeTokenOutResult = await callNativeTokenOut(ctx, sellTokenDTO);
-  let nativeTokensToProvide = new BigNumber(callNativeTokenOutResult.calculatedQuantity);
+  const nativeTokensToProvide = new BigNumber(callNativeTokenOutResult.calculatedQuantity);
+  const transactionFees = callNativeTokenOutResult.extraFees.transactionFees;
+
   const nativeTokensLeftInVault = new BigNumber(sale.nativeTokenQuantity);
   const nativeToken = sale.fetchNativeTokenInstanceKey();
   const memeToken = sale.fetchSellingTokenInstanceKey();
 
+  // Abort if the vault doesn't have enough native tokens to pay the user
   if (nativeTokensLeftInVault.comparedTo(nativeTokensToProvide) < 0) {
-    nativeTokensToProvide = nativeTokensLeftInVault;
-    const nativeTokensBeingSoldDto = new NativeTokenQuantityDto(
-      sellTokenDTO.vaultAddress,
-      nativeTokensToProvide
-    );
-    const callMemeTokenInResult = await callMemeTokenIn(ctx, nativeTokensBeingSoldDto);
-    sellTokenDTO.tokenQuantity = new BigNumber(callMemeTokenInResult.calculatedQuantity);
+    throw new ValidationFailedError("Not enough GALA in sale contract to carry out this operation.");
   }
 
+  // Enforce slippage tolerance: expected amount must not be greater than what will actually be received
   if (
     sellTokenDTO.expectedNativeToken &&
     sellTokenDTO.expectedNativeToken.comparedTo(nativeTokensToProvide) > 0
@@ -84,6 +80,20 @@ export async function sellExactToken(
     sellTokenDTO.extraFees?.maxAcceptableReverseBondingCurveFee
   );
 
+  // Transfer launchpad transaction fee if applicable
+  const launchpadFeeAddressConfiguration = await fetchLaunchpadFeeAddress(ctx);
+  if (launchpadFeeAddressConfiguration && transactionFees) {
+    await transferToken(ctx, {
+      from: ctx.callingUser,
+      to: launchpadFeeAddressConfiguration.feeAddress,
+      tokenInstanceKey: nativeToken,
+      quantity: new BigNumber(transactionFees),
+      allowancesToUse: [],
+      authorizedOnBehalf: undefined
+    });
+  }
+
+  // Transfer meme tokens from user to vault
   await transferToken(ctx, {
     from: ctx.callingUser,
     to: sellTokenDTO.vaultAddress,
@@ -93,6 +103,7 @@ export async function sellExactToken(
     authorizedOnBehalf: undefined
   });
 
+  // Transfer native tokens from vault to user
   await transferToken(ctx, {
     from: sellTokenDTO.vaultAddress,
     to: ctx.callingUser,
@@ -105,12 +116,16 @@ export async function sellExactToken(
     }
   });
 
+  // Update sale state with this transaction
   sale.sellToken(sellTokenDTO.tokenQuantity, nativeTokensToProvide);
   await putChainObject(ctx, sale);
 
   const token = await fetchTokenClass(ctx, sale.sellingToken);
   return {
     inputQuantity: sellTokenDTO.tokenQuantity.toFixed(),
+    totalFees: new BigNumber(transactionFees)
+      .plus(sellTokenDTO.extraFees?.maxAcceptableReverseBondingCurveFee ?? 0)
+      .toFixed(),
     outputQuantity: nativeTokensToProvide.toFixed(),
     tokenName: token.name,
     tradeType: "Sell",

package/src/chaincode/launchpad/sellWithNative.ts

@@ -12,19 +12,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { ValidationFailedError } from "@gala-chain/api";
 import { GalaChainContext, fetchTokenClass, putChainObject, transferToken } from "@gala-chain/chaincode";
-import { BigNumber } from "bignumber.js";
+import BigNumber from "bignumber.js";
 
 import { NativeTokenQuantityDto, TradeResDto } from "../../api/types";
 import { SlippageToleranceExceededError } from "../../api/utils/error";
-import { fetchAndValidateSale } from "../utils";
+import { fetchAndValidateSale, fetchLaunchpadFeeAddress } from "../utils";
 import { callMemeTokenIn } from "./callMemeTokenIn";
 import { payReverseBondingCurveFee } from "./fees";
 
-BigNumber.config({
-  ROUNDING_MODE: BigNumber.ROUND_UP
-});
-
 /**
  * Executes a sale of tokens using native tokens (e.g., GALA) in exchange for the specified token amount.
  *
@@ -48,18 +45,25 @@ export async function sellWithNative(
   ctx: GalaChainContext,
   sellTokenDTO: NativeTokenQuantityDto
 ): Promise<TradeResDto> {
+  // Fetch and validate the sale object
   const sale = await fetchAndValidateSale(ctx, sellTokenDTO.vaultAddress);
 
   const nativeTokensLeftInVault = new BigNumber(sale.nativeTokenQuantity);
+
+  // Cap nativeTokenQuantity to the vault balance if the requested amount exceeds it
   if (nativeTokensLeftInVault.comparedTo(sellTokenDTO.nativeTokenQuantity) < 0) {
-    sellTokenDTO.nativeTokenQuantity = nativeTokensLeftInVault;
+    throw new ValidationFailedError("Not enough GALA in sale contract to carry out this operation.");
   }
 
+  // Calculate how many tokens need to be sold to get the requested native amount
   const callMemeTokenInResult = await callMemeTokenIn(ctx, sellTokenDTO);
+  const transactionFees = callMemeTokenInResult.extraFees.transactionFees;
   const tokensToSell = new BigNumber(callMemeTokenInResult.calculatedQuantity);
+
   const nativeToken = sale.fetchNativeTokenInstanceKey();
   const memeToken = sale.fetchSellingTokenInstanceKey();
 
+  // Enforce slippage tolerance
   if (sellTokenDTO.expectedToken && sellTokenDTO.expectedToken.comparedTo(tokensToSell) < 0) {
     throw new SlippageToleranceExceededError(
       "Token amount expected to cost for this operation is less than the the actual amount required."
@@ -75,6 +79,20 @@ export async function sellWithNative(
     sellTokenDTO.extraFees?.maxAcceptableReverseBondingCurveFee
   );
 
+  // Transfer launchpad transaction fees if applicable
+  const launchpadFeeAddressConfiguration = await fetchLaunchpadFeeAddress(ctx);
+  if (launchpadFeeAddressConfiguration && transactionFees) {
+    await transferToken(ctx, {
+      from: ctx.callingUser,
+      to: launchpadFeeAddressConfiguration.feeAddress,
+      tokenInstanceKey: nativeToken,
+      quantity: new BigNumber(transactionFees),
+      allowancesToUse: [],
+      authorizedOnBehalf: undefined
+    });
+  }
+
+  // Send meme tokens from user to vault
   await transferToken(ctx, {
     from: ctx.callingUser,
     to: sellTokenDTO.vaultAddress,
@@ -83,6 +101,8 @@ export async function sellWithNative(
     allowancesToUse: [],
     authorizedOnBehalf: undefined
   });
+
+  // Send native tokens from vault to user
   await transferToken(ctx, {
     from: sellTokenDTO.vaultAddress,
     to: ctx.callingUser,
@@ -95,12 +115,16 @@ export async function sellWithNative(
     }
   });
 
+  // Update internal sale tracking
   sale.sellToken(tokensToSell, sellTokenDTO.nativeTokenQuantity);
   await putChainObject(ctx, sale);
 
   const token = await fetchTokenClass(ctx, sale.sellingToken);
   return {
     inputQuantity: tokensToSell.toFixed(),
+    totalFees: new BigNumber(transactionFees)
+      .plus(sellTokenDTO.extraFees?.maxAcceptableReverseBondingCurveFee ?? 0)
+      .toFixed(),
     outputQuantity: sellTokenDTO.nativeTokenQuantity.toFixed(),
     tokenName: token.name,
     tradeType: "Sell",