prebid.js 9.5.0 → 9.7.0

package/modules/uid2IdSystem_shared.js

@@ -7,12 +7,22 @@ function isValidIdentity(identity) {
   return !!(typeof identity === 'object' && identity !== null && identity.advertising_token && identity.identity_expires && identity.refresh_from && identity.refresh_token && identity.refresh_expires);
 }
 
+// Helper function to prepend message
+function prependMessage(message) {
+  return `UID2 shared library - ${message}`;
+}
+
+// Wrapper function for logInfo
+function logInfoWrapper(logInfo, ...args) {
+  logInfo(prependMessage(args[0]), ...args.slice(1));
+}
+
 // This is extracted from an in-progress API client. Once it's available via NPM, this class should be replaced with the NPM package.
 export class Uid2ApiClient {
   constructor(opts, clientId, logInfo, logWarn) {
     this._baseUrl = opts.baseUrl;
     this._clientVersion = clientId;
-    this._logInfo = logInfo;
+    this._logInfo = (...args) => logInfoWrapper(logInfo, ...args);
     this._logWarn = logWarn;
   }
 
@@ -35,7 +45,7 @@ export class Uid2ApiClient {
     if (this.isValidRefreshResponse(response)) {
       if (response.status === 'success') { return { status: response.status, identity: response.body }; }
       return response;
-    } else { return `Response didn't contain a valid status`; }
+    } else { return prependMessage(`Response didn't contain a valid status`); }
   }
   callRefreshApi(refreshDetails) {
     const url = this._baseUrl + '/v2/token/refresh';
@@ -53,7 +63,7 @@ export class Uid2ApiClient {
             this._logInfo('No response decryption key available, assuming unencrypted JSON');
             const response = JSON.parse(responseText);
             const result = this.ResponseToRefreshResult(response);
-            if (typeof result === 'string') { rejectPromise(result); } else { resolvePromise(result); }
+            if (typeof result === 'string') { rejectPromise(prependMessage(result)); } else { resolvePromise(result); }
           } else {
             this._logInfo('Decrypting refresh API response');
             const encodeResp = this.createArrayBuffer(atob(responseText));
@@ -69,12 +79,12 @@ export class Uid2ApiClient {
                 this._logInfo('Decrypted to:', decryptedResponse);
                 const response = JSON.parse(decryptedResponse);
                 const result = this.ResponseToRefreshResult(response);
-                if (typeof result === 'string') { rejectPromise(result); } else { resolvePromise(result); }
-              }, (reason) => this._logWarn(`Call to UID2 API failed`, reason));
-            }, (reason) => this._logWarn(`Call to UID2 API failed`, reason));
+                if (typeof result === 'string') { rejectPromise(prependMessage(result)); } else { resolvePromise(result); }
+              }, (reason) => this._logWarn(prependMessage(`Call to UID2 API failed`), reason));
+            }, (reason) => this._logWarn(prependMessage(`Call to UID2 API failed`), reason));
           }
         } catch (_err) {
-          rejectPromise(responseText);
+          rejectPromise(prependMessage(responseText));
         }
       },
       error: (error, xhr) => {
@@ -82,9 +92,9 @@ export class Uid2ApiClient {
           this._logInfo('Error status, assuming unencrypted JSON');
           const response = JSON.parse(xhr.responseText);
           const result = this.ResponseToRefreshResult(response);
-          if (typeof result === 'string') { rejectPromise(result); } else { resolvePromise(result); }
+          if (typeof result === 'string') { rejectPromise(prependMessage(result)); } else { resolvePromise(result); }
         } catch (_e) {
-          rejectPromise(error)
+          rejectPromise(prependMessage(error));
         }
       }
     }, refreshDetails.refresh_token, { method: 'POST',
@@ -99,7 +109,7 @@ export class Uid2StorageManager {
     this._storage = storage;
     this._preferLocalStorage = preferLocalStorage;
     this._storageName = storageName;
-    this._logInfo = logInfo;
+    this._logInfo = (...args) => logInfoWrapper(logInfo, ...args);
   }
   readCookie(cookieName) {
     return this._storage.cookiesAreEnabled() ? this._storage.getCookie(cookieName) : null;
@@ -392,7 +402,7 @@ if (FEATURES.UID2_CSTG) {
       this._baseUrl = opts.baseUrl;
       this._serverPublicKey = opts.cstg.serverPublicKey;
       this._subscriptionId = opts.cstg.subscriptionId;
-      this._logInfo = logInfo;
+      this._logInfo = (...args) => logInfoWrapper(logInfo, ...args);
       this._logWarn = logWarn;
     }
 
@@ -512,11 +522,11 @@ if (FEATURES.UID2_CSTG) {
                 // A 200 should always be a success response.
                 // Something has gone wrong.
                 rejectPromise(
-                  `API error: Response body was invalid for HTTP status 200: ${decryptedResponse}`
+                  prependMessage(`API error: Response body was invalid for HTTP status 200: ${decryptedResponse}`)
                 );
               }
             } catch (err) {
-              rejectPromise(err);
+              rejectPromise(prependMessage(err));
             }
           },
           error: (error, xhr) => {
@@ -524,32 +534,32 @@ if (FEATURES.UID2_CSTG) {
               if (xhr.status === 400) {
                 const response = JSON.parse(xhr.responseText);
                 if (this.isCstgApiClientErrorResponse(response)) {
-                  rejectPromise(`Client error: ${response.message}`);
+                  rejectPromise(prependMessage(`Client error: ${response.message}`));
                 } else {
                   // A 400 should always be a client error.
                   // Something has gone wrong.
                   rejectPromise(
-                    `API error: Response body was invalid for HTTP status 400: ${xhr.responseText}`
+                    prependMessage(`UID2 API error: Response body was invalid for HTTP status 400: ${xhr.responseText}`)
                   );
                 }
               } else if (xhr.status === 403) {
                 const response = JSON.parse(xhr.responseText);
                 if (this.isCstgApiForbiddenResponse(xhr)) {
-                  rejectPromise(`Forbidden: ${response.message}`);
+                  rejectPromise(prependMessage(`Forbidden: ${response.message}`));
                 } else {
                   // A 403 should always be a forbidden response.
                   // Something has gone wrong.
                   rejectPromise(
-                    `API error: Response body was invalid for HTTP status 403: ${xhr.responseText}`
+                    prependMessage(`UID2 API error: Response body was invalid for HTTP status 403: ${xhr.responseText}`)
                   );
                 }
               } else {
                 rejectPromise(
-                  `API error: Unexpected HTTP status ${xhr.status}: ${error}`
+                  prependMessage(`UID2 API error: Unexpected HTTP status ${xhr.status}: ${error}`)
                 );
               }
             } catch (_e) {
-              rejectPromise(error);
+              rejectPromise(prependMessage(error));
             }
           },
         },
