@gala-chain/launchpad 1.0.1 → 1.0.2

package/src/chaincode/launchpad/finaliseSale.ts

@@ -46,8 +46,8 @@ export async function finalizeSale(ctx: GalaChainContext, sale: LaunchpadSale):
   const key = ctx.stub.createCompositeKey(LaunchpadFinalizeFeeAllocation.INDEX_KEY, []);
   const feeAllocation = await getObjectByKey(ctx, LaunchpadFinalizeFeeAllocation, key).catch(() => undefined);
 
-  const platformFeeAddressConfiguration = await fetchLaunchpadFeeAddress(ctx);
-  if (!platformFeeAddressConfiguration) {
+  const launchpadFeeAddressConfiguration = await fetchLaunchpadFeeAddress(ctx);
+  if (!launchpadFeeAddressConfiguration) {
     throw new PreConditionFailedError("Platform fee configuration is yet to be defined.");
   }
 
@@ -75,7 +75,7 @@ export async function finalizeSale(ctx: GalaChainContext, sale: LaunchpadSale):
 
   await transferToken(ctx, {
     from: vaultAddressAlias,
-    to: platformFeeAddressConfiguration.feeAddress,
+    to: launchpadFeeAddressConfiguration.feeAddress,
     tokenInstanceKey: nativeToken,
     quantity: new BigNumber(sale.nativeTokenQuantity)
       .times(platformFeePercentage)

package/src/chaincode/launchpad/index.ts

@@ -26,3 +26,4 @@ export * from "./finalizeTokenAllocation";
 export * from "./sellWithNative";
 export * from "./configureLaunchpadFeeConfig";
 export * from "./fetchLaunchpadAdressConfig";
+export * from "./launchpadBatchSubmitAuthorizations";

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

@@ -0,0 +1,185 @@
+/*
+ * 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 { NotFoundError } from "@gala-chain/api";
+import { GalaChainContext, getObjectByKey, putChainObject } from "@gala-chain/chaincode";
+
+import {
+  AuthorizeBatchSubmitterDto,
+  BatchSubmitAuthoritiesResDto,
+  DeauthorizeBatchSubmitterDto,
+  FetchBatchSubmitAuthoritiesDto,
+  LaunchpadBatchSubmitAuthorities
+} from "../../api/types";
+import {
+  authorizeLaunchpadBatchSubmitter,
+  deauthorizeLaunchpadBatchSubmitter,
+  fetchLaunchpadBatchSubmitAuthorities,
+  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", () => {
+    it("should create with initial authorities", () => {
+      const auth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+      expect(auth.authorities).toEqual(["user1", "user2"]);
+    });
+
+    it("should add authority", () => {
+      const auth = new LaunchpadBatchSubmitAuthorities(["user1"]);
+      auth.addAuthority("user2");
+      expect(auth.authorities).toEqual(["user1", "user2"]);
+    });
+
+    it("should not add duplicate authority", () => {
+      const auth = new LaunchpadBatchSubmitAuthorities(["user1"]);
+      auth.addAuthority("user1");
+      expect(auth.authorities).toEqual(["user1"]);
+    });
+
+    it("should remove authority", () => {
+      const auth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+      auth.removeAuthority("user1");
+      expect(auth.authorities).toEqual(["user2"]);
+    });
+
+    it("should check if user is authorized", () => {
+      const auth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+      expect(auth.isAuthorized("user1")).toBe(true);
+      expect(auth.isAuthorized("user3")).toBe(false);
+    });
+
+    it("should get authorized authorities", () => {
+      const auth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+      const authorities = auth.getAuthorities();
+      expect(authorities).toEqual(["user1", "user2"]);
+      // Should return a copy, not the original array
+      authorities.push("user3");
+      expect(auth.authorities).toEqual(["user1", "user2"]);
+    });
+  });
+
+  describe("fetchBatchSubmitAuthorizations", () => {
+    it("should return existing authorizations", async () => {
+      const ctx = createMockContext("user1");
+      const existingAuth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+
+      (getObjectByKey as jest.Mock).mockResolvedValue(existingAuth);
+      (putChainObject as jest.Mock).mockResolvedValue(undefined);
+
+      const result = await fetchLaunchpadBatchSubmitAuthorities(ctx);
+
+      expect(result).toBe(existingAuth);
+    });
+  });
+
+  describe("authorizeBatchSubmitter", () => {
+    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);
+
+      const dto = new AuthorizeBatchSubmitterDto();
+      dto.authorities = ["user2", "user3"];
+
+      const result = await authorizeLaunchpadBatchSubmitter(ctx, dto);
+
+      expect(result).toBeInstanceOf(BatchSubmitAuthoritiesResDto);
+      expect(result.authorities).toContain("user1");
+      expect(result.authorities).toContain("user2");
+      expect(result.authorities).toContain("user3");
+    });
+
+    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);
+
+      const dto = new AuthorizeBatchSubmitterDto();
+      dto.authorities = ["user1", "user2"];
+
+      const result = await authorizeLaunchpadBatchSubmitter(ctx, dto);
+
+      expect(result).toBeInstanceOf(BatchSubmitAuthoritiesResDto);
+      expect(result.authorities).toContain("user1");
+      expect(result.authorities).toContain("user2");
+      expect(putChainObject).toHaveBeenCalled();
+    });
+  });
+
+  describe("deauthorizeBatchSubmitter", () => {
+    it("should deauthorize user when caller is authorized", async () => {
+      const ctx = createMockContext("user1");
+      const existingAuth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+
+      (getObjectByKey as jest.Mock).mockResolvedValue(existingAuth);
+      (putChainObject as jest.Mock).mockResolvedValue(undefined);
+
+      const dto = new DeauthorizeBatchSubmitterDto();
+      dto.authority = "user2";
+
+      const result = await deauthorizeLaunchpadBatchSubmitter(ctx, dto);
+
+      expect(result).toBeInstanceOf(BatchSubmitAuthoritiesResDto);
+      expect(result.authorities).toContain("user1");
+      expect(result.authorities).not.toContain("user2");
+    });
+  });
+
+  describe("getBatchSubmitAuthorizations", () => {
+    it("should return current authorizations", async () => {
+      const ctx = createMockContext("user1");
+      const existingAuth = new LaunchpadBatchSubmitAuthorities(["user1", "user2"]);
+
+      (getObjectByKey as jest.Mock).mockResolvedValue(existingAuth);
+
+      const dto = new FetchBatchSubmitAuthoritiesDto();
+      const result = await getLaunchpadBatchSubmitAuthorities(ctx, dto);
+
+      expect(result).toBeInstanceOf(BatchSubmitAuthoritiesResDto);
+      expect(result.authorities).toEqual(["user1", "user2"]);
+    });
+  });
+});

package/src/chaincode/launchpad/launchpadBatchSubmitAuthorizations.ts

@@ -0,0 +1,105 @@
+/*
+ * 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 { ChainError } from "@gala-chain/api";
+import { GalaChainContext, getObjectByKey, putChainObject } from "@gala-chain/chaincode";
+
+import {
+  AuthorizeBatchSubmitterDto,
+  BatchSubmitAuthoritiesResDto,
+  DeauthorizeBatchSubmitterDto,
+  ErrorCode,
+  FetchBatchSubmitAuthoritiesDto,
+  LaunchpadBatchSubmitAuthorities
+} from "../../api";
+
+/**
+ * Fetches the batch submit authorities from the chain.
+ */
+export async function fetchLaunchpadBatchSubmitAuthorities(
+  ctx: GalaChainContext
+): Promise<LaunchpadBatchSubmitAuthorities> {
+  const key = ctx.stub.createCompositeKey(LaunchpadBatchSubmitAuthorities.INDEX_KEY, []);
+
+  return await getObjectByKey(ctx, LaunchpadBatchSubmitAuthorities, key);
+}
+
+/**
+ * Authorizes users to call BatchSubmit operations.
+ * Only existing authorized users can add new authorizations.
+ */
+export async function authorizeLaunchpadBatchSubmitter(
+  ctx: GalaChainContext,
+  dto: AuthorizeBatchSubmitterDto
+): Promise<BatchSubmitAuthoritiesResDto> {
+  const key = ctx.stub.createCompositeKey(LaunchpadBatchSubmitAuthorities.INDEX_KEY, []);
+  const authorities = await getObjectByKey(ctx, LaunchpadBatchSubmitAuthorities, key).catch((e) => {
+    const chainError = ChainError.from(e);
+    if (chainError.matches(ErrorCode.NOT_FOUND)) {
+      return new LaunchpadBatchSubmitAuthorities([]);
+    } else {
+      throw chainError;
+    }
+  });
+
+  // Add new authorities
+  for (const authority of dto.authorities) {
+    authorities.addAuthority(authority);
+  }
+
+  await putChainObject(ctx, authorities);
+
+  const result = new BatchSubmitAuthoritiesResDto();
+  result.authorities = authorities.getAuthorities();
+  return result;
+}
+
+/**
+ * Deauthorizes a user from calling BatchSubmit operations.
+ */
+export async function deauthorizeLaunchpadBatchSubmitter(
+  ctx: GalaChainContext,
+  dto: DeauthorizeBatchSubmitterDto
+): Promise<BatchSubmitAuthoritiesResDto> {
+  const authorities = await fetchLaunchpadBatchSubmitAuthorities(ctx);
+
+  authorities.removeAuthority(dto.authority);
+  await putChainObject(ctx, authorities);
+
+  const result = new BatchSubmitAuthoritiesResDto();
+  result.authorities = authorities.getAuthorities();
+  return result;
+}
+
+/**
+ * Fetches the current batch submit authorizations.
+ */
+export async function getLaunchpadBatchSubmitAuthorities(
+  ctx: GalaChainContext,
+  dto: FetchBatchSubmitAuthoritiesDto
+): Promise<BatchSubmitAuthoritiesResDto> {
+  const authorities = await fetchLaunchpadBatchSubmitAuthorities(ctx);
+  const result = new BatchSubmitAuthoritiesResDto();
+
+  result.authorities = authorities.getAuthorities();
+  return result;
+}
+
+/**
+ * Checks if the calling user is authorized to perform batch submit operations.
+ */
+export async function isAuthorizedForLaunchpadBatchSubmit(ctx: GalaChainContext): Promise<boolean> {
+  const authorities = await fetchLaunchpadBatchSubmitAuthorities(ctx);
+  return authorities.isAuthorized(ctx.callingUser);
+}

package/src/chaincode/launchpad/sellExactToken.ts

@@ -12,13 +12,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { ValidationFailedError } from "@gala-chain/api";
 import { GalaChainContext, fetchTokenClass, putChainObject, transferToken } from "@gala-chain/chaincode";
 import { BigNumber } from "bignumber.js";
 
-import { ExactTokenQuantityDto, NativeTokenQuantityDto, TradeResDto } from "../../api/types";
+import { ExactTokenQuantityDto, TradeResDto } from "../../api/types";
 import { SlippageToleranceExceededError } from "../../api/utils/error";
-import { fetchAndValidateSale } from "../utils";
-import { callMemeTokenIn } from "./callMemeTokenIn";
+import { fetchAndValidateSale, fetchLaunchpadFeeAddress } from "../utils";
 import { callNativeTokenOut } from "./callNativeTokenOut";
 import { payReverseBondingCurveFee } from "./fees";
 
@@ -48,24 +48,24 @@ export async function sellExactToken(
   ctx: GalaChainContext,
   sellTokenDTO: ExactTokenQuantityDto
 ): Promise<TradeResDto> {
+  // Fetch and validate the current sale object
   const sale = await fetchAndValidateSale(ctx, sellTokenDTO.vaultAddress);
 
+  // Determine how much native token (e.g., GALA) the user will receive for the exact token quantity
   const callNativeTokenOutResult = await callNativeTokenOut(ctx, sellTokenDTO);
-  let nativeTokensToProvide = new BigNumber(callNativeTokenOutResult.calculatedQuantity);
+  const nativeTokensToProvide = new BigNumber(callNativeTokenOutResult.calculatedQuantity);
+  const transactionFees = callNativeTokenOutResult.extraFees.transactionFees;
+
   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) {
-    nativeTokensToProvide = nativeTokensLeftInVault;
-    const nativeTokensBeingSoldDto = new NativeTokenQuantityDto(
-      sellTokenDTO.vaultAddress,
-      nativeTokensToProvide
-    );
-    const callMemeTokenInResult = await callMemeTokenIn(ctx, nativeTokensBeingSoldDto);
-    sellTokenDTO.tokenQuantity = new BigNumber(callMemeTokenInResult.calculatedQuantity);
+    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
@@ -84,6 +84,20 @@ export async function sellExactToken(
     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
+    });
+  }
+
+  // Transfer meme tokens from user to vault
   await transferToken(ctx, {
     from: ctx.callingUser,
     to: sellTokenDTO.vaultAddress,
@@ -93,6 +107,7 @@ export async function sellExactToken(
     authorizedOnBehalf: undefined
   });
 
+  // Transfer native tokens from vault to user
   await transferToken(ctx, {
     from: sellTokenDTO.vaultAddress,
     to: ctx.callingUser,
@@ -105,12 +120,16 @@ export async function sellExactToken(
     }
   });
 
+  // Update sale state with this transaction
   sale.sellToken(sellTokenDTO.tokenQuantity, nativeTokensToProvide);
   await putChainObject(ctx, sale);
 
   const token = await fetchTokenClass(ctx, sale.sellingToken);
   return {
     inputQuantity: sellTokenDTO.tokenQuantity.toFixed(),
+    totalFees: new BigNumber(transactionFees)
+      .plus(sellTokenDTO.extraFees?.maxAcceptableReverseBondingCurveFee ?? 0)
+      .toFixed(),
     outputQuantity: nativeTokensToProvide.toFixed(),
     tokenName: token.name,
     tradeType: "Sell",

package/src/chaincode/launchpad/sellWithNative.ts

@@ -12,12 +12,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { ValidationFailedError } from "@gala-chain/api";
 import { GalaChainContext, fetchTokenClass, putChainObject, transferToken } from "@gala-chain/chaincode";
 import { BigNumber } from "bignumber.js";
 
 import { NativeTokenQuantityDto, TradeResDto } from "../../api/types";
 import { SlippageToleranceExceededError } from "../../api/utils/error";
-import { fetchAndValidateSale } from "../utils";
+import { fetchAndValidateSale, fetchLaunchpadFeeAddress } from "../utils";
 import { callMemeTokenIn } from "./callMemeTokenIn";
 import { payReverseBondingCurveFee } from "./fees";
 
@@ -48,18 +49,25 @@ export async function sellWithNative(
   ctx: GalaChainContext,
   sellTokenDTO: NativeTokenQuantityDto
 ): Promise<TradeResDto> {
+  // Fetch and validate the sale object
   const sale = await fetchAndValidateSale(ctx, sellTokenDTO.vaultAddress);
 
   const nativeTokensLeftInVault = new BigNumber(sale.nativeTokenQuantity);
+
+  // Cap nativeTokenQuantity to the vault balance if the requested amount exceeds it
   if (nativeTokensLeftInVault.comparedTo(sellTokenDTO.nativeTokenQuantity) < 0) {
-    sellTokenDTO.nativeTokenQuantity = nativeTokensLeftInVault;
+    throw new ValidationFailedError("Not enough GALA in sale contract to carry out this operation.");
   }
 
+  // Calculate how many tokens need to be sold to get the requested native amount
   const callMemeTokenInResult = await callMemeTokenIn(ctx, sellTokenDTO);
+  const transactionFees = callMemeTokenInResult.extraFees.transactionFees;
   const tokensToSell = new BigNumber(callMemeTokenInResult.calculatedQuantity);
+
   const nativeToken = sale.fetchNativeTokenInstanceKey();
   const memeToken = sale.fetchSellingTokenInstanceKey();
 
+  // Enforce slippage tolerance
   if (sellTokenDTO.expectedToken && sellTokenDTO.expectedToken.comparedTo(tokensToSell) < 0) {
     throw new SlippageToleranceExceededError(
       "Token amount expected to cost for this operation is less than the the actual amount required."
@@ -75,6 +83,20 @@ export async function sellWithNative(
     sellTokenDTO.extraFees?.maxAcceptableReverseBondingCurveFee
   );
 
+  // Transfer launchpad transaction fees 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
+    });
+  }
+
+  // Send meme tokens from user to vault
   await transferToken(ctx, {
     from: ctx.callingUser,
     to: sellTokenDTO.vaultAddress,
@@ -83,6 +105,8 @@ export async function sellWithNative(
     allowancesToUse: [],
     authorizedOnBehalf: undefined
   });
+
+  // Send native tokens from vault to user
   await transferToken(ctx, {
     from: sellTokenDTO.vaultAddress,
     to: ctx.callingUser,
@@ -95,12 +119,16 @@ export async function sellWithNative(
     }
   });
 
+  // Update internal sale tracking
   sale.sellToken(tokensToSell, sellTokenDTO.nativeTokenQuantity);
   await putChainObject(ctx, sale);
 
   const token = await fetchTokenClass(ctx, sale.sellingToken);
   return {
     inputQuantity: tokensToSell.toFixed(),
+    totalFees: new BigNumber(transactionFees)
+      .plus(sellTokenDTO.extraFees?.maxAcceptableReverseBondingCurveFee ?? 0)
+      .toFixed(),
     outputQuantity: sellTokenDTO.nativeTokenQuantity.toFixed(),
     tokenName: token.name,
     tradeType: "Sell",