@jolibox/implement 1.1.55 → 1.2.0-beta.9

package/src/common/rewards/registers/utils/coins/joligem/fetch-gem-balance.ts

@@ -0,0 +1,15 @@
+import { IHttpClient } from '@/common/http';
+import { StandardResponse } from '@jolibox/types';
+
+export const fetchGemBalance = async (httpClient: IHttpClient) => {
+  const res = await httpClient.get<
+    StandardResponse<{
+      balance: number;
+    }>
+  >('/api/joli-gem/balance', {
+    query: {
+      type: 'GEM'
+    }
+  });
+  return res.data;
+};

package/src/common/rewards/registers/utils/coins/joligem/gem-handler.ts

@@ -0,0 +1,134 @@
+import { IHttpClient } from '@/common/http';
+import { context } from '@/common/context';
+import { uuidv4 } from '@jolibox/common';
+import { UnlockOptionsEventName, IUnlockOptionsEvent } from '@/common/rewards/reward-emitter';
+import { IAdBreakParams } from '@/common/ads';
+import { EventPromiseHandler } from '../../event-listener';
+import { CURRENCY_CONFIG } from '../currency-config';
+
+import {
+  createInitiateAndAwaitPayment,
+  registerUsePaymentCommand,
+  registerUseUnloginCommand,
+  createShowUnloginModal
+} from '../commands';
+import { registerUseJolicoinCommand, createShowUnlockWithCurrencyModal } from '../commands/use-jolicoin';
+import { rewardsCommands } from '../rewards-command';
+import { RewardsCommandType } from '@jolibox/types';
+import { track } from '@/native/report';
+
+interface IGemUnlockRes {
+  code: 'SUCCESS' | 'BALANCE_NOT_ENOUGH' | 'EPISODE_LOCK_JUMP' | 'EPISODE_UNLOCK_ALREADY';
+  message: string;
+  data: {
+    transactionId: string;
+    quantity: number;
+    balance: number;
+  };
+}
+
+export const createCommonGemRewardHandler = (
+  type: 'JOLI_GEM' | 'ADS-JOLI_GEM',
+  httpClient: IHttpClient,
+  {
+    handlers: {
+      handleUnlockSuccess,
+      handleUnlockFailed,
+      unlockOptionsHandler,
+      initiateAndAwaitPayment,
+      showUnlockWithCurrencyModal,
+      showUnloginModal
+    }
+  }: {
+    handlers: {
+      handleUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
+      handleUnlockFailed?: (params: IAdBreakParams) => void;
+      unlockOptionsHandler: EventPromiseHandler<IUnlockOptionsEvent, typeof UnlockOptionsEventName>;
+      initiateAndAwaitPayment: ReturnType<typeof createInitiateAndAwaitPayment>;
+      showUnlockWithCurrencyModal: ReturnType<typeof createShowUnlockWithCurrencyModal>;
+      showUnloginModal: ReturnType<typeof createShowUnloginModal>;
+    };
+  }
+) => {
+  // register commands
+  registerUseUnloginCommand(type, 'JOLI_GEM', {
+    httpClient: httpClient,
+    showUnloginModal: showUnloginModal
+  });
+  registerUsePaymentCommand(type, 'JOLI_GEM', {
+    httpClient: httpClient,
+    initiateAndAwaitPayment: initiateAndAwaitPayment
+  });
+  registerUseJolicoinCommand(type, 'JOLI_GEM', {
+    showUnlockWithCurrencyModal: showUnlockWithCurrencyModal
+  });
+
+  const commands = [`Rewards.${type}.usePayment`, `Rewards.${type}.useJolicoin`];
+
+  return async (params: IAdBreakParams) => {
+    try {
+      let result = true;
+      for (const command of commands) {
+        const commandResult = await rewardsCommands.executeCommand(command as RewardsCommandType);
+        result = result && commandResult.result !== 'FAILED';
+        if (commandResult.result !== 'CONTINUE') {
+          break;
+        }
+      }
+
+      if (!result) {
+        handleUnlockFailed?.(params);
+        return false;
+      }
+
+      const config = CURRENCY_CONFIG['GEM'];
+      const unlockWithGem = await httpClient.post<IGemUnlockRes>(config.unlockEndpoint, {
+        data: {
+          type: 'GAME_REWARD',
+          reqId: `${uuidv4()}-${context.mpType}-${Date.now()}`,
+          gameInfo: {
+            gameId: context.mpId
+          }
+        }
+      });
+
+      console.log('-----unlockWithGem request result-----', unlockWithGem);
+      if (unlockWithGem.code == 'SUCCESS') {
+        try {
+          params.adBreakDone?.({
+            breakType: params.type,
+            breakName: 'name' in params ? params.name ?? '' : '',
+            breakFormat: 'reward',
+            breakStatus: 'viewed'
+          });
+          if ('adViewed' in params) {
+            params.adViewed?.();
+          }
+          track('gem_unlock_success', {
+            quantity: unlockWithGem.data.quantity
+          });
+        } catch (e) {
+          console.error('-----unlockWithGem adBreakDone error-----', e);
+        }
+
+        handleUnlockSuccess?.({
+          quantity: unlockWithGem.data.quantity,
+          balance: unlockWithGem.data.balance
+        });
+        return true;
+      }
+      handleUnlockFailed?.(params);
+      return false;
+    } catch (e) {
+      console.info(`GemRewardHandler error:`, e);
+      if (e instanceof Error && e.message == 'CANCEL') {
+        // Cancel should terminate the reward handler, invoke unlock failed
+        throw e;
+      }
+      handleUnlockFailed?.(params);
+      return false;
+    } finally {
+      unlockOptionsHandler.clearCache();
+    }
+  };
+};