@@ -678,43 +688,45 @@ if (FEATURES.UID2_CSTG) {
 }
 
 export function Uid2GetId(config, prebidStorageManager, _logInfo, _logWarn) {
+  const logInfo = (...args) => logInfoWrapper(_logInfo, ...args);
+
   let suppliedToken = null;
   const preferLocalStorage = (config.storage !== 'cookie');
-  const storageManager = new Uid2StorageManager(prebidStorageManager, preferLocalStorage, config.internalStorage, _logInfo);
-  _logInfo(`Module is using ${preferLocalStorage ? 'local storage' : 'cookies'} for internal storage.`);
+  const storageManager = new Uid2StorageManager(prebidStorageManager, preferLocalStorage, config.internalStorage, logInfo);
+  logInfo(`Module is using ${preferLocalStorage ? 'local storage' : 'cookies'} for internal storage.`);
 
   const isCstgEnabled =
   clientSideTokenGenerator &&
   clientSideTokenGenerator.isCSTGOptionsValid(config.cstg, _logWarn);
   if (isCstgEnabled) {
-    _logInfo(`Module is using client-side token generation.`);
+    logInfo(`Module is using client-side token generation.`);
     // Ignores config.paramToken and config.serverCookieName if any is provided
     suppliedToken = null;
   } else if (config.paramToken) {
     suppliedToken = config.paramToken;
-    _logInfo('Read token from params', suppliedToken);
+    logInfo('Read token from params', suppliedToken);
   } else if (config.serverCookieName) {
     suppliedToken = storageManager.readProvidedCookie(config.serverCookieName);
-    _logInfo('Read token from server-supplied cookie', suppliedToken);
+    logInfo('Read token from server-supplied cookie', suppliedToken);
   }
   let storedTokens = storageManager.getStoredValueWithFallback();
-  _logInfo('Loaded module-stored tokens:', storedTokens);
+  logInfo('Loaded module-stored tokens:', storedTokens);
 
   if (storedTokens && typeof storedTokens === 'string') {
     // Stored value is a plain token - if no token is supplied, just use the stored value.
 
     if (!suppliedToken && !isCstgEnabled) {
-      _logInfo('Returning legacy cookie value.');
+      logInfo('Returning legacy cookie value.');
       return { id: storedTokens };
     }
     // Otherwise, ignore the legacy value - it should get over-written later anyway.
-    _logInfo('Discarding superseded legacy cookie.');
+    logInfo('Discarding superseded legacy cookie.');
     storedTokens = null;
   }
 
   if (suppliedToken && storedTokens) {
     if (storedTokens.originalToken?.advertising_token !== suppliedToken.advertising_token) {
-      _logInfo('Server supplied new token - ignoring stored value.', storedTokens.originalToken?.advertising_token, suppliedToken.advertising_token);
+      logInfo('Server supplied new token - ignoring stored value.', storedTokens.originalToken?.advertising_token, suppliedToken.advertising_token);
       // Stored token wasn't originally sourced from the provided token - ignore the stored value. A new user has logged in?
       storedTokens = null;
     }
@@ -723,16 +735,16 @@ export function Uid2GetId(config, prebidStorageManager, _logInfo, _logWarn) {
   if (FEATURES.UID2_CSTG && isCstgEnabled) {
     const cstgIdentity = clientSideTokenGenerator.getValidIdentity(config.cstg, _logWarn);
     if (cstgIdentity) {
-      if (storedTokens && clientSideTokenGenerator.isStoredTokenInvalid(cstgIdentity, storedTokens, _logInfo, _logWarn)) {
+      if (storedTokens && clientSideTokenGenerator.isStoredTokenInvalid(cstgIdentity, storedTokens, logInfo, _logWarn)) {
         storedTokens = null;
       }
 
       if (!storedTokens || Date.now() > storedTokens.latestToken.refresh_expires) {
-        const promise = clientSideTokenGenerator.generateTokenAndStore(config.apiBaseUrl, config.cstg, cstgIdentity, storageManager, _logInfo, _logWarn);
-        _logInfo('Generate token using CSTG');
+        const promise = clientSideTokenGenerator.generateTokenAndStore(config.apiBaseUrl, config.cstg, cstgIdentity, storageManager, logInfo, _logWarn);
+        logInfo('Generate token using CSTG');
         return { callback: (cb) => {
           promise.then((result) => {
-            _logInfo('Token generation responded, passing the new token on.', result);
+            logInfo('Token generation responded, passing the new token on.', result);
             cb(result);
           });
         } };
@@ -742,25 +754,25 @@ export function Uid2GetId(config, prebidStorageManager, _logInfo, _logWarn) {
 
   const useSuppliedToken = !(storedTokens?.latestToken) || (suppliedToken && suppliedToken.identity_expires > storedTokens.latestToken.identity_expires);
   const newestAvailableToken = useSuppliedToken ? suppliedToken : storedTokens.latestToken;
-  _logInfo('UID2 module selected latest token', useSuppliedToken, newestAvailableToken);
+  logInfo('UID2 module selected latest token', useSuppliedToken, newestAvailableToken);
   if ((!newestAvailableToken || Date.now() > newestAvailableToken.refresh_expires)) {
-    _logInfo('Newest available token is expired and not refreshable.');
+    logInfo('Newest available token is expired and not refreshable.');
     return { id: null };
   }
   if (Date.now() > newestAvailableToken.identity_expires) {
-    const promise = refreshTokenAndStore(config.apiBaseUrl, newestAvailableToken, config.clientId, storageManager, _logInfo, _logWarn);
-    _logInfo('Token is expired but can be refreshed, attempting refresh.');
+    const promise = refreshTokenAndStore(config.apiBaseUrl, newestAvailableToken, config.clientId, storageManager, logInfo, _logWarn);
+    logInfo('Token is expired but can be refreshed, attempting refresh.');
     return { callback: (cb) => {
       promise.then((result) => {
-        _logInfo('Refresh reponded, passing the updated token on.', result);
+        logInfo('Refresh reponded, passing the updated token on.', result);
         cb(result);
       });
     } };
   }
   // If should refresh (but don't need to), refresh in the background.
   if (Date.now() > newestAvailableToken.refresh_from) {
-    _logInfo(`Refreshing token in background with low priority.`);
-    refreshTokenAndStore(config.apiBaseUrl, newestAvailableToken, config.clientId, storageManager, _logInfo, _logWarn);
+    logInfo(`Refreshing token in background with low priority.`);
+    refreshTokenAndStore(config.apiBaseUrl, newestAvailableToken, config.clientId, storageManager, logInfo, _logWarn);
   }
   const tokens = {
     originalToken: suppliedToken ?? storedTokens?.originalToken,

package/modules/viantOrtbBidAdapter.js

@@ -5,7 +5,7 @@ import {ortbConverter} from '../libraries/ortbConverter/converter.js'
 import {deepAccess, getBidIdParameter, logError} from '../src/utils.js';
 
 const BIDDER_CODE = 'viant';
-const ENDPOINT = 'https://bidders-us-east-1.adelphic.net/d/rtb/v25/prebid/bidder'
+const ENDPOINT = 'https://bidders-us.adelphic.net/d/rtb/v25/prebid/bidder'
 const ADAPTER_VERSION = '2.0.0';
 
 const DEFAULT_BID_TTL = 300;

package/modules/wurflRtdProvider.js

@@ -0,0 +1,213 @@
+import { submodule } from '../src/hook.js';
+import { fetch, sendBeacon } from '../src/ajax.js';
+import { loadExternalScript } from '../src/adloader.js';
+import {
+  mergeDeep,
+  prefixLog,
+} from '../src/utils.js';
+
+// Constants
+const REAL_TIME_MODULE = 'realTimeData';
+const MODULE_NAME = 'wurfl';
+
+// WURFL_JS_HOST is the host for the WURFL service endpoints
+const WURFL_JS_HOST = 'https://prebid.wurflcloud.com';
+// WURFL_JS_ENDPOINT_PATH is the path for the WURFL.js endpoint used to load WURFL data
+const WURFL_JS_ENDPOINT_PATH = '/wurfl.js';
+// STATS_ENDPOINT_PATH is the path for the stats endpoint used to send analytics data
+const STATS_ENDPOINT_PATH = '/v1/prebid/stats';
+
+const logger = prefixLog('[WURFL RTD Submodule]');
+
+// enrichedBidders holds a list of prebid bidder names, of bidders which have been
+// injected with WURFL data
+const enrichedBidders = new Set();
+
+/**
+ * init initializes the WURFL RTD submodule
+ * @param {Object} config Configuration for WURFL RTD submodule
+ * @param {Object} userConsent User consent data
+ */
+const init = (config, userConsent) => {
+  logger.logMessage('initialized');
+  return true;
+}
+
+/**
+ * getBidRequestData enriches the OpenRTB 2.0 device data with WURFL data
+ * @param {Object} reqBidsConfigObj Bid request configuration object
+ * @param {Function} callback Called on completion
+ * @param {Object} config Configuration for WURFL RTD submodule
+ * @param {Object} userConsent User consent data
+ */
+const getBidRequestData = (reqBidsConfigObj, callback, config, userConsent) => {
+  const altHost = config.params?.altHost ?? null;
+  const isDebug = config.params?.debug ?? false;
+
+  const bidders = new Set();
+  reqBidsConfigObj.adUnits.forEach(adUnit => {
+    adUnit.bids.forEach(bid => {
+      bidders.add(bid.bidder);
+    });
+  });
+
+  let host = WURFL_JS_HOST;
+  if (altHost) {
+    host = altHost;
+  }
+
+  const url = new URL(host);
+  url.pathname = WURFL_JS_ENDPOINT_PATH;
+
+  if (isDebug) {
+    url.searchParams.set('debug', 'true')
+  }
+
+  url.searchParams.set('mode', 'prebid')
+  logger.logMessage('url', url.toString());
+
+  try {
+    loadExternalScript(url.toString(), MODULE_NAME, () => {
+      logger.logMessage('script injected');
+      window.WURFLPromises.complete.then((res) => {
+        logger.logMessage('received data', res);
+        if (!res.wurfl_pbjs) {
+          logger.logError('invalid WURFL.js for Prebid response');
+        } else {
+          enrichBidderRequests(reqBidsConfigObj, bidders, res);
+        }
+        callback();
+      });
+    });
+  } catch (err) {
+    logger.logError(err);
+    callback();
+  }
+}
+
+/**
+ * enrichBidderRequests enriches the OpenRTB 2.0 device data with WURFL data for Business Edition
+ * @param {Object} reqBidsConfigObj Bid request configuration object
+ * @param {Array} bidders List of bidders
+ * @param {Object} wjsResponse WURFL.js response
+ */
+function enrichBidderRequests(reqBidsConfigObj, bidders, wjsResponse) {
+  const authBidders = wjsResponse.wurfl_pbjs?.authorized_bidders ?? {};
+  const caps = wjsResponse.wurfl_pbjs?.caps ?? [];
+
+  bidders.forEach((bidderCode) => {
+    if (bidderCode in authBidders) {
+      // inject WURFL data
+      enrichedBidders.add(bidderCode);
+      const data = bidderData(wjsResponse.WURFL, caps, authBidders[bidderCode]);
+      logger.logMessage(`injecting data for ${bidderCode}: `, data);
+      enrichBidderRequest(reqBidsConfigObj, bidderCode, data);
+      return;
+    }
+    // inject WURFL low entropy data
+    const data = lowEntropyData(wjsResponse.WURFL, wjsResponse.wurfl_pbjs?.low_entropy_caps);
+    logger.logMessage(`injecting low entropy data for ${bidderCode}: `, data);
+    enrichBidderRequest(reqBidsConfigObj, bidderCode, data);
+  });
+}
+
+/**
+ * bidderData returns the WURFL data for a bidder
+ * @param {Object} wurflData WURFL data
+ * @param {Array} caps Capability list
+ * @param {Array} filter Filter list
+ * @returns {Object} Bidder data
+ */
+export const bidderData = (wurflData, caps, filter) => {
+  const data = {};
+  caps.forEach((cap, index) => {
+    if (!filter.includes(index)) {
+      return;
+    }
+    if (cap in wurflData) {
+      data[cap] = wurflData[cap];
+    }
+  });
+  return data;
+}
+
+/**
+ * lowEntropyData returns the WURFL low entropy data
+ * @param {Object} wurflData WURFL data
+ * @param {Array} lowEntropyCaps Low entropy capability list
+ * @returns {Object} Bidder data
+ */
+export const lowEntropyData = (wurflData, lowEntropyCaps) => {
+  const data = {};
+  lowEntropyCaps.forEach((cap, _) => {
+    let value = wurflData[cap];
+    if (cap == 'complete_device_name') {
+      value = value.replace(/Apple (iP(hone|ad|od)).*/, 'Apple iP$2');
+    }
+    data[cap] = value;
+  });
+  return data;
+}
+
+/**
+ * enrichBidderRequest enriches the bidder request with WURFL data
+ * @param {Object} reqBidsConfigObj Bid request configuration object
+ * @param {String} bidderCode Bidder code
+ * @param {Object} wurflData WURFL data
+ */
+export const enrichBidderRequest = (reqBidsConfigObj, bidderCode, wurflData) => {
+  const ortb2data = {
+    'device': {
+      'ext': {
+        'wurfl': wurflData,
+      }
+    },
+  };
+  mergeDeep(reqBidsConfigObj.ortb2Fragments.bidder, { [bidderCode]: ortb2data });
+}
+
+/**
+ * onAuctionEndEvent is called when the auction ends
+ * @param {Object} auctionDetails Auction details
+ * @param {Object} config Configuration for WURFL RTD submodule
+ * @param {Object} userConsent User consent data
+ */
+function onAuctionEndEvent(auctionDetails, config, userConsent) {
+  const altHost = config.params?.altHost ?? null;
+
+  let host = WURFL_JS_HOST;
+  if (altHost) {
+    host = altHost;
+  }
+
+  const url = new URL(host);
+  url.pathname = STATS_ENDPOINT_PATH;
+
+  if (enrichedBidders.size === 0) {
+    return;
+  }
+
+  var payload = JSON.stringify({ bidders: [...enrichedBidders] });
+  const sentBeacon = sendBeacon(url.toString(), payload);
+  if (sentBeacon) {
+    return;
+  }
+
+  fetch(url.toString(), {
+    method: 'POST',
+    body: payload,
+    mode: 'no-cors',
+    keepalive: true
+  });
+}
+
+// The WURFL submodule
+export const wurflSubmodule = {
+  name: MODULE_NAME,
+  init,
+  getBidRequestData,
+  onAuctionEndEvent,
+}
+
+// Register the WURFL submodule as submodule of realTimeData
+submodule(REAL_TIME_MODULE, wurflSubmodule);

package/modules/wurflRtdProvider.md

@@ -0,0 +1,67 @@
+# WURFL Real-time Data Submodule
+
+## Overview
+
+    Module Name: WURFL Rtd Provider
+    Module Type: Rtd Provider
+    Maintainer: prebid@scientiamobile.com
+
+## Description
+
+The WURFL RTD module enriches the OpenRTB 2.0 device data with [WURFL data](https://www.scientiamobile.com/wurfl-js-business-edition-at-the-intersection-of-javascript-and-enterprise/).
+The module sets the WURFL data in `device.ext.wurfl` and all the bidder adapters will always receive the low entry capabilites like `is_mobile`, `complete_device_name` and `form_factor`. 
+
+For a more detailed analysis bidders can subscribe to detect iPhone and iPad models and receive additional [WURFL device capabilities](https://www.scientiamobile.com/capabilities/?products%5B%5D=wurfl-js).
+
+## User-Agent Client Hints
+
+WURFL.js is fully compatible with Chromium's User-Agent Client Hints (UA-CH) initiative. If User-Agent Client Hints are absent in the HTTP headers that WURFL.js receives, the service will automatically fall back to using the User-Agent Client Hints' JS API to fetch [high entropy client hint values](https://wicg.github.io/ua-client-hints/#getHighEntropyValues) from the client device. However, we recommend that you explicitly opt-in/advertise support for User-Agent Client Hints on your website and delegate them to the WURFL.js service for the fastest detection experience. Our documentation regarding implementing User-Agent Client Hint support [is available here](https://docs.scientiamobile.com/guides/implementing-useragent-clienthints). 
+
+## Usage
+
+### Build
+```
+gulp build --modules="wurflRtdProvider,appnexusBidAdapter,..."  
+```
+
+### Configuration
+
+Use `setConfig` to instruct Prebid.js to initilize the WURFL RTD module, as specified below. 
+
+This module is configured as part of the `realTimeData.dataProviders`
+
+```javascript
+var TIMEOUT = 1000;
+pbjs.setConfig({
+    realTimeData: {
+        auctionDelay: TIMEOUT,
+        dataProviders: [{
+            name: 'wurfl',
+            waitForIt: true,
+            params: {
+                debug: false
+            }
+        }]
+    }
+});
+```
+
+### Parameters 
+
+| Name                      | Type          | Description                                                      | Default           |
+| :------------------------ | :------------ | :--------------------------------------------------------------- |:----------------- |
+| name                      | String        | Real time data module name                                       | Always 'wurfl'    |
+| waitForIt                 | Boolean       | Should be `true` if there's an `auctionDelay` defined (optional) | `false`           |
+| params                    | Object        |                                                                  |                   |
+| params.altHost            | String        | Alternate host to connect to WURFL.js                            |                   |
+| params.debug              | Boolean       | Enable debug                                                     | `false`           |
+
+## Testing 
+
+To view an example of how the WURFL RTD module works :
+
+`gulp serve --modules=wurflRtdProvider,appnexusBidAdapter`
+
+and then point your browser at:
+
+`http://localhost:9999/integrationExamples/gpt/wurflRtdProvider_example.html`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "9.5.0",
+  "version": "9.7.0",
   "description": "Header Bidding Management Library",
   "main": "src/prebid.public.js",
   "exports": {

package/src/adloader.js

@@ -32,6 +32,7 @@ const _approvedLoadExternalJSList = [
   'dynamicAdBoost',
   '51Degrees',
   'symitridap',
+  'wurfl',
   // UserId Submodules
   'justtag',
   'tncId',

package/src/prebid.js

@@ -41,7 +41,7 @@ import {enrichFPD} from './fpd/enrichment.js';
 import {allConsent} from './consentHandler.js';
 import {insertLocatorFrame, renderAdDirect} from './adRendering.js';
 import {getHighestCpm} from './utils/reducers.js';
-import {fillVideoDefaults} from './video.js';
+import {fillVideoDefaults, validateOrtbVideoFields} from './video.js';
 
 const pbjsInstance = getGlobal();
 const { triggerUserSyncs } = userSync;
@@ -134,6 +134,7 @@ function validateVideoMediaType(adUnit) {
       delete validatedAdUnit.mediaTypes.video.playerSize;
     }
   }
+  validateOrtbVideoFields(validatedAdUnit);
   return validatedAdUnit;
 }
 
@@ -869,6 +870,10 @@ pbjsInstance.getHighestCpmBids = function (adUnitCode) {
   return targeting.getWinningBids(adUnitCode);
 };
 
+pbjsInstance.clearAllAuctions = function () {
+  auctionManager.clearAllAuctions();
+};
+
 if (FEATURES.VIDEO) {
   /**
    * Mark the winning bid as used, should only be used in conjunction with video

package/src/video.js

@@ -1,4 +1,4 @@
-import {deepAccess, logError} from './utils.js';
+import {deepAccess, isArrayOfNums, isInteger, isNumber, isPlainObject, isStr, logError, logWarn} from './utils.js';
 import {config} from '../src/config.js';
 import {hook} from './hook.js';
 import {auctionManager} from './auctionManager.js';
@@ -6,6 +6,47 @@ import {auctionManager} from './auctionManager.js';
 export const OUTSTREAM = 'outstream';
 export const INSTREAM = 'instream';
 
+/**
+ * List of OpenRTB 2.x video object properties with simple validators.
+ * Not included: `companionad`, `durfloors`, `ext`
+ * reference: https://github.com/InteractiveAdvertisingBureau/openrtb2.x/blob/main/2.6.md
+ */
+export const ORTB_VIDEO_PARAMS = new Map([
+  [ 'mimes', value => Array.isArray(value) && value.length > 0 && value.every(v => typeof v === 'string') ],
+  [ 'minduration', isInteger ],
+  [ 'maxduration', isInteger ],
+  [ 'startdelay', isInteger ],
+  [ 'maxseq', isInteger ],
+  [ 'poddur', isInteger ],
+  [ 'protocols', isArrayOfNums ],
+  [ 'w', isInteger ],
+  [ 'h', isInteger ],
+  [ 'podid', isStr ],
+  [ 'podseq', isInteger ],
+  [ 'rqddurs', isArrayOfNums ],
+  [ 'placement', isInteger ], // deprecated, see plcmt
+  [ 'plcmt', isInteger ],
+  [ 'linearity', isInteger ],
+  [ 'skip', value => [1, 0].includes(value) ],
+  [ 'skipmin', isInteger ],
+  [ 'skipafter', isInteger ],
+  [ 'sequence', isInteger ], // deprecated
+  [ 'slotinpod', isInteger ],
+  [ 'mincpmpersec', isNumber ],
+  [ 'battr', isArrayOfNums ],
+  [ 'maxextended', isInteger ],
+  [ 'minbitrate', isInteger ],
+  [ 'maxbitrate', isInteger ],
+  [ 'boxingallowed', isInteger ],
+  [ 'playbackmethod', isArrayOfNums ],
+  [ 'playbackend', isInteger ],
+  [ 'delivery', isArrayOfNums ],
+  [ 'pos', isInteger ],
+  [ 'api', isArrayOfNums ],
+  [ 'companiontype', isArrayOfNums ],
+  [ 'poddedupe', isArrayOfNums ]
+]);
+
 export function fillVideoDefaults(adUnit) {
   const video = adUnit?.mediaTypes?.video;
   if (video != null && video.plcmt == null) {
@@ -17,6 +58,42 @@ export function fillVideoDefaults(adUnit) {
   }
 }
 
+/**
+ * validateOrtbVideoFields mutates the `adUnit.mediaTypes.video` object by removing invalid ortb properties (default).
+ * The onInvalidParam callback can be used to handle invalid properties differently.
+ * Other properties are ignored and kept as is.
+ *
+ * @param {Object} adUnit - The adUnit object.
+ * @param {Function} onInvalidParam - The callback function to be called with key, value, and adUnit.
+ * @returns {void}
+ */
+export function validateOrtbVideoFields(adUnit, onInvalidParam) {
+  const videoParams = adUnit?.mediaTypes?.video;
+
+  if (!isPlainObject(videoParams)) {
+    logWarn(`validateOrtbVideoFields: videoParams must be an object.`);
+    return;
+  }
+
+  if (videoParams != null) {
+    Object.entries(videoParams)
+      .forEach(([key, value]) => {
+        if (!ORTB_VIDEO_PARAMS.has(key)) {
+          return
+        }
+        const isValid = ORTB_VIDEO_PARAMS.get(key)(value);
+        if (!isValid) {
+          if (typeof onInvalidParam === 'function') {
+            onInvalidParam(key, value, adUnit);
+          } else {
+            delete videoParams[key];
+            logWarn(`Invalid prop in adUnit "${adUnit.code}": Invalid value for mediaTypes.video.${key} ORTB property. The property has been removed.`);
+          }
+        }
+      });
+  }
+}
+
 /**
  * @typedef {object} VideoBid
  * @property {string} adId id of the bid