@jolibox/implement 1.2.5-beta.3 → 1.2.5

package/src/common/cache/request-cache-service.ts

@@ -0,0 +1,393 @@
+/**
+ * 通用请求缓存服务基类
+ * 支持部分数据缓存，部分数据实时获取的混合模式
+ */
+
+export interface CacheConfig<TCacheData, TServerData> {
+  /** 缓存持续时间，默认10分钟 */
+  duration?: number;
+  /** 请求超时时间，默认3秒 */
+  timeout?: number;
+  /** 缓存键生成函数 */
+  keyGenerator?: <TRequest>(endpoint: string, params?: TRequest) => string;
+  /** 数据一致性校验函数 */
+  consistencyChecker?: (cached: TCacheData, serverData: TServerData) => boolean;
+}
+
+export interface CacheEntry<T> {
+  data: T;
+  timestamp: number;
+  expiresAt: number;
+  key: string;
+  sequence: number; // 请求序列号
+  metadata?: Record<string, unknown>;
+}
+
+export interface CacheStats {
+  cacheCount: number;
+  validCount: number;
+  expiredCount: number;
+}
+
+export interface RequestAdapter<TRequest, TResponse, TCacheData, TRealTimeData> {
+  /** 执行实际的网络请求 */
+  execute(endpoint: string, options?: TRequest): Promise<TResponse>;
+  /** 从响应中提取需要缓存的部分（不变数据） */
+  extractCacheableData?(response: TResponse): TCacheData;
+  /** 从响应中提取实时数据部分（变化数据） */
+  extractRealTimeData?(response: TResponse): TRealTimeData;
+  /** 合并缓存数据和实时数据 */
+  mergeData?(cached: TCacheData, realTime: TRealTimeData): TResponse;
+  /** 处理纯缓存场景的数据，当没有新的网络请求时 */
+  processCachedData?(cached: TCacheData): TResponse;
+}
+
+export abstract class RequestCacheService<TRequest, TResponse, TCacheData, TRealTimeData> {
+  private cache = new Map<string, CacheEntry<TCacheData>>();
+  private readonly config: {
+    duration: number;
+    timeout: number;
+    keyGenerator: <TReq>(endpoint: string, params?: TReq) => string;
+    consistencyChecker: (cached: TCacheData, serverData: TCacheData) => boolean;
+  };
+
+  // 请求去重：每个key只允许同时有一个正在进行的请求
+  private pendingRequests = new Map<string, Promise<TResponse>>();
+
+  // 请求序列号：防止晚到的请求覆盖早发出的请求结果
+  private requestSequence = 0;
+  private cacheSequences = new Map<string, number>();
+
+  constructor(
+    protected requestAdapter: RequestAdapter<TRequest, TResponse, TCacheData, TRealTimeData>,
+    config: Partial<CacheConfig<TCacheData, TCacheData>> = {}
+  ) {
+    this.config = {
+      duration: 10 * 60 * 1000, // 10分钟
+      timeout: 3000, // 3秒
+      keyGenerator: <TReq>(endpoint: string, _params?: TReq) => endpoint,
+      consistencyChecker: () => true,
+      ...config
+    };
+  }
+
+  /**
+   * 带缓存的请求方法 - 缓存优先 + 实时数据混合模式 + 请求去重
+   */
+  async request(endpoint: string, options?: TRequest): Promise<TResponse> {
+    const cacheKey = this.config.keyGenerator(endpoint, options);
+
+    // 检查是否有正在进行的请求，如果有则等待其完成
+    const pendingRequest = this.pendingRequests.get(cacheKey);
+    if (pendingRequest) {
+      console.log(`[RequestCacheService] Reusing pending request for ${endpoint}`);
+      return pendingRequest;
+    }
+
+    // internal request promise for background update
+    const internalRequestPromise = this.requestInternal(endpoint, options);
+
+    // createTimeoutPromise
+    const timeoutPromise = this.createTimeoutPromise();
+
+    // usePromiseRace
+    const racedPromise = Promise.race([internalRequestPromise, timeoutPromise]).catch(async (error) => {
+      // if timeout error, try to get data from cache as fallback
+      if (error.message.includes('timeout')) {
+        const cachedData = this.getValidCachedData(cacheKey);
+        if (cachedData) {
+          console.warn(`[RequestCacheService] Request timeout, falling back to cache for ${endpoint}`);
+          return this.requestAdapter.processCachedData
+            ? this.requestAdapter.processCachedData(cachedData)
+            : (cachedData as TResponse);
+        }
+      }
+      throw error;
+    });
+
+    this.pendingRequests.set(cacheKey, racedPromise);
+
+    // ensure internal request can be completed in background for cache update
+    internalRequestPromise
+      .then((result) => {
+        // 成功时不需要特殊处理，requestInternal 已经更新了缓存
+        console.log(`[RequestCacheService] Background request completed successfully for ${endpoint}`);
+      })
+      .catch((error) => {
+        console.warn(`[RequestCacheService] Background request failed for ${endpoint}:`, error);
+      });
+
+    try {
+      const result = await racedPromise;
+      return result;
+    } finally {
+      // 请求完成后清理 pending request
+      this.pendingRequests.delete(cacheKey);
+    }
+  }
+
+  private async requestInternal(endpoint: string, options?: TRequest): Promise<TResponse> {
+    const cacheKey = this.config.keyGenerator(endpoint, options);
+    const currentSequence = ++this.requestSequence; // 生成请求序列号
+
+    const cachedData = this.getValidCachedData(cacheKey);
+
+    console.log('[RequestCacheService] requestInternal start', endpoint, 'cached:', cachedData);
+    if (cachedData) {
+      if (this.requestAdapter.extractRealTimeData && this.requestAdapter.mergeData) {
+        try {
+          const freshResponse = await this.requestAdapter.execute(endpoint, options);
+          const realTimeData = this.requestAdapter.extractRealTimeData(freshResponse);
+
+          const serverCacheableData = this.requestAdapter.extractCacheableData?.(freshResponse);
+          if (serverCacheableData && !this.config.consistencyChecker(cachedData, serverCacheableData)) {
+            console.log(`[RequestCacheService] Cache invalidated due to data change for ${endpoint}`);
+            this.setCachedDataWithSequence(cacheKey, serverCacheableData, currentSequence);
+            return freshResponse;
+          }
+
+          return this.requestAdapter.mergeData(cachedData, realTimeData);
+        } catch (error) {
+          console.warn(
+            `[RequestCacheService] Failed to fetch real-time data, using cache only for ${endpoint}:`,
+            error
+          );
+          return this.requestAdapter.processCachedData
+            ? this.requestAdapter.processCachedData(cachedData)
+            : (cachedData as TResponse);
+        }
+      }
+
+      console.log(`[RequestCacheService] use cache for ${endpoint}`);
+      return this.requestAdapter.processCachedData
+        ? this.requestAdapter.processCachedData(cachedData)
+        : (cachedData as TResponse);
+    }
+
+    console.log(
+      `[RequestCacheService] Cache miss, fetching fresh data for ${endpoint} (sequence: ${currentSequence})`
+    );
+    const freshResponse = await this.requestAdapter.execute(endpoint, options);
+
+    const serverCacheableData = this.requestAdapter.extractCacheableData?.(freshResponse);
+    if (serverCacheableData) {
+      this.setCachedDataWithSequence(cacheKey, serverCacheableData, currentSequence);
+    }
+
+    return freshResponse;
+  }
+
+  /**
+   * timeout
+   */
+  private createTimeoutPromise(): Promise<never> {
+    return new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(
+          new Error(`[RequestCacheService] Request timeout after ${this.config.timeout / 1000} seconds`)
+        );
+      }, this.config.timeout);
+    });
+  }
+
+  /**
+   * get valid cached data
+   */
+  private getValidCachedData(key: string): TCacheData | null {
+    const cached = this.cache.get(key);
+
+    if (!cached) {
+      return null;
+    }
+
+    // 检查过期
+    if (Date.now() > cached.expiresAt) {
+      this.cache.delete(key);
+      return null;
+    }
+
+    return cached.data;
+  }
+
+  /**
+   * 设置缓存数据 (带序列号检查)
+   */
+  private setCachedDataWithSequence(
+    key: string,
+    data: TCacheData,
+    sequence: number,
+    metadata?: Record<string, unknown>
+  ): void {
+    const existing = this.cache.get(key);
+
+    // 如果已有缓存且序列号更新（说明当前请求是过时的），则不更新缓存
+    if (existing && existing.sequence > sequence) {
+      console.log(
+        `[RequestCacheService] Ignoring stale cache update for ${key} (current: ${existing.sequence}, incoming: ${sequence})`
+      );
+      return;
+    }
+
+    const now = Date.now();
+    this.cache.set(key, {
+      data: JSON.parse(JSON.stringify(data)), // 深拷贝
+      timestamp: now,
+      expiresAt: now + this.config.duration,
+      key,
+      sequence,
+      metadata
+    });
+
+    this.cacheSequences.set(key, sequence);
+    console.log(`[RequestCacheService] Updated cache for ${key} with sequence ${sequence}`);
+  }
+
+  /**
+   * refresh cache
+   */
+  async refreshCache(endpoint: string, options?: TRequest): Promise<TResponse> {
+    const cacheKey = this.config.keyGenerator(endpoint, options);
+    this.cache.delete(cacheKey);
+
+    return this.request(endpoint, options);
+  }
+
+  /**
+   * force request and update cache
+   */
+  async forceRequest(endpoint: string, options?: TRequest): Promise<TResponse> {
+    const cacheKey = this.config.keyGenerator(endpoint, options);
+    const currentSequence = ++this.requestSequence;
+
+    console.log(`[RequestCacheService] Force request for ${endpoint} (sequence: ${currentSequence})`);
+
+    const freshResponse = await this.requestAdapter.execute(endpoint, options);
+
+    const serverCacheableData = this.requestAdapter.extractCacheableData?.(freshResponse);
+
+    if (serverCacheableData) {
+      this.setCachedDataWithSequence(cacheKey, serverCacheableData, currentSequence);
+      console.log(`[RequestCacheService] Force updated cache for ${endpoint}`);
+    }
+
+    return freshResponse;
+  }
+
+  /**
+   * warmup cache - 避免与正在进行的请求冲突
+   */
+  async warmupCache(endpoint: string, options?: TRequest): Promise<void> {
+    const cacheKey = this.config.keyGenerator(endpoint, options);
+
+    // 如果有正在进行的请求，跳过 warmup
+    if (this.pendingRequests.has(cacheKey)) {
+      console.log(`[RequestCacheService] Skipping warmup for ${endpoint} - request in progress`);
+      return;
+    }
+
+    // 如果已有有效缓存，跳过 warmup
+    if (this.hasValidCache(cacheKey)) {
+      console.log(`[RequestCacheService] Skipping warmup for ${endpoint} - valid cache exists`);
+      return;
+    }
+
+    try {
+      console.log(`[RequestCacheService] Warming up cache for ${endpoint}`);
+      await this.forceRequest(endpoint, options);
+    } catch (error) {
+      console.warn(`[RequestCacheService] Cache warmup failed for ${endpoint}:`, error);
+    }
+  }
+
+  /**
+   * clear cache with target key
+   */
+  clearCache(key?: string): void {
+    if (key) {
+      this.cache.delete(key);
+      this.cacheSequences.delete(key);
+      this.pendingRequests.delete(key);
+      console.log(`[RequestCacheService] Cleared cache for ${key}`);
+    } else {
+      this.cache.clear();
+      this.cacheSequences.clear();
+      this.pendingRequests.clear();
+      this.requestSequence = 0; // 重置序列号
+      console.log('[RequestCacheService] Cleared all cache');
+    }
+  }
+
+  /**
+   * clear expired cache
+   */
+  clearExpiredCache(): void {
+    const now = Date.now();
+    for (const [key, entry] of this.cache) {
+      if (now > entry.expiresAt) {
+        this.cache.delete(key);
+        this.cacheSequences.delete(key);
+      }
+    }
+    console.log('[RequestCacheService] Cleared expired cache entries');
+  }
+
+  /**
+   * get cache stats
+   */
+  getCacheStats(): CacheStats & { pendingRequestCount: number } {
+    const now = Date.now();
+    let validCount = 0;
+    let expiredCount = 0;
+
+    for (const entry of this.cache.values()) {
+      if (now > entry.expiresAt) {
+        expiredCount++;
+      } else {
+        validCount++;
+      }
+    }
+
+    return {
+      cacheCount: this.cache.size,
+      validCount,
+      expiredCount,
+      pendingRequestCount: this.pendingRequests.size
+    };
+  }
+
+  /**
+   * get all cache keys
+   */
+  getCacheKeys(): string[] {
+    return Array.from(this.cache.keys());
+  }
+
+  /**
+   * check if the target key has valid cache
+   */
+  hasValidCache(key: string): boolean {
+    const cached = this.cache.get(key);
+    return cached ? Date.now() <= cached.expiresAt : false;
+  }
+
+  /**
+   * get pending request keys for debugging
+   */
+  getPendingRequestKeys(): string[] {
+    return Array.from(this.pendingRequests.keys());
+  }
+
+  /**
+   * check if a request is currently pending
+   */
+  hasPendingRequest(key: string): boolean {
+    return this.pendingRequests.has(key);
+  }
+
+  /**
+   * get cache sequence for a specific key
+   */
+  getCacheSequence(key: string): number | undefined {
+    return this.cacheSequences.get(key);
+  }
+}

