@jolibox/implement 1.2.8 → 1.2.9-beta.9

package/dist/native/payment/utils/__tests__/cache-with-storage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/native/payment/utils/cache-with-storage.d.ts

@@ -0,0 +1,7 @@
+export declare function executeAndCache<T>(cacheKey: string, executor: () => Promise<T>, options?: {
+    storageKeyPrefix?: string;
+}): Promise<T>;
+export declare function executeWithPersistentCache<T>(cacheKey: string, executor: () => Promise<T>, options?: {
+    cacheDuration?: number;
+    storageKeyPrefix?: string;
+}): Promise<T>;

package/dist/native/rewards/check-frequency.d.ts

@@ -40,9 +40,17 @@ export declare const checkUnloginModalFrequencyGem: (config: {
     canShow: boolean;
     isFirst: boolean;
 }>;
+export declare const checkSubscriptionFrequency: (config: {
+    dailyMaxPopUps?: number;
+    minInterval?: number;
+}) => Promise<{
+    canShow: boolean;
+    isFirst: boolean;
+}>;
 export declare const updateUseModalFrequency: () => Promise<void>;
 export declare const updatePaymentFrequency: () => Promise<void>;
 export declare const updateUnloginModalFrequency: () => Promise<void>;
 export declare const updateUseModalFrequencyGem: () => Promise<void>;
 export declare const updatePaymentFrequencyGem: () => Promise<void>;
 export declare const updateUnloginModalFrequencyGem: () => Promise<void>;
+export declare const updateSubscriptionFrequency: () => Promise<void>;

package/dist/native/rewards/index.d.ts

@@ -4,3 +4,4 @@
 import './ui/use-modal';
 import './ui/payment-modal';
 import './ui/unlogin-modal';
+import './ui/subscription-modal';

package/dist/native/rewards/ui/subscription-modal.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/native/subscription/index.d.ts

@@ -0,0 +1,3 @@
+export * from './subscription-service';
+export * from './type';
+export declare const subscriptionService: import("./subscription-service").SubscriptionService;

package/dist/native/subscription/registers/base.d.ts

@@ -0,0 +1,22 @@
+import { StandardResponse } from '@jolibox/types';
+import type { IPlaceSubscriptionOrderResponse } from './type';
+import { UserPaymentError, InternalPaymentError } from '@jolibox/common';
+type SubscriptionStatus = 'INIT' | 'PENDING' | 'SUCCESS' | 'FAILED';
+declare const createSubscriptionError: (errMsg: string, errNo: number, extra?: Record<string, unknown>) => UserPaymentError | InternalPaymentError, createSubscriptionInternalError: (errMsg: string, errNo: number, extra?: Record<string, unknown>) => UserPaymentError | InternalPaymentError;
+export { createSubscriptionError, createSubscriptionInternalError };
+export declare abstract class BaseSubscriptionRegister<T extends Record<string, any>, E extends Record<string, any>, R = void> {
+    private _orderId;
+    private _orderStatus;
+    startSubscription: (params: T) => Promise<StandardResponse<R>>;
+    protected generateCallbackUrl: () => string;
+    protected setOrderId(orderId: string): void;
+    protected setOrderStatus(status: SubscriptionStatus): void;
+    protected createSubscriptionError: (errMsg: string, errNo: number, extra?: Record<string, unknown>) => UserPaymentError | InternalPaymentError;
+    protected createSubscriptionInternalError: (errMsg: string, errNo: number, extra?: Record<string, unknown>) => UserPaymentError | InternalPaymentError;
+    abstract placeOrder(params: T): Promise<StandardResponse<IPlaceSubscriptionOrderResponse<E>>>;
+    abstract cancelOrder(orderId: string): Promise<StandardResponse<void>>;
+    abstract generateSubscriptionContext(): Record<string, any>;
+    abstract subscribe(params: T): Promise<StandardResponse<R>>;
+    get orderId(): string | null;
+    get status(): SubscriptionStatus;
+}

package/dist/native/subscription/registers/sub-app.d.ts

@@ -0,0 +1,21 @@
+import { StandardResponse } from '@jolibox/types';
+export interface IPlaceOrderSubAppParams {
+    basePlanId: string;
+    appStoreProductId: string;
+    productId: string;
+}
+export interface ISubAppProductInfo {
+    subPlanId: string;
+}
+export interface ISubAppSubscriptionContext {
+    gameId: string;
+    productId: string;
+    planId: string;
+}
+export declare function createSubAppSubscriptionHandler(): (params: {
+    productId: string;
+    appStoreProductId: string;
+    planId: string;
+}) => Promise<StandardResponse<{
+    subPlanId: string;
+}, unknown>>;

package/dist/native/subscription/registers/type.d.ts

@@ -0,0 +1,10 @@
+export interface IPlaceSubscriptionOrderResponse<T = any> {
+    orderId: string;
+    productInfo: T;
+}
+export declare const SubscriptionErrorCodeMap: {
+    readonly PlaceOrderFailed: 1001;
+    readonly CancelOrderFailed: 1002;
+    readonly SubscriptionFailed: 1003;
+    readonly InvalidPlan: 1004;
+};

package/dist/native/subscription/subscription-helper.d.ts

@@ -0,0 +1,22 @@
+export type SubscriptionType = 'SUB_APP';
+import { StandardResponse } from '@jolibox/types';
+export type SubscriptionResult<T> = StandardResponse<T>;
+export interface SubscriptionHandlerMap {
+    SUB_APP: (params: {
+        productId: string;
+        appStoreProductId: string;
+        planId: string;
+    }) => Promise<SubscriptionResult<{
+        subPlanId: string;
+    }>>;
+}
+export type SubscriptionHandler<T extends SubscriptionType> = SubscriptionHandlerMap[T];
+export declare function createSubscriptionHelper(): {
+    registerSubscriptionHandler<T extends SubscriptionType>(type: T, handler: SubscriptionHandler<T>): void;
+    invokeSubscription<T extends SubscriptionType>(type: T, ...args: Parameters<SubscriptionHandler<T>>): Promise<any>;
+};
+export type SubscriptionHelper = ReturnType<typeof createSubscriptionHelper>;
+export declare const subscriptionHelper: {
+    registerSubscriptionHandler<T extends SubscriptionType>(type: T, handler: SubscriptionHandler<T>): void;
+    invokeSubscription<T extends SubscriptionType>(type: T, ...args: Parameters<SubscriptionHandler<T>>): Promise<any>;
+};

package/dist/native/subscription/subscription-service.d.ts

@@ -0,0 +1,43 @@
+import { ISubscriptionTierData } from '@jolibox/types';
+import { StandardResponse } from '@jolibox/types';
+import { RequestCacheService } from '@jolibox/common';
+type SubscriptionRequest = Record<string, never>;
+type SubscriptionResponse = ISubscriptionTierData[];
+interface SubscriptionCacheData {
+    subscriptionTiers: ISubscriptionTierData[];
+}
+declare class BaseSubscriptionService extends RequestCacheService<SubscriptionRequest, SubscriptionResponse, SubscriptionCacheData, never> {
+    private apiEndpoint;
+    private pendingSubscriptions;
+    private subInfoCacheKeys;
+    constructor(apiEndpoint: string);
+    getSubInfo(): Promise<SubscriptionResponse | undefined>;
+    refreshSubInfo(): Promise<SubscriptionResponse | undefined>;
+    updateNativePriceCache(appStoreProductIds: string[]): Promise<void>;
+    updateAllNativePriceCache(): Promise<void>;
+    subscribe(params: {
+        basePlanId: string;
+        nativeProductId: string;
+        appStoreProductId: string;
+    }): Promise<{
+        subPlanId: string;
+        message: string;
+        result: 'SUCCESS' | 'FAILED' | 'FAILURE_SUBSCRIPTED';
+    }>;
+    invokeSubscriptionPanel(): Promise<StandardResponse<{
+        result: 'SUCCESS' | 'FAILED';
+        subPlanId?: string;
+    }>>;
+    getTierByProductId(productId: string): Promise<{
+        nativeProductId: string;
+        appStoreProductId: string;
+        basePlanId: string;
+    } | undefined>;
+    private listenSubscriptionPanelStateChange;
+}
+export declare class SubscriptionService extends BaseSubscriptionService {
+    constructor();
+}
+export declare const createSubscriptionService: () => SubscriptionService;
+export declare const clearSubscriptionNativePriceCache: () => void;
+export {};

package/dist/native/subscription/type.d.ts

@@ -0,0 +1,18 @@
+export interface ISubscriptionPlanData {
+    basePlanId: string;
+    productId: string;
+    pricing: {
+        formattedPrice: string;
+        originalPrice?: string;
+        discountPercentage?: number;
+    };
+    trial?: {
+        duration: number;
+        description?: string;
+    };
+    promotion?: {
+        type: 'new_user' | 'limited_time' | 'winback';
+        badge: string;
+        description: string;
+    };
+}

package/implement.build.log

@@ -1,9 +1,9 @@
 Invoking: npm run clean && npm run build:esm && tsc 
 
-> @jolibox/implement@1.2.8 clean
+> @jolibox/implement@1.2.9-beta.9 clean
 > rimraf ./dist
 
 
-> @jolibox/implement@1.2.8 build:esm
+> @jolibox/implement@1.2.9-beta.9 build:esm
 > BUILD_VERSION=$(node -p "require('./package.json').version")  node esbuild.config.js --format=esm
 

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@jolibox/implement",
   "description": "This project is Jolibox JS-SDk implement for Native && H5",
-  "version": "1.2.8",
+  "version": "1.2.9-beta.9",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@jolibox/common": "1.2.8",
-    "@jolibox/types": "1.2.8",
-    "@jolibox/native-bridge": "1.2.8",
-    "@jolibox/ads": "1.2.8",
+    "@jolibox/common": "1.2.9-beta.9",
+    "@jolibox/types": "1.2.9-beta.9",
+    "@jolibox/native-bridge": "1.2.9-beta.9",
+    "@jolibox/ads": "1.2.9-beta.9",
     "localforage": "1.10.0",
     "@jolibox/ui": "1.0.0",
     "web-vitals": "4.2.4"

package/src/common/context/index.ts

@@ -76,6 +76,9 @@ const wrapContext = () => {
   const testMode = joliboxEnv === 'staging';
   const channel = headerJson?.channel;
 
+  const originUrl = new URL(window.location.href);
+  const originUrlParams = originUrl.searchParams;
+
   // default should show stay recommend panel
   let shouldInterupt = payloadJson?.__shouldInterupt;
 
@@ -93,7 +96,7 @@ const wrapContext = () => {
       return joliboxEnv;
     },
     get joliSource(): string | null {
-      return urlParams.get('joliSource') ?? null;
+      return originUrlParams.get('joliSource') ?? urlParams.get('joliSource') ?? null;
     },
     get mpId(): string {
       return defaultGameID ?? payloadJson?.id ?? '';

package/src/common/rewards/registers/use-gem-only.ts

@@ -13,10 +13,12 @@ export const createGemOnlyRewardHandler = (
   httpClient: IHttpClient,
   {
     onUnlockSuccess,
-    onUnlockFailed
+    onUnlockFailed,
+    hasSubscription
   }: {
     onUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
     onUnlockFailed?: () => void;
+    hasSubscription: () => boolean;
   }
 ): GemOnlyRewardsHandler => {
   const handleUnlockFailed = (() => (params: IAdBreakParams) => {
@@ -50,7 +52,8 @@ export const createGemOnlyRewardHandler = (
       unlockOptionsHandler,
       initiateAndAwaitPayment,
       showUnlockWithCurrencyModal: showUnlockWithGemModal,
-      showUnloginModal
+      showUnloginModal,
+      hasSubscription
     }
   });
 

package/src/common/rewards/registers/use-gem.ts

@@ -13,10 +13,12 @@ export const createGemRewardHandler = (
   httpClient: IHttpClient,
   {
     onUnlockSuccess,
-    onUnlockFailed
+    onUnlockFailed,
+    hasSubscription
   }: {
     onUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
     onUnlockFailed?: () => void;
+    hasSubscription: () => boolean;
   }
 ): GemRewardsHandler => {
   const handleUnlockFailed = () => {
@@ -45,7 +47,8 @@ export const createGemRewardHandler = (
       unlockOptionsHandler,
       initiateAndAwaitPayment,
       showUnlockWithCurrencyModal: showUnlockWithGemModal,
-      showUnloginModal
+      showUnloginModal,
+      hasSubscription
     }
   });
 

package/src/common/rewards/registers/use-jolicoin-only.ts

@@ -13,10 +13,12 @@ export const createJolicoinOnlyRewardHandler = (
   httpClient: IHttpClient,
   {
     onUnlockSuccess,
-    onUnlockFailed
+    onUnlockFailed,
+    hasSubscription
   }: {
     onUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
     onUnlockFailed?: () => void;
+    hasSubscription: () => boolean;
   }
 ): JolicoinOnlyRewardsHandler => {
   const handleUnlockFailed = (() => (params: IAdBreakParams) => {
@@ -50,7 +52,8 @@ export const createJolicoinOnlyRewardHandler = (
       unlockOptionsHandler,
       initiateAndAwaitPayment,
       showUnlockWithCurrencyModal: showUnlockWithJolicoinModal,
-      showUnloginModal
+      showUnloginModal,
+      hasSubscription
     }
   });
 

package/src/common/rewards/registers/use-jolicoin.ts

@@ -13,10 +13,12 @@ export const createJolicoinRewardHandler = (
   httpClient: IHttpClient,
   {
     onUnlockSuccess,
-    onUnlockFailed
+    onUnlockFailed,
+    hasSubscription
   }: {
     onUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
     onUnlockFailed?: () => void;
+    hasSubscription: () => boolean;
   }
 ): JolicoinRewardsHandler => {
   const handleUnlockFailed = () => {
@@ -45,7 +47,8 @@ export const createJolicoinRewardHandler = (
       unlockOptionsHandler,
       initiateAndAwaitPayment,
       showUnlockWithCurrencyModal: showUnlockWithJolicoinModal,
-      showUnloginModal
+      showUnloginModal,
+      hasSubscription
     }
   });
 

package/src/common/rewards/registers/use-subscription.ts

@@ -9,10 +9,12 @@ export const createSubscriptionRewardHandler = (
   httpClient: IHttpClient,
   {
     onSubSuccess,
-    onSubFailed
+    onSubFailed,
+    hasSubscription
   }: {
     onSubSuccess?: () => void;
     onSubFailed?: () => void;
+    hasSubscription: () => boolean;
   }
 ): SubscriptionRewardsHandler => {
   const handleUnlockFailed = () => {
@@ -26,7 +28,8 @@ export const createSubscriptionRewardHandler = (
       handleSubSuccess: onSubSuccess,
       handleSubFailed: handleUnlockFailed,
       unlockOptionsHandler,
-      showSubscriptionModal
+      showSubscriptionModal,
+      hasSubscription
     }
   });
 

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

@@ -17,6 +17,8 @@ import {
 import { rewardsCommands } from '../rewards-command';
 import { RewardsCommandType } from '@jolibox/types';
 import { refreshBalanceCache, warmupBalanceCache } from './cached-fetch-balance';
+import { CURRENCY_HANDLERS } from '../commands/currency-handlers';
+import { checkIfSupportSubscription } from '../../common';
 
 interface ICurrencyUnlockRes {
   code: 'SUCCESS' | 'BALANCE_NOT_ENOUGH' | 'EPISODE_LOCK_JUMP' | 'EPISODE_UNLOCK_ALREADY';
@@ -39,7 +41,8 @@ const createCommonCurrencyRewardHandler = (
       unlockOptionsHandler,
       initiateAndAwaitPayment,
       showUnlockWithCurrencyModal,
-      showUnloginModal
+      showUnloginModal,
+      hasSubscription
     }
   }: {
     handlers: {
@@ -49,6 +52,7 @@ const createCommonCurrencyRewardHandler = (
       initiateAndAwaitPayment: ReturnType<typeof createInitiateAndAwaitPayment>;
       showUnlockWithCurrencyModal: ReturnType<typeof createShowUnlockWithCurrencyModal>;
       showUnloginModal: ReturnType<typeof createShowUnloginModal>;
+      hasSubscription?: () => boolean;
     };
   }
 ) => {
@@ -67,19 +71,36 @@ const createCommonCurrencyRewardHandler = (
   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;
+      const unlockOptions = await unlockOptionsHandler.getData();
+
+      const supportSubscription = checkIfSupportSubscription(unlockOptions, hasSubscription);
+      if (supportSubscription) {
+        // Use currency handler for balance and quantity calculation
+        const handler = CURRENCY_HANDLERS['JOLI_COIN'];
+        const newBalance = await handler.fetchBalance(httpClient);
+        const currentUser = handler.getCurrentUser(unlockOptions);
+        const newUser = handler.createUpdatedUser(newBalance?.balance ?? 0, currentUser.enableAutoDeduct);
+
+        if (!handler.isEnough(unlockOptions, newUser)) {
+          handleUnlockFailed?.(params);
+          return false;
+        }
+      } else {
+        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;
         }
       }
 
-      if (!result) {
-        handleUnlockFailed?.(params);
-        return false;
-      }
+      // success
 
       const config = CURRENCY_CONFIG[currencyType];
       const unlockWithCurrency = await httpClient.post<ICurrencyUnlockRes>(config.unlockEndpoint, {
@@ -143,6 +164,7 @@ export const createCommonJolicoinRewardHandler = (
       initiateAndAwaitPayment: ReturnType<typeof createInitiateAndAwaitPayment>;
       showUnlockWithCurrencyModal: ReturnType<typeof createShowUnlockWithCurrencyModal>;
       showUnloginModal: ReturnType<typeof createShowUnloginModal>;
+      hasSubscription?: () => boolean;
     };
   }
 ) => {

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

@@ -4,7 +4,7 @@ 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 { CURRENCY_CONFIG, CurrencyType } from '../currency-config';
 
 import {
   createInitiateAndAwaitPayment,
@@ -16,6 +16,8 @@ import { registerUseJolicoinCommand, createShowUnlockWithCurrencyModal } from '.
 import { rewardsCommands } from '../rewards-command';
 import { RewardsCommandType } from '@jolibox/types';
 import { refreshGemBalanceCache, warmupGemBalanceCache } from './cached-fetch-gem-balance';
+import { CURRENCY_HANDLERS } from '../commands/currency-handlers';
+import { checkIfSupportSubscription } from '../../common';
 
 interface IGemUnlockRes {
   code: 'SUCCESS' | 'BALANCE_NOT_ENOUGH' | 'EPISODE_LOCK_JUMP' | 'EPISODE_UNLOCK_ALREADY';
@@ -37,7 +39,8 @@ export const createCommonGemRewardHandler = (
       unlockOptionsHandler,
       initiateAndAwaitPayment,
       showUnlockWithCurrencyModal,
-      showUnloginModal
+      showUnloginModal,
+      hasSubscription
     }
   }: {
     handlers: {
@@ -47,6 +50,7 @@ export const createCommonGemRewardHandler = (
       initiateAndAwaitPayment: ReturnType<typeof createInitiateAndAwaitPayment>;
       showUnlockWithCurrencyModal: ReturnType<typeof createShowUnlockWithCurrencyModal>;
       showUnloginModal: ReturnType<typeof createShowUnloginModal>;
+      hasSubscription?: () => boolean;
     };
   }
 ) => {
@@ -67,18 +71,35 @@ export const createCommonGemRewardHandler = (
 
   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;
-        }
-      }
+      const unlockOptions = await unlockOptionsHandler.getData();
+      const supportSubscription = checkIfSupportSubscription(unlockOptions, hasSubscription);
 
-      if (!result) {
-        handleUnlockFailed?.(params);
-        return false;
+      console.log('[GemHandler] supportSubscription', supportSubscription, unlockOptions);
+      if (supportSubscription) {
+        // Use currency handler for balance and quantity calculation
+        const handler = CURRENCY_HANDLERS['JOLI_GEM'];
+        const newBalance = await handler.fetchBalance(httpClient);
+        const currentUser = handler.getCurrentUser(unlockOptions);
+        const newUser = handler.createUpdatedUser(newBalance?.balance ?? 0, currentUser.enableAutoDeduct);
+
+        if (!handler.isEnough(unlockOptions, newUser)) {
+          handleUnlockFailed?.(params);
+          return false;
+        }
+      } else {
+        let result = true;
+        for (const command of commands) {
+          const commandResult = await rewardsCommands.executeCommand(command as RewardsCommandType);
+          console.log('[GemHandler] command result', commandResult, command);
+          result = result && commandResult.result !== 'FAILED';
+          if (commandResult.result !== 'CONTINUE') {
+            break;
+          }
+        }
+        if (!result) {
+          handleUnlockFailed?.(params);
+          return false;
+        }
       }
 
       const config = CURRENCY_CONFIG['GEM'];

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

@@ -6,3 +6,12 @@ export const unlockOptionsHandler = createEventPromiseHandler<
   IUnlockOptionsEvent,
   typeof UnlockOptionsEventName
 >(rewardsEmitter, UnlockOptionsEventName);
+
+export const checkIfSupportSubscription = (
+  unlockOptions: IUnlockOptionsEvent,
+  extraCheck?: () => boolean
+) => {
+  const hasSubscription = unlockOptions.options?.some((option) => option.type === 'SUBSCRIPTION');
+  console.log('typeof extraCheck', typeof extraCheck, extraCheck?.());
+  return hasSubscription && (!extraCheck || extraCheck?.());
+};

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

@@ -1,4 +1,6 @@
+import { CURRENCY_HANDLERS, CurrencyType } from '../../coins/commands/currency-handlers';
 import { rewardsCommands } from '../../coins/rewards-command';
+import { unlockOptionsHandler } from '../../common';
 import { createEventPromiseHandler } from '../../event-listener';
 import { IUseSubscriptionResultEvent, UseSubscriptionResultEventName } from '@/common/rewards/reward-emitter';
 import { rewardsEmitter, InvokeSubscriptionEventName } from '@/common/rewards/reward-emitter';
@@ -8,6 +10,20 @@ export const registerUseSubscriptionCommand = (params: {
 }) => {
   const { showSubscriptionModal } = params;
   rewardsCommands.registerCommand(`Rewards.subscription`, async () => {
+    const unlockOptions = await unlockOptionsHandler.getData();
+
+    const type = unlockOptions?.options?.find((option) => option.type === 'JOLI_GEM')?.type;
+    // Use currency handler for balance and quantity calculation
+    const handler = CURRENCY_HANDLERS[type ? 'JOLI_GEM' : 'JOLI_COIN'];
+    const currentUser = handler.getCurrentUser(unlockOptions);
+
+    // if enough, pass this command into JOLI_GEM or JOLI_COIN command
+    if (handler.isEnough(unlockOptions, currentUser)) {
+      return {
+        result: 'FAILED'
+      };
+    }
+
     const subscriptionResult = await showSubscriptionModal();
     return {
       result: subscriptionResult === 'SUCCESS' ? 'SUCCESS' : 'FAILED'

package/src/common/rewards/registers/utils/subscription/sub-handler.ts

@@ -7,18 +7,28 @@ import { RewardsCommandType } from '@jolibox/types';
 import { createShowSubscriptionModal } from './commands/use-subscription';
 import { registerUseSubscriptionCommand } from './commands';
 import { context } from '@/common/context';
+import { checkIfSupportSubscription } from '../common';
+import { refreshBalanceCache } from '../coins/jolicoin/cached-fetch-balance';
+import { refreshGemBalanceCache } from '../coins/joligem/cached-fetch-gem-balance';
 
 export const createCommonSubscriptionHandler = (
   type: 'SUBSCRIPTION',
   httpClient: IHttpClient,
   {
-    handlers: { handleSubSuccess, handleSubFailed, unlockOptionsHandler, showSubscriptionModal }
+    handlers: {
+      handleSubSuccess,
+      handleSubFailed,
+      unlockOptionsHandler,
+      showSubscriptionModal,
+      hasSubscription
+    }
   }: {
     handlers: {
       handleSubSuccess?: () => void;
       handleSubFailed?: (params: IAdBreakParams) => void;
       unlockOptionsHandler: EventPromiseHandler<IUnlockOptionsEvent, typeof UnlockOptionsEventName>;
       showSubscriptionModal: ReturnType<typeof createShowSubscriptionModal>;
+      hasSubscription?: () => boolean;
     };
   }
 ) => {
@@ -31,6 +41,12 @@ export const createCommonSubscriptionHandler = (
 
   return async (params: IAdBreakParams) => {
     try {
+      const unlockOptions = await unlockOptionsHandler.getData();
+      const supportSubscription = checkIfSupportSubscription(unlockOptions, hasSubscription);
+      if (!supportSubscription) {
+        // pass to next handler
+        return false;
+      }
       let result = true;
       for (const command of commands) {
         const commandResult = await rewardsCommands.executeCommand(command as RewardsCommandType);
@@ -40,12 +56,11 @@ export const createCommonSubscriptionHandler = (
         }
       }
 
-      if (!result) {
-        handleSubFailed?.(params);
-        return false;
-      }
+      // refresh balance and gem balance cache.in case of user login, the balance and gem balance is not updated.
+      refreshBalanceCache(httpClient);
+      refreshGemBalanceCache(httpClient);
 
-      console.log('-----unlockWithSubscription result-----');
+      console.log('-----unlockWithSubscription result-----', result);
       if (result) {
         try {
           params.adBreakDone?.({
@@ -82,6 +97,7 @@ export const createCommonSubscriptionHandler = (
       handleSubFailed?.(params);
       return false;
     } finally {
+      // do not clear cache for unlockoptions
       // unlockOptionsHandler.clearCache();
     }
   };

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

@@ -84,6 +84,10 @@ export interface IUseModalFrequencyConfig {
       dailyMaxPopUps?: number;
       minInterval?: number;
     };
+    joinMember: {
+      dailyMaxPopUps?: number;
+      minInterval?: number;
+    };
   };
   loginGuide: {
     show: boolean;
@@ -146,6 +150,10 @@ export const DefaltJoliCoinUseAndCharge = {
   useJolicoin: {
     dailyMaxPopUps: 2,
     minInterval: 8 * 60 * 60 * 1000
+  },
+  joinMember: {
+    dailyMaxPopUps: 2,
+    minInterval: 8 * 60 * 60 * 1000
   }
 };