@jolibox/implement 1.1.11-beta.1 → 1.1.11-beta.10

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

@@ -1,6 +1,10 @@
+import type { IHttpClient } from '../http';
+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'
@@ -10,233 +14,318 @@ 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(
-    // context: JoliboxSDKPipeExecutor,
+    readonly track: Track,
+    readonly httpClient: IHttpClient,
     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 createInitialStrategy = (initialThreshold: number) => {
+  const initTimestamp = Date.now();
 
-    const shouldBannedInitial = this.checkShouldBannedInitial();
-    if (shouldBannedInitial) {
-      return shouldBannedInitial;
+  /**
+   * 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 check;
+};
 
-    const shouldBannedForSession = this.checkShouldBannedForSession(type);
-    if (shouldBannedForSession) {
-      return shouldBannedForSession;
-    }
+const createHighFreqStrategy = (highFreqThreshold = 2000) => {
+  let highFreqCounter = 0;
+  let highFreqTimer: number | null = null;
 
-    const shouldBannedForTime = this.checkShouldBannedForTime(type);
-    if (shouldBannedForTime) {
-      return shouldBannedForTime;
+  /**
+   * 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
+   */
+  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 'ALLOWED';
   };
-}
+
+  return check;
+};

package/src/common/ads/index.ts

@@ -1,9 +1,10 @@
 import { AdsActionDetection } from './ads-action-detection';
 import { AdsAntiCheating } from './anti-cheating';
-import { Track } from '../report';
 import { context } from '../context';
 import { ChannelPolicy } from './channel-policy';
 import { EventEmitter } from '@jolibox/common';
+import type { Track } from '../report';
+import type { IHttpClient } from '../http';
 
 declare global {
   interface Window {
@@ -254,10 +255,6 @@ interface IJoliboxAdsResponse {
   };
 }
 
-interface HttpClient {
-  get<T>(url: string, options?: { query?: Record<string, string> }): Promise<T>;
-}
-
 export const adEventEmitter = new EventEmitter<{
   isAdShowing: [boolean];
 }>();
@@ -278,8 +275,8 @@ export class JoliboxAdsImpl {
   /**
    * Internal constructor, should not be called directly
    */
-  constructor(readonly track: Track, readonly httpClient: HttpClient, readonly checkNetwork: () => boolean) {
-    this.antiCheating = new AdsAntiCheating(checkNetwork);
+  constructor(readonly track: Track, readonly httpClient: IHttpClient, readonly checkNetwork: () => boolean) {
+    this.antiCheating = new AdsAntiCheating(track, httpClient, checkNetwork);
     this.adsActionDetection = new AdsActionDetection(this.track);
     this.channelPolicy = new ChannelPolicy(httpClient);
   }
@@ -400,7 +397,10 @@ export class JoliboxAdsImpl {
 
       const beforeAd = () => {
         adEventEmitter.emit('isAdShowing', true);
-        this.track('CallBeforeAd', {});
+        this.track('CallBeforeAd', {
+          type: params.type,
+          name: params.name ?? ''
+        });
         if (originBeforeAd) {
           originBeforeAd();
         }
@@ -408,7 +408,10 @@ export class JoliboxAdsImpl {
 
       const afterAd = () => {
         adEventEmitter.emit('isAdShowing', false);
-        this.track('CallAfterAd', {});
+        this.track('CallAfterAd', {
+          type: params.type,
+          name: params.name ?? ''
+        });
         if (originAfterAd) {
           originAfterAd();
         }
@@ -478,36 +481,46 @@ export class JoliboxAdsImpl {
       }
     }
 
-    const adsDisplayPermission = this.antiCheating.checkAdsDisplayPermission(
+    const { reason, info } = this.antiCheating.checkAdsDisplayPermission(
       params.type === 'reward' ? 'reward' : 'interstitial'
     );
 
-    switch (adsDisplayPermission) {
+    switch (reason) {
       case 'NETWORK_NOT_OK':
       case 'BANNED_FOR_SESSION':
-        console.warn('Ads not allowed', adsDisplayPermission);
+        // console.warn('Ads not allowed', reason);
         params.adBreakDone?.({
           breakType: params.type,
-          breakName: adsDisplayPermission,
+          breakName: reason,
           breakFormat: params.type === 'reward' ? 'reward' : 'interstitial',
           breakStatus: 'noAdPreloaded'
         });
-        this.track('PreventAdsCheating', {
-          reason: adsDisplayPermission
-        });
+        this.antiCheating.report(reason);
         return;
       case 'BLOCK_INITIAL':
       case 'BANNED_FOR_TIME':
       case 'WAITING_BANNED_RELEASE':
-        console.warn('Ads not allowed', adsDisplayPermission);
+        // console.warn('Ads not allowed', adsDisplayPermission);
         params.adBreakDone?.({
           breakType: params.type,
           breakFormat: params.type === 'reward' ? 'reward' : 'interstitial',
-          breakStatus: 'viewed' // TODO: need to confirm
+          breakStatus: 'frequencyCapped'
         });
-        this.track('PreventAdsCheating', {
-          reason: adsDisplayPermission
+        this.antiCheating.report(reason);
+        return;
+      case 'HOLDING_HIGH_FREQ':
+        // follow google's style to forbid high freq request
+        params.adBreakDone?.({
+          breakFormat: params.type === 'reward' ? 'reward' : 'interstitial',
+          breakName: '',
+          breakStatus: (info?.count ?? 0) > 6 ? 'other' : 'frequencyCapped',
+          breakType: params.type
         });
+        // every 3 hit, report to anti-cheating system
+        // if a user click 1 time every 1 second, it will cause 20 reports for 1 minute
+        if (info?.count && info.count !== 0 && info.count % 3 === 0) {
+          this.antiCheating.report(reason, info?.count);
+        }
         return;
       default:
         // allowed

package/src/common/context/index.ts

@@ -105,11 +105,10 @@ const wrapContext = () => {
     },
     encodeJoliSourceQuery: (newPayloadJson: QueryParams['payloadJson']) => {
       if (headerJson && signature) {
-        return encodeJoliSourceQuery({
-          headerJson,
-          payloadJson: { ...payloadJson, ...newPayloadJson },
-          signature
-        });
+        return encodeJoliSourceQuery(
+          { ...payloadJson, ...newPayloadJson },
+          urlParams.get('joliSource') ?? ''
+        );
       }
       return urlParams.get('joliSource') ?? '';
     }