@gala-chain/launchpad 1.0.13 → 1.0.15

package/src/chaincode/launchpad/createSale.ts

@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ConflictError, TokenInstanceKey, asValidUserAlias } from "@gala-chain/api";
+import { ConflictError, DefaultError, TokenInstanceKey, asValidUserAlias } from "@gala-chain/api";
 import {
   GalaChainContext,
   createTokenClass,
@@ -23,7 +23,13 @@ import {
 } from "@gala-chain/chaincode";
 import BigNumber from "bignumber.js";
 
-import { CreateSaleResDto, CreateTokenSaleDTO, LaunchpadSale, NativeTokenQuantityDto } from "../../api/types";
+import {
+  CreateSaleResDto,
+  CreateTokenSaleDTO,
+  LaunchpadSale,
+  NativeTokenQuantityDto,
+  SaleStatus
+} from "../../api/types";
 import { PreConditionFailedError } from "../../api/utils/error";
 import { buyWithNative } from "./buyWithNative";
 
@@ -85,7 +91,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,
@@ -131,6 +137,23 @@ export async function createSale(
     isSaleFinalized = tradeStatus.isFinalized;
   }
 
+  // handling the optional saleStartTime after the preBuyQuantity allows
+  // creators to still optionally specify a pre-buy even when a
+  // sale is marked Upcoming / Coming Soon.
+  // Otherwise `buyWithNative` would throw an error when validating the sale is active.
+  if (launchpadDetails.saleStartTime !== undefined) {
+    launchpad.saleStartTime = launchpadDetails.saleStartTime;
+
+    // handle edge case
+    // if a sale was immediately sold out with a pre-buy on creation,
+    // do not set the ended sale back to UPCOMING
+    if (launchpad.saleStatus !== SaleStatus.END) {
+      launchpad.saleStatus = SaleStatus.UPCOMING;
+    }
+
+    await putChainObject(ctx, launchpad);
+  }
+
   // Return the response object
   return {
     image: launchpadDetails.tokenImage,

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);

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

@@ -12,8 +12,9 @@
  * 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 { randomUniqueKey } from "@gala-chain/api";
+import { fixture, transactionSuccess, users } from "@gala-chain/test";
+import { plainToInstance } from "class-transformer";
 
 import {
   AuthorizeBatchSubmitterDto,
@@ -22,6 +23,7 @@ import {
   FetchBatchSubmitAuthoritiesDto,
   LaunchpadBatchSubmitAuthorities
 } from "../../api/types";
+import { LaunchpadContract } from "../LaunchpadContract";
 import {
   authorizeLaunchpadBatchSubmitter,
   deauthorizeLaunchpadBatchSubmitter,
@@ -29,37 +31,8 @@ import {
   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", () => {
+  describe("BatchSubmitAuthorities chain object", () => {
     it("should create with initial authorities", () => {
       const auth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
       expect(auth.authorities).toEqual(["user1", "user2"]);
@@ -99,87 +72,196 @@ describe("BatchSubmitAuthorizations", () => {
     });
   });
 
-  describe("fetchBatchSubmitAuthorizations", () => {
+  describe("fetchLaunchpadBatchSubmitAuthorities", () => {
     it("should return existing authorizations", async () => {
-      const ctx = createMockContext("user1");
-      const existingAuth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+      // Given
+      const existingAuth = new LaunchpadBatchSubmitAuthorities([
+        users.testUser1.identityKey,
+        users.testUser2.identityKey
+      ]);
 
-      (getObjectByKey as jest.Mock).mockResolvedValue(existingAuth);
-      (putChainObject as jest.Mock).mockResolvedValue(undefined);
+      const { ctx } = fixture(LaunchpadContract).registeredUsers(users.testUser1).savedState(existingAuth);
 
+      // When
       const result = await fetchLaunchpadBatchSubmitAuthorities(ctx);
 
-      expect(result).toBe(existingAuth);
+      // Then
+      expect(result).toBeInstanceOf(LaunchpadBatchSubmitAuthorities);
+      expect(result.authorities).toContain(users.testUser1.identityKey);
+      expect(result.authorities).toContain(users.testUser2.identityKey);
     });
   });
 
-  describe("authorizeBatchSubmitter", () => {
+  describe("authorizeLaunchpadBatchSubmitter", () => {
     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);
+      // Given
+      const existingAuth = new LaunchpadBatchSubmitAuthorities([users.testUser1.identityKey]);
+
+      const { ctx } = fixture(LaunchpadContract).registeredUsers(users.testUser1).savedState(existingAuth);
 
       const dto = new AuthorizeBatchSubmitterDto();
-      dto.authorities = ["user2", "user3"];
+      dto.authorities = [users.testUser2.identityKey];
+      dto.uniqueKey = randomUniqueKey();
+      dto.sign(users.testUser1.privateKey);
 
+      // When
       const result = await authorizeLaunchpadBatchSubmitter(ctx, dto);
 
+      // Then
       expect(result).toBeInstanceOf(BatchSubmitAuthoritiesResDto);
-      expect(result.authorities).toContain("user1");
-      expect(result.authorities).toContain("user2");
-      expect(result.authorities).toContain("user3");
+      expect(result.authorities).toContain(users.testUser1.identityKey);
+      expect(result.authorities).toContain(users.testUser2.identityKey);
     });
 
     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);
+      // Given
+      const { ctx } = fixture(LaunchpadContract).registeredUsers(users.testUser1);
 
       const dto = new AuthorizeBatchSubmitterDto();
-      dto.authorities = ["user1", "user2"];
+      dto.authorities = [users.testUser1.identityKey, users.testUser2.identityKey];
+      dto.uniqueKey = randomUniqueKey();
+      dto.sign(users.testUser1.privateKey);
 
+      // When
       const result = await authorizeLaunchpadBatchSubmitter(ctx, dto);
 
+      // Then
       expect(result).toBeInstanceOf(BatchSubmitAuthoritiesResDto);
-      expect(result.authorities).toContain("user1");
-      expect(result.authorities).toContain("user2");
-      expect(putChainObject).toHaveBeenCalled();
+      expect(result.authorities).toContain(users.testUser1.identityKey);
+      expect(result.authorities).toContain(users.testUser2.identityKey);
     });
   });
 
-  describe("deauthorizeBatchSubmitter", () => {
+  describe("deauthorizeLaunchpadBatchSubmitter", () => {
     it("should deauthorize user when caller is authorized", async () => {
-      const ctx = createMockContext("user1");
-      const existingAuth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+      // Given
+      const existingAuth = new LaunchpadBatchSubmitAuthorities([
+        users.testUser1.identityKey,
+        users.testUser2.identityKey
+      ]);
 
-      (getObjectByKey as jest.Mock).mockResolvedValue(existingAuth);
-      (putChainObject as jest.Mock).mockResolvedValue(undefined);
+      const { ctx } = fixture(LaunchpadContract).registeredUsers(users.testUser1).savedState(existingAuth);
 
       const dto = new DeauthorizeBatchSubmitterDto();
-      dto.authority = "user2";
+      dto.authority = users.testUser2.identityKey;
+      dto.uniqueKey = randomUniqueKey();
+      dto.sign(users.testUser1.privateKey);
 
+      // When
       const result = await deauthorizeLaunchpadBatchSubmitter(ctx, dto);
 
+      // Then
       expect(result).toBeInstanceOf(BatchSubmitAuthoritiesResDto);
-      expect(result.authorities).toContain("user1");
-      expect(result.authorities).not.toContain("user2");
+      expect(result.authorities).toContain(users.testUser1.identityKey);
+      expect(result.authorities).not.toContain(users.testUser2.identityKey);
     });
   });
 
-  describe("getBatchSubmitAuthorizations", () => {
+  describe("getLaunchpadBatchSubmitAuthorities", () => {
     it("should return current authorizations", async () => {
-      const ctx = createMockContext("user1");
-      const existingAuth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+      // Given
+      const existingAuth = new LaunchpadBatchSubmitAuthorities([
+        users.testUser1.identityKey,
+        users.testUser2.identityKey
+      ]);
 
-      (getObjectByKey as jest.Mock).mockResolvedValue(existingAuth);
+      const { ctx } = fixture(LaunchpadContract).registeredUsers(users.testUser1).savedState(existingAuth);
 
       const dto = new FetchBatchSubmitAuthoritiesDto();
+      dto.uniqueKey = randomUniqueKey();
+      dto.sign(users.testUser1.privateKey);
+
+      // When
       const result = await getLaunchpadBatchSubmitAuthorities(ctx, dto);
 
+      // Then
       expect(result).toBeInstanceOf(BatchSubmitAuthoritiesResDto);
-      expect(result.authorities).toEqual(["user1", "user2"]);
+      expect(result.authorities).toEqual([users.testUser1.identityKey, users.testUser2.identityKey]);
+    });
+  });
+
+  describe("AuthorizeBatchSubmitter contract method", () => {
+    it("should authorize new users through contract", async () => {
+      // Given
+      const existingAuth = new LaunchpadBatchSubmitAuthorities([users.admin.identityKey]);
+
+      const { ctx, contract } = fixture(LaunchpadContract)
+        .caClientIdentity("test-admin", "CuratorOrg")
+        .registeredUsers(users.admin)
+        .savedState(existingAuth);
+
+      const dto = new AuthorizeBatchSubmitterDto();
+      dto.authorities = [users.testUser2.identityKey];
+      dto.uniqueKey = randomUniqueKey();
+      dto.sign(users.admin.privateKey);
+
+      const expectedResponse = plainToInstance(BatchSubmitAuthoritiesResDto, {
+        authorities: [users.admin.identityKey, users.testUser2.identityKey]
+      });
+
+      // When
+      const result = await contract.AuthorizeBatchSubmitter(ctx, dto);
+
+      // Then
+      expect(result).toEqual(transactionSuccess(expectedResponse));
+    });
+  });
+
+  describe("DeauthorizeBatchSubmitter contract method", () => {
+    it("should deauthorize user through contract", async () => {
+      // Given
+      const existingAuth = new LaunchpadBatchSubmitAuthorities([
+        users.admin.identityKey,
+        users.testUser2.identityKey
+      ]);
+
+      const { ctx, contract } = fixture(LaunchpadContract)
+        .caClientIdentity("test-admin", "CuratorOrg")
+        .registeredUsers(users.admin)
+        .savedState(existingAuth);
+
+      const dto = new DeauthorizeBatchSubmitterDto();
+      dto.authority = users.testUser2.identityKey;
+      dto.uniqueKey = randomUniqueKey();
+      dto.sign(users.admin.privateKey);
+
+      const expectedResponse = plainToInstance(BatchSubmitAuthoritiesResDto, {
+        authorities: [users.admin.identityKey]
+      });
+
+      // When
+      const result = await contract.DeauthorizeBatchSubmitter(ctx, dto);
+
+      // Then
+      expect(result).toEqual(transactionSuccess(expectedResponse));
+    });
+  });
+
+  describe("GetBatchSubmitAuthorities contract method", () => {
+    it("should return current authorizations through contract", async () => {
+      // Given
+      const existingAuth = new LaunchpadBatchSubmitAuthorities([
+        users.testUser1.identityKey,
+        users.testUser2.identityKey
+      ]);
+
+      const { ctx, contract } = fixture(LaunchpadContract)
+        .registeredUsers(users.testUser1)
+        .savedState(existingAuth);
+
+      const dto = new FetchBatchSubmitAuthoritiesDto();
+      dto.uniqueKey = randomUniqueKey();
+      dto.sign(users.testUser1.privateKey);
+
+      const expectedResponse = plainToInstance(BatchSubmitAuthoritiesResDto, {
+        authorities: [users.testUser1.identityKey, users.testUser2.identityKey]
+      });
+
+      // When
+      const result = await contract.GetBatchSubmitAuthorities(ctx, dto);
+
+      // Then
+      expect(result).toEqual(transactionSuccess(expectedResponse));
     });
   });
 });

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

@@ -21,8 +21,7 @@ import {
   asValidUserAlias,
   randomUniqueKey
 } from "@gala-chain/api";
-import { InvalidDecimalError } from "@gala-chain/chaincode";
-import { currency, fixture, transactionError, users } from "@gala-chain/test";
+import { currency, fixture, users } from "@gala-chain/test";
 import BigNumber from "bignumber.js";
 import { plainToInstance } from "class-transformer";
 
@@ -87,7 +86,7 @@ describe("sellExactToken", () => {
 
   it("should sell exact token amount successfully", async () => {
     // Given
-    sale.buyToken(new BigNumber("1000"), new BigNumber("50")); // Users bought tokens, sale now has GALA
+    sale.buyToken(new BigNumber("1000"), new BigNumber("100")); // Users bought tokens, sale now has GALA
     const { ctx, contract } = fixture(LaunchpadContract)
       .registeredUsers(users.testUser1)
       .savedState(
@@ -116,82 +115,6 @@ describe("sellExactToken", () => {
     expect(response.Data).toHaveProperty("isFinalized");
   });
 
-  it("should reject sell when native token has 0 decimals and bonding curve produces fractional quantity", async () => {
-    // Given
-    const zeroDecimalNativeClass = plainToInstance(TokenClass, {
-      ...launchpadgala.tokenClassPlain(),
-      decimals: 0 // Integer-only native token
-    });
-
-    // Simulate prior buys to establish sale state
-    sale.buyToken(new BigNumber("5000"), new BigNumber("100"));
-
-    const { ctx, contract } = fixture(LaunchpadContract)
-      .registeredUsers(users.testUser1)
-      .savedState(
-        currencyClass,
-        currencyInstance,
-        zeroDecimalNativeClass,
-        launchpadGalaInstance,
-        sale,
-        salelaunchpadGalaBalance,
-        saleCurrencyBalance,
-        userlaunchpadGalaBalance,
-        userCurrencyBalance
-      );
-
-    // Choose a token quantity that will produce fractional native tokens from bonding curve
-    const sellDto = new ExactTokenQuantityDto(vaultAddress, new BigNumber("100"));
-    sellDto.uniqueKey = randomUniqueKey();
-    const signedDto = sellDto.signed(users.testUser1.privateKey);
-
-    // When
-    const response = await contract.SellExactToken(ctx, signedDto);
-
-    // Then - Expect error due to decimal precision mismatch
-    expect(response).toEqual(
-      transactionError(new InvalidDecimalError(new BigNumber("0.00166022"), zeroDecimalNativeClass.decimals))
-    );
-  });
-
-  it("should reject sell when meme token has 0 decimals and input dto contains greater fractional precision", async () => {
-    // Given
-    const zeroDecimalMemeClass = plainToInstance(TokenClass, {
-      ...currency.tokenClassPlain(),
-      decimals: 0 // Integer-only native token
-    });
-
-    // Simulate prior buys to establish sale state
-    sale.buyToken(new BigNumber("5000"), new BigNumber("100"));
-
-    const { ctx, contract } = fixture(LaunchpadContract)
-      .registeredUsers(users.testUser1)
-      .savedState(
-        zeroDecimalMemeClass,
-        currencyInstance,
-        launchpadGalaClass,
-        launchpadGalaInstance,
-        sale,
-        salelaunchpadGalaBalance,
-        saleCurrencyBalance,
-        userlaunchpadGalaBalance,
-        userCurrencyBalance
-      );
-
-    // Choose a token quantity that will produce fractional native tokens from bonding curve
-    const sellDto = new ExactTokenQuantityDto(vaultAddress, new BigNumber("100.555"));
-    sellDto.uniqueKey = randomUniqueKey();
-    const signedDto = sellDto.signed(users.testUser1.privateKey);
-
-    // When
-    const response = await contract.SellExactToken(ctx, signedDto);
-
-    // Then - Expect error due to decimal precision mismatch
-    expect(response).toEqual(
-      transactionError(new InvalidDecimalError(sellDto.tokenQuantity, zeroDecimalMemeClass.decimals))
-    );
-  });
-
   it("should handle small token sell amount", async () => {
     // Given
     sale.buyToken(new BigNumber("500"), new BigNumber("25")); // Users bought tokens, sale now has GALA
@@ -224,7 +147,7 @@ describe("sellExactToken", () => {
 
   it("should handle sell with expected native token parameter", async () => {
     // Given
-    sale.buyToken(new BigNumber("800"), new BigNumber("40")); // Users bought tokens, sale now has GALA
+    sale.buyToken(new BigNumber("800"), new BigNumber("50")); // Users bought tokens, sale now has GALA
     const { ctx, contract } = fixture(LaunchpadContract)
       .registeredUsers(users.testUser1)
       .savedState(
@@ -254,7 +177,7 @@ describe("sellExactToken", () => {
 
   it("should handle large token sell amount", async () => {
     // Given
-    sale.buyToken(new BigNumber("2000"), new BigNumber("100")); // Users bought tokens, sale now has GALA
+    sale.buyToken(new BigNumber("2000"), new BigNumber("500")); // Users bought tokens, sale now has GALA
     const { ctx, contract } = fixture(LaunchpadContract)
       .registeredUsers(users.testUser1)
       .savedState(