@gala-chain/launchpad 1.0.8 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gala-chain/launchpad",
-  "version": "1.0.8",
+  "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`);
@@ -67,7 +69,7 @@ describe("buyWithNative", () => {
     // Initialize sale with manual values
     sale = new LaunchpadSale(
       vaultAddress,
-      launchpadGalaInstance.instanceKeyObj(),
+      currencyInstance.instanceKeyObj(),
       undefined,
       users.testUser1.identityKey
     );
@@ -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,23 +230,76 @@ 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
+    });
+
+    // When
+    const buyTokenRes = await contract.BuyExactToken(ctx, dto);
+
+    // Then
+    expect(buyTokenRes).toEqual(transactionSuccess(expectedResponse));
+  });
+
+  test("User should be able to finalize sale , if fee is configured", async () => {
+    //Given
+    salelaunchpadGalaBalance = plainToInstance(TokenBalance, {
+      ...launchpadgala.tokenBalance(),
+      owner: vaultAddress,
+      quantity: new BigNumber("0")
     });
-    expect(buyTokenRes.Data?.inputQuantity).toEqual("0.08991559");
-    expect(buyTokenRes.Data?.outputQuantity).toEqual("5430");
+
+    saleCurrencyBalance = plainToInstance(TokenBalance, {
+      ...currency.tokenBalance(),
+      owner: vaultAddress,
+      quantity: new BigNumber("2e+7")
+    });
+    userlaunchpadGalaBalance = plainToInstance(TokenBalance, {
+      ...launchpadgala.tokenBalance(),
+      owner: users.testUser1.identityKey,
+      quantity: new BigNumber("100000000")
+    });
+
+    const launchpadConfig = new LaunchpadFeeConfig(users.testUser2.identityKey, Number("0.001"), [
+      users.testUser2.identityKey
+    ]);
+
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .registeredUsers(users.testUser1)
+      .savedState(
+        currencyClass,
+        currencyInstance,
+        launchpadGalaClass,
+        launchpadGalaInstance,
+        sale,
+        salelaunchpadGalaBalance,
+        saleCurrencyBalance,
+        userlaunchpadGalaBalance,
+        userCurrencyBalance,
+        launchpadConfig
+      );
+
+    const dto = new ExactTokenQuantityDto(vaultAddress, new BigNumber("10000000"));
+
+    dto.uniqueKey = randomUniqueKey();
+    dto.sign(users.testUser1.privateKey);
+
+    //When
+    const buyTokenRes = await contract.BuyExactToken(ctx, dto);
+
+    //Then
+    expect(buyTokenRes).toEqual(transactionSuccess());
+    expect(buyTokenRes.Data?.isFinalized).toBe(true);
   });
 
   it("should throw error if user has insufficient funds incuding the transaction fees", async () => {

package/src/chaincode/launchpad/buyExactToken.ts

@@ -89,7 +89,7 @@ export async function buyExactToken(
   // Transfer transaction fees
   const launchpadFeeAddressConfiguration = await fetchLaunchpadFeeAddress(ctx);
   if (launchpadFeeAddressConfiguration && transactionFees) {
-    const totalRequired = new BigNumber(buyTokenDTO.tokenQuantity).plus(transactionFees);
+    const totalRequired = nativeTokensToBuy.plus(new BigNumber(transactionFees));
 
     const buyerBalance = await fetchOrCreateBalance(ctx, ctx.callingUser, sale.nativeToken);
     if (buyerBalance.getQuantityTotal().lt(totalRequired)) {

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