package/src/common/rewards/registers/utils/index.ts

@@ -1,4 +1,5 @@
-import { IJoliCoin, IUnlockOption } from '@/common/rewards/type';
+import { IJoliCoin, IGem, IUnlockOption } from '@/common/rewards/type';
+import { isNumber } from '@jolibox/common';
 
 export const canUseJolicoin = (unlockOptions: IUnlockOption[], joliCoin?: IJoliCoin) => {
   return unlockOptions.some(
@@ -17,3 +18,21 @@ export const joliCoinIsEnough = (unlockOptions: IUnlockOption[], joliCoin?: IJol
       option.joliCoinChoices.some((choice) => choice.joliCoinQuantity <= (joliCoin?.balance ?? 0))
   );
 };
+
+// Gem utility functions
+export const canUseGem = (unlockOptions: IUnlockOption[], gem?: IGem) => {
+  return unlockOptions.some((option) => {
+    if (option.type === 'JOLI_GEM' && isNumber(option.joliGemChoice?.joliGemQuantity)) {
+      return option.joliGemChoice.joliGemQuantity <= (gem?.balance ?? 0) && !!gem?.enableAutoDeduct;
+    }
+    return false;
+  });
+};
+
+export const gemIsEnough = (unlockOptions: IUnlockOption[], gem?: IGem) => {
+  const gemOptions = unlockOptions.find((option) => option.type === 'JOLI_GEM');
+  if (gemOptions) {
+    return (gemOptions.joliGemChoice?.joliGemQuantity ?? 0) <= (gem?.balance ?? 0);
+  }
+  return false;
+};

package/src/common/rewards/reward-emitter.ts

@@ -1,12 +1,12 @@
 // rewards-emitter-wrapper.ts
 
 import { EventEmitter } from '@jolibox/common';
-import { IUnlockOption } from './type';
-import { IJoliCoin } from './type';
+import { IUnlockOption, IJoliCoin, IGem } from './type';
 
 export interface IUnlockOptionsEvent {
   options: IUnlockOption[];
   userJoliCoin: IJoliCoin;
+  userGem?: IGem;
 }
 
 export const UnlockOptionsEventName = 'UNLOCK_OPTIONS_CHANGED' as const;
@@ -21,6 +21,8 @@ export const InvokeUnloginModalEventName = 'INVOKE_UNLOGIN_MODAL_EVENT' as const
 type IPaymentResult = 'SUCCESS' | 'FAILED' | 'CANCEL';
 export interface IPaymentEvent {
   userJoliCoin?: IJoliCoin;
+  userGem?: IGem;
+  currency: 'JOLI_COIN' | 'JOLI_GEM';
   paymentResult: IPaymentResult;
 }
 
@@ -32,8 +34,9 @@ export interface IPaymentChoice {
 }
 
 export interface IInvokePaymentEvent {
-  userJoliCoin: IJoliCoin;
-  joliCoinQuantity: number;
+  userCurrency: IJoliCoin | IGem;
+  quantity: number;
+  currency: 'JOLI_COIN' | 'JOLI_GEM';
   enableAutoDeduct: boolean;
   confirmButtonText: string;
   cancelButtonText: string;
@@ -42,8 +45,9 @@ export interface IInvokePaymentEvent {
 
 export interface IUseModalEvent {
   enableAutoDeduct: boolean;
-  userJoliCoin: IJoliCoin;
-  joliCoinQuantity: number;
+  userCurrency: IJoliCoin | IGem;
+  quantity: number;
+  currency: 'JOLI_COIN' | 'JOLI_GEM';
   confirmButtonText: string;
   cancelButtonText: string;
   sequenceId?: string;
@@ -52,6 +56,7 @@ export interface IUseModalEvent {
 export interface IUseUnloginModalEvent {
   confirmButtonText: string;
   cancelButtonText: string;
+  currency: 'JOLI_COIN' | 'JOLI_GEM';
 }
 
 export interface IUseModalResultEvent {
@@ -61,10 +66,9 @@ export interface IUseModalResultEvent {
 export interface IUseUnloginModalResultEvent {
   result: 'SUCCESS' | 'CANCEL' | 'ADS' | 'FAILED' | 'NOT_SUPPORT';
   rewards?: {
-    jolicoin?: {
-      claimedRewardValue: number;
-      isFirstLogin: boolean;
-    };
+    claimedRewardValue: number;
+    isFirstLogin: boolean;
+    currency?: 'JOLI_COIN' | 'JOLI_GEM';
   };
 }
 
@@ -88,12 +92,18 @@ export interface IUseModalFrequencyConfig {
 
 export interface RewardsEventMap extends Record<string, unknown[]> {
   [UnlockOptionsEventName]: [IUnlockOptionsEvent];
-  [InvokePaymentEventName]: ['JOLI_COIN' | 'ADS-JOLI_COIN', IInvokePaymentEvent];
+  [InvokePaymentEventName]: [
+    'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
+    IInvokePaymentEvent
+  ];
   [PaymentResultEventName]: [IPaymentEvent];
   [UseModalResultEventName]: [IUseModalResultEvent];
-  [UseModalEventName]: ['JOLI_COIN' | 'ADS-JOLI_COIN', IUseModalEvent];
+  [UseModalEventName]: ['JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM', IUseModalEvent];
   [UseModalFrequencyEventName]: [IUseModalFrequencyConfig];
-  [InvokeUnloginModalEventName]: ['JOLI_COIN' | 'ADS-JOLI_COIN', IUseUnloginModalEvent];
+  [InvokeUnloginModalEventName]: [
+    'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
+    IUseUnloginModalEvent
+  ];
   [UseUnloginModalResultEventName]: [IUseUnloginModalResultEvent];
 }
 

package/src/common/rewards/reward-helper.ts

@@ -1,4 +1,4 @@
-export type RewardType = 'ADS' | 'JOLI_COIN' | 'JOLI_COIN_ONLY';
+export type RewardType = 'ADS' | 'JOLI_COIN' | 'JOLI_COIN_ONLY' | 'JOLI_GEM' | 'JOLI_GEM_ONLY';
 
 import { context } from '../context';
 import type { AdsRewardsHandler } from './registers/use-ads';
@@ -8,6 +8,8 @@ export interface RewardHandlerMap {
   ADS: AdsRewardsHandler;
   JOLI_COIN: (params?: unknown) => Promise<boolean>; // coins + ads
   JOLI_COIN_ONLY: (params?: unknown) => Promise<boolean>; // coins only
+  JOLI_GEM: (params?: unknown) => Promise<boolean>; // gem + ads
+  JOLI_GEM_ONLY: (params?: unknown) => Promise<boolean>; // gem only
 }
 
 export type RewardHandler<T extends RewardType> = RewardHandlerMap[T];

package/src/common/rewards/type.ts

@@ -3,14 +3,25 @@ export interface IJoliCoin {
   enableAutoDeduct: boolean;
 }
 
-export type IUnlockOptionType = 'JOLI_COIN' | 'ADS';
+export interface IGem {
+  balance: number;
+  enableAutoDeduct: boolean;
+}
+
+export type IUnlockOptionType = 'JOLI_COIN' | 'ADS' | 'JOLI_GEM';
 
 interface IJoliCoinChoice {
   joliCoinQuantity: number;
 }
+
+interface IGemChoice {
+  joliGemQuantity: number;
+}
+
 export interface IUnlockOption {
   type: IUnlockOptionType;
   joliCoinChoices: IJoliCoinChoice[];
+  joliGemChoice: IGemChoice | null;
 }
 
 export interface IJolicoinRewardOption {
@@ -21,5 +32,6 @@ export interface IJolicoinRewardOption {
   };
   extra: {
     joliCoin: IJoliCoin;
+    joliGem?: IGem;
   };
 }

package/src/h5/rewards/index.ts

@@ -33,17 +33,24 @@ onCustomEvent('ON_JOLIBOX_JOLI_COIN_USE_RESULT', (data) => {
     useModalResult: UseCoinEventMap[data.result]
   });
 });
-rewardsEmitter.on(UseModalEventName, (type: 'JOLI_COIN' | 'ADS-JOLI_COIN', params: IUseModalEvent) => {
-  notifyCustomEvent('JOLIBOX_JOLI_COIN_USE_EVENT', {
-    JOLI_COIN: {
-      quantity: params.joliCoinQuantity,
-      balance: params.userJoliCoin.balance,
-      enableAutoDeduct: params.enableAutoDeduct
-    },
-    type,
-    sequenceId: params.sequenceId ?? v4()
-  });
-});
+rewardsEmitter.on(
+  UseModalEventName,
+  (type: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM', params: IUseModalEvent) => {
+    // not support gem in h5
+    if (type == 'ADS-JOLI_GEM' || type == 'JOLI_GEM') {
+      return;
+    }
+    notifyCustomEvent('JOLIBOX_JOLI_COIN_USE_EVENT', {
+      JOLI_COIN: {
+        quantity: params.quantity,
+        balance: params.userCurrency.balance,
+        enableAutoDeduct: params.enableAutoDeduct
+      },
+      type: type as 'JOLI_COIN' | 'ADS-JOLI_COIN',
+      sequenceId: params.sequenceId ?? v4()
+    });
+  }
+);
 
 /**
  * payment jolicoin modal
@@ -51,21 +58,26 @@ rewardsEmitter.on(UseModalEventName, (type: 'JOLI_COIN' | 'ADS-JOLI_COIN', param
 onCustomEvent('ON_JOLIBOX_TOPUP_JOLI_COIN_RESULT', (data) => {
   rewardsEmitter.emit(PaymentResultEventName, {
     paymentResult: data.result == 'ADS' ? 'FAILED' : data.result,
-    userJoliCoin: data.joliCoin
+    userJoliCoin: data.joliCoin,
+    currency: 'JOLI_COIN' // h5 only support jolicoin, should get currency from data later
   });
 });
 
 rewardsEmitter.on(
   InvokePaymentEventName,
-  async (type: 'JOLI_COIN' | 'ADS-JOLI_COIN', params: IInvokePaymentEvent) => {
+  async (type: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM', params: IInvokePaymentEvent) => {
     // 充值面板
+    if (type == 'ADS-JOLI_GEM' || type == 'JOLI_GEM') {
+      return;
+    }
+
     notifyCustomEvent('JOLIBOX_TOPUP_EVENT', {
       JOLI_COIN: {
-        quantity: params.joliCoinQuantity,
-        balance: params.userJoliCoin.balance,
+        quantity: params.quantity,
+        balance: params.userCurrency.balance,
         enableAutoDeduct: params.enableAutoDeduct
       },
-      type,
+      type: type as 'JOLI_COIN' | 'ADS-JOLI_COIN',
       sequenceId: params.sequenceId ?? v4()
     });
   }
@@ -76,10 +88,8 @@ onCustomEvent('ON_JOLIBOX_JOLI_UNLOGIN_MODAL_RESULT_EVENT', (data) => {
   rewardsEmitter.emit(UseUnloginModalResultEventName, {
     result: data.result == 'ADS' ? 'FAILED' : data.result,
     rewards: {
-      jolicoin: {
-        claimedRewardValue: data.extra?.firstLogin?.reward?.rewardValue ?? 0,
-        isFirstLogin: data.isFirstLogin ?? false
-      }
+      claimedRewardValue: data.extra?.firstLogin?.reward?.rewardValue ?? 0,
+      isFirstLogin: data.isFirstLogin ?? false
     }
   });
 
@@ -90,6 +100,9 @@ onCustomEvent('ON_JOLIBOX_JOLI_UNLOGIN_MODAL_RESULT_EVENT', (data) => {
 
 rewardsEmitter.on(InvokeUnloginModalEventName, async (type) => {
   // 未登录面板
+  if (type == 'ADS-JOLI_GEM' || type == 'JOLI_GEM') {
+    return;
+  }
   notifyCustomEvent('JOLIBOX_JOLI_UNLOGIN_MODAL_EVENT', {
     sequenceId: v4(),
     type: type

package/src/native/api/ads.ts

@@ -23,7 +23,9 @@ import {
   rewardsHelper,
   createAdsRewardHandler,
   createJolicoinRewardHandler,
-  createJolicoinOnlyRewardHandler
+  createJolicoinOnlyRewardHandler,
+  createGemRewardHandler,
+  createGemOnlyRewardHandler
 } from '@/common/rewards';
 import { adEventEmitter } from '@/common/ads';
 
@@ -115,6 +117,25 @@ rewardsHelper.registerRewardHandler(
   }) as unknown as (params?: unknown) => Promise<boolean>
 );
 
+// gem
+rewardsHelper.registerRewardHandler(
+  'JOLI_GEM',
+  createGemRewardHandler(httpClient, {
+    onUnlockSuccess: (params) => {
+      showGemSuccessToast(params);
+    }
+  }) as unknown as (params?: unknown) => Promise<boolean>
+);
+
+rewardsHelper.registerRewardHandler(
+  'JOLI_GEM_ONLY',
+  createGemOnlyRewardHandler(httpClient, {
+    onUnlockSuccess: (params) => {
+      showGemSuccessToast(params);
+    }
+  }) as unknown as (params?: unknown) => Promise<boolean>
+);
+
 const showUnlockSuccessToast = (params: { quantity: number; balance: number }) => {
   const { quantity } = params;
   const toastTemplate = `{slot-coin} ${quantity} {slot-i18n-jolicoin.coinUsed}`;
@@ -122,6 +143,9 @@ const showUnlockSuccessToast = (params: { quantity: number; balance: number }) =
     customStyle: {
       mark: {
         marginRight: '8px'
+      },
+      base: {
+        with: 'auto'
       }
     },
     i18nParams: {
@@ -130,6 +154,36 @@ const showUnlockSuccessToast = (params: { quantity: number; balance: number }) =
   });
 };
 
+export const showGemSuccessToast = (params: { quantity: number; balance: number }) => {
+  const { quantity } = params;
+  const toastTemplate = `{slot-correct} ${quantity * -1} {slot-gem}`;
+  createToast(toastTemplate, {
+    customStyle: {
+      mark: {
+        marginRight: '8px'
+      },
+      base: {
+        'font-size': '25px',
+        'font-weight': '700',
+        'line-height': '18px'
+      },
+      span: {
+        width: 'auto',
+        minWidth: 'fit-content',
+        maxWidth: '60px',
+        textAlign: 'center',
+        padding: '0 2px',
+        lineHeight: '25px'
+      },
+      gem: {
+        transform: 'translateY(-2px)',
+        width: '28px',
+        height: '28px'
+      }
+    }
+  });
+};
+
 const adInit = createSyncAPI('adInit', {
   implement: (config?: IAdsInitParams) => {
     ads.init(config);

package/src/native/api/call-host-method.ts

@@ -1,4 +1,4 @@
-import { canIUseNative, createAPI, registerCanIUse, t } from './base';
+import { canIUseNative, createAPI, registerCanIUse, t, createSyncAPI } from './base';
 import { invokeNative } from '@jolibox/native-bridge';
 import { hostEmitter, UserCustomError } from '@jolibox/common';
 import { createCommands } from '@jolibox/common';
@@ -95,3 +95,38 @@ commands.registerCommand('API.callHostMethod', callHostMethodAsync);
 registerCanIUse('callHostMethod', {
   version: '1.1.49'
 });
+
+//user track
+const userTrackAsync = createAPI('userTrackAsync', {
+  paramsSchema: t.tuple(
+    t.object({
+      event: t.string(),
+      eventType: t.number(),
+      params: t.object().optional().default({})
+    })
+  ),
+  implement: async ({ event, eventType, params }) => {
+    const supportedMethods = await getSupportedMethods();
+    if (!supportedMethods.includes('userTrackAsync')) {
+      throw new UserCustomError('Method not supported', 10001);
+    }
+    const { errNo, errMsg } = await invokeNative('trackAsync', {
+      event,
+      eventType,
+      data: {
+        ...params
+      },
+      webviewId: context.webviewId
+    });
+    if (errNo !== 0) {
+      throw new UserCustomError(errMsg, errNo);
+    }
+    return;
+  }
+});
+
+commands.registerCommand('API.track', userTrackAsync);
+
+registerCanIUse('track', {
+  version: '1.1.53'
+});

package/src/native/bootstrap/index.ts

@@ -218,13 +218,17 @@ function addDoExitLoader() {
 }
 
 async function fetchMetaConfig() {
-  const url = `${context.baseApiHost}/api/fe-configs/js-sdk/basic-meta`;
-  const {
-    response: { data }
-  } = await innerFetch<IBasicMetaConfig>(url);
-
-  if (data) {
-    baskcMeta = data;
+  try {
+    const url = `/api/fe-configs/js-sdk/basic-meta`;
+    const {
+      response: { data }
+    } = await innerFetch<IBasicMetaConfig>(url);
+
+    if (data) {
+      baskcMeta = data;
+    }
+  } catch (error) {
+    console.error('fetchMetaConfig error:', error);
   }
 }
 

package/src/native/payment/index.ts

@@ -5,3 +5,5 @@ import { createJolicoinIAPPaymentHandler } from './registers/jolicoin-iap';
 export const paymentHelper = createPaymentHelper();
 paymentHelper.registerPaymentHandler('JOLI_COIN', createJolicoinPaymentHandler());
 paymentHelper.registerPaymentHandler('JOLI_COIN_IAP', createJolicoinIAPPaymentHandler());
+// Temporarily reuse the same IAP handler for gem, can be extended later with gem-specific logic
+paymentHelper.registerPaymentHandler('JOLI_GEM_IAP', createJolicoinIAPPaymentHandler());

package/src/native/payment/payment-helper.ts

@@ -1,4 +1,4 @@
-export type PaymentType = 'JOLI_COIN' | 'JOLI_COIN_IAP'; // current only jolicoin
+export type PaymentType = 'JOLI_COIN' | 'JOLI_COIN_IAP' | 'JOLI_GEM_IAP'; // support both jolicoin and gem
 
 import { StandardResponse } from '@jolibox/types';
 import { reportError } from '@/common/report/errors/report';
@@ -9,6 +9,7 @@ type PaymentResult = StandardResponse<void>;
 export interface PaymentHandlerMap {
   JOLI_COIN: (productId: string) => Promise<PaymentResult>; // jolicoin
   JOLI_COIN_IAP: (params: { productId: string; appStoreProductId: string }) => Promise<PaymentResult>; // jolicoin iap
+  JOLI_GEM_IAP: (params: { productId: string; appStoreProductId: string }) => Promise<PaymentResult>; // gem iap
 }
 
 export type PaymentHandler<T extends PaymentType> = PaymentHandlerMap[T];

package/src/native/rewards/check-frequency.ts

@@ -53,6 +53,11 @@ export const checkUseModalFrequency = createFrequencyChecker('joli_coin_use_moda
 export const checkPaymentFrequency = createFrequencyChecker('joli_coin_payment_frequency');
 export const checkUnloginModalFrequency = createFrequencyChecker('joli_coin_unlogin_modal_frequency');
 
+// gem frequency
+export const checkUseModalFrequencyGem = createFrequencyChecker('joli_gem_use_modal_frequency');
+export const checkPaymentFrequencyGem = createFrequencyChecker('joli_gem_payment_frequency');
+export const checkUnloginModalFrequencyGem = createFrequencyChecker('joli_gem_unlogin_modal_frequency');
+
 // common update frequency
 function createFrequencyUpdater(storageKey: string) {
   return async () => {
@@ -68,3 +73,8 @@ function createFrequencyUpdater(storageKey: string) {
 export const updateUseModalFrequency = createFrequencyUpdater('joli_coin_use_modal_frequency');
 export const updatePaymentFrequency = createFrequencyUpdater('joli_coin_payment_frequency');
 export const updateUnloginModalFrequency = createFrequencyUpdater('joli_coin_unlogin_modal_frequency');
+
+// gem frequency
+export const updateUseModalFrequencyGem = createFrequencyUpdater('joli_gem_use_modal_frequency');
+export const updatePaymentFrequencyGem = createFrequencyUpdater('joli_gem_payment_frequency');
+export const updateUnloginModalFrequencyGem = createFrequencyUpdater('joli_gem_unlogin_modal_frequency');