diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 584f6f8894a..84c97376a3e 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -38,7 +38,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
diff --git a/.github/workflows/issue_tracker.yml b/.github/workflows/issue_tracker.yml
index 69cf4c5fc7f..a55e5f05cb8 100644
--- a/.github/workflows/issue_tracker.yml
+++ b/.github/workflows/issue_tracker.yml
@@ -14,7 +14,7 @@ jobs:
     steps:
       - name: Generate token
         id: generate_token
-        uses: tibdex/github-app-token@b62528385c34dbc9f38e5f4225ac829252d1ea92
+        uses: tibdex/github-app-token@0914d50df753bbc42180d982a6550f195390069f
         with:
           app_id: ${{ secrets.ISSUE_APP_ID }}
           private_key: ${{ secrets.ISSUE_APP_PEM }}
diff --git a/modules/adkernelBidAdapter.js b/modules/adkernelBidAdapter.js
index ac0984fec68..6ae19c3efdc 100644
--- a/modules/adkernelBidAdapter.js
+++ b/modules/adkernelBidAdapter.js
@@ -98,7 +98,6 @@ export const spec = {
     {code: 'displayioads'},
     {code: 'rtbdemand_com'},
     {code: 'bidbuddy'},
-    {code: 'adliveconnect'},
     {code: 'didnadisplay'},
     {code: 'qortex'},
     {code: 'adpluto'},
diff --git a/modules/adtelligentBidAdapter.js b/modules/adtelligentBidAdapter.js
index cab2b8956bc..a315c9a696e 100644
--- a/modules/adtelligentBidAdapter.js
+++ b/modules/adtelligentBidAdapter.js
@@ -15,15 +15,9 @@ const HOST_GETTERS = {
       return 'ghb' + subdomainSuffixes[num++ % subdomainSuffixes.length] + '.adtelligent.com';
     }
   }()),
-  navelix: () => 'ghb.hb.navelix.com',
-  appaloosa: () => 'ghb.hb.appaloosa.media',
-  onefiftytwomedia: () => 'ghb.ads.152media.com',
-  bidsxchange: () => 'ghb.hbd.bidsxchange.com',
   streamkey: () => 'ghb.hb.streamkey.net',
   janet: () => 'ghb.bidder.jmgads.com',
-  pgam: () => 'ghb.pgamssp.com',
   ocm: () => 'ghb.cenarius.orangeclickmedia.com',
-  vidcrunchllc: () => 'ghb.platform.vidcrunch.com',
   '9dotsmedia': () => 'ghb.platform.audiodots.com',
   copper6: () => 'ghb.app.copper6.com'
 }
@@ -42,16 +36,10 @@ export const spec = {
   code: BIDDER_CODE,
   gvlid: 410,
   aliases: [
-    'onefiftytwomedia',
-    'appaloosa',
-    'bidsxchange',
     'streamkey',
     'janet',
     { code: 'selectmedia', gvlid: 775 },
-    { code: 'navelix', gvlid: 380 },
-    'pgam',
     { code: 'ocm', gvlid: 1148 },
-    { code: 'vidcrunchllc', gvlid: 1145 },
     '9dotsmedia',
     'copper6',
   ],
diff --git a/modules/boldwinBidAdapter.js b/modules/boldwinBidAdapter.js
index 3915df8b976..4d97f830d33 100644
--- a/modules/boldwinBidAdapter.js
+++ b/modules/boldwinBidAdapter.js
@@ -80,6 +80,15 @@ export const spec = {
       if (bidderRequest.gdprConsent) {
         request.gdpr = bidderRequest.gdprConsent;
       }
+
+      // Add GPP consent
+      if (bidderRequest.gppConsent) {
+        request.gpp = bidderRequest.gppConsent.gppString;
+        request.gpp_sid = bidderRequest.gppConsent.applicableSections;
+      } else if (bidderRequest.ortb2?.regs?.gpp) {
+        request.gpp = bidderRequest.ortb2.regs.gpp;
+        request.gpp_sid = bidderRequest.ortb2.regs.gpp_sid;
+      }
     }
     const len = validBidRequests.length;
 
diff --git a/modules/cadentApertureMXBidAdapter.js b/modules/cadentApertureMXBidAdapter.js
index 22ed0590e05..32c0a4e4643 100644
--- a/modules/cadentApertureMXBidAdapter.js
+++ b/modules/cadentApertureMXBidAdapter.js
@@ -374,7 +374,7 @@ export const spec = {
     }
     return cadentBidResponses;
   },