package/src/common/rewards/cached-fetch-reward.ts

@@ -16,7 +16,6 @@ const priority = () => {
   return (a: RewardType, b: RewardType) => {
     // Priority order: GEM > JOLI_COIN > ADS
     const priorityMap: Record<RewardType, number> = {
-      SUBSCRIPTION: 4,
       JOLI_GEM: 3,
       JOLI_GEM_ONLY: 3,
       JOLI_COIN: 2,
@@ -30,24 +29,8 @@ const priority = () => {
 
 const sortRewards = (rewardsTypes: RewardType[]): RewardType[] => {
   if (!rewardsTypes.length) return ['ADS'];
-
-  // Handle JOLI_GEM cases
-  if (rewardsTypes.includes('JOLI_GEM')) {
-    if (rewardsTypes.length === 1) {
-      return ['JOLI_GEM_ONLY'];
-    } else if (rewardsTypes.includes('SUBSCRIPTION') && rewardsTypes.length === 2) {
-      return ['SUBSCRIPTION', 'JOLI_GEM_ONLY'];
-    }
-  }
-
-  // Handle JOLI_COIN cases
-  if (rewardsTypes.includes('JOLI_COIN')) {
-    if (rewardsTypes.length === 1) {
-      return ['JOLI_COIN_ONLY'];
-    } else if (rewardsTypes.includes('SUBSCRIPTION') && rewardsTypes.length === 2) {
-      return ['SUBSCRIPTION', 'JOLI_COIN_ONLY'];
-    }
-  }
+  if (rewardsTypes.includes('JOLI_GEM') && rewardsTypes.length <= 1) return ['JOLI_GEM_ONLY'];
+  if (rewardsTypes.includes('JOLI_COIN') && rewardsTypes.length <= 1) return ['JOLI_COIN_ONLY'];
 
   return rewardsTypes.sort(priority());
 };

package/src/common/rewards/cached-reward-service.ts

@@ -1,4 +1,4 @@
-import { RequestCacheService, RequestAdapter } from '@jolibox/common';
+import { RequestCacheService, RequestAdapter } from '../cache/request-cache-service';
 import { IHttpClient } from '../http';
 import { StandardResponse, GlobalConfig } from '@jolibox/types';
 import { IJolicoinRewardOption, IUnlockOption, IJoliCoin, IGem } from './type';
@@ -50,8 +50,8 @@ class RewardRequestAdapter
   extractCacheableData(response: IJolicoinRewardOption): UnlockOptionsCacheData {
     return {
       unlockOptions: response.data?.unlockOptions || [],
-      joliCoin: response.extra?.joliCoin,
-      joliGem: response.extra?.joliGem || { balance: 0, enableAutoDeduct: false }
+      joliCoin: response.extra.joliCoin,
+      joliGem: response.extra.joliGem || { balance: 0, enableAutoDeduct: false }
     };
   }
 

package/src/common/rewards/index.ts

@@ -10,7 +10,6 @@ export * from './registers/use-jolicoin';
 export * from './registers/use-jolicoin-only';
 export * from './registers/use-gem';
 export * from './registers/use-gem-only';
-export * from './registers/use-subscription';
 
 export { warmupBalanceCache } from './registers/utils/coins/jolicoin/cached-fetch-balance';
 export { warmupGemBalanceCache } from './registers/utils/coins/joligem/cached-fetch-gem-balance';

package/src/common/rewards/registers/utils/coins/commands/use-payment.ts

@@ -10,6 +10,8 @@ import {
   InvokePaymentEventName
 } from '@/common/rewards/reward-emitter';
 import { CURRENCY_HANDLERS, CurrencyType } from './currency-handlers';
+import { refreshGemBalanceCache } from '../joligem/cached-fetch-gem-balance';
+import { refreshBalanceCache } from '../jolicoin/cached-fetch-balance';
 
 export const registerUsePaymentCommand = <T extends IJoliCoin | IGem>(
   prefix: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
@@ -48,6 +50,12 @@ export const registerUsePaymentCommand = <T extends IJoliCoin | IGem>(
         currency: currency as T extends IJoliCoin ? 'JOLI_COIN' : 'JOLI_GEM'
       });
 
+      if (currency === 'JOLI_GEM') {
+        refreshGemBalanceCache(httpClient);
+      } else {
+        refreshBalanceCache(httpClient);
+      }
+
       return {
         result: paymentResult === 'SUCCESS' ? 'SUCCESS' : 'FAILED'
       };

package/src/common/rewards/registers/utils/coins/jolicoin/cached-fetch-balance.ts

@@ -1,4 +1,4 @@
-import { RequestCacheService, RequestAdapter } from '@jolibox/common';
+import { RequestCacheService, RequestAdapter } from '@/common/cache/request-cache-service';
 import { IHttpClient } from '@/common/http';
 import { StandardResponse } from '@jolibox/types';
 

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

@@ -1,4 +1,4 @@
-import { RequestCacheService, RequestAdapter } from '@jolibox/common';
+import { RequestCacheService, RequestAdapter } from '@/common/cache/request-cache-service';
 import { IHttpClient } from '@/common/http';
 import { StandardResponse } from '@jolibox/types';
 

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

@@ -17,8 +17,6 @@ export const UseModalResultEventName = 'ON_USE_MODAL_RESULT' as const;
 export const UseModalFrequencyEventName = 'ON_USE_MODAL_FREQUENCY' as const;
 export const UseUnloginModalResultEventName = 'ON_USE_UNLOGIN_MODAL_EVENT' as const;
 export const InvokeUnloginModalEventName = 'INVOKE_UNLOGIN_MODAL_EVENT' as const;
-export const InvokeSubscriptionEventName = 'INVOKE_SUBSCRIPTION_EVENT' as const;
-export const UseSubscriptionResultEventName = 'ON_USE_SUBSCRIPTION_RESULT' as const;
 
 type IPaymentResult = 'SUCCESS' | 'FAILED' | 'CANCEL';
 export interface IPaymentEvent {
@@ -92,10 +90,6 @@ export interface IUseModalFrequencyConfig {
   };
 }
 
-export interface IUseSubscriptionResultEvent {
-  result: 'SUCCESS' | 'CANCEL' | 'FAILED';
-}
-
 export interface RewardsEventMap extends Record<string, unknown[]> {
   [UnlockOptionsEventName]: [IUnlockOptionsEvent];
   [InvokePaymentEventName]: [
@@ -111,8 +105,6 @@ export interface RewardsEventMap extends Record<string, unknown[]> {
     IUseUnloginModalEvent
   ];
   [UseUnloginModalResultEventName]: [IUseUnloginModalResultEvent];
-  [InvokeSubscriptionEventName]: ['SUBSCRIPTION'];
-  [UseSubscriptionResultEventName]: [IUseSubscriptionResultEvent];
 }
 
 export const originalRewardsEmitter = new EventEmitter<RewardsEventMap>();

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

@@ -1,10 +1,4 @@
-export type RewardType =
-  | 'ADS'
-  | 'JOLI_COIN'
-  | 'JOLI_COIN_ONLY'
-  | 'JOLI_GEM'
-  | 'JOLI_GEM_ONLY'
-  | 'SUBSCRIPTION';
+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';
@@ -16,7 +10,6 @@ export interface RewardHandlerMap {
   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
-  SUBSCRIPTION: (params?: unknown) => Promise<boolean>; // subscription
 }
 
 export type RewardHandler<T extends RewardType> = RewardHandlerMap[T];

package/src/common/utils/index.ts

@@ -8,11 +8,6 @@ const JOLIBOX_JOLI_COIN_USE_EVENT = 'JOLIBOX_JOLI_COIN_USE_EVENT';
 const JOLIBOX_JOLI_UNLOGIN_MODAL_EVENT = 'JOLIBOX_JOLI_UNLOGIN_MODAL_EVENT'; // unlogin modal event, triggered when unlogin
 // unlogin modal result event success.
 
-// subscrition
-
-const JOLIBOX_GET_USER_SUB_STATUS = 'JOLIBOX_GET_USER_SUB_STATUS';
-const JOLIBOX_SUB_EVENT = 'JOLIBOX_SUB_EVENT';
-
 interface JoliboxCustomEvent {
   [JOLIBOX_CUSTOM_ADS_EVENT_TYPE]: {
     isAdShowing: boolean;
@@ -46,12 +41,6 @@ interface JoliboxCustomEvent {
     sequenceId: string;
     type: 'ADS-JOLI_COIN' | 'JOLI_COIN';
   };
-  [JOLIBOX_GET_USER_SUB_STATUS]: {
-    sequenceId: string;
-  };
-  [JOLIBOX_SUB_EVENT]: {
-    sequenceId: string;
-  };
 }
 
 const notifyCustomEvent = <T extends keyof JoliboxCustomEvent>(eventName: T, data: JoliboxCustomEvent[T]) => {
@@ -77,10 +66,6 @@ const ON_JOLIBOX_TOPUP_JOLI_COIN_RESULT = 'ON_JOLIBOX_TOPUP_JOLI_COIN_RESULT';
 const ON_JOLIBOX_JOLI_COIN_USE_RESULT = 'ON_JOLIBOX_JOLI_COIN_USE_RESULT';
 const ON_JOLIBOX_JOLI_UNLOGIN_MODAL_RESULT_EVENT = 'ON_JOLIBOX_JOLI_UNLOGIN_MODAL_RESULT_EVENT';
 
-// subscription
-const ON_GET_USER_SUB_STATUS = 'ON_GET_USER_SUB_STATUS';
-const ON_JOLIBOX_SUB_RESULT_EVENT = 'ON_JOLIBOX_SUB_RESULT_EVENT';
-
 interface ReceivedJoliboxCustomEvent {
   [ON_JOLIBOX_TOPUP_JOLI_COIN_RESULT]: {
     sequenceId: string;
@@ -108,14 +93,6 @@ interface ReceivedJoliboxCustomEvent {
     };
     isFirstLogin?: boolean;
   };
-  [ON_GET_USER_SUB_STATUS]: {
-    sequenceId: string;
-    isSubUser: boolean;
-  };
-  [ON_JOLIBOX_SUB_RESULT_EVENT]: {
-    sequenceId: string;
-    result: 'SUCCESS' | 'CANCEL' | 'FAILED';
-  };
 }
 
 type ReceivedJoliboxCustomEventResult = keyof ReceivedJoliboxCustomEvent;

package/src/h5/api/ads.ts

@@ -6,8 +6,7 @@ import {
   createAdsRewardHandler,
   rewardsHelper,
   createJolicoinRewardHandler,
-  createJolicoinOnlyRewardHandler,
-  createSubscriptionRewardHandler
+  createJolicoinOnlyRewardHandler
 } from '@/common/rewards';
 import {
   JoliboxAdsForGame,
@@ -25,7 +24,7 @@ import GamedistributionAdsHandler from './platformAdsHandle/GamedistributionAdsH
 import FunmaxAdsHandler from './platformAdsHandle/FunmaxAdsHandler';
 import JoliboxAdsHandler from './platformAdsHandle/JoliboxAdsHandler';
 import { warmupRewardCache } from '@/common/rewards/fetch-reward';
-import { warmupBalanceCache } from '@/common/rewards';
+import { warmupBalanceCache, warmupGemBalanceCache } from '@/common/rewards';
 
 declare global {
   interface Window {
@@ -130,9 +129,13 @@ const adsContext: IAdsContext<'GAME'> = {
   }
 };
 
-
-const handleUnlockWithSubscriptionSuccess = () => {
-  track('subscription_unlock_success', {});
+const handleUnlockSuccess = (params: { quantity: number; balance: number }) => {
+  notifyCustomEvent('JOLIBOX_CUSTOM_REWARDS_EVENT', {
+    JOLI_COIN: params
+  });
+  track('jolicoin_unlock_success', {
+    quantity: params.quantity
+  });
 };
 
 const adsManager = new H5AdsManager(adsContext);
@@ -142,18 +145,14 @@ rewardsHelper.registerRewardHandler('ADS', createAdsRewardHandler(adsHandler.get
 rewardsHelper.registerRewardHandler(
   'JOLI_COIN',
   createJolicoinRewardHandler(httpClient, {
-    onUnlockSuccess: (params: { quantity: number; balance: number }) => {
-      notifyCustomEvent('JOLIBOX_CUSTOM_REWARDS_EVENT', {
-        JOLI_COIN: params
-      });
-    }
+    onUnlockSuccess: handleUnlockSuccess.bind(this)
   }) as unknown as (params?: unknown) => Promise<boolean>
 );
 
 rewardsHelper.registerRewardHandler(
-  'SUBSCRIPTION',
-  createSubscriptionRewardHandler(httpClient, {
-    onSubSuccess: handleUnlockWithSubscriptionSuccess.bind(this)
+  'JOLI_COIN_ONLY',
+  createJolicoinOnlyRewardHandler(httpClient, {
+    onUnlockSuccess: handleUnlockSuccess.bind(this)
   }) as unknown as (params?: unknown) => Promise<boolean>
 );