@gala-chain/launchpad 1.0.8 → 1.0.10

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

@@ -0,0 +1,259 @@
+/*
+ * 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, TokenInstance, randomUniqueKey } from "@gala-chain/api";
+import { currency, fixture, users } from "@gala-chain/test";
+import BigNumber from "bignumber.js";
+import { plainToInstance } from "class-transformer";
+
+import { CreateTokenSaleDTO } from "../../api/types";
+import { LaunchpadContract } from "../LaunchpadContract";
+
+describe("createSale", () => {
+  it("should create a new token sale successfully", async () => {
+    // Given
+    const { ctx, contract } = fixture(LaunchpadContract).registeredUsers(users.testUser1);
+
+    const createSaleDto = new CreateTokenSaleDTO(
+      "Test Token",
+      "TEST",
+      "A test token for launchpad",
+      "https://example.com/token.png",
+      new BigNumber(0),
+      "TestCollection",
+      "TestCategory"
+    );
+    createSaleDto.websiteUrl = "https://example.com";
+    createSaleDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = createSaleDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.CreateSale(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.tokenName).toBe("Test Token");
+    expect(response.Data?.symbol).toBe("TEST");
+    expect(response.Data?.description).toBe("A test token for launchpad");
+    expect(response.Data?.collection).toBe("TestCollection");
+    expect(response.Data?.category).toBe("TestCategory");
+    expect(response.Data?.vaultAddress).toBeDefined();
+    expect(response.Data?.creatorAddress).toBe(users.testUser1.identityKey);
+    expect(response.Data?.isFinalized).toBe(false);
+  });
+
+  it("should create token sale with telegram URL", async () => {
+    // Given
+    const { ctx, contract } = fixture(LaunchpadContract).registeredUsers(users.testUser1);
+
+    const createSaleDto = new CreateTokenSaleDTO(
+      "Telegram Token",
+      "TG",
+      "A token with telegram link",
+      "https://example.com/tg.png",
+      new BigNumber(0),
+      "TelegramCollection",
+      "SocialCategory"
+    );
+    createSaleDto.telegramUrl = "https://t.me/testtoken";
+    createSaleDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = createSaleDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.CreateSale(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.telegramUrl).toBe("https://t.me/testtoken");
+    expect(response.Data?.websiteUrl).toBe("");
+    expect(response.Data?.twitterUrl).toBe("");
+  });
+
+  it("should create token sale with twitter URL", async () => {
+    // Given
+    const { ctx, contract } = fixture(LaunchpadContract).registeredUsers(users.testUser1);
+
+    const createSaleDto = new CreateTokenSaleDTO(
+      "Twitter Token",
+      "TWT",
+      "A token with twitter link",
+      "https://example.com/twt.png",
+      new BigNumber(0),
+      "TwitterCollection",
+      "SocialCategory"
+    );
+    createSaleDto.twitterUrl = "https://twitter.com/testtoken";
+    createSaleDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = createSaleDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.CreateSale(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.twitterUrl).toBe("https://twitter.com/testtoken");
+  });
+
+  it("should create token sale with pre-buy amount", async () => {
+    // Given - Setup GALA token for pre-buy (matching LaunchpadSale nativeToken)
+    const galaClass = plainToInstance(TokenClass, {
+      collection: "GALA",
+      category: "Unit",
+      type: "none",
+      additionalKey: "none",
+      decimals: 8,
+      name: "GALA",
+      symbol: "GALA",
+      description: "GALA token",
+      image: "",
+      maxSupply: new BigNumber("1e+10"),
+      maxCapacity: new BigNumber("1e+10"),
+      totalMintAllowance: new BigNumber("1e+10"),
+      totalSupply: new BigNumber("1e+10"),
+      totalBurned: new BigNumber("0"),
+      authorities: [users.testUser1.identityKey]
+    });
+
+    const galaInstance = plainToInstance(TokenInstance, {
+      collection: "GALA",
+      category: "Unit",
+      type: "none",
+      additionalKey: "none",
+      instance: new BigNumber(0),
+      isNonFungible: false,
+      owner: users.testUser1.identityKey,
+      quantity: new BigNumber("1e+10")
+    });
+
+    const userGalaBalance = plainToInstance(TokenBalance, {
+      collection: "GALA",
+      category: "Unit",
+      type: "none",
+      additionalKey: "none",
+      instance: new BigNumber(0),
+      owner: users.testUser1.identityKey,
+      quantity: new BigNumber("1000") // User has GALA for pre-buy
+    });
+
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .registeredUsers(users.testUser1)
+      .savedState(galaClass, galaInstance, userGalaBalance);
+
+    const createSaleDto = new CreateTokenSaleDTO(
+      "Pre-buy Token",
+      "PRE",
+      "A token with pre-buy",
+      "https://example.com/pre.png",
+      new BigNumber("10"),
+      "PreBuyCollection",
+      "PreBuyCategory"
+    );
+    createSaleDto.websiteUrl = "https://example.com";
+    createSaleDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = createSaleDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.CreateSale(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.initialBuyQuantity).toBe("10");
+  });
+
+  it("should convert token symbol to uppercase", async () => {
+    // Given
+    const { ctx, contract } = fixture(LaunchpadContract).registeredUsers(users.testUser1);
+
+    const createSaleDto = new CreateTokenSaleDTO(
+      "Lowercase Token",
+      "lower", // lowercase symbol
+      "A token with lowercase symbol",
+      "https://example.com/lower.png",
+      new BigNumber(0),
+      "LowerCollection",
+      "LowerCategory"
+    );
+    createSaleDto.websiteUrl = "https://example.com";
+    createSaleDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = createSaleDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.CreateSale(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.symbol).toBe("LOWER"); // Should be converted to uppercase
+  });
+
+  it("should create sale with all social media URLs", async () => {
+    // Given
+    const { ctx, contract } = fixture(LaunchpadContract).registeredUsers(users.testUser1);
+
+    const createSaleDto = new CreateTokenSaleDTO(
+      "Social Token",
+      "SOC",
+      "A fully connected social token",
+      "https://example.com/soc.png",
+      new BigNumber(0),
+      "SocialCollection",
+      "FullSocialCategory"
+    );
+    createSaleDto.websiteUrl = "https://socialtoken.com";
+    createSaleDto.telegramUrl = "https://t.me/socialtoken";
+    createSaleDto.twitterUrl = "https://twitter.com/socialtoken";
+    createSaleDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = createSaleDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.CreateSale(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.websiteUrl).toBe("https://socialtoken.com");
+    expect(response.Data?.telegramUrl).toBe("https://t.me/socialtoken");
+    expect(response.Data?.twitterUrl).toBe("https://twitter.com/socialtoken");
+  });
+
+  it("should create sale with custom token image", async () => {
+    // Given
+    const { ctx, contract } = fixture(LaunchpadContract).registeredUsers(users.testUser1);
+
+    const createSaleDto = new CreateTokenSaleDTO(
+      "Image Token",
+      "IMG",
+      "A token with custom image",
+      "https://cdn.example.com/token-logo.png",
+      new BigNumber(0),
+      "ImageCollection",
+      "ImageCategory"
+    );
+    createSaleDto.websiteUrl = "https://example.com";
+    createSaleDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = createSaleDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.CreateSale(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.image).toBe("https://cdn.example.com/token-logo.png");
+  });
+});

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

@@ -0,0 +1,141 @@
+/*
+ * 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 {
+  TokenInstance,
+  TokenInstanceKey,
+  UserAlias,
+  asValidUserAlias,
+  randomUniqueKey
+} from "@gala-chain/api";
+import { fixture, users } from "@gala-chain/test";
+import BigNumber from "bignumber.js";
+
+import { FetchSaleDto, LaunchpadSale, ReverseBondingCurveConfigurationChainObject } from "../../api/types";
+import { LaunchpadContract } from "../LaunchpadContract";
+import launchpadgala from "../test/launchpadgala";
+
+describe("fetchSaleDetails", () => {
+  let launchpadGalaInstance: TokenInstance;
+  let vaultAddress: UserAlias;
+  let sale: LaunchpadSale;
+
+  beforeEach(() => {
+    launchpadGalaInstance = launchpadgala.tokenInstance();
+    vaultAddress = asValidUserAlias(`service|${launchpadgala.tokenClassKey().toStringKey()}$launchpad`);
+
+    // Initialize sale
+    sale = new LaunchpadSale(
+      vaultAddress,
+      launchpadGalaInstance.instanceKeyObj(),
+      undefined,
+      users.testUser1.identityKey
+    );
+  });
+
+  it("should fetch existing sale details successfully", async () => {
+    // Given
+    const { ctx, contract } = fixture(LaunchpadContract).registeredUsers(users.testUser1).savedState(sale);
+
+    const fetchSaleDto = new FetchSaleDto(vaultAddress);
+    fetchSaleDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = fetchSaleDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.FetchSaleDetails(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.vaultAddress).toBe(vaultAddress);
+    expect(response.Data?.saleOwner).toBe(users.testUser1.identityKey);
+    expect(response.Data?.sellingToken).toEqual(launchpadGalaInstance.instanceKeyObj());
+  });
+
+  it("should handle sale with existing trades", async () => {
+    // Given
+    sale.buyToken(new BigNumber("100"), new BigNumber("0.01"));
+    const { ctx, contract } = fixture(LaunchpadContract).registeredUsers(users.testUser1).savedState(sale);
+
+    const fetchSaleDto = new FetchSaleDto(vaultAddress);
+    fetchSaleDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = fetchSaleDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.FetchSaleDetails(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.fetchTokensSold()).toBe("100");
+    expect(new BigNumber(response.Data?.nativeTokenQuantity || "0").isPositive()).toBe(true);
+  });
+
+  it("should return sale with correct finalization status", async () => {
+    // Given - Create finalized sale
+    sale.finalizeSale();
+    const { ctx, contract } = fixture(LaunchpadContract).registeredUsers(users.testUser1).savedState(sale);
+
+    const fetchSaleDto = new FetchSaleDto(vaultAddress);
+    fetchSaleDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = fetchSaleDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.FetchSaleDetails(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.saleStatus).toBe("Finished");
+  });
+
+  it("should fetch sale with reverse bonding curve configuration", async () => {
+    // Given - Create sale with reverse bonding curve
+    const tokenInstanceKey = new TokenInstanceKey();
+    tokenInstanceKey.collection = "TestCollection";
+    tokenInstanceKey.category = "TestCategory";
+    tokenInstanceKey.type = "TEST";
+    tokenInstanceKey.additionalKey = "test:key";
+    tokenInstanceKey.instance = new BigNumber(0);
+
+    const reverseBondingCurveConfig = new ReverseBondingCurveConfigurationChainObject(
+      new BigNumber(0.02), // minFeePortion
+      new BigNumber(0.05) // maxFeePortion
+    );
+
+    const saleWithConfig = new LaunchpadSale(
+      vaultAddress,
+      tokenInstanceKey,
+      reverseBondingCurveConfig,
+      users.testUser1.identityKey
+    );
+
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .registeredUsers(users.testUser1)
+      .savedState(saleWithConfig);
+
+    const fetchSaleDto = new FetchSaleDto(vaultAddress);
+    fetchSaleDto.uniqueKey = randomUniqueKey();
+
+    const signedDto = fetchSaleDto.signed(users.testUser1.privateKey);
+
+    // When
+    const response = await contract.FetchSaleDetails(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.reverseBondingCurveConfiguration).toBeDefined();
+    expect(response.Data?.reverseBondingCurveConfiguration?.maxFeePortion).toEqual(new BigNumber(0.05));
+  });
+});

package/src/chaincode/launchpad/finaliseSale.ts

@@ -52,7 +52,7 @@ export async function finalizeSale(ctx: GalaChainContext, sale: LaunchpadSale):
   }
 
   const platformFeePercentage = feeAllocation ? feeAllocation.platformFeePercentage : 0.01;
-  const ownerAllocationPercentage = feeAllocation ? feeAllocation.ownerAllocationPercentage : 0.5;
+  const ownerAllocationPercentage = feeAllocation ? feeAllocation.ownerAllocationPercentage : 0.05;
   const liquidityAllocationPercentage = feeAllocation ? feeAllocation.liquidityAllocationPercentage : 0.94;
 
   const nativeToken = sale.fetchNativeTokenInstanceKey();

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

@@ -0,0 +1,126 @@
+/*
+ * 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 { asValidUserAlias, randomUniqueKey } from "@gala-chain/api";
+import { fixture, users } from "@gala-chain/test";
+
+import { FinalizeTokenAllocationDto, LaunchpadFeeConfig } from "../../api/types";
+import { LaunchpadContract } from "../LaunchpadContract";
+
+describe("finalizeTokenAllocation", () => {
+  let feeConfig: LaunchpadFeeConfig;
+
+  beforeEach(() => {
+    feeConfig = new LaunchpadFeeConfig(asValidUserAlias("client|platformFeeAddress"), 0.01, [
+      users.admin.identityKey
+    ]);
+  });
+
+  it("should create new token allocation successfully", async () => {
+    // Given
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .caClientIdentity("test-admin", "CuratorOrg")
+      .registeredUsers(users.admin)
+      .savedState(feeConfig);
+
+    const finalizeDto = new FinalizeTokenAllocationDto();
+    finalizeDto.platformFeePercentage = 0.02;
+    finalizeDto.ownerFeePercentage = 0.03;
+    finalizeDto.uniqueKey = randomUniqueKey();
+    const signedDto = finalizeDto.signed(users.admin.privateKey);
+
+    // When
+    const response = await contract.FinalizeTokenAllocation(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.platformFeePercentage).toBe(0.02);
+    expect(response.Data?.ownerAllocationPercentage).toBe(0.03);
+  });
+
+  it("should update existing token allocation", async () => {
+    // Given - Create existing allocation first
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .caClientIdentity("test-admin", "CuratorOrg")
+      .registeredUsers(users.admin)
+      .savedState(feeConfig);
+
+    const initialDto = new FinalizeTokenAllocationDto();
+    initialDto.platformFeePercentage = 0.01;
+    initialDto.ownerFeePercentage = 0.02;
+    initialDto.uniqueKey = randomUniqueKey();
+    const signedInitialDto = initialDto.signed(users.admin.privateKey);
+
+    await contract.FinalizeTokenAllocation(ctx, signedInitialDto);
+
+    // Update with new values
+    const updateDto = new FinalizeTokenAllocationDto();
+    updateDto.platformFeePercentage = 0.05;
+    updateDto.ownerFeePercentage = 0.06;
+    updateDto.uniqueKey = randomUniqueKey();
+    const signedUpdateDto = updateDto.signed(users.admin.privateKey);
+
+    // When
+    const response = await contract.FinalizeTokenAllocation(ctx, signedUpdateDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.platformFeePercentage).toBe(0.05);
+    expect(response.Data?.ownerAllocationPercentage).toBe(0.06);
+  });
+
+  it("should handle zero percentage allocations", async () => {
+    // Given
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .caClientIdentity("test-admin", "CuratorOrg")
+      .registeredUsers(users.admin)
+      .savedState(feeConfig);
+
+    const finalizeDto = new FinalizeTokenAllocationDto();
+    finalizeDto.platformFeePercentage = 0;
+    finalizeDto.ownerFeePercentage = 0;
+    finalizeDto.uniqueKey = randomUniqueKey();
+    const signedDto = finalizeDto.signed(users.admin.privateKey);
+
+    // When
+    const response = await contract.FinalizeTokenAllocation(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.platformFeePercentage).toBe(0);
+    expect(response.Data?.ownerAllocationPercentage).toBe(0);
+  });
+
+  it("should handle high percentage allocations", async () => {
+    // Given
+    const { ctx, contract } = fixture(LaunchpadContract)
+      .caClientIdentity("test-admin", "CuratorOrg")
+      .registeredUsers(users.admin)
+      .savedState(feeConfig);
+
+    const finalizeDto = new FinalizeTokenAllocationDto();
+    finalizeDto.platformFeePercentage = 0.1; // 10%
+    finalizeDto.ownerFeePercentage = 0.15; // 15%
+    finalizeDto.uniqueKey = randomUniqueKey();
+    const signedDto = finalizeDto.signed(users.admin.privateKey);
+
+    // When
+    const response = await contract.FinalizeTokenAllocation(ctx, signedDto);
+
+    // Then
+    expect(response.Status).toBe(1);
+    expect(response.Data?.platformFeePercentage).toBe(0.1);
+    expect(response.Data?.ownerAllocationPercentage).toBe(0.15);
+  });
+});