@gala-chain/launchpad 1.0.9 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gala-chain/launchpad",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "GalaChain Launchpad Chaincode",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",
@@ -25,7 +25,7 @@
   "dependencies": {
     "@gala-chain/api": "~2.3.4",
     "@gala-chain/chaincode": "~2.3.4",
-    "@gala-chain/dex": "1.0.4",
+    "@gala-chain/dex": "1.0.19",
     "@grpc/grpc-js": "1.10.10",
     "decimal.js": "^10.5.0",
     "dotenv": "^16.0.1",

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

@@ -23,7 +23,8 @@ import {
   asValidUserAlias,
   randomUniqueKey
 } from "@gala-chain/api";
-import { currency, fixture, users } from "@gala-chain/test";
+import { InvalidDecimalError } from "@gala-chain/chaincode";
+import { currency, fixture, transactionError, transactionSuccess, users } from "@gala-chain/test";
 import BigNumber from "bignumber.js";
 import { plainToInstance } from "class-transformer";
 
@@ -31,7 +32,8 @@ import {
   ExactTokenQuantityDto,
   LaunchpadFeeConfig,
   LaunchpadSale,
-  NativeTokenQuantityDto
+  NativeTokenQuantityDto,
+  TradeResDto
 } from "../../api/types";
 import { LaunchpadContract } from "../LaunchpadContract";
 import launchpadgala from "../test/launchpadgala";
@@ -59,7 +61,7 @@ describe("buyWithNative", () => {
 
     launchpadGalaClass = plainToInstance(TokenClass, {
       ...launchpadgala.tokenClassPlain(),
-      decimals: 18
+      decimals: 8
     });
 
     vaultAddress = asValidUserAlias(`service|${launchpadGalaClassKey.toStringKey()}$launchpad`);
@@ -97,8 +99,8 @@ describe("buyWithNative", () => {
     });
   });
 
-  test("User should be able to buy exact tokens, without fee configured", async () => {
-    //Given
+  it("should properly round buy qty to native token decimals limit when bonding curve produces greater fractional precision", async () => {
+    // Given
     const { ctx, contract } = fixture(LaunchpadContract)
       .registeredUsers(users.testUser1)
       .savedState(
@@ -113,32 +115,97 @@ describe("buyWithNative", () => {
         userCurrencyBalance
       );
 
+    // Choose a token quantity that will produce fractional native tokens from bonding curve
+    // The bonding curve calculation will produce a value like 0.00825575
     const dto = new ExactTokenQuantityDto(vaultAddress, new BigNumber("500"));
+    dto.uniqueKey = randomUniqueKey();
+    dto.sign(users.testUser1.privateKey);
+
+    // When
+    const buyTokenRes = await contract.BuyExactToken(ctx, dto);
+
+    // Then
+    expect(buyTokenRes).toEqual(transactionSuccess());
+  });
 
+  it("should reject buy when meme token has 0 decimals and input dto contains fractional quantity", async () => {
+    // Given - Setup token with 0 decimals to force decimal precision error
+    const zeroDecimalCurrencyClass = plainToInstance(TokenClass, {
+      ...currency.tokenClassPlain(),
+      decimals: 0 // Integer-only token
+    });
+
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .registeredUsers(users.testUser1)
+      .savedState(
+        zeroDecimalCurrencyClass,
+        currencyInstance,
+        launchpadGalaClass,
+        launchpadGalaInstance,
+        sale,
+        salelaunchpadGalaBalance,
+        saleCurrencyBalance,
+        userlaunchpadGalaBalance,
+        userCurrencyBalance
+      );
+
+    const dto = new ExactTokenQuantityDto(vaultAddress, new BigNumber("500.555"));
     dto.uniqueKey = randomUniqueKey();
     dto.sign(users.testUser1.privateKey);
 
-    //When
+    // When
     const buyTokenRes = await contract.BuyExactToken(ctx, dto);
 
-    //Then
-    expect(buyTokenRes.Data).toMatchObject({
+    // Then
+    expect(buyTokenRes).toEqual(
+      transactionError(new InvalidDecimalError(dto.tokenQuantity, zeroDecimalCurrencyClass.decimals))
+    );
+  });
+
+  test("User should be able to buy exact tokens, without fee configured", async () => {
+    // Given
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .registeredUsers(users.testUser1)
+      .savedState(
+        currencyClass,
+        currencyInstance,
+        launchpadGalaClass,
+        launchpadGalaInstance,
+        sale,
+        salelaunchpadGalaBalance,
+        saleCurrencyBalance,
+        userlaunchpadGalaBalance,
+        userCurrencyBalance
+      );
+
+    const dto = new ExactTokenQuantityDto(vaultAddress, new BigNumber("500"));
+
+    dto.uniqueKey = randomUniqueKey();
+    dto.sign(users.testUser1.privateKey);
+
+    const expectedResponse = plainToInstance(TradeResDto, {
       inputQuantity: "0.00825575",
       totalFees: "0.00000000",
+      totalTokenSold: "500",
       outputQuantity: "500",
       tokenName: "AUTOMATEDTESTCOIN",
       tradeType: "Buy",
+      uniqueKey: dto.uniqueKey,
       vaultAddress: "service|GALA$Unit$none$none$launchpad",
       userAddress: "client|testUser1",
       isFinalized: false,
       functionName: "BuyExactToken"
     });
-    expect(buyTokenRes.Data?.inputQuantity).toEqual("0.00825575");
-    expect(buyTokenRes.Data?.outputQuantity).toEqual("500");
+
+    // When
+    const buyTokenRes = await contract.BuyExactToken(ctx, dto);
+
+    // Then
+    expect(buyTokenRes).toEqual(transactionSuccess(expectedResponse));
   });
 
   test("User should be able to buy tokens , fee configured check", async () => {
-    //Given
+    // Given
     const launchpadConfig = new LaunchpadFeeConfig(users.testUser2.identityKey, Number("0.32"), [
       users.testUser2.identityKey
     ]);
@@ -163,26 +230,28 @@ describe("buyWithNative", () => {
     dto.uniqueKey = randomUniqueKey();
     dto.sign(users.testUser1.privateKey);
 
-    //When
-    const buyTokenRes = await contract.BuyExactToken(ctx, dto);
-
-    //Then
-    expect(buyTokenRes.Data).toMatchObject({
+    const expectedResponse = plainToInstance(TradeResDto, {
       inputQuantity: "0.08991559",
       totalFees: "0.02877299",
+      totalTokenSold: "5430",
       outputQuantity: "5430",
       tokenName: "AUTOMATEDTESTCOIN",
       tradeType: "Buy",
       vaultAddress: "service|GALA$Unit$none$none$launchpad",
       userAddress: "client|testUser1",
       isFinalized: false,
-      functionName: "BuyExactToken"
+      functionName: "BuyExactToken",
+      uniqueKey: dto.uniqueKey
     });
-    expect(buyTokenRes.Data?.inputQuantity).toEqual("0.08991559");
-    expect(buyTokenRes.Data?.outputQuantity).toEqual("5430");
+
+    // When
+    const buyTokenRes = await contract.BuyExactToken(ctx, dto);
+
+    // Then
+    expect(buyTokenRes).toEqual(transactionSuccess(expectedResponse));
   });
 
-  test("User should be able to finalise sale , if fee is configured", async () => {
+  test("User should be able to finalize sale , if fee is configured", async () => {
     //Given
     salelaunchpadGalaBalance = plainToInstance(TokenBalance, {
       ...launchpadgala.tokenBalance(),
@@ -229,6 +298,7 @@ describe("buyWithNative", () => {
     const buyTokenRes = await contract.BuyExactToken(ctx, dto);
 
     //Then
+    expect(buyTokenRes).toEqual(transactionSuccess());
     expect(buyTokenRes.Data?.isFinalized).toBe(true);
   });
 

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

@@ -23,11 +23,12 @@ import {
   asValidUserAlias,
   randomUniqueKey
 } from "@gala-chain/api";
-import { currency, fixture, users } from "@gala-chain/test";
+import { InvalidDecimalError } from "@gala-chain/chaincode";
+import { currency, fixture, transactionError, transactionSuccess, users } from "@gala-chain/test";
 import BigNumber from "bignumber.js";
 import { plainToInstance } from "class-transformer";
 
-import { LaunchpadFeeConfig, LaunchpadSale, NativeTokenQuantityDto } from "../../api/types";
+import { LaunchpadFeeConfig, LaunchpadSale, NativeTokenQuantityDto, TradeResDto } from "../../api/types";
 import { LaunchpadContract } from "../LaunchpadContract";
 import launchpadgala from "../test/launchpadgala";
 
@@ -63,7 +64,7 @@ describe("buyWithNative", () => {
     // Initialize sale with manual values
     sale = new LaunchpadSale(
       vaultAddress,
-      launchpadGalaInstance.instanceKeyObj(),
+      currencyInstance.instanceKeyObj(),
       undefined,
       users.testUser1.identityKey
     );
@@ -93,7 +94,79 @@ describe("buyWithNative", () => {
     });
   });
 
-  test("User should be able to buy tokens with providing native gala , without fee configured", async () => {
+  it("should round buy when meme token has 0 decimals and bonding curve produces fractional quantity", async () => {
+    // Given
+    const zeroDecimalCurrencyClass = plainToInstance(TokenClass, {
+      ...currency.tokenClassPlain(),
+      decimals: 0 // Integer-only meme token
+    });
+
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .registeredUsers(users.testUser1)
+      .savedState(
+        currencyInstance,
+        zeroDecimalCurrencyClass,
+        launchpadGalaInstance,
+        launchpadGalaClass,
+        sale,
+        salelaunchpadGalaBalance,
+        saleCurrencyBalance,
+        userlaunchpadGalaBalance,
+        userCurrencyBalance
+      );
+
+    // Use a native token amount that will produce fractional meme tokens from bonding curve
+    const dto = new NativeTokenQuantityDto(vaultAddress, new BigNumber("0.01"));
+    dto.uniqueKey = randomUniqueKey();
+    dto.sign(users.testUser1.privateKey);
+
+    // When
+    const buyTokenRes = await contract.BuyWithNative(ctx, dto);
+
+    // Then - Expect code to round transferToken qty to decimal limit specified by TokenClass
+    expect(buyTokenRes).not.toEqual(
+      transactionError(
+        new InvalidDecimalError(new BigNumber("605.60177406237267161"), zeroDecimalCurrencyClass.decimals)
+      )
+    );
+  });
+
+  it("should reject buy when input dto has higher fractional precision than GALA TokenClass", async () => {
+    // Given
+    const zeroDecimalLaunchpadClass = plainToInstance(TokenClass, {
+      ...launchpadgala.tokenClassPlain(),
+      decimals: 0 // Integer-only meme token
+    });
+
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .registeredUsers(users.testUser1)
+      .savedState(
+        currencyInstance,
+        currencyClass,
+        zeroDecimalLaunchpadClass,
+        launchpadGalaInstance,
+        sale,
+        salelaunchpadGalaBalance,
+        saleCurrencyBalance,
+        userlaunchpadGalaBalance,
+        userCurrencyBalance
+      );
+
+    // Use a native token amount that will produce fractional meme tokens from bonding curve
+    const dto = new NativeTokenQuantityDto(vaultAddress, new BigNumber("0.01"));
+    dto.uniqueKey = randomUniqueKey();
+    dto.sign(users.testUser1.privateKey);
+
+    // When
+    const buyTokenRes = await contract.BuyWithNative(ctx, dto);
+
+    // Then - Expect error due to decimal precision mismatch
+    expect(buyTokenRes).toEqual(
+      transactionError(new InvalidDecimalError(dto.nativeTokenQuantity, zeroDecimalLaunchpadClass.decimals))
+    );
+  });
+
+  test("User buys tokens by providing native gala, without fee needing to be configured", async () => {
     //Given
     const { ctx, contract } = fixture(LaunchpadContract)
       .registeredUsers(users.testUser1)
@@ -114,27 +187,28 @@ describe("buyWithNative", () => {
     dto.uniqueKey = randomUniqueKey();
     dto.sign(users.testUser1.privateKey);
 
-    //When
-    const buyTokenRes = await contract.BuyWithNative(ctx, dto);
-
-    //Then
-    expect(buyTokenRes.Data).toMatchObject({
+    const expectedResponse = plainToInstance(TradeResDto, {
       inputQuantity: "150",
       totalFees: "0.00000000",
-      outputQuantity: "2101667.8890651635002",
+      totalTokenSold: "2101667.8890651635",
+      outputQuantity: "2101667.8890651635",
       tokenName: "AUTOMATEDTESTCOIN",
       tradeType: "Buy",
       vaultAddress: "service|GALA$Unit$none$none$launchpad",
       userAddress: "client|testUser1",
       isFinalized: false,
-      functionName: "BuyWithNative"
+      functionName: "BuyWithNative",
+      uniqueKey: dto.uniqueKey
     });
 
-    expect(buyTokenRes.Data?.inputQuantity).toEqual("150");
-    expect(buyTokenRes.Data?.outputQuantity).toEqual("2101667.8890651635002");
+    //When
+    const buyTokenRes = await contract.BuyWithNative(ctx, dto);
+
+    //Then
+    expect(buyTokenRes).toEqual(transactionSuccess(expectedResponse));
   });
 
-  test("User should be able to buy tokens , fee configured check", async () => {
+  test("User buys tokens, configured fee is checked", async () => {
     //Given
     const launchpadConfig = new LaunchpadFeeConfig(users.testUser2.identityKey, Number("0.32"), [
       users.testUser2.identityKey
@@ -159,25 +233,25 @@ describe("buyWithNative", () => {
     dto.uniqueKey = randomUniqueKey();
     dto.sign(users.testUser1.privateKey);
 
-    //When
-    const buyTokenRes = await contract.BuyWithNative(ctx, dto);
-
-    //Then
-    expect(buyTokenRes.Data).toMatchObject({
+    const expectedResponse = plainToInstance(TradeResDto, {
       inputQuantity: "1000",
       totalFees: "320.00000000",
-      outputQuantity: "3663321.3628130557168",
+      totalTokenSold: "3663321.3628130557",
+      outputQuantity: "3663321.3628130557",
       tokenName: "AUTOMATEDTESTCOIN",
       tradeType: "Buy",
       vaultAddress: "service|GALA$Unit$none$none$launchpad",
       userAddress: "client|testUser1",
       isFinalized: false,
-      functionName: "BuyWithNative"
+      functionName: "BuyWithNative",
+      uniqueKey: dto.uniqueKey
     });
 
-    expect(buyTokenRes.Data?.totalFees).toEqual("320.00000000");
-    expect(buyTokenRes.Data?.inputQuantity).toEqual("1000");
-    expect(buyTokenRes.Data?.outputQuantity).toEqual("3663321.3628130557168");
+    //When
+    const buyTokenRes = await contract.BuyWithNative(ctx, dto);
+
+    //Then
+    expect(buyTokenRes).toEqual(transactionSuccess(expectedResponse));
   });
 
   it("should throw error if user has insufficient funds incuding the transaction fees", async () => {
@@ -211,7 +285,7 @@ describe("buyWithNative", () => {
 
     //Then
     expect(buyTokenRes).toEqual(
-      GalaChainResponse.Error(
+      transactionError(
         new ValidationFailedError(
           "Insufficient balance: Total amount required including fee is 2166101.31430784"
         )

package/src/chaincode/launchpad/buyWithNative.ts

@@ -12,11 +12,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ValidationFailedError } from "@gala-chain/api";
+import { TokenClass, ValidationFailedError } from "@gala-chain/api";
 import {
   GalaChainContext,
   fetchOrCreateBalance,
   fetchTokenClass,
+  getObjectByKey,
   putChainObject,
   transferToken
 } from "@gala-chain/chaincode";
@@ -65,11 +66,24 @@ export async function buyWithNative(
   const nativeToken = sale.fetchNativeTokenInstanceKey();
   const memeToken = sale.fetchSellingTokenInstanceKey();
 
+  // Round tokensToBuy based on decimals property of sellToken TokenClass entry,
+  // because otherwise `transferToken()` call below will fail with
+  // an INVALID_DECIMALS error.
+  const { collection, category, type, additionalKey } = sale.sellingToken;
+
+  const memeTokenClass = await getObjectByKey(
+    ctx,
+    TokenClass,
+    TokenClass.getCompositeKeyFromParts(TokenClass.INDEX_KEY, [collection, category, type, additionalKey])
+  );
+
+  tokensToBuy = tokensToBuy.decimalPlaces(memeTokenClass.decimals);
+
   // If vault has fewer tokens than what user wants to buy, cap the purchase
   if (tokensLeftInVault.comparedTo(tokensToBuy) <= 0) {
-    tokensToBuy = tokensLeftInVault;
-    const nativeTokensrequiredToBuyDto = new ExactTokenQuantityDto(buyTokenDTO.vaultAddress, tokensToBuy);
-    const callNativeTokenInResult = await callNativeTokenIn(ctx, nativeTokensrequiredToBuyDto);
+    tokensToBuy = tokensLeftInVault.decimalPlaces(memeTokenClass.decimals);
+    const nativeTokensRequiredToBuyDto = new ExactTokenQuantityDto(buyTokenDTO.vaultAddress, tokensToBuy);
+    const callNativeTokenInResult = await callNativeTokenIn(ctx, nativeTokensRequiredToBuyDto);
     transactionFees = callMemeTokenOutResult.extraFees.transactionFees;
     buyTokenDTO.nativeTokenQuantity = new BigNumber(callNativeTokenInResult.calculatedQuantity);
     isSaleFinalized = true;
@@ -80,8 +94,9 @@ export async function buyWithNative(
     buyTokenDTO.nativeTokenQuantity
       .plus(new BigNumber(sale.nativeTokenQuantity))
       .gte(new BigNumber(LaunchpadSale.MARKET_CAP))
-  )
+  ) {
     isSaleFinalized = true;
+  }
 
   // Check for slippage condition
   if (buyTokenDTO.expectedToken && buyTokenDTO.expectedToken.comparedTo(tokensToBuy) > 0) {

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

@@ -0,0 +1,244 @@
+/*
+ * 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 {
+  TokenBalance,
+  TokenClass,
+  TokenClassKey,
+  TokenInstance,
+  UserAlias,
+  asValidUserAlias,
+  randomUniqueKey
+} from "@gala-chain/api";
+import { currency, fixture, users } from "@gala-chain/test";
+import BigNumber from "bignumber.js";
+import { plainToInstance } from "class-transformer";
+
+import { LaunchpadSale, NativeTokenQuantityDto } from "../../api/types";
+import { LaunchpadContract } from "../LaunchpadContract";
+import launchpadgala from "../test/launchpadgala";
+
+describe("callMemeTokenIn", () => {
+  let currencyClass: TokenClass;
+  let currencyInstance: TokenInstance;
+  let launchpadGalaClass: TokenClass;
+  let launchpadGalaInstance: TokenInstance;
+  let launchpadGalaClassKey: TokenClassKey;
+  let vaultAddress: UserAlias;
+  let sale: LaunchpadSale;
+  let salelaunchpadGalaBalance: TokenBalance;
+  let saleCurrencyBalance: TokenBalance;
+  let userlaunchpadGalaBalance: TokenBalance;
+  let userCurrencyBalance: TokenBalance;
+
+  beforeEach(() => {
+    currencyClass = currency.tokenClass();
+    currencyInstance = currency.tokenInstance();
+    launchpadGalaClass = launchpadgala.tokenClass();
+    launchpadGalaInstance = launchpadgala.tokenInstance();
+    launchpadGalaClassKey = launchpadgala.tokenClassKey();
+
+    vaultAddress = asValidUserAlias(`service|${launchpadGalaClassKey.toStringKey()}$launchpad`);
+
+    // Initialize sale with manual values
+    sale = new LaunchpadSale(
+      vaultAddress,
+      currencyInstance.instanceKeyObj(),
+      undefined,
+      users.testUser1.identityKey
+    );
+
+    // Create sale balances - sale needs tokens to pay out
+    salelaunchpadGalaBalance = plainToInstance(TokenBalance, {
+      ...launchpadgala.tokenBalance(),
+      owner: vaultAddress,
+      quantity: new BigNumber("97.238975330345368866")
+    });
+    saleCurrencyBalance = plainToInstance(TokenBalance, {
+      ...currency.tokenBalance(),
+      owner: vaultAddress,
+      quantity: new BigNumber("188809.790718")
+    });
+
+    // Create user balances - user needs tokens to swap
+    userlaunchpadGalaBalance = plainToInstance(TokenBalance, {
+      ...launchpadgala.tokenBalance(),
+      owner: users.testUser1.identityKey,
+      quantity: new BigNumber("10000") // User has 10k launchpadGala tokens
+    });
+    userCurrencyBalance = plainToInstance(TokenBalance, {
+      ...currency.tokenBalance(),
+      owner: users.testUser1.identityKey,
+      quantity: new BigNumber("10000") // User has 10k CURRENCY tokens
+    });
+  });
+
+  it("should calculate meme token required amount for selling", async () => {
+    // Given
+    sale.buyToken(new BigNumber("605.60177406237267161"), new BigNumber(0.01));
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .registeredUsers(users.testUser1)
+      .savedState(
+        currencyClass,
+        currencyInstance,
+        launchpadGalaClass,
+        launchpadGalaInstance,
+        sale,
+        salelaunchpadGalaBalance,
+        saleCurrencyBalance,
+        userlaunchpadGalaBalance,
+        userCurrencyBalance
+      );
+
+    const callMemeTokenInDto = new NativeTokenQuantityDto(vaultAddress, new BigNumber(1));
+    callMemeTokenInDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = callMemeTokenInDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.CallMemeTokenIn(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data).toHaveProperty("calculatedQuantity");
+    expect(response.Data).toHaveProperty("extraFees");
+    expect(response.Data?.extraFees).toHaveProperty("reverseBondingCurve");
+    expect(response.Data?.extraFees).toHaveProperty("transactionFees");
+  });
+
+  it("should calculate tokens required for native token amount of 10", async () => {
+    // Given
+    sale.buyToken(new BigNumber("605.60177406237267161"), new BigNumber(0.01));
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .registeredUsers(users.testUser1)
+      .savedState(
+        currencyClass,
+        currencyInstance,
+        launchpadGalaClass,
+        launchpadGalaInstance,
+        sale,
+        salelaunchpadGalaBalance,
+        saleCurrencyBalance,
+        userlaunchpadGalaBalance,
+        userCurrencyBalance
+      );
+
+    const callMemeTokenInDto = new NativeTokenQuantityDto(vaultAddress, new BigNumber(10));
+    callMemeTokenInDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = callMemeTokenInDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.CallMemeTokenIn(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.calculatedQuantity).toBeDefined();
+    expect(new BigNumber(response.Data?.calculatedQuantity || "0").isPositive()).toBe(true);
+  });
+
+  it("should handle edge case with minimal native token amount", async () => {
+    // Given
+    sale.buyToken(new BigNumber("100"), new BigNumber(0.01));
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .registeredUsers(users.testUser1)
+      .savedState(
+        currencyClass,
+        currencyInstance,
+        launchpadGalaClass,
+        launchpadGalaInstance,
+        sale,
+        salelaunchpadGalaBalance,
+        saleCurrencyBalance,
+        userlaunchpadGalaBalance,
+        userCurrencyBalance
+      );
+
+    const callMemeTokenInDto = new NativeTokenQuantityDto(vaultAddress, new BigNumber("0.001"));
+    callMemeTokenInDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = callMemeTokenInDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.CallMemeTokenIn(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.calculatedQuantity).toBeDefined();
+  });
+
+  it("should handle calculation when native token amount exceeds vault balance", async () => {
+    // Given
+    sale.buyToken(new BigNumber("100"), new BigNumber(0.01));
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .registeredUsers(users.testUser1)
+      .savedState(
+        currencyClass,
+        currencyInstance,
+        launchpadGalaClass,
+        launchpadGalaInstance,
+        sale,
+        salelaunchpadGalaBalance,
+        saleCurrencyBalance,
+        userlaunchpadGalaBalance,
+        userCurrencyBalance
+      );
+
+    // Request more native tokens than available in vault
+    const callMemeTokenInDto = new NativeTokenQuantityDto(vaultAddress, new BigNumber("1000000"));
+    callMemeTokenInDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = callMemeTokenInDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.CallMemeTokenIn(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.calculatedQuantity).toBeDefined();
+  });
+
+  it("should calculate correct fees for transaction", async () => {
+    // Given
+    sale.buyToken(new BigNumber("500"), new BigNumber(0.01));
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .registeredUsers(users.testUser1)
+      .savedState(
+        currencyClass,
+        currencyInstance,
+        launchpadGalaClass,
+        launchpadGalaInstance,
+        sale,
+        salelaunchpadGalaBalance,
+        saleCurrencyBalance,
+        userlaunchpadGalaBalance,
+        userCurrencyBalance
+      );
+
+    const callMemeTokenInDto = new NativeTokenQuantityDto(vaultAddress, new BigNumber(5));
+    callMemeTokenInDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = callMemeTokenInDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.CallMemeTokenIn(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.extraFees.reverseBondingCurve).toBeDefined();
+    expect(response.Data?.extraFees.transactionFees).toBeDefined();
+    expect(new BigNumber(response.Data?.extraFees.reverseBondingCurve || "0").isFinite()).toBe(true);
+    expect(new BigNumber(response.Data?.extraFees.transactionFees || "0").isFinite()).toBe(true);
+  });
+});