-  getUserSyncs: function (syncOptions, responses, gdprConsent, uspConsent) {
+  getUserSyncs: function (syncOptions, responses, gdprConsent, uspConsent, gppConsent) {
     const syncs = [];
     const consentParams = [];
     if (syncOptions.iframeEnabled) {
@@ -390,6 +390,14 @@ export const spec = {
       if (uspConsent && typeof uspConsent.consentString === 'string') {
         consentParams.push(`usp=${uspConsent.consentString}`);
       }
+      if (gppConsent && typeof gppConsent === 'object') {
+        if (gppConsent.gppString && typeof gppConsent.gppString === 'string') {
+          consentParams.push(`gpp=${gppConsent.gppString}`);
+        }
+        if (gppConsent.applicableSections && typeof gppConsent.applicableSections === 'object') {
+          consentParams.push(`gpp_sid=${gppConsent.applicableSections}`);
+        }
+      }
       if (consentParams.length > 0) {
         url = url + '?' + consentParams.join('&');
       }
diff --git a/modules/coinzillaBidAdapter.js b/modules/coinzillaBidAdapter.js
index 15731423c49..c7d8fa5797c 100644
--- a/modules/coinzillaBidAdapter.js
+++ b/modules/coinzillaBidAdapter.js
@@ -77,7 +77,7 @@ export const spec = {
         dealId: dealId,
         currency: currency,
         netRevenue: netRevenue,
-        ttl: bidRequest.timeout,
+        ttl: response.timeout,
         referrer: referrer,
         ad: response.ad,
         mediaType: response.mediaType,
diff --git a/modules/consentManagementGpp.js b/modules/consentManagementGpp.js
index 69fc5789953..8160ee2378c 100644
--- a/modules/consentManagementGpp.js
+++ b/modules/consentManagementGpp.js
@@ -247,7 +247,7 @@ class GPP10Client extends GPPClient {
 
   getGPPData(pingData) {
     const parsedSections = GreedyPromise.all(
-      pingData.supportedAPIs.map((api) => this.cmp({
+      (pingData.supportedAPIs || pingData.apiSupport || []).map((api) => this.cmp({
         command: 'getSection',
         parameter: api
       }).catch(err => {
diff --git a/modules/experianRtdProvider.js b/modules/experianRtdProvider.js
new file mode 100644
index 00000000000..e18296342de
--- /dev/null
+++ b/modules/experianRtdProvider.js
@@ -0,0 +1,135 @@
+import { submodule } from '../src/hook.js';
+import { getStorageManager } from '../src/storageManager.js';
+import { MODULE_TYPE_RTD } from '../src/activities/modules.js';
+import {
+  deepAccess,
+  isArray,
+  isPlainObject,
+  isStr,
+  mergeDeep,
+  safeJSONParse,
+  timestamp
+} from '../src/utils.js';
+import { ajax } from '../src/ajax.js';
+
+export const SUBMODULE_NAME = 'experian_rtid';
+export const EXPERIAN_RTID_DATA_KEY = 'experian_rtid_data';
+export const EXPERIAN_RTID_EXPIRATION_KEY = 'experian_rtid_expiration';
+export const EXPERIAN_RTID_STALE_KEY = 'experian_rtid_stale';
+export const EXPERIAN_RTID_NO_TRACK_KEY = 'experian_rtid_no_track';
+const EXPERIAN_RTID_URL = 'https://rtid.tapad.com'
+const storage = getStorageManager({ moduleType: MODULE_TYPE_RTD, moduleName: SUBMODULE_NAME });
+
+export const experianRtdObj = {
+  /**
+   * @summary modify bid request data
+   * @param {Object} reqBidsConfigObj
+   * @param {function} done
+   * @param {SubmoduleConfig} config
+   * @param {UserConsentData} userConsent
+   */
+  getBidRequestData(reqBidsConfigObj, done, config, userConsent) {
+    const dataEnvelope = storage.getDataFromLocalStorage(EXPERIAN_RTID_DATA_KEY, null);
+    const stale = storage.getDataFromLocalStorage(EXPERIAN_RTID_STALE_KEY, null);
+    const expired = storage.getDataFromLocalStorage(EXPERIAN_RTID_EXPIRATION_KEY, null);
+    const noTrack = storage.getDataFromLocalStorage(EXPERIAN_RTID_NO_TRACK_KEY, null);
+    const now = timestamp()
+    if (now > new Date(expired).getTime() || (noTrack == null && dataEnvelope == null)) {
+      // request data envelope and don't manipulate bids
+      experianRtdObj.requestDataEnvelope(config, userConsent)
+      done();
+      return false;
+    }
+    if (now > new Date(stale).getTime()) {
+      // request data envelope and manipulate bids
+      experianRtdObj.requestDataEnvelope(config, userConsent);
+    }
+    if (noTrack != null) {
+      done();
+      return false;
+    }
+    experianRtdObj.alterBids(reqBidsConfigObj, config);
+    done()
+    return true;
+  },
+
+  alterBids(reqBidsConfigObj, config) {
+    const dataEnvelope = safeJSONParse(storage.getDataFromLocalStorage(EXPERIAN_RTID_DATA_KEY, null));
+    if (dataEnvelope == null) {
+      return;
+    }
+    deepAccess(config, 'params.bidders').forEach((bidderCode) => {
+      const bidderData = dataEnvelope.find(({ bidder }) => bidder === bidderCode)
+      if (bidderData != null) {
+        mergeDeep(reqBidsConfigObj.ortb2Fragments.bidder, { [bidderCode]: { experianRtidKey: bidderData.data.key, experianRtidData: bidderData.data.data } })
+      }
+    })
+  },
+  requestDataEnvelope(config, userConsent) {
+    function storeDataEnvelopeResponse(response) {
+      const responseJson = safeJSONParse(response);
+      if (responseJson != null) {
+        storage.setDataInLocalStorage(EXPERIAN_RTID_STALE_KEY, responseJson.staleAt, null);
+        storage.setDataInLocalStorage(EXPERIAN_RTID_EXPIRATION_KEY, responseJson.expiresAt, null);
+        if (responseJson.status === 'no_track') {
+          storage.setDataInLocalStorage(EXPERIAN_RTID_NO_TRACK_KEY, 'no_track', null);
+          storage.removeDataFromLocalStorage(EXPERIAN_RTID_DATA_KEY, null);
+        } else {
+          storage.setDataInLocalStorage(EXPERIAN_RTID_DATA_KEY, JSON.stringify(responseJson.data), null);
+          storage.removeDataFromLocalStorage(EXPERIAN_RTID_NO_TRACK_KEY, null);
+        }
+      }
+    }
+    const queryString = experianRtdObj.extractConsentQueryString(config, userConsent)
+    const fullUrl = queryString == null ? `${EXPERIAN_RTID_URL}/acc/${deepAccess(config, 'params.accountId')}/ids` : `${EXPERIAN_RTID_URL}/acc/${deepAccess(config, 'params.accountId')}/ids${queryString}`
+    ajax(fullUrl, storeDataEnvelopeResponse, null, { withCredentials: true, contentType: 'application/json' })
+  },
+  extractConsentQueryString(config, userConsent) {
+    const queryObj = {};
+
+    if (userConsent != null) {
+      if (userConsent.gdpr != null) {
+        const { gdprApplies, consentString } = userConsent.gdpr;
+        mergeDeep(queryObj, {gdpr: gdprApplies, gdpr_consent: consentString})
+      }
+      if (userConsent.uspConsent != null) {
+        mergeDeep(queryObj, {us_privacy: userConsent.uspConsent})
+      }
+    }
+    const consentQueryString = Object.entries(queryObj).map(([key, val]) => `${key}=${val}`).join('&');
+
+    let idsString = '';
+    if (deepAccess(config, 'params.ids') != null && isPlainObject(deepAccess(config, 'params.ids'))) {
+      idsString = Object.entries(deepAccess(config, 'params.ids')).map(([idType, val]) => {
+        if (isArray(val)) {
+          return val.map((singleVal) => `id.${idType}=${singleVal}`).join('&')
+        } else {
+          return `id.${idType}=${val}`
+        }
+      }).join('&')
+    }
+
+    const combinedString = [consentQueryString, idsString].filter((string) => string !== '').join('&');
+    return combinedString !== '' ? `?${combinedString}` : undefined;
+  },
+  /**
+   * @function
+   * @summary init sub module
+   * @name RtdSubmodule#init
+   * @param {SubmoduleConfig} config
+   * @param {UserConsentData} userConsent
+   * @return {boolean} false to remove sub module
+   */
+  init(config, userConsent) {
+    return isStr(deepAccess(config, 'params.accountId'));
+  }
+}
+
+/** @type {RtdSubmodule} */
+export const experianRtdSubmodule = {
+  name: SUBMODULE_NAME,
+  getBidRequestData: experianRtdObj.getBidRequestData,
+  init: experianRtdObj.init
+}
+
+submodule('realTimeData', experianRtdSubmodule);
diff --git a/modules/experianRtdProvider.md b/modules/experianRtdProvider.md
new file mode 100644
index 00000000000..ad46e0c3d55
--- /dev/null
+++ b/modules/experianRtdProvider.md
@@ -0,0 +1,52 @@
+# Experian Real-time Data Submodule
+
+## Overview
+
+    Module Name: Experian Rtd Provider
+    Module Type: Rtd Provider
+    Maintainer: team-ui@tapad.com
+
+## Description
+
+The Experian RTD module adds encrypted identifier envelope to the bidding object.
+
+## Usage
+
+### Build
+```
+gulp build --modules="rtdModule,experianRtdProvider,appnexusBidAdapter,..."
+```
+
+> Note that the global RTD module, `rtdModule`, is a prerequisite of the Experian RTD module.
+
+### Configuration
+
+Use `setConfig` to instruct Prebid.js to initialize the Experian RTD module, as specified below.
+
+This module is configured as part of the `realTimeData.dataProviders`
+
+```javascript
+pbjs.setConfig({
+  realTimeData: {
+    auctionDelay: 300,
+    dataProviders: [{
+      name: 'experian_rtid',
+      waitForIt: true,
+      params: {
+        accountId: 'ZylatYg',
+        bidders: ['sovrn', 'pubmatic'],
+        ids: { maid: ['424', '2982'], hem: 'my-hem' }
+      }
+    }]
+  }
+})
+```
+
+### Parameters
+| Name             | Type                                    | Description                                                                  | Default                |
+|:-----------------|:----------------------------------------|:-----------------------------------------------------------------------------|:-----------------------|
+| name             | String                                  | Real time data module name                                                   | Always 'experian_rtid' |
+| waitForIt        | Boolean                                 | Set to true to maximize chance for bidder enrichment, used with auctionDelay | `false`                |
+| params.accountId | String                                  | Your account id issued by Experian                                           |                        |
+| params.bidders   | Array<string>                           | List of bidders for which you would like data to be set                      |                        |
+| params.ids       | Record<string, Array<string> or string> | Additional identifiers to send to Experian RTID endpoint                     |                        |
diff --git a/modules/flippBidAdapter.js b/modules/flippBidAdapter.js
new file mode 100644
index 00000000000..dfe8141170d
--- /dev/null
+++ b/modules/flippBidAdapter.js
@@ -0,0 +1,183 @@
+import {isEmpty, parseUrl} from '../src/utils.js';
+import { registerBidder } from '../src/adapters/bidderFactory.js';
+import { BANNER } from '../src/mediaTypes.js';
+import {getStorageManager} from '../src/storageManager.js';
+
+const NETWORK_ID = 11090;
+const AD_TYPES = [4309, 641];
+const DTX_TYPES = [5061];
+const TARGET_NAME = 'inline';
+const BIDDER_CODE = 'flipp';
+const ENDPOINT = 'https://gateflipp.flippback.com/flyer-locator-service/client_bidding';
+const DEFAULT_TTL = 30;
+const DEFAULT_CURRENCY = 'USD';
+const DEFAULT_CREATIVE_TYPE = 'NativeX';
+const VALID_CREATIVE_TYPES = ['DTX', 'NativeX'];
+const FLIPP_USER_KEY = 'flipp-uid';
+const COMPACT_DEFAULT_HEIGHT = 600;
+
+let userKey = null;
+export const storage = getStorageManager({bidderCode: BIDDER_CODE});
+
+export function getUserKey(options = {}) {
+  if (userKey) {
+    return userKey;
+  }
+
+  // If the partner provides the user key use it, otherwise fallback to cookies
+  if (options.userKey && isValidUserKey(options.userKey)) {
+    userKey = options.userKey;
+    return options.userKey;
+  }
+  // Grab from Cookie
+  const foundUserKey = storage.cookiesAreEnabled() && storage.getCookie(FLIPP_USER_KEY);
+  if (foundUserKey) {
+    return foundUserKey;
+  }
+
+  // Generate if none found
+  userKey = generateUUID();
+
+  // Set cookie
+  if (storage.cookiesAreEnabled()) {
+    storage.setCookie(FLIPP_USER_KEY, userKey);
+  }
+
+  return userKey;
+}
+
+function isValidUserKey(userKey) {
+  return !userKey.startsWith('#');
+}
+
+const generateUUID = () => {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+};
+
+/**
+ * Determines if a creativeType is valid
+ *
+ * @param {string} creativeType The Creative Type to validate.
+ * @return string creativeType if this is a valid Creative Type, and 'NativeX' otherwise.
+ */
+const validateCreativeType = (creativeType) => {
+  if (creativeType && VALID_CREATIVE_TYPES.includes(creativeType)) {
+    return creativeType;
+  } else {
+    return DEFAULT_CREATIVE_TYPE;
+  }
+};
+
+const getAdTypes = (creativeType) => {
+  if (creativeType === 'DTX') {
+    return DTX_TYPES;
+  }
+  return AD_TYPES;
+}
+
+export const spec = {
+  code: BIDDER_CODE,
+  supportedMediaTypes: [BANNER],
+  /**
+   * Determines whether or not the given bid request is valid.
+   *
+   * @param {BidRequest} bid The bid params to validate.
+   * @return boolean True if this is a valid bid, and false otherwise.
+   */
+  isBidRequestValid: function(bid) {
+    return !!(bid.params.siteId) && !!(bid.params.publisherNameIdentifier);
+  },
+  /**
+   * Make a server request from the list of BidRequests.
+   *
+   * @param {BidRequest[]} validBidRequests[] an array of bids
+   * @param {BidderRequest} bidderRequest master bidRequest object
+   * @return ServerRequest Info describing the request to the server.
+   */
+  buildRequests: function(validBidRequests, bidderRequest) {
+    const urlParams = parseUrl(bidderRequest.refererInfo.page).search;
+    const contentCode = urlParams['flipp-content-code'];
+    const userKey = getUserKey(validBidRequests[0]?.params);
+    const placements = validBidRequests.map((bid, index) => {
+      const options = bid.params.options || {};
+      if (!options.hasOwnProperty('startCompact')) {
+        options.startCompact = true;
+      }
+      return {
+        divName: TARGET_NAME,
+        networkId: NETWORK_ID,
+        siteId: bid.params.siteId,
+        adTypes: getAdTypes(bid.params.creativeType),
+        count: 1,
+        ...(!isEmpty(bid.params.zoneIds) && {zoneIds: bid.params.zoneIds}),
+        properties: {
+          ...(!isEmpty(contentCode) && {contentCode: contentCode.slice(0, 32)}),
+        },
+        options,
+        prebid: {
+          requestId: bid.bidId,
+          publisherNameIdentifier: bid.params.publisherNameIdentifier,
+          height: bid.mediaTypes.banner.sizes[index][0],
+          width: bid.mediaTypes.banner.sizes[index][1],
+          creativeType: validateCreativeType(bid.params.creativeType),
+        }
+      }
+    });
+    return {
+      method: 'POST',
+      url: ENDPOINT,
+      data: {
+        placements,
+        url: bidderRequest.refererInfo.page,
+        user: {
+          key: userKey,
+        },
+      },
+    }
+  },
+  /**
+   * Unpack the response from the server into a list of bids.
+   *
+   * @param {ServerResponse} serverResponse A successful response from the server.
+   * @param {BidRequest} bidRequest A bid request object
+   * @return {Bid[]} An array of bids which were nested inside the server.
+   */
+  interpretResponse: function(serverResponse, bidRequest) {
+    if (!serverResponse?.body) return [];
+    const placements = bidRequest.data.placements;
+    const res = serverResponse.body;
+    if (!isEmpty(res) && !isEmpty(res.decisions) && !isEmpty(res.decisions.inline)) {
+      return res.decisions.inline.map(decision => {
+        const placement = placements.find(p => p.prebid.requestId === decision.prebid?.requestId);
+        const height = placement.options?.startCompact ? COMPACT_DEFAULT_HEIGHT : decision.height;
+        return {
+          bidderCode: BIDDER_CODE,
+          requestId: decision.prebid?.requestId,
+          cpm: decision.prebid?.cpm,
+          width: decision.width,
+          height,
+          creativeId: decision.adId,
+          currency: DEFAULT_CURRENCY,
+          netRevenue: true,
+          ttl: DEFAULT_TTL,
+          ad: decision.prebid?.creative,
+        }
+      });
+    }
+    return [];
+  },
+
+  /**
+   * Register the user sync pixels which should be dropped after the auction.
+   *
+   * @param {SyncOptions} syncOptions Which user syncs are allowed?
+   * @param {ServerResponse[]} serverResponses List of server's responses.
+   * @return {UserSync[]} The user syncs which should be dropped.
+   */
+  getUserSyncs: (syncOptions, serverResponses) => [],
+}
+registerBidder(spec);
diff --git a/modules/flippBidAdapter.md b/modules/flippBidAdapter.md
new file mode 100644
index 00000000000..810b883e3f9
--- /dev/null
+++ b/modules/flippBidAdapter.md
@@ -0,0 +1,44 @@
+# Overview
+
+```
+Module Name: Flipp Bid Adapter
+Module Type: Bidder Adapter
+Maintainer: prebid@flipp.com
+```
+
+# Description
+
+This module connects publishers to Flipp's Shopper Experience via Prebid.js.
+
+
+# Test parameters
+
+```javascript
+var adUnits = [
+    {
+        code: 'flipp-scroll-ad-content',
+        mediaTypes: {
+            banner: {
+                sizes: [
+                    [300, 600]
+                ]
+            }
+        },
+        bids: [
+            {
+                bidder: 'flipp',
+                params: {
+                    creativeType: 'NativeX', // Optional, can be one of 'NativeX' (default) or 'DTX' 
+                    publisherNameIdentifier: 'wishabi-test-publisher', // Required
+                    siteId: 1192075, // Required
+                    zoneIds: [260678], // Optional
+                    userKey: "", // Optional
+                    options: {
+                        startCompact: true // Optional, default to true
+                    }
+                }
+            }
+        ]
+    }
+]
+```
diff --git a/modules/freepassIdSystem.js b/modules/freepassIdSystem.js
index d52c537e800..419aa9ec414 100644
--- a/modules/freepassIdSystem.js
+++ b/modules/freepassIdSystem.js
@@ -1,8 +1,12 @@
 import { submodule } from '../src/hook.js';
-import {generateUUID, logMessage} from '../src/utils.js';
+import { logMessage } from '../src/utils.js';
+import { getCoreStorageManager } from '../src/storageManager.js';
 
 const MODULE_NAME = 'freepassId';
 
+export const FREEPASS_COOKIE_KEY = '_f_UF8cCRlr';
+export const storage = getCoreStorageManager(MODULE_NAME);
+
 export const freepassIdSubmodule = {
   name: MODULE_NAME,
   decode: function (value, config) {
@@ -15,7 +19,12 @@ export const freepassIdSubmodule = {
     logMessage('Getting FreePass ID using config: ' + JSON.stringify(config));
 
     const freepassData = config.params !== undefined ? (config.params.freepassData || {}) : {}
-    let idObject = {userId: generateUUID()};
+    const idObject = {};
+
+    const userId = storage.getCookie(FREEPASS_COOKIE_KEY);
+    if (userId !== null) {
+      idObject.userId = userId;
+    }
 
     if (freepassData.commonId !== undefined) {
       idObject.commonId = config.params.freepassData.commonId;
@@ -29,8 +38,8 @@ export const freepassIdSubmodule = {
   },
 
   extendId: function (config, consent, cachedIdObject) {
-    let freepassData = config.params.freepassData;
-    let hasFreepassData = freepassData !== undefined;
+    const freepassData = config.params.freepassData;
+    const hasFreepassData = freepassData !== undefined;
     if (!hasFreepassData) {
       logMessage('No Freepass Data. CachedIdObject will not be extended: ' + JSON.stringify(cachedIdObject));
       return {
@@ -38,12 +47,7 @@ export const freepassIdSubmodule = {
       };
     }
 
-    if (freepassData.commonId === cachedIdObject.commonId && freepassData.userIp === cachedIdObject.userIp) {
-      logMessage('FreePass ID is already up-to-date: ' + JSON.stringify(cachedIdObject));
-      return {
-        id: cachedIdObject
-      };
-    }
+    const currentCookieId = storage.getCookie(FREEPASS_COOKIE_KEY);
 
     logMessage('Extending FreePass ID object: ' + JSON.stringify(cachedIdObject));
     logMessage('Extending FreePass ID using config: ' + JSON.stringify(config));
@@ -52,8 +56,8 @@ export const freepassIdSubmodule = {
       id: {
         commonId: freepassData.commonId,
         userIp: freepassData.userIp,
-        userId: cachedIdObject.userId,
-      },
+        userId: currentCookieId
+      }
     };
   }
 };
diff --git a/modules/growthCodeAnalyticsAdapter.js b/modules/growthCodeAnalyticsAdapter.js
index e7c572ae48a..5c7cc254f1d 100644
--- a/modules/growthCodeAnalyticsAdapter.js
+++ b/modules/growthCodeAnalyticsAdapter.js
@@ -13,7 +13,7 @@ import {MODULE_TYPE_ANALYTICS} from '../src/activities/modules.js';
 
 const MODULE_NAME = 'growthCodeAnalytics';
 const DEFAULT_PID = 'INVALID_PID'
-const ENDPOINT_URL = 'https://p2.gcprivacy.com/v3/pb/analytics'
+const ENDPOINT_URL = 'https://analytics.gcprivacy.com/v3/pb/analytics'
 
 export const storage = getStorageManager({moduleType: MODULE_TYPE_ANALYTICS, moduleName: MODULE_NAME});
 
diff --git a/modules/id5IdSystem.md b/modules/id5IdSystem.md
index cf90290b1d8..927fa10f87b 100644
--- a/modules/id5IdSystem.md
+++ b/modules/id5IdSystem.md
@@ -1,6 +1,6 @@
-# ID5 Universal ID
+# ID5 ID
 
-The ID5 ID is a shared, neutral identifier that publishers and ad tech platforms can use to recognise users even in environments where 3rd party cookies are not available. The ID5 ID is designed to respect users' privacy choices and publishers’ preferences throughout the advertising value chain. For more information about the ID5 ID and detailed integration docs, please visit [our documentation](https://support.id5.io/portal/en/kb/articles/prebid-js-user-id-module).
+The ID5 ID is a shared, neutral identifier that publishers and ad tech platforms can use to recognise users even in environments where 3rd party cookies are not available. The ID5 ID is designed to respect users' privacy choices and publishers’ preferences throughout the advertising value chain. For more information about the ID5 ID and detailed integration docs, please visit [our documentation](https://wiki.id5.io/en/identitycloud/retrieve-id5-ids/prebid-user-id-module/id5-prebid-user-id-module).
 
 ## ID5 ID Registration
 
@@ -29,7 +29,7 @@ pbjs.setConfig({
         abTesting: {             // optional
           enabled: true,         // false by default
           controlGroupPct: 0.1   // valid values are 0.0 - 1.0 (inclusive)
-        }, 
+        },
         disableExtensions: false // optional
       },
       storage: {
@@ -49,7 +49,7 @@ pbjs.setConfig({
 | name | Required | String | The name of this module: `"id5Id"`                                                                                                                                                                                                                                             | `"id5Id"` |
 | params | Required | Object | Details for the ID5 ID.                                                                                                                                                                                                                                                        | |
 | params.partner | Required | Number | This is the ID5 Partner Number obtained from registering with ID5.                                                                                                                                                                                                             | `173` |
-| params.pd | Optional | String | Partner-supplied data used for linking ID5 IDs across domains. See [our documentation](https://support.id5.io/portal/en/kb/articles/passing-partner-data-to-id5) for details on generating the string. Omit the parameter or leave as an empty string if no data to supply     | `"MT1iNTBjY..."` |
+| params.pd | Optional | String | Partner-supplied data used for linking ID5 IDs across domains. See [our documentation](https://wiki.id5.io/en/identitycloud/retrieve-id5-ids/passing-partner-data-to-id5) for details on generating the string. Omit the parameter or leave as an empty string if no data to supply     | `"MT1iNTBjY..."` |
 | params.provider | Optional | String | An identifier provided by ID5 to technology partners who manage Prebid setups on behalf of publishers. Reach out to [ID5](mailto:prebid@id5.io) if you have questions about this parameter                                                                                     | `pubmatic-identity-hub` |
 | params.abTesting | Optional | Object | Allows publishers to easily run an A/B Test. If enabled and the user is in the Control Group, the ID5 ID will NOT be exposed to bid adapters for that request                                                                                                                  | Disabled by default |
 | params.abTesting.enabled | Optional | Boolean | Set this to `true` to turn on this feature                                                                                                                                                                                                                                     | `true` or `false` |
@@ -68,3 +68,6 @@ pbjs.setConfig({
 Publishers may want to test the value of the ID5 ID with their downstream partners. While there are various ways to do this, A/B testing is a standard approach. Instead of publishers manually enabling or disabling the ID5 User ID Module based on their control group settings (which leads to fewer calls to ID5, reducing our ability to recognize the user), we have baked this in to our module directly.
 
 To turn on A/B Testing, simply edit the configuration (see above table) to enable it and set what percentage of users you would like to set for the control group. The control group is the set of user where an ID5 ID will not be exposed in to bid adapters or in the various user id functions available on the `pbjs` global. An additional value of `ext.abTestingControlGroup` will be set to `true` or `false` that can be used to inform reporting systems that the user was in the control group or not. It's important to note that the control group is user based, and not request based. In other words, from one page view to another, a user will always be in or out of the control group.
+
+### A Note on Using Multiple Wrappers
+If you or your monetization partners are deploying multiple Prebid wrappers on your websites, you should make sure you add the ID5 ID User ID module to *every* wrapper. Only the bidders configured in the Prebid wrapper where the ID5 ID User ID module is installed and configured will be able to pick up the ID5 ID. Bidders from other Prebid instances will not be able to pick up the ID5 ID.
diff --git a/modules/neuwoRtdProvider.js b/modules/neuwoRtdProvider.js
index 00a3c59b4a6..881bbc10b11 100644
--- a/modules/neuwoRtdProvider.js
+++ b/modules/neuwoRtdProvider.js
@@ -10,14 +10,14 @@ const SEGTAX_IAB = 6 // IAB - Content Taxonomy version 2
 const RESPONSE_IAB_TIER_1 = 'marketing_categories.iab_tier_1'
 const RESPONSE_IAB_TIER_2 = 'marketing_categories.iab_tier_2'
 
-function init(config = {}, userConsent) {
-  config.params = config.params || {}
+function init(config, userConsent) {
+  // config.params = config.params || {}
   // ignore module if publicToken is missing (module setup failure)
-  if (!config.params.publicToken) {
+  if (!config || !config.params || !config.params.publicToken) {
     logError('publicToken missing', 'NeuwoRTDModule', 'config.params.publicToken')
     return false;
   }
-  if (!config.params.apiUrl) {
+  if (!config || !config.params || !config.params.apiUrl) {
     logError('apiUrl missing', 'NeuwoRTDModule', 'config.params.apiUrl')
     return false;
   }
@@ -25,14 +25,14 @@ function init(config = {}, userConsent) {
 }
 
 export function getBidRequestData(reqBidsConfigObj, callback, config, userConsent) {
-  config.params = config.params || {};
+  const confParams = config.params || {};
   logInfo('NeuwoRTDModule', 'starting getBidRequestData')
 
-  const wrappedArgUrl = encodeURIComponent(config.params.argUrl || getRefererInfo().page);
+  const wrappedArgUrl = encodeURIComponent(confParams.argUrl || getRefererInfo().page);
   /* adjust for pages api.url?prefix=test (to add params with '&') as well as api.url (to add params with '?') */
-  const joiner = config.params.apiUrl.indexOf('?') < 0 ? '?' : '&'
-  const url = config.params.apiUrl + joiner + [
-    'token=' + config.params.publicToken,
+  const joiner = confParams.apiUrl.indexOf('?') < 0 ? '?' : '&'
+  const url = confParams.apiUrl + joiner + [
+    'token=' + confParams.publicToken,
     'url=' + wrappedArgUrl
   ].join('&')
   const billingId = generateUUID();
diff --git a/modules/neuwoRtdProvider.md b/modules/neuwoRtdProvider.md
index 2adead66d4e..fb52734d451 100644
--- a/modules/neuwoRtdProvider.md
+++ b/modules/neuwoRtdProvider.md
@@ -33,6 +33,8 @@ pbjs.setConfig({realTimeData: { dataProviders: [ neuwoDataProvider ]}})
 
 # Testing
 
+`gulp test --modules=rtdModule,neuwoRtdProvider`
+
 ## Add development tools if necessary
 
 - Install node for npm
diff --git a/modules/openxBidAdapter.js b/modules/openxBidAdapter.js
index 03423a028b4..d206e70aac4 100644
--- a/modules/openxBidAdapter.js
+++ b/modules/openxBidAdapter.js
@@ -12,6 +12,7 @@ export const SYNC_URL = 'https://u.openx.net/w/1.0/pd';
 export const DEFAULT_PH = '2d1251ae-7f3a-47cf-bd2a-2f288854a0ba';
 export const spec = {
   code: 'openx',
+  gvlid: 69,
   supportedMediaTypes: [BANNER, VIDEO],
   isBidRequestValid,
   buildRequests,
diff --git a/modules/optidigitalBidAdapter.js b/modules/optidigitalBidAdapter.js
index 9f84ff034ea..489f2c8264c 100755
--- a/modules/optidigitalBidAdapter.js
+++ b/modules/optidigitalBidAdapter.js
@@ -90,6 +90,12 @@ export const spec = {
       payload.uspConsent = bidderRequest.uspConsent;
     }
 
+    if (_getEids(validBidRequests[0])) {
+      payload.user = {
+        eids: _getEids(validBidRequests[0])
+      }
+    }
+
     const payloadObject = JSON.stringify(payload);
     return {
       method: 'POST',
@@ -223,6 +229,12 @@ function _getFloor (bid, sizes, currency) {
   return floor !== null ? floor : bid.params.floor;
 }
 
+function _getEids(bidRequest) {
+  if (deepAccess(bidRequest, 'userIdAsEids')) {
+    return bidRequest.userIdAsEids;
+  }
+}
+
 export function resetSync() {
   isSynced = false;
 }
diff --git a/modules/optidigitalBidAdapter.md b/modules/optidigitalBidAdapter.md
index 466dfb3bef2..327e7a27c75 100755
--- a/modules/optidigitalBidAdapter.md
+++ b/modules/optidigitalBidAdapter.md
@@ -37,10 +37,13 @@ Bidder Adapter for Prebid.js.
 
 ```
 pbjs.setConfig({
-  userSync: {
-    iframeEnabled: true,
-    syncEnabled: true,
-    syncDelay: 3000
-  }
+  userSync: {
+    filterSettings: {
+      iframe: {
+        bidders: '*', // '*' represents all bidders
+        filter: 'include'
+      }
+    }
+  }
 });
 ```
diff --git a/modules/pangleBidAdapter.js b/modules/pangleBidAdapter.js
new file mode 100644
index 00000000000..408a8b24c29
--- /dev/null
+++ b/modules/pangleBidAdapter.js
@@ -0,0 +1,110 @@
+// ver V1.0.3
+import { BANNER } from '../src/mediaTypes.js';
+import { ortbConverter } from '../libraries/ortbConverter/converter.js'
+import { registerBidder } from '../src/adapters/bidderFactory.js';
+import { deepSetValue, generateUUID, timestamp } from '../src/utils.js';
+import { getStorageManager } from '../src/storageManager.js';
+import { MODULE_TYPE_RTD } from '../src/activities/modules.js';
+
+const BIDDER_CODE = 'pangle';
+const ENDPOINT = 'https://pangle.pangleglobal.com/api/ad/union/web_js/common/get_ads';
+
+const DEFAULT_BID_TTL = 30;
+const DEFAULT_CURRENCY = 'USD';
+const DEFAULT_NET_REVENUE = true;
+const PANGLE_COOKIE = '_pangle_id';
+const COOKIE_EXP = 86400 * 1000 * 365 * 1; // 1 year
+export const storage = getStorageManager({ moduleType: MODULE_TYPE_RTD, moduleName: BIDDER_CODE })
+
+export function isValidUuid(uuid) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+    uuid
+  );
+}
+
+function getPangleCookieId() {
+  let sid = storage.cookiesAreEnabled() && storage.getCookie(PANGLE_COOKIE);
+
+  if (
+    !sid || !isValidUuid(sid)
+  ) {
+    sid = generateUUID();
+    setPangleCookieId(sid);
+  }
+
+  return sid;
+}
+
+function setPangleCookieId(sid) {
+  if (storage.cookiesAreEnabled()) {
+    const expires = (new Date(timestamp() + COOKIE_EXP)).toGMTString();
+
+    storage.setCookie(PANGLE_COOKIE, sid, expires);
+  }
+}
+
+const converter = ortbConverter({
+  context: {
+    netRevenue: DEFAULT_NET_REVENUE,
+    ttl: DEFAULT_BID_TTL,
+    currency: DEFAULT_CURRENCY,
+    mediaType: BANNER
+  }
+});
+
+export const spec = {
+  code: BIDDER_CODE,
+  supportedMediaTypes: [BANNER],
+
+  getDeviceType: function (ua) {
+    if ((/ipad|android 3.0|xoom|sch-i800|playbook|tablet|kindle/i.test(ua.toLowerCase()))) {
+      return 5; // 'tablet'
+    }
+    if ((/iphone|ipod|android|blackberry|opera|mini|windows\sce|palm|smartphone|iemobile/i.test(ua.toLowerCase()))) {
+      return 4; // 'mobile'
+    }
+    return 2; // 'desktop'
+  },
+
+  isBidRequestValid: function (bid) {
+    return Boolean(bid.params.token);
+  },
+
+  buildRequests(bidRequests, bidderRequest) {
+    const data = converter.toORTB({ bidRequests, bidderRequest })
+    const devicetype = spec.getDeviceType(navigator.userAgent);
+    deepSetValue(data, 'device.devicetype', devicetype);
+    if (bidderRequest.userId && typeof bidderRequest.userId === 'object') {
+      const pangleId = getPangleCookieId();
+      // add pangle cookie
+      const _eids = data.user?.ext?.eids ?? []
+      deepSetValue(data, 'user.ext.eids', [..._eids, {
+        source: document.location.host,
+        uids: [
+          {
+            id: pangleId,
+            atype: 1
+          }
+        ]
+      }]);
+    }
+    bidRequests.forEach((item, idx) => {
+      deepSetValue(data.imp[idx], 'ext.networkids', item.params);
+      deepSetValue(data.imp[idx], 'banner.api', [5]);
+    });
+
+    return [{
+      method: 'POST',
+      url: ENDPOINT,
+      data,
+      options: { contentType: 'application/json', withCredentials: true }
+    }]
+  },
+
+  interpretResponse(response, request) {
+    const bids = converter.fromORTB({ response: response.body, request: request.data }).bids;
+    return bids;
+  },
+};
+
+registerBidder(spec);
diff --git a/modules/pangleBidAdapter.md b/modules/pangleBidAdapter.md
new file mode 100644
index 00000000000..8fc628dcc89
--- /dev/null
+++ b/modules/pangleBidAdapter.md
@@ -0,0 +1,32 @@
+# Overview
+
+Module Name: pangle Bidder Adapter
+Module Type: Bidder Adapter
+Maintainer: <pangle_dsp@bytedance.com>
+
+# Description
+
+An adapter to get a bid from pangle DSP.
+
+# Test Parameters
+
+```javascript
+var adUnits = [{
+ // banner
+ code: 'test1',
+ mediaTypes: {
+  banner: {
+   sizes: [[300, 250]]
+  }
+ },
+
+ bids: [{
+  bidder: 'pangle',
+  params: {
+   token: 'aass',
+   appid: 612,
+   placementid: 123,
+  }
+ }]
+}];
+```
diff --git a/modules/pgamsspBidAdapter.js b/modules/pgamsspBidAdapter.js
new file mode 100644
index 00000000000..7d285daf3c6
--- /dev/null
+++ b/modules/pgamsspBidAdapter.js
@@ -0,0 +1,212 @@
+import { isFn, deepAccess, logMessage, logError } from '../src/utils.js';
+import { convertOrtbRequestToProprietaryNative } from '../src/native.js';
+
+import { registerBidder } from '../src/adapters/bidderFactory.js';
+import { BANNER, NATIVE, VIDEO } from '../src/mediaTypes.js';
+import { config } from '../src/config.js';
+
+const BIDDER_CODE = 'pgamssp';
+const AD_URL = 'https://us-east.pgammedia.com/pbjs';
+const SYNC_URL = 'https://cs.pgammedia.com';
+
+function isBidResponseValid(bid) {
+  if (!bid.requestId || !bid.cpm || !bid.creativeId || !bid.ttl || !bid.currency) {
+    return false;
+  }
+
+  switch (bid.mediaType) {
+    case BANNER:
+      return Boolean(bid.width && bid.height && bid.ad);
+    case VIDEO:
+      return Boolean(bid.vastUrl || bid.vastXml);
+    case NATIVE:
+      return Boolean(bid.native && bid.native.impressionTrackers && bid.native.impressionTrackers.length);
+    default:
+      return false;
+  }
+}
+
+function getPlacementReqData(bid) {
+  const { params, bidId, mediaTypes } = bid;
+  const schain = bid.schain || {};
+  const { placementId, endpointId } = params;
+  const bidfloor = getBidFloor(bid);
+
+  const placement = {
+    bidId,
+    schain,
+    bidfloor
+  };
+
+  if (placementId) {
+    placement.placementId = placementId;
+    placement.type = 'publisher';
+  } else if (endpointId) {
+    placement.endpointId = endpointId;
+    placement.type = 'network';
+  }
+
+  if (mediaTypes && mediaTypes[BANNER]) {
+    placement.adFormat = BANNER;
+    placement.sizes = mediaTypes[BANNER].sizes;
+  } else if (mediaTypes && mediaTypes[VIDEO]) {
+    placement.adFormat = VIDEO;
+    placement.playerSize = mediaTypes[VIDEO].playerSize;
+    placement.minduration = mediaTypes[VIDEO].minduration;
+    placement.maxduration = mediaTypes[VIDEO].maxduration;
+    placement.mimes = mediaTypes[VIDEO].mimes;
+    placement.protocols = mediaTypes[VIDEO].protocols;
+    placement.startdelay = mediaTypes[VIDEO].startdelay;
+    placement.placement = mediaTypes[VIDEO].placement;
+    placement.skip = mediaTypes[VIDEO].skip;
+    placement.skipafter = mediaTypes[VIDEO].skipafter;
+    placement.minbitrate = mediaTypes[VIDEO].minbitrate;
+    placement.maxbitrate = mediaTypes[VIDEO].maxbitrate;
+    placement.delivery = mediaTypes[VIDEO].delivery;
+    placement.playbackmethod = mediaTypes[VIDEO].playbackmethod;
+    placement.api = mediaTypes[VIDEO].api;
+    placement.linearity = mediaTypes[VIDEO].linearity;
+  } else if (mediaTypes && mediaTypes[NATIVE]) {
+    placement.native = mediaTypes[NATIVE];
+    placement.adFormat = NATIVE;
+  }
+
+  return placement;
+}
+
+function getBidFloor(bid) {
+  if (!isFn(bid.getFloor)) {
+    return deepAccess(bid, 'params.bidfloor', 0);
+  }
+
+  try {
+    const bidFloor = bid.getFloor({
+      currency: 'USD',
+      mediaType: '*',
+      size: '*',
+    });
+    return bidFloor.floor;
+  } catch (err) {
+    logError(err);
+    return 0;
+  }
+}
+
+export const spec = {
+  code: BIDDER_CODE,
+  supportedMediaTypes: [BANNER, VIDEO, NATIVE],
+
+  isBidRequestValid: (bid = {}) => {
+    const { params, bidId, mediaTypes } = bid;
+    let valid = Boolean(bidId && params && (params.placementId || params.endpointId));
+
+    if (mediaTypes && mediaTypes[BANNER]) {
+      valid = valid && Boolean(mediaTypes[BANNER] && mediaTypes[BANNER].sizes);
+    } else if (mediaTypes && mediaTypes[VIDEO]) {
+      valid = valid && Boolean(mediaTypes[VIDEO] && mediaTypes[VIDEO].playerSize);
+    } else if (mediaTypes && mediaTypes[NATIVE]) {
+      valid = valid && Boolean(mediaTypes[NATIVE]);
+    } else {
+      valid = false;
+    }
+    return valid;
+  },
+
+  buildRequests: (validBidRequests = [], bidderRequest = {}) => {
+    // convert Native ORTB definition to old-style prebid native definition
+    validBidRequests = convertOrtbRequestToProprietaryNative(validBidRequests);
+
+    let deviceWidth = 0;
+    let deviceHeight = 0;
+
+    let winLocation;
+    try {
+      const winTop = window.top;
+      deviceWidth = winTop.screen.width;
+      deviceHeight = winTop.screen.height;
+      winLocation = winTop.location;
+    } catch (e) {
+      logMessage(e);
+      winLocation = window.location;
+    }
+
+    const refferUrl = bidderRequest.refererInfo && bidderRequest.refererInfo.page;
+    let refferLocation;
+    try {
+      refferLocation = refferUrl && new URL(refferUrl);
+    } catch (e) {
+      logMessage(e);
+    }
+    // TODO: does the fallback make sense here?
+    let location = refferLocation || winLocation;
+    const language = (navigator && navigator.language) ? navigator.language.split('-')[0] : '';
+    const host = location.host;
+    const page = location.pathname;
+    const secure = location.protocol === 'https:' ? 1 : 0;
+    const placements = [];
+    const request = {
+      deviceWidth,
+      deviceHeight,
+      language,
+      secure,
+      host,
+      page,
+      placements,
+      coppa: config.getConfig('coppa') === true ? 1 : 0,
+      ccpa: bidderRequest.uspConsent || undefined,
+      gdpr: bidderRequest.gdprConsent || undefined,
+      tmax: bidderRequest.timeout
+    };
+
+    const len = validBidRequests.length;
+    for (let i = 0; i < len; i++) {
+      const bid = validBidRequests[i];
+      placements.push(getPlacementReqData(bid));
+    }
+
+    return {
+      method: 'POST',
+      url: AD_URL,
+      data: request
+    };
+  },
+
+  interpretResponse: (serverResponse) => {
+    let response = [];
+    for (let i = 0; i < serverResponse.body.length; i++) {
+      let resItem = serverResponse.body[i];
+      if (isBidResponseValid(resItem)) {
+        const advertiserDomains = resItem.adomain && resItem.adomain.length ? resItem.adomain : [];
+        resItem.meta = { ...resItem.meta, advertiserDomains };
+
+        response.push(resItem);
+      }
+    }
+    return response;
+  },
+
+  getUserSyncs: (syncOptions, serverResponses, gdprConsent, uspConsent) => {
+    let syncType = syncOptions.iframeEnabled ? 'iframe' : 'image';
+    let syncUrl = SYNC_URL + `/${syncType}?pbjs=1`;
+    if (gdprConsent && gdprConsent.consentString) {
+      if (typeof gdprConsent.gdprApplies === 'boolean') {
+        syncUrl += `&gdpr=${Number(gdprConsent.gdprApplies)}&gdpr_consent=${gdprConsent.consentString}`;
+      } else {
+        syncUrl += `&gdpr=0&gdpr_consent=${gdprConsent.consentString}`;
+      }
+    }
+    if (uspConsent && uspConsent.consentString) {
+      syncUrl += `&ccpa_consent=${uspConsent.consentString}`;
+    }
+
+    const coppa = config.getConfig('coppa') ? 1 : 0;
+    syncUrl += `&coppa=${coppa}`;
+
+    return [{
+      type: syncType,
+      url: syncUrl
+    }];
+  }
+};
+
+registerBidder(spec);
diff --git a/modules/pgamsspBidAdapter.md b/modules/pgamsspBidAdapter.md
new file mode 100644
index 00000000000..c162ec33053
--- /dev/null
+++ b/modules/pgamsspBidAdapter.md
@@ -0,0 +1,79 @@
+# Overview
+
+```
+Module Name: PGAMSSP Bidder Adapter
+Module Type: PGAMSSP Bidder Adapter
+Maintainer: info@pgammedia.com
+```
+
+# Description
+
+Connects to PGAMSSP exchange for bids.
+PGAMSSP bid adapter supports Banner, Video (instream and outstream) and Native.
+
+# Test Parameters
+```
+    var adUnits = [
+                // Will return static test banner
+                {
+                    code: 'adunit1',
+                    mediaTypes: {
+                        banner: {
+                            sizes: [ [300, 250], [320, 50] ],
+                        }
+                    },
+                    bids: [
+                        {
+                            bidder: 'pgamssp',
+                            params: {
+                                placementId: 'testBanner',
+                            }
+                        }
+                    ]
+                },
+                {
+                    code: 'addunit2',
+                    mediaTypes: {
+                        video: {
+                            playerSize: [ [640, 480] ],
+                            context: 'instream',
+                            minduration: 5,
+                            maxduration: 60,
+                        }
+                    },
+                    bids: [
+                        {
+                            bidder: 'pgamssp',
+                            params: {
+                                placementId: 'testVideo',
+                            }
+                        }
+                    ]
+                },
+                {
+                    code: 'addunit3',
+                    mediaTypes: {
+                        native: {
+                            title: {
+                                required: true
+                            },
+                            body: {
+                                required: true
+                            },
+                            icon: {
+                                required: true,
+                                size: [64, 64]
+                            }
+                        }
+                    },
+                    bids: [
+                        {
+                            bidder: 'pgamssp',
+                            params: {
+                                placementId: 'testNative',
+                            }
+                        }
+                    ]
+                }
+            ];
+```
\ No newline at end of file
diff --git a/modules/prebidServerBidAdapter/ortbConverter.js b/modules/prebidServerBidAdapter/ortbConverter.js
index 9d29b66cfc8..7d3a6137d40 100644
--- a/modules/prebidServerBidAdapter/ortbConverter.js
+++ b/modules/prebidServerBidAdapter/ortbConverter.js
@@ -168,6 +168,10 @@ const PBS_CONVERTER = ortbConverter({
         // FPD is handled different for PBS - the base request will only contain global FPD;
         // bidder-specific values are set in ext.prebid.bidderconfig
 
+        if (context.transmitTids) {
+          deepSetValue(ortbRequest, 'source.tid', proxyBidderRequest.auctionId);
+        }
+
         mergeDeep(ortbRequest, context.s2sBidRequest.ortb2Fragments?.global);
 
         // also merge in s2sConfig.extPrebid
diff --git a/modules/smartyadsBidAdapter.js b/modules/smartyadsBidAdapter.js
index 1644a15e92d..3e6c5cf360b 100644
--- a/modules/smartyadsBidAdapter.js
+++ b/modules/smartyadsBidAdapter.js
@@ -129,16 +129,22 @@ export const spec = {
     if (bid.winUrl) {
       ajax(bid.winUrl, () => {}, JSON.stringify(bid));
     } else {
-      ajax('https://et-nd43.itdsmr.com/?c=o&m=prebid&secret_key=prebid_js&winTest=1', () => {}, JSON.stringify(bid));
+      if (bid?.postData && bid?.postData[0] && bid?.postData[0].params && bid?.postData[0].params[0].host == 'prebid') {
+        ajax('https://et-nd43.itdsmr.com/?c=o&m=prebid&secret_key=prebid_js&winTest=1', () => {}, JSON.stringify(bid));
+      }
     }
   },
 
   onTimeout: function(bid) {
-    ajax('https://et-nd43.itdsmr.com/?c=o&m=prebid&secret_key=prebid_js&bidTimeout=1', () => {}, JSON.stringify(bid));
+    if (bid?.postData && bid?.postData[0] && bid?.postData[0].params && bid?.postData[0].params[0].host == 'prebid') {
+      ajax('https://et-nd43.itdsmr.com/?c=o&m=prebid&secret_key=prebid_js&bidTimeout=1', () => {}, JSON.stringify(bid));
+    }
   },
 
   onBidderError: function(bid) {
-    ajax('https://et-nd43.itdsmr.com/?c=o&m=prebid&secret_key=prebid_js&bidderError=1', () => {}, JSON.stringify(bid));
+    if (bid?.postData && bid?.postData[0] && bid?.postData[0].params && bid?.postData[0].params[0].host == 'prebid') {
+      ajax('https://et-nd43.itdsmr.com/?c=o&m=prebid&secret_key=prebid_js&bidderError=1', () => {}, JSON.stringify(bid));
+    }
   },
 
 };
diff --git a/modules/yieldloveBidAdapter.js b/modules/yieldloveBidAdapter.js
new file mode 100644
index 00000000000..4568206b20a
--- /dev/null
+++ b/modules/yieldloveBidAdapter.js
@@ -0,0 +1,149 @@
+import {registerBidder} from '../src/adapters/bidderFactory.js';
+import * as utils from '../src/utils.js';
+import {BANNER} from '../src/mediaTypes.js';
+
+const ENDPOINT_URL = 'https://s2s.yieldlove-ad-serving.net/openrtb2/auction';
+
+const DEFAULT_BID_TTL = 300; /* 5 minutes */
+const DEFAULT_CURRENCY = 'EUR';
+
+const participatedBidders = []
+
+export const spec = {
+  gvlid: 251,
+  code: 'yieldlove',
+  aliases: [],
+  supportedMediaTypes: [BANNER],
+
+  isBidRequestValid: function (bid) {
+    return !!(bid.params.pid && bid.params.rid)
+  },
+
+  buildRequests: function (validBidRequests, bidderRequest) {
+    const anyValidBidRequest = validBidRequests[0]
+
+    const impressions = validBidRequests.map(bidRequest => {
+      return {
+        ext: {
+          prebid: {
+            storedrequest: {
+              id: bidRequest.params.pid?.toString()
+            }
+          }
+        },
+        banner: {
+          format: bidRequest.sizes.map(sizeArr => ({
+            w: sizeArr[0],
+            h: sizeArr[1],
+          }))
+        },
+        secure: 1,
+        id: bidRequest.bidId
+      }
+    })
+
+    const s2sRequest = {
+      device: {
+        ua: window.navigator.userAgent,
+        w: window.innerWidth,
+        h: window.innerHeight,
+      },
+      site: {
+        ver: '1.9.0',
+        publisher: {
+          id: anyValidBidRequest.params.rid
+        },
+        page: window.location.href,
+        domain: anyValidBidRequest.params.rid
+      },
+      ext: {
+        prebid: {
+          targeting: {},
+          cache: {
+            bids: {}
+          },
+          storedrequest: {
+            id: anyValidBidRequest.params.rid
+          },
+        }
+      },
+      user: {
+        ext: {
+          consent: bidderRequest.gdprConsent?.consentString
+        },
+      },
+      id: utils.generateUUID(),
+      imp: impressions,
+      regs: {
+        ext: {
+          gdpr: 1
+        }
+      }
+    }
+
+    return {
+      method: 'POST',
+      url: ENDPOINT_URL,
+      data: s2sRequest,
+      options: {
+        contentType: 'text/plain',
+        withCredentials: true
+      },
+    };
+  },
+
+  interpretResponse: function (serverResponse) {
+    const bidResponses = []
+    const seatBids = serverResponse.body?.seatbid || []
+    seatBids.reduce((bids, cur) => {
+      if (cur.bid && cur.bid.length > 0) bids = bids.concat(cur.bid)
+      return bids
+    }, []).forEach(bid => {
+      bidResponses.push({
+        requestId: bid.impid,
+        cpm: bid.price,
+        width: bid.w,
+        height: bid.h,
+        ad: bid.adm,
+        ttl: DEFAULT_BID_TTL,
+        creativeId: bid.crid,
+        netRevenue: true,
+        currency: DEFAULT_CURRENCY
+      })
+    })
+
+    const bidders = serverResponse.body?.ext.responsetimemillis || {}
+    Object.keys(bidders).forEach(bidder => {
+      if (!participatedBidders.includes(bidder)) participatedBidders.push(bidder)
+    })
+
+    if (bidResponses.length === 0) {
+      utils.logInfo('interpretResponse :: no bid');
+    }
+
+    return bidResponses;
+  },
+
+  getUserSyncs: function (syncOptions, serverResponses, gdprConsent, uspConsent) {
+    const syncs = []
+
+    let gdprParams = ''
+    gdprParams = `gdpr=${Number(gdprConsent?.gdprApplies)}&`
+    gdprParams += `gdpr_consent=${gdprConsent?.consentString || ''}`
+
+    let bidderParams = ''
+    if (participatedBidders.length > 0) {
+      bidderParams = `bidders=${participatedBidders.join(',')}`
+    }
+
+    syncs.push({
+      type: 'iframe',
+      url: `https://cdn-a.yieldlove.com/load-cookie.html?endpoint=yieldlove&max_sync_count=100&${gdprParams}&${bidderParams}`
+    })
+
+    return syncs
+  },
+
+};
+
+registerBidder(spec);
diff --git a/modules/yieldloveBidAdapter.md b/modules/yieldloveBidAdapter.md
new file mode 100644
index 00000000000..8fd71b55f88
--- /dev/null
+++ b/modules/yieldloveBidAdapter.md
@@ -0,0 +1,38 @@
+# Overview
+
+```
+Module Name:  Yieldlove Bid Adapter
+Module Type:  Bidder Adapter
+Maintainer:   adapter@yieldlove.com
+```
+
+
+# Description
+
+Connects to **[Yieldlove](https://www.yieldlove.com/)**s S2S platform for bids.
+
+```js
+const adUnits = [
+  {
+    code: 'test-div',
+    mediaTypes: { banner: { sizes: [[300, 250]] }},
+    bids: [
+      {
+        bidder: 'yieldlove',
+        params: {
+          pid: 34437,
+          rid: 'website.com'
+        }
+      }
+    ]
+  }
+]
+```
+
+
+# Bid Parameters
+
+| Name          | Scope        | Description                                             | Example                    | Type         |
+|---------------|--------------|---------------------------------------------------------|----------------------------|--------------|
+| rid           | **required** | Publisher ID on the Yieldlove platform                  | `website.com`              | String       |
+| pid           | **required** | Placement ID on the Yieldlove platform                  | `34437`                    | Number       |
diff --git a/modules/zeta_global_sspAnalyticsAdapter.js b/modules/zeta_global_sspAnalyticsAdapter.js
index ee3bb9cd5d6..9609a047656 100644
--- a/modules/zeta_global_sspAnalyticsAdapter.js
+++ b/modules/zeta_global_sspAnalyticsAdapter.js
@@ -1,4 +1,4 @@
-import { logInfo, logError } from '../src/utils.js';
+import {logInfo, logError, deepClone} from '../src/utils.js';
 import { ajax } from '../src/ajax.js';
 import adapterManager from '../src/adapterManager.js';
 import CONSTANTS from '../src/constants.json';
@@ -10,6 +10,10 @@ const ADAPTER_CODE = 'zeta_global_ssp';
 const BASE_URL = 'https://ssp.disqus.com/prebid/event';
 const LOG_PREFIX = 'ZetaGlobalSsp-Analytics: ';
 
+const cache = {
+  auctions: {}
+};
+
 /// /////////// VARIABLES ////////////////////////////////////
 
 let publisherId; // int
@@ -24,19 +28,71 @@ function sendEvent(eventType, event) {
   );
 }
 
+function getZetaParams(event) {
+  if (event.adUnits) {
+    for (const i in event.adUnits) {
+      const unit = event.adUnits[i];
+      if (unit.bids) {
+        for (const j in unit.bids) {
+          const bid = unit.bids[j];
+          if (bid.bidder === ADAPTER_CODE && bid.params) {
+            return bid.params;
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+
 /// /////////// ADAPTER EVENT HANDLER FUNCTIONS //////////////
 
-function adRenderSucceededHandler(args) {
+function adRenderSucceededHandler(originalArgs) {
+  const args = deepClone(originalArgs);
   let eventType = CONSTANTS.EVENTS.AD_RENDER_SUCCEEDED
   logInfo(LOG_PREFIX + 'handle ' + eventType + ' event');
 
+  if (args.bid) {
+    // cleanup object
+    delete args.bid.metrics;
+    delete args.bid.ad;
+
+    // set zetaParams from cache
+    if (args.bid.auctionId) {
+      const zetaParams = cache.auctions[args.bid.auctionId];
+      if (zetaParams) {
+        args.bid.params = [ zetaParams ];
+      }
+    }
+  }
+
   sendEvent(eventType, args);
 }
 
-function auctionEndHandler(args) {
+function auctionEndHandler(originalArgs) {
+  const args = deepClone(originalArgs);
   let eventType = CONSTANTS.EVENTS.AUCTION_END;
   logInfo(LOG_PREFIX + 'handle ' + eventType + ' event');
 
+  // cleanup object
+  delete args.metrics;
+  if (args.bidderRequests) {
+    args.bidderRequests.forEach(requests => {
+      delete requests.metrics;
+      if (requests.bids) {
+        requests.bids.forEach(bid => {
+          delete bid.metrics;
+        })
+      }
+    })
+  }
+
+  // save zetaParams to cache
+  const zetaParams = getZetaParams(args);
+  if (zetaParams && args.auctionId) {
+    cache.auctions[args.auctionId] = zetaParams;
+  }
+
   sendEvent(eventType, args);
 }
 
diff --git a/package-lock.json b/package-lock.json
index c77ed85fdcf..0013ab90fc8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "8.13.0-pre",
+  "version": "8.14.0-pre",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
diff --git a/package.json b/package.json
index 43c0c1cc6f8..577f10f4c17 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "8.13.0-pre",
+  "version": "8.14.0-pre",
   "description": "Header Bidding Management Library",
   "main": "src/prebid.js",
   "scripts": {
diff --git a/src/adapterManager.js b/src/adapterManager.js
index 45c4d890944..6513d41ca3c 100644
--- a/src/adapterManager.js
+++ b/src/adapterManager.js
@@ -545,6 +545,9 @@ adapterManager.aliasBidAdapter = function (bidderCode, alias, options) {
         } else {
           let spec = bidAdapter.getSpec();
           let gvlid = options && options.gvlid;
+          if (spec.gvlid != null && gvlid == null) {
+            logWarn(`Alias '${alias}' will NOT re-use the GVL ID of the original adapter ('${spec.code}', gvlid: ${spec.gvlid}). Functionality that requires TCF consent may not work as expected.`)
+          }
           let skipPbsAliasing = options && options.skipPbsAliasing;
           newAdapter = newBidder(Object.assign({}, spec, { code: alias, gvlid, skipPbsAliasing }));
           _aliasRegistry[alias] = bidderCode;
diff --git a/src/auction.js b/src/auction.js
index 48e1a8e3436..54621669c59 100644
--- a/src/auction.js
+++ b/src/auction.js
@@ -90,7 +90,7 @@ import {bidderSettings} from './bidderSettings.js';
 import * as events from './events.js';
 import adapterManager from './adapterManager.js';
 import CONSTANTS from './constants.json';
-import {GreedyPromise} from './utils/promise.js';
+import {defer, GreedyPromise} from './utils/promise.js';
 import {useMetrics} from './utils/perfMetrics.js';
 import {adjustCpm} from './utils/cpm.js';
 import {getGlobal} from './prebidGlobal.js';
@@ -143,6 +143,7 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
   const _auctionId = auctionId || generateUUID();
   const _timeout = cbTimeout;
   const _timelyBidders = new Set();
+  const done = defer();
   let _bidsRejected = [];
   let _callback = callback;
   let _bidderRequests = [];
@@ -193,7 +194,6 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
     if (cleartimer) {
       clearTimeout(_timer);
     }
-
     if (_auctionEnd === undefined) {
       let timedOutBidders = [];
       if (timedOut) {
@@ -209,6 +209,7 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
       metrics.checkpoint('auctionEnd');
       metrics.timeBetween('requestBids', 'auctionEnd', 'requestBids.total');
       metrics.timeBetween('callBids', 'auctionEnd', 'requestBids.callBids');
+      done.resolve();
 
       events.emit(CONSTANTS.EVENTS.AUCTION_END, getProperties());
       bidsBackCallback(_adUnits, function () {
@@ -392,6 +393,7 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
     setBidTargeting,
     getWinningBids: () => _winningBids,
     getAuctionStart: () => _auctionStart,
+    getAuctionEnd: () => _auctionEnd,
     getTimeout: () => _timeout,
     getAuctionId: () => _auctionId,
     getAuctionStatus: () => _auctionStatus,
@@ -403,6 +405,7 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
     getNonBids: () => _nonBids,
     getFPD: () => ortb2Fragments,
     getMetrics: () => metrics,
+    end: done.promise
   };
 }
 
diff --git a/src/auctionManager.js b/src/auctionManager.js
index 90d5fb543e2..498c200ba21 100644
--- a/src/auctionManager.js
+++ b/src/auctionManager.js
@@ -19,12 +19,16 @@
  * @property {function(): void} clearAllAuctions - clear all auctions for testing
  */
 
-import { uniques, flatten, logWarn } from './utils.js';
+import { uniques, logWarn } from './utils.js';
 import { newAuction, getStandardBidderSettings, AUCTION_COMPLETED } from './auction.js';
-import {find} from './polyfill.js';
 import {AuctionIndex} from './auctionIndex.js';
 import CONSTANTS from './constants.json';
 import {useMetrics} from './utils/perfMetrics.js';
+import {ttlCollection} from './utils/ttlCollection.js';
+import {getTTL, onTTLBufferChange} from './bidTTL.js';
+import {config} from './config.js';
+
+const CACHE_TTL_SETTING = 'minBidCacheTTL';
 
 /**
  * Creates new instance of auctionManager. There will only be one instance of auctionManager but
@@ -33,15 +37,42 @@ import {useMetrics} from './utils/perfMetrics.js';
  * @returns {AuctionManager} auctionManagerInstance
  */
 export function newAuctionManager() {
-  const _auctions = [];
+  let minCacheTTL = null;
+
+  const _auctions = ttlCollection({
+    startTime: (au) => au.end.then(() => au.getAuctionEnd()),
+    ttl: (au) => minCacheTTL == null ? null : au.end.then(() => {
+      return Math.max(minCacheTTL, ...au.getBidsReceived().map(getTTL)) * 1000
+    }),
+  });
+
+  onTTLBufferChange(() => {
+    if (minCacheTTL != null) _auctions.refresh();
+  })
+
+  config.getConfig(CACHE_TTL_SETTING, (cfg) => {
+    const prev = minCacheTTL;
+    minCacheTTL = cfg?.[CACHE_TTL_SETTING];
+    minCacheTTL = typeof minCacheTTL === 'number' ? minCacheTTL : null;
+    if (prev !== minCacheTTL) {
+      _auctions.refresh();
+    }
+  })
+
   const auctionManager = {};
 
+  function getAuction(auctionId) {
+    for (const auction of _auctions) {
+      if (auction.getAuctionId() === auctionId) return auction;
+    }
+  }
+
   auctionManager.addWinningBid = function(bid) {
     const metrics = useMetrics(bid.metrics);
     metrics.checkpoint('bidWon');
     metrics.timeBetween('auctionEnd', 'bidWon', 'render.pending');
     metrics.timeBetween('requestBids', 'bidWon', 'render.e2e');
-    const auction = find(_auctions, auction => auction.getAuctionId() === bid.auctionId);
+    const auction = getAuction(bid.auctionId);
     if (auction) {
       bid.status = CONSTANTS.BID_STATUS.RENDERED;
       auction.addWinningBid(bid);
@@ -50,48 +81,44 @@ export function newAuctionManager() {
     }
   };
 
-  auctionManager.getAllWinningBids = function() {
-    return _auctions.map(auction => auction.getWinningBids())
-      .reduce(flatten, []);
-  };
-
-  auctionManager.getBidsRequested = function() {
-    return _auctions.map(auction => auction.getBidRequests())
-      .reduce(flatten, []);
-  };
-
-  auctionManager.getNoBids = function() {
-    return _auctions.map(auction => auction.getNoBids())
-      .reduce(flatten, []);
-  };
-
-  auctionManager.getBidsReceived = function() {
-    return _auctions.map((auction) => {
-      if (auction.getAuctionStatus() === AUCTION_COMPLETED) {
-        return auction.getBidsReceived();
+  Object.entries({
+    getAllWinningBids: {
+      name: 'getWinningBids',
+    },
+    getBidsRequested: {
+      name: 'getBidRequests'
+    },
+    getNoBids: {},
+    getAdUnits: {},
+    getBidsReceived: {
+      pre(auction) {
+        return auction.getAuctionStatus() === AUCTION_COMPLETED;
       }
-    }).reduce(flatten, [])
-      .filter(bid => bid);
-  };
+    },
+    getAdUnitCodes: {
+      post: uniques,
+    }
+  }).forEach(([mgrMethod, {name = mgrMethod, pre, post}]) => {
+    const mapper = pre == null
+      ? (auction) => auction[name]()
+      : (auction) => pre(auction) ? auction[name]() : [];
+    const filter = post == null
+      ? (items) => items
+      : (items) => items.filter(post)
+    auctionManager[mgrMethod] = () => {
+      return filter(_auctions.toArray().flatMap(mapper));
+    }
+  })
+
+  function allBidsReceived() {
+    return _auctions.toArray().flatMap(au => au.getBidsReceived())
+  }
 
   auctionManager.getAllBidsForAdUnitCode = function(adUnitCode) {
-    return _auctions.map((auction) => {
-      return auction.getBidsReceived();
-    }).reduce(flatten, [])
+    return allBidsReceived()
       .filter(bid => bid && bid.adUnitCode === adUnitCode)
   };
 
-  auctionManager.getAdUnits = function() {
-    return _auctions.map(auction => auction.getAdUnits())
-      .reduce(flatten, []);
-  };
-
-  auctionManager.getAdUnitCodes = function() {
-    return _auctions.map(auction => auction.getAdUnitCodes())
-      .reduce(flatten, [])
-      .filter(uniques);
-  };
-
   auctionManager.createAuction = function(opts) {
     const auction = newAuction(opts);
     _addAuction(auction);
@@ -99,7 +126,8 @@ export function newAuctionManager() {
   };
 
   auctionManager.findBidByAdId = function(adId) {
-    return find(_auctions.map(auction => auction.getBidsReceived()).reduce(flatten, []), bid => bid.adId === adId);
+    return allBidsReceived()
+      .find(bid => bid.adId === adId);
   };
 
   auctionManager.getStandardBidderAdServerTargeting = function() {
@@ -111,24 +139,25 @@ export function newAuctionManager() {
     if (bid) bid.status = status;
 
     if (bid && status === CONSTANTS.BID_STATUS.BID_TARGETING_SET) {
-      const auction = find(_auctions, auction => auction.getAuctionId() === bid.auctionId);
+      const auction = getAuction(bid.auctionId);
       if (auction) auction.setBidTargeting(bid);
     }
   }
 
   auctionManager.getLastAuctionId = function() {
-    return _auctions.length && _auctions[_auctions.length - 1].getAuctionId()
+    const auctions = _auctions.toArray();
+    return auctions.length && auctions[auctions.length - 1].getAuctionId()
   };
 
   auctionManager.clearAllAuctions = function() {
-    _auctions.length = 0;
+    _auctions.clear();
   }
 
   function _addAuction(auction) {
-    _auctions.push(auction);
+    _auctions.add(auction);
   }
 
-  auctionManager.index = new AuctionIndex(() => _auctions);
+  auctionManager.index = new AuctionIndex(() => _auctions.toArray());
 
   return auctionManager;
 }
diff --git a/src/bidTTL.js b/src/bidTTL.js
new file mode 100644
index 00000000000..55ba0c026b0
--- /dev/null
+++ b/src/bidTTL.js
@@ -0,0 +1,25 @@
+import {config} from './config.js';
+import {logError} from './utils.js';
+let TTL_BUFFER = 1;
+
+const listeners = [];
+
+config.getConfig('ttlBuffer', (cfg) => {
+  if (typeof cfg.ttlBuffer === 'number') {
+    const prev = TTL_BUFFER;
+    TTL_BUFFER = cfg.ttlBuffer;
+    if (prev !== TTL_BUFFER) {
+      listeners.forEach(l => l(TTL_BUFFER))
+    }
+  } else {
+    logError('Invalid value for ttlBuffer', cfg.ttlBuffer);
+  }
+})
+
+export function getTTL(bid) {
+  return bid.ttl - (bid.hasOwnProperty('ttlBuffer') ? bid.ttlBuffer : TTL_BUFFER);
+}
+
+export function onTTLBufferChange(listener) {
+  listeners.push(listener);
+}
diff --git a/src/events.js b/src/events.js
index 62f8c070deb..bea5d4ee4d9 100644
--- a/src/events.js
+++ b/src/events.js
@@ -3,23 +3,38 @@
  */
 import * as utils from './utils.js'
 import CONSTANTS from './constants.json';
+import {ttlCollection} from './utils/ttlCollection.js';
+import {config} from './config.js';
+const TTL_CONFIG = 'eventHistoryTTL';
 
-var slice = Array.prototype.slice;
-var push = Array.prototype.push;
+let eventTTL = null;
 
-// define entire events
-// var allEvents = ['bidRequested','bidResponse','bidWon','bidTimeout'];
-var allEvents = utils._map(CONSTANTS.EVENTS, function (v) {
-  return v;
+// keep a record of all events fired
+const eventsFired = ttlCollection({
+  monotonic: true,
+  ttl: () => eventTTL,
+})
+
+config.getConfig(TTL_CONFIG, (val) => {
+  const previous = eventTTL;
+  val = val?.[TTL_CONFIG];
+  eventTTL = typeof val === 'number' ? val * 1000 : null;
+  if (previous !== eventTTL) {
+    eventsFired.refresh();
+  }
 });
 
-var idPaths = CONSTANTS.EVENT_ID_PATHS;
+let slice = Array.prototype.slice;
+let push = Array.prototype.push;
+
+// define entire events
+let allEvents = Object.values(CONSTANTS.EVENTS);
+
+const idPaths = CONSTANTS.EVENT_ID_PATHS;
 
-// keep a record of all events fired
-var eventsFired = [];
 const _public = (function () {
-  var _handlers = {};
-  var _public = {};
+  let _handlers = {};
+  let _public = {};
 
   /**
    *
@@ -30,18 +45,18 @@ const _public = (function () {
   function _dispatch(eventString, args) {
     utils.logMessage('Emitting event for: ' + eventString);
 
-    var eventPayload = args[0] || {};
-    var idPath = idPaths[eventString];
-    var key = eventPayload[idPath];
-    var event = _handlers[eventString] || { que: [] };
-    var eventKeys = utils._map(event, function (v, k) {
+    let eventPayload = args[0] || {};
+    let idPath = idPaths[eventString];
+    let key = eventPayload[idPath];
+    let event = _handlers[eventString] || { que: [] };
+    let eventKeys = utils._map(event, function (v, k) {
       return k;
     });
 
-    var callbacks = [];
+    let callbacks = [];
 
     // record the event:
-    eventsFired.push({
+    eventsFired.add({
       eventType: eventString,
       args: eventPayload,
       id: key,
@@ -79,7 +94,7 @@ const _public = (function () {
   _public.on = function (eventString, handler, id) {
     // check whether available event or not
     if (_checkAvailableEvent(eventString)) {
-      var event = _handlers[eventString] || { que: [] };
+      let event = _handlers[eventString] || { que: [] };
 
       if (id) {
         event[id] = event[id] || { que: [] };
@@ -95,12 +110,12 @@ const _public = (function () {
   };
 
   _public.emit = function (event) {
-    var args = slice.call(arguments, 1);
+    let args = slice.call(arguments, 1);
     _dispatch(event, args);
   };
 
   _public.off = function (eventString, handler, id) {
-    var event = _handlers[eventString];
+    let event = _handlers[eventString];
 
     if (utils.isEmpty(event) || (utils.isEmpty(event.que) && utils.isEmpty(event[id]))) {
       return;
@@ -112,14 +127,14 @@ const _public = (function () {
 
     if (id) {
       utils._each(event[id].que, function (_handler) {
-        var que = event[id].que;
+        let que = event[id].que;
         if (_handler === handler) {
           que.splice(que.indexOf(_handler), 1);
         }
       });
     } else {
       utils._each(event.que, function (_handler) {
-        var que = event.que;
+        let que = event.que;
         if (_handler === handler) {
           que.splice(que.indexOf(_handler), 1);
         }
@@ -142,13 +157,7 @@ const _public = (function () {
    * @return {Array} array of events fired
    */
   _public.getEvents = function () {
-    var arrayCopy = [];
-    utils._each(eventsFired, function (value) {
-      var newProp = Object.assign({}, value);
-      arrayCopy.push(newProp);
-    });
-
-    return arrayCopy;
+    return eventsFired.toArray().map(val => Object.assign({}, val))
   };
 
   return _public;
@@ -159,5 +168,5 @@ utils._setEventEmitter(_public.emit.bind(_public));
 export const {on, off, get, getEvents, emit, addEvents} = _public;
 
 export function clearEvents() {
-  eventsFired.length = 0;
+  eventsFired.clear();
 }
diff --git a/src/prebid.js b/src/prebid.js
index 94ade8e5f83..5c5f66d6028 100644
--- a/src/prebid.js
+++ b/src/prebid.js
@@ -52,6 +52,7 @@ import {newMetrics, useMetrics} from './utils/perfMetrics.js';
 import {defer, GreedyPromise} from './utils/promise.js';
 import {enrichFPD} from './fpd/enrichment.js';
 import {allConsent} from './consentHandler.js';
+import {fillVideoDefaults} from './video.js';
 
 const pbjsInstance = getGlobal();
 const { triggerUserSyncs } = userSync;
@@ -269,6 +270,12 @@ export const checkAdUnitSetup = hook('sync', function (adUnits) {
   return validatedAdUnits;
 }, 'checkAdUnitSetup');
 
+function fillAdUnitDefaults(adUnits) {
+  if (FEATURES.VIDEO) {
+    adUnits.forEach(au => fillVideoDefaults(au))
+  }
+}
+
 /// ///////////////////////////////
 //                              //
 //    Start Public APIs         //
@@ -658,6 +665,7 @@ pbjsInstance.requestBids = (function() {
 
 export const startAuction = hook('async', function ({ bidsBackHandler, timeout: cbTimeout, adUnits, ttlBuffer, adUnitCodes, labels, auctionId, ortb2Fragments, metrics, defer } = {}) {
   const s2sBidders = getS2SBidderSet(config.getConfig('s2sConfig') || []);
+  fillAdUnitDefaults(adUnits);
   adUnits = useMetrics(metrics).measureTime('requestBids.validate', () => checkAdUnitSetup(adUnits));
 
   function auctionDone(bids, timedOut, auctionId) {
diff --git a/src/targeting.js b/src/targeting.js
index a75c9a2b52f..ed313c55684 100644
--- a/src/targeting.js
+++ b/src/targeting.js
@@ -24,19 +24,11 @@ import {hook} from './hook.js';
 import {bidderSettings} from './bidderSettings.js';
 import {find, includes} from './polyfill.js';
 import CONSTANTS from './constants.json';
+import {getTTL} from './bidTTL.js';
 
 var pbTargetingKeys = [];
 
 const MAX_DFP_KEYLENGTH = 20;
-let DEFAULT_TTL_BUFFER = 1;
-
-config.getConfig('ttlBuffer', (cfg) => {
-  if (typeof cfg.ttlBuffer === 'number') {
-    DEFAULT_TTL_BUFFER = cfg.ttlBuffer;
-  } else {
-    logError('Invalid value for ttlBuffer', cfg.ttlBuffer);
-  }
-})
 
 const CFG_ALLOW_TARGETING_KEYS = `targetingControls.allowTargetingKeys`;
 const CFG_ADD_TARGETING_KEYS = `targetingControls.addTargetingKeys`;
@@ -47,7 +39,7 @@ export const TARGETING_KEYS = Object.keys(CONSTANTS.TARGETING_KEYS).map(
 );
 
 // return unexpired bids
-const isBidNotExpired = (bid) => (bid.responseTimestamp + (bid.ttl - (bid.hasOwnProperty('ttlBuffer') ? bid.ttlBuffer : DEFAULT_TTL_BUFFER)) * 1000) > timestamp();
+const isBidNotExpired = (bid) => (bid.responseTimestamp + getTTL(bid) * 1000) > timestamp();
 
 // return bids whose status is not set. Winning bids can only have a status of `rendered`.
 const isUnusedBid = (bid) => bid && ((bid.status && !includes([CONSTANTS.BID_STATUS.RENDERED], bid.status)) || !bid.status);
diff --git a/src/utils.js b/src/utils.js
index ece29732723..2ce4f9cc8bb 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -1408,3 +1408,31 @@ export const escapeUnsafeChars = (() => {
     return str.replace(/[<>\b\f\n\r\t\0\u2028\u2029\\]/g, x => escapes[x])
   }
 })();
+
+/**
+ * Perform a binary search for `el` on an ordered array `arr`.
+ *
+ * @returns the lowest nonnegative integer I that satisfies:
+ *   key(arr[i]) >= key(el) for each i between I and arr.length
+ *
+ *   (if one or more matches are found for `el`, returns the index of the first;
+ *   if the element is not found, return the index of the first element that's greater;
+ *   if no greater element exists, return `arr.length`)
+ */
+export function binarySearch(arr, el, key = (el) => el) {
+  let left = 0;
+  let right = arr.length && arr.length - 1;
+  const target = key(el);
+  while (right - left > 1) {
+    const middle = left + Math.round((right - left) / 2);
+    if (target > key(arr[middle])) {
+      left = middle;
+    } else {
+      right = middle;
+    }
+  }
+  while (arr.length > left && target > key(arr[left])) {
+    left++;
+  }
+  return left;
+}
diff --git a/src/utils/ttlCollection.js b/src/utils/ttlCollection.js
new file mode 100644
index 00000000000..392ed1c9ad7
--- /dev/null
+++ b/src/utils/ttlCollection.js
@@ -0,0 +1,139 @@
+import {GreedyPromise} from './promise.js';
+import {binarySearch, timestamp} from '../utils.js';
+
+/**
+ * Create a set-like collection that automatically forgets items after a certain time.
+ *
+ * @param {({}) => Number|Promise<Number>} startTime? a function taking an item added to this collection,
+ *   and returning (a promise to) a timestamp to be used as the starting time for the item
+ *   (the item will be dropped after `ttl(item)` milliseconds have elapsed since this timestamp).
+ *   Defaults to the time the item was added to the collection.
+ * @param {({}) => Number|void|Promise<Number|void>} ttl a function taking an item added to this collection,
+ *   and returning (a promise to) the duration (in milliseconds) the item should be kept in it.
+ *   May return null to indicate that the item should be persisted indefinitely.
+ * @param {boolean} monotonic? set to true for better performance, but only if, given any two items A and B in this collection:
+ *   if A was added before B, then:
+ *     - startTime(A) + ttl(A) <= startTime(B) + ttl(B)
+ *     - Promise.all([startTime(A), ttl(A)]) never resolves later than Promise.all([startTime(B), ttl(B)])
+ * @param {number} slack? maximum duration (in milliseconds) that an item is allowed to persist
+ *   once past its TTL. This is also roughly the interval between "garbage collection" sweeps.
+ */
+export function ttlCollection(
+  {
+    startTime = timestamp,
+    ttl = () => null,
+    monotonic = false,
+    slack = 5000
+  } = {}
+) {
+  const items = new Map();
+  const pendingPurge = [];
+  const markForPurge = monotonic
+    ? (entry) => pendingPurge.push(entry)
+    : (entry) => pendingPurge.splice(binarySearch(pendingPurge, entry, (el) => el.expiry), 0, entry)
+  let nextPurge, task;
+
+  function reschedulePurge() {
+    task && clearTimeout(task);
+    if (pendingPurge.length > 0) {
+      const now = timestamp();
+      nextPurge = Math.max(now, pendingPurge[0].expiry + slack);
+      task = setTimeout(() => {
+        const now = timestamp();
+        let cnt = 0;
+        for (const entry of pendingPurge) {
+          if (entry.expiry > now) break;
+          items.delete(entry.item)
+          cnt++;
+        }
+        pendingPurge.splice(0, cnt);
+        task = null;
+        reschedulePurge();
+      }, nextPurge - now);
+    } else {
+      task = null;
+    }
+  }
+
+  function mkEntry(item) {
+    const values = {};
+    const thisCohort = currentCohort;
+    let expiry;
+
+    function update() {
+      if (thisCohort === currentCohort && values.start != null && values.delta != null) {
+        expiry = values.start + values.delta;
+        markForPurge(entry);
+        if (task == null || nextPurge > expiry + slack) {
+          reschedulePurge();
+        }
+      }
+    }
+
+    const [init, refresh] = Object.entries({
+      start: startTime,
+      delta: ttl
+    }).map(([field, getter]) => {
+      let currentCall;
+      return function() {
+        const thisCall = currentCall = {};
+        GreedyPromise.resolve(getter(item)).then((val) => {
+          if (thisCall === currentCall) {
+            values[field] = val;
+            update();
+          }
+        });
+      }
+    })
+
+    const entry = {
+      item,
+      refresh,
+      get expiry() {
+        return expiry;
+      },
+    };
+
+    init();
+    refresh();
+    return entry;
+  }
+
+  let currentCohort = {};
+
+  return {
+    [Symbol.iterator]: () => items.keys(),
+    /**
+     * Add an item to this collection.
+     * @param item
+     */
+    add(item) {
+      !items.has(item) && items.set(item, mkEntry(item));
+    },
+    /**
+     * Clear this collection.
+     */
+    clear() {
+      pendingPurge.length = 0;
+      reschedulePurge();
+      items.clear();
+      currentCohort = {};
+    },
+    /**
+     * @returns {[]} all the items in this collection, in insertion order.
+     */
+    toArray() {
+      return Array.from(items.keys());
+    },
+    /**
+     * Refresh the TTL for each item in this collection.
+     */
+    refresh() {
+      pendingPurge.length = 0;
+      reschedulePurge();
+      for (const entry of items.values()) {
+        entry.refresh();
+      }
+    },
+  };
+}
diff --git a/src/video.js b/src/video.js
index 7930e318874..ff137892a2b 100644
--- a/src/video.js
+++ b/src/video.js
@@ -1,25 +1,21 @@
-import adapterManager from './adapterManager.js';
-import { deepAccess, logError } from './utils.js';
-import { config } from '../src/config.js';
-import {includes} from './polyfill.js';
-import { hook } from './hook.js';
+import {deepAccess, logError} from './utils.js';
+import {config} from '../src/config.js';
+import {hook} from './hook.js';
 import {auctionManager} from './auctionManager.js';
 
-const VIDEO_MEDIA_TYPE = 'video';
 export const OUTSTREAM = 'outstream';
 export const INSTREAM = 'instream';
 
-/**
- * Helper functions for working with video-enabled adUnits
- */
-export const videoAdUnit = adUnit => {
-  const mediaType = adUnit.mediaType === VIDEO_MEDIA_TYPE;
-  const mediaTypes = deepAccess(adUnit, 'mediaTypes.video');
-  return mediaType || mediaTypes;
-};
-export const videoBidder = bid => includes(adapterManager.videoAdapters, bid.bidder);
-export const hasNonVideoBidder = adUnit =>
-  adUnit.bids.filter(bid => !videoBidder(bid)).length;
+export function fillVideoDefaults(adUnit) {
+  const video = adUnit?.mediaTypes?.video;
+  if (video != null && video.plcmt == null) {
+    if (video.context === OUTSTREAM || [2, 3, 4].includes(video.placement)) {
+      video.plcmt = 4;
+    } else if (video.context !== OUTSTREAM && [2, 6].includes(video.playbackmethod)) {
+      video.plcmt = 2;
+    }
+  }
+}
 
 /**
  * @typedef {object} VideoBid
diff --git a/test/spec/auctionmanager_spec.js b/test/spec/auctionmanager_spec.js
index 4061e757d97..d8598dc2063 100644
--- a/test/spec/auctionmanager_spec.js
+++ b/test/spec/auctionmanager_spec.js
@@ -763,9 +763,10 @@ describe('auctionmanager.js', function () {
   });
 
   describe('createAuction', () => {
-    let adUnits, stubMakeBidRequests, stubCallAdapters
+    let adUnits, stubMakeBidRequests, stubCallAdapters, bids;
 
     beforeEach(() => {
+      bids = [];
       stubMakeBidRequests = sinon.stub(adapterManager, 'makeBidRequests').returns([{
         bidderCode: BIDDER_CODE,
         bids: [{
@@ -773,6 +774,7 @@ describe('auctionmanager.js', function () {
         }]
       }]);
       stubCallAdapters = sinon.stub(adapterManager, 'callBids').callsFake((au, reqs, addBid, done) => {
+        bids.forEach(bid => addBid(bid.adUnitCode, bid));
         reqs.forEach(r => done.apply(r));
       });
       adUnits = [{
@@ -787,6 +789,7 @@ describe('auctionmanager.js', function () {
     afterEach(() => {
       stubMakeBidRequests.restore();
       stubCallAdapters.restore();
+      auctionManager.clearAllAuctions();
     });
 
     it('passes global and bidder ortb2 to the auction', () => {
@@ -814,6 +817,79 @@ describe('auctionmanager.js', function () {
       });
       expect(auction.getNonBids()[0]).to.equal('test');
     });
+
+    describe('stale auctions', () => {
+      let clock, auction;
+      beforeEach(() => {
+        clock = sinon.useFakeTimers();
+        auction = auctionManager.createAuction({adUnits});
+        indexAuctions.push(auction);
+      });
+      afterEach(() => {
+        clock.restore();
+        config.resetConfig();
+      });
+
+      it('are dropped after their last bid becomes stale (if minBidCacheTTL is set)', () => {
+        config.setConfig({
+          minBidCacheTTL: 0
+        });
+        bids = [
+          {
+            adUnitCode: ADUNIT_CODE,
+            transactionId: ADUNIT_CODE,
+            ttl: 10
+          }, {
+            adUnitCode: ADUNIT_CODE,
+            transactionId: ADUNIT_CODE,
+            ttl: 100
+          }
+        ];
+        auction.callBids();
+        return auction.end.then(() => {
+          clock.tick(50 * 1000);
+          expect(auctionManager.getBidsReceived().length).to.equal(2);
+          clock.tick(56 * 1000);
+          expect(auctionManager.getBidsReceived()).to.eql([]);
+        });
+      });
+
+      it('are dropped after `minBidCacheTTL` seconds if they had no bid', () => {
+        auction.callBids();
+        config.setConfig({
+          minBidCacheTTL: 2
+        });
+        return auction.end.then(() => {
+          expect(auctionManager.getNoBids().length).to.eql(1);
+          clock.tick(10 * 10000);
+          expect(auctionManager.getNoBids().length).to.eql(0);
+        })
+      });
+
+      Object.entries({
+        'bids': {
+          bd: [{
+            adUnitCode: ADUNIT_CODE,
+            transactionId: ADUNIT_CODE,
+            ttl: 10
+          }],
+          entries: () => auctionManager.getBidsReceived()
+        },
+        'no bids': {
+          bd: [],
+          entries: () => auctionManager.getNoBids()
+        }
+      }).forEach(([t, {bd, entries}]) => {
+        it(`with ${t} are never dropped if minBidCacheTTL is not set`, () => {
+          bids = bd;
+          auction.callBids();
+          return auction.end.then(() => {
+            clock.tick(100 * 1000);
+            expect(entries().length > 0).to.be.true;
+          })
+        })
+      });
+    })
   });
 
   describe('addBidResponse #1', function () {
@@ -1024,36 +1100,47 @@ describe('auctionmanager.js', function () {
         assert.strictEqual(addedBid.renderer.url, myBid.renderer.url);
       });
 
-      it('bid for a regular unit and a video unit', function() {
-        let renderer = {
-          url: 'renderer.js',
-          render: (bid) => bid
-        };
-        Object.assign(adUnits[0], {renderer});
-        // make sure that if the renderer is only on the second ad unit, prebid
-        // still correctly uses it
-        let bid = mockBid();
-        let bidRequests = [mockBidRequest(bid, {auctionId: auction.getAuctionId()})];
-
-        bidRequests[0].bids[1] = Object.assign({
-          bidId: utils.getUniqueIdentifierStr()
-        }, bidRequests[0].bids[0]);
-        Object.assign(bidRequests[0].bids[0], {
-          adUnitCode: ADUNIT_CODE1,
-          transactionId: ADUNIT_CODE1,
-        });
+      describe('bid for a regular unit and a video unit', () => {
+        beforeEach(() => {
+          const renderer = {
+            url: 'renderer.js',
+            render: (bid) => bid
+          };
+          Object.assign(adUnits[0], {renderer});
+          // make sure that if the renderer is only on the second ad unit, prebid
+          // still correctly uses it
+          let bid = mockBid();
+          let bidRequests = [mockBidRequest(bid, {auctionId: auction.getAuctionId()})];
+
+          bidRequests[0].bids[1] = Object.assign({
+            bidId: utils.getUniqueIdentifierStr()
+          }, bidRequests[0].bids[0]);
+          Object.assign(bidRequests[0].bids[0], {
+            adUnitCode: ADUNIT_CODE1,
+            transactionId: ADUNIT_CODE1,
+          });
 
-        makeRequestsStub.returns(bidRequests);
+          makeRequestsStub.returns(bidRequests);
 
-        // this should correspond with the second bid in the bidReq because of the ad unit code
-        bid.mediaType = 'video-outstream';
-        spec.interpretResponse.returns(bid);
+          // this should correspond with the second bid in the bidReq because of the ad unit code
+          bid.mediaType = 'video-outstream';
+          spec.interpretResponse.returns(bid);
+        });
 
-        auction.callBids();
+        it('should use renderers on bid response', () => {
+          auction.callBids();
 
-        const addedBid = find(auction.getBidsReceived(), bid => bid.adUnitCode == ADUNIT_CODE);
-        assert.equal(addedBid.renderer.url, 'renderer.js');
-      });
+          const addedBid = find(auction.getBidsReceived(), bid => bid.adUnitCode === ADUNIT_CODE);
+          assert.equal(addedBid.renderer.url, 'renderer.js');
+        });
+
+        it('should resolve .end', () => {
+          auction.callBids();
+          return auction.end.then(() => {
+            expect(auction.getBidsReceived().length).to.eql(1);
+          })
+        })
+      })
 
       it('sets bidResponse.ttlBuffer from adUnit.ttlBuffer', () => {
         adUnits[0].ttlBuffer = 0;
@@ -1087,15 +1174,33 @@ describe('auctionmanager.js', function () {
         events.emit.restore();
       });
 
+      function respondToRequest(requestIndex) {
+        server.requests[requestIndex].respond(200, {}, 'response body');
+      }
+
+      it('resolves .end on timeout', (done) => {
+        registerBidder(mockBidder(BIDDER_CODE, [bids[0]]));
+        registerBidder(mockBidder(BIDDER_CODE1, [bids[1]]));
+        let endResolved = false;
+        function callback() {
+          expect(endResolved).to.be.true;
+          done()
+        }
+        auction = auctionModule.newAuction({adUnits, adUnitCodes, callback, cbTimeout: 20});
+        setupBids(auction.getAuctionId());
+        auction.callBids();
+        respondToRequest(0);
+        auction.end.then(() => {
+          endResolved = true;
+        })
+      })
+
       it('should emit BID_TIMEOUT and AUCTION_END for timed out bids', function (done) {
         const spec1 = mockBidder(BIDDER_CODE, [bids[0]]);
         registerBidder(spec1);
         const spec2 = mockBidder(BIDDER_CODE1, [bids[1]]);
         registerBidder(spec2);
 
-        function respondToRequest(requestIndex) {
-          server.requests[requestIndex].respond(200, {}, 'response body');
-        }
         function auctionCallback() {
           const bidTimeoutCall = eventsEmitSpy.withArgs(CONSTANTS.EVENTS.BID_TIMEOUT).getCalls()[0];
           const timedOutBids = bidTimeoutCall.args[1];
@@ -1117,6 +1222,7 @@ describe('auctionmanager.js', function () {
         auction.callBids();
         respondToRequest(0);
       });
+
       it('should NOT emit BID_TIMEOUT when all bidders responded in time', function (done) {
         const spec1 = mockBidder(BIDDER_CODE, [bids[0]]);
         registerBidder(spec1);
@@ -1142,9 +1248,6 @@ describe('auctionmanager.js', function () {
         const spec2 = mockBidder(BIDDER_CODE1, []);
         registerBidder(spec2);
 
-        function respondToRequest(requestIndex) {
-          server.requests[requestIndex].respond(200, {}, 'response body');
-        }
         function auctionCallback() {
           const bidTimeoutCall = eventsEmitSpy.withArgs(CONSTANTS.EVENTS.BID_TIMEOUT).getCalls()[0];
           const timedOutBids = bidTimeoutCall.args[1];
diff --git a/test/spec/modules/adtelligentBidAdapter_spec.js b/test/spec/modules/adtelligentBidAdapter_spec.js
index e40828e6852..f271f638e98 100644
--- a/test/spec/modules/adtelligentBidAdapter_spec.js
+++ b/test/spec/modules/adtelligentBidAdapter_spec.js
@@ -11,16 +11,10 @@ const EXPECTED_ENDPOINTS = [
   'https://ghb.adtelligent.com/v2/auction/'
 ];
 const aliasEP = {
-  'appaloosa': 'https://ghb.hb.appaloosa.media/v2/auction/',
-  'appaloosa_publisherSuffix': 'https://ghb.hb.appaloosa.media/v2/auction/',
-  'onefiftytwomedia': 'https://ghb.ads.152media.com/v2/auction/',
-  'navelix': 'https://ghb.hb.navelix.com/v2/auction/',
-  'bidsxchange': 'https://ghb.hbd.bidsxchange.com/v2/auction/',
+  'janet_publisherSuffix': 'https://ghb.bidder.jmgads.com/v2/auction/',
   'streamkey': 'https://ghb.hb.streamkey.net/v2/auction/',
   'janet': 'https://ghb.bidder.jmgads.com/v2/auction/',
-  'pgam': 'https://ghb.pgamssp.com/v2/auction/',
   'ocm': 'https://ghb.cenarius.orangeclickmedia.com/v2/auction/',
-  'vidcrunchllc': 'https://ghb.platform.vidcrunch.com/v2/auction/',
   '9dotsmedia': 'https://ghb.platform.audiodots.com/v2/auction/',
   'copper6': 'https://ghb.app.copper6.com/v2/auction/',
 };
diff --git a/test/spec/modules/boldwinBidAdapter_spec.js b/test/spec/modules/boldwinBidAdapter_spec.js
index 5b51183ea6d..52a6ec03757 100644
--- a/test/spec/modules/boldwinBidAdapter_spec.js
+++ b/test/spec/modules/boldwinBidAdapter_spec.js
@@ -19,7 +19,8 @@ describe('BoldwinBidAdapter', function () {
   const bidderRequest = {
     refererInfo: {
       referer: 'test.com'
-    }
+    },
+    ortb2: {}
   };
 
   describe('isBidRequestValid', function () {
@@ -110,6 +111,36 @@ describe('BoldwinBidAdapter', function () {
       expect(data.placements).to.be.an('array').that.is.empty;
     });
   });
+
+  describe('gpp consent', function () {
+    it('bidderRequest.gppConsent', () => {
+      bidderRequest.gppConsent = {
+        gppString: 'abc123',
+        applicableSections: [8]
+      };
+
+      let serverRequest = spec.buildRequests([bid], bidderRequest);
+      let data = serverRequest.data;
+      expect(data).to.be.an('object');
+      expect(data).to.have.property('gpp');
+      expect(data).to.have.property('gpp_sid');
+
+      delete bidderRequest.gppConsent;
+    })
+
+    it('bidderRequest.ortb2.regs.gpp', () => {
+      bidderRequest.ortb2.regs = bidderRequest.ortb2.regs || {};
+      bidderRequest.ortb2.regs.gpp = 'abc123';
+      bidderRequest.ortb2.regs.gpp_sid = [8];
+
+      let serverRequest = spec.buildRequests([bid], bidderRequest);
+      let data = serverRequest.data;
+      expect(data).to.be.an('object');
+      expect(data).to.have.property('gpp');
+      expect(data).to.have.property('gpp_sid');
+    })
+  });
+
   describe('interpretResponse', function () {
     it('Should interpret banner response', function () {
       const banner = {
diff --git a/test/spec/modules/cadentApertureMXBidAdapter_spec.js b/test/spec/modules/cadentApertureMXBidAdapter_spec.js
index 64f3d047a3a..202659641f9 100644
--- a/test/spec/modules/cadentApertureMXBidAdapter_spec.js
+++ b/test/spec/modules/cadentApertureMXBidAdapter_spec.js
@@ -834,5 +834,38 @@ describe('cadent_aperture_mx Adapter', function () {
       expect(syncs[0].url).to.contains('usp=test');
       expect(syncs[0].url).to.equal('https://biddr.brealtime.com/check.html?gdpr=1&gdpr_consent=test&usp=test')
     });
+
+    it('should pass gpp string and section id', function() {
+      let syncs = spec.getUserSyncs({iframeEnabled: true}, {}, {}, {}, {
+        gppString: 'abcdefgs',
+        applicableSections: [1, 2, 4]
+      });
+      expect(syncs).to.not.be.an('undefined');
+      expect(syncs[0].url).to.contains('gpp=abcdefgs')
+      expect(syncs[0].url).to.contains('gpp_sid=1,2,4')
+    });
+
+    it('should pass us_privacy and gdpr string and gpp string', function () {
+      let syncs = spec.getUserSyncs({ iframeEnabled: true }, {},
+        {
+          gdprApplies: true,
+          consentString: 'test'
+        },
+        {
+          consentString: 'test'
+        },
+        {
+          gppString: 'abcdefgs',
+          applicableSections: [1, 2, 4]
+        }
+      );
+      expect(syncs).to.not.be.an('undefined');
+      expect(syncs).to.have.lengthOf(1);
+      expect(syncs[0].type).to.equal('iframe');
+      expect(syncs[0].url).to.contains('gdpr=1');
+      expect(syncs[0].url).to.contains('usp=test');
+      expect(syncs[0].url).to.contains('gpp=abcdefgs');
+      expect(syncs[0].url).to.equal('https://biddr.brealtime.com/check.html?gdpr=1&gdpr_consent=test&usp=test&gpp=abcdefgs&gpp_sid=1,2,4');
+    });
   });
 });
diff --git a/test/spec/modules/consentManagementGpp_spec.js b/test/spec/modules/consentManagementGpp_spec.js
index e15ce30940c..99d4f94f502 100644
--- a/test/spec/modules/consentManagementGpp_spec.js
+++ b/test/spec/modules/consentManagementGpp_spec.js
@@ -572,6 +572,17 @@ describe('consentManagementGpp', function () {
           expect(err.message).to.eql('err');
           done();
         });
+      });
+
+      it('should not choke if supportedAPIs is missing', () => {
+        [gppData, pingData].forEach(ob => { delete ob.supportedAPIs; })
+        mockCmpCommands({
+          getGPPData: () => gppData
+        });
+        return gppClient.getGPPData(pingData).then(res => {
+          expect(res.gppString).to.eql(gppData.gppString);
+          expect(res.parsedSections).to.eql({});
+        })
       })
 
       describe('section data', () => {
diff --git a/test/spec/modules/experianRtdProvider_spec.js b/test/spec/modules/experianRtdProvider_spec.js
new file mode 100644
index 00000000000..fd104674d70
--- /dev/null
+++ b/test/spec/modules/experianRtdProvider_spec.js
@@ -0,0 +1,365 @@
+import {
+  EXPERIAN_RTID_DATA_KEY,
+  EXPERIAN_RTID_EXPIRATION_KEY,
+  EXPERIAN_RTID_STALE_KEY,
+  SUBMODULE_NAME,
+  experianRtdObj,
+  experianRtdSubmodule, EXPERIAN_RTID_NO_TRACK_KEY
+} from '../../../modules/experianRtdProvider.js';
+import { getStorageManager } from '../../../src/storageManager.js';
+import { MODULE_TYPE_RTD } from '../../../src/activities/modules';
+import { safeJSONParse, timestamp } from '../../../src/utils';
+import {server} from '../../mocks/xhr.js';
+
+describe('Experian realtime module', () => {
+  const sandbox = sinon.createSandbox();
+  let requests;
+
+  const storage = getStorageManager({ moduleType: MODULE_TYPE_RTD, moduleName: SUBMODULE_NAME })
+  beforeEach(() => {
+    requests = server.requests;
+    storage.removeDataFromLocalStorage(EXPERIAN_RTID_DATA_KEY, null)
+    storage.removeDataFromLocalStorage(EXPERIAN_RTID_EXPIRATION_KEY, null)
+    storage.removeDataFromLocalStorage(EXPERIAN_RTID_STALE_KEY, null)
+    storage.removeDataFromLocalStorage(EXPERIAN_RTID_NO_TRACK_KEY, null)
+  })
+  afterEach(() => {
+    sandbox.restore();
+  })
+  // Bid request config
+  const reqBidsConfigObj = {
+    adUnits: [{
+      bids: [
+        { bidder: 'appnexus' }
+      ]
+    }]
+  };
+  describe('init', () => {
+    it('succeeds when params have accountId', () => {
+      const initResult = experianRtdSubmodule.init({ params: { accountId: 'ZylatYg' } })
+      expect(initResult).to.be.true;
+    })
+
+    it('fails when params don\'t have accountId', () => {
+      const initResult = experianRtdSubmodule.init({ })
+      expect(initResult).to.be.false;
+    })
+  })
+
+  describe('getBidRequestData', () => {
+    describe('when local storage has data, isn\'t no track, isn\'t stale and isn\'t expired', () => {
+      beforeEach(() => {
+        const now = timestamp()
+        storage.setDataInLocalStorage(EXPERIAN_RTID_DATA_KEY, JSON.stringify([
+          {
+            bidder: 'pubmatic',
+            data: {
+              key: 'pubmatic-encryption-key-1',
+              data: 'IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg=='
+            }
+          },
+          {
+            bidder: 'sovrn',
+            data: {
+              key: 'sovrn-encryption-key-1',
+              data: 'IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg=='
+            }
+          }
+        ]), null)
+
+        storage.setDataInLocalStorage(EXPERIAN_RTID_EXPIRATION_KEY, new Date(now + 100000).toISOString(), null)
+        storage.setDataInLocalStorage(EXPERIAN_RTID_STALE_KEY, new Date(now + 50000).toISOString(), null)
+      })
+      it('doesn\'t request data envelope, and alters bids', () => {
+        const bidsConfig = {
+          ortb2Fragments: {
+            bidder: {}
+          }
+        }
+        const moduleConfig = { params: { accountId: 'ZylatYg', bidders: ['pubmatic', 'sovrn'] } }
+        const dataEnvelopeSpy = sandbox.spy(experianRtdObj, 'requestDataEnvelope')
+        const alterBidsSpy = sandbox.spy(experianRtdObj, 'alterBids')
+        experianRtdSubmodule.getBidRequestData(bidsConfig, sinon.stub, moduleConfig)
+        sandbox.assert.calledWithExactly(alterBidsSpy, bidsConfig, moduleConfig)
+        expect(dataEnvelopeSpy.called).to.be.false;
+      })
+    })
+
+    describe('when local storage has data but it is stale', () => {
+      beforeEach(() => {
+        const now = timestamp()
+        storage.setDataInLocalStorage(EXPERIAN_RTID_DATA_KEY, JSON.stringify([
+          {
+            bidder: 'pubmatic',
+            data: {
+              key: 'pubmatic-encryption-key-1',
+              data: 'IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg=='
+            }
+          },
+          {
+            bidder: 'sovrn',
+            data: {
+              key: 'sovrn-encryption-key-1',
+              data: 'IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg=='
+            }
+          }
+        ]), null)
+
+        storage.setDataInLocalStorage(EXPERIAN_RTID_EXPIRATION_KEY, new Date(now + 100000).toISOString(), null)
+        storage.setDataInLocalStorage(EXPERIAN_RTID_STALE_KEY, new Date(now - 50000).toISOString(), null)
+      })
+      it('it requests data envelope and alters bids', () => {
+        const bidsConfig = {
+          ortb2Fragments: {
+            bidder: {}
+          }
+        }
+        const userConsent = {gdpr: {}, uspConsent: {}}
+        const moduleConfig = { params: { accountId: 'ZylatYg', bidders: ['pubmatic', 'sovrn'] } }
+        const dataEnvelopeSpy = sandbox.spy(experianRtdObj, 'requestDataEnvelope')
+        const alterBidsSpy = sandbox.spy(experianRtdObj, 'alterBids')
+        experianRtdSubmodule.getBidRequestData(bidsConfig, sinon.stub, moduleConfig, userConsent)
+        sandbox.assert.calledWithExactly(alterBidsSpy, bidsConfig, moduleConfig)
+        sandbox.assert.calledWithExactly(dataEnvelopeSpy, moduleConfig, userConsent)
+      })
+    })
+    describe('when local storage has data but it is expired', () => {
+      beforeEach(() => {
+        const now = timestamp()
+        storage.setDataInLocalStorage(EXPERIAN_RTID_DATA_KEY, JSON.stringify([
+          {
+            bidder: 'pubmatic',
+            data: {
+              key: 'pubmatic-encryption-key-1',
+              data: 'IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg=='
+            }
+          },
+          {
+            bidder: 'sovrn',
+            data: {
+              key: 'sovrn-encryption-key-1',
+              data: 'IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg=='
+            }
+          }
+        ]), null)
+
+        storage.setDataInLocalStorage(EXPERIAN_RTID_EXPIRATION_KEY, new Date(now - 50000).toISOString(), null)
+        storage.setDataInLocalStorage(EXPERIAN_RTID_STALE_KEY, new Date(now - 100000).toISOString(), null)
+      })
+      it('requests data envelope, and doesn\'t alter bids', () => {
+        const bidsConfig = {
+          ortb2Fragments: {
+            bidder: {}
+          }
+        }
+        const userConsent = {gdpr: {}, uspConsent: {}}
+        const moduleConfig = { params: { accountId: 'ZylatYg', bidders: ['pubmatic', 'sovrn'] } }
+        const dataEnvelopeSpy = sandbox.spy(experianRtdObj, 'requestDataEnvelope')
+        const alterBidsSpy = sandbox.spy(experianRtdObj, 'alterBids')
+        experianRtdSubmodule.getBidRequestData(bidsConfig, sinon.stub, moduleConfig, userConsent)
+        sandbox.assert.calledWithExactly(dataEnvelopeSpy, moduleConfig, userConsent)
+        expect(alterBidsSpy.called).to.be.false;
+      })
+    })
+    describe('when local storage has no data envelope', () => {
+      it('requests data envelope, and doesn\'t alter bids', () => {
+        const bidsConfig = {
+          ortb2Fragments: {
+            bidder: {}
+          }
+        }
+        const userConsent = {gdpr: {}, uspConsent: {}}
+        const moduleConfig = { params: { accountId: 'ZylatYg', bidders: ['pubmatic', 'sovrn'] } }
+        const dataEnvelopeSpy = sandbox.spy(experianRtdObj, 'requestDataEnvelope')
+        const alterBidsSpy = sandbox.spy(experianRtdObj, 'alterBids')
+        experianRtdSubmodule.getBidRequestData(bidsConfig, sinon.stub, moduleConfig, userConsent)
+        sandbox.assert.calledWithExactly(dataEnvelopeSpy, moduleConfig, userConsent)
+        expect(alterBidsSpy.called).to.be.false;
+      })
+    })
+    describe('when local storage has no track and is expired', () => {
+      beforeEach(() => {
+        const now = timestamp()
+        storage.setDataInLocalStorage(EXPERIAN_RTID_NO_TRACK_KEY, 'no_track', null)
+
+        storage.setDataInLocalStorage(EXPERIAN_RTID_EXPIRATION_KEY, new Date(now - 50000).toISOString(), null)
+        storage.setDataInLocalStorage(EXPERIAN_RTID_STALE_KEY, new Date(now - 100000).toISOString(), null)
+      })
+      it('requests data envelope, and doesn\'t alter bids', () => {
+        const bidsConfig = {
+          ortb2Fragments: {
+            bidder: {}
+          }
+        }
+        const userConsent = {gdpr: {}, uspConsent: {}}
+        const moduleConfig = { params: { accountId: 'ZylatYg', bidders: ['pubmatic', 'sovrn'] } }
+        const dataEnvelopeSpy = sandbox.spy(experianRtdObj, 'requestDataEnvelope')
+        const alterBidsSpy = sandbox.spy(experianRtdObj, 'alterBids')
+        experianRtdSubmodule.getBidRequestData(bidsConfig, sinon.stub, moduleConfig, userConsent)
+        sandbox.assert.calledWithExactly(dataEnvelopeSpy, moduleConfig, userConsent)
+        expect(alterBidsSpy.called).to.be.false;
+      })
+    })
+
+    describe('when local storage has no track and is stale', () => {
+      beforeEach(() => {
+        const now = timestamp()
+        storage.setDataInLocalStorage(EXPERIAN_RTID_NO_TRACK_KEY, 'no_track', null)
+
+        storage.setDataInLocalStorage(EXPERIAN_RTID_EXPIRATION_KEY, new Date(now + 100000).toISOString(), null)
+        storage.setDataInLocalStorage(EXPERIAN_RTID_STALE_KEY, new Date(now - 50000).toISOString(), null)
+      })
+      it('requests data envelope, and doesn\'t alter bids', () => {
+        const bidsConfig = {
+          ortb2Fragments: {
+            bidder: {}
+          }
+        }
+        const userConsent = {gdpr: {}, uspConsent: {}}
+        const moduleConfig = { params: { accountId: 'ZylatYg', bidders: ['pubmatic', 'sovrn'] } }
+        const dataEnvelopeSpy = sandbox.spy(experianRtdObj, 'requestDataEnvelope')
+        const alterBidsSpy = sandbox.spy(experianRtdObj, 'alterBids')
+        experianRtdSubmodule.getBidRequestData(bidsConfig, sinon.stub, moduleConfig, userConsent)
+        sandbox.assert.calledWithExactly(dataEnvelopeSpy, moduleConfig, userConsent)
+        expect(alterBidsSpy.called).to.be.false;
+      })
+    })
+
+    describe('when local storage has no track and isn\'t expired or stale', () => {
+      beforeEach(() => {
+        const now = timestamp()
+        storage.setDataInLocalStorage(EXPERIAN_RTID_NO_TRACK_KEY, 'no_track', null)
+
+        storage.setDataInLocalStorage(EXPERIAN_RTID_EXPIRATION_KEY, new Date(now + 100000).toISOString(), null)
+        storage.setDataInLocalStorage(EXPERIAN_RTID_STALE_KEY, new Date(now + 50000).toISOString(), null)
+      })
+      it('doesn\'t alter bids and doesn\'t request data envelope', () => {
+        const bidsConfig = {
+          ortb2Fragments: {
+            bidder: {}
+          }
+        }
+        const userConsent = {gdpr: {}, uspConsent: {}}
+        const moduleConfig = { params: { accountId: 'ZylatYg', bidders: ['pubmatic', 'sovrn'] } }
+        const dataEnvelopeSpy = sandbox.spy(experianRtdObj, 'requestDataEnvelope')
+        const alterBidsSpy = sandbox.spy(experianRtdObj, 'alterBids')
+        experianRtdSubmodule.getBidRequestData(bidsConfig, sinon.stub, moduleConfig, userConsent)
+        expect(alterBidsSpy.called).to.be.false;
+        expect(dataEnvelopeSpy.called).to.be.false;
+      })
+    })
+  })
+
+  describe('alterBids', () => {
+    describe('data envelope has every bidder from config', () => {
+      beforeEach(() => {
+        const now = timestamp()
+        storage.setDataInLocalStorage(EXPERIAN_RTID_DATA_KEY, JSON.stringify([
+          {
+            bidder: 'pubmatic',
+            data: {
+              key: 'pubmatic-encryption-key-1',
+              data: 'IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg=='
+            }
+          },
+          {
+            bidder: 'sovrn',
+            data: {
+              key: 'sovrn-encryption-key-1',
+              data: 'IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg=='
+            }
+          }
+        ]), null)
+
+        storage.setDataInLocalStorage(EXPERIAN_RTID_EXPIRATION_KEY, new Date(now + 100000).toISOString(), null)
+        storage.setDataInLocalStorage(EXPERIAN_RTID_STALE_KEY, new Date(now + 50000).toISOString(), null)
+      })
+
+      it('alters bids for the bidders in the module config', () => {
+        const bidsConfig = {
+          ortb2Fragments: {
+            bidder: {}
+          }
+        }
+        const moduleConfig = { params: { accountId: 'ZylatYg', bidders: ['pubmatic'] } }
+        experianRtdObj.alterBids(bidsConfig, moduleConfig);
+        expect(bidsConfig.ortb2Fragments.bidder).to.deep.equal({pubmatic: {
+          experianRtidKey: 'pubmatic-encryption-key-1',
+          experianRtidData: 'IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg=='
+        }})
+      })
+    })
+    describe('data envelope is missing bidders from config', () => {
+      beforeEach(() => {
+        const now = timestamp()
+        storage.setDataInLocalStorage(EXPERIAN_RTID_DATA_KEY, JSON.stringify([
+          {
+            bidder: 'sovrn',
+            data: {
+              key: 'sovrn-encryption-key-1',
+              data: 'IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg=='
+            }
+          }
+        ]), null)
+
+        storage.setDataInLocalStorage(EXPERIAN_RTID_EXPIRATION_KEY, new Date(now + 100000).toISOString(), null)
+        storage.setDataInLocalStorage(EXPERIAN_RTID_STALE_KEY, new Date(now + 50000).toISOString(), null)
+      })
+
+      it('alters bids for the bidders in the module config', () => {
+        const bidsConfig = {
+          ortb2Fragments: {
+            bidder: {}
+          }
+        }
+        const moduleConfig = { params: { accountId: 'ZylatYg', bidders: ['pubmatic', 'sovrn'] } }
+        experianRtdObj.alterBids(bidsConfig, moduleConfig);
+        expect(bidsConfig.ortb2Fragments.bidder).to.deep.equal({
+          sovrn: {
+            experianRtidKey: 'sovrn-encryption-key-1',
+            experianRtidData: 'IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg=='
+          }})
+      })
+    })
+  })
+
+  describe('requestDataEnvelope', () => {
+    it('sends request to experian rtd and stores response', () => {
+      const moduleConfig = { params: { accountId: 'ZylatYg', bidders: ['pubmatic', 'sovrn'] } }
+      experianRtdObj.requestDataEnvelope(moduleConfig, { gdpr: { gdprApplies: 0, consentString: 'wow' }, uspConsent: '1YYY' })
+      requests[0].respond(
+        200,
+        { 'Content-Type': 'application/json' },
+        '{"staleAt":"2023-06-01T00:00:00","expiresAt":"2023-06-03T00:00:00","status":"ok","data":[{"bidder":"pubmatic","data":{"key":"pubmatic-encryption-key-1","data":"IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg=="}},{"bidder":"sovrn","data":{"key":"sovrn-encryption-key-1","data":"IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg=="}}]}'
+      )
+
+      expect(requests[0].url).to.equal('https://rtid.tapad.com/acc/ZylatYg/ids?gdpr=0&gdpr_consent=wow&us_privacy=1YYY')
+      expect(safeJSONParse(storage.getDataFromLocalStorage(EXPERIAN_RTID_DATA_KEY, null))).to.deep.equal([{bidder: 'pubmatic', data: {key: 'pubmatic-encryption-key-1', data: 'IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg=='}}, {bidder: 'sovrn', data: {key: 'sovrn-encryption-key-1', data: 'IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg=='}}])
+      expect(storage.getDataFromLocalStorage(EXPERIAN_RTID_STALE_KEY)).to.equal('2023-06-01T00:00:00')
+      expect(storage.getDataFromLocalStorage(EXPERIAN_RTID_EXPIRATION_KEY)).to.equal('2023-06-03T00:00:00')
+    })
+  })
+
+  describe('extractConsentQueryString', () => {
+    describe('when userConsent is empty', () => {
+      it('returns undefined', () => {
+        expect(experianRtdObj.extractConsentQueryString({})).to.be.undefined
+      })
+    })
+
+    describe('when userConsent exists', () => {
+      it('builds query string', () => {
+        expect(
+          experianRtdObj.extractConsentQueryString({}, { gdpr: { gdprApplies: 1, consentString: 'this-is-something' }, uspConsent: '1YYY' })
+        ).to.equal('?gdpr=1&gdpr_consent=this-is-something&us_privacy=1YYY')
+      })
+    })
+
+    describe('when config.ids exists', () => {
+      it('builds query string', () => {
+        expect(experianRtdObj.extractConsentQueryString({ params: { accountId: 'ZylatYg', ids: { maid: ['424', '2982'], hem: 'my-hem' } } }, { gdpr: { gdprApplies: 1, consentString: 'this-is-something' }, uspConsent: '1YYY' }))
+          .to.equal('?gdpr=1&gdpr_consent=this-is-something&us_privacy=1YYY&id.maid=424&id.maid=2982&id.hem=my-hem')
+      })
+    })
+  })
+})
diff --git a/test/spec/modules/flippBidAdapter_spec.js b/test/spec/modules/flippBidAdapter_spec.js
new file mode 100644
index 00000000000..518052ad91e
--- /dev/null
+++ b/test/spec/modules/flippBidAdapter_spec.js
@@ -0,0 +1,170 @@
+import {expect} from 'chai';
+import {spec} from 'modules/flippBidAdapter';
+import {newBidder} from 'src/adapters/bidderFactory';
+const ENDPOINT = 'https://gateflipp.flippback.com/flyer-locator-service/client_bidding';
+describe('flippAdapter', function () {
+  const adapter = newBidder(spec);
+
+  describe('inherited functions', function () {
+    it('exists and is a function', function () {
+      expect(adapter.callBids).to.exist.and.to.be.a('function');
+    });
+  });
+
+  describe('isBidRequestValid', function () {
+    const bid = {
+      bidder: 'flipp',
+      params: {
+        publisherNameIdentifier: 'random',
+        siteId: 1234,
+        zoneIds: [1, 2, 3, 4],
+      }
+    };
+    it('should return true when required params found', function () {
+      expect(spec.isBidRequestValid(bid)).to.equal(true);
+    });
+
+    it('should return false when required params are not passed', function () {
+      let invalidBid = Object.assign({}, bid);
+      invalidBid.params = { siteId: 1234 }
+      expect(spec.isBidRequestValid(invalidBid)).to.equal(false);
+    });
+  });
+
+  describe('buildRequests', function () {
+    const bidRequests = [{
+      bidder: 'flipp',
+      params: {
+        siteId: 1234,
+      },
+      adUnitCode: '/10000/unit_code',
+      sizes: [[300, 600]],
+      mediaTypes: {banner: {sizes: [[300, 600]]}},
+      bidId: '237f4d1a293f99',
+      bidderRequestId: '1a857fa34c1c96',
+      auctionId: 'a297d1aa-7900-4ce4-a0aa-caa8d46c4af7',
+      transactionId: '00b2896c-2731-4f01-83e4-7a3ad5da13b6',
+    }];
+    const bidderRequest = {
+      refererInfo: {
+        referer: 'http://example.com'
+      }
+    };
+
+    it('sends bid request to ENDPOINT via POST', function () {
+      const request = spec.buildRequests(bidRequests, bidderRequest);
+      expect(request.method).to.equal('POST');
+    });
+
+    it('sends bid request to ENDPOINT with query parameter', function () {
+      const request = spec.buildRequests(bidRequests, bidderRequest);
+      expect(request.url).to.equal(ENDPOINT);
+    });
+  });
+
+  describe('interpretResponse', function() {
+    it('should get correct bid response', function() {
+      const bidRequest = {
+        method: 'POST',
+        url: ENDPOINT,
+        data: {
+          placements: [{
+            divName: 'slot',
+            networkId: 12345,
+            siteId: 12345,
+            adTypes: [12345],
+            count: 1,
+            prebid: {
+              requestId: '237f4d1a293f99',
+              publisherNameIdentifier: 'bid.params.publisherNameIdentifier',
+              height: 600,
+              width: 300,
+            },
+            user: '10462725-da61-4d3a-beff-6d05239e9a6e"',
+          }],
+          url: 'http://example.com',
+        },
+      };
+
+      const serverResponse = {
+        body: {
+          'decisions': {
+            'inline': [{
+              'bidCpm': 1,
+              'adId': 262838368,
+              'height': 600,
+              'width': 300,
+              'storefront': { 'flyer_id': 5435567 },
+              'prebid': {
+                'requestId': '237f4d1a293f99',
+                'cpm': 1.11,
+                'creative': 'Returned from server',
+              }
+            }]
+          },
+          'location': {'city': 'Oakville'},
+        },
+      };
+
+      const expectedResponse = [
+        {
+          bidderCode: 'flipp',
+          requestId: '237f4d1a293f99',
+          currency: 'USD',
+          cpm: 1.11,
+          netRevenue: true,
+          width: 300,
+          height: 600,
+          creativeId: 262838368,
+          ttl: 30,
+          ad: 'Returned from server',
+        }
+      ];
+
+      const result = spec.interpretResponse(serverResponse, bidRequest);
+      expect(result).to.have.lengthOf(1);
+      expect(result).to.deep.have.same.members(expectedResponse);
+    });
+
+    it('should get empty bid response when no ad is returned', function() {
+      const bidRequest = {
+        method: 'POST',
+        url: ENDPOINT,
+        data: {
+          placements: [{
+            divName: 'slot',
+            networkId: 12345,
+            siteId: 12345,
+            adTypes: [12345],
+            count: 1,
+            prebid: {
+              requestId: '237f4d1a293f99',
+              publisherNameIdentifier: 'bid.params.publisherNameIdentifier',
+              height: 600,
+              width: 300,
+            },
+            user: '10462725-da61-4d3a-beff-6d05239e9a6e"',
+          }],
+          url: 'http://example.com',
+        },
+      };
+
+      const serverResponse = {
+        body: {
+          'decisions': {
+            'inline': []
+          },
+          'location': {'city': 'Oakville'},
+        },
+      };
+
+      const result = spec.interpretResponse(serverResponse, bidRequest);
+      expect(result).to.have.lengthOf(0);
+      expect(result).to.deep.have.same.members([]);
+    })
+
+    it('should get empty response when bid server returns 204', function() {
+      expect(spec.interpretResponse({})).to.be.empty;
+    });
+  });
+});
diff --git a/test/spec/modules/freepassIdSystem_spec.js b/test/spec/modules/freepassIdSystem_spec.js
index f7407f5eb94..0a9fa956cd4 100644
--- a/test/spec/modules/freepassIdSystem_spec.js
+++ b/test/spec/modules/freepassIdSystem_spec.js
@@ -1,4 +1,4 @@
-import {freepassIdSubmodule} from 'modules/freepassIdSystem';
+import { freepassIdSubmodule, storage, FREEPASS_COOKIE_KEY } from 'modules/freepassIdSystem';
 import sinon from 'sinon';
 import * as utils from '../../../src/utils';
 
@@ -6,15 +6,16 @@ let expect = require('chai').expect;
 
 describe('FreePass ID System', function () {
   const UUID = '15fde1dc-1861-4894-afdf-b757272f3568';
+  let getCookieStub;
 
   before(function () {
-    sinon.stub(utils, 'generateUUID').returns(UUID);
     sinon.stub(utils, 'logMessage');
+    getCookieStub = sinon.stub(storage, 'getCookie');
   });
 
   after(function () {
-    utils.generateUUID.restore();
     utils.logMessage.restore();
+    getCookieStub.restore();
   });
 
   describe('freepassIdSubmodule', function () {
@@ -39,71 +40,19 @@ describe('FreePass ID System', function () {
     };
 
     it('should return an IdObject with a UUID', function () {
+      getCookieStub.withArgs(FREEPASS_COOKIE_KEY).returns(UUID);
       const objectId = freepassIdSubmodule.getId(config, undefined);
       expect(objectId).to.be.an('object');
       expect(objectId.id).to.be.an('object');
       expect(objectId.id.userId).to.equal(UUID);
     });
 
-    it('should include userIp in IdObject', function () {
+    it('should return an IdObject without UUID when absent in cookie', function () {
+      getCookieStub.withArgs(FREEPASS_COOKIE_KEY).returns(null);
       const objectId = freepassIdSubmodule.getId(config, undefined);
       expect(objectId).to.be.an('object');
       expect(objectId.id).to.be.an('object');
-      expect(objectId.id.userIp).to.equal('127.0.0.1');
-    });
-    it('should skip userIp in IdObject if not available', function () {
-      const localConfig = Object.assign({}, config);
-      delete localConfig.params.freepassData.userIp;
-      const objectId = freepassIdSubmodule.getId(localConfig, undefined);
-      expect(objectId).to.be.an('object');
-      expect(objectId.id).to.be.an('object');
-      expect(objectId.id.userIp).to.be.undefined;
-    });
-    it('should skip userIp in IdObject if freepassData is not available', function () {
-      const localConfig = JSON.parse(JSON.stringify(config));
-      delete localConfig.params.freepassData;
-      const objectId = freepassIdSubmodule.getId(localConfig, undefined);
-      expect(objectId).to.be.an('object');
-      expect(objectId.id).to.be.an('object');
-      expect(objectId.id.userIp).to.be.undefined;
-    });
-    it('should skip userIp in IdObject if params is not available', function () {
-      const localConfig = JSON.parse(JSON.stringify(config));
-      delete localConfig.params;
-      const objectId = freepassIdSubmodule.getId(localConfig, undefined);
-      expect(objectId).to.be.an('object');
-      expect(objectId.id).to.be.an('object');
-      expect(objectId.id.userIp).to.be.undefined;
-    });
-    it('should include commonId in IdObject', function () {
-      const objectId = freepassIdSubmodule.getId(config, undefined);
-      expect(objectId).to.be.an('object');
-      expect(objectId.id).to.be.an('object');
-      expect(objectId.id.commonId).to.equal('commonId');
-    });
-    it('should skip commonId in IdObject if not available', function () {
-      const localConfig = Object.assign({}, config);
-      delete localConfig.params.freepassData.commonId;
-      const objectId = freepassIdSubmodule.getId(localConfig, undefined);
-      expect(objectId).to.be.an('object');
-      expect(objectId.id).to.be.an('object');
-      expect(objectId.id.commonId).to.be.undefined;
-    });
-    it('should skip commonId in IdObject if freepassData is not available', function () {
-      const localConfig = JSON.parse(JSON.stringify(config));
-      delete localConfig.params.freepassData;
-      const objectId = freepassIdSubmodule.getId(localConfig, undefined);
-      expect(objectId).to.be.an('object');
-      expect(objectId.id).to.be.an('object');
-      expect(objectId.id.commonId).to.be.undefined;
-    });
-    it('should skip commonId in IdObject if params is not available', function () {
-      const localConfig = JSON.parse(JSON.stringify(config));
-      delete localConfig.params;
-      const objectId = freepassIdSubmodule.getId(localConfig, undefined);
-      expect(objectId).to.be.an('object');
-      expect(objectId.id).to.be.an('object');
-      expect(objectId.id.commonId).to.be.undefined;
+      expect(objectId.id.userId).to.be.undefined;
     });
   });
 
@@ -142,12 +91,15 @@ describe('FreePass ID System', function () {
     };
 
     it('should return cachedIdObject if there are no changes', function () {
+      getCookieStub.withArgs(FREEPASS_COOKIE_KEY).returns(UUID);
       const idObject = freepassIdSubmodule.getId(config, undefined);
       const cachedIdObject = Object.assign({}, idObject.id);
       const extendedIdObject = freepassIdSubmodule.extendId(config, undefined, cachedIdObject);
       expect(extendedIdObject).to.be.an('object');
       expect(extendedIdObject.id).to.be.an('object');
-      expect(extendedIdObject.id).to.equal(cachedIdObject);
+      expect(extendedIdObject.id.userId).to.equal(UUID);
+      expect(extendedIdObject.id.userIp).to.equal(config.params.freepassData.userIp);
+      expect(extendedIdObject.id.commonId).to.equal(config.params.freepassData.commonId);
     });
 
     it('should return cachedIdObject if there are no new data', function () {
@@ -182,5 +134,20 @@ describe('FreePass ID System', function () {
       expect(extendedIdObject.id).to.be.an('object');
       expect(extendedIdObject.id.userIp).to.equal('192.168.1.1');
     });
+
+    it('should return new userId when changed from cache', function () {
+      getCookieStub.withArgs(FREEPASS_COOKIE_KEY).returns(UUID);
+      const idObject = freepassIdSubmodule.getId(config, undefined);
+      const cachedIdObject = Object.assign({}, idObject.id);
+      const localConfig = JSON.parse(JSON.stringify(config));
+      localConfig.params.freepassData.userIp = '192.168.1.1';
+
+      getCookieStub.withArgs(FREEPASS_COOKIE_KEY).returns('NEW_UUID');
+      const extendedIdObject = freepassIdSubmodule.extendId(localConfig, undefined, cachedIdObject);
+      expect(extendedIdObject).to.be.an('object');
+      expect(extendedIdObject.id).to.be.an('object');
+      expect(extendedIdObject.id.userIp).to.equal('192.168.1.1');
+      expect(extendedIdObject.id.userId).to.equal('NEW_UUID');
+    });
   });
 });
diff --git a/test/spec/modules/optidigitalBidAdapter_spec.js b/test/spec/modules/optidigitalBidAdapter_spec.js
index 62c37f85cc8..30e72452c39 100755
--- a/test/spec/modules/optidigitalBidAdapter_spec.js
+++ b/test/spec/modules/optidigitalBidAdapter_spec.js
@@ -479,6 +479,28 @@ describe('optidigitalAdapterTests', function () {
       expect(payload.imp[0].bidFloor).to.exist;
     });
 
+    it('should add userEids to payload', function() {
+      const userIdAsEids = [{
+        source: 'pubcid.org',
+        uids: [{
+          id: '121213434342343',
+          atype: 1
+        }]
+      }];
+      validBidRequests[0].userIdAsEids = userIdAsEids;
+      bidderRequest.userIdAsEids = userIdAsEids;
+      const request = spec.buildRequests(validBidRequests, bidderRequest);
+      const payload = JSON.parse(request.data);
+      expect(payload.user.eids).to.deep.equal(userIdAsEids);
+    });
+
+    it('should not add userIdAsEids to payload when userIdAsEids is not present', function() {
+      validBidRequests[0].userIdAsEids = undefined;
+      const request = spec.buildRequests(validBidRequests, bidderRequest);
+      const payload = JSON.parse(request.data);
+      expect(payload.user).to.deep.equal(undefined);
+    });
+
     function returnBannerSizes(mediaTypes, expectedSizes) {
       const bidRequest = Object.assign(validBidRequests[0], mediaTypes);
       const request = spec.buildRequests([bidRequest], bidderRequest);
diff --git a/test/spec/modules/pangleBidAdapter_spec.js b/test/spec/modules/pangleBidAdapter_spec.js
new file mode 100644
index 00000000000..79cbc30b4ec
--- /dev/null
+++ b/test/spec/modules/pangleBidAdapter_spec.js
@@ -0,0 +1,187 @@
+import { expect } from 'chai';
+import { spec } from 'modules/pangleBidAdapter.js';
+
+const REQUEST = [{
+  adUnitCode: 'adUnitCode1',
+  bidId: 'bidId1',
+  auctionId: 'auctionId-56a2-4f71-9098-720a68f2f708',
+  ortb2Imp: {
+    ext: {
+      tid: 'cccc1234',
+    }
+  },
+  mediaTypes: {
+    banner: {
+      sizes: [
+        [300, 250]
+      ]
+    }
+  },
+  bidder: 'pangle',
+  params: {
+    placementid: 999,
+    appid: 111,
+  },
+},
+{
+  adUnitCode: 'adUnitCode2',
+  bidId: 'bidId2',
+  auctionId: 'auctionId-56a2-4f71-9098-720a68f2f708',
+  ortb2Imp: {
+    ext: {
+      tid: 'cccc1234',
+    }
+  },
+  mediaTypes: {
+    banner: {
+      sizes: [
+        [300, 250]
+      ]
+    }
+  },
+  bidder: 'pangle',
+  params: {
+    placementid: 999,
+    appid: 111,
+  },
+}];
+const DEFAULT_OPTIONS = {
+  userId: {
+    britepoolid: 'pangle-britepool',
+    criteoId: 'pangle-criteo',
+    digitrustid: { data: { id: 'pangle-digitrust' } },
+    id5id: { uid: 'pangle-id5' },
+    idl_env: 'pangle-idl-env',
+    lipb: { lipbid: 'pangle-liveintent' },
+    netId: 'pangle-netid',
+    parrableId: { eid: 'pangle-parrable' },
+    pubcid: 'pangle-pubcid',
+    tdid: 'pangle-ttd',
+  }
+};
+
+const RESPONSE = {
+  'headers': null,
+  'body': {
+    'id': 'requestId',
+    'seatbid': [
+      {
+        'bid': [
+          {
+            'id': 'bidId1',
+            'impid': 'bidId1',
+            'price': 0.18,
+            'adm': '<script>adm</script>',
+            'adid': '144762342',
+            'adomain': [
+              'https://dummydomain.com'
+            ],
+            'iurl': 'iurl',
+            'cid': '109',
+            'crid': 'creativeId',
+            'cat': [],
+            'w': 300,
+            'h': 250,
+            'ext': {
+              'prebid': {
+                'type': 'banner'
+              },
+              'bidder': {
+                'pangle': {
+                  'brand_id': 334553,
+                  'auction_id': 514667951122925701,
+                  'bidder_id': 2,
+                  'bid_ad_type': 0
+                }
+              }
+            }
+          }
+        ],
+        'seat': 'seat'
+      }
+    ]
+  }
+};
+
+describe('pangle bid adapter', function () {
+  describe('isBidRequestValid', function () {
+    it('should accept request if placementid and appid is passed', function () {
+      let bid = {
+        bidder: 'pangle',
+        params: {
+          token: 'xxx',
+        }
+      };
+      expect(spec.isBidRequestValid(bid)).to.equal(true);
+    });
+    it('reject requests without params', function () {
+      let bid = {
+        bidder: 'pangle',
+        params: {}
+      };
+      expect(spec.isBidRequestValid(bid)).to.equal(false);
+    });
+  });
+
+  describe('buildRequests', function () {
+    it('creates request data', function () {
+      let request = spec.buildRequests(REQUEST, DEFAULT_OPTIONS)[0];
+      expect(request).to.exist.and.to.be.a('object');
+      const payload = request.data;
+      expect(payload.imp[0]).to.have.property('id', REQUEST[0].bidId);
+      expect(payload.imp[1]).to.have.property('id', REQUEST[1].bidId);
+    });
+  });
+
+  describe('interpretResponse', function () {
+    it('has bids', function () {
+      let request = spec.buildRequests(REQUEST, DEFAULT_OPTIONS)[0];
+      let bids = spec.interpretResponse(RESPONSE, request);
+      expect(bids).to.be.an('array').that.is.not.empty;
+      validateBidOnIndex(0);
+
+      function validateBidOnIndex(index) {
+        expect(bids[index]).to.have.property('currency', 'USD');
+        expect(bids[index]).to.have.property('requestId', RESPONSE.body.seatbid[0].bid[index].id);
+        expect(bids[index]).to.have.property('cpm', RESPONSE.body.seatbid[0].bid[index].price);
+        expect(bids[index]).to.have.property('width', RESPONSE.body.seatbid[0].bid[index].w);
+        expect(bids[index]).to.have.property('height', RESPONSE.body.seatbid[0].bid[index].h);
+        expect(bids[index]).to.have.property('ad', RESPONSE.body.seatbid[0].bid[index].adm);
+        expect(bids[index]).to.have.property('creativeId', RESPONSE.body.seatbid[0].bid[index].crid);
+        expect(bids[index]).to.have.property('ttl', 30);
+        expect(bids[index]).to.have.property('netRevenue', true);
+      }
+    });
+
+    it('handles empty response', function () {
+      let request = spec.buildRequests(REQUEST, DEFAULT_OPTIONS)[0];
+      const EMPTY_RESP = Object.assign({}, RESPONSE, { 'body': {} });
+      const bids = spec.interpretResponse(EMPTY_RESP, request);
+      expect(bids).to.be.empty;
+    });
+  });
+
+  describe('parseUserAgent', function () {
+    let desktop, mobile, tablet;
+    beforeEach(function () {
+      desktop = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36';
+      mobile = 'Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.3 Mobile/15E148 Safari/604.1';
+      tablet = 'Apple iPad: Mozilla/5.0 (iPad; CPU OS 13_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.1.1 Mobile/15E148 Safari/605.1.15';
+    });
+
+    it('should return correct device type: tablet', function () {
+      let deviceType = spec.getDeviceType(tablet);
+      expect(deviceType).to.equal(5);
+    });
+
+    it('should return correct device type: mobile', function () {
+      let deviceType = spec.getDeviceType(mobile);
+      expect(deviceType).to.equal(4);
+    });
+
+    it('should return correct device type: desktop', function () {
+      let deviceType = spec.getDeviceType(desktop);
+      expect(deviceType).to.equal(2);
+    });
+  });
+});
diff --git a/test/spec/modules/pgamsspBidAdapter_spec.js b/test/spec/modules/pgamsspBidAdapter_spec.js
new file mode 100644
index 00000000000..7e2323d4b81
--- /dev/null
+++ b/test/spec/modules/pgamsspBidAdapter_spec.js
@@ -0,0 +1,399 @@
+import { expect } from 'chai';
+import { spec } from '../../../modules/pgamsspBidAdapter.js';
+import { BANNER, VIDEO, NATIVE } from '../../../src/mediaTypes.js';
+import { getUniqueIdentifierStr } from '../../../src/utils.js';
+
+const bidder = 'pgamssp'
+
+describe('PGAMBidAdapter', function () {
+  const bids = [
+    {
+      bidId: getUniqueIdentifierStr(),
+      bidder: bidder,
+      mediaTypes: {
+        [BANNER]: {
+          sizes: [[300, 250]]
+        }
+      },
+      params: {
+        placementId: 'testBanner',
+      }
+    },
+    {
+      bidId: getUniqueIdentifierStr(),
+      bidder: bidder,
+      mediaTypes: {
+        [VIDEO]: {
+          playerSize: [[300, 300]],
+          minduration: 5,
+          maxduration: 60
+        }
+      },
+      params: {
+        placementId: 'testVideo',
+      }
+    },
+    {
+      bidId: getUniqueIdentifierStr(),
+      bidder: bidder,
+      mediaTypes: {
+        [NATIVE]: {
+          native: {
+            title: {
+              required: true
+            },
+            body: {
+              required: true
+            },
+            icon: {
+              required: true,
+              size: [64, 64]
+            }
+          }
+        }
+      },
+      params: {
+        placementId: 'testNative',
+      }
+    }
+  ];
+
+  const invalidBid = {
+    bidId: getUniqueIdentifierStr(),
+    bidder: bidder,
+    mediaTypes: {
+      [BANNER]: {
+        sizes: [[300, 250]]
+      }
+    },
+    params: {
+
+    }
+  }
+
+  const bidderRequest = {
+    uspConsent: '1---',
+    gdprConsent: 'COvFyGBOvFyGBAbAAAENAPCAAOAAAAAAAAAAAEEUACCKAAA.IFoEUQQgAIQwgIwQABAEAAAAOIAACAIAAAAQAIAgEAACEAAAAAgAQBAAAAAAAGBAAgAAAAAAAFAAECAAAgAAQARAEQAAAAAJAAIAAgAAAYQEAAAQmAgBC3ZAYzUw',
+    refererInfo: {
+      referer: 'https://test.com'
+    },
+    timeout: 500
+  };
+
+  describe('isBidRequestValid', function () {
+    it('Should return true if there are bidId, params and key parameters present', function () {
+      expect(spec.isBidRequestValid(bids[0])).to.be.true;
+    });
+    it('Should return false if at least one of parameters is not present', function () {
+      expect(spec.isBidRequestValid(invalidBid)).to.be.false;
+    });
+  });
+
+  describe('buildRequests', function () {
+    let serverRequest = spec.buildRequests(bids, bidderRequest);
+
+    it('Creates a ServerRequest object with method, URL and data', function () {
+      expect(serverRequest).to.exist;
+      expect(serverRequest.method).to.exist;
+      expect(serverRequest.url).to.exist;
+      expect(serverRequest.data).to.exist;
+    });
+
+    it('Returns POST method', function () {
+      expect(serverRequest.method).to.equal('POST');
+    });
+
+    it('Returns valid URL', function () {
+      expect(serverRequest.url).to.equal('https://us-east.pgammedia.com/pbjs');
+    });
+
+    it('Returns general data valid', function () {
+      let data = serverRequest.data;
+      expect(data).to.be.an('object');
+      expect(data).to.have.all.keys('deviceWidth',
+        'deviceHeight',
+        'language',
+        'secure',
+        'host',
+        'page',
+        'placements',
+        'coppa',
+        'ccpa',
+        'gdpr',
+        'tmax'
+      );
+      expect(data.deviceWidth).to.be.a('number');
+      expect(data.deviceHeight).to.be.a('number');
+      expect(data.language).to.be.a('string');
+      expect(data.secure).to.be.within(0, 1);
+      expect(data.host).to.be.a('string');
+      expect(data.page).to.be.a('string');
+      expect(data.coppa).to.be.a('number');
+      expect(data.gdpr).to.be.a('string');
+      expect(data.ccpa).to.be.a('string');
+      expect(data.tmax).to.be.a('number');
+      expect(data.placements).to.have.lengthOf(3);
+    });
+
+    it('Returns valid placements', function () {
+      const { placements } = serverRequest.data;
+      for (let i = 0, len = placements.length; i < len; i++) {
+        const placement = placements[i];
+        expect(placement.placementId).to.be.oneOf(['testBanner', 'testVideo', 'testNative']);
+        expect(placement.adFormat).to.be.oneOf([BANNER, VIDEO, NATIVE]);
+        expect(placement.bidId).to.be.a('string');
+        expect(placement.schain).to.be.an('object');
+        expect(placement.bidfloor).to.exist.and.to.equal(0);
+        expect(placement.type).to.exist.and.to.equal('publisher');
+
+        if (placement.adFormat === BANNER) {
+          expect(placement.sizes).to.be.an('array');
+        }
+        switch (placement.adFormat) {
+          case BANNER:
+            expect(placement.sizes).to.be.an('array');
+            break;
+          case VIDEO:
+            expect(placement.playerSize).to.be.an('array');
+            expect(placement.minduration).to.be.an('number');
+            expect(placement.maxduration).to.be.an('number');
+            break;
+          case NATIVE:
+            expect(placement.native).to.be.an('object');
+            break;
+        }
+      }
+    });
+
+    it('Returns data with gdprConsent and without uspConsent', function () {
+      delete bidderRequest.uspConsent;
+      serverRequest = spec.buildRequests(bids, bidderRequest);
+      let data = serverRequest.data;
+      expect(data.gdpr).to.exist;
+      expect(data.gdpr).to.be.a('string');
+      expect(data.gdpr).to.equal(bidderRequest.gdprConsent);
+      expect(data.ccpa).to.not.exist;
+      delete bidderRequest.gdprConsent;
+    });
+
+    it('Returns data with uspConsent and without gdprConsent', function () {
+      bidderRequest.uspConsent = '1---';
+      delete bidderRequest.gdprConsent;
+      serverRequest = spec.buildRequests(bids, bidderRequest);
+      let data = serverRequest.data;
+      expect(data.ccpa).to.exist;
+      expect(data.ccpa).to.be.a('string');
+      expect(data.ccpa).to.equal(bidderRequest.uspConsent);
+      expect(data.gdpr).to.not.exist;
+    });
+
+    it('Returns empty data if no valid requests are passed', function () {
+      serverRequest = spec.buildRequests([], bidderRequest);
+      let data = serverRequest.data;
+      expect(data.placements).to.be.an('array').that.is.empty;
+    });
+  });
+
+  describe('interpretResponse', function () {
+    it('Should interpret banner response', function () {
+      const banner = {
+        body: [{
+          mediaType: 'banner',
+          width: 300,
+          height: 250,
+          cpm: 0.4,
+          ad: 'Test',
+          requestId: '23fhj33i987f',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1',
+          meta: {
+            advertiserDomains: ['google.com'],
+            advertiserId: 1234
+          }
+        }]
+      };
+      let bannerResponses = spec.interpretResponse(banner);
+      expect(bannerResponses).to.be.an('array').that.is.not.empty;
+      let dataItem = bannerResponses[0];
+      expect(dataItem).to.have.all.keys('requestId', 'cpm', 'width', 'height', 'ad', 'ttl', 'creativeId',
+        'netRevenue', 'currency', 'dealId', 'mediaType', 'meta');
+      expect(dataItem.requestId).to.equal(banner.body[0].requestId);
+      expect(dataItem.cpm).to.equal(banner.body[0].cpm);
+      expect(dataItem.width).to.equal(banner.body[0].width);
+      expect(dataItem.height).to.equal(banner.body[0].height);
+      expect(dataItem.ad).to.equal(banner.body[0].ad);
+      expect(dataItem.ttl).to.equal(banner.body[0].ttl);
+      expect(dataItem.creativeId).to.equal(banner.body[0].creativeId);
+      expect(dataItem.netRevenue).to.be.true;
+      expect(dataItem.currency).to.equal(banner.body[0].currency);
+      expect(dataItem.meta).to.be.an('object').that.has.any.key('advertiserDomains');
+    });
+    it('Should interpret video response', function () {
+      const video = {
+        body: [{
+          vastUrl: 'test.com',
+          mediaType: 'video',
+          cpm: 0.5,
+          requestId: '23fhj33i987f',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1',
+          meta: {
+            advertiserDomains: ['google.com'],
+            advertiserId: 1234
+          }
+        }]
+      };
+      let videoResponses = spec.interpretResponse(video);
+      expect(videoResponses).to.be.an('array').that.is.not.empty;
+
+      let dataItem = videoResponses[0];
+      expect(dataItem).to.have.all.keys('requestId', 'cpm', 'vastUrl', 'ttl', 'creativeId',
+        'netRevenue', 'currency', 'dealId', 'mediaType', 'meta');
+      expect(dataItem.requestId).to.equal('23fhj33i987f');
+      expect(dataItem.cpm).to.equal(0.5);
+      expect(dataItem.vastUrl).to.equal('test.com');
+      expect(dataItem.ttl).to.equal(120);
+      expect(dataItem.creativeId).to.equal('2');
+      expect(dataItem.netRevenue).to.be.true;
+      expect(dataItem.currency).to.equal('USD');
+      expect(dataItem.meta).to.be.an('object').that.has.any.key('advertiserDomains');
+    });
+    it('Should interpret native response', function () {
+      const native = {
+        body: [{
+          mediaType: 'native',
+          native: {
+            clickUrl: 'test.com',
+            title: 'Test',
+            image: 'test.com',
+            impressionTrackers: ['test.com'],
+          },
+          ttl: 120,
+          cpm: 0.4,
+          requestId: '23fhj33i987f',
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          meta: {
+            advertiserDomains: ['google.com'],
+            advertiserId: 1234
+          }
+        }]
+      };
+      let nativeResponses = spec.interpretResponse(native);
+      expect(nativeResponses).to.be.an('array').that.is.not.empty;
+
+      let dataItem = nativeResponses[0];
+      expect(dataItem).to.have.keys('requestId', 'cpm', 'ttl', 'creativeId', 'netRevenue', 'currency', 'mediaType', 'native', 'meta');
+      expect(dataItem.native).to.have.keys('clickUrl', 'impressionTrackers', 'title', 'image')
+      expect(dataItem.requestId).to.equal('23fhj33i987f');
+      expect(dataItem.cpm).to.equal(0.4);
+      expect(dataItem.native.clickUrl).to.equal('test.com');
+      expect(dataItem.native.title).to.equal('Test');
+      expect(dataItem.native.image).to.equal('test.com');
+      expect(dataItem.native.impressionTrackers).to.be.an('array').that.is.not.empty;
+      expect(dataItem.native.impressionTrackers[0]).to.equal('test.com');
+      expect(dataItem.ttl).to.equal(120);
+      expect(dataItem.creativeId).to.equal('2');
+      expect(dataItem.netRevenue).to.be.true;
+      expect(dataItem.currency).to.equal('USD');
+      expect(dataItem.meta).to.be.an('object').that.has.any.key('advertiserDomains');
+    });
+    it('Should return an empty array if invalid banner response is passed', function () {
+      const invBanner = {
+        body: [{
+          width: 300,
+          cpm: 0.4,
+          ad: 'Test',
+          requestId: '23fhj33i987f',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1'
+        }]
+      };
+
+      let serverResponses = spec.interpretResponse(invBanner);
+      expect(serverResponses).to.be.an('array').that.is.empty;
+    });
+    it('Should return an empty array if invalid video response is passed', function () {
+      const invVideo = {
+        body: [{
+          mediaType: 'video',
+          cpm: 0.5,
+          requestId: '23fhj33i987f',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1'
+        }]
+      };
+      let serverResponses = spec.interpretResponse(invVideo);
+      expect(serverResponses).to.be.an('array').that.is.empty;
+    });
+    it('Should return an empty array if invalid native response is passed', function () {
+      const invNative = {
+        body: [{
+          mediaType: 'native',
+          clickUrl: 'test.com',
+          title: 'Test',
+          impressionTrackers: ['test.com'],
+          ttl: 120,
+          requestId: '23fhj33i987f',
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+        }]
+      };
+      let serverResponses = spec.interpretResponse(invNative);
+      expect(serverResponses).to.be.an('array').that.is.empty;
+    });
+    it('Should return an empty array if invalid response is passed', function () {
+      const invalid = {
+        body: [{
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1'
+        }]
+      };
+      let serverResponses = spec.interpretResponse(invalid);
+      expect(serverResponses).to.be.an('array').that.is.empty;
+    });
+  });
+
+  describe('getUserSyncs', function() {
+    it('Should return array of objects with proper sync config , include GDPR', function() {
+      const syncData = spec.getUserSyncs({}, {}, {
+        consentString: 'ALL',
+        gdprApplies: true,
+      }, {});
+      expect(syncData).to.be.an('array').which.is.not.empty;
+      expect(syncData[0]).to.be.an('object')
+      expect(syncData[0].type).to.be.a('string')
+      expect(syncData[0].type).to.equal('image')
+      expect(syncData[0].url).to.be.a('string')
+      expect(syncData[0].url).to.equal('https://cs.pgammedia.com/image?pbjs=1&gdpr=1&gdpr_consent=ALL&coppa=0')
+    });
+    it('Should return array of objects with proper sync config , include CCPA', function() {
+      const syncData = spec.getUserSyncs({}, {}, {}, {
+        consentString: '1---'
+      });
+      expect(syncData).to.be.an('array').which.is.not.empty;
+      expect(syncData[0]).to.be.an('object')
+      expect(syncData[0].type).to.be.a('string')
+      expect(syncData[0].type).to.equal('image')
+      expect(syncData[0].url).to.be.a('string')
+      expect(syncData[0].url).to.equal('https://cs.pgammedia.com/image?pbjs=1&ccpa_consent=1---&coppa=0')
+    });
+  });
+});
diff --git a/test/spec/modules/prebidServerBidAdapter_spec.js b/test/spec/modules/prebidServerBidAdapter_spec.js
index ad6c4318cc7..c823366dbce 100644
--- a/test/spec/modules/prebidServerBidAdapter_spec.js
+++ b/test/spec/modules/prebidServerBidAdapter_spec.js
@@ -712,8 +712,8 @@ describe('S2S Adapter', function () {
       beforeEach(() => {
         s2sReq = {
           ...REQUEST,
-          ortb2Fragments: {global: {source: {tid: 'mock-tid'}}},
-          ad_units: REQUEST.ad_units.map(au => ({...au, ortb2Imp: {ext: {tid: 'mock-tid'}}}))
+          ortb2Fragments: {global: {}},
+          ad_units: REQUEST.ad_units.map(au => ({...au, ortb2Imp: {ext: {tid: 'mock-tid'}}})),
         };
         BID_REQUESTS[0].bids[0].ortb2Imp = {ext: {tid: 'mock-tid'}};
       });
@@ -726,15 +726,15 @@ describe('S2S Adapter', function () {
       it('should not be set when transmitTid is not allowed, with ext.prebid.createtids: false', () => {
         config.setConfig({ s2sConfig: CONFIG, enableTIDs: false });
         const req = makeRequest();
-        expect(req.source.tid).to.not.exist;
-        expect(req.imp[0].ext.tid).to.not.exist;
+        expect(req.source?.tid).to.not.exist;
+        expect(req.imp[0].ext?.tid).to.not.exist;
         expect(req.ext.prebid.createtids).to.equal(false);
       });
 
-      it('should be picked from FPD otherwise', () => {
+      it('should be set to auction ID otherwise', () => {
         config.setConfig({s2sConfig: CONFIG, enableTIDs: true});
         const req = makeRequest();
-        expect(req.source.tid).to.eql('mock-tid');
+        expect(req.source.tid).to.eql(BID_REQUESTS[0].auctionId);
         expect(req.imp[0].ext.tid).to.eql('mock-tid');
       })
     })
diff --git a/test/spec/modules/smartyadsBidAdapter_spec.js b/test/spec/modules/smartyadsBidAdapter_spec.js
index 350cad33704..992fff14f33 100644
--- a/test/spec/modules/smartyadsBidAdapter_spec.js
+++ b/test/spec/modules/smartyadsBidAdapter_spec.js
@@ -280,7 +280,21 @@ describe('SmartyadsAdapter', function () {
     });
 
     it('should send a valid bid won notice', function () {
-      spec.onBidWon(bidResponse);
+      const bid = {
+        'c': 'o',
+        'm': 'prebid',
+        'secret_key': 'prebid_js',
+        'winTest': '1',
+        'postData': [{
+          'bidder': 'smartyads',
+          'params': [
+            {'host': 'prebid',
+              'accountid': '123',
+              'sourceid': '12345'
+            }]
+        }]
+      };
+      spec.onBidWon(bid);
       expect(server.requests.length).to.equal(1);
     });
   });
@@ -291,7 +305,21 @@ describe('SmartyadsAdapter', function () {
     });
 
     it('should send a valid bid timeout notice', function () {
-      spec.onTimeout({});
+      const bid = {
+        'c': 'o',
+        'm': 'prebid',
+        'secret_key': 'prebid_js',
+        'bidTimeout': '1',
+        'postData': [{
+          'bidder': 'smartyads',
+          'params': [
+            {'host': 'prebid',
+              'accountid': '123',
+              'sourceid': '12345'
+            }]
+        }]
+      };
+      spec.onTimeout(bid);
       expect(server.requests.length).to.equal(1);
     });
   });
@@ -302,7 +330,21 @@ describe('SmartyadsAdapter', function () {
     });
 
     it('should send a valid bidder error notice', function () {
-      spec.onBidderError({});
+      const bid = {
+        'c': 'o',
+        'm': 'prebid',
+        'secret_key': 'prebid_js',
+        'bidderError': '1',
+        'postData': [{
+          'bidder': 'smartyads',
+          'params': [
+            {'host': 'prebid',
+              'accountid': '123',
+              'sourceid': '12345'
+            }]
+        }]
+      };
+      spec.onBidderError(bid);
       expect(server.requests.length).to.equal(1);
     });
   });
diff --git a/test/spec/modules/yieldloveBidAdapter_spec.js b/test/spec/modules/yieldloveBidAdapter_spec.js
new file mode 100644
index 00000000000..b142eef0ffa
--- /dev/null
+++ b/test/spec/modules/yieldloveBidAdapter_spec.js
@@ -0,0 +1,128 @@
+import { expect } from 'chai';
+import { spec } from 'modules/yieldloveBidAdapter.js';
+
+const ENDPOINT_URL = 'https://s2s.yieldlove-ad-serving.net/openrtb2/auction';
+
+// test params
+const pid = 34437;
+const rid = 'website.com';
+
+describe('Yieldlove Bid Adaper', function () {
+  const bidRequests = [
+    {
+      'bidder': 'yieldlove',
+      'adUnitCode': 'adunit-code',
+      'sizes': [ [300, 250] ],
+      'params': {
+        pid,
+        rid
+      }
+    }
+  ];
+
+  const serverResponse = {
+    body: {
+      seatbid: [
+        {
+          bid: [
+            {
+              impid: 'aaaa',
+              price: 0.5,
+              w: 300,
+              h: 250,
+              adm: '<div>test</div>',
+              crid: '1234',
+            }
+          ]
+        }
+      ],
+      ext: {}
+    }
+  }
+
+  describe('isBidRequestValid', () => {
+    const bid = bidRequests[0];
+
+    it('should return true when required params found', function () {
+      expect(spec.isBidRequestValid(bid)).to.equal(true);
+    });
+
+    it('should return false when required params are not present', function () {
+      const invalidBid = { ...bid, params: {} };
+      expect(spec.isBidRequestValid(invalidBid)).to.equal(false);
+    });
+
+    it('should return false when required param "pid" is not present', function () {
+      const invalidBid = { ...bid, params: { ...bid.params, pid: undefined } };
+      expect(spec.isBidRequestValid(invalidBid)).to.equal(false);
+    });
+
+    it('should return false when required param "rid" is not present', function () {
+      const invalidBid = { ...bid, params: { ...bid.params, rid: undefined } };
+      expect(spec.isBidRequestValid(invalidBid)).to.equal(false);
+    });
+  });
+
+  describe('buildRequests', () => {
+    it('should build the request', function () {
+      const request = spec.buildRequests(bidRequests, {});
+      const payload = request.data;
+      const url = request.url;
+
+      expect(url).to.equal(ENDPOINT_URL);
+
+      expect(payload.site).to.exist;
+      expect(payload.site.publisher).to.exist;
+      expect(payload.site.publisher.id).to.exist;
+      expect(payload.site.publisher.id).to.equal(rid);
+      expect(payload.site.domain).to.exist;
+      expect(payload.site.domain).to.equal(rid);
+
+      expect(payload.imp).to.exist;
+      expect(payload.imp[0]).to.exist;
+      expect(payload.imp[0].ext).to.exist;
+      expect(payload.imp[0].ext.prebid).to.exist;
+      expect(payload.imp[0].ext.prebid.storedrequest).to.exist;
+      expect(payload.imp[0].ext.prebid.storedrequest.id).to.exist;
+      expect(payload.imp[0].ext.prebid.storedrequest.id).to.equal(pid.toString());
+    });
+  });
+
+  describe('interpretResponse', () => {
+    it('should interpret the response by pushing it in the bids elem', function () {
+      const allResponses = spec.interpretResponse(serverResponse);
+      const response = allResponses[0];
+      const seatbid = serverResponse.body.seatbid[0].bid[0];
+
+      expect(response.requestId).to.exist;
+      expect(response.requestId).to.equal(seatbid.impid);
+      expect(response.cpm).to.exist;
+      expect(response.cpm).to.equal(seatbid.price);
+      expect(response.width).to.exist;
+      expect(response.width).to.equal(seatbid.w);
+      expect(response.height).to.exist;
+      expect(response.height).to.equal(seatbid.h);
+      expect(response.ad).to.exist;
+      expect(response.ad).to.equal(seatbid.adm);
+      expect(response.ttl).to.exist;
+      expect(response.creativeId).to.exist;
+      expect(response.creativeId).to.equal(seatbid.crid);
+      expect(response.netRevenue).to.exist;
+      expect(response.currency).to.exist;
+    });
+  });
+
+  describe('getUserSyncs', function() {
+    it('should retrieve user iframe syncs', function () {
+      expect(spec.getUserSyncs({ iframeEnabled: true }, [serverResponse], undefined, undefined)).to.deep.equal([{
+        type: 'iframe',
+        url: 'https://cdn-a.yieldlove.com/load-cookie.html?endpoint=yieldlove&max_sync_count=100&gdpr=NaN&gdpr_consent=&'
+      }]);
+
+      expect(spec.getUserSyncs({ iframeEnabled: true }, [serverResponse], { gdprApplies: true, consentString: 'example' }, undefined)).to.deep.equal([{
+        type: 'iframe',
+        url: 'https://cdn-a.yieldlove.com/load-cookie.html?endpoint=yieldlove&max_sync_count=100&gdpr=1&gdpr_consent=example&'
+      }]);
+    });
+  });
+})
diff --git a/test/spec/modules/zeta_global_sspAnalyticsAdapter_spec.js b/test/spec/modules/zeta_global_sspAnalyticsAdapter_spec.js
index cbba815cfc1..962d135cd6d 100644
--- a/test/spec/modules/zeta_global_sspAnalyticsAdapter_spec.js
+++ b/test/spec/modules/zeta_global_sspAnalyticsAdapter_spec.js
@@ -2,19 +2,20 @@ import zetaAnalyticsAdapter from 'modules/zeta_global_sspAnalyticsAdapter.js';
 import {config} from 'src/config';
 import CONSTANTS from 'src/constants.json';
 import {server} from '../../mocks/xhr.js';
+import {logError} from '../../../src/utils';
 
 let utils = require('src/utils');
 let events = require('src/events');
 
-const MOCK = {
-  STUB: {
-    'auctionId': '25c6d7f5-699a-4bfc-87c9-996f915341fa'
-  },
+const EVENTS = {
   AUCTION_END: {
     'auctionId': '75e394d9-ccce-4978-9238-91e6a1ac88a1',
     'timestamp': 1638441234544,
     'auctionEnd': 1638441234784,
     'auctionStatus': 'completed',
+    'metrics': {
+      'someMetric': 1
+    },
     'adUnits': [
       {
         'code': '/19968336/header-bid-tag-0',
@@ -74,13 +75,6 @@ const MOCK = {
         'bids': [
           {
             'bidder': 'zeta_global_ssp',
-            'params': {
-              'sid': 111,
-              'tags': {
-                'shortname': 'prebid_analytics_event_test_shortname',
-                'position': 'test_position'
-              }
-            },
             'mediaTypes': {
               'banner': {
                 'sizes': [
@@ -309,6 +303,9 @@ const MOCK = {
       'cpm': 2.258302852806723,
       'currency': 'USD',
       'ad': 'test_ad',
+      'metrics': {
+        'someMetric': 0
+      },
       'ttl': 200,
       'creativeId': '456456456',
       'netRevenue': true,
@@ -344,11 +341,7 @@ const MOCK = {
       'status': 'rendered',
       'params': [
         {
-          'sid': 111,
-          'tags': {
-            'shortname': 'prebid_analytics_event_test_shortname',
-            'position': 'test_position'
-          }
+          'nonZetaParam': 'nonZetaValue'
         }
       ]
     },
@@ -392,33 +385,23 @@ describe('Zeta Global SSP Analytics Adapter', function() {
       zetaAnalyticsAdapter.disableAnalytics();
     });
 
-    it('events are sent', function() {
-      this.timeout(5000);
-      events.emit(CONSTANTS.EVENTS.AUCTION_INIT, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.AUCTION_END, MOCK.AUCTION_END);
-      events.emit(CONSTANTS.EVENTS.BID_ADJUSTMENT, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.BID_TIMEOUT, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.BID_REQUESTED, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.BID_RESPONSE, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.NO_BID, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.BID_WON, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.BIDDER_DONE, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.BIDDER_ERROR, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.SET_TARGETING, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.BEFORE_REQUEST_BIDS, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.BEFORE_BIDDER_HTTP, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.REQUEST_BIDS, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.ADD_AD_UNITS, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.AD_RENDER_FAILED, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.AD_RENDER_SUCCEEDED, MOCK.AD_RENDER_SUCCEEDED);
-      events.emit(CONSTANTS.EVENTS.TCF2_ENFORCEMENT, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.AUCTION_DEBUG, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.BID_VIEWABLE, MOCK.STUB);
-      events.emit(CONSTANTS.EVENTS.STALE_RENDER, MOCK.STUB);
+    it('Move ZetaParams through analytics events', function() {
+      this.timeout(3000);
+
+      events.emit(CONSTANTS.EVENTS.AUCTION_END, EVENTS.AUCTION_END);
+      events.emit(CONSTANTS.EVENTS.AD_RENDER_SUCCEEDED, EVENTS.AD_RENDER_SUCCEEDED);
 
       expect(requests.length).to.equal(2);
-      expect(JSON.parse(requests[0].requestBody)).to.deep.equal(MOCK.AUCTION_END);
-      expect(JSON.parse(requests[1].requestBody)).to.deep.equal(MOCK.AD_RENDER_SUCCEEDED);
+      const auctionEnd = JSON.parse(requests[0].requestBody);
+      const auctionSucceeded = JSON.parse(requests[1].requestBody);
+
+      expect(auctionEnd.metrics).to.be.undefined;
+
+      expect(auctionSucceeded.bid.ad).to.be.undefined;
+      expect(auctionSucceeded.bid.metrics).to.be.undefined;
+
+      expect(auctionSucceeded.bid.params[0]).to.be.deep.equal(EVENTS.AUCTION_END.adUnits[0].bids[0].params);
+      expect(EVENTS.AUCTION_END.adUnits[0].bids[0].bidder).to.be.equal('zeta_global_ssp');
     });
   });
 });
diff --git a/test/spec/unit/core/events_spec.js b/test/spec/unit/core/events_spec.js
new file mode 100644
index 00000000000..6551c9f2456
--- /dev/null
+++ b/test/spec/unit/core/events_spec.js
@@ -0,0 +1,30 @@
+import {config} from 'src/config.js';
+import {emit, clearEvents, getEvents} from '../../../../src/events.js';
+
+describe('events', () => {
+  let clock;
+  beforeEach(() => {
+    clock = sinon.useFakeTimers();
+    clearEvents();
+  });
+  afterEach(() => {
+    clock.restore();
+  });
+
+  it('should clear event log using eventHistoryTTL config', () => {
+    emit('testEvent', {});
+    expect(getEvents().length).to.eql(1);
+    config.setConfig({eventHistoryTTL: 1});
+    clock.tick(500);
+    expect(getEvents().length).to.eql(1);
+    clock.tick(6000);
+    expect(getEvents().length).to.eql(0);
+  });
+
+  it('should take history TTL in seconds', () => {
+    emit('testEvent', {});
+    config.setConfig({eventHistoryTTL: 1000});
+    clock.tick(10000);
+    expect(getEvents().length).to.eql(1);
+  })
+})
diff --git a/test/spec/unit/pbjs_api_spec.js b/test/spec/unit/pbjs_api_spec.js
index 5c361d186c0..b39c984316a 100644
--- a/test/spec/unit/pbjs_api_spec.js
+++ b/test/spec/unit/pbjs_api_spec.js
@@ -25,7 +25,6 @@ import {stubAuctionIndex} from '../../helpers/indexStub.js';
 import {createBid} from '../../../src/bidfactory.js';
 import {enrichFPD} from '../../../src/fpd/enrichment.js';
 import {mockFpdEnrichments} from '../../helpers/fpd.js';
-
 var assert = require('chai').assert;
 var expect = require('chai').expect;
 
@@ -43,13 +42,12 @@ var adUnits = getAdUnits();
 var adUnitCodes = getAdUnits().map(unit => unit.code);
 var bidsBackHandler = function() {};
 const timeout = 2000;
-var auction = auctionManager.createAuction({adUnits, adUnitCodes, callback: bidsBackHandler, cbTimeout: timeout});
-auction.getBidRequests = getBidRequests;
-auction.getBidsReceived = getBidResponses;
-auction.getAdUnits = getAdUnits;
-auction.getAuctionStatus = function() { return auctionModule.AUCTION_COMPLETED }
+let auction;
 
 function resetAuction() {
+  if (auction == null) {
+    auction = auctionManager.createAuction({adUnits, adUnitCodes, callback: bidsBackHandler, cbTimeout: timeout});
+  }
   $$PREBID_GLOBAL$$.setConfig({ enableSendAllBids: false });
   auction.getBidRequests = getBidRequests;
   auction.getBidsReceived = getBidResponses;
diff --git a/test/spec/unit/utils/ttlCollection_spec.js b/test/spec/unit/utils/ttlCollection_spec.js
new file mode 100644
index 00000000000..29c6c438855
--- /dev/null
+++ b/test/spec/unit/utils/ttlCollection_spec.js
@@ -0,0 +1,180 @@
+import {ttlCollection} from '../../../../src/utils/ttlCollection.js';
+
+describe('ttlCollection', () => {
+  it('can add & retrieve items', () => {
+    const coll = ttlCollection();
+    expect(coll.toArray()).to.eql([]);
+    coll.add(1);
+    coll.add(2);
+    expect(coll.toArray()).to.eql([1, 2]);
+  });
+
+  it('can clear', () => {
+    const coll = ttlCollection();
+    coll.add('item');
+    coll.clear();
+    expect(coll.toArray()).to.eql([]);
+  });
+
+  it('can be iterated over', () => {
+    const coll = ttlCollection();
+    coll.add('1');
+    coll.add('2');
+    expect(Array.from(coll)).to.eql(['1', '2']);
+  })
+
+  describe('autopurge', () => {
+    let clock, pms, waitForPromises;
+    const SLACK = 2000;
+    beforeEach(() => {
+      clock = sinon.useFakeTimers();
+      pms = [];
+      waitForPromises = () => Promise.all(pms);
+    });
+    afterEach(() => {
+      clock.restore();
+    });
+
+    Object.entries({
+      'defer': (value) => {
+        const pm = Promise.resolve(value);
+        pms.push(pm);
+        return pm;
+      },
+      'do not defer': (value) => value,
+    }).forEach(([t, resolve]) => {
+      describe(`when ttl/startTime ${t}`, () => {
+        let coll;
+        beforeEach(() => {
+          coll = ttlCollection({
+            startTime: (item) => resolve(item.start == null ? new Date().getTime() : item.start),
+            ttl: (item) => resolve(item.ttl),
+            slack: SLACK
+          })
+        });
+
+        it('should clear items after enough time has passed', () => {
+          coll.add({no: 'ttl'});
+          coll.add({ttl: 1000});
+          coll.add({ttl: 4000});
+          return waitForPromises().then(() => {
+            clock.tick(500);
+            expect(coll.toArray()).to.eql([{no: 'ttl'}, {ttl: 1000}, {ttl: 4000}]);
+            clock.tick(SLACK + 500);
+            expect(coll.toArray()).to.eql([{no: 'ttl'}, {ttl: 4000}]);
+            clock.tick(3000);
+            expect(coll.toArray()).to.eql([{no: 'ttl'}]);
+          });
+        });
+
+        it('should not wait too long if a shorter ttl shows up', () => {
+          coll.add({ttl: 4000});
+          coll.add({ttl: 1000});
+          return waitForPromises().then(() => {
+            clock.tick(1000 + SLACK);
+            expect(coll.toArray()).to.eql([
+              {ttl: 4000}
+            ]);
+          });
+        });
+
+        it('should not wait more if later ttls are within slack', () => {
+          coll.add({start: 0, ttl: 4000});
+          return waitForPromises().then(() => {
+            clock.tick(4000);
+            coll.add({start: 0, ttl: 5000});
+            return waitForPromises().then(() => {
+              clock.tick(SLACK);
+              expect(coll.toArray()).to.eql([]);
+            });
+          });
+        });
+
+        it('should clear items ASAP if they expire in the past', () => {
+          clock.tick(10000);
+          coll.add({start: 0, ttl: 1000});
+          return waitForPromises().then(() => {
+            clock.tick(SLACK);
+            expect(coll.toArray()).to.eql([]);
+          });
+        });
+
+        it('should clear items ASAP if they have ttl = 0', () => {
+          coll.add({ttl: 0});
+          return waitForPromises().then(() => {
+            clock.tick(SLACK);
+            expect(coll.toArray()).to.eql([]);
+          });
+        });
+
+        describe('refresh', () => {
+          it('should refresh missing TTLs', () => {
+            const item = {};
+            coll.add(item);
+            return waitForPromises().then(() => {
+              item.ttl = 1000;
+              return waitForPromises().then(() => {
+                clock.tick(1000 + SLACK);
+                expect(coll.toArray()).to.eql([item]);
+                coll.refresh();
+                return waitForPromises().then(() => {
+                  clock.tick(1);
+                  expect(coll.toArray()).to.eql([]);
+                });
+              });
+            });
+          });
+
+          it('should refresh existing TTLs', () => {
+            const item = {
+              ttl: 1000
+            };
+            coll.add(item);
+            return waitForPromises().then(() => {
+              clock.tick(1000);
+              item.ttl = 4000;
+              coll.refresh();
+              return waitForPromises().then(() => {
+                clock.tick(SLACK);
+                expect(coll.toArray()).to.eql([item]);
+                clock.tick(3000);
+                expect(coll.toArray()).to.eql([]);
+              });
+            });
+          });
+
+          it('should discard initial TTL if it does not resolve before a refresh', () => {
+            let resolveTTL;
+            const item = {
+              ttl: new Promise((resolve) => {
+                resolveTTL = resolve;
+              })
+            };
+            coll.add(item);
+            item.ttl = null;
+            coll.refresh();
+            resolveTTL(1000);
+            return waitForPromises().then(() => {
+              clock.tick(1000 + SLACK + 1000);
+              expect(coll.toArray()).to.eql([item]);
+            });
+          });
+
+          it('should discard TTLs on clear', () => {
+            const item = {
+              ttl: 1000
+            };
+            coll.add(item);
+            coll.clear();
+            item.ttl = null;
+            coll.add(item);
+            return waitForPromises().then(() => {
+              clock.tick(1000 + SLACK + 1000);
+              expect(coll.toArray()).to.eql([item]);
+            });
+          });
+        });
+      });
+    });
+  });
+});
diff --git a/test/spec/utils_spec.js b/test/spec/utils_spec.js
index e26683074c8..6e7f8ba0e8f 100644
--- a/test/spec/utils_spec.js
+++ b/test/spec/utils_spec.js
@@ -2,7 +2,7 @@ import {getAdServerTargeting} from 'test/fixtures/fixtures.js';
 import {expect} from 'chai';
 import CONSTANTS from 'src/constants.json';
 import * as utils from 'src/utils.js';
-import {deepEqual, memoize, waitForElementToLoad} from 'src/utils.js';
+import {binarySearch, deepEqual, memoize, waitForElementToLoad} from 'src/utils.js';
 
 var assert = require('assert');
 
@@ -1233,5 +1233,44 @@ describe('memoize', () => {
     mem('one', 'three');
     expect(mem('one', 'three')).to.eql(['one', 'three']);
     expect(fn.callCount).to.eql(2);
-  })
+  });
+
+  describe('binarySearch', () => {
+    [
+      {
+        arr: [],
+        tests: [
+          ['any', 0]
+        ]
+      },
+      {
+        arr: [10],
+        tests: [
+          [5, 0],
+          [10, 0],
+          [20, 1],
+        ],
+      },
+      {
+        arr: [10, 20, 30, 30, 40],
+        tests: [
+          [5, 0],
+          [15, 1],
+          [10, 0],
+          [30, 2],
+          [35, 4],
+          [40, 4],
+          [100, 5]
+        ]
+      }
+    ].forEach(({arr, tests}) => {
+      describe(`on ${arr}`, () => {
+        tests.forEach(([el, pos]) => {
+          it(`finds index for ${el} => ${pos}`, () => {
+            expect(binarySearch(arr, el)).to.equal(pos);
+          });
+        });
+      });
+    })
+  });
 })
diff --git a/test/spec/video_spec.js b/test/spec/video_spec.js
index 61621c7ec42..35d0a4fef24 100644
--- a/test/spec/video_spec.js
+++ b/test/spec/video_spec.js
@@ -1,4 +1,4 @@
-import { isValidVideoBid } from 'src/video.js';
+import {fillVideoDefaults, isValidVideoBid} from 'src/video.js';
 import {hook} from '../../src/hook.js';
 import {stubAuctionIndex} from '../helpers/indexStub.js';
 
@@ -7,97 +7,169 @@ describe('video.js', function () {
     hook.ready();
   });
 
-  it('validates valid instream bids', function () {
-    const bid = {
-      adId: '456xyz',
-      vastUrl: 'http://www.example.com/vastUrl',
-      transactionId: 'au'
-    };
-    const adUnits = [{
-      transactionId: 'au',
-      mediaTypes: {
-        video: {context: 'instream'}
-      }
-    }];
-    const valid = isValidVideoBid(bid, {index: stubAuctionIndex({adUnits})});
-    expect(valid).to.equal(true);
-  });
+  describe('fillVideoDefaults', () => {
+    function fillDefaults(videoMediaType = {}) {
+      const adUnit = {mediaTypes: {video: videoMediaType}};
+      fillVideoDefaults(adUnit);
+      return adUnit.mediaTypes.video;
+    }
 
-  it('catches invalid instream bids', function () {
-    const bid = {
-      transactionId: 'au'
-    };
-    const adUnits = [{
-      transactionId: 'au',
-      mediaTypes: {
-        video: {context: 'instream'}
-      }
-    }];
-    const valid = isValidVideoBid(bid, {index: stubAuctionIndex({adUnits})});
-    expect(valid).to.equal(false);
-  });
+    describe('should set plcmt = 4 when', () => {
+      it('context is "outstream"', () => {
+        expect(fillDefaults({context: 'outstream'})).to.eql({
+          context: 'outstream',
+          plcmt: 4
+        })
+      });
+      [2, 3, 4].forEach(placement => {
+        it(`placemement is "${placement}"`, () => {
+          expect(fillDefaults({placement})).to.eql({
+            placement,
+            plcmt: 4
+          });
+        })
+      });
+    });
+    describe('should set plcmt = 2 when', () => {
+      [2, 6].forEach(playbackmethod => {
+        it(`playbackmethod is "${playbackmethod}"`, () => {
+          expect(fillDefaults({playbackmethod})).to.eql({
+            playbackmethod,
+            plcmt: 2,
+          });
+        });
+      });
+    });
+    describe('should not set plcmt when', () => {
+      Object.entries({
+        'it was set by pub (context=outstream)': {
+          expected: 1,
+          video: {
+            context: 'outstream',
+            plcmt: 1
+          }
+        },
+        'it was set by pub (placement=2)': {
+          expected: 1,
+          video: {
+            placement: 2,
+            plcmt: 1
+          }
+        },
+        'placement not in 2, 3, 4': {
+          expected: undefined,
+          video: {
+            placement: 1
+          }
+        },
+        'it was set by pub (playbackmethod=2)': {
+          expected: 1,
+          video: {
+            plcmt: 1,
+            playbackmethod: 2
+          }
+        }
+      }).forEach(([t, {expected, video}]) => {
+        it(t, () => {
+          expect(fillDefaults(video).plcmt).to.eql(expected);
+        })
+      })
+    })
+  })
 
-  it('catches invalid bids when prebid-cache is disabled', function () {
-    const adUnits = [{
-      transactionId: 'au',
-      bidder: 'vastOnlyVideoBidder',
-      mediaTypes: {video: {}},
-    }];
+  describe('isValidVideoBid', () => {
+    it('validates valid instream bids', function () {
+      const bid = {
+        adId: '456xyz',
+        vastUrl: 'http://www.example.com/vastUrl',
+        transactionId: 'au'
+      };
+      const adUnits = [{
+        transactionId: 'au',
+        mediaTypes: {
+          video: {context: 'instream'}
+        }
+      }];
+      const valid = isValidVideoBid(bid, {index: stubAuctionIndex({adUnits})});
+      expect(valid).to.equal(true);
+    });
 
-    const valid = isValidVideoBid({ transactionId: 'au', vastXml: '<xml>vast</xml>' }, {index: stubAuctionIndex({adUnits})});
+    it('catches invalid instream bids', function () {
+      const bid = {
+        transactionId: 'au'
+      };
+      const adUnits = [{
+        transactionId: 'au',
+        mediaTypes: {
+          video: {context: 'instream'}
+        }
+      }];
+      const valid = isValidVideoBid(bid, {index: stubAuctionIndex({adUnits})});
+      expect(valid).to.equal(false);
+    });
 
-    expect(valid).to.equal(false);
-  });
+    it('catches invalid bids when prebid-cache is disabled', function () {
+      const adUnits = [{
+        transactionId: 'au',
+        bidder: 'vastOnlyVideoBidder',
+        mediaTypes: {video: {}},
+      }];
 
-  it('validates valid outstream bids', function () {
-    const bid = {
-      transactionId: 'au',
-      renderer: {
-        url: 'render.url',
-        render: () => true,
-      }
-    };
-    const adUnits = [{
-      transactionId: 'au',
-      mediaTypes: {
-        video: {context: 'outstream'}
-      }
-    }];
-    const valid = isValidVideoBid(bid, {index: stubAuctionIndex({adUnits})});
-    expect(valid).to.equal(true);
-  });
+      const valid = isValidVideoBid({ transactionId: 'au', vastXml: '<xml>vast</xml>' }, {index: stubAuctionIndex({adUnits})});
 
-  it('validates valid outstream bids with a publisher defined renderer', function () {
-    const bid = {
-      transactionId: 'au',
-    };
-    const adUnits = [{
-      transactionId: 'au',
-      mediaTypes: {
-        video: {
-          context: 'outstream',
+      expect(valid).to.equal(false);
+    });
+
+    it('validates valid outstream bids', function () {
+      const bid = {
+        transactionId: 'au',
+        renderer: {
+          url: 'render.url',
+          render: () => true,
         }
-      },
-      renderer: {
-        url: 'render.url',
-        render: () => true,
-      }
-    }];
-    const valid = isValidVideoBid(bid, {index: stubAuctionIndex({adUnits})});
-    expect(valid).to.equal(true);
-  });
+      };
+      const adUnits = [{
+        transactionId: 'au',
+        mediaTypes: {
+          video: {context: 'outstream'}
+        }
+      }];
+      const valid = isValidVideoBid(bid, {index: stubAuctionIndex({adUnits})});
+      expect(valid).to.equal(true);
+    });
 
-  it('catches invalid outstream bids', function () {
-    const bid = {
-      transactionId: 'au',
-    };
-    const adUnits = [{
-      transactionId: 'au',
-      mediaTypes: {
-        video: {context: 'outstream'}
-      }
-    }];
-    const valid = isValidVideoBid(bid, {index: stubAuctionIndex({adUnits})});
-    expect(valid).to.equal(false);
-  });
+    it('validates valid outstream bids with a publisher defined renderer', function () {
+      const bid = {
+        transactionId: 'au',
+      };
+      const adUnits = [{
+        transactionId: 'au',
+        mediaTypes: {
+          video: {
+            context: 'outstream',
+          }
+        },
+        renderer: {
+          url: 'render.url',
+          render: () => true,
+        }
+      }];
+      const valid = isValidVideoBid(bid, {index: stubAuctionIndex({adUnits})});
+      expect(valid).to.equal(true);
+    });
+
+    it('catches invalid outstream bids', function () {
+      const bid = {
+        transactionId: 'au',
+      };
+      const adUnits = [{
+        transactionId: 'au',
+        mediaTypes: {
+          video: {context: 'outstream'}
+        }
+      }];
+      const valid = isValidVideoBid(bid, {index: stubAuctionIndex({adUnits})});
+      expect(valid).to.equal(false);
+    });
+  })
 });