@jolibox/implement 1.1.12 → 1.1.13-beta.10

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

@@ -6,3 +6,4 @@ import './keyboard';
 import './task';
 import './login';
 import './ads';
+import './navigate';

package/dist/native/api/keyboard.d.ts

@@ -1,7 +1,7 @@
 export declare const showKeyboard: (params: {
     defaultValue?: string | undefined;
-    maxLength?: unknown;
     multiple?: boolean | undefined;
+    maxLength?: unknown;
 }) => import("@jolibox/types").StandardResponse<void>;
 export declare const updateKeyboard: (params: {
     value: string;

package/dist/native/api/navigate.d.ts

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

package/dist/native/network/create-fetch.d.ts

@@ -15,6 +15,7 @@ type PublicFetch = <T>(url: string, options?: FetchOptions) => Promise<{
 }>;
 export declare function createFetch(createMethod: 'createRequestTaskSync', operateMethod: 'operateRequestTaskSync', options?: {
     baseUrl?: string;
+    defaultHeaders?: Record<string, string>;
     type: 'public';
 }): PublicFetch;
 export declare function createFetch(createMethod: 'createRequestTaskSync', operateMethod: 'operateRequestTaskSync', options?: {

package/dist/native/ui/retention.d.ts

@@ -0,0 +1 @@
+export declare function openRetentionSchema(): Promise<boolean>;

package/implement.build.log

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

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@jolibox/implement",
   "description": "This project is Jolibox JS-SDk implement for Native && H5",
-  "version": "1.1.12",
+  "version": "1.1.13-beta.10",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@jolibox/common": "1.1.12",
-    "@jolibox/types": "1.1.12",
+    "@jolibox/common": "1.1.13-beta.10",
+    "@jolibox/types": "1.1.13-beta.10",
+    "@jolibox/native-bridge": "1.1.13-beta.10",
     "localforage": "1.10.0",
+    "@jolibox/ui": "1.0.0",
     "web-vitals": "4.2.4"
   },
   "devDependencies": {

package/src/common/ads/anti-cheating.test.ts

@@ -20,7 +20,9 @@ describe('createLeadingNotifiableDebounce', () => {
   };
 
   it('should ban initial call', async () => {
-    localStorage.clear();
+    (window as any).__joliboxLocalStorage__ = window.localStorage;
+
+    (window as any).__joliboxLocalStorage__.clear();
 
     const adsAntiCheating = new AdsAntiCheating(track, http, () => true, config);
     await new Promise((resolve) => setTimeout(resolve, 10));
@@ -32,7 +34,7 @@ describe('createLeadingNotifiableDebounce', () => {
   });
 
   it('should ban continous calling', async () => {
-    localStorage.clear();
+    (window as any).__joliboxLocalStorage__.clear();
 
     const adsAntiCheating = new AdsAntiCheating(track, http, () => true, config);
     await new Promise((resolve) => setTimeout(resolve, 100));

package/src/common/ads/anti-cheating.ts

@@ -1,5 +1,7 @@
 import type { IHttpClient } from '../http';
 import type { Track } from '../report';
+import { getOriginalLocalStorage } from '@jolibox/common';
+getOriginalLocalStorage();
 
 export type AdsDisplayPermission =
   | 'BLOCK_INITIAL'
@@ -24,6 +26,12 @@ export interface IAdsAntiCheatingConfig {
   highFreqThreshold?: number; // default 2000 (2s)
 }
 
+declare global {
+  interface Window {
+    __joliboxLocalStorage__: Storage;
+  }
+}
+
 export class AdsAntiCheating {
   private checkShouldBanInitial: ReturnType<typeof createInitialStrategy>;
   private checkShouldBanHighFreq: ReturnType<typeof createHighFreqStrategy>;
@@ -177,7 +185,7 @@ const createBanForTimeStrategy = (
     _records: [] as CallAdsHistory[],
     init() {
       try {
-        const fromStorage = JSON.parse(window.localStorage.getItem(TIMESTAMP_STORAGE_KEY) ?? '[]');
+        const fromStorage = JSON.parse(window.__joliboxLocalStorage__.getItem(TIMESTAMP_STORAGE_KEY) ?? '[]');
         if (Array.isArray(fromStorage)) {
           this._records = fromStorage;
         } else {
@@ -192,7 +200,7 @@ const createBanForTimeStrategy = (
     },
     set values(value: CallAdsHistory[]) {
       try {
-        window.localStorage.setItem(TIMESTAMP_STORAGE_KEY, JSON.stringify(value));
+        window.__joliboxLocalStorage__.setItem(TIMESTAMP_STORAGE_KEY, JSON.stringify(value));
       } catch {
         // console.error('Failed to save timestamps');
         // do nothing
@@ -205,7 +213,7 @@ const createBanForTimeStrategy = (
     _record: false,
     init() {
       try {
-        const fromStorage = JSON.parse(window.localStorage.getItem(BAN_FOR_TIME_KEY) ?? 'false');
+        const fromStorage = JSON.parse(window.__joliboxLocalStorage__.getItem(BAN_FOR_TIME_KEY) ?? 'false');
         if (typeof fromStorage === 'boolean') {
           this._record = fromStorage;
         }
@@ -228,7 +236,7 @@ const createBanForTimeStrategy = (
     },
     set value(value: boolean) {
       try {
-        window.localStorage.setItem(BAN_FOR_TIME_KEY, JSON.stringify(value));
+        window.__joliboxLocalStorage__.setItem(BAN_FOR_TIME_KEY, JSON.stringify(value));
       } catch {
         // do nothing
       }

package/src/common/ads/index.ts

@@ -377,6 +377,55 @@ export class JoliboxAdsImpl {
    * @returns IAdBreakParams
    */
   private wrapAdBreakParams = (params: IAdBreakParams): IAdBreakParams => {
+    let googleHasResponse = false;
+
+    /* hook adBreakDone to track adBreakDone event -- start */
+    const originAdBreakDone = params.adBreakDone;
+    const adBreakDone = (placementInfo: IPlacementInfo) => {
+      googleHasResponse = true;
+      this.adsActionDetection.adBreakIsShowing = false;
+      this.track('CallAdBreakDone', {
+        breakType: placementInfo.breakType,
+        breakName: placementInfo.breakName ?? '',
+        breakFormat: placementInfo.breakFormat,
+        breakStatus: placementInfo.breakStatus
+      });
+      if (originAdBreakDone) {
+        originAdBreakDone(placementInfo);
+      }
+    };
+    params.adBreakDone = adBreakDone;
+    /* hook adBreakDone to track adBreakDone event -- end */
+
+    /* hook for reward -- start */
+    if (params.type === 'reward') {
+      const originBeforeReward = params.beforeReward;
+      const wrapShowAdFn = (originShowAdFn: () => void) => () => {
+        this.track('CallShowAdFn', null);
+        originShowAdFn();
+      };
+      const beforeReward = (originShowAdFn: () => void) => {
+        googleHasResponse = true;
+        if (originBeforeReward) {
+          originBeforeReward(wrapShowAdFn(originShowAdFn));
+        }
+      };
+      params.beforeReward = beforeReward;
+
+      window.setTimeout(() => {
+        if (!googleHasResponse) {
+          this.track('CallAdBreakTimeout', { type: params.type });
+          params.adBreakDone?.({
+            breakType: params.type,
+            breakName: params.name ?? '',
+            breakFormat: 'reward',
+            breakStatus: 'timeout'
+          });
+        }
+      }, 5000); // Timeout duration in milliseconds, 5 seconds
+    }
+    /* hook for reward -- end */
+
     const isPreroll = (params: IAdBreakParams): params is IPrerollParams => {
       return params.type === 'preroll';
     };
@@ -396,6 +445,7 @@ export class JoliboxAdsImpl {
       const originAfterAd = params.afterAd;
 
       const beforeAd = () => {
+        googleHasResponse = true;
         adEventEmitter.emit('isAdShowing', true);
         this.track('CallBeforeAd', {
           type: params.type,
@@ -407,6 +457,7 @@ export class JoliboxAdsImpl {
       };
 
       const afterAd = () => {
+        googleHasResponse = true;
         adEventEmitter.emit('isAdShowing', false);
         this.track('CallAfterAd', {
           type: params.type,
@@ -529,39 +580,6 @@ export class JoliboxAdsImpl {
 
     const type = params.type;
 
-    /* hook adBreakDone to track adBreakDone event -- start */
-    const originAdBreakDone = params.adBreakDone;
-    const adBreakDone = (placementInfo: IPlacementInfo) => {
-      this.adsActionDetection.adBreakIsShowing = false;
-      this.track('CallAdBreakDone', {
-        breakType: placementInfo.breakType,
-        breakName: placementInfo.breakName ?? '',
-        breakFormat: placementInfo.breakFormat,
-        breakStatus: placementInfo.breakStatus
-      });
-      if (originAdBreakDone) {
-        originAdBreakDone(placementInfo);
-      }
-    };
-    params.adBreakDone = adBreakDone;
-    /* hook adBreakDone to track adBreakDone event -- end */
-
-    /* hook beforeAd to track beforeAd event -- start */
-    if (params.type === 'reward') {
-      const originBeforeReward = params.beforeReward;
-      const wrapShowAdFn = (originShowAdFn: () => void) => () => {
-        this.track('CallShowAdFn', null);
-        originShowAdFn();
-      };
-      const beforeReward = (originShowAdFn: () => void) => {
-        if (originBeforeReward) {
-          originBeforeReward(wrapShowAdFn(originShowAdFn));
-        }
-      };
-      params.beforeReward = beforeReward;
-    }
-    /* hook beforeAd to track beforeAd event -- end */
-
     let paramsToTrack;
     switch (type) {
       case 'preroll':

package/src/common/context/index.ts

@@ -1,7 +1,7 @@
 import { mergeArray, mergeWith } from '@jolibox/common';
 import { DeviceInfo, HostInfo, HostUserInfo, SdkInfo } from './types';
 import { Env } from '@jolibox/types';
-import { parseUrlQuery } from './url-parse';
+import { parseUrlQuery, encodeJoliSourceQuery, QueryParams } from './url-parse';
 import { getAppVersion } from '../http/xua';
 import { getDeviceId } from '@jolibox/common';
 
@@ -36,12 +36,13 @@ const env = Object.assign({}, nativeEnv?.() ?? defaultEnv);
 type MPType = 'game' | 'miniApp';
 
 const wrapContext = () => {
-  const { payloadJson, headerJson } = env.schema.length ? parseUrlQuery(env.schema) : {};
+  const { payloadJson, headerJson, signature } = env.schema.length ? parseUrlQuery(env.schema) : {};
   const defaultSessionId = `${env.deviceInfo.did}-${new Date().getTime()}`;
   const url = new URL(env.schema.length ? env.schema : window.location.href);
   const urlParams = url.searchParams;
   const defaultGameID = urlParams.get('mpId') ?? urlParams.get('appId') ?? urlParams.get('gameId') ?? '';
-  const sessionId = payloadJson?.sessionId ?? urlParams.get('sessionId') ?? defaultSessionId;
+  const sessionId =
+    env.clientSessionId ?? payloadJson?.sessionId ?? urlParams.get('sessionId') ?? defaultSessionId;
   const testAdsMode = !!(payloadJson?.testAdsMode ?? urlParams.get('testAdsMode') === 'true');
   const joliboxEnv = payloadJson?.joliboxEnv ?? urlParams.get('joliboxEnv') ?? 'production';
   const testMode = joliboxEnv === 'staging';
@@ -93,8 +94,26 @@ const wrapContext = () => {
     get webviewId(): number {
       return env.webviewId ?? -1;
     },
+    get shouldInterupt(): boolean | undefined {
+      return payloadJson?.__shouldInterupt;
+    },
+    get from(): number | undefined {
+      return payloadJson?.__from;
+    },
+    get baseApiHost(): string {
+      return testMode ? 'https://stg-api.jolibox.com' : 'https://api.jolibox.com';
+    },
     onEnvConfigChanged: (newConfig: Partial<Env>) => {
       mergeWith(env, newConfig, mergeArray);
+    },
+    encodeJoliSourceQuery: (newPayloadJson: QueryParams['payloadJson']) => {
+      if (headerJson && signature) {
+        return encodeJoliSourceQuery(
+          { ...payloadJson, ...newPayloadJson },
+          urlParams.get('joliSource') ?? ''
+        );
+      }
+      return urlParams.get('joliSource') ?? '';
     }
   };
 };

package/src/common/context/url-parse.ts

@@ -14,6 +14,12 @@ interface PayloadJson {
   joliboxEnv?: 'staging' | 'production';
   sessionId?: string;
   __mpType?: 'game' | 'miniApp';
+  __orientation?: 'HORIZONTAL' | 'VERTICAL';
+  __transparent?: boolean;
+  __entryPath?: string;
+  __showStatusBar?: boolean;
+  __shouldInterupt?: boolean;
+  __from?: number; // 从哪个小程序打开的
 }
 
 interface Signature {
@@ -21,7 +27,7 @@ interface Signature {
   payloadSig?: string;
 }
 
-interface QueryParams {
+export interface QueryParams {
   headerJson: HeaderJson;
   payloadJson: PayloadJson;
   signature: Signature;
@@ -38,6 +44,12 @@ const base64UrlDecode = <T>(input: string): T => {
   }
 };
 
+const base64UrlEncode = <T>(input: T): string => {
+  const jsonStr = JSON.stringify(input);
+  const base64 = btoa(jsonStr);
+  return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+};
+
 export const parseUrlQuery = (url: string): QueryParams => {
   try {
     const urlObj = new URL(url);
@@ -63,3 +75,14 @@ export const parseUrlQuery = (url: string): QueryParams => {
     };
   }
 };
+
+export const encodeJoliSourceQuery = (payloadJson: PayloadJson, originJoliSource: string): string => {
+  const joli_source = originJoliSource.split('.');
+  if (joli_source && joli_source.length === 3) {
+    const headerJsonStr = joli_source[0];
+    const payloadJsonStr = base64UrlEncode(payloadJson);
+    const signatureJsonStr = joli_source[2];
+    return `${headerJsonStr}.${payloadJsonStr}.${signatureJsonStr}`;
+  }
+  return originJoliSource;
+};

package/src/common/rewards/__tests__/can-use-jolicoin.test.ts

@@ -0,0 +1,94 @@
+import { IUnlockOptionType } from '../type';
+import { canUseJolicoin } from '../registers/utils';
+
+describe('canUseJolicoin', () => {
+  it('should return true when joliCoin balance is sufficient and autoDeduct is enabled', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 100 }]
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(true);
+  });
+
+  it('should return true when joliCoin balance is more than required', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 50 }]
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(true);
+  });
+
+  it('should return false when joliCoin balance is insufficient', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 150 }]
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(false);
+  });
+
+  it('should return false when autoDeduct is disabled', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 50 }]
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: false };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(false);
+  });
+
+  it('should return false when there is no JOLI_COIN option', () => {
+    const unlockOptions = [
+      {
+        type: 'ADS' as IUnlockOptionType,
+        joliCoinChoices: []
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(false);
+  });
+
+  it('should return false with empty unlockOptions', () => {
+    const unlockOptions: any[] = [];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(false);
+  });
+
+  it('should return false when joliCoin is undefined', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 50 }]
+      }
+    ];
+
+    expect(canUseJolicoin(unlockOptions, undefined)).toBe(false);
+  });
+
+  it('should return true when at least one choice is valid', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 200 }, { joliCoinQuantity: 50 }]
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(true);
+  });
+});

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

@@ -0,0 +1,33 @@
+import { UnlockOptionsEventName, unlockOptionsEmitter } from '.';
+import { IHttpClient } from '../http';
+import { RewardsHelper, RewardType } from './reward-helper';
+import { IJolicoinRewardOption } from './type';
+
+const priority = () => {
+  return (a: RewardType, b: RewardType) => {
+    if (a === 'JOLI_COIN' && b === 'ADS') return -1;
+    if (a === 'ADS' && b === 'JOLI_COIN') return 1;
+    return 0;
+  };
+};
+
+export const createRewardFetcher = (rewardsHelper: RewardsHelper) => {
+  rewardsHelper.registerRewardsFetcher(async (httpClient: IHttpClient) => {
+    const defaultRewards: RewardType[] = [];
+    const res = await httpClient.post<IJolicoinRewardOption>('/api/games/unlock-options', {});
+    if (res.code !== 'SUCCESS') {
+      return defaultRewards;
+    }
+    unlockOptionsEmitter.emit(UnlockOptionsEventName, {
+      options: res.data?.unlockOptions || [],
+      userJoliCoin: res.extra?.joliCoin || {
+        balance: 0,
+        enableAutoDeduct: false
+      }
+    });
+
+    const rewardsTypes = res.data?.unlockOptions?.map((option) => option.type) || Array.from(defaultRewards);
+    // Sort reward types with JOLI_COIN having higher priority than ADS
+    return rewardsTypes.sort(priority());
+  });
+};

package/src/common/rewards/index.ts

@@ -0,0 +1,20 @@
+import { createRewardsHelper } from './reward-helper';
+import { createRewardFetcher } from './fetch-reward';
+import { EventEmitter } from '@jolibox/common';
+import { IUnlockOption, IJoliCoin } from './type';
+
+export const rewardsHelper = createRewardsHelper();
+createRewardFetcher(rewardsHelper);
+
+export * from './registers/use-ads';
+export * from './registers/use-jolicoin';
+
+export interface IUnlockOptionsEvent {
+  options: IUnlockOption[];
+  userJoliCoin: IJoliCoin;
+}
+
+export const UnlockOptionsEventName = 'UNLOCK_OPTIONS_CHANGED' as const;
+export const unlockOptionsEmitter = new EventEmitter<{
+  [UnlockOptionsEventName]: [IUnlockOptionsEvent];
+}>();

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

@@ -0,0 +1,9 @@
+import { JoliboxAdsImpl, IRewardParams } from '../../ads';
+
+export type AdsRewardsHandler = (params: IRewardParams) => Promise<boolean>;
+export const createAdsRewardHandler = (ads: JoliboxAdsImpl): AdsRewardsHandler => {
+  return async (params: IRewardParams) => {
+    ads.adBreak(params);
+    return true;
+  };
+};

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

@@ -0,0 +1,89 @@
+import { IHttpClient } from '@/common/http';
+import { context } from '@/common/context';
+import { uuidv4 } from '@jolibox/common';
+import { canUseJolicoin } from './utils';
+import { unlockOptionsEmitter, UnlockOptionsEventName, IUnlockOptionsEvent } from '..';
+
+interface IJolicoinUnlockRes {
+  code: 'SUCCESS' | 'BALANCE_NOT_ENOUGH' | 'EPISODE_LOCK_JUMP' | 'EPISODE_UNLOCK_ALREADY';
+  message: string;
+  data: {
+    transactionId: string;
+    quantity: number;
+    balance: number;
+  };
+}
+
+export type JolicoinRewardsHandler = () => Promise<boolean>;
+export const createJolicoinRewardHandler = (
+  httpClient: IHttpClient,
+  {
+    onUnlockSuccess,
+    onUnlockFailed
+  }: {
+    onUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
+    onUnlockFailed?: () => void;
+  }
+): JolicoinRewardsHandler => {
+  let unlockOptionsPromise: Promise<IUnlockOptionsEvent> | null = null;
+  let resolveUnlockOptions: ((value: IUnlockOptionsEvent) => void) | null = null;
+  let cachedUnlockOptions: IUnlockOptionsEvent | null = null;
+
+  const createUnlockOptionsPromise = () => {
+    if (cachedUnlockOptions) {
+      unlockOptionsPromise = Promise.resolve(cachedUnlockOptions);
+      return;
+    }
+
+    unlockOptionsPromise = new Promise<IUnlockOptionsEvent>((resolve) => {
+      resolveUnlockOptions = resolve;
+    });
+  };
+
+  createUnlockOptionsPromise();
+
+  unlockOptionsEmitter.on(UnlockOptionsEventName, (options) => {
+    cachedUnlockOptions = options;
+    if (resolveUnlockOptions) {
+      resolveUnlockOptions(options);
+      resolveUnlockOptions = null;
+    }
+  });
+
+  return async () => {
+    try {
+      if (!unlockOptionsPromise) {
+        createUnlockOptionsPromise();
+      }
+      const unlockOptions = await unlockOptionsPromise!;
+      if (!canUseJolicoin(unlockOptions?.options || [], unlockOptions?.userJoliCoin)) {
+        onUnlockFailed?.();
+        return false;
+      }
+
+      const unlockWithJolicoin = await httpClient.post<IJolicoinUnlockRes>('/api/joli-coin/unlock', {
+        data: {
+          // TODO: support drama
+          type: 'GAME_REWARD',
+          reqId: `${uuidv4()}-${context.mpType}-${Date.now()}`,
+          gameInfo: {
+            gameId: context.mpId
+          }
+        }
+      });
+      if (unlockWithJolicoin.code == 'SUCCESS') {
+        onUnlockSuccess?.({
+          quantity: unlockWithJolicoin.data.quantity,
+          balance: unlockWithJolicoin.data.balance
+        });
+        return true;
+      }
+      onUnlockFailed?.();
+      return false;
+    } catch (e) {
+      console.error(`JolicoinRewardHandler error:`, e);
+      onUnlockFailed?.();
+      return false;
+    }
+  };
+};

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

@@ -0,0 +1,11 @@
+import { IJoliCoin, IUnlockOption } from '@/common/rewards/type';
+
+export const canUseJolicoin = (unlockOptions: IUnlockOption[], joliCoin?: IJoliCoin) => {
+  return unlockOptions.some(
+    (option) =>
+      option.type === 'JOLI_COIN' &&
+      option.joliCoinChoices.some(
+        (choice) => choice.joliCoinQuantity <= (joliCoin?.balance ?? 0) && !!joliCoin?.enableAutoDeduct
+      )
+  );
+};

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

@@ -0,0 +1,56 @@
+export type RewardType = 'ADS' | 'JOLI_COIN';
+
+import { context } from '../context';
+import type { AdsRewardsHandler } from './registers/use-ads';
+
+export interface RewardHandlerMap {
+  ADS: AdsRewardsHandler;
+  JOLI_COIN: (params?: unknown) => Promise<boolean>;
+}
+
+export type RewardHandler<T extends RewardType> = RewardHandlerMap[T];
+
+const isTestMode = context.testMode;
+export function createRewardsHelper() {
+  const rewardsHandlers = new Map<RewardType, RewardHandler<any>>();
+  let rewardFetcher: ((...args: any[]) => Promise<RewardType[]>) | undefined;
+
+  return {
+    registerRewardHandler<T extends RewardType>(type: T, handler: RewardHandler<T>) {
+      rewardsHandlers.set(type, handler);
+    },
+    async handleReward<T extends RewardType>(rewardsTypes: T[], ...args: Parameters<RewardHandler<T>>) {
+      const result = await rewardsTypes.reduce(async (prevPromise, type) => {
+        const prevResult = await prevPromise;
+        if (prevResult === true) return true;
+
+        isTestMode && console.log(`handleReward ${type}`);
+        const handler = rewardsHandlers.get(type);
+        const nextResult = handler ? await handler(...args) : prevResult;
+        isTestMode && console.log(`handleReward ${type} ${nextResult}`);
+        return nextResult;
+      }, Promise.resolve(false));
+
+      return result;
+    },
+    async registerRewardsFetcher<T extends RewardType>(fetcher: (...args: any[]) => Promise<T[]>) {
+      rewardFetcher = async (...args: unknown[]) => {
+        try {
+          const rewardsTypes = await fetcher(...args);
+          return rewardsTypes;
+        } catch (e) {
+          console.error(`getRewardOptions error:`, e);
+          return ['ADS'];
+        }
+      };
+    },
+    async getRewardsTypes(...args: unknown[]): Promise<RewardType[]> {
+      if (!rewardFetcher) {
+        return ['ADS'];
+      }
+      return await rewardFetcher(...args);
+    }
+  };
+}
+
+export type RewardsHelper = ReturnType<typeof createRewardsHelper>;