@jolibox/implement 1.1.11 → 1.1.13-beta.1

package/dist/native/js-bridge/subscribe.d.ts

@@ -4,5 +4,7 @@ export interface Subscribes {
     onNative: On;
     offNative: Off;
     subscribeHandler: AnyFunction;
+    subscribe: On;
+    unsubscribe: Off;
 }
 export declare function createSubscribe(jsCore: jsb.JSCore): Subscribes;

package/dist/native/js-bridge/types.d.ts

@@ -2,6 +2,7 @@ export type Listener = (...args: any[]) => any;
 export type On = <T extends string>(event: T, handler: Listener) => void;
 export type Off = <T extends string>(event: T, handler: Listener) => void;
 export type InvokeHandler = (callbackId: string | number, data: string | Record<string, unknown>) => void;
+export type Publish = (event: string, data: Record<string, unknown>, webviewId?: number, force?: boolean) => void;
 export type SubscribeHandler = (event: string, data: string | Record<string, unknown>, webviewId?: number) => void;
 export type AnyFunction = (...args: any[]) => any;
 export interface JSBridge {
@@ -11,4 +12,7 @@ export interface JSBridge {
     applyNative: jsb.service.ApplyNative;
     onNative: jsb.service.OnNative;
     offNative: jsb.service.OffNative;
+    publish: Publish;
+    subscribe: On;
+    unsubscribe: Off;
 }

package/dist/native/js-core/jolibox-js-core.d.ts

@@ -5,6 +5,11 @@ declare global {
             invoke: (invokeString: string) => void;
             onDocumentReady: (paramsstr: string) => void;
             doExit: (uuidString: string) => void;
+            publish: (params: {
+                event: string;
+                webviewIds: number[] | '*';
+                paramsString: string;
+            }) => void;
         };
         webkit?: {
             messageHandlers: {
@@ -18,7 +23,7 @@ declare global {
                 publish: {
                     postMessage: (params: {
                         event: string;
-                        webviewIds: string;
+                        webviewIds: number[] | '*';
                         paramsString: string;
                     }) => void;
                 };
@@ -39,7 +44,7 @@ declare global {
 }
 export declare const RuntimeLoader: {
     trigger(): void;
-    exit(): boolean;
+    exit(): Promise<boolean>;
     onReady(fn: () => void): void;
-    doExit(fn: () => boolean): void;
+    doExit(fn: () => Promise<boolean>): void;
 };

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.11 clean
+> @jolibox/implement@1.1.13-beta.1 clean
 > rimraf ./dist
 
 
-> @jolibox/implement@1.1.11 build:esm
+> @jolibox/implement@1.1.13-beta.1 build:esm
 > BUILD_VERSION=$(node -p "require('./package.json').version")  node esbuild.config.js --format=esm
 

package/package.json

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

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

@@ -0,0 +1,79 @@
+import { AdsAntiCheating, IAdsAntiCheatingConfig } from './anti-cheating';
+
+describe('createLeadingNotifiableDebounce', () => {
+  jest.setTimeout(3000); // increase timeout for tes
+
+  const track = jest.fn() as any;
+  const http = {
+    get: jest.fn(),
+    post: jest.fn()
+  };
+
+  const config: IAdsAntiCheatingConfig = {
+    initialThreshold: 50,
+    highFreqThreshold: 50,
+    maxAllowedAdsForTime: 2,
+    banForTimeThreshold: 500, // 500ms
+    bannedReleaseTime: 500, // 500ms
+    banForSessionThreshold: 3000, // 4s
+    maxAllowedAdsForSession: 7 // 7 ads
+  };
+
+  it('should ban initial call', async () => {
+    localStorage.clear();
+
+    const adsAntiCheating = new AdsAntiCheating(track, http, () => true, config);
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    const a = adsAntiCheating.checkAdsDisplayPermission('reward');
+    expect(a.reason).toBe('BLOCK_INITIAL');
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const b = adsAntiCheating.checkAdsDisplayPermission('reward');
+    expect(b.reason).toBe('ALLOWED');
+  });
+
+  it('should ban continous calling', async () => {
+    localStorage.clear();
+
+    const adsAntiCheating = new AdsAntiCheating(track, http, () => true, config);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const a = adsAntiCheating.checkAdsDisplayPermission('reward');
+    expect(a.reason).toBe('ALLOWED');
+
+    // wait 10 ms
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    const b = adsAntiCheating.checkAdsDisplayPermission('reward');
+    expect(b.reason).toBe('HOLDING_HIGH_FREQ');
+    expect(b.info?.count).toBe(1);
+
+    // wait another 10 ms
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    const d = adsAntiCheating.checkAdsDisplayPermission('reward');
+    expect(d.reason).toBe('HOLDING_HIGH_FREQ');
+    expect(d.info?.count).toBe(2);
+
+    // wait another 100ms to reset the high freq timer, but trigger banned for time
+    await new Promise((resolve) => setTimeout(resolve, 60)); // wait 100ms
+    const c = adsAntiCheating.checkAdsDisplayPermission('reward');
+    expect(c.reason).toBe('BANNED_FOR_TIME');
+
+    // wait another 100ms
+    await new Promise((resolve) => setTimeout(resolve, 100)); // wait 100ms
+    const e = adsAntiCheating.checkAdsDisplayPermission('reward');
+    expect(e.reason).toBe('WAITING_BANNED_RELEASE');
+    const isBannedForTime1 = window.localStorage.getItem('jolibox-sdk-ads-ban-for-time');
+    expect(isBannedForTime1).toBe('true');
+
+    // wait another 400ms to reset the banned for time timer and allow display
+    await new Promise((resolve) => setTimeout(resolve, 400)); // wait 400ms
+    const f = adsAntiCheating.checkAdsDisplayPermission('reward');
+    expect(f.reason).toBe('ALLOWED');
+
+    // 500ms
+    await new Promise((resolve) => setTimeout(resolve, 500)); // wait 500ms
+    const g = adsAntiCheating.checkAdsDisplayPermission('reward');
+    expect(g.reason).toBe('BANNED_FOR_SESSION');
+
+    const isBannedForTime = window.localStorage.getItem('jolibox-sdk-ads-ban-for-time');
+    expect(isBannedForTime).toBe('false'); // should be false after the timer resets
+  });
+});

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

@@ -4,6 +4,7 @@ import type { Track } from '../report';
 export type AdsDisplayPermission =
   | 'BLOCK_INITIAL'
   | 'BANNED_FOR_SESSION'
+  | 'HOLDING_HIGH_FREQ'
   | 'NETWORK_NOT_OK'
   | 'WAITING_BANNED_RELEASE'
   | 'BANNED_FOR_TIME'
@@ -13,35 +14,21 @@ interface CallAdsHistory {
   type: 'reward' | 'interstitial';
 }
 
-const TIMESTAMP_STORAGE_KEY = 'jolibox-sdk-ads-callbreak-timestamps';
-
-interface IAdsAntiCheatingConfig {
+export interface IAdsAntiCheatingConfig {
   maxAllowedAdsForTime?: number; // default 8
-  bannedForTimeThreshold?: number; // default 60000 (1 minute)
-  bannedReleaseTime?: number; // default 60000 (1 minute), must be >= checkingTimeThreashold
+  banForTimeThreshold?: number; // default 60000 (1 minute)
+  bannedReleaseTime?: number; // default 60000 (1 minute), must be >= checkingTimeThreshold
   initialThreshold?: number; // default 2000
   maxAllowedAdsForSession?: number; // default 200
-  bannedForSessionThreshold?: number; // default 600000 (10 minutes)
+  banForSessionThreshold?: number; // default 600000 (10 minutes)
+  highFreqThreshold?: number; // default 2000 (2s)
 }
 
 export class AdsAntiCheating {
-  private maxAllowedAdsForTime = 8;
-  private bannedForTimeThreshold = 60000;
-  private bannedReleaseTime = 60000;
-  private isBanningForTime = false;
-  private releaseBannedForTimeTimeout: number | null = null;
-
-  private maxAllowedAdsForSession = 200;
-  private bannedForSessionThreshold = 600000;
-  private isBanningForSession = false;
-
-  private initialThreshold = 2000;
-
-  private _callAdsTimestampsForTime: CallAdsHistory[] = []; // max x timestamps for time
-  private callAdsTimestampsForSession: CallAdsHistory[] = []; // max x timestamps for session
-
-  private initTimestamp = 0;
-  // private context: JoliboxSDKPipeExecutor;
+  private checkShouldBanInitial: ReturnType<typeof createInitialStrategy>;
+  private checkShouldBanHighFreq: ReturnType<typeof createHighFreqStrategy>;
+  private checkShouldBanForTime: ReturnType<typeof createBanForTimeStrategy>;
+  private checkShouldBanForSession: ReturnType<typeof createBanForSessionStrategy>;
 
   constructor(
     readonly track: Track,
@@ -49,217 +36,296 @@ export class AdsAntiCheating {
     readonly checkNetwork: () => boolean,
     config?: IAdsAntiCheatingConfig
   ) {
-    this.maxAllowedAdsForTime = config?.maxAllowedAdsForTime ?? 8;
-    this.bannedForTimeThreshold = config?.bannedForTimeThreshold ?? 60000;
-    this.bannedReleaseTime = config?.bannedReleaseTime ?? 60000;
-
-    this.maxAllowedAdsForSession = config?.maxAllowedAdsForSession ?? 200;
-    this.bannedForSessionThreshold = config?.bannedForSessionThreshold ?? 600000;
-
-    this.initialThreshold = config?.initialThreshold ?? 2000;
+    const maxAllowedAdsForTime = config?.maxAllowedAdsForTime ?? 8;
+    const banForTimeThreshold = config?.banForTimeThreshold ?? 60000;
+    const bannedReleaseTime = config?.bannedReleaseTime ?? 60000;
+
+    const maxAllowedAdsForSession = config?.maxAllowedAdsForSession ?? 200;
+    const banForSessionThreshold = config?.banForSessionThreshold ?? 600000;
+
+    const initialThreshold = config?.initialThreshold ?? 2000;
+    const highFreqThreshold = config?.highFreqThreshold ?? 2000;
+
+    this.checkShouldBanInitial = createInitialStrategy(initialThreshold);
+    this.checkShouldBanHighFreq = createHighFreqStrategy(highFreqThreshold);
+    this.checkShouldBanForTime = createBanForTimeStrategy(
+      maxAllowedAdsForTime,
+      banForTimeThreshold,
+      bannedReleaseTime
+    );
+    this.checkShouldBanForSession = createBanForSessionStrategy(
+      maxAllowedAdsForSession,
+      banForSessionThreshold
+    );
+  }
 
-    if (this.maxAllowedAdsForTime <= 1) {
-      throw new Error('maxAllowedAdsForTime must be greater than 1');
+  public checkAdsDisplayPermission: (type: 'reward' | 'interstitial') => {
+    reason: AdsDisplayPermission;
+    info?: { count: number };
+  } = (type) => {
+    if (!this.checkNetwork()) {
+      return { reason: 'NETWORK_NOT_OK' };
     }
 
-    if (this.bannedForTimeThreshold < 0) {
-      throw new Error('bannedForTimeThreshold must be greater than or equal to 0');
+    const shouldBanInitial = this.checkShouldBanInitial();
+    if (shouldBanInitial) {
+      return { reason: shouldBanInitial };
     }
 
-    if (this.bannedReleaseTime < this.bannedForTimeThreshold) {
-      throw new Error('bannedReleaseTime must be greater than or equal to bannedForTimeThreshold');
+    const shouldBanForSession = this.checkShouldBanForSession(type);
+    if (shouldBanForSession) {
+      return { reason: shouldBanForSession };
     }
 
-    if (this.initialThreshold < 0) {
-      throw new Error('initialThreshold must be greater than or equal to 0');
+    const shouldBanForHighFreq = this.checkShouldBanHighFreq(type);
+    if (shouldBanForHighFreq) {
+      return shouldBanForHighFreq;
     }
 
-    this.initCallAdsTimestampsForTime();
-    this.initTimestamp = Date.now();
-    // this.context = context;
-  }
-
-  /**
-   * Restore call ads timestamps for time from local storage
-   */
-  private initCallAdsTimestampsForTime = () => {
-    try {
-      const fromStorage = JSON.parse(window.localStorage.getItem(TIMESTAMP_STORAGE_KEY) ?? '[]');
-      if (Array.isArray(fromStorage)) {
-        this._callAdsTimestampsForTime = fromStorage;
-      } else {
-        this._callAdsTimestampsForTime = [];
-      }
-    } catch {
-      this._callAdsTimestampsForTime = [];
+    const shouldBanForTime = this.checkShouldBanForTime(type);
+    if (shouldBanForTime) {
+      return { reason: shouldBanForTime };
     }
-  };
 
-  /**
-   * Get call ads timestamps for time
-   */
-  private get callAdsTimestampsForTime() {
-    return this._callAdsTimestampsForTime;
-  }
+    return { reason: 'ALLOWED' };
+  };
 
   /**
-   * Set call ads timestamps for time, this will also save to local storage
+   * Report an ad display permission issue.
+   * Report to both event tracking system and the business backend system.
+   * @param reason
    */
-  private set callAdsTimestampsForTime(timestamps: CallAdsHistory[]) {
-    try {
-      window.localStorage.setItem(TIMESTAMP_STORAGE_KEY, JSON.stringify(timestamps));
-    } catch {
-      console.error('Failed to save timestamps');
-    }
-    this._callAdsTimestampsForTime = timestamps;
+  public report(reason: AdsDisplayPermission, count?: number) {
+    const info = count ? { reason, count } : { reason };
+    this.track('PreventAdsCheating', info);
+    this.httpClient.post('/api/base/app-event', {
+      data: {
+        eventType: 'PREVENT_ADS_CHEATING',
+        adsInfo: info
+      }
+    });
   }
+}
 
-  /**
-   * Set a timeout to release the banned for time status
-   */
-  private setReleaseBannedForTime = () => {
-    if (this.releaseBannedForTimeTimeout) {
-      window.clearTimeout(this.releaseBannedForTimeTimeout);
-      this.releaseBannedForTimeTimeout = null;
-    }
-    this.releaseBannedForTimeTimeout = window.setTimeout(() => {
-      this.isBanningForTime = false;
-      this.releaseBannedForTimeTimeout = null;
-    }, this.bannedReleaseTime);
-  };
-
-  /**
-   * Check if we should ban for initial call. By default, if user makes a call less than 2 seconds after the first call, block.
-   * @returns
-   */
-  private checkShouldBannedInitial = () => {
-    const now = Date.now();
-    const diffFromInit = now - this.initTimestamp;
-    // if initial call less than x seconds, block
-    if (diffFromInit <= this.initialThreshold) {
-      return 'BLOCK_INITIAL';
-    }
-  };
+const createBanForSessionStrategy = (maxAllowedAdsForSession: number, banForSessionThreshold: number) => {
+  let isBannedForSession = false;
+  let callAdsTimestampsForSession: CallAdsHistory[] = [];
 
   /**
    * Check if we should ban this user for the whole session. By default, if user makes more than 200 calls in 10 minutes, ban for the session.
    * @param type
    * @returns
    */
-  private checkShouldBannedForSession = (type: 'reward' | 'interstitial') => {
-    if (this.isBanningForSession) {
+  const check = (type: 'reward' | 'interstitial') => {
+    if (isBannedForSession) {
       return 'BANNED_FOR_SESSION';
     }
 
     const now = Date.now();
 
     // keep track of call timestamps
-    this.callAdsTimestampsForSession = this.callAdsTimestampsForSession.concat({
+    callAdsTimestampsForSession = callAdsTimestampsForSession.concat({
       timestamp: now,
       type
     });
 
     // if only 1 call, no need to check
-    if (this.callAdsTimestampsForSession.length === 1) {
+    if (callAdsTimestampsForSession.length === 1) {
       return undefined;
     }
 
     // keep last x timestamps
-    if (this.callAdsTimestampsForSession.length > this.maxAllowedAdsForSession) {
-      this.callAdsTimestampsForSession = this.callAdsTimestampsForSession.slice(
-        -this.maxAllowedAdsForSession
-      );
+    if (callAdsTimestampsForSession.length > maxAllowedAdsForSession) {
+      callAdsTimestampsForSession = callAdsTimestampsForSession.slice(-maxAllowedAdsForSession);
     }
 
     // if less than x seconds, ban for session
-    if (this.callAdsTimestampsForSession.length === this.maxAllowedAdsForSession) {
-      const diffFromFirst = now - this.callAdsTimestampsForSession[0].timestamp;
-      if (diffFromFirst <= this.bannedForSessionThreshold) {
-        this.isBanningForSession = true;
+    if (callAdsTimestampsForSession.length === maxAllowedAdsForSession) {
+      const diffFromFirst = now - callAdsTimestampsForSession[0].timestamp;
+      if (diffFromFirst <= banForSessionThreshold) {
+        isBannedForSession = true;
         return 'BANNED_FOR_SESSION';
       }
     }
   };
 
+  return check;
+};
+
+const createBanForTimeStrategy = (
+  maxAllowedAdsForTime: number,
+  banForTimeThreshold: number,
+  bannedReleaseTime: number
+) => {
+  let releaseBannedForTimeTimeout: number | null = null;
+
+  const setReleaseBannedForTime = (timeout: number) => {
+    if (releaseBannedForTimeTimeout) {
+      window.clearTimeout(releaseBannedForTimeTimeout);
+      releaseBannedForTimeTimeout = null;
+    }
+    releaseBannedForTimeTimeout = window.setTimeout(() => {
+      isBannedForTime.value = false;
+      releaseBannedForTimeTimeout = null;
+    }, timeout);
+  };
+
+  const TIMESTAMP_STORAGE_KEY = 'jolibox-sdk-ads-callbreak-timestamps';
+  const BAN_FOR_TIME_KEY = 'jolibox-sdk-ads-ban-for-time';
+
+  const callAdsHistory = {
+    _records: [] as CallAdsHistory[],
+    init() {
+      try {
+        const fromStorage = JSON.parse(window.localStorage.getItem(TIMESTAMP_STORAGE_KEY) ?? '[]');
+        if (Array.isArray(fromStorage)) {
+          this._records = fromStorage;
+        } else {
+          this._records = [];
+        }
+      } catch {
+        this._records = [];
+      }
+    },
+    get values() {
+      return this._records;
+    },
+    set values(value: CallAdsHistory[]) {
+      try {
+        window.localStorage.setItem(TIMESTAMP_STORAGE_KEY, JSON.stringify(value));
+      } catch {
+        // console.error('Failed to save timestamps');
+        // do nothing
+      }
+      this._records = value;
+    }
+  };
+
+  const isBannedForTime = {
+    _record: false,
+    init() {
+      try {
+        const fromStorage = JSON.parse(window.localStorage.getItem(BAN_FOR_TIME_KEY) ?? 'false');
+        if (typeof fromStorage === 'boolean') {
+          this._record = fromStorage;
+        }
+      } catch {
+        this._record = false; // default value
+      }
+      if (this._record) {
+        const lastCall: CallAdsHistory | undefined = callAdsHistory.values[callAdsHistory.values.length - 1];
+        const timeDiff = lastCall ? Date.now() - lastCall.timestamp : bannedReleaseTime;
+        if (timeDiff <= bannedReleaseTime && timeDiff > 0) {
+          // within the banned release time window
+          setReleaseBannedForTime(timeDiff);
+        } else {
+          this._record = false;
+        }
+      }
+    },
+    get value() {
+      return this._record;
+    },
+    set value(value: boolean) {
+      try {
+        window.localStorage.setItem(BAN_FOR_TIME_KEY, JSON.stringify(value));
+      } catch {
+        // do nothing
+      }
+      this._record = value;
+    }
+  };
+
+  callAdsHistory.init();
+  isBannedForTime.init();
+
   /**
    * Check if we should ban this user for a period of time. By default, if user makes more than 8 calls in 1 minute, ban for 1 minute.
    * After 1 minute, user can make calls again.
    * @param type
    * @returns
    */
-  private checkShouldBannedForTime = (type: 'reward' | 'interstitial') => {
-    if (this.isBanningForTime) {
+  const check = (type: 'reward' | 'interstitial') => {
+    if (isBannedForTime.value) {
       return 'WAITING_BANNED_RELEASE';
     }
 
     const now = Date.now();
 
     // keep track of call timestamps
-    this.callAdsTimestampsForTime = this.callAdsTimestampsForTime.concat({
+    callAdsHistory.values = callAdsHistory.values.concat({
       timestamp: now,
       type
     });
 
     // if only 1 call, no need to check
-    if (this.callAdsTimestampsForTime.length === 1) {
+    if (callAdsHistory.values.length === 1) {
       return undefined;
     }
 
     // keep last x timestamps
-    if (this.callAdsTimestampsForTime.length > this.maxAllowedAdsForTime) {
-      this.callAdsTimestampsForTime = this.callAdsTimestampsForTime.slice(-this.maxAllowedAdsForTime);
+    if (callAdsHistory.values.length > maxAllowedAdsForTime) {
+      callAdsHistory.values = callAdsHistory.values.slice(-maxAllowedAdsForTime);
     }
 
     // if less than x seconds, ban for time
-    if (this.callAdsTimestampsForTime.length === this.maxAllowedAdsForTime) {
-      const diffFromFirst = now - this.callAdsTimestampsForTime[0].timestamp;
-      if (diffFromFirst <= this.bannedForTimeThreshold) {
-        this.isBanningForTime = true;
-        this.setReleaseBannedForTime();
+    if (callAdsHistory.values.length === maxAllowedAdsForTime) {
+      const diffFromFirst = now - callAdsHistory.values[0].timestamp;
+      if (diffFromFirst <= banForTimeThreshold) {
+        isBannedForTime.value = true;
+        setReleaseBannedForTime(bannedReleaseTime);
         return 'BANNED_FOR_TIME';
       }
     }
   };
+  return check;
+};
 
-  public checkAdsDisplayPermission: (type: 'reward' | 'interstitial') => AdsDisplayPermission = (type) => {
-    if (!this.checkNetwork()) {
-      return 'NETWORK_NOT_OK';
-    }
-
-    const shouldBannedInitial = this.checkShouldBannedInitial();
-    if (shouldBannedInitial) {
-      return shouldBannedInitial;
-    }
-
-    const shouldBannedForSession = this.checkShouldBannedForSession(type);
-    if (shouldBannedForSession) {
-      return shouldBannedForSession;
-    }
+const createInitialStrategy = (initialThreshold: number) => {
+  const initTimestamp = Date.now();
 
-    const shouldBannedForTime = this.checkShouldBannedForTime(type);
-    if (shouldBannedForTime) {
-      return shouldBannedForTime;
+  /**
+   * Check if we should ban for initial call. By default, if user makes a call less than 2 seconds after the first call, block.
+   * @returns
+   */
+  const check = () => {
+    const now = Date.now();
+    const diffFromInit = now - initTimestamp;
+    // if initial call less than x seconds, block
+    if (diffFromInit <= initialThreshold) {
+      return 'BLOCK_INITIAL';
     }
-
-    return 'ALLOWED';
   };
+  return check;
+};
+
+const createHighFreqStrategy = (highFreqThreshold = 2000) => {
+  let highFreqCounter = 0;
+  let highFreqTimer: number | null = null;
 
   /**
-   * Report an ad display permission issue.
-   * Report to both event tracking system and the business backend system.
-   * @param reason
+   * Check if we should ban for high frequency calling. If user makes a call more than 1 times in x seconds, block.
+   * This only works for reward ads.
+   *
+   * @param type
+   * @returns
    */
-  public report(reason: AdsDisplayPermission) {
-    this.track('PreventAdsCheating', {
-      reason
-    });
-    this.httpClient.post('/api/base/app-event', {
-      data: {
-        eventType: 'PREVENT_ADS_CHEATING',
-        adsInfo: {
-          reason
-        }
+  const check = (type: 'reward' | 'interstitial') => {
+    if (type === 'reward') {
+      if (highFreqTimer) {
+        highFreqCounter += 1;
+        return { reason: 'HOLDING_HIGH_FREQ' as const, info: { count: highFreqCounter } };
+      } else {
+        highFreqTimer = window.setTimeout(() => {
+          if (highFreqTimer) {
+            window.clearTimeout(highFreqTimer);
+            highFreqTimer = 0;
+            highFreqCounter = 0;
+          }
+        }, highFreqThreshold);
       }
-    });
-  }
-}
+    }
+  };
+
+  return check;
+};