@gala-chain/launchpad 1.0.13 → 1.0.14

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(

package/src/chaincode/launchpad/sellExactToken.ts

@@ -18,9 +18,9 @@ import { BigNumber } from "bignumber.js";
 
 import { ExactTokenQuantityDto, TradeResDto } from "../../api/types";
 import { SlippageToleranceExceededError } from "../../api/utils/error";
-import { fetchAndValidateSale, fetchLaunchpadFeeAddress } from "../utils";
+import { fetchAndValidateSale } from "../utils";
 import { callNativeTokenOut } from "./callNativeTokenOut";
-import { payReverseBondingCurveFee } from "./fees";
+import { payReverseBondingCurveFee, transferTransactionFees } from "./fees";
 
 /**
  * Executes the sale of an exact amount of tokens for native tokens (e.g., GALA).
@@ -49,25 +49,26 @@ export async function sellExactToken(
 
   // Determine how much native token (e.g., GALA) the user will receive for the exact token quantity
   const callNativeTokenOutResult = await callNativeTokenOut(ctx, sellTokenDTO);
-  const nativeTokensToProvide = new BigNumber(callNativeTokenOutResult.calculatedQuantity);
-  const transactionFees = callNativeTokenOutResult.extraFees.transactionFees;
+  const tokensBeingSold = new BigNumber(callNativeTokenOutResult.originalQuantity); // number of tokens user wants to sell
+  const nativeTokensPayout = new BigNumber(callNativeTokenOutResult.calculatedQuantity); // number of native tokens user will receive
+  const transactionFees = new BigNumber(callNativeTokenOutResult.extraFees.transactionFees); // transaction fees
 
   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) {
+  if (new BigNumber(sellTokenDTO.tokenQuantity).isGreaterThan(nativeTokensLeftInVault)) {
     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
+    sellTokenDTO.expectedNativeToken.isGreaterThan(nativeTokensPayout)
   ) {
     throw new SlippageToleranceExceededError(
-      `expected ${sellTokenDTO.expectedNativeToken.toString()}, but only ${nativeTokensToProvide.toString()} tokens can be provided. Reduce the expected amount or adjust your slippage tolerance.`
+      `expected ${sellTokenDTO.expectedNativeToken.toString()}, but only ${nativeTokensPayout.toString()} tokens can be provided. Reduce the expected amount or adjust your slippage tolerance.`
     );
   }
 
@@ -76,29 +77,19 @@ export async function sellExactToken(
   await payReverseBondingCurveFee(
     ctx,
     sale,
-    nativeTokensToProvide,
+    nativeTokensPayout,
     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
-    });
-  }
+  await transferTransactionFees(ctx, sale, transactionFees, nativeToken);
 
   // Transfer meme tokens from user to vault
   await transferToken(ctx, {
     from: ctx.callingUser,
     to: sellTokenDTO.vaultAddress,
     tokenInstanceKey: memeToken,
-    quantity: sellTokenDTO.tokenQuantity,
+    quantity: tokensBeingSold,
     allowancesToUse: [],
     authorizedOnBehalf: undefined
   });
@@ -108,7 +99,7 @@ export async function sellExactToken(
     from: sellTokenDTO.vaultAddress,
     to: ctx.callingUser,
     tokenInstanceKey: nativeToken,
-    quantity: nativeTokensToProvide,
+    quantity: nativeTokensPayout,
     allowancesToUse: [],
     authorizedOnBehalf: {
       callingOnBehalf: sellTokenDTO.vaultAddress,
@@ -117,16 +108,16 @@ export async function sellExactToken(
   });
 
   // Update sale state with this transaction
-  sale.sellToken(sellTokenDTO.tokenQuantity, nativeTokensToProvide);
+  sale.sellToken(tokensBeingSold, nativeTokensPayout);
   await putChainObject(ctx, sale);
 
   const token = await fetchTokenClass(ctx, sale.sellingToken);
   return {
-    inputQuantity: sellTokenDTO.tokenQuantity.toFixed(),
-    totalFees: new BigNumber(transactionFees)
+    inputQuantity: tokensBeingSold.toFixed(),
+    totalFees: transactionFees
       .plus(sellTokenDTO.extraFees?.maxAcceptableReverseBondingCurveFee ?? 0)
       .toFixed(),
-    outputQuantity: nativeTokensToProvide.toFixed(),
+    outputQuantity: nativeTokensPayout.toFixed(),
     tokenName: token.name,
     tradeType: "Sell",
     vaultAddress: sellTokenDTO.vaultAddress,

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

@@ -125,46 +125,6 @@ describe("sellWithNative", () => {
     );
   });
 
-  it("should reject sell when dto contains fractional precision greater than native TokenClass.decimals", async () => {
-    // Given - Setup meme token with 0 decimals to force decimal precision error
-    const zeroDecimalLaunchpadGalaClass = plainToInstance(TokenClass, {
-      ...launchpadgala.tokenClassPlain(),
-      decimals: 8 // This codebase currently hard-codes 8 as NATIVE_TOKEN_DECIMALS...
-    });
-
-    // Simulate prior buys to establish sale state with native tokens
-    sale.buyToken(new BigNumber("100"), new BigNumber("100"));
-
-    const { ctx, contract } = fixture(LaunchpadContract)
-      .registeredUsers(users.testUser1)
-      .savedState(
-        currencyClass,
-        currencyInstance,
-        zeroDecimalLaunchpadGalaClass,
-        launchpadGalaInstance,
-        sale,
-        salelaunchpadGalaBalance,
-        saleCurrencyBalance,
-        userlaunchpadGalaBalance,
-        userCurrencyBalance
-      );
-
-    // Request native tokens that will require fractional meme tokens from bonding curve
-    const sellDto = new NativeTokenQuantityDto(vaultAddress, new BigNumber("0.123456789"));
-    sellDto.uniqueKey = randomUniqueKey();
-    sellDto.sign(users.testUser1.privateKey);
-
-    // When
-    const response = await contract.SellWithNative(ctx, sellDto);
-
-    // Then - Expect error due to decimal precision mismatch
-    expect(response).toEqual(
-      transactionError(
-        new InvalidDecimalError(sellDto.nativeTokenQuantity, zeroDecimalLaunchpadGalaClass.decimals)
-      )
-    );
-  });
-
   it("should sell tokens for native currency successfully", async () => {
     // Given
     sale.buyToken(new BigNumber("10000"), new BigNumber("10")); // Users bought tokens, sale now has GALA
@@ -188,12 +148,12 @@ describe("sellWithNative", () => {
 
     const expectedResponse = plainToInstance(TradeResDto, {
       functionName: "SellWithNative",
-      inputQuantity: "6008.9271949682",
+      inputQuantity: "6008.9271949683",
       isFinalized: false,
       outputQuantity: "0.1",
       tokenName: "AUTOMATEDTESTCOIN",
       totalFees: "0",
-      totalTokenSold: "3991.0728050318",
+      totalTokenSold: "3991.0728050317",
       tradeType: "Sell",
       uniqueKey: sellDto.uniqueKey,
       userAddress: "client|testUser1",