@jolibox/implement 1.1.11-beta.3 → 1.1.11-beta.4

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;
+};

package/src/common/ads/index.ts

@@ -481,32 +481,42 @@ 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.antiCheating.report(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: 'frequencyCapped'
         });
-        this.antiCheating.report(adsDisplayPermission);
+        this.antiCheating.report(reason);
+        return;
+      case 'HOLDING_HIGH_FREQ':
+        params.adBreakDone?.({
+          breakType: params.type,
+          breakFormat: params.type === 'reward' ? 'reward' : 'interstitial',
+          breakStatus: 'frequencyCapped'
+        });
+        if ((info?.count ?? 0) === 3) {
+          this.antiCheating.report(reason, info?.count);
+        }
         return;
       default:
         // allowed