From e1441a4fdf2375ebb13ae88475e887378380bb19 Mon Sep 17 00:00:00 2001
From: Patrick McCann <patmmccann@gmail.com>
Date: Thu, 7 Sep 2023 09:58:27 -0400
Subject: [PATCH 01/46] Update video_spec.js (#10443)

---
 test/spec/video_spec.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/spec/video_spec.js b/test/spec/video_spec.js
index 9a6333589ad..35d0a4fef24 100644
--- a/test/spec/video_spec.js
+++ b/test/spec/video_spec.js
@@ -62,11 +62,11 @@ describe('video.js', function () {
             placement: 1
           }
         },
-        'it was set by pub (playmethod=2)': {
+        'it was set by pub (playbackmethod=2)': {
           expected: 1,
           video: {
             plcmt: 1,
-            playmethod: 2
+            playbackmethod: 2
           }
         }
       }).forEach(([t, {expected, video}]) => {

From 41d0b949b07374194406639b98866496b28ebc6f Mon Sep 17 00:00:00 2001
From: Demetrio Girardi <dgirardi@prebid.org>
Date: Thu, 7 Sep 2023 08:49:44 -0700
Subject: [PATCH 02/46] Experian RTD provider: fix unit tests (#10449)

---
 test/spec/modules/experianRtdProvider_spec.js | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/test/spec/modules/experianRtdProvider_spec.js b/test/spec/modules/experianRtdProvider_spec.js
index 50b905a13ec..fd104674d70 100644
--- a/test/spec/modules/experianRtdProvider_spec.js
+++ b/test/spec/modules/experianRtdProvider_spec.js
@@ -9,17 +9,15 @@ import {
 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();
-  const xhr = sinon.useFakeXMLHttpRequest();
+  let requests;
 
-  let requests = [];
   const storage = getStorageManager({ moduleType: MODULE_TYPE_RTD, moduleName: SUBMODULE_NAME })
   beforeEach(() => {
-    xhr.onCreate = (request) => {
-      requests.push(request);
-    }
+    requests = server.requests;
     storage.removeDataFromLocalStorage(EXPERIAN_RTID_DATA_KEY, null)
     storage.removeDataFromLocalStorage(EXPERIAN_RTID_EXPIRATION_KEY, null)
     storage.removeDataFromLocalStorage(EXPERIAN_RTID_STALE_KEY, null)
@@ -27,8 +25,6 @@ describe('Experian realtime module', () => {
   })
   afterEach(() => {
     sandbox.restore();
-    xhr.restore();
-    requests = [];
   })
   // Bid request config
   const reqBidsConfigObj = {

From c772b60755a090b9a1c4a066c4d123db7d131eba Mon Sep 17 00:00:00 2001
From: "Prebid.js automated release" <prebidjs-release@prebid.org>
Date: Thu, 7 Sep 2023 16:57:34 +0000
Subject: [PATCH 03/46] Prebid 8.13.0 release

---
 package-lock.json | 2 +-
 package.json      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 82d5a79adce..bd9286ecbab 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "8.13.0-pre",
+  "version": "8.13.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
diff --git a/package.json b/package.json
index 8b9b206b57c..33e33eb07f9 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "8.13.0-pre",
+  "version": "8.13.0",
   "description": "Header Bidding Management Library",
   "main": "src/prebid.js",
   "scripts": {

From ac00929578d5ec6eebe7853f3258b245052f6c3c Mon Sep 17 00:00:00 2001
From: "Prebid.js automated release" <prebidjs-release@prebid.org>
Date: Thu, 7 Sep 2023 16:57:34 +0000
Subject: [PATCH 04/46] Increment version to 8.14.0-pre

---
 package-lock.json | 2 +-
 package.json      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index bd9286ecbab..dbfc057de9f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "8.13.0",
+  "version": "8.14.0-pre",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
diff --git a/package.json b/package.json
index 33e33eb07f9..a95acbb8cfe 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "8.13.0",
+  "version": "8.14.0-pre",
   "description": "Header Bidding Management Library",
   "main": "src/prebid.js",
   "scripts": {

From c91f3379de84a9df3365701df047d208b5b64653 Mon Sep 17 00:00:00 2001
From: Demetrio Girardi <dgirardi@prebid.org>
Date: Thu, 7 Sep 2023 10:10:53 -0700
Subject: [PATCH 05/46] Core: warn about missing GVLID on custom bidder aliases
 (#10451)

---
 src/adapterManager.js | 3 +++
 1 file changed, 3 insertions(+)

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;

From 2042919527ce82866dfe2921a1bfcdff4e55ddb4 Mon Sep 17 00:00:00 2001
From: Demetrio Girardi <dgirardi@prebid.org>
Date: Thu, 7 Sep 2023 10:58:44 -0700
Subject: [PATCH 06/46] Core: introduce new `eventHistoryTTL` and
 `minBidCacheTTL` settings to control memory usage (#10308)

* Core: introduce `eventHistoryTTL` to periodically purge events from event log

* Core: introduce `preserveBidCache` to drop stale auctions

* `minBidCacheTTL` instead of `preserveBidCache`
---
 src/auction.js                             |   7 +-
 src/auctionManager.js                      | 121 ++++++++------
 src/bidTTL.js                              |  25 +++
 src/events.js                              |  71 ++++----
 src/targeting.js                           |  12 +-
 src/utils.js                               |  28 ++++
 src/utils/ttlCollection.js                 | 139 ++++++++++++++++
 test/spec/auctionmanager_spec.js           | 169 +++++++++++++++----
 test/spec/unit/core/events_spec.js         |  30 ++++
 test/spec/unit/pbjs_api_spec.js            |  10 +-
 test/spec/unit/utils/ttlCollection_spec.js | 180 +++++++++++++++++++++
 test/spec/utils_spec.js                    |  43 ++++-
 12 files changed, 705 insertions(+), 130 deletions(-)
 create mode 100644 src/bidTTL.js
 create mode 100644 src/utils/ttlCollection.js
 create mode 100644 test/spec/unit/core/events_spec.js
 create mode 100644 test/spec/unit/utils/ttlCollection_spec.js

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

From 7210492c378f017faac7dbaaf8c3015fb64d2e24 Mon Sep 17 00:00:00 2001
From: Demetrio Girardi <dgirardi@prebid.org>
Date: Fri, 8 Sep 2023 05:41:26 -0700
Subject: [PATCH 07/46] PBS adapter: fix bug where `source.tid` is not sent
 even with `enableTIDs: true` (#10454)

---
 modules/prebidServerBidAdapter/ortbConverter.js  |  4 ++++
 test/spec/modules/prebidServerBidAdapter_spec.js | 12 ++++++------
 2 files changed, 10 insertions(+), 6 deletions(-)

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/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');
       })
     })

From a40fb1f9ff95fb4409001d7259765f86597303c0 Mon Sep 17 00:00:00 2001
From: aplio <ryo.091219@gmail.com>
Date: Fri, 8 Sep 2023 22:16:10 +0900
Subject: [PATCH 08/46] FreepassIdSystem: get userId from cookie (#10298)

---
 modules/freepassIdSystem.js                | 28 ++++---
 test/spec/modules/freepassIdSystem_spec.js | 87 +++++++---------------
 2 files changed, 43 insertions(+), 72 deletions(-)

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/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');
+    });
   });
 });

From b892374830497d8554289f08e5da680266656a89 Mon Sep 17 00:00:00 2001
From: Mike Chowla <mike.chowla@openx.com>
Date: Fri, 8 Sep 2023 06:21:41 -0700
Subject: [PATCH 09/46] OpenX: add missing gvlid (#10453)

---
 modules/openxBidAdapter.js | 1 +
 1 file changed, 1 insertion(+)

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,

From 85bb955cc76b0dc08abf9eecbb4670b9961564ce Mon Sep 17 00:00:00 2001
From: asurovenko-zeta <80847074+asurovenko-zeta@users.noreply.github.com>
Date: Mon, 11 Sep 2023 07:55:35 +0200
Subject: [PATCH 10/46] ZetaGlobalSsp AnalyticsAdapter: provide zeta params
 through cache (#10402)

* ZetaGlobalSsp Analytics Adapter: save ZetaParams to cache

* bugfix

* test

* fixes by review

---------

Co-authored-by: Surovenko Alexey <surovenko.alexey@gmail.com>
Co-authored-by: Alexey Surovenko <ASurovenko@vdhk6ddf9m.home>
---
 modules/zeta_global_sspAnalyticsAdapter.js    | 62 +++++++++++++++++-
 .../zeta_global_sspAnalyticsAdapter_spec.js   | 65 +++++++------------
 2 files changed, 83 insertions(+), 44 deletions(-)

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/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');
     });
   });
 });

From 5c8472c874cb37a9a811ec740804f533669fd300 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 11 Sep 2023 07:40:48 -0700
Subject: [PATCH 11/46] Bump tibdex/github-app-token from 1.8.2 to 2.0.0
 (#10464)

Bumps [tibdex/github-app-token](https://github.com/tibdex/github-app-token) from 1.8.2 to 2.0.0.
- [Release notes](https://github.com/tibdex/github-app-token/releases)
- [Commits](https://github.com/tibdex/github-app-token/compare/0d49dd721133f900ebd5e0dff2810704e8defbc6...0914d50df753bbc42180d982a6550f195390069f)

---
updated-dependencies:
- dependency-name: tibdex/github-app-token
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/issue_tracker.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/issue_tracker.yml b/.github/workflows/issue_tracker.yml
index 7bf92e9ede8..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@0d49dd721133f900ebd5e0dff2810704e8defbc6
+        uses: tibdex/github-app-token@0914d50df753bbc42180d982a6550f195390069f
         with:
           app_id: ${{ secrets.ISSUE_APP_ID }}
           private_key: ${{ secrets.ISSUE_APP_PEM }}

From 64349d989dfd76ee41d345183f1bcf28be409282 Mon Sep 17 00:00:00 2001
From: Denis Logachov <denis@adkernel.com>
Date: Mon, 11 Sep 2023 18:03:07 +0300
Subject: [PATCH 12/46] Adkernel: adliveconnect alias removal (#10462)

---
 modules/adkernelBidAdapter.js | 1 -
 1 file changed, 1 deletion(-)

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'},

From 36eadbd329b6525d663d0dd4ece137f2dead793f Mon Sep 17 00:00:00 2001
From: rishko00 <43280707+rishko00@users.noreply.github.com>
Date: Mon, 11 Sep 2023 18:28:05 +0300
Subject: [PATCH 13/46] SmartyadsBidAdapter/send_notifics_noly_on_prebid_host
 (#10457)

Co-authored-by: vrishko <vasyl.rishko@smartyads.com>
---
 modules/smartyadsBidAdapter.js                | 12 +++--
 test/spec/modules/smartyadsBidAdapter_spec.js | 48 +++++++++++++++++--
 2 files changed, 54 insertions(+), 6 deletions(-)

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/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);
     });
   });

From 5c9e0cff882ba3cd8e7b61b8f4ac963bdec9765a Mon Sep 17 00:00:00 2001
From: optidigital-prebid
 <124287395+optidigital-prebid@users.noreply.github.com>
Date: Mon, 11 Sep 2023 17:49:42 +0200
Subject: [PATCH 14/46] update prebid adapter (#10459)

Co-authored-by: Dawid W <dawid@optidigital.fr>
---
 modules/optidigitalBidAdapter.js              | 12 ++++++++++
 modules/optidigitalBidAdapter.md              | 13 ++++++-----
 .../modules/optidigitalBidAdapter_spec.js     | 22 +++++++++++++++++++
 3 files changed, 42 insertions(+), 5 deletions(-)

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/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);

From e626373a2eea5490017273939a021fac4179f208 Mon Sep 17 00:00:00 2001
From: Mike Lei <mike.lei@flipp.com>
Date: Mon, 11 Sep 2023 11:51:42 -0700
Subject: [PATCH 15/46] Flipp Bid Adapter : initial release (#10412)

* Flipp Bid Adapter: initial release

* Added flippBidAdapter

* OFF-372 Support DTX/Hero in flippBidAdapter (#2)

* support creativeType

* OFF-422 flippBidAdapter handle AdTypes

---------

Co-authored-by: Jairo Panduro <jpanduro@blackbird-lab.com>

* OFF-465 Add getUserKey logic to prebid.js adapter (#3)

* Support cookie sync and uid

* address pr feedback

* remove redundant check

* OFF-500 Support "startCompact" param for Prebid.JS #4

* set startCompact default value (#5)

* fix docs

* use client bidding endpoint

* update unit testing endpoint

---------

Co-authored-by: Jairo Panduro <jpanduro@blackbird-lab.com>
---
 modules/flippBidAdapter.js                | 183 ++++++++++++++++++++++
 modules/flippBidAdapter.md                |  44 ++++++
 test/spec/modules/flippBidAdapter_spec.js | 170 ++++++++++++++++++++
 3 files changed, 397 insertions(+)
 create mode 100644 modules/flippBidAdapter.js
 create mode 100644 modules/flippBidAdapter.md
 create mode 100644 test/spec/modules/flippBidAdapter_spec.js

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

From ff91af17c42cacb7036dc1e05d832fd69d0f2b63 Mon Sep 17 00:00:00 2001
From: southern-growthcode
 <79725079+southern-growthcode@users.noreply.github.com>
Date: Mon, 11 Sep 2023 15:07:41 -0400
Subject: [PATCH 16/46] GC-100 Update the hostname of the end point (#10468)

---
 modules/growthCodeAnalyticsAdapter.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

From 914cf6d2becf1e9beca252da3d6ca36355534d39 Mon Sep 17 00:00:00 2001
From: Demetrio Girardi <dgirardi@prebid.org>
Date: Mon, 11 Sep 2023 13:38:48 -0700
Subject: [PATCH 17/46] consentManagementGpp: do not require `supportedAPIs`
 from CMP (#10470)

---
 modules/consentManagementGpp.js                |  2 +-
 test/spec/modules/consentManagementGpp_spec.js | 11 +++++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

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/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', () => {

From 78269b68cc9ec8fd514def7b11e987c1bd53647f Mon Sep 17 00:00:00 2001
From: PGAMSSP <142323401+PGAMSSP@users.noreply.github.com>
Date: Tue, 12 Sep 2023 00:20:59 +0300
Subject: [PATCH 18/46] Bid adapter PGAMSSP: new adapter (#10368)

* new adapter PGAMSSP

* upd
---
 modules/pgamsspBidAdapter.js                | 212 +++++++++++
 modules/pgamsspBidAdapter.md                |  79 ++++
 test/spec/modules/pgamsspBidAdapter_spec.js | 399 ++++++++++++++++++++
 3 files changed, 690 insertions(+)
 create mode 100644 modules/pgamsspBidAdapter.js
 create mode 100644 modules/pgamsspBidAdapter.md
 create mode 100644 test/spec/modules/pgamsspBidAdapter_spec.js

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/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')
+    });
+  });
+});

From a81323f500913c24045a53ce7f29f8898929ee7e Mon Sep 17 00:00:00 2001
From: Pascal Salesch <pascal.b.salesch@gmail.com>
Date: Mon, 11 Sep 2023 23:31:50 +0200
Subject: [PATCH 19/46] Yieldlove Bid Adapter: Initial Release (#10175)

* YieldloveBidAdapter: Release

* Update modules/yieldloveBidAdapter.md

* Update modules/yieldloveBidAdapter.js

* Update yieldloveBidAdapter.md

* Update yieldloveBidAdapter_spec.js

* Update yieldloveBidAdapter.md

* always send bid request per https

* fix auctionId leak

---------

Co-authored-by: PascalSalesch <pascal.salesch@yieldlove.com>
---
 modules/yieldloveBidAdapter.js                | 149 ++++++++++++++++++
 modules/yieldloveBidAdapter.md                |  38 +++++
 test/spec/modules/yieldloveBidAdapter_spec.js | 128 +++++++++++++++
 3 files changed, 315 insertions(+)
 create mode 100644 modules/yieldloveBidAdapter.js
 create mode 100644 modules/yieldloveBidAdapter.md
 create mode 100644 test/spec/modules/yieldloveBidAdapter_spec.js

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/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&'
+      }]);
+    });
+  });
+})

From f54c6e5f52b0e4cb6bc83c30661901620f17a185 Mon Sep 17 00:00:00 2001
From: hzchen98 <hzchen98@gmail.com>
Date: Tue, 12 Sep 2023 16:26:20 +0200
Subject: [PATCH 20/46] Ssmas Bid Adapter : use iframe for user sync (#10465)

* change to https

* user sync type iframe
---
 modules/ssmasBidAdapter.js | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/modules/ssmasBidAdapter.js b/modules/ssmasBidAdapter.js
index 3005910789b..0b70a80e757 100644
--- a/modules/ssmasBidAdapter.js
+++ b/modules/ssmasBidAdapter.js
@@ -113,12 +113,19 @@ export const spec = {
       params.push(`ccpa_consent=${uspConsent.consentString}`);
     }
 
-    if (syncOptions.pixelEnabled && serverResponses.length > 0) {
+    if (syncOptions.iframeEnabled && serverResponses.length > 0) {
       syncs.push({
-        type: 'image',
-        url: `${SYNC_URL}?${params.join('&')}`
+        type: 'iframe',
+        url: `${SYNC_URL}/iframe?${params.join('&')}`
       });
     }
+
+    // if (syncOptions.pixelEnabled && serverResponses.length > 0) {
+    //   syncs.push({
+    //     type: 'image',
+    //     url: `${SYNC_URL}/image?${params.join('&')}`
+    //   });
+    // }
     return syncs;
   },
 };

From 779146a511896f0ae9cfa1ec8aad05a094b46e89 Mon Sep 17 00:00:00 2001
From: Viktor Dreiling <34981284+3link@users.noreply.github.com>
Date: Tue, 12 Sep 2023 16:35:41 +0200
Subject: [PATCH 21/46] LiveIntent UserId module: fix Ajax timeout when calling
 the collector endpoint (#10425)

* Update LiveConnect

* Separate timeout for the collctor

* Update package-lock.json

* Fix package-lock
---
 modules/liveIntentIdSystem.js |  7 ++++---
 package-lock.json             | 18 +++++++++---------
 package.json                  |  2 +-
 3 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/modules/liveIntentIdSystem.js b/modules/liveIntentIdSystem.js
index 2d9e6b63a35..8fab266ecce 100644
--- a/modules/liveIntentIdSystem.js
+++ b/modules/liveIntentIdSystem.js
@@ -12,6 +12,7 @@ import { gdprDataHandler, uspDataHandler } from '../src/adapterManager.js';
 import {getStorageManager} from '../src/storageManager.js';
 import {MODULE_TYPE_UID} from '../src/activities/modules.js';
 
+const DEFAULT_AJAX_TIMEOUT = 5000
 const EVENTS_TOPIC = 'pre_lips'
 const MODULE_NAME = 'liveIntentId';
 const LI_PROVIDER_DOMAIN = 'liveintent.com';
@@ -65,6 +66,7 @@ function parseLiveIntentCollectorConfig(collectConfig) {
   collectConfig.fpiStorageStrategy && (config.storageStrategy = collectConfig.fpiStorageStrategy);
   collectConfig.fpiExpirationDays && (config.expirationDays = collectConfig.fpiExpirationDays);
   collectConfig.collectorUrl && (config.collectorUrl = collectConfig.collectorUrl);
+  config.ajaxTimeout = collectConfig.ajaxTimeout || DEFAULT_AJAX_TIMEOUT;
   return config;
 }
 
@@ -99,9 +101,8 @@ function initializeLiveConnect(configParams) {
   if (configParams.url) {
     identityResolutionConfig.url = configParams.url
   }
-  if (configParams.ajaxTimeout) {
-    identityResolutionConfig.ajaxTimeout = configParams.ajaxTimeout;
-  }
+
+  identityResolutionConfig.ajaxTimeout = configParams.ajaxTimeout || DEFAULT_AJAX_TIMEOUT;
 
   const liveConnectConfig = parseLiveIntentCollectorConfig(configParams.liCollectConfig);
 
diff --git a/package-lock.json b/package-lock.json
index dbfc057de9f..b0de52e2d6d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -22,7 +22,7 @@
         "express": "^4.15.4",
         "fun-hooks": "^0.9.9",
         "just-clone": "^1.0.2",
-        "live-connect-js": "^6.0.0"
+        "live-connect-js": "^6.0.1"
       },
       "devDependencies": {
         "@babel/eslint-parser": "^7.16.5",
@@ -16260,12 +16260,12 @@
       }
     },
     "node_modules/live-connect-js": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/live-connect-js/-/live-connect-js-6.0.0.tgz",
-      "integrity": "sha512-4iMSeDPpueYoGEK4U152yKg+hj7jTxkzyfJUAGxtVHxdgjsjh8QmP3kLlTLBBrR/g/L/WCX47PBQxtGW9z8Rlw==",
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/live-connect-js/-/live-connect-js-6.0.1.tgz",
+      "integrity": "sha512-+TwM7cjgyutqaMNlTQKNY9nJFDPpSWfoazSHmlWxOPlimp10PSZGABIbtulNGGpYbR/Zxgc+C/uW5OxqcNEPXg==",
       "dependencies": {
         "live-connect-common": "^3.0.0",
-        "live-connect-handlers": "^2.0.0",
+        "live-connect-handlers": "^2.1.0",
         "tiny-hashes": "1.0.1"
       },
       "engines": {
@@ -37923,12 +37923,12 @@
       }
     },
     "live-connect-js": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/live-connect-js/-/live-connect-js-6.0.0.tgz",
-      "integrity": "sha512-4iMSeDPpueYoGEK4U152yKg+hj7jTxkzyfJUAGxtVHxdgjsjh8QmP3kLlTLBBrR/g/L/WCX47PBQxtGW9z8Rlw==",
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/live-connect-js/-/live-connect-js-6.0.1.tgz",
+      "integrity": "sha512-+TwM7cjgyutqaMNlTQKNY9nJFDPpSWfoazSHmlWxOPlimp10PSZGABIbtulNGGpYbR/Zxgc+C/uW5OxqcNEPXg==",
       "requires": {
         "live-connect-common": "^3.0.0",
-        "live-connect-handlers": "^2.0.0",
+        "live-connect-handlers": "^2.1.0",
         "tiny-hashes": "1.0.1"
       }
     },
diff --git a/package.json b/package.json
index a95acbb8cfe..577f10f4c17 100644
--- a/package.json
+++ b/package.json
@@ -132,7 +132,7 @@
     "express": "^4.15.4",
     "fun-hooks": "^0.9.9",
     "just-clone": "^1.0.2",
-    "live-connect-js": "^6.0.0"
+    "live-connect-js": "^6.0.1"
   },
   "optionalDependencies": {
     "fsevents": "^2.3.2"

From 4f8cf681f28f22584868cbc00be46e07e97d1d19 Mon Sep 17 00:00:00 2001
From: Vincent <vincent.r06@gmail.com>
Date: Tue, 12 Sep 2023 17:19:06 +0200
Subject: [PATCH 22/46] Grid Bid Adapter: parse timeout and bidfloor to integer
 and float values (#10461)

Co-authored-by: v.raybaud <v.raybaud@criteo.com>
---
 modules/gridBidAdapter.js                | 10 +++++-----
 test/spec/modules/gridBidAdapter_spec.js | 18 ++++++++++++++++++
 2 files changed, 23 insertions(+), 5 deletions(-)

diff --git a/modules/gridBidAdapter.js b/modules/gridBidAdapter.js
index 2e44ac46f91..aa00a84273c 100644
--- a/modules/gridBidAdapter.js
+++ b/modules/gridBidAdapter.js
@@ -91,7 +91,7 @@ export const spec = {
     let {bidderRequestId, gdprConsent, uspConsent, timeout, refererInfo, gppConsent} = bidderRequest || {};
 
     const referer = refererInfo ? encodeURIComponent(refererInfo.page) : '';
-    const tmax = timeout;
+    const tmax = parseInt(timeout) || null;
     const imp = [];
     const bidsMap = {};
     const requests = [];
@@ -133,7 +133,7 @@ export const spec = {
       };
       if (ortb2Imp) {
         if (ortb2Imp.instl) {
-          impObj.instl = ortb2Imp.instl;
+          impObj.instl = parseInt(ortb2Imp.instl) || null;
         }
 
         if (ortb2Imp.ext) {
@@ -485,7 +485,7 @@ export const spec = {
  */
 function _getFloor (mediaTypes, bid) {
   const curMediaType = mediaTypes.video ? 'video' : 'banner';
-  let floor = bid.params.bidFloor || bid.params.floorcpm || 0;
+  let floor = parseFloat(bid.params.bidFloor || bid.params.floorcpm || 0) || null;
 
   if (typeof bid.getFloor === 'function') {
     const floorInfo = bid.getFloor({
@@ -595,8 +595,8 @@ function createVideoRequest(videoParams, mediaType, bidSizes) {
 
   if (!videoData.w || !videoData.h) return;
 
-  const minDur = mind || durationRangeSec[0] || videoData.minduration;
-  const maxDur = maxd || durationRangeSec[1] || videoData.maxduration;
+  const minDur = mind || durationRangeSec[0] || parseInt(videoData.minduration) || null;
+  const maxDur = maxd || durationRangeSec[1] || parseInt(videoData.maxduration) || null;
 
   if (minDur) {
     videoData.minduration = minDur;
diff --git a/test/spec/modules/gridBidAdapter_spec.js b/test/spec/modules/gridBidAdapter_spec.js
index da51ed058be..b12083236a2 100644
--- a/test/spec/modules/gridBidAdapter_spec.js
+++ b/test/spec/modules/gridBidAdapter_spec.js
@@ -941,6 +941,15 @@ describe('TheMediaGrid Adapter', function () {
       getDataFromLocalStorageStub.restore();
     })
 
+    it('tmax should be set as integer', function() {
+      let [request] = spec.buildRequests([bidRequests[0]], {...bidderRequest, timeout: '10'});
+      let payload = parseRequest(request.data);
+      expect(payload.tmax).to.equal(10);
+      [request] = spec.buildRequests([bidRequests[0]], {...bidderRequest, timeout: 'ddqwdwdq'});
+      payload = parseRequest(request.data);
+      expect(payload.tmax).to.equal(null);
+    })
+
     describe('floorModule', function () {
       const floorTestData = {
         'currency': 'USD',
@@ -975,6 +984,15 @@ describe('TheMediaGrid Adapter', function () {
         const payload = parseRequest(request.data);
         expect(payload.imp[0].bidfloor).to.equal(bidfloor);
       });
+      it('should return the bidfloor string value if it is greater than getFloor.floor', function () {
+        const bidfloor = '1.80';
+        const bidRequestsWithFloor = { ...bidRequest };
+        bidRequestsWithFloor.params = Object.assign({bidFloor: bidfloor}, bidRequestsWithFloor.params);
+        const [request] = spec.buildRequests([bidRequestsWithFloor], bidderRequest);
+        expect(request.data).to.be.an('string');
+        const payload = parseRequest(request.data);
+        expect(payload.imp[0].bidfloor).to.equal(1.80);
+      });
     });
   });
 

From b8a39f4576fe36440e3832b8168cc326301bf823 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micka=C3=ABl=20Leclerc?= <mickael.leclerc@teads.com>
Date: Tue, 12 Sep 2023 17:26:59 +0200
Subject: [PATCH 23/46] teads Bid Adapter: get OpenGraph title (#10439)

* teadsBidAdapter: Also get OpenGraph title

* Improv + add tests

* Add tests over title + description payload length

* Add tests for catch case when cross-origin
---
 modules/teadsBidAdapter.js                |  12 ++-
 test/spec/modules/teadsBidAdapter_spec.js | 122 ++++++++++++++++++----
 2 files changed, 106 insertions(+), 28 deletions(-)

diff --git a/modules/teadsBidAdapter.js b/modules/teadsBidAdapter.js
index 570ee51df9c..6107d1a6e66 100644
--- a/modules/teadsBidAdapter.js
+++ b/modules/teadsBidAdapter.js
@@ -174,9 +174,13 @@ function getReferrerInfo(bidderRequest) {
 
 function getPageTitle() {
   try {
-    return window.top.document.title || document.title;
+    const ogTitle = window.top.document.querySelector('meta[property="og:title"]')
+
+    return window.top.document.title || (ogTitle && ogTitle.content) || '';
   } catch (e) {
-    return document.title;
+    const ogTitle = document.querySelector('meta[property="og:title"]')
+
+    return document.title || (ogTitle && ogTitle.content) || '';
   }
 }
 
@@ -185,9 +189,7 @@ function getPageDescription() {
 
   try {
     element = window.top.document.querySelector('meta[name="description"]') ||
-      window.top.document.querySelector('meta[property="og:description"]') ||
-      document.querySelector('meta[name="description"]') ||
-      document.querySelector('meta[property="og:description"]')
+      window.top.document.querySelector('meta[property="og:description"]')
   } catch (e) {
     element = document.querySelector('meta[name="description"]') ||
       document.querySelector('meta[property="og:description"]')
diff --git a/test/spec/modules/teadsBidAdapter_spec.js b/test/spec/modules/teadsBidAdapter_spec.js
index 9bd8c44b88a..b0d5f436e0b 100644
--- a/test/spec/modules/teadsBidAdapter_spec.js
+++ b/test/spec/modules/teadsBidAdapter_spec.js
@@ -1,23 +1,20 @@
 import {expect} from 'chai';
 import {spec, storage} from 'modules/teadsBidAdapter.js';
 import {newBidder} from 'src/adapters/bidderFactory.js';
-import {getStorageManager} from 'src/storageManager';
 
 const ENDPOINT = 'https://a.teads.tv/hb/bid-request';
 const AD_SCRIPT = '<script type="text/javascript" class="teads" async="true" src="https://a.teads.tv/hb/getAdSettings"></script>"';
 
 describe('teadsBidAdapter', () => {
   const adapter = newBidder(spec);
-  let cookiesAreEnabledStub, getCookieStub;
+  let sandbox;
 
   beforeEach(function () {
-    cookiesAreEnabledStub = sinon.stub(storage, 'cookiesAreEnabled');
-    getCookieStub = sinon.stub(storage, 'getCookie');
+    sandbox = sinon.sandbox.create();
   });
 
   afterEach(function () {
-    cookiesAreEnabledStub.restore();
-    getCookieStub.restore();
+    sandbox.restore();
   });
 
   describe('inherited functions', () => {
@@ -257,20 +254,99 @@ describe('teadsBidAdapter', () => {
       expect(payload.pageReferrer).to.deep.equal(document.referrer);
     });
 
-    it('should add pageTitle info to payload', function () {
-      const request = spec.buildRequests(bidRequests, bidderRequestDefault);
-      const payload = JSON.parse(request.data);
+    describe('pageTitle', function () {
+      it('should add pageTitle info to payload based on document title', function () {
+        const testText = 'This is a title';
+        sandbox.stub(window.top.document, 'title').value(testText);
+
+        const request = spec.buildRequests(bidRequests, bidderRequestDefault);
+        const payload = JSON.parse(request.data);
+
+        expect(payload.pageTitle).to.exist;
+        expect(payload.pageTitle).to.deep.equal(testText);
+      });
+
+      it('should add pageTitle info to payload based on open-graph title', function () {
+        const testText = 'This is a title from open-graph';
+        sandbox.stub(window.top.document, 'title').value('');
+        sandbox.stub(window.top.document, 'querySelector').withArgs('meta[property="og:title"]').returns({ content: testText });
+
+        const request = spec.buildRequests(bidRequests, bidderRequestDefault);
+        const payload = JSON.parse(request.data);
+
+        expect(payload.pageTitle).to.exist;
+        expect(payload.pageTitle).to.deep.equal(testText);
+      });
+
+      it('should add pageTitle info to payload sliced on 300 first characters', function () {
+        const testText = Array(500).join('a');
+        sandbox.stub(window.top.document, 'title').value(testText);
+
+        const request = spec.buildRequests(bidRequests, bidderRequestDefault);
+        const payload = JSON.parse(request.data);
+
+        expect(payload.pageTitle).to.exist;
+        expect(payload.pageTitle).to.have.length(300);
+      });
+
+      it('should add pageTitle info to payload when fallbacking from window.top', function () {
+        const testText = 'This is a fallback title';
+        sandbox.stub(window.top.document, 'querySelector').throws();
+        sandbox.stub(document, 'title').value(testText);
 
-      expect(payload.pageTitle).to.exist;
-      expect(payload.pageTitle).to.deep.equal(window.top.document.title || document.title);
+        const request = spec.buildRequests(bidRequests, bidderRequestDefault);
+        const payload = JSON.parse(request.data);
+
+        expect(payload.pageTitle).to.exist;
+        expect(payload.pageTitle).to.deep.equal(testText);
+      });
     });
 
-    it('should add pageDescription info to payload', function () {
-      const request = spec.buildRequests(bidRequests, bidderRequestDefault);
-      const payload = JSON.parse(request.data);
+    describe('pageDescription', function () {
+      it('should add pageDescription info to payload based on open-graph description', function () {
+        const testText = 'This is a description';
+        sandbox.stub(window.top.document, 'querySelector').withArgs('meta[name="description"]').returns({ content: testText });
+
+        const request = spec.buildRequests(bidRequests, bidderRequestDefault);
+        const payload = JSON.parse(request.data);
+
+        expect(payload.pageDescription).to.exist;
+        expect(payload.pageDescription).to.deep.equal(testText);
+      });
+
+      it('should add pageDescription info to payload based on open-graph description', function () {
+        const testText = 'This is a description from open-graph';
+        sandbox.stub(window.top.document, 'querySelector').withArgs('meta[property="og:description"]').returns({ content: testText });
+
+        const request = spec.buildRequests(bidRequests, bidderRequestDefault);
+        const payload = JSON.parse(request.data);
+
+        expect(payload.pageDescription).to.exist;
+        expect(payload.pageDescription).to.deep.equal(testText);
+      });
+
+      it('should add pageDescription info to payload sliced on 300 first characters', function () {
+        const testText = Array(500).join('a');
+        sandbox.stub(window.top.document, 'querySelector').withArgs('meta[name="description"]').returns({ content: testText });
+
+        const request = spec.buildRequests(bidRequests, bidderRequestDefault);
+        const payload = JSON.parse(request.data);
+
+        expect(payload.pageDescription).to.exist;
+        expect(payload.pageDescription).to.have.length(300);
+      });
+
+      it('should add pageDescription info to payload when fallbacking from window.top', function () {
+        const testText = 'This is a fallback description';
+        sandbox.stub(window.top.document, 'querySelector').throws();
+        sandbox.stub(document, 'querySelector').withArgs('meta[name="description"]').returns({ content: testText });
 
-      expect(payload.pageDescription).to.exist;
-      expect(payload.pageDescription).to.deep.equal('');
+        const request = spec.buildRequests(bidRequests, bidderRequestDefault);
+        const payload = JSON.parse(request.data);
+
+        expect(payload.pageDescription).to.exist;
+        expect(payload.pageDescription).to.deep.equal(testText);
+      });
     });
 
     it('should add timeToFirstByte info to payload', function () {
@@ -697,7 +773,7 @@ describe('teadsBidAdapter', () => {
       describe('First-party cookie Teads ID', function () {
         it('should not add firstPartyCookieTeadsId param to payload if cookies are not enabled' +
             ' and teads user id not available', function () {
-          cookiesAreEnabledStub.returns(false);
+          sandbox.stub(storage, 'cookiesAreEnabled').returns(false);
 
           const bidRequest = {
             ...baseBidRequest,
@@ -714,8 +790,8 @@ describe('teadsBidAdapter', () => {
 
         it('should not add firstPartyCookieTeadsId param to payload if cookies are enabled ' +
             'but first-party cookie and teads user id are not available', function () {
-          cookiesAreEnabledStub.returns(true);
-          getCookieStub.withArgs('_tfpvi').returns(undefined);
+          sandbox.stub(storage, 'cookiesAreEnabled').returns(true);
+          sandbox.stub(storage, 'getCookie').withArgs('_tfpvi').returns(undefined);
 
           const bidRequest = {
             ...baseBidRequest,
@@ -732,8 +808,8 @@ describe('teadsBidAdapter', () => {
 
         it('should add firstPartyCookieTeadsId from cookie if it\'s available ' +
             'and teads user id is not', function () {
-          cookiesAreEnabledStub.returns(true);
-          getCookieStub.withArgs('_tfpvi').returns('my-teads-id');
+          sandbox.stub(storage, 'cookiesAreEnabled').returns(true);
+          sandbox.stub(storage, 'getCookie').withArgs('_tfpvi').returns('my-teads-id');
 
           const bidRequest = {
             ...baseBidRequest,
@@ -751,8 +827,8 @@ describe('teadsBidAdapter', () => {
 
         it('should add firstPartyCookieTeadsId from user id module if it\'s available ' +
             'even if cookie is available too', function () {
-          cookiesAreEnabledStub.returns(true);
-          getCookieStub.withArgs('_tfpvi').returns('my-teads-id');
+          sandbox.stub(storage, 'cookiesAreEnabled').returns(true);
+          sandbox.stub(storage, 'getCookie').withArgs('_tfpvi').returns('my-teads-id');
 
           const bidRequest = {
             ...baseBidRequest,

From 4c2902f36759476482e4a0f9ab482e569b0efb7a Mon Sep 17 00:00:00 2001
From: Olivier <osazos@adagio.io>
Date: Tue, 12 Sep 2023 17:33:59 +0200
Subject: [PATCH 24/46] Adagio Analytics Adapter: new endpoint and new code to
 track auctions (#10426)

* adagio analytics adapter - track auctions

* update cpm definitions and values

* adagioAnalyticsAdapter: add GVLID

* adagioAnalyticsAdapter: update .md file

* adagioAnalyticsAdapter: add new params

* adagioAnalyticsAdapter: fix tests

---------

Co-authored-by: Francois ROTTA <frotta@adagio.io>
---
 modules/adagioAnalyticsAdapter.js             | 328 ++++++++++++++++-
 modules/adagioAnalyticsAdapter.md             |  10 +-
 .../modules/adagioAnalyticsAdapter_spec.js    | 343 +++++++++++++++++-
 3 files changed, 660 insertions(+), 21 deletions(-)

diff --git a/modules/adagioAnalyticsAdapter.js b/modules/adagioAnalyticsAdapter.js
index 96f3f089cbd..f9b79639073 100644
--- a/modules/adagioAnalyticsAdapter.js
+++ b/modules/adagioAnalyticsAdapter.js
@@ -5,16 +5,35 @@
 import adapter from '../libraries/analyticsAdapter/AnalyticsAdapter.js';
 import adapterManager from '../src/adapterManager.js';
 import CONSTANTS from '../src/constants.json';
-import { getWindowTop } from '../src/utils.js';
+import { ajax } from '../src/ajax.js';
+import { BANNER } from '../src/mediaTypes.js';
+import { getWindowTop, getWindowSelf, deepAccess, logInfo, logError } from '../src/utils.js';
+import { getGlobal } from '../src/prebidGlobal.js';
 
 const emptyUrl = '';
 const analyticsType = 'endpoint';
 const events = Object.keys(CONSTANTS.EVENTS).map(key => CONSTANTS.EVENTS[key]);
-const VERSION = '2.0.0';
+const ADAGIO_GVLID = 617;
+const VERSION = '3.0.0';
+const PREBID_VERSION = '$prebid.version$';
+const ENDPOINT = 'https://c.4dex.io/pba.gif';
+const cache = {
+  auctions: {},
+  getAuction: function(auctionId, adUnitCode) {
+    return this.auctions[auctionId][adUnitCode];
+  },
+  updateAuction: function(auctionId, adUnitCode, values) {
+    this.auctions[auctionId][adUnitCode] = {
+      ...this.auctions[auctionId][adUnitCode],
+      ...values
+    };
+  }
+};
+const enc = window.encodeURIComponent;
 
-const adagioEnqueue = function adagioEnqueue(action, data) {
-  getWindowTop().ADAGIO.queue.push({ action, data, ts: Date.now() });
-}
+/**
+/* BEGIN ADAGIO.JS CODE
+*/
 
 function canAccessTopWindow() {
   try {
@@ -24,12 +43,293 @@ function canAccessTopWindow() {
   } catch (error) {
     return false;
   }
-}
+};
+
+function getCurrentWindow() {
+  return currentWindow;
+};
+
+let currentWindow;
+
+const adagioEnqueue = function adagioEnqueue(action, data) {
+  getCurrentWindow().ADAGIO.queue.push({ action, data, ts: Date.now() });
+};
+
+/**
+* END ADAGIO.JS CODE
+*/
+
+/**
+* UTILS FUNCTIONS
+*/
+
+const guard = {
+  adagio: (value) => isAdagio(value),
+  bidTracked: (auctionId, adUnitCode) => deepAccess(cache, `auctions.${auctionId}.${adUnitCode}`, false)
+};
+
+function removeDuplicates(arr, getKey) {
+  const seen = {};
+  return arr.filter(item => {
+    const key = getKey(item);
+    return seen.hasOwnProperty(key) ? false : (seen[key] = true);
+  });
+};
+
+function getAdapterNameForAlias(aliasName) {
+  return adapterManager.aliasRegistry[aliasName] || aliasName;
+};
+
+function isAdagio(value) {
+  return value.toLowerCase().includes('adagio') ||
+    getAdapterNameForAlias(value).toLowerCase().includes('adagio');
+};
+
+function getMediaTypeAlias(mediaType) {
+  const mediaTypesMap = {
+    banner: 'ban',
+    outstream: 'vidout',
+    instream: 'vidin',
+    adpod: 'vidadpod',
+    native: 'nat'
+  };
+  return mediaTypesMap[mediaType] || mediaType;
+};
+
+/**
+* sendRequest to Adagio. It filter null values and encode each query param.
+* @param {Object} qp
+*/
+function sendRequest(qp) {
+  // Removing null values
+  qp = Object.keys(qp).reduce((acc, key) => {
+    if (qp[key] !== null) {
+      acc[key] = qp[key];
+    }
+    return acc;
+  }, {});
+
+  const url = `${ENDPOINT}?${Object.keys(qp).map(key => `${key}=${enc(qp[key])}`).join('&')}`;
+  ajax(url, null, null, {method: 'GET'});
+};
+
+/**
+ * Send a new beacon to Adagio. It increment the version of the beacon.
+ * @param {string} auctionId
+ * @param {string} adUnitCode
+ */
+function sendNewBeacon(auctionId, adUnitCode) {
+  cache.updateAuction(auctionId, adUnitCode, {
+    v: (cache.getAuction(auctionId, adUnitCode).v || 0) + 1
+  });
+  sendRequest(cache.getAuction(auctionId, adUnitCode));
+};
+
+/**
+ * END UTILS FUNCTIONS
+*/
+
+/**
+ * HANDLERS
+ * - handlerAuctionInit
+ * - handlerBidResponse
+ * - handlerBidWon
+ * - handlerAdRender
+ *
+ * Each handler is called when the event is fired.
+*/
+
+function handlerAuctionInit(event) {
+  const w = getCurrentWindow();
+
+  const prebidAuctionId = event.auctionId;
+  const adUnitCodes = removeDuplicates(event.adUnitCodes, adUnitCode => adUnitCode);
+
+  // Check if Adagio is on the bid requests.
+  // If not, we don't need to track the auction.
+  const adagioBidRequest = event.bidderRequests.find(bidRequest => isAdagio(bidRequest.bidderCode));
+  if (!adagioBidRequest) {
+    logInfo(`Adagio is not on the bid requests for auction '${prebidAuctionId}'`)
+    return;
+  }
+
+  cache.auctions[prebidAuctionId] = {};
+
+  adUnitCodes.forEach(adUnitCode => {
+    const adUnits = event.adUnits.filter(adUnit => adUnit.code === adUnitCode);
+
+    // Get all bidders configures for the ad unit.
+    const bidders = removeDuplicates(
+      adUnits.map(adUnit => adUnit.bids.map(bid => ({bidder: bid.bidder, params: bid.params}))).flat(),
+      bidder => bidder.bidder
+    );
+
+    // Check if Adagio is configured for the ad unit.
+    // If not, we don't need to track the ad unit.
+    const adagioBidder = bidders.find(bidder => isAdagio(bidder.bidder));
+    if (!adagioBidder) {
+      logInfo(`Adagio is not configured for ad unit '${adUnitCode}'`);
+      return;
+    }
+
+    // Get all media types and banner sizes configured for the ad unit.
+    const mediaTypes = adUnits.map(adUnit => adUnit.mediaTypes);
+    const mediaTypesKeys = removeDuplicates(
+      mediaTypes.map(mediaTypeObj => Object.keys(mediaTypeObj)).flat(),
+      mediaTypeKey => mediaTypeKey
+    ).map(mediaType => getMediaTypeAlias(mediaType)).sort();
+    const bannerSizes = removeDuplicates(
+      mediaTypes.filter(mediaType => mediaType.hasOwnProperty(BANNER))
+        .map(mediaType => mediaType[BANNER].sizes.map(size => size.join('x')))
+        .flat(),
+      bannerSize => bannerSize
+    ).sort();
+
+    // Get all Adagio bids for the ad unit from the bidRequest.
+    // If no bids, we don't need to track the ad unit.
+    const adagioAdUnitBids = adagioBidRequest.bids.filter(bid => bid.adUnitCode === adUnitCode);
+    if (deepAccess(adagioAdUnitBids, 'length', 0) <= 0) {
+      logInfo(`Adagio is not on the bid requests for ad unit '${adUnitCode}' and auction '${prebidAuctionId}'`)
+      return;
+    }
+    // Get Adagio params from the first bid.
+    // We assume that all Adagio bids for a same adunit have the same params.
+    const params = adagioAdUnitBids[0].params;
+
+    // Get all media types requested for Adagio.
+    const adagioMediaTypes = removeDuplicates(
+      adagioAdUnitBids.map(bid => Object.keys(bid.mediaTypes)).flat(),
+      mediaTypeKey => mediaTypeKey
+    ).flat().map(mediaType => getMediaTypeAlias(mediaType)).sort();
+
+    const qp = {
+      v: 0,
+      pbjsv: PREBID_VERSION,
+      org_id: params.organizationId,
+      site: params.site,
+      pv_id: params.pageviewId,
+      auct_id: params.adagioAuctionId,
+      adu_code: adUnitCode,
+      url_dmn: w.location.hostname,
+      dvc: params.environment,
+      pgtyp: params.pagetype,
+      plcmt: params.placement,
+      tname: params.testName || null,
+      tvname: params.testVariationName || null,
+      mts: mediaTypesKeys.join(','),
+      ban_szs: bannerSizes.join(','),
+      bdrs: bidders.map(bidder => getAdapterNameForAlias(bidder.bidder)).sort().join(','),
+      adg_mts: adagioMediaTypes.join(',')
+    };
+
+    cache.auctions[prebidAuctionId][adUnitCode] = qp;
+    sendNewBeacon(prebidAuctionId, adUnitCode);
+  });
+};
+
+/**
+ * handlerBidResponse allow to track the adagio bid response
+ * and to update the auction cache with the seat ID.
+ * No beacon is sent here.
+*/
+function handlerBidResponse(event) {
+  if (!guard.adagio(event.bidder)) {
+    return;
+  }
+
+  if (!guard.bidTracked(event.auctionId, event.adUnitCode)) {
+    return;
+  }
+
+  cache.updateAuction(event.auctionId, event.adUnitCode, {
+    adg_sid: event.seatId || null
+  });
+};
+
+function handlerBidWon(event) {
+  if (!guard.bidTracked(event.auctionId, event.adUnitCode)) {
+    return;
+  }
+
+  let adsCurRateToUSD = (event.currency === 'USD') ? 1 : null;
+  let ogCurRateToUSD = (event.originalCurrency === 'USD') ? 1 : null;
+  try {
+    if (typeof getGlobal().convertCurrency === 'function') {
+      // Currency module is loaded, we can calculate the conversion rate.
+
+      // Get the conversion rate from the original currency to USD.
+      ogCurRateToUSD = getGlobal().convertCurrency(1, event.originalCurrency, 'USD');
+      // Get the conversion rate from the ad server currency to USD.
+      adsCurRateToUSD = getGlobal().convertCurrency(1, event.currency, 'USD');
+    }
+  } catch (error) {
+    logError('Error on Adagio Analytics Adapter - handlerBidWon', error);
+  }
+
+  cache.updateAuction(event.auctionId, event.adUnitCode, {
+    win_bdr: getAdapterNameForAlias(event.bidder),
+    win_mt: getMediaTypeAlias(event.mediaType),
+    win_ban_sz: event.mediaType === BANNER ? `${event.width}x${event.height}` : null,
+
+    // ad server currency
+    win_cpm: event.cpm,
+    cur: event.currency,
+    cur_rate: adsCurRateToUSD,
+
+    // original currency from bidder
+    og_cpm: event.originalCpm,
+    og_cur: event.originalCurrency,
+    og_cur_rate: ogCurRateToUSD,
+  });
+  sendNewBeacon(event.auctionId, event.adUnitCode);
+};
+
+function handlerAdRender(event, isSuccess) {
+  const { auctionId, adUnitCode } = event.bid;
+  if (!guard.bidTracked(auctionId, adUnitCode)) {
+    return;
+  }
+
+  cache.updateAuction(auctionId, adUnitCode, {
+    rndr: isSuccess ? 1 : 0
+  });
+  sendNewBeacon(auctionId, adUnitCode);
+};
+
+/**
+ * END HANDLERS
+*/
 
 let adagioAdapter = Object.assign(adapter({ emptyUrl, analyticsType }), {
-  track: function({ eventType, args }) {
-    if (typeof args !== 'undefined' && events.indexOf(eventType) !== -1) {
-      adagioEnqueue('pb-analytics-event', { eventName: eventType, args });
+  track: function(event) {
+    const { eventType, args } = event;
+
+    try {
+      switch (eventType) {
+        case CONSTANTS.EVENTS.AUCTION_INIT:
+          handlerAuctionInit(args);
+          break;
+        case CONSTANTS.EVENTS.BID_RESPONSE:
+          handlerBidResponse(args);
+          break;
+        case CONSTANTS.EVENTS.BID_WON:
+          handlerBidWon(args);
+          break;
+        case CONSTANTS.EVENTS.AD_RENDER_SUCCEEDED:
+        case CONSTANTS.EVENTS.AD_RENDER_FAILED:
+          handlerAdRender(args, eventType === CONSTANTS.EVENTS.AD_RENDER_SUCCEEDED);
+          break;
+      }
+    } catch (error) {
+      logError('Error on Adagio Analytics Adapter', error);
+    }
+
+    try {
+      if (typeof args !== 'undefined' && events.indexOf(eventType) !== -1) {
+        adagioEnqueue('pb-analytics-event', { eventName: eventType, args });
+      }
+    } catch (error) {
+      logError('Error on Adagio Analytics Adapter - adagio.js', error);
     }
   }
 });
@@ -37,11 +337,8 @@ let adagioAdapter = Object.assign(adapter({ emptyUrl, analyticsType }), {
 adagioAdapter.originEnableAnalytics = adagioAdapter.enableAnalytics;
 
 adagioAdapter.enableAnalytics = config => {
-  if (!canAccessTopWindow()) {
-    return;
-  }
-
-  const w = getWindowTop();
+  const w = (canAccessTopWindow()) ? getWindowTop() : getWindowSelf();
+  currentWindow = w;
 
   w.ADAGIO = w.ADAGIO || {};
   w.ADAGIO.queue = w.ADAGIO.queue || [];
@@ -53,7 +350,8 @@ adagioAdapter.enableAnalytics = config => {
 
 adapterManager.registerAnalyticsAdapter({
   adapter: adagioAdapter,
-  code: 'adagio'
+  code: 'adagio',
+  gvlid: ADAGIO_GVLID,
 });
 
 export default adagioAdapter;
diff --git a/modules/adagioAnalyticsAdapter.md b/modules/adagioAnalyticsAdapter.md
index 312a26ea8da..9fc2cb0bb88 100644
--- a/modules/adagioAnalyticsAdapter.md
+++ b/modules/adagioAnalyticsAdapter.md
@@ -8,10 +8,10 @@ Maintainer: dev@adagio.io
 
 Analytics adapter for Adagio
 
-# Test Parameters
+# Settings
 
-```
-{
-  provider: 'adagio'
-}
+```js
+  pbjs.enableAnalytics({
+    provider: 'adagio',
+  });
 ```
diff --git a/test/spec/modules/adagioAnalyticsAdapter_spec.js b/test/spec/modules/adagioAnalyticsAdapter_spec.js
index 581f3cb1b87..39fb5d2d068 100644
--- a/test/spec/modules/adagioAnalyticsAdapter_spec.js
+++ b/test/spec/modules/adagioAnalyticsAdapter_spec.js
@@ -1,12 +1,14 @@
 import adagioAnalyticsAdapter from 'modules/adagioAnalyticsAdapter.js';
 import { expect } from 'chai';
 import * as utils from 'src/utils.js';
+import { getGlobal } from 'src/prebidGlobal.js';
+import { server } from 'test/mocks/xhr.js';
 
 let adapterManager = require('src/adapterManager').default;
 let events = require('src/events');
 let constants = require('src/constants.json');
 
-describe('adagio analytics adapter', () => {
+describe('adagio analytics adapter - adagio.js', () => {
   let sandbox;
   let adagioQueuePushSpy;
 
@@ -174,3 +176,342 @@ describe('adagio analytics adapter', () => {
     });
   });
 });
+
+const AUCTION_ID = '25c6d7f5-699a-4bfc-87c9-996f915341fa';
+
+const BID_ADAGIO = Object.assign({}, BID_ADAGIO, {
+  bidder: 'adagio',
+  auctionId: AUCTION_ID,
+  adUnitCode: '/19968336/header-bid-tag-1',
+  bidId: '3bd4ebb1c900e2',
+  partnerImpId: 'partnerImpressionID-2',
+  adId: 'fake_ad_id_2',
+  requestId: '3bd4ebb1c900e2',
+  width: 728,
+  height: 90,
+  mediaType: 'banner',
+  cpm: 1.42,
+  currency: 'USD',
+  originalCpm: 1.42,
+  originalCurrency: 'USD',
+  dealId: 'the-deal-id',
+  dealChannel: 'PMP',
+  mi: 'matched-impression',
+  seatBidId: 'aaaa-bbbb-cccc-dddd',
+  adserverTargeting: {
+    'hb_bidder': 'another',
+    'hb_adid': '3bd4ebb1c900e2',
+    'hb_pb': '1.500',
+    'hb_size': '728x90',
+    'hb_source': 'server'
+  },
+  meta: {
+    advertiserDomains: ['example.com']
+  },
+  seatId: '42',
+});
+
+const BID_ANOTHER = Object.assign({}, BID_ANOTHER, {
+  bidder: 'another',
+  auctionId: AUCTION_ID,
+  adUnitCode: '/19968336/header-bid-tag-1',
+  bidId: '3bd4ebb1c900e2',
+  partnerImpId: 'partnerImpressionID-2',
+  adId: 'fake_ad_id_2',
+  requestId: '3bd4ebb1c900e2',
+  width: 728,
+  height: 90,
+  mediaType: 'banner',
+  cpm: 1.71,
+  currency: 'EUR',
+  originalCpm: 1.62,
+  originalCurrency: 'GBP',
+  dealId: 'the-deal-id',
+  dealChannel: 'PMP',
+  mi: 'matched-impression',
+  seatBidId: 'aaaa-bbbb-cccc-dddd',
+  adserverTargeting: {
+    'hb_bidder': 'another',
+    'hb_adid': '3bd4ebb1c900e2',
+    'hb_pb': '1.500',
+    'hb_size': '728x90',
+    'hb_source': 'server'
+  },
+  meta: {
+    advertiserDomains: ['example.com']
+  }
+});
+
+const PARAMS_ADG = {
+  organizationId: '1001',
+  site: 'test-com',
+  pageviewId: 'a68e6d70-213b-496c-be0a-c468ff387106',
+  environment: 'desktop',
+  pagetype: 'article',
+  placement: 'pave_top'
+};
+
+const MOCK = {
+  SET_TARGETING: {
+    [BID_ADAGIO.adUnitCode]: BID_ADAGIO.adserverTargeting,
+    [BID_ANOTHER.adUnitCode]: BID_ANOTHER.adserverTargeting
+  },
+  AUCTION_INIT: {
+    'auctionId': AUCTION_ID,
+    'timestamp': 1519767010567,
+    'auctionStatus': 'inProgress',
+    'adUnits': [ {
+      'code': '/19968336/header-bid-tag-1',
+      'mediaTypes': {
+        'banner': {
+          'sizes': [
+            [
+              640,
+              480
+            ],
+            [
+              640,
+              100
+            ]
+          ]
+        }
+      },
+      'sizes': [[640, 480]],
+      'bids': [ {
+        'bidder': 'another',
+        'params': {
+          'publisherId': '1001'
+        },
+      }, {
+        'bidder': 'adagio',
+        'params': {
+          ...PARAMS_ADG
+        },
+      }, ],
+      'transactionId': 'ca4af27a-6d02-4f90-949d-d5541fa12014'
+    }, {
+      'code': '/19968336/footer-bid-tag-1',
+      'mediaTypes': {
+        'banner': {
+          'sizes': [
+            [
+              640,
+              480
+            ]
+          ]
+        }
+      },
+      'sizes': [[640, 480]],
+      'bids': [ {
+        'bidder': 'another',
+        'params': {
+          'publisherId': '1001'
+        },
+      } ],
+      'transactionId': 'ca4af27a-6d02-4f90-949d-d5541fa12014'
+    } ],
+    'adUnitCodes': ['/19968336/header-bid-tag-1', '/19968336/footer-bid-tag-1'],
+    'bidderRequests': [ {
+      'bidderCode': 'another',
+      'auctionId': AUCTION_ID,
+      'bidderRequestId': '1be65d7958826a',
+      'bids': [ {
+        'bidder': 'another',
+        'params': {
+          'publisherId': '1001',
+        },
+        'mediaTypes': {
+          'banner': {
+            'sizes': [[640, 480]]
+          }
+        },
+        'adUnitCode': '/19968336/header-bid-tag-1',
+        'transactionId': 'ca4af27a-6d02-4f90-949d-d5541fa12014',
+        'sizes': [[640, 480]],
+        'bidId': '2ecff0db240757',
+        'bidderRequestId': '1be65d7958826a',
+        'auctionId': AUCTION_ID,
+        'src': 'client',
+        'bidRequestsCount': 1
+      }, {
+        'bidder': 'another',
+        'params': {
+          'publisherId': '1001'
+        },
+        'mediaTypes': {
+          'banner': {
+            'sizes': [[640, 480]]
+          }
+        },
+        'adUnitCode': '/19968336/footer-bid-tag-1',
+        'transactionId': 'ca4af27a-6d02-4f90-949d-d5541fa12014',
+        'sizes': [[640, 480]],
+        'bidId': '2ecff0db240757',
+        'bidderRequestId': '1be65d7958826a',
+        'auctionId': AUCTION_ID,
+        'src': 'client',
+        'bidRequestsCount': 1
+      }
+      ],
+      'timeout': 3000,
+      'refererInfo': {
+        'topmostLocation': 'http://www.test.com/page.html', 'reachedTop': true, 'numIframes': 0, 'stack': ['http://www.test.com/page.html']
+      }
+    }, {
+      'bidderCode': 'adagio',
+      'auctionId': AUCTION_ID,
+      'bidderRequestId': '1be65d7958826a',
+      'bids': [ {
+        'bidder': 'adagio',
+        'params': {
+          ...PARAMS_ADG,
+          adagioAuctionId: '6fc53663-bde5-427b-ab63-baa9ed296f47'
+        },
+        'mediaTypes': {
+          'banner': {
+            'sizes': [[640, 480]]
+          }
+        },
+        'adUnitCode': '/19968336/header-bid-tag-1',
+        'transactionId': 'ca4af27a-6d02-4f90-949d-d5541fa12014',
+        'sizes': [[640, 480]],
+        'bidId': '2ecff0db240757',
+        'bidderRequestId': '1be65d7958826a',
+        'auctionId': AUCTION_ID,
+        'src': 'client',
+        'bidRequestsCount': 1
+      }
+      ],
+      'timeout': 3000,
+      'refererInfo': {
+        'topmostLocation': 'http://www.test.com/page.html', 'reachedTop': true, 'numIframes': 0, 'stack': ['http://www.test.com/page.html']
+      }
+    }
+    ],
+    'bidsReceived': [],
+    'winningBids': [],
+    'timeout': 3000
+  },
+  BID_RESPONSE: {
+    adagio: BID_ADAGIO,
+    another: BID_ANOTHER
+  },
+  BID_WON: {
+    adagio: Object.assign({}, BID_ADAGIO, {
+      'status': 'rendered'
+    }),
+    another: Object.assign({}, BID_ANOTHER, {
+      'status': 'rendered'
+    })
+  },
+  AD_RENDER_SUCCEEDED: {
+    ad: '<div>ad</div>',
+    adId: 'fake_ad_id_2',
+    bid: BID_ANOTHER
+  },
+};
+
+describe('adagio analytics adapter', () => {
+  let sandbox;
+
+  beforeEach(() => {
+    sandbox = sinon.sandbox.create();
+
+    sandbox.stub(events, 'getEvents').returns([]);
+
+    adapterManager.registerAnalyticsAdapter({
+      code: 'adagio',
+      adapter: adagioAnalyticsAdapter
+    });
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('track', () => {
+    beforeEach(() => {
+      adapterManager.enableAnalytics({
+        provider: 'adagio'
+      });
+    });
+
+    afterEach(() => {
+      adagioAnalyticsAdapter.disableAnalytics();
+    });
+
+    it('builds and sends auction data', () => {
+      getGlobal().convertCurrency = (cpm, from, to) => {
+        const convKeys = {
+          'GBP-EUR': 0.7,
+          'EUR-GBP': 1.3,
+          'USD-EUR': 0.8,
+          'EUR-USD': 1.2,
+          'USD-GBP': 0.6,
+          'GBP-USD': 1.6,
+        };
+        return cpm * (convKeys[`${from}-${to}`] || 1);
+      };
+
+      events.emit(constants.EVENTS.AUCTION_INIT, MOCK.AUCTION_INIT);
+      events.emit(constants.EVENTS.BID_RESPONSE, MOCK.BID_RESPONSE.adagio);
+      events.emit(constants.EVENTS.BID_RESPONSE, MOCK.BID_RESPONSE.another);
+      events.emit(constants.EVENTS.BID_WON, MOCK.BID_WON.another);
+      events.emit(constants.EVENTS.AD_RENDER_SUCCEEDED, MOCK.AD_RENDER_SUCCEEDED);
+
+      expect(server.requests.length).to.equal(3);
+      {
+        const { protocol, hostname, pathname, search } = utils.parseUrl(server.requests[0].url);
+        expect(protocol).to.equal('https');
+        expect(hostname).to.equal('c.4dex.io');
+        expect(pathname).to.equal('/pba.gif');
+        expect(search.v).to.equal('1');
+        expect(search.pbjsv).to.equal('$prebid.version$');
+        expect(search.auct_id).to.equal('6fc53663-bde5-427b-ab63-baa9ed296f47');
+        expect(search.adu_code).to.equal('/19968336/header-bid-tag-1');
+        expect(search.org_id).to.equal('1001');
+        expect(search.site).to.equal('test-com');
+        expect(search.pv_id).to.equal('a68e6d70-213b-496c-be0a-c468ff387106');
+        expect(search.url_dmn).to.equal(window.location.hostname);
+        expect(search.dvc).to.equal('desktop');
+        expect(search.pgtyp).to.equal('article');
+        expect(search.plcmt).to.equal('pave_top');
+        expect(search.mts).to.equal('ban');
+        expect(search.ban_szs).to.equal('640x100,640x480');
+        expect(search.bdrs).to.equal('adagio,another');
+        expect(search.adg_mts).to.equal('ban');
+      }
+
+      {
+        const { protocol, hostname, pathname, search } = utils.parseUrl(server.requests[1].url);
+        expect(protocol).to.equal('https');
+        expect(hostname).to.equal('c.4dex.io');
+        expect(pathname).to.equal('/pba.gif');
+        expect(search.v).to.equal('2');
+        expect(search.auct_id).to.equal('6fc53663-bde5-427b-ab63-baa9ed296f47');
+        expect(search.adu_code).to.equal('/19968336/header-bid-tag-1');
+        expect(search.adg_sid).to.equal('42');
+        expect(search.win_bdr).to.equal('another');
+        expect(search.win_mt).to.equal('ban');
+        expect(search.win_ban_sz).to.equal('728x90');
+        expect(search.win_cpm).to.equal('1.71');
+        expect(search.cur).to.equal('EUR');
+        expect(search.cur_rate).to.equal('1.2');
+        expect(search.og_cpm).to.equal('1.62');
+        expect(search.og_cur).to.equal('GBP');
+        expect(search.og_cur_rate).to.equal('1.6');
+      }
+
+      {
+        const { protocol, hostname, pathname, search } = utils.parseUrl(server.requests[2].url);
+        expect(protocol).to.equal('https');
+        expect(hostname).to.equal('c.4dex.io');
+        expect(pathname).to.equal('/pba.gif');
+        expect(search.v).to.equal('3');
+        expect(search.auct_id).to.equal('6fc53663-bde5-427b-ab63-baa9ed296f47');
+        expect(search.adu_code).to.equal('/19968336/header-bid-tag-1');
+        expect(search.rndr).to.equal('1');
+      }
+    });
+  });
+});

From 550a7cb040f44bb6718d35aecb497aee62856017 Mon Sep 17 00:00:00 2001
From: wojciech-bialy-wpm
 <67895844+wojciech-bialy-wpm@users.noreply.github.com>
Date: Wed, 13 Sep 2023 13:44:52 +0200
Subject: [PATCH 25/46] [sspbc-adapter] add support for topicsFPD module
 (#10416)

---
 modules/sspBCBidAdapter.js | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/modules/sspBCBidAdapter.js b/modules/sspBCBidAdapter.js
index 70db18c61e1..2b39faa02d8 100644
--- a/modules/sspBCBidAdapter.js
+++ b/modules/sspBCBidAdapter.js
@@ -12,7 +12,7 @@ const SYNC_URL = 'https://ssp.wp.pl/bidder/usersync';
 const NOTIFY_URL = 'https://ssp.wp.pl/bidder/notify';
 const GVLID = 676;
 const TMAX = 450;
-const BIDDER_VERSION = '5.9';
+const BIDDER_VERSION = '5.91';
 const DEFAULT_CURRENCY = 'PLN';
 const W = window;
 const { navigator } = W;
@@ -199,6 +199,22 @@ const applyClientHints = ortbRequest => {
   ortbRequest.user = { ...ortbRequest.user, ...ch };
 };
 
+const applyTopics = (validBidRequest, ortbRequest) => {
+  const userData = validBidRequest.ortb2?.user?.data || [];
+  const topicsData = userData.filter(dataObj => {
+    const segtax = dataObj.ext?.segtax;
+    return segtax >= 600 && segtax <= 609;
+  })[0];
+
+  // format topics obj for exchange
+  if (topicsData) {
+    topicsData.id = `${topicsData.ext.segtax}`;
+    topicsData.name = 'topics';
+    delete (topicsData.ext);
+    ortbRequest.user.data.push(topicsData);
+  }
+};
+
 const applyUserIds = (validBidRequest, ortbRequest) => {
   const eids = validBidRequest.userIdAsEids
   if (eids && eids.length) {
@@ -682,6 +698,7 @@ const spec = {
     applyGdpr(bidderRequest, payload);
     applyClientHints(payload);
     applyUserIds(validBidRequests[0], payload);
+    applyTopics(bidderRequest, payload);
 
     return {
       method: 'POST',

From 51a2b9c16ee4af040cab0a024f4a3e101a264f77 Mon Sep 17 00:00:00 2001
From: Robert Ray Martinez III <rrmartinez1552@gmail.com>
Date: Wed, 13 Sep 2023 04:45:58 -0700
Subject: [PATCH 26/46] Yieldmo - Dont require params.video (#10467)

---
 modules/yieldmoBidAdapter.js                |  4 ++--
 test/spec/modules/yieldmoBidAdapter_spec.js | 12 ++++++++++++
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/modules/yieldmoBidAdapter.js b/modules/yieldmoBidAdapter.js
index 0e2c7b4bf59..d2e97f5178e 100644
--- a/modules/yieldmoBidAdapter.js
+++ b/modules/yieldmoBidAdapter.js
@@ -432,12 +432,12 @@ function openRtbImpression(bidRequest) {
     }
   };
 
-  const mediaTypesParams = deepAccess(bidRequest, 'mediaTypes.video');
+  const mediaTypesParams = deepAccess(bidRequest, 'mediaTypes.video', {});
   Object.keys(mediaTypesParams)
     .filter(param => includes(OPENRTB_VIDEO_BIDPARAMS, param))
     .forEach(param => imp.video[param] = mediaTypesParams[param]);
 
-  const videoParams = deepAccess(bidRequest, 'params.video');
+  const videoParams = deepAccess(bidRequest, 'params.video', {});
   Object.keys(videoParams)
     .filter(param => includes(OPENRTB_VIDEO_BIDPARAMS, param))
     .forEach(param => imp.video[param] = videoParams[param]);
diff --git a/test/spec/modules/yieldmoBidAdapter_spec.js b/test/spec/modules/yieldmoBidAdapter_spec.js
index 25fe176553d..229dc05e2fa 100644
--- a/test/spec/modules/yieldmoBidAdapter_spec.js
+++ b/test/spec/modules/yieldmoBidAdapter_spec.js
@@ -425,6 +425,18 @@ describe('YieldmoAdapter', function () {
         expect(requests[0].url).to.be.equal(VIDEO_ENDPOINT);
       });
 
+      it('should not require params.video if required props in mediaTypes.video', function () {
+        videoBid.mediaTypes.video = {
+          ...videoBid.mediaTypes.video,
+          ...videoBid.params.video
+        };
+        delete videoBid.params.video;
+        const requests = build([videoBid]);
+        expect(requests.length).to.equal(1);
+        expect(requests[0].method).to.equal('POST');
+        expect(requests[0].url).to.be.equal(VIDEO_ENDPOINT);
+      });
+
       it('should add mediaTypes.video prop to the imp.video prop', function () {
         utils.deepAccess(videoBid, 'mediaTypes.video')['minduration'] = 40;
         expect(buildVideoBidAndGetVideoParam().minduration).to.equal(40);

From 66a8b6aa9369973cbcc14f3f4285114739c81257 Mon Sep 17 00:00:00 2001
From: Idan Botbol <ibotbol@undertone.com>
Date: Wed, 13 Sep 2023 14:55:37 +0300
Subject: [PATCH 27/46] Undertone Bid Adapter: adding gpid support to bid
 requests (#10414)

* * Update undertone adapter - change parameters - placementId parameter is now optional and not mandatory - undertoneBidAdapter.js

* Updated undertone bid adapter tests accordingly - undertoneBidAdapter_spec.js

* * Update undertone adapter - change parameters - placementId parameter is now optional and not mandatory - undertoneBidAdapter.js

 * Updated undertone bid adapter tests accordingly - undertoneBidAdapter_spec.js

* fix lint issue in undertone adapter spec

* added user sync function to undertone adapter

* * Update undertone adapter - change parameters - placementId parameter is now optional and not mandatory - undertoneBidAdapter.js

* Updated undertone bid adapter tests accordingly - undertoneBidAdapter_spec.js

* added user sync function to undertone adapter

* added user sync function to undertone adapter

* revert package-lock.json

* added user sync function to undertone adapter

* Update undertoneBidAdapter.js

* Update browsers.json

* Undertone: added GPP support and video plcmt

* Fix lint issues

* Undertone: added support for GPID

* identation fix

---------

Co-authored-by: omerko <omer.koren@perion.com>
Co-authored-by: Omer Koren <omerko@users.noreply.github.com>
Co-authored-by: AnnaPerion <annat@perion.com>
Co-authored-by: Oran Hollaender <oran@perion.com>
Co-authored-by: tamirnPerion <44399211+tamirnPerion@users.noreply.github.com>
Co-authored-by: tamarm <tamarm@perion.com>
Co-authored-by: tamarm <40788385+tamarm-perion@users.noreply.github.com>
Co-authored-by: Keren Gattegno <kereng@perion.com>
---
 modules/undertoneBidAdapter.js                |  1 +
 test/spec/modules/undertoneBidAdapter_spec.js | 38 ++++++++++++++-----
 2 files changed, 29 insertions(+), 10 deletions(-)

diff --git a/modules/undertoneBidAdapter.js b/modules/undertoneBidAdapter.js
index 9dcbefd374b..c7e8102ffc9 100644
--- a/modules/undertoneBidAdapter.js
+++ b/modules/undertoneBidAdapter.js
@@ -139,6 +139,7 @@ export const spec = {
         domain: domain,
         placementId: bidReq.params.placementId != undefined ? bidReq.params.placementId : null,
         publisherId: bidReq.params.publisherId,
+        gpid: deepAccess(bidReq, 'ortb2Imp.ext.gpid', deepAccess(bidReq, 'ortb2Imp.ext.data.pbadslot', '')),
         sizes: bidReq.sizes,
         params: bidReq.params
       };
diff --git a/test/spec/modules/undertoneBidAdapter_spec.js b/test/spec/modules/undertoneBidAdapter_spec.js
index 7f9c2e7b3d5..5cf53c661a9 100644
--- a/test/spec/modules/undertoneBidAdapter_spec.js
+++ b/test/spec/modules/undertoneBidAdapter_spec.js
@@ -39,12 +39,19 @@ const videoBidReq = [{
       maxDuration: 30
     }
   },
-  mediaTypes: {video: {
-    context: 'outstream',
-    playerSize: [640, 480],
-    placement: 1,
-    plcmt: 1
-  }},
+  ortb2Imp: {
+    ext: {
+      gpid: '/1111/gpid#728x90',
+    }
+  },
+  mediaTypes: {
+    video: {
+      context: 'outstream',
+      playerSize: [640, 480],
+      placement: 1,
+      plcmt: 1
+    }
+  },
   sizes: [[300, 250], [300, 600]],
   bidId: '263be71e91dd9d',
   auctionId: '9ad1fa8d-2297-4660-a018-b39945054746'
@@ -56,10 +63,19 @@ const videoBidReq = [{
     placementId: '10433395',
     publisherId: 12345
   },
-  mediaTypes: {video: {
-    context: 'outstream',
-    playerSize: [640, 480]
-  }},
+  ortb2Imp: {
+    ext: {
+      data: {
+        pbadslot: '/1111/pbadslot#728x90'
+      }
+    }
+  },
+  mediaTypes: {
+    video: {
+      context: 'outstream',
+      playerSize: [640, 480]
+    }
+  },
   sizes: [[300, 250], [300, 600]],
   bidId: '263be71e91dd9d',
   auctionId: '9ad1fa8d-2297-4660-a018-b39945054746'
@@ -463,12 +479,14 @@ describe('Undertone Adapter', () => {
       expect(bidVideo.video.skippable).to.equal(true);
       expect(bidVideo.video.placement).to.equal(1);
       expect(bidVideo.video.plcmt).to.equal(1);
+      expect(bidVideo.gpid).to.equal('/1111/gpid#728x90');
 
       expect(bidVideo2.video.skippable).to.equal(null);
       expect(bidVideo2.video.maxDuration).to.equal(null);
       expect(bidVideo2.video.playbackMethod).to.equal(null);
       expect(bidVideo2.video.placement).to.equal(null);
       expect(bidVideo2.video.plcmt).to.equal(null);
+      expect(bidVideo2.gpid).to.equal('/1111/pbadslot#728x90');
     });
     it('should send all userIds data to server', function () {
       const request = spec.buildRequests(bidReqUserIds, bidderReq);

From eb683f47a8cff1d51d7e859ad0fedcd0c223ae33 Mon Sep 17 00:00:00 2001
From: PrecisoSRL <134591565+PrecisoSRL@users.noreply.github.com>
Date: Wed, 13 Sep 2023 17:35:34 +0530
Subject: [PATCH 28/46] Preciso Bid Adapter : modified the request parameters 
 (#10436)

* New bid adapter : Preciso

* Added deafualt statement in interpretNativeAd

* removed trailing space

* Added Protected Audience API (FLEDGE) support

* updated with getConfig method f pr pulling ortb2 data

* updated the precisoBidAdapter

* updated the test cases

* changed user sync url and also fixed the CORS error

* removed test params from hello_world.html and 204 error fix

* changed responses fields in the precisoBidAdapter.js

* error fix

* removed test params

* reverted the test params

* modified the request

* removed the empty line

* removed blank line in precisoBidAdapter_spec.js

---------

Co-authored-by: Nikhil Gopal Chennissery <nikhil.gc@preciso.net>
---
 modules/precisoBidAdapter.js                | 80 +++++++++++++--------
 test/spec/modules/precisoBidAdapter_spec.js | 34 +++++----
 2 files changed, 68 insertions(+), 46 deletions(-)

diff --git a/modules/precisoBidAdapter.js b/modules/precisoBidAdapter.js
index b62d8b0c6b4..c7f7db56fd4 100644
--- a/modules/precisoBidAdapter.js
+++ b/modules/precisoBidAdapter.js
@@ -1,5 +1,5 @@
-import { logMessage } from '../src/utils.js';
-import {registerBidder} from '../src/adapters/bidderFactory.js';
+import { logMessage, isFn, deepAccess } from '../src/utils.js';
+import { registerBidder } from '../src/adapters/bidderFactory.js';
 import { BANNER, NATIVE, VIDEO } from '../src/mediaTypes.js';
 import { config } from '../src/config.js';
 import { convertOrtbRequestToProprietaryNative } from '../src/native.js';
@@ -33,16 +33,38 @@ export const spec = {
       location = winTop.location;
       logMessage(e);
     };
-    let placements = [];
-    let imp = [];
+
     let site = {
       'domain': location.domain || '',
       'page': location || ''
     }
 
     let request = {
-      'id': '123456',
-      'imp': imp,
+      id: '123456678',
+      imp: validBidRequests.map(request => {
+        const { bidId, sizes, mediaType } = request
+        const item = {
+          id: bidId,
+          region: request.params.region,
+          traffic: mediaType,
+          bidFloor: getBidFloor(request)
+        }
+
+        if (request.mediaTypes.banner) {
+          item.banner = {
+            format: (request.mediaTypes.banner.sizes || sizes).map(size => {
+              return { w: size[0], h: size[1] }
+            }),
+          }
+        }
+
+        if (request.schain) {
+          item.schain = request.schain;
+        }
+
+        return item
+      }),
+
       'site': site,
       'deviceWidth': winTop.screen.width,
       'deviceHeight': winTop.screen.height,
@@ -50,9 +72,9 @@ export const spec = {
       'secure': 1,
       'host': location.host,
       'page': location.pathname,
-      'coppa': config.getConfig('coppa') === true ? 1 : 0,
-      'placements': placements
+      'coppa': config.getConfig('coppa') === true ? 1 : 0
     };
+
     request.language.indexOf('-') != -1 && (request.language = request.language.split('-')[0])
     if (bidderRequest) {
       if (bidderRequest.uspConsent) {
@@ -66,32 +88,11 @@ export const spec = {
       }
     }
 
-    const len = validBidRequests.length;
-
-    for (let i = 0; i < len; i++) {
-      let bid = validBidRequests[i];
-      let traff = bid.params.traffic || BANNER
-      placements.push({
-        region: bid.params.region,
-        bidId: bid.bidId,
-        sizes: bid.mediaTypes && bid.mediaTypes[traff] && bid.mediaTypes[traff].sizes ? bid.mediaTypes[traff].sizes : [],
-        traffic: traff,
-        publisherId: bid.params.publisherId
-      });
-      imp.push({
-        id: bid.bidId,
-        sizes: bid.mediaTypes && bid.mediaTypes[traff] && bid.mediaTypes[traff].sizes ? bid.mediaTypes[traff].sizes : [],
-        traffic: traff,
-        publisherId: bid.params.publisherId
-      })
-      if (bid.schain) {
-        placements.schain = bid.schain;
-      }
-    }
     return {
       method: 'POST',
       url: AD_URL,
-      data: request
+      data: request,
+
     };
   },
 
@@ -143,4 +144,21 @@ export const spec = {
 
 };
 
+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 (_) {
+    return 0
+  }
+}
+
 registerBidder(spec);
diff --git a/test/spec/modules/precisoBidAdapter_spec.js b/test/spec/modules/precisoBidAdapter_spec.js
index db38845c11a..1a7e24d64cb 100644
--- a/test/spec/modules/precisoBidAdapter_spec.js
+++ b/test/spec/modules/precisoBidAdapter_spec.js
@@ -1,5 +1,5 @@
-import {expect} from 'chai';
-import {spec} from '../../../modules/precisoBidAdapter.js';
+import { expect } from 'chai';
+import { spec } from '../../../modules/precisoBidAdapter.js';
 import { config } from '../../../src/config.js';
 
 const DEFAULT_PRICE = 1
@@ -10,14 +10,19 @@ const BIDDER_CODE = 'preciso';
 
 describe('PrecisoAdapter', function () {
   let bid = {
-
     bidId: '23fhj33i987f',
     bidder: 'preciso',
+    mediaTypes: {
+      banner: {
+        sizes: [[DEFAULT_BANNER_WIDTH, DEFAULT_BANNER_HEIGHT]]
+      }
+    },
     params: {
       host: 'prebid',
       sourceid: '0',
       publisherId: '0',
-      traffic: 'banner',
+      mediaType: 'banner',
+
       region: 'prebid-eu'
 
     }
@@ -50,7 +55,9 @@ describe('PrecisoAdapter', function () {
     it('Returns valid data if array of bids is valid', function () {
       let data = serverRequest.data;
       expect(data).to.be.an('object');
-      expect(data).to.have.all.keys('id', 'imp', 'site', 'deviceWidth', 'deviceHeight', 'language', 'secure', 'host', 'page', 'placements', 'coppa');
+
+      // expect(data).to.have.all.keys('bidId', 'imp', 'site', 'deviceWidth', 'deviceHeight', 'language', 'secure', 'host', 'page', 'placements', 'coppa');
+
       expect(data.deviceWidth).to.be.a('number');
       expect(data.deviceHeight).to.be.a('number');
       expect(data.coppa).to.be.a('number');
@@ -58,26 +65,21 @@ describe('PrecisoAdapter', function () {
       expect(data.secure).to.be.within(0, 1);
       expect(data.host).to.be.a('string');
       expect(data.page).to.be.a('string');
-      let placement = data['placements'][0];
-      expect(placement).to.have.keys('region', 'bidId', 'traffic', 'sizes', 'publisherId');
-      expect(placement.bidId).to.equal('23fhj33i987f');
-      expect(placement.traffic).to.equal('banner');
-      expect(placement.region).to.equal('prebid-eu');
     });
     it('Returns empty data if no valid requests are passed', function () {
       serverRequest = spec.buildRequests([]);
       let data = serverRequest.data;
-      expect(data.placements).to.be.an('array').that.is.empty;
+      expect(data.imp).to.be.an('array').that.is.empty;
     });
   });
 
-  describe('with COPPA', function() {
-    beforeEach(function() {
+  describe('with COPPA', function () {
+    beforeEach(function () {
       sinon.stub(config, 'getConfig')
         .withArgs('coppa')
         .returns(true);
     });
-    afterEach(function() {
+    afterEach(function () {
       config.getConfig.restore();
     });
 
@@ -90,7 +92,9 @@ describe('PrecisoAdapter', function () {
   describe('interpretResponse', function () {
     it('should get correct bid response', function () {
       let response = {
-        id: 'f6adb85f-4e19-45a0-b41e-2a5b9a48f23a',
+
+        bidderRequestId: 'f6adb85f-4e19-45a0-b41e-2a5b9a48f23a',
+
         seatbid: [
           {
             bid: [

From 00b23dacbe17cc9c038f4d580546320a7fc618e4 Mon Sep 17 00:00:00 2001
From: Michael Callari <mike.callari@gmail.com>
Date: Wed, 13 Sep 2023 08:11:35 -0400
Subject: [PATCH 29/46] OptimeraRTD - Adding apiVersion param and v1 endpoint.
 (#10476)

---
 modules/optimeraRtdProvider.js                | 26 ++++++-
 modules/optimeraRtdProvider.md                |  6 +-
 test/spec/modules/optimeraRtdProvider_spec.js | 71 ++++++++++++++++++-
 3 files changed, 97 insertions(+), 6 deletions(-)

diff --git a/modules/optimeraRtdProvider.js b/modules/optimeraRtdProvider.js
index dfe8f1bfcf2..04d9b9d1b9f 100644
--- a/modules/optimeraRtdProvider.js
+++ b/modules/optimeraRtdProvider.js
@@ -16,6 +16,7 @@
  * @property {string} clientID
  * @property {string} optimeraKeyName
  * @property {string} device
+ * @property {string} apiVersion
  */
 
 import { logInfo, logError } from '../src/utils.js';
@@ -38,7 +39,10 @@ export let optimeraKeyName = 'hb_deal_optimera';
  * the targeting values.
  * @type {string}
  */
-export const scoresBaseURL = 'https://dyv1bugovvq1g.cloudfront.net/';
+export const scoresBaseURL = {
+  v0: 'https://dyv1bugovvq1g.cloudfront.net/',
+  v1: 'https://v1.oapi26b.com/',
+};
 
 /**
  * Optimera Score File URL.
@@ -58,6 +62,12 @@ export let clientID;
  */
 export let device = 'default';
 
+/**
+ * Optional apiVersion parameter.
+ * @type {string}
+ */
+export let apiVersion = 'v0';
+
 /**
  * Targeting object for all ad positions.
  * @type {string}
@@ -127,6 +137,7 @@ export function onAuctionInit(auctionDetails, config, userConsent) {
 
 /**
  * Initialize the Module.
+ * moduleConfig.params.apiVersion can be either v0 or v1.
  */
 export function init(moduleConfig) {
   _moduleParams = moduleConfig.params;
@@ -138,6 +149,9 @@ export function init(moduleConfig) {
     if (_moduleParams.device) {
       device = _moduleParams.device;
     }
+    if (_moduleParams.apiVersion) {
+      apiVersion = (_moduleParams.apiVersion.includes('v1', 'v0')) ? _moduleParams.apiVersion : 'v0';
+    }
     setScoresURL();
     scoreFileRequest();
     return true;
@@ -162,7 +176,15 @@ export function init(moduleConfig) {
 export function setScoresURL() {
   const optimeraHost = window.location.host;
   const optimeraPathName = window.location.pathname;
-  const newScoresURL = `${scoresBaseURL}${clientID}/${optimeraHost}${optimeraPathName}.js`;
+  const baseUrl = scoresBaseURL[apiVersion] ? scoresBaseURL[apiVersion] : scoresBaseURL.v0;
+  let newScoresURL;
+
+  if (apiVersion === 'v1') {
+    newScoresURL = `${baseUrl}api/products/scores?c=${clientID}&h=${optimeraHost}&p=${optimeraPathName}&s=${device}`;
+  } else {
+    newScoresURL = `${baseUrl}${clientID}/${optimeraHost}${optimeraPathName}.js`;
+  }
+
   if (scoresURL !== newScoresURL) {
     scoresURL = newScoresURL;
     fetchScoreFile = true;
diff --git a/modules/optimeraRtdProvider.md b/modules/optimeraRtdProvider.md
index 610dec537e0..8b66deb5ad5 100644
--- a/modules/optimeraRtdProvider.md
+++ b/modules/optimeraRtdProvider.md
@@ -1,6 +1,6 @@
 # Overview
 ```
-Module Name: Optimera Real Time Date Module
+Module Name: Optimera Real Time Data Module
 Module Type: RTD Module
 Maintainer: mcallari@optimera.nyc
 ```
@@ -26,7 +26,8 @@ Configuration example for using RTD module with `optimera` provider
           params: {
             clientID: '9999',
             optimeraKeyName: 'optimera',
-            device: 'de'
+            device: 'de',
+            apiVersion: 'v0',
           }
         }
       ]
@@ -42,3 +43,4 @@ Contact Optimera to get assistance with the params.
 | clientID  | string  | required | Optimera Client ID |
 | optimeraKeyName  | string  | optional |  GAM key name for Optimera. If migrating from the Optimera bidder adapter this will default to hb_deal_optimera and can be ommitted from the configuration. |
 | device  | string  | optional | Device type code for mobile, tablet, or desktop. Either mo, tb, de |
+| apiVersion  | string  | optional | Optimera API Versions. Either v0, or v1. ** Note: v1 wll need to be enabled specifically for your account, otherwise use v0.
\ No newline at end of file
diff --git a/test/spec/modules/optimeraRtdProvider_spec.js b/test/spec/modules/optimeraRtdProvider_spec.js
index aec8b79045e..8a9f000bbb9 100644
--- a/test/spec/modules/optimeraRtdProvider_spec.js
+++ b/test/spec/modules/optimeraRtdProvider_spec.js
@@ -21,13 +21,80 @@ describe('Optimera RTD sub module', () => {
   });
 });
 
-describe('Optimera RTD score file url is properly set', () => {
-  it('Proerly set the score file url', () => {
+describe('Optimera RTD score file URL is properly set for v0', () => {
+  it('should properly set the score file URL', () => {
+    const conf = {
+      dataProviders: [{
+        name: 'optimeraRTD',
+        params: {
+          clientID: '9999',
+          optimeraKeyName: 'optimera',
+          device: 'de',
+          apiVersion: 'v0',
+        }
+      }]
+    };
+    optimeraRTD.init(conf.dataProviders[0]);
+    optimeraRTD.setScores();
+    expect(optimeraRTD.apiVersion).to.equal('v0');
+    expect(optimeraRTD.scoresURL).to.equal('https://dyv1bugovvq1g.cloudfront.net/9999/localhost:9876/context.html.js');
+  });
+
+  it('should properly set the score file URL without apiVersion set', () => {
+    const conf = {
+      dataProviders: [{
+        name: 'optimeraRTD',
+        params: {
+          clientID: '9999',
+          optimeraKeyName: 'optimera',
+          device: 'de',
+        }
+      }]
+    };
+    optimeraRTD.init(conf.dataProviders[0]);
+    optimeraRTD.setScores();
+    expect(optimeraRTD.apiVersion).to.equal('v0');
+    expect(optimeraRTD.scoresURL).to.equal('https://dyv1bugovvq1g.cloudfront.net/9999/localhost:9876/context.html.js');
+  });
+
+  it('should properly set the score file URL with an api version other than v0 or v1', () => {
+    const conf = {
+      dataProviders: [{
+        name: 'optimeraRTD',
+        params: {
+          clientID: '9999',
+          optimeraKeyName: 'optimera',
+          device: 'de',
+          apiVersion: 'v15',
+        }
+      }]
+    };
+    optimeraRTD.init(conf.dataProviders[0]);
     optimeraRTD.setScores();
     expect(optimeraRTD.scoresURL).to.equal('https://dyv1bugovvq1g.cloudfront.net/9999/localhost:9876/context.html.js');
   });
 });
 
+describe('Optimera RTD score file URL is properly set for v1', () => {
+  it('should properly set the score file URL', () => {
+    const conf = {
+      dataProviders: [{
+        name: 'optimeraRTD',
+        params: {
+          clientID: '9999',
+          optimeraKeyName: 'optimera',
+          device: 'de',
+          apiVersion: 'v1',
+        }
+      }]
+    };
+    optimeraRTD.init(conf.dataProviders[0]);
+    optimeraRTD.setScores();
+    expect(optimeraRTD.apiVersion).to.equal('v1');
+    expect(optimeraRTD.scoresURL).to.equal('https://v1.oapi26b.com/api/products/scores?c=9999&h=localhost:9876&p=/context.html&s=de');
+  });
+});
+
 describe('Optimera RTD score file properly sets targeting values', () => {
   const scores = {
     'div-0': ['A1', 'A2'],

From d4203d2f5141529ef40c0bbfd3b56b0938809b27 Mon Sep 17 00:00:00 2001
From: Antonios Sarhanis <antonios@adnuntius.com>
Date: Wed, 13 Sep 2023 22:23:54 +1000
Subject: [PATCH 30/46] Adnuntius Bid Adaptor: Enable choosing bidType for cpm.
 (#10446)

- enable the use of grossBid or netBid in cpm of bid response.
---
 .../gpt/adnuntius_example.html                | 95 +++++++++++++++++++
 modules/adnuntiusBidAdapter.js                | 16 +++-
 test/spec/modules/adnuntiusBidAdapter_spec.js | 24 ++++-
 3 files changed, 129 insertions(+), 6 deletions(-)
 create mode 100644 integrationExamples/gpt/adnuntius_example.html

diff --git a/integrationExamples/gpt/adnuntius_example.html b/integrationExamples/gpt/adnuntius_example.html
new file mode 100644
index 00000000000..b61c4e0674e
--- /dev/null
+++ b/integrationExamples/gpt/adnuntius_example.html
@@ -0,0 +1,95 @@
+<html>
+<head>
+    <script async src="https://www.googletagservices.com/tag/js/gpt.js"></script>
+    <script async src="../../build/dev/prebid.js"></script>
+    <script>
+        var FAILSAFE_TIMEOUT = 3000;
+
+        var adUnits = [
+            {
+                code: 'div-gpt-ad-1683695049516-0',
+                mediaTypes: {
+                    banner: {
+                        sizes: [[320, 320]]
+                    }
+                },
+                bids: [{
+                    bidder: 'adnuntius',
+                    params: {
+                        auId: "201208",
+                        network: "adnuntius",
+                        bidType: 'netBid'
+                    }
+                }]
+            },
+        ];
+        var googletag = googletag || {};
+        googletag.cmd = googletag.cmd || [];
+        googletag.cmd.push(function() {
+            googletag.pubads().disableInitialLoad();
+        });
+
+        var pbjs = pbjs || {};
+        pbjs.que = pbjs.que || [];
+
+        pbjs.que.push(function() {
+            pbjs.setConfig({
+                enableSendAllBids: true,
+                targetingControls: {
+                    alwaysIncludeDeals: true
+                },
+                userSync: {
+                    syncEnabled: false
+                }
+            });
+
+            pbjs.setBidderConfig({
+                bidders: ['adnuntius'],
+                config: {
+                    bidType: 'netBid'
+                }
+            });
+
+            pbjs.addAdUnits(adUnits);
+            pbjs.requestBids({bidsBackHandler: initAdserver});
+        });
+
+        function initAdserver() {
+            if (pbjs.initAdserverSet) return;
+            pbjs.initAdserverSet = true;
+            googletag.cmd.push(function() {
+                pbjs.que.push(function() {
+                    pbjs.setTargetingForGPTAsync('div-gpt-ad-1683695049516-0');
+                    googletag.pubads().refresh();
+                });
+            });
+        }
+
+        // in case PBJS doesn't load
+        setTimeout(function() {
+            initAdserver();
+        }, FAILSAFE_TIMEOUT);
+
+        window.googletag = window.googletag || {cmd: []};
+        googletag.cmd.push(function() {
+            googletag.defineSlot('/19660636/320x320', [320, 320], 'div-gpt-ad-1683695049516-0').addService(googletag.pubads());
+            googletag.pubads().enableSingleRequest();
+            googletag.enableServices();
+        });
+    </script>
+</head>
+<body>
+<h2>Adnuntius Prebid Adaptor Test</h2>
+<h5>Ad Slot 1</h5>
+
+<!-- /19660636/320x320 -->
+<div id='div-gpt-ad-1683695049516-0' style='min-width: 320px; min-height: 320px;'>
+    <script>
+        googletag.cmd.push(function() {
+            googletag.display('div-gpt-ad-1683695049516-0');
+        });
+    </script>
+</div>
+
+</body>
+</html>
diff --git a/modules/adnuntiusBidAdapter.js b/modules/adnuntiusBidAdapter.js
index e44e2b1471a..a2b695e55e0 100644
--- a/modules/adnuntiusBidAdapter.js
+++ b/modules/adnuntiusBidAdapter.js
@@ -14,6 +14,7 @@ const ENDPOINT_URL_EUROPE = 'https://europe.delivery.adnuntius.com/i';
 const GVLID = 855;
 const DEFAULT_VAST_VERSION = 'vast4'
 const MAXIMUM_DEALS_LIMIT = 5;
+const VALID_BID_TYPES = ['netBid', 'grossBid'];
 
 const checkSegment = function (segment) {
   if (isStr(segment)) return segment;
@@ -48,6 +49,10 @@ const getUsi = function (meta, ortb2, bidderRequest) {
   return usi
 }
 
+const validateBidType = function(bidTypeOption) {
+  return VALID_BID_TYPES.indexOf(bidTypeOption || '') > -1 ? bidTypeOption : 'bid';
+}
+
 const AU_ID_REGEX = new RegExp('^[0-9A-Fa-f]{1,20}$');
 
 export const spec = {
@@ -126,6 +131,15 @@ export const spec = {
   interpretResponse: function (serverResponse, bidRequest) {
     const adUnits = serverResponse.body.adUnits;
 
+    let validatedBidType = validateBidType(config.getConfig().bidType);
+    if (bidRequest.bid) {
+      bidRequest.bid.forEach(b => {
+        if (b.params && b.params.bidType) {
+          validatedBidType = validateBidType(b.params.bidType);
+        }
+      });
+    }
+
     function buildAdResponse(bidderCode, ad, adUnit, dealCount) {
       const destinationUrls = ad.destinationUrls || {};
       const advertiserDomains = [];
@@ -135,7 +149,7 @@ export const spec = {
       const adResponse = {
         bidderCode: bidderCode,
         requestId: adUnit.targetId,
-        cpm: (ad.bid) ? ad.bid.amount * 1000 : 0,
+        cpm: ad[validatedBidType] ? ad[validatedBidType].amount * 1000 : 0,
         width: Number(ad.creativeWidth),
         height: Number(ad.creativeHeight),
         creativeId: ad.creativeId,
diff --git a/test/spec/modules/adnuntiusBidAdapter_spec.js b/test/spec/modules/adnuntiusBidAdapter_spec.js
index 4ddbaaa2e2a..6a77c9205ca 100644
--- a/test/spec/modules/adnuntiusBidAdapter_spec.js
+++ b/test/spec/modules/adnuntiusBidAdapter_spec.js
@@ -99,7 +99,10 @@ describe('adnuntiusBidAdapter', function() {
 
   const videoBidRequest = {
     bid: videoBidderRequest,
-    bidder: 'adnuntius'
+    bidder: 'adnuntius',
+    params: {
+      bidType: 'justsomestuff-error-handling'
+    }
   }
 
   const deals = [
@@ -749,12 +752,20 @@ describe('adnuntiusBidAdapter', function() {
 
   describe('interpretResponse', function() {
     it('should return valid response when passed valid server response', function() {
-      const interpretedResponse = spec.interpretResponse(serverResponse, singleBidRequest);
+      config.setBidderConfig({
+        bidders: ['adnuntius'],
+        config: {
+          bidType: 'netBid',
+          maxDeals: 1
+        }
+      });
+
+      const interpretedResponse = config.runWithBidder('adnuntius', () => spec.interpretResponse(serverResponse, singleBidRequest));
       expect(interpretedResponse).to.have.lengthOf(2);
 
       const deal = serverResponse.body.adUnits[0].deals[0];
       expect(interpretedResponse[0].bidderCode).to.equal('adnuntius');
-      expect(interpretedResponse[0].cpm).to.equal(deal.bid.amount * 1000);
+      expect(interpretedResponse[0].cpm).to.equal(deal.netBid.amount * 1000);
       expect(interpretedResponse[0].width).to.equal(Number(deal.creativeWidth));
       expect(interpretedResponse[0].height).to.equal(Number(deal.creativeHeight));
       expect(interpretedResponse[0].creativeId).to.equal(deal.creativeId);
@@ -770,7 +781,7 @@ describe('adnuntiusBidAdapter', function() {
 
       const ad = serverResponse.body.adUnits[0].ads[0];
       expect(interpretedResponse[1].bidderCode).to.equal('adnuntius');
-      expect(interpretedResponse[1].cpm).to.equal(ad.bid.amount * 1000);
+      expect(interpretedResponse[1].cpm).to.equal(ad.netBid.amount * 1000);
       expect(interpretedResponse[1].width).to.equal(Number(ad.creativeWidth));
       expect(interpretedResponse[1].height).to.equal(Number(ad.creativeHeight));
       expect(interpretedResponse[1].creativeId).to.equal(ad.creativeId);
@@ -808,6 +819,9 @@ describe('adnuntiusBidAdapter', function() {
           {
             bidder: 'adn-alt',
             bidId: 'adn-0000000000000551',
+            params: {
+              bidType: 'netBid'
+            }
           }
         ]
       };
@@ -818,7 +832,7 @@ describe('adnuntiusBidAdapter', function() {
 
       const ad = serverResponse.body.adUnits[0].ads[0];
       expect(interpretedResponse[0].bidderCode).to.equal('adn-alt');
-      expect(interpretedResponse[0].cpm).to.equal(ad.bid.amount * 1000);
+      expect(interpretedResponse[0].cpm).to.equal(ad.netBid.amount * 1000);
       expect(interpretedResponse[0].width).to.equal(Number(ad.creativeWidth));
       expect(interpretedResponse[0].height).to.equal(Number(ad.creativeHeight));
       expect(interpretedResponse[0].creativeId).to.equal(ad.creativeId);

From 725ed6036f1110d92e78d336ecea357fd5324afd Mon Sep 17 00:00:00 2001
From: JonGoSonobi <jgo@sonobi.com>
Date: Wed, 13 Sep 2023 14:57:58 -0400
Subject: [PATCH 31/46] Sonobi Bid Adapter : send video playbackmethod and
 placement in the bid request (#10474)

* Send video playbackmethod and placement in the bid request to Sonobi

* added a separate field for plcmt
---
 modules/sonobiBidAdapter.js                | 32 ++++++++++++++--------
 test/spec/modules/sonobiBidAdapter_spec.js |  7 +++--
 2 files changed, 26 insertions(+), 13 deletions(-)

diff --git a/modules/sonobiBidAdapter.js b/modules/sonobiBidAdapter.js
index 704275cc1bf..b40ff9a65c9 100644
--- a/modules/sonobiBidAdapter.js
+++ b/modules/sonobiBidAdapter.js
@@ -60,23 +60,15 @@ export const spec = {
    */
   buildRequests: (validBidRequests, bidderRequest) => {
     const bids = validBidRequests.map(bid => {
-      let mediaType;
-
-      if (deepAccess(bid, 'mediaTypes.video')) {
-        mediaType = 'video';
-      } else if (deepAccess(bid, 'mediaTypes.banner')) {
-        mediaType = 'display';
-      }
-
       let slotIdentifier = _validateSlot(bid);
       if (/^[\/]?[\d]+[[\/].+[\/]?]?$/.test(slotIdentifier)) {
         slotIdentifier = slotIdentifier.charAt(0) === '/' ? slotIdentifier : '/' + slotIdentifier;
         return {
-          [`${slotIdentifier}|${bid.bidId}`]: `${_validateSize(bid)}|${_validateFloor(bid)}${_validateGPID(bid)}${_validateMediaType(mediaType)}`
+          [`${slotIdentifier}|${bid.bidId}`]: `${_validateSize(bid)}|${_validateFloor(bid)}${_validateGPID(bid)}${_validateMediaType(bid)}`
         }
       } else if (/^[0-9a-fA-F]{20}$/.test(slotIdentifier) && slotIdentifier.length === 20) {
         return {
-          [bid.bidId]: `${slotIdentifier}|${_validateSize(bid)}|${_validateFloor(bid)}${_validateGPID(bid)}${_validateMediaType(mediaType)}`
+          [bid.bidId]: `${slotIdentifier}|${_validateSize(bid)}|${_validateFloor(bid)}${_validateGPID(bid)}${_validateMediaType(bid)}`
         }
       } else {
         logError(`The ad unit code or Sonobi Placement id for slot ${bid.bidId} is invalid`);
@@ -336,10 +328,28 @@ function _validateGPID(bid) {
   return ''
 }
 
-function _validateMediaType(mediaType) {
+function _validateMediaType(bidRequest) {
+  let mediaType;
+  if (deepAccess(bidRequest, 'mediaTypes.video')) {
+    mediaType = 'video';
+  } else if (deepAccess(bidRequest, 'mediaTypes.banner')) {
+    mediaType = 'display';
+  }
+
   let mediaTypeValidation = '';
   if (mediaType === 'video') {
     mediaTypeValidation = 'c=v,';
+    if (deepAccess(bidRequest, 'mediaTypes.video.playbackmethod')) {
+      mediaTypeValidation = `${mediaTypeValidation}pm=${deepAccess(bidRequest, 'mediaTypes.video.playbackmethod').join(':')},`;
+    }
+    if (deepAccess(bidRequest, 'mediaTypes.video.placement')) {
+      let placement = deepAccess(bidRequest, 'mediaTypes.video.placement');
+      mediaTypeValidation = `${mediaTypeValidation}p=${placement},`;
+    }
+    if (deepAccess(bidRequest, 'mediaTypes.video.plcmt')) {
+      let plcmt = deepAccess(bidRequest, 'mediaTypes.video.plcmt');
+      mediaTypeValidation = `${mediaTypeValidation}pl=${plcmt},`;
+    }
   } else if (mediaType === 'display') {
     mediaTypeValidation = 'c=d,';
   }
diff --git a/test/spec/modules/sonobiBidAdapter_spec.js b/test/spec/modules/sonobiBidAdapter_spec.js
index de8d0a5bda7..b179f870e0d 100644
--- a/test/spec/modules/sonobiBidAdapter_spec.js
+++ b/test/spec/modules/sonobiBidAdapter_spec.js
@@ -295,7 +295,10 @@ describe('SonobiBidAdapter', function () {
       mediaTypes: {
         video: {
           playerSize: [640, 480],
-          context: 'outstream'
+          context: 'outstream',
+          playbackmethod: [1, 2, 3],
+          plcmt: 3,
+          placement: 2
         }
       }
     },
@@ -339,7 +342,7 @@ describe('SonobiBidAdapter', function () {
     }];
 
     let keyMakerData = {
-      '30b31c1838de1f': '1a2b3c4d5e6f1a2b3c4d|640x480|f=1.25,gpid=/123123/gpt_publisher/adunit-code-1,c=v,',
+      '30b31c1838de1f': '1a2b3c4d5e6f1a2b3c4d|640x480|f=1.25,gpid=/123123/gpt_publisher/adunit-code-1,c=v,pm=1:2:3,p=2,pl=3,',
       '30b31c1838de1d': '1a2b3c4d5e6f1a2b3c4e|300x250,300x600|f=0.42,gpid=/123123/gpt_publisher/adunit-code-3,c=d,',
       '/7780971/sparks_prebid_LB|30b31c1838de1e': '300x250,300x600|gpid=/7780971/sparks_prebid_LB,c=d,',
     };

From bc2f3f63f172578cc6a7ea7e342fd88964d062e2 Mon Sep 17 00:00:00 2001
From: hkimmgni <144719203+hkimmgni@users.noreply.github.com>
Date: Wed, 13 Sep 2023 15:35:23 -0400
Subject: [PATCH 32/46] Add rubicon size 632 and 634 (#10481)

---
 modules/rubiconBidAdapter.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/modules/rubiconBidAdapter.js b/modules/rubiconBidAdapter.js
index 2c2a02e1949..8e083a43505 100644
--- a/modules/rubiconBidAdapter.js
+++ b/modules/rubiconBidAdapter.js
@@ -139,7 +139,9 @@ var sizeMap = {
   576: '610x877',
   578: '980x552',
   580: '505x656',
-  622: '192x160'
+  622: '192x160',
+  632: '1200x450',
+  634: '340x450'
 };
 
 _each(sizeMap, (item, key) => sizeMap[item] = key);

From 50bcec38aa0c671406aacfde9bc570a59a0749fc Mon Sep 17 00:00:00 2001
From: AndreaC <67786179+darkstarac@users.noreply.github.com>
Date: Wed, 13 Sep 2023 21:37:10 +0200
Subject: [PATCH 33/46] AIDEM Bidder Adapter: ortbConverter (#10391)

* AIDEM Bid Adapter

* Added _spec.js

* update

* Fix Navigator in _spec.js

* Removed timeout handler.

* Added publisherId as required bidder params

* moved publisherId into site publisher object

* Added wpar to environment

* Added placementId parameter

* added unit tests for the wpar environment object

* PlacementId is now a required parameter
Added optional rateLimit parameter
Added publisherId, siteId, placementId in win notice payload
Added unit tests

* Revert to optional placementId parameter
Added missing semicolons

* Extended win notice

* Added arbitrary ext field to win notice

* Moved aidemBidAdapter implementation to comply with ortbConverter

* disabled video-specific tests

---------

Co-authored-by: Giovanni Sollazzo <gs@aidem.com>
Co-authored-by: darkstar <canazza@wazabit.it>
Co-authored-by: Andrea Tumbarello <Wazabit@users.noreply.github.com>
---
 modules/aidemBidAdapter.js                | 371 +++--------------
 test/spec/modules/aidemBidAdapter_spec.js | 483 +++++++---------------
 2 files changed, 222 insertions(+), 632 deletions(-)

diff --git a/modules/aidemBidAdapter.js b/modules/aidemBidAdapter.js
index 7469f26156b..c6a5cd96fb6 100644
--- a/modules/aidemBidAdapter.js
+++ b/modules/aidemBidAdapter.js
@@ -1,27 +1,15 @@
-import {
-  _each,
-  contains,
-  deepAccess,
-  deepSetValue,
-  getDNT,
-  isBoolean,
-  isNumber,
-  isStr,
-  logError,
-  logInfo
-} from '../src/utils.js';
+import {deepAccess, deepSetValue, isBoolean, isNumber, isStr, logError, logInfo} from '../src/utils.js';
 import {config} from '../src/config.js';
 import {BANNER, VIDEO} from '../src/mediaTypes.js';
 import {registerBidder} from '../src/adapters/bidderFactory.js';
 import {getRefererInfo} from '../src/refererDetection.js';
 import {ajax} from '../src/ajax.js';
+import {ortbConverter} from '../libraries/ortbConverter/converter.js';
 
 const BIDDER_CODE = 'aidem';
 const BASE_URL = 'https://zero.aidemsrv.com';
 const LOCAL_BASE_URL = 'http://127.0.0.1:8787';
 
-const AVAILABLE_CURRENCIES = ['USD'];
-const DEFAULT_CURRENCY = ['USD']; // NOTE - USD is the only supported currency right now; Hardcoded for bids
 const SUPPORTED_MEDIA_TYPES = [BANNER, VIDEO];
 const REQUIRED_VIDEO_PARAMS = [ 'mimes', 'protocols', 'context' ];
 
@@ -37,34 +25,63 @@ export const ERROR_CODES = {
 };
 
 const endpoints = {
-  request: `${BASE_URL}/bid/request`,
-  notice: {
-    win: `${BASE_URL}/notice/win`,
-    timeout: `${BASE_URL}/notice/timeout`,
-    error: `${BASE_URL}/notice/error`,
-  }
+  request: `${BASE_URL}/prebidjs/ortb/v2.6/bid/request`,
+  // notice: {
+  //   win: `${BASE_URL}/notice/win`,
+  //   timeout: `${BASE_URL}/notice/timeout`,
+  //   error: `${BASE_URL}/notice/error`,
+  // }
 };
 
-export function setEndPoints(env = null, path = '', mediaType = BANNER) {
+export function setEndPoints(env = null, path = '') {
   switch (env) {
     case 'local':
-      endpoints.request = mediaType === BANNER ? `${LOCAL_BASE_URL}${path}/bid/request` : `${LOCAL_BASE_URL}${path}/bid/videorequest`;
-      endpoints.notice.win = `${LOCAL_BASE_URL}${path}/notice/win`;
-      endpoints.notice.error = `${LOCAL_BASE_URL}${path}/notice/error`;
-      endpoints.notice.timeout = `${LOCAL_BASE_URL}${path}/notice/timeout`;
+      endpoints.request = `${LOCAL_BASE_URL}${path}/prebidjs/ortb/v2.6/bid/request`;
       break;
     case 'main':
-      endpoints.request = mediaType === BANNER ? `${BASE_URL}${path}/bid/request` : `${BASE_URL}${path}/bid/videorequest`;
-      endpoints.notice.win = `${BASE_URL}${path}/notice/win`;
-      endpoints.notice.error = `${BASE_URL}${path}/notice/error`;
-      endpoints.notice.timeout = `${BASE_URL}${path}/notice/timeout`;
+      endpoints.request = `${BASE_URL}${path}/prebidjs/ortb/v2.6/bid/request`;
       break;
   }
   return endpoints;
 }
 
 config.getConfig('aidem', function (config) {
-  if (config.aidem.env) { setEndPoints(config.aidem.env, config.aidem.path, config.aidem.mediaType); }
+  if (config.aidem.env) { setEndPoints(config.aidem.env, config.aidem.path); }
+});
+
+const converter = ortbConverter({
+  context: {
+    netRevenue: true,
+    ttl: 30
+  },
+  request(buildRequest, imps, bidderRequest, context) {
+    logInfo('Building request');
+    const request = buildRequest(imps, bidderRequest, context);
+    deepSetValue(request, 'at', 1);
+    setPrebidRequestEnvironment(request);
+    deepSetValue(request, 'regs', getRegs());
+    deepSetValue(request, 'site.publisher.id', bidderRequest.bids[0].params.publisherId);
+    deepSetValue(request, 'site.id', bidderRequest.bids[0].params.siteId);
+    return request;
+  },
+  imp(buildImp, bidRequest, context) {
+    logInfo('Building imp bidRequest', bidRequest);
+    const imp = buildImp(bidRequest, context);
+    deepSetValue(imp, 'tagId', bidRequest.params.placementId);
+    return imp;
+  },
+  bidResponse(buildBidResponse, bid, context) {
+    const {bidRequest} = context;
+    const bidResponse = buildBidResponse(bid, context);
+    logInfo('Building bidResponse');
+    logInfo('bid', bid);
+    logInfo('bidRequest', bidRequest);
+    logInfo('bidResponse', bidResponse);
+    if (bidResponse.mediaType === VIDEO) {
+      deepSetValue(bidResponse, 'vastUrl', bid.adm);
+    }
+    return bidResponse;
+  }
 });
 
 // AIDEM Custom FN
@@ -89,49 +106,6 @@ function recur(obj) {
   return result;
 }
 
-// =================================================================================
-function getConnectionType() {
-  const connection = navigator.connection || navigator.webkitConnection;
-  if (!connection) {
-    return 0;
-  }
-  switch (connection.type) {
-    case 'ethernet':
-      return 1;
-    case 'wifi':
-      return 2;
-    case 'cellular':
-      switch (connection.effectiveType) {
-        case 'slow-2g':
-          return 4;
-        case '2g':
-          return 4;
-        case '3g':
-          return 5;
-        case '4g':
-          return 6;
-        case '5g':
-          return 7;
-        default:
-          return 3;
-      }
-    default:
-      return 0;
-  }
-}
-
-function getDevice() {
-  const language = navigator.language || navigator.browserLanguage || navigator.userLanguage || navigator.systemLanguage;
-  return {
-    ua: navigator.userAgent,
-    dnt: !!getDNT(),
-    language: language,
-    connectiontype: getConnectionType(),
-    screen_width: screen.width,
-    screen_height: screen.height
-  };
-}
-
 function getRegs() {
   let regs = {};
   const consentManagement = config.getConfig('consentManagement');
@@ -157,129 +131,6 @@ function getRegs() {
   return regs;
 }
 
-function getPageUrl(bidderRequest) {
-  return bidderRequest?.refererInfo?.page;
-}
-
-function buildWinNotice(bid) {
-  const params = bid.params[0];
-  const app = deepAccess(bid, 'meta.ext.app')
-  const winNoticeExt = deepAccess(bid, 'meta.ext.win_notice_ext')
-  return {
-    publisherId: params.publisherId,
-    siteId: params.siteId,
-    placementId: params.placementId,
-    burl: deepAccess(bid, 'meta.burl'),
-    cpm: bid.cpm,
-    currency: bid.currency,
-    impid: deepAccess(bid, 'meta.impid'),
-    dsp_id: deepAccess(bid, 'meta.dsp_id'),
-    adUnitCode: bid.adUnitCode,
-    // TODO: fix auctionId/transactionId leak: https://github.com/prebid/Prebid.js/issues/9781
-    auctionId: bid.auctionId,
-    transactionId: bid.transactionId,
-    ttl: bid.ttl,
-    requestTimestamp: bid.requestTimestamp,
-    responseTimestamp: bid.responseTimestamp,
-    mediatype: bid.mediaType,
-    environment: app ? 'app' : 'web',
-    ...app,
-    ext: winNoticeExt,
-  };
-}
-
-function buildErrorNotice(prebidErrorResponse) {
-  return {
-    message: `Prebid.js: Server call for ${prebidErrorResponse.bidderCode} failed.`,
-    url: encodeURIComponent(getPageUrl(prebidErrorResponse)),
-    auctionId: prebidErrorResponse.auctionId,
-    bidderRequestId: prebidErrorResponse.bidderRequestId,
-    metrics: {}
-  };
-}
-
-function hasValidFloor(obj) {
-  if (!obj) return false;
-  const hasValue = !isNaN(Number(obj.value));
-  const hasCurrency = contains(AVAILABLE_CURRENCIES, obj.currency);
-  return hasValue && hasCurrency;
-}
-
-function getMediaType(bidRequest) {
-  if ((bidRequest.mediaTypes && bidRequest.mediaTypes.hasOwnProperty('video')) || bidRequest.params.hasOwnProperty('video')) { return VIDEO; }
-  return BANNER;
-}
-
-function getPrebidRequestFields(bidderRequest, bidRequests) {
-  const payload = {};
-  // Base Payload Data
-  deepSetValue(payload, 'id', bidderRequest.bidderRequestId);
-  // Impressions
-  setPrebidImpressionObject(bidRequests, payload);
-  // Device
-  deepSetValue(payload, 'device', getDevice());
-  // Timeout
-  deepSetValue(payload, 'tmax', bidderRequest.timeout);
-  // Currency
-  deepSetValue(payload, 'cur', DEFAULT_CURRENCY);
-  // Timezone
-  deepSetValue(payload, 'tz', new Date().getTimezoneOffset());
-  // Privacy Regs
-  deepSetValue(payload, 'regs', getRegs());
-  // Site
-  setPrebidSiteObject(bidderRequest, payload);
-  // Environment
-  setPrebidRequestEnvironment(payload);
-  // AT auction type
-  deepSetValue(payload, 'at', 1);
-
-  return payload;
-}
-
-function setPrebidImpressionObject(bidRequests, payload) {
-  payload.imp = [];
-  _each(bidRequests, function (bidRequest) {
-    const impressionObject = {};
-    // Placement or ad tag used to initiate the auction
-    deepSetValue(impressionObject, 'id', bidRequest.bidId);
-    // Transaction id
-    // TODO: `imp.tid` is not ORTB, is this intentional?
-    deepSetValue(impressionObject, 'tid', deepAccess(bidRequest, 'ortb2Imp.ext.tid'));
-    // placement id
-    deepSetValue(impressionObject, 'tagid', deepAccess(bidRequest, 'params.placementId', null));
-    // Publisher id
-    deepSetValue(payload, 'site.publisher.id', deepAccess(bidRequest, 'params.publisherId'));
-    // Site id
-    deepSetValue(payload, 'site.id', deepAccess(bidRequest, 'params.siteId'));
-    const mediaType = getMediaType(bidRequest);
-    switch (mediaType) {
-      case 'banner':
-        setPrebidImpressionObjectBanner(bidRequest, impressionObject);
-        break;
-      case 'video':
-        setPrebidImpressionObjectVideo(bidRequest, impressionObject);
-        break;
-    }
-
-    // Floor (optional)
-    setPrebidImpressionObjectFloor(bidRequest, impressionObject);
-
-    impressionObject.imp_ext = {};
-
-    payload.imp.push(impressionObject);
-  });
-}
-
-function setPrebidSiteObject(bidderRequest, payload) {
-  deepSetValue(payload, 'site.domain', deepAccess(bidderRequest, 'refererInfo.domain'));
-  deepSetValue(payload, 'site.page', deepAccess(bidderRequest, 'refererInfo.page'));
-  deepSetValue(payload, 'site.referer', deepAccess(bidderRequest, 'refererInfo.ref'));
-  deepSetValue(payload, 'site.cat', deepAccess(bidderRequest, 'ortb2.site.cat'));
-  deepSetValue(payload, 'site.sectioncat', deepAccess(bidderRequest, 'ortb2.site.sectioncat'));
-  deepSetValue(payload, 'site.keywords', deepAccess(bidderRequest, 'ortb2.site.keywords'));
-  deepSetValue(payload, 'site.site_ext', deepAccess(bidderRequest, 'ortb2.site.ext')); // see https://docs.prebid.org/features/firstPartyData.html
-}
-
 function setPrebidRequestEnvironment(payload) {
   const __navigator = JSON.parse(JSON.stringify(recur(navigator)));
   delete __navigator.plugins;
@@ -296,92 +147,6 @@ function setPrebidRequestEnvironment(payload) {
   deepSetValue(payload, 'environment.wpar.innerHeight', window.innerHeight);
 }
 
-function setPrebidImpressionObjectFloor(bidRequest, impressionObject) {
-  const floor = deepAccess(bidRequest, 'params.floor');
-  if (hasValidFloor(floor)) {
-    deepSetValue(impressionObject, 'floor.value', floor.value);
-    deepSetValue(impressionObject, 'floor.currency', floor.currency);
-  }
-}
-
-function setPrebidImpressionObjectBanner(bidRequest, impressionObject) {
-  deepSetValue(impressionObject, 'mediatype', BANNER);
-  deepSetValue(impressionObject, 'banner.topframe', 1);
-  deepSetValue(impressionObject, 'banner.format', []);
-  _each(bidRequest.mediaTypes.banner.sizes, function (bannerFormat) {
-    const format = {};
-    deepSetValue(format, 'w', bannerFormat[0]);
-    deepSetValue(format, 'h', bannerFormat[1]);
-    deepSetValue(format, 'format_ext', {});
-    impressionObject.banner.format.push(format);
-  });
-}
-
-function setPrebidImpressionObjectVideo(bidRequest, impressionObject) {
-  deepSetValue(impressionObject, 'mediatype', VIDEO);
-  deepSetValue(impressionObject, 'video.format', []);
-  deepSetValue(impressionObject, 'video.mimes', bidRequest.mediaTypes.video.mimes);
-  deepSetValue(impressionObject, 'video.minDuration', bidRequest.mediaTypes.video.minduration);
-  deepSetValue(impressionObject, 'video.maxDuration', bidRequest.mediaTypes.video.maxduration);
-  deepSetValue(impressionObject, 'video.protocols', bidRequest.mediaTypes.video.protocols);
-  deepSetValue(impressionObject, 'video.context', bidRequest.mediaTypes.video.context);
-  deepSetValue(impressionObject, 'video.playbackmethod', bidRequest.mediaTypes.video.playbackmethod);
-  deepSetValue(impressionObject, 'skip', bidRequest.mediaTypes.video.skip);
-  deepSetValue(impressionObject, 'skipafter', bidRequest.mediaTypes.video.skipafter);
-  deepSetValue(impressionObject, 'video.pos', bidRequest.mediaTypes.video.pos);
-  _each(bidRequest.mediaTypes.video.playerSize, function (videoPlayerSize) {
-    const format = {};
-    deepSetValue(format, 'w', videoPlayerSize[0]);
-    deepSetValue(format, 'h', videoPlayerSize[1]);
-    deepSetValue(format, 'format_ext', {});
-    impressionObject.video.format.push(format);
-  });
-}
-
-function getPrebidResponseBidObject(openRTBResponseBidObject) {
-  const prebidResponseBidObject = {};
-  // Common properties
-  deepSetValue(prebidResponseBidObject, 'requestId', openRTBResponseBidObject.impid);
-  deepSetValue(prebidResponseBidObject, 'cpm', parseFloat(openRTBResponseBidObject.price));
-  deepSetValue(prebidResponseBidObject, 'creativeId', openRTBResponseBidObject.crid);
-  deepSetValue(prebidResponseBidObject, 'currency', openRTBResponseBidObject.cur ? openRTBResponseBidObject.cur.toUpperCase() : DEFAULT_CURRENCY);
-  deepSetValue(prebidResponseBidObject, 'width', openRTBResponseBidObject.w);
-  deepSetValue(prebidResponseBidObject, 'height', openRTBResponseBidObject.h);
-  deepSetValue(prebidResponseBidObject, 'dealId', openRTBResponseBidObject.dealid);
-  deepSetValue(prebidResponseBidObject, 'netRevenue', true);
-  deepSetValue(prebidResponseBidObject, 'ttl', 60000);
-
-  if (openRTBResponseBidObject.mediatype === VIDEO) {
-    logInfo('bidObject.mediatype == VIDEO');
-    deepSetValue(prebidResponseBidObject, 'mediaType', VIDEO);
-    deepSetValue(prebidResponseBidObject, 'vastUrl', openRTBResponseBidObject.adm);
-  } else {
-    logInfo('bidObject.mediatype == BANNER');
-    deepSetValue(prebidResponseBidObject, 'mediaType', BANNER);
-    deepSetValue(prebidResponseBidObject, 'ad', openRTBResponseBidObject.adm);
-  }
-  setPrebidResponseBidObjectMeta(prebidResponseBidObject, openRTBResponseBidObject);
-  return prebidResponseBidObject;
-}
-
-function setPrebidResponseBidObjectMeta(prebidResponseBidObject, openRTBResponseBidObject) {
-  logInfo('AIDEM Bid Adapter meta', openRTBResponseBidObject);
-  deepSetValue(prebidResponseBidObject, 'meta.advertiserDomains', deepAccess(openRTBResponseBidObject, 'meta.advertiserDomains'));
-  deepSetValue(prebidResponseBidObject, 'meta.ext', deepAccess(openRTBResponseBidObject, 'meta.ext'));
-  if (openRTBResponseBidObject.cat && Array.isArray(openRTBResponseBidObject.cat)) {
-    const primaryCatId = openRTBResponseBidObject.cat.shift();
-    deepSetValue(prebidResponseBidObject, 'meta.primaryCatId', primaryCatId);
-    deepSetValue(prebidResponseBidObject, 'meta.secondaryCatIds', openRTBResponseBidObject.cat);
-  }
-  deepSetValue(prebidResponseBidObject, 'meta.id', openRTBResponseBidObject.id);
-  deepSetValue(prebidResponseBidObject, 'meta.dsp_id', openRTBResponseBidObject.dsp_id);
-  deepSetValue(prebidResponseBidObject, 'meta.adid', openRTBResponseBidObject.adid);
-  deepSetValue(prebidResponseBidObject, 'meta.burl', openRTBResponseBidObject.burl);
-  deepSetValue(prebidResponseBidObject, 'meta.impid', openRTBResponseBidObject.impid);
-  deepSetValue(prebidResponseBidObject, 'meta.cat', openRTBResponseBidObject.cat);
-  deepSetValue(prebidResponseBidObject, 'meta.cid', openRTBResponseBidObject.cid);
-}
-
 function hasValidMediaType(bidRequest) {
   const supported = hasBannerMediaType(bidRequest) || hasVideoMediaType(bidRequest);
   if (!supported) {
@@ -494,48 +259,38 @@ export const spec = {
     return passesRateLimit(bidRequest);
   },
 
-  buildRequests: function(validBidRequests, bidderRequest) {
-    logInfo('validBidRequests: ', validBidRequests);
+  buildRequests: function(bidRequests, bidderRequest) {
+    logInfo('bidRequests: ', bidRequests);
     logInfo('bidderRequest: ', bidderRequest);
-    const prebidRequest = getPrebidRequestFields(bidderRequest, validBidRequests);
-    const payloadString = JSON.stringify(prebidRequest);
-
+    const data = converter.toORTB({bidRequests, bidderRequest});
+    logInfo('request payload', data);
     return {
       method: 'POST',
       url: endpoints.request,
-      data: payloadString,
+      data,
       options: {
         withCredentials: true
       }
     };
   },
 
-  interpretResponse: function (serverResponse) {
-    const bids = [];
-    logInfo('serverResponse: ', serverResponse);
-    _each(serverResponse.body.bid, function (bidObject) {
-      logInfo('bidObject: ', bidObject);
-      if (!bidObject.price || !bidObject.adm) {
-        return;
-      }
-      logInfo('CPM OK');
-      const bid = getPrebidResponseBidObject(bidObject);
-      bids.push(bid);
-    });
-    return bids;
+  interpretResponse: function (serverResponse, request) {
+    logInfo('serverResponse body: ', serverResponse.body);
+    logInfo('request data: ', request.data);
+    const ortbBids = converter.fromORTB({response: serverResponse.body, request: request.data}).bids;
+    logInfo('ortbBids: ', ortbBids);
+    return ortbBids;
   },
 
   onBidWon: function(bid) {
     // Bidder specific code
     logInfo('onBidWon bid: ', bid);
-    const notice = buildWinNotice(bid);
-    ajax(endpoints.notice.win, null, JSON.stringify(notice), { method: 'POST', withCredentials: true });
+    ajax(bid.burl);
   },
 
-  onBidderError: function({ bidderRequest }) {
-    // Bidder specific code
-    const notice = buildErrorNotice(bidderRequest);
-    ajax(endpoints.notice.error, null, JSON.stringify(notice), { method: 'POST', withCredentials: true });
-  },
+  // onBidderError: function({ bidderRequest }) {
+  //   const notice = buildErrorNotice(bidderRequest);
+  //   ajax(endpoints.notice.error, null, JSON.stringify(notice), { method: 'POST', withCredentials: true });
+  // },
 };
 registerBidder(spec);
diff --git a/test/spec/modules/aidemBidAdapter_spec.js b/test/spec/modules/aidemBidAdapter_spec.js
index 8b401491ba0..3de348197b2 100644
--- a/test/spec/modules/aidemBidAdapter_spec.js
+++ b/test/spec/modules/aidemBidAdapter_spec.js
@@ -155,9 +155,9 @@ const DEFAULT_VALID_BANNER_REQUESTS = [
   {
     adUnitCode: 'test-div',
     auctionId: 'b06c5141-fe8f-4cdf-9d7d-54415490a917',
-    bidId: '22c4871113f461',
+    bidId: '2705bfae8ea667',
     bidder: 'aidem',
-    bidderRequestId: '15246a574e859f',
+    bidderRequestId: '1bbb7854dfa0d8',
     mediaTypes: {
       banner: {
         sizes: [
@@ -171,11 +171,7 @@ const DEFAULT_VALID_BANNER_REQUESTS = [
       placementId: '13144370'
     },
     src: 'client',
-    ortb2Imp: {
-      ext: {
-        tid: '54a58774-7a41-494e-9aaf-fa7b79164f0c',
-      },
-    },
+    transactionId: 'db739693-9b4a-4669-9945-8eab938783cc'
   }
 ];
 
@@ -183,9 +179,9 @@ const DEFAULT_VALID_VIDEO_REQUESTS = [
   {
     adUnitCode: 'test-div',
     auctionId: 'b06c5141-fe8f-4cdf-9d7d-54415490a917',
-    bidId: '22c4871113f461',
+    bidId: '2705bfae8ea667',
     bidder: 'aidem',
-    bidderRequestId: '15246a574e859f',
+    bidderRequestId: '1bbb7854dfa0d8',
     mediaTypes: {
       video: {
         minduration: 7,
@@ -200,18 +196,23 @@ const DEFAULT_VALID_VIDEO_REQUESTS = [
       placementId: '13144370'
     },
     src: 'client',
-    ortb2Imp: {
-      ext: {
-        tid: '54a58774-7a41-494e-9aaf-fa7b79164f0c',
-      }
-    },
+    transactionId: 'db739693-9b4a-4669-9945-8eab938783cc'
   }
 ];
 
 const VALID_BIDDER_REQUEST = {
-  auctionId: '6e9b46c3-65a8-46ea-89f4-c5071110c85c',
+  auctionId: '19c97f22-5bd1-4b16-a128-80f75fb0a8a0',
   bidderCode: 'aidem',
-  bidderRequestId: '170ea5d2b1d073',
+  bidderRequestId: '1bbb7854dfa0d8',
+  bids: [
+    {
+      params: {
+        placementId: '13144370',
+        siteId: '23434',
+        publisherId: '7689670753'
+      },
+    }
+  ],
   refererInfo: {
     page: 'test-page',
     domain: 'test-domain',
@@ -219,182 +220,68 @@ const VALID_BIDDER_REQUEST = {
   },
 }
 
-// Add mediatype
 const SERVER_RESPONSE_BANNER = {
-  body: {
-    id: 'efa1930a-bc3e-4fd0-8368-08bc40236b4f',
-    bid: [
-      // BANNER
-      {
-        'id': '2e614be960ee1d',
-        'impid': '2e614be960ee1d',
-        'price': 7.91,
-        'mediatype': 'banner',
-        'adid': '24277955',
-        'adm': 'creativity_banner',
-        'adomain': [
-          'aidem.com'
-        ],
-        'iurl': 'http://www.aidem.com',
-        'cat': [],
-        'cid': '4193561',
-        'crid': '24277955',
-        'w': 300,
-        'h': 250,
-        'ext': {
-          'dspid': 85,
-          'advbrandid': 1246,
-          'advbrand': 'AIDEM'
-        }
-      },
-    ],
-    cur: 'USD'
-  },
-}
-
-const SERVER_RESPONSE_VIDEO = {
-  body: {
-    id: 'efa1930a-bc3e-4fd0-8368-08bc40236b4f',
-    bid: [
-      // VIDEO
-      {
-        'id': '2876a29392a47c',
-        'impid': '2876a29392a47c',
-        'price': 7.93,
-        'mediatype': 'video',
-        'adid': '24277955',
-        'adm': 'https://hermes.aidemsrv.com/vast-tag/cl9mzhhd502uq09l720uegb02?auction_id={{AUCTION_ID}}&cachebuster={{CACHEBUSTER}}',
-        'adomain': [
-          'aidem.com'
-        ],
-        'iurl': 'http://www.aidem.com',
-        'cat': [],
-        'cid': '4193561',
-        'crid': '24277955',
-        'w': 640,
-        'h': 480,
-        'ext': {
-          'dspid': 85,
-          'advbrandid': 1246,
-          'advbrand': 'AIDEM'
-        }
-      }
-    ],
-    cur: 'USD'
-  },
-}
-
-const WIN_NOTICE_WEB = {
-  'adId': '3a20ee5dc78c1e',
-  'adUnitCode': 'div-gpt-ad-1460505748561-0',
-  'creativeId': '24277955',
-  'cpm': 1,
-  'netRevenue': false,
-  'adserverTargeting': {
-    'hb_bidder': 'aidem',
-    'hb_adid': '3a20ee5dc78c1e',
-    'hb_pb': '1.00',
-    'hb_size': '300x250',
-    'hb_source': 'client',
-    'hb_format': 'banner',
-    'hb_adomain': 'example.com'
-  },
-
-  'auctionId': '85864730-6cbc-4e56-bc3c-a4a6596dca5b',
-  'currency': [
-    'USD'
-  ],
-  'mediaType': 'banner',
-  'meta': {
-    'advertiserDomains': [
-      'cloudflare.com'
-    ],
-    'ext': {}
-  },
-  'size': '300x250',
-  'params': [
+  'id': '19c97f22-5bd1-4b16-a128-80f75fb0a8a0',
+  'seatbid': [
     {
-      'placementId': '13144370',
-      'siteId': '23434',
-      'publisherId': '7689670753'
+      'bid': [
+        {
+          'id': 'beeswax/aidem',
+          'impid': '2705bfae8ea667',
+          'price': 0.00875,
+          'burl': 'imp_burl',
+          'adm': 'creativity_banner',
+          'adid': '2:64:162:1001',
+          'adomain': [
+            'aidem.com'
+          ],
+          'cid': '64',
+          'crid': 'aidem-1001',
+          'cat': [],
+          'w': 300,
+          'h': 250,
+          'mtype': 1
+        }
+      ],
+      'seat': 'aidemdsp',
+      'group': 0
     }
   ],
-  'width': 300,
-  'height': 250,
-  'status': 'rendered',
-  'transactionId': 'ce089116-4251-45c3-bdbb-3a03cb13816b',
-  'ttl': 300,
-  'requestTimestamp': 1666796241007,
-  'responseTimestamp': 1666796241021,
-  metrics: {
-    getMetrics() {
-      return {
-
-      }
-    }
-  }
+  'cur': 'USD'
 }
 
-const WIN_NOTICE_APP = {
-  'adId': '3a20ee5dc78c1e',
-  'adUnitCode': 'div-gpt-ad-1460505748561-0',
-  'creativeId': '24277955',
-  'cpm': 1,
-  'netRevenue': false,
-  'adserverTargeting': {
-    'hb_bidder': 'aidem',
-    'hb_adid': '3a20ee5dc78c1e',
-    'hb_pb': '1.00',
-    'hb_size': '300x250',
-    'hb_source': 'client',
-    'hb_format': 'banner',
-    'hb_adomain': 'example.com'
-  },
-
-  'auctionId': '85864730-6cbc-4e56-bc3c-a4a6596dca5b',
-  'currency': [
-    'USD'
-  ],
-  'mediaType': 'banner',
-  'meta': {
-    'advertiserDomains': [
-      'cloudflare.com'
-    ],
-    'ext': {
-      'app': {
-        'app_bundle': '{{APP_BUNDLE}}',
-        'app_id': '{{APP_ID}}',
-        'app_name': '{{APP_NAME}}',
-        'app_store_url': '{{APP_STORE_URL}}',
-        'inventory_source': '{{INVENTORY_SOURCE}}'
-      },
-      'win_notice_ext': {
-        'seatid': '{{SEAT_ID}}'
-      }
-    }
-  },
-  'size': '300x250',
-  'params': [
+const SERVER_RESPONSE_VIDEO = {
+  'id': '19c97f22-5bd1-4b16-a128-80f75fb0a8a0',
+  'seatbid': [
     {
-      'placementId': '13144370',
-      'siteId': '23434',
-      'publisherId': '7689670753'
+      'bid': [
+        {
+          'id': 'beeswax/aidem',
+          'impid': '2705bfae8ea667',
+          'price': 0.00875,
+          'burl': 'imp_burl',
+          'adm': 'creativity_banner',
+          'adid': '2:64:162:1001',
+          'adomain': [
+            'aidem.com'
+          ],
+          'cid': '64',
+          'crid': 'aidem-1001',
+          'cat': [],
+          'w': 300,
+          'h': 250,
+          'mtype': 2
+        }
+      ],
+      'seat': 'aidemdsp',
+      'group': 0
     }
   ],
-  'width': 300,
-  'height': 250,
-  'status': 'rendered',
-  'transactionId': 'ce089116-4251-45c3-bdbb-3a03cb13816b',
-  'ttl': 300,
-  'requestTimestamp': 1666796241007,
-  'responseTimestamp': 1666796241021,
-  metrics: {
-    getMetrics() {
-      return {
+  'cur': 'USD'
+}
 
-      }
-    }
-  }
+const WIN_NOTICE = {
+  burl: 'burl'
 }
 
 const ERROR_NOTICE = {
@@ -512,109 +399,95 @@ describe('Aidem adapter', () => {
       const requests = spec.buildRequests(DEFAULT_VALID_BANNER_REQUESTS, VALID_BIDDER_REQUEST);
       expect(requests).to.be.an('object');
       expect(requests.method).to.be.a('string')
-      expect(requests.data).to.be.a('string')
+      expect(requests.data).to.be.a('object')
       expect(requests.options).to.be.an('object').that.have.a.property('withCredentials')
     });
 
     it('should have a well formatted banner payload', () => {
-      const requests = spec.buildRequests(DEFAULT_VALID_BANNER_REQUESTS, VALID_BIDDER_REQUEST);
-      const payload = JSON.parse(requests.data)
-      expect(payload).to.be.a('object').that.has.all.keys(
-        'id', 'imp', 'device', 'cur', 'tz', 'regs', 'site', 'environment', 'at'
+      const {data} = spec.buildRequests(DEFAULT_VALID_BANNER_REQUESTS, VALID_BIDDER_REQUEST);
+      expect(data).to.be.a('object').that.has.all.keys(
+        'id', 'imp', 'regs', 'site', 'environment', 'at', 'test'
       )
-      expect(payload.imp).to.be.a('array').that.has.lengthOf(DEFAULT_VALID_BANNER_REQUESTS.length)
+      expect(data.imp).to.be.a('array').that.has.lengthOf(DEFAULT_VALID_BANNER_REQUESTS.length)
 
-      expect(payload.imp[0]).to.be.a('object').that.has.all.keys(
-        'banner', 'id', 'mediatype', 'imp_ext', 'tid', 'tagid'
+      expect(data.imp[0]).to.be.a('object').that.has.all.keys(
+        'banner', 'id', 'tagId'
       )
-      expect(payload.imp[0].banner).to.be.a('object').that.has.all.keys(
+      expect(data.imp[0].banner).to.be.a('object').that.has.all.keys(
         'format', 'topframe'
       )
     });
 
-    it('should have a well formatted video payload', () => {
-      const requests = spec.buildRequests(DEFAULT_VALID_VIDEO_REQUESTS, VALID_BIDDER_REQUEST);
-      const payload = JSON.parse(requests.data)
-      expect(payload).to.be.a('object').that.has.all.keys(
-        'id', 'imp', 'device', 'cur', 'tz', 'regs', 'site', 'environment', 'at'
-      )
-      expect(payload.imp).to.be.a('array').that.has.lengthOf(DEFAULT_VALID_VIDEO_REQUESTS.length)
-
-      expect(payload.imp[0]).to.be.a('object').that.has.all.keys(
-        'video', 'id', 'mediatype', 'imp_ext', 'tid', 'tagid'
-      )
-      expect(payload.imp[0].video).to.be.a('object').that.has.all.keys(
-        'format', 'mimes', 'minDuration', 'maxDuration', 'protocols'
-      )
-    });
+    if (FEATURES.VIDEO) {
+      it('should have a well formatted video payload', () => {
+        const {data} = spec.buildRequests(DEFAULT_VALID_VIDEO_REQUESTS, VALID_BIDDER_REQUEST);
+        expect(data).to.be.a('object').that.has.all.keys(
+          'id', 'imp', 'regs', 'site', 'environment', 'at', 'test'
+        )
+        expect(data.imp).to.be.a('array').that.has.lengthOf(DEFAULT_VALID_VIDEO_REQUESTS.length)
 
-    it('should have a well formatted bid floor payload if configured', () => {
-      const validBannerRequests = utils.deepClone(DEFAULT_VALID_BANNER_REQUESTS)
-      validBannerRequests[0].params.floor = {
-        value: 1.98,
-        currency: 'USD'
-      }
-      const requests = spec.buildRequests(validBannerRequests, VALID_BIDDER_REQUEST);
-      const payload = JSON.parse(requests.data)
-      const { floor } = payload.imp[0]
-      expect(floor).to.be.a('object').that.has.all.keys(
-        'value', 'currency'
-      )
-    });
+        expect(data.imp[0]).to.be.a('object').that.has.all.keys(
+          'video', 'id', 'tagId'
+        )
+        expect(data.imp[0].video).to.be.a('object').that.has.all.keys(
+          'mimes', 'minduration', 'maxduration', 'protocols', 'w', 'h'
+        )
+      });
+    }
 
     it('should hav wpar keys in environment object', function () {
-      const requests = spec.buildRequests(DEFAULT_VALID_VIDEO_REQUESTS, VALID_BIDDER_REQUEST);
-      const payload = JSON.parse(requests.data)
-      expect(payload).to.have.property('environment')
-      expect(payload.environment).to.be.a('object').that.have.property('wpar')
-      expect(payload.environment.wpar).to.be.a('object').that.has.keys('innerWidth', 'innerHeight')
+      const {data} = spec.buildRequests(DEFAULT_VALID_VIDEO_REQUESTS, VALID_BIDDER_REQUEST);
+      expect(data).to.have.property('environment')
+      expect(data.environment).to.be.a('object').that.have.property('wpar')
+      expect(data.environment.wpar).to.be.a('object').that.has.keys('innerWidth', 'innerHeight')
     });
   })
 
   describe('interpretResponse', () => {
     it('should return a valid bid array with a banner bid', () => {
-      const response = utils.deepClone(SERVER_RESPONSE_BANNER)
-      const interpreted = spec.interpretResponse(response)
-      expect(interpreted).to.be.a('array').that.has.lengthOf(1)
-      interpreted.forEach(value => {
+      const {data} = spec.buildRequests(DEFAULT_VALID_BANNER_REQUESTS, VALID_BIDDER_REQUEST)
+      const bids = spec.interpretResponse({body: SERVER_RESPONSE_BANNER}, { data })
+      expect(bids).to.be.a('array').that.has.lengthOf(1)
+      bids.forEach(value => {
         expect(value).to.be.a('object').that.has.all.keys(
-          'ad', 'cpm', 'creativeId', 'currency', 'height', 'mediaType', 'meta', 'netRevenue', 'requestId', 'ttl', 'width', 'dealId'
+          'ad', 'cpm', 'creativeId', 'currency', 'height', 'mediaType', 'meta', 'netRevenue', 'requestId', 'ttl', 'width', 'burl', 'seatBidId', 'creative_id'
         )
       })
     });
 
-    it('should return a valid bid array with a banner bid', () => {
-      const response = utils.deepClone(SERVER_RESPONSE_VIDEO)
-      const interpreted = spec.interpretResponse(response)
-      expect(interpreted).to.be.a('array').that.has.lengthOf(1)
-      interpreted.forEach(value => {
-        expect(value).to.be.a('object').that.has.all.keys(
-          'vastUrl', 'cpm', 'creativeId', 'currency', 'height', 'mediaType', 'meta', 'netRevenue', 'requestId', 'ttl', 'width', 'dealId'
-        )
-      })
-    });
+    if (FEATURES.VIDEO) {
+      it('should return a valid bid array with a video bid', () => {
+        const {data} = spec.buildRequests(DEFAULT_VALID_VIDEO_REQUESTS, VALID_BIDDER_REQUEST)
+        const bids = spec.interpretResponse({body: SERVER_RESPONSE_VIDEO}, { data })
+        expect(bids).to.be.a('array').that.has.lengthOf(1)
+        bids.forEach(value => {
+          expect(value).to.be.a('object').that.has.all.keys(
+            'vastUrl', 'vastXml', 'playerHeight', 'playerWidth', 'cpm', 'creativeId', 'currency', 'height', 'mediaType', 'meta', 'netRevenue', 'requestId', 'ttl', 'width', 'burl', 'seatBidId', 'creative_id'
+          )
+        })
+      });
+    }
 
     it('should return a valid bid array with netRevenue', () => {
-      const response = utils.deepClone(SERVER_RESPONSE_BANNER)
-      response.body.bid[0].isNet = true
-      const interpreted = spec.interpretResponse(response)
-      expect(interpreted).to.be.a('array').that.has.lengthOf(1)
-      expect(interpreted[0].netRevenue).to.be.true
-    });
-
-    it('should return an empty bid array if one of seatbid entry is missing price property', () => {
-      const response = utils.deepClone(SERVER_RESPONSE_BANNER)
-      delete response.body.bid[0].price
-      const interpreted = spec.interpretResponse(response)
-      expect(interpreted).to.be.a('array').that.has.lengthOf(0)
-    });
-
-    it('should return an empty bid array if one of seatbid entry is missing adm property', () => {
-      const response = utils.deepClone(SERVER_RESPONSE_BANNER)
-      delete response.body.bid[0].adm
-      const interpreted = spec.interpretResponse(response)
-      expect(interpreted).to.be.a('array').that.has.lengthOf(0)
-    });
+      const {data} = spec.buildRequests(DEFAULT_VALID_VIDEO_REQUESTS, VALID_BIDDER_REQUEST)
+      const bids = spec.interpretResponse({body: SERVER_RESPONSE_VIDEO}, { data })
+      expect(bids).to.be.a('array').that.has.lengthOf(1)
+      expect(bids[0].netRevenue).to.be.true
+    });
+
+    // it('should return an empty bid array if one of seatbid entry is missing price property', () => {
+    //   const response = utils.deepClone(SERVER_RESPONSE_BANNER)
+    //   delete response.body.bid[0].price
+    //   const interpreted = spec.interpretResponse(response)
+    //   expect(interpreted).to.be.a('array').that.has.lengthOf(0)
+    // });
+
+    // it('should return an empty bid array if one of seatbid entry is missing adm property', () => {
+    //   const response = utils.deepClone(SERVER_RESPONSE_BANNER)
+    //   delete response.body.bid[0].adm
+    //   const interpreted = spec.interpretResponse(response)
+    //   expect(interpreted).to.be.a('array').that.has.lengthOf(0)
+    // });
   })
 
   describe('onBidWon', () => {
@@ -622,34 +495,29 @@ describe('Aidem adapter', () => {
       expect(spec.onBidWon).to.exist.and.to.be.a('function')
     });
 
-    it(`should send a valid bid won notice from web environment`, function () {
-      spec.onBidWon(WIN_NOTICE_WEB);
-      expect(server.requests.length).to.equal(1);
-    });
-
-    it(`should send a valid bid won notice from app environment`, function () {
-      spec.onBidWon(WIN_NOTICE_APP);
+    it(`should send a win notice`, function () {
+      spec.onBidWon(WIN_NOTICE);
       expect(server.requests.length).to.equal(1);
     });
   });
 
-  describe('onBidderError', () => {
-    it(`should exists and type function`, function () {
-      expect(spec.onBidderError).to.exist.and.to.be.a('function')
-    });
-
-    it(`should send a valid error notice`, function () {
-      spec.onBidderError({ bidderRequest: ERROR_NOTICE })
-      expect(server.requests.length).to.equal(1);
-      const body = JSON.parse(server.requests[0].requestBody)
-      expect(body).to.be.a('object').that.has.all.keys('message', 'auctionId', 'bidderRequestId', 'url', 'metrics')
-      // const { bids } = JSON.parse(server.requests[0].requestBody)
-      // expect(bids).to.be.a('array').that.has.lengthOf(1)
-      // _each(bids, (bid) => {
-      //   expect(bid).to.be.a('object').that.has.all.keys('adUnitCode', 'auctionId', 'bidId', 'bidderRequestId', 'transactionId', 'metrics')
-      // })
-    });
-  });
+  // describe('onBidderError', () => {
+  //   it(`should exists and type function`, function () {
+  //     expect(spec.onBidderError).to.exist.and.to.be.a('function')
+  //   });
+  //
+  //   it(`should send a valid error notice`, function () {
+  //     spec.onBidderError({ bidderRequest: ERROR_NOTICE })
+  //     expect(server.requests.length).to.equal(1);
+  //     const body = JSON.parse(server.requests[0].requestBody)
+  //     expect(body).to.be.a('object').that.has.all.keys('message', 'auctionId', 'bidderRequestId', 'url', 'metrics')
+  //     // const { bids } = JSON.parse(server.requests[0].requestBody)
+  //     // expect(bids).to.be.a('array').that.has.lengthOf(1)
+  //     // _each(bids, (bid) => {
+  //     //   expect(bid).to.be.a('object').that.has.all.keys('adUnitCode', 'auctionId', 'bidId', 'bidderRequestId', 'transactionId', 'metrics')
+  //     // })
+  //   });
+  // });
 
   describe('setEndPoints', () => {
     it(`should exists and type function`, function () {
@@ -659,64 +527,35 @@ describe('Aidem adapter', () => {
     it(`should not modify default endpoints`, function () {
       const endpoints = setEndPoints()
       const requestURL = new URL(endpoints.request)
-      const winNoticeURL = new URL(endpoints.notice.win)
-      const timeoutNoticeURL = new URL(endpoints.notice.timeout)
-      const errorNoticeURL = new URL(endpoints.notice.error)
-
       expect(requestURL.host).to.equal('zero.aidemsrv.com')
-      expect(winNoticeURL.host).to.equal('zero.aidemsrv.com')
-      expect(timeoutNoticeURL.host).to.equal('zero.aidemsrv.com')
-      expect(errorNoticeURL.host).to.equal('zero.aidemsrv.com')
-
-      expect(decodeURIComponent(requestURL.pathname)).to.equal('/bid/request')
-      expect(decodeURIComponent(winNoticeURL.pathname)).to.equal('/notice/win')
-      expect(decodeURIComponent(timeoutNoticeURL.pathname)).to.equal('/notice/timeout')
-      expect(decodeURIComponent(errorNoticeURL.pathname)).to.equal('/notice/error')
+      expect(decodeURIComponent(requestURL.pathname)).to.equal('/prebidjs/ortb/v2.6/bid/request')
     });
 
     it(`should not change request endpoint`, function () {
       const endpoints = setEndPoints('default')
       const requestURL = new URL(endpoints.request)
-      expect(decodeURIComponent(requestURL.pathname)).to.equal('/bid/request')
+      expect(decodeURIComponent(requestURL.pathname)).to.equal('/prebidjs/ortb/v2.6/bid/request')
     });
 
     it(`should change to local env`, function () {
       const endpoints = setEndPoints('local')
       const requestURL = new URL(endpoints.request)
-      const winNoticeURL = new URL(endpoints.notice.win)
-      const timeoutNoticeURL = new URL(endpoints.notice.timeout)
-      const errorNoticeURL = new URL(endpoints.notice.error)
 
       expect(requestURL.host).to.equal('127.0.0.1:8787')
-      expect(winNoticeURL.host).to.equal('127.0.0.1:8787')
-      expect(timeoutNoticeURL.host).to.equal('127.0.0.1:8787')
-      expect(errorNoticeURL.host).to.equal('127.0.0.1:8787')
     });
 
     it(`should add a path prefix`, function () {
       const endpoints = setEndPoints('local', '/path')
       const requestURL = new URL(endpoints.request)
-      const winNoticeURL = new URL(endpoints.notice.win)
-      const timeoutNoticeURL = new URL(endpoints.notice.timeout)
-      const errorNoticeURL = new URL(endpoints.notice.error)
 
-      expect(decodeURIComponent(requestURL.pathname)).to.equal('/path/bid/request')
-      expect(decodeURIComponent(winNoticeURL.pathname)).to.equal('/path/notice/win')
-      expect(decodeURIComponent(timeoutNoticeURL.pathname)).to.equal('/path/notice/timeout')
-      expect(decodeURIComponent(errorNoticeURL.pathname)).to.equal('/path/notice/error')
+      expect(decodeURIComponent(requestURL.pathname)).to.equal('/path/prebidjs/ortb/v2.6/bid/request')
     });
 
     it(`should add a path prefix and change request endpoint`, function () {
       const endpoints = setEndPoints('local', '/path')
       const requestURL = new URL(endpoints.request)
-      const winNoticeURL = new URL(endpoints.notice.win)
-      const timeoutNoticeURL = new URL(endpoints.notice.timeout)
-      const errorNoticeURL = new URL(endpoints.notice.error)
 
-      expect(decodeURIComponent(requestURL.pathname)).to.equal('/path/bid/request')
-      expect(decodeURIComponent(winNoticeURL.pathname)).to.equal('/path/notice/win')
-      expect(decodeURIComponent(timeoutNoticeURL.pathname)).to.equal('/path/notice/timeout')
-      expect(decodeURIComponent(errorNoticeURL.pathname)).to.equal('/path/notice/error')
+      expect(decodeURIComponent(requestURL.pathname)).to.equal('/path/prebidjs/ortb/v2.6/bid/request')
     });
   });
 
@@ -758,8 +597,7 @@ describe('Aidem adapter', () => {
         coppa: true
       });
       const { data } = spec.buildRequests(DEFAULT_VALID_BANNER_REQUESTS, VALID_BIDDER_REQUEST);
-      const request = JSON.parse(data)
-      expect(request.regs.coppa_applies).to.equal(true)
+      expect(data.regs.coppa_applies).to.equal(true)
     });
 
     it(`should set gdpr to true`, function () {
@@ -771,8 +609,7 @@ describe('Aidem adapter', () => {
         }
       });
       const { data } = spec.buildRequests(DEFAULT_VALID_BANNER_REQUESTS, VALID_BIDDER_REQUEST);
-      const request = JSON.parse(data)
-      expect(request.regs.gdpr_applies).to.equal(true)
+      expect(data.regs.gdpr_applies).to.equal(true)
     });
 
     it(`should set usp_consent string`, function () {
@@ -789,8 +626,7 @@ describe('Aidem adapter', () => {
         }
       });
       const { data } = spec.buildRequests(DEFAULT_VALID_BANNER_REQUESTS, VALID_BIDDER_REQUEST);
-      const request = JSON.parse(data)
-      expect(request.regs.us_privacy).to.equal('1YYY')
+      expect(data.regs.us_privacy).to.equal('1YYY')
     });
 
     it(`should not set usp_consent string`, function () {
@@ -807,8 +643,7 @@ describe('Aidem adapter', () => {
         }
       });
       const { data } = spec.buildRequests(DEFAULT_VALID_BANNER_REQUESTS, VALID_BIDDER_REQUEST);
-      const request = JSON.parse(data)
-      expect(request.regs.us_privacy).to.undefined
+      expect(data.regs.us_privacy).to.undefined
     });
   });
 });

From 294b84e37a6074c5c4f3988592033cf62feb4030 Mon Sep 17 00:00:00 2001
From: Volodymyr Hunko <98126264+WinnieThePooh2004@users.noreply.github.com>
Date: Thu, 14 Sep 2023 09:26:48 +0300
Subject: [PATCH 34/46] Admixer Bid Adapter : removed ortb2 from imp array
 (#10450)

* Update README.md

update

* removed ortb2 from admixer imp

---------

Co-authored-by: AdmixerTech <35560933+AdmixerTech@users.noreply.github.com>
Co-authored-by: AdmixerTech <admin@admixer.net>
Co-authored-by: AdmixerTech <admixertech@users.noreply.github.com>
---
 modules/admixerBidAdapter.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/modules/admixerBidAdapter.js b/modules/admixerBidAdapter.js
index 1006fef631c..6cbc36c1dcd 100644
--- a/modules/admixerBidAdapter.js
+++ b/modules/admixerBidAdapter.js
@@ -73,6 +73,7 @@ export const spec = {
     validRequest.forEach((bid) => {
       let imp = {};
       Object.keys(bid).forEach(key => imp[key] = bid[key]);
+      imp.ortb2 && delete imp.ortb2;
       payload.imps.push(imp);
     });
     return {

From 6438f2749b89234bba70ff265b33214b4861cfa9 Mon Sep 17 00:00:00 2001
From: Demetrio Girardi <dgirardi@prebid.org>
Date: Thu, 14 Sep 2023 04:48:11 -0700
Subject: [PATCH 35/46] PBS adapter: log and trigger BIDDER_ERROR events on
 server errors (#10482)

---
 modules/prebidServerBidAdapter/index.js          | 6 +++++-
 test/spec/modules/prebidServerBidAdapter_spec.js | 9 +++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/modules/prebidServerBidAdapter/index.js b/modules/prebidServerBidAdapter/index.js
index 3cae4497354..776ad99fa25 100644
--- a/modules/prebidServerBidAdapter/index.js
+++ b/modules/prebidServerBidAdapter/index.js
@@ -483,7 +483,11 @@ export function PrebidServer() {
           done();
           doClientSideSyncs(requestedBidders, gdprConsent, uspConsent, gppConsent);
         },
-        onError: done,
+        onError(msg, error) {
+          logError(`Prebid server call failed: '${msg}'`, error);
+          bidRequests.forEach(bidderRequest => events.emit(CONSTANTS.EVENTS.BIDDER_ERROR, {error, bidderRequest}));
+          done();
+        },
         onBid: function ({adUnit, bid}) {
           const metrics = bid.metrics = s2sBidRequest.metrics.fork().renameWith();
           metrics.checkpoint('addBidResponse');
diff --git a/test/spec/modules/prebidServerBidAdapter_spec.js b/test/spec/modules/prebidServerBidAdapter_spec.js
index c823366dbce..4b783803507 100644
--- a/test/spec/modules/prebidServerBidAdapter_spec.js
+++ b/test/spec/modules/prebidServerBidAdapter_spec.js
@@ -2876,6 +2876,15 @@ describe('S2S Adapter', function () {
       events.emit.restore();
     });
 
+    it('triggers BIDDER_ERROR on server error', () => {
+      config.setConfig({ s2sConfig: CONFIG });
+      adapter.callBids(REQUEST, BID_REQUESTS, addBidResponse, done, ajax);
+      server.requests[0].respond(400, {}, {});
+      BID_REQUESTS.forEach(bidderRequest => {
+        sinon.assert.calledWith(events.emit, CONSTANTS.EVENTS.BIDDER_ERROR, sinon.match({bidderRequest}))
+      })
+    })
+
     // TODO: test dependent on pbjs_api_spec.  Needs to be isolated
     it('does not call addBidResponse and calls done when ad unit not set', function () {
       config.setConfig({ s2sConfig: CONFIG });

From 61d4f5c138cda109a295b1033a42c3e6a2589040 Mon Sep 17 00:00:00 2001
From: Denis Logachov <denis@adkernel.com>
Date: Thu, 14 Sep 2023 18:46:37 +0300
Subject: [PATCH 36/46] Adkernel: added mediatypes.* attributes support
 (#10472)

---
 modules/adkernelBidAdapter.js                | 57 ++++++++++----------
 test/spec/modules/adkernelBidAdapter_spec.js | 26 +++++++--
 2 files changed, 49 insertions(+), 34 deletions(-)

diff --git a/modules/adkernelBidAdapter.js b/modules/adkernelBidAdapter.js
index 6ae19c3efdc..71d5c809e71 100644
--- a/modules/adkernelBidAdapter.js
+++ b/modules/adkernelBidAdapter.js
@@ -29,18 +29,19 @@ import {convertOrtbRequestToProprietaryNative} from '../src/native.js';
  *
  * Please contact prebid@adkernel.com and we'll add your adapter as an alias.
  */
-const VIDEO_PARAMS = ['pos', 'context', 'placement', 'api', 'mimes', 'protocols', 'playbackmethod', 'minduration', 'maxduration',
+const VIDEO_PARAMS = ['pos', 'context', 'placement', 'plcmt', 'api', 'mimes', 'protocols', 'playbackmethod', 'minduration', 'maxduration',
   'startdelay', 'linearity', 'skip', 'skipmin', 'skipafter', 'minbitrate', 'maxbitrate', 'delivery', 'playbackend', 'boxingallowed'];
 const VIDEO_FPD = ['battr', 'pos'];
 const NATIVE_FPD = ['battr', 'api'];
+const BANNER_PARAMS = ['pos'];
 const BANNER_FPD = ['btype', 'battr', 'pos', 'api'];
 const VERSION = '1.6';
 const SYNC_IFRAME = 1;
 const SYNC_IMAGE = 2;
-const SYNC_TYPES = Object.freeze({
+const SYNC_TYPES = {
   1: 'iframe',
   2: 'image'
-});
+};
 const GVLID = 14;
 
 const NATIVE_MODEL = [
@@ -275,33 +276,37 @@ function buildImp(bidRequest, secure) {
   var mediaType;
   var sizes = [];
 
-  if (deepAccess(bidRequest, 'mediaTypes.banner')) {
+  if (bidRequest.mediaTypes?.banner) {
     sizes = getAdUnitSizes(bidRequest);
+    let pbBanner = bidRequest.mediaTypes.banner;
     imp.banner = {
+      ...getDefinedParamsOrEmpty(bidRequest.ortb2Imp, BANNER_FPD),
+      ...getDefinedParamsOrEmpty(pbBanner, BANNER_PARAMS),
       format: sizes.map(wh => parseGPTSingleSizeArrayToRtbSize(wh)),
       topframe: 0
     };
-    populateImpFpd(imp.banner, bidRequest, BANNER_FPD);
     mediaType = BANNER;
-  } else if (deepAccess(bidRequest, 'mediaTypes.video')) {
-    let video = deepAccess(bidRequest, 'mediaTypes.video');
-    imp.video = getDefinedParams(video, VIDEO_PARAMS);
-    populateImpFpd(imp.video, bidRequest, VIDEO_FPD);
-    if (video.playerSize) {
-      sizes = video.playerSize[0];
+  } else if (bidRequest.mediaTypes?.video) {
+    let pbVideo = bidRequest.mediaTypes.video;
+    imp.video = {
+      ...getDefinedParamsOrEmpty(bidRequest.ortb2Imp, VIDEO_FPD),
+      ...getDefinedParamsOrEmpty(pbVideo, VIDEO_PARAMS)
+    };
+    if (pbVideo.playerSize) {
+      sizes = pbVideo.playerSize[0];
       imp.video = Object.assign(imp.video, parseGPTSingleSizeArrayToRtbSize(sizes) || {});
-    } else if (video.w && video.h) {
-      imp.video.w = video.w;
-      imp.video.h = video.h;
+    } else if (pbVideo.w && pbVideo.h) {
+      imp.video.w = pbVideo.w;
+      imp.video.h = pbVideo.h;
     }
     mediaType = VIDEO;
-  } else if (deepAccess(bidRequest, 'mediaTypes.native')) {
+  } else if (bidRequest.mediaTypes?.native) {
     let nativeRequest = buildNativeRequest(bidRequest.mediaTypes.native);
     imp.native = {
+      ...getDefinedParamsOrEmpty(bidRequest.ortb2Imp, NATIVE_FPD),
       ver: '1.1',
       request: JSON.stringify(nativeRequest)
     };
-    populateImpFpd(imp.native, bidRequest, NATIVE_FPD);
     mediaType = NATIVE;
   } else {
     throw new Error('Unsupported bid received');
@@ -316,6 +321,13 @@ function buildImp(bidRequest, secure) {
   return imp;
 }
 
+function getDefinedParamsOrEmpty(object, params) {
+  if (object === undefined) {
+    return {};
+  }
+  return getDefinedParams(object, params);
+}
+
 /**
  * Builds native request from native adunit
  */
@@ -345,19 +357,6 @@ function buildNativeRequest(nativeReq) {
   return request;
 }
 
-/**
- * Populate impression-level FPD from bid request
- * @param target {Object}
- * @param bidRequest {BidRequest}
- * @param props {String[]}
- */
-function populateImpFpd(target, bidRequest, props) {
-  if (bidRequest.ortb2Imp === undefined) {
-    return;
-  }
-  Object.assign(target, getDefinedParams(bidRequest.ortb2Imp, props));
-}
-
 /**
  *  Builds image asset request
  */
diff --git a/test/spec/modules/adkernelBidAdapter_spec.js b/test/spec/modules/adkernelBidAdapter_spec.js
index 90200a801c5..ac2e3785780 100644
--- a/test/spec/modules/adkernelBidAdapter_spec.js
+++ b/test/spec/modules/adkernelBidAdapter_spec.js
@@ -15,11 +15,13 @@ describe('Adkernel adapter', function () {
       auctionId: 'auc-001',
       mediaTypes: {
         banner: {
-          sizes: [[300, 250], [300, 200]]
+          sizes: [[300, 250], [300, 200]],
+          pos: 1
         }
       },
       ortb2Imp: {
-        battr: [6, 7, 9]
+        battr: [6, 7, 9],
+        pos: 2
       }
     }, bid2_zone2 = {
       bidder: 'adkernel',
@@ -103,7 +105,11 @@ describe('Adkernel adapter', function () {
         video: {
           context: 'instream',
           playerSize: [[640, 480]],
-          api: [1, 2]
+          api: [1, 2],
+          placement: 1,
+          plcmt: 1,
+          skip: 1,
+          pos: 1
         }
       },
       adUnitCode: 'ad-unit-1'
@@ -346,6 +352,11 @@ describe('Adkernel adapter', function () {
       expect(bidRequest.imp[0].banner.battr).to.be.eql([6, 7, 9]);
     });
 
+    it('should respect mediatypes attributes over FPD', function() {
+      expect(bidRequest.imp[0].banner).to.have.property('pos');
+      expect(bidRequest.imp[0].banner.pos).to.be.eql(1);
+    });
+
     it('shouldn\'t contain gdpr nor ccpa information for default request', function () {
       let [_, bidRequests] = buildRequest([bid1_zone1]);
       expect(bidRequests[0]).to.not.have.property('regs');
@@ -438,8 +449,13 @@ describe('Adkernel adapter', function () {
     });
 
     it('should have openrtb video impression parameters', function() {
-      expect(bidRequests[0].imp[0].video).to.have.property('api');
-      expect(bidRequests[0].imp[0].video.api).to.be.eql([1, 2]);
+      let video = bidRequests[0].imp[0].video;
+      expect(video).to.have.property('api');
+      expect(video.api).to.be.eql([1, 2]);
+      expect(video.placement).to.be.eql(1);
+      expect(video.plcmt).to.be.eql(1);
+      expect(video.skip).to.be.eql(1);
+      expect(video.pos).to.be.eql(1);
     });
   });
 

From 80754550c118bce24c9640a9b08f6c5bc9c1dfb0 Mon Sep 17 00:00:00 2001
From: Demetrio Girardi <dgirardi@prebid.org>
Date: Thu, 14 Sep 2023 10:09:21 -0700
Subject: [PATCH 37/46] Core: improve and fix bid timeout logic (#10379)

* Clean up timeout logic: doCallbacksIfTimedOut

* Core: simplify bid timeouts, fix s2s timeout edge case

* use more descriptive varnames
---
 modules/adpod.js                 |   4 -
 src/adapterManager.js            |  37 ++++---
 src/auction.js                   |  70 +++----------
 src/utils.js                     |   3 +-
 test/spec/auctionmanager_spec.js | 171 ++++++++++++++++++++-----------
 test/spec/modules/adpod_spec.js  |   3 -
 6 files changed, 146 insertions(+), 142 deletions(-)

diff --git a/modules/adpod.js b/modules/adpod.js
index 4ab8e4e5ab9..0318785d55e 100644
--- a/modules/adpod.js
+++ b/modules/adpod.js
@@ -28,7 +28,6 @@ import {
 import {
   addBidToAuction,
   AUCTION_IN_PROGRESS,
-  doCallbacksIfTimedout,
   getPriceByGranularity,
   getPriceGranularity
 } from '../src/auction.js';
@@ -212,9 +211,6 @@ function firePrebidCacheCall(auctionInstance, bidList, afterBidAdded) {
   store(bidList, function (error, cacheIds) {
     if (error) {
       logWarn(`Failed to save to the video cache: ${error}. Video bid(s) must be discarded.`);
-      for (let i = 0; i < bidList.length; i++) {
-        doCallbacksIfTimedout(auctionInstance, bidList[i]);
-      }
     } else {
       for (let i = 0; i < cacheIds.length; i++) {
         // when uuid in response is empty string then the key already existed, so this bid wasn't cached
diff --git a/src/adapterManager.js b/src/adapterManager.js
index 6513d41ca3c..554fde21734 100644
--- a/src/adapterManager.js
+++ b/src/adapterManager.js
@@ -380,13 +380,13 @@ adapterManager.callBids = (adUnits, bidRequests, addBidResponse, doneCb, request
     return;
   }
 
-  let [clientBidRequests, serverBidRequests] = bidRequests.reduce((partitions, bidRequest) => {
+  let [clientBidderRequests, serverBidderRequests] = bidRequests.reduce((partitions, bidRequest) => {
     partitions[Number(typeof bidRequest.src !== 'undefined' && bidRequest.src === CONSTANTS.S2S.SRC)].push(bidRequest);
     return partitions;
   }, [[], []]);
 
   var uniqueServerBidRequests = [];
-  serverBidRequests.forEach(serverBidRequest => {
+  serverBidderRequests.forEach(serverBidRequest => {
     var index = -1;
     for (var i = 0; i < uniqueServerBidRequests.length; ++i) {
       if (serverBidRequest.uniquePbsTid === uniqueServerBidRequests[i].uniquePbsTid) {
@@ -413,14 +413,17 @@ adapterManager.callBids = (adUnits, bidRequests, addBidResponse, doneCb, request
       let uniquePbsTid = uniqueServerBidRequests[counter].uniquePbsTid;
       let adUnitsS2SCopy = uniqueServerBidRequests[counter].adUnitsS2SCopy;
 
-      let uniqueServerRequests = serverBidRequests.filter(serverBidRequest => serverBidRequest.uniquePbsTid === uniquePbsTid);
+      let uniqueServerRequests = serverBidderRequests.filter(serverBidRequest => serverBidRequest.uniquePbsTid === uniquePbsTid);
 
       if (s2sAdapter) {
         let s2sBidRequest = {'ad_units': adUnitsS2SCopy, s2sConfig, ortb2Fragments};
         if (s2sBidRequest.ad_units.length) {
           let doneCbs = uniqueServerRequests.map(bidRequest => {
             bidRequest.start = timestamp();
-            return doneCb.bind(bidRequest);
+            return function () {
+              onTimelyResponse(bidRequest.bidderRequestId);
+              doneCbs.apply(bidRequest, arguments);
+            }
           });
 
           const bidders = getBidderCodes(s2sBidRequest.ad_units).filter((bidder) => adaptersServerSide.includes(bidder));
@@ -435,7 +438,7 @@ adapterManager.callBids = (adUnits, bidRequests, addBidResponse, doneCb, request
           // make bid requests
           s2sAdapter.callBids(
             s2sBidRequest,
-            serverBidRequests,
+            serverBidderRequests,
             addBidResponse,
             () => doneCbs.forEach(done => done()),
             s2sAjax
@@ -449,35 +452,35 @@ adapterManager.callBids = (adUnits, bidRequests, addBidResponse, doneCb, request
   });
 
   // handle client adapter requests
-  clientBidRequests.forEach(bidRequest => {
-    bidRequest.start = timestamp();
+  clientBidderRequests.forEach(bidderRequest => {
+    bidderRequest.start = timestamp();
     // TODO : Do we check for bid in pool from here and skip calling adapter again ?
-    const adapter = _bidderRegistry[bidRequest.bidderCode];
-    config.runWithBidder(bidRequest.bidderCode, () => {
+    const adapter = _bidderRegistry[bidderRequest.bidderCode];
+    config.runWithBidder(bidderRequest.bidderCode, () => {
       logMessage(`CALLING BIDDER`);
-      events.emit(CONSTANTS.EVENTS.BID_REQUESTED, bidRequest);
+      events.emit(CONSTANTS.EVENTS.BID_REQUESTED, bidderRequest);
     });
     let ajax = ajaxBuilder(requestBidsTimeout, requestCallbacks ? {
-      request: requestCallbacks.request.bind(null, bidRequest.bidderCode),
+      request: requestCallbacks.request.bind(null, bidderRequest.bidderCode),
       done: requestCallbacks.done
     } : undefined);
-    const adapterDone = doneCb.bind(bidRequest);
+    const adapterDone = doneCb.bind(bidderRequest);
     try {
       config.runWithBidder(
-        bidRequest.bidderCode,
+        bidderRequest.bidderCode,
         bind.call(
           adapter.callBids,
           adapter,
-          bidRequest,
+          bidderRequest,
           addBidResponse,
           adapterDone,
           ajax,
-          onTimelyResponse,
-          config.callbackWithBidder(bidRequest.bidderCode)
+          () => onTimelyResponse(bidderRequest.bidderRequestId),
+          config.callbackWithBidder(bidderRequest.bidderCode)
         )
       );
     } catch (e) {
-      logError(`${bidRequest.bidderCode} Bid Adapter emitted an uncaught error when parsing their bidRequest`, {e, bidRequest});
+      logError(`${bidderRequest.bidderCode} Bid Adapter emitted an uncaught error when parsing their bidRequest`, {e, bidRequest: bidderRequest});
       adapterDone();
     }
   });
diff --git a/src/auction.js b/src/auction.js
index 54621669c59..c3712c0a4df 100644
--- a/src/auction.js
+++ b/src/auction.js
@@ -62,7 +62,6 @@ import {
   adUnitsFilter,
   bind,
   deepAccess,
-  flatten,
   generateUUID,
   getValue,
   isEmpty,
@@ -142,7 +141,7 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
   const _adUnitCodes = adUnitCodes;
   const _auctionId = auctionId || generateUUID();
   const _timeout = cbTimeout;
-  const _timelyBidders = new Set();
+  const _timelyRequests = new Set();
   const done = defer();
   let _bidsRejected = [];
   let _callback = callback;
@@ -152,7 +151,7 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
   let _winningBids = [];
   let _auctionStart;
   let _auctionEnd;
-  let _timer;
+  let _timeoutTimer;
   let _auctionStatus;
   let _nonBids = [];
 
@@ -183,24 +182,20 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
   }
 
   function startAuctionTimer() {
-    const timedOut = true;
-    const timeoutCallback = executeCallback.bind(null, timedOut);
-    let timer = setTimeout(timeoutCallback, _timeout);
-    _timer = timer;
+    _timeoutTimer = setTimeout(() => executeCallback(true), _timeout);
   }
 
-  function executeCallback(timedOut, cleartimer) {
-    // clear timer when done calls executeCallback
-    if (cleartimer) {
-      clearTimeout(_timer);
+  function executeCallback(timedOut) {
+    if (!timedOut) {
+      clearTimeout(_timeoutTimer);
     }
     if (_auctionEnd === undefined) {
-      let timedOutBidders = [];
+      let timedOutRequests = [];
       if (timedOut) {
         logMessage(`Auction ${_auctionId} timedOut`);
-        timedOutBidders = getTimedOutBids(_bidderRequests, _timelyBidders);
-        if (timedOutBidders.length) {
-          events.emit(CONSTANTS.EVENTS.BID_TIMEOUT, timedOutBidders);
+        timedOutRequests = _bidderRequests.filter(rq => !_timelyRequests.has(rq.bidderRequestId)).flatMap(br => br.bids)
+        if (timedOutRequests.length) {
+          events.emit(CONSTANTS.EVENTS.BID_TIMEOUT, timedOutRequests);
         }
       }
 
@@ -226,8 +221,8 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
           logError('Error executing bidsBackHandler', null, e);
         } finally {
           // Calling timed out bidders
-          if (timedOutBidders.length) {
-            adapterManager.callTimedOutBidders(adUnits, timedOutBidders, _timeout);
+          if (timedOutRequests.length) {
+            adapterManager.callTimedOutBidders(adUnits, timedOutRequests, _timeout);
           }
           // Only automatically sync if the publisher has not chosen to "enableOverride"
           let userSyncConfig = config.getConfig('userSync') || {};
@@ -245,11 +240,11 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
     // when all bidders have called done callback atleast once it means auction is complete
     logInfo(`Bids Received for Auction with id: ${_auctionId}`, _bidsReceived);
     _auctionStatus = AUCTION_COMPLETED;
-    executeCallback(false, true);
+    executeCallback(false);
   }
 
-  function onTimelyResponse(bidderCode) {
-    _timelyBidders.add(bidderCode);
+  function onTimelyResponse(bidderRequestId) {
+    _timelyRequests.add(bidderRequestId);
   }
 
   function callBids() {
@@ -387,7 +382,6 @@ export function newAuction({adUnits, adUnitCodes, callback, cbTimeout, labels, a
     addBidReceived,
     addBidRejected,
     addNoBid,
-    executeCallback,
     callBids,
     addWinningBid,
     setBidTargeting,
@@ -557,12 +551,6 @@ export function auctionCallbacks(auctionDone, auctionInstance, {index = auctionM
   }
 }
 
-export function doCallbacksIfTimedout(auctionInstance, bidResponse) {
-  if (bidResponse.timeToRespond > auctionInstance.getTimeout() + config.getConfig('timeoutBuffer')) {
-    auctionInstance.executeCallback(true);
-  }
-}
-
 // Add a bid to the auction.
 export function addBidToAuction(auctionInstance, bidResponse) {
   setupBidTargeting(bidResponse);
@@ -570,8 +558,6 @@ export function addBidToAuction(auctionInstance, bidResponse) {
   useMetrics(bidResponse.metrics).timeSince('addBidResponse', 'addBidResponse.total');
   auctionInstance.addBidReceived(bidResponse);
   events.emit(CONSTANTS.EVENTS.BID_RESPONSE, bidResponse);
-
-  doCallbacksIfTimedout(auctionInstance, bidResponse);
 }
 
 // Video bids may fail if the cache is down, or there's trouble on the network.
@@ -618,16 +604,11 @@ const _storeInCache = (batch) => {
       const { auctionInstance, bidResponse, afterBidAdded } = batch[i];
       if (error) {
         logWarn(`Failed to save to the video cache: ${error}. Video bid must be discarded.`);
-
-        doCallbacksIfTimedout(auctionInstance, bidResponse);
       } else {
         if (cacheId.uuid === '') {
           logWarn(`Supplied video cache key was already in use by Prebid Cache; caching attempt was rejected. Video bid must be discarded.`);
-
-          doCallbacksIfTimedout(auctionInstance, bidResponse);
         } else {
           bidResponse.videoCacheKey = cacheId.uuid;
-
           if (!bidResponse.vastUrl) {
             bidResponse.vastUrl = getCacheUrl(bidResponse.videoCacheKey);
           }
@@ -1017,24 +998,3 @@ function groupByPlacement(bidsByPlacement, bid) {
   bidsByPlacement[bid.adUnitCode].bids.push(bid);
   return bidsByPlacement;
 }
-
-/**
- * Returns a list of bids that we haven't received a response yet where the bidder did not call done
- * @param {BidRequest[]} bidderRequests List of bids requested for auction instance
- * @param {Set} timelyBidders Set of bidders which responded in time
- *
- * @typedef {Object} TimedOutBid
- * @property {string} bidId The id representing the bid
- * @property {string} bidder The string name of the bidder
- * @property {string} adUnitCode The code used to uniquely identify the ad unit on the publisher's page
- * @property {string} auctionId The id representing the auction
- *
- * @return {Array<TimedOutBid>} List of bids that Prebid hasn't received a response for
- */
-function getTimedOutBids(bidderRequests, timelyBidders) {
-  const timedOutBids = bidderRequests
-    .map(bid => (bid.bids || []).filter(bid => !timelyBidders.has(bid.bidder)))
-    .reduce(flatten, []);
-
-  return timedOutBids;
-}
diff --git a/src/utils.js b/src/utils.js
index 2ce4f9cc8bb..5ad8b5031bd 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -925,8 +925,7 @@ export function isValidMediaTypes(mediaTypes) {
 export function getUserConfiguredParams(adUnits, adUnitCode, bidder) {
   return adUnits
     .filter(adUnit => adUnit.code === adUnitCode)
-    .map((adUnit) => adUnit.bids)
-    .reduce(flatten, [])
+    .flatMap((adUnit) => adUnit.bids)
     .filter((bidderData) => bidderData.bidder === bidder)
     .map((bidderData) => bidderData.params || {});
 }
diff --git a/test/spec/auctionmanager_spec.js b/test/spec/auctionmanager_spec.js
index d8598dc2063..be4a7f819cd 100644
--- a/test/spec/auctionmanager_spec.js
+++ b/test/spec/auctionmanager_spec.js
@@ -5,7 +5,7 @@ import {
   adjustBids,
   getMediaTypeGranularity,
   getPriceByGranularity,
-  addBidResponse
+  addBidResponse, resetAuctionState
 } from 'src/auction.js';
 import CONSTANTS from 'src/constants.json';
 import * as auctionModule from 'src/auction.js';
@@ -23,6 +23,7 @@ import {AuctionIndex} from '../../src/auctionIndex.js';
 import {expect} from 'chai';
 import {deepClone} from '../../src/utils.js';
 import { IMAGE as ortbNativeRequest } from 'src/native.js';
+import {PrebidServer} from '../../modules/prebidServerBidAdapter/index.js';
 
 var assert = require('assert');
 
@@ -48,6 +49,7 @@ function mockBid(opts) {
   let bidderCode = opts && opts.bidderCode;
 
   return {
+    adUnitCode: opts?.adUnitCode || ADUNIT_CODE,
     'ad': 'creative',
     'cpm': '1.99',
     'width': 300,
@@ -68,6 +70,11 @@ function mockBid(opts) {
         transactionId: this.transactionId,
         auctionId: this.auctionId
       }
+    },
+    _ctx: {
+      adUnits: opts?.adUnits,
+      src: opts?.src,
+      uniquePbsTid: opts?.uniquePbsTid,
     }
   };
 }
@@ -96,6 +103,9 @@ function mockBidRequest(bid, opts) {
     'bidderCode': bidderCode || bid.bidderCode,
     'auctionId': opts && opts.auctionId,
     'bidderRequestId': requestId,
+    src: bid?._ctx?.src,
+    adUnitsS2SCopy: bid?._ctx?.src === CONSTANTS.S2S.SRC ? bid?._ctx?.adUnits : undefined,
+    uniquePbsTid: bid?._ctx?.src === CONSTANTS.S2S.SRC ? bid?._ctx?.uniquePbsTid : undefined,
     'bids': [
       {
         'bidder': bidderCode || bid.bidderCode,
@@ -108,7 +118,8 @@ function mockBidRequest(bid, opts) {
         'bidId': bid.requestId,
         'bidderRequestId': requestId,
         'auctionId': opts && opts.auctionId,
-        'mediaTypes': mediaType
+        'mediaTypes': mediaType,
+        src: bid?._ctx?.src
       }
     ],
     'auctionStart': 1505250713622,
@@ -160,6 +171,7 @@ describe('auctionmanager.js', function () {
     indexAuctions = [];
     indexStub = sinon.stub(auctionManager, 'index');
     indexStub.get(() => new AuctionIndex(() => indexAuctions));
+    resetAuctionState();
   });
 
   afterEach(() => {
@@ -915,6 +927,11 @@ describe('auctionmanager.js', function () {
       beforeEach(function () {
         ajaxStub = sinon.stub(ajaxLib, 'ajaxBuilder').callsFake(mockAjaxBuilder);
         adUnits = [{
+          mediaTypes: {
+            banner: {
+              sizes: []
+            }
+          },
           code: ADUNIT_CODE,
           transactionId: ADUNIT_CODE,
           bids: [
@@ -1150,12 +1167,19 @@ describe('auctionmanager.js', function () {
     });
 
     describe('when auction timeout is 20', function () {
-      let eventsEmitSpy;
+      let eventsEmitSpy, auctionDone;
 
-      function setupBids(auctionId) {
-        bids = [mockBid(), mockBid({ bidderCode: BIDDER_CODE1 })];
-        let bidRequests = bids.map(bid => mockBidRequest(bid, {auctionId}));
+      function respondToRequest(requestIndex) {
+        server.requests[requestIndex].respond(200, {}, 'response body');
+      }
+
+      function runAuction() {
+        let bidRequests = bids.map(bid => mockBidRequest(bid, {auctionId: auction.getAuctionId()}));
         makeRequestsStub.returns(bidRequests);
+        return new Promise((resolve) => {
+          auctionDone = resolve;
+          auction.callBids();
+        })
       }
 
       beforeEach(function () {
@@ -1164,102 +1188,127 @@ describe('auctionmanager.js', function () {
           transactionId: ADUNIT_CODE,
           bids: [
             {bidder: BIDDER_CODE, params: {placementId: 'id'}},
+            {bidder: BIDDER_CODE1, params: {placementId: 'id'}},
           ]
         }];
         adUnitCodes = [ADUNIT_CODE];
 
         eventsEmitSpy = sinon.spy(events, 'emit');
+        bids = [mockBid(), mockBid({ bidderCode: BIDDER_CODE1 })];
+        const spec1 = mockBidder(BIDDER_CODE, [bids[0]]);
+        registerBidder(spec1);
+        const spec2 = mockBidder(BIDDER_CODE1, [bids[1]]);
+        registerBidder(spec2);
+        auction = auctionModule.newAuction({adUnits, adUnitCodes, callback: () => auctionDone(), cbTimeout: 20});
       });
+
       afterEach(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]]));
+      it('resolves .end on timeout', () => {
         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;
         })
+        const pm = runAuction().then(() => {
+          expect(endResolved).to.be.true;
+        });
+        respondToRequest(0);
+        return pm;
       })
 
-      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 auctionCallback() {
+      it('should emit BID_TIMEOUT and AUCTION_END for timed out bids', function () {
+        const pm = runAuction().then(() => {
           const bidTimeoutCall = eventsEmitSpy.withArgs(CONSTANTS.EVENTS.BID_TIMEOUT).getCalls()[0];
           const timedOutBids = bidTimeoutCall.args[1];
           assert.equal(timedOutBids.length, 1);
           assert.equal(timedOutBids[0].bidder, BIDDER_CODE1);
           // Check that additional properties are available
-          assert.equal(timedOutBids[0].params.placementId, 'id');
+          assert.equal(timedOutBids[0].params[0].placementId, 'id');
 
           const auctionEndCall = eventsEmitSpy.withArgs(CONSTANTS.EVENTS.AUCTION_END).getCalls()[0];
           const auctionProps = auctionEndCall.args[1];
           assert.equal(auctionProps.adUnits, adUnits);
           assert.equal(auctionProps.timeout, 20);
           assert.equal(auctionProps.auctionStatus, AUCTION_COMPLETED)
-          done();
-        }
-        auction = auctionModule.newAuction({adUnits, adUnitCodes, callback: auctionCallback, cbTimeout: 20});
-        setupBids(auction.getAuctionId());
-
-        auction.callBids();
+        });
         respondToRequest(0);
+        return pm;
       });
 
-      it('should NOT emit BID_TIMEOUT when all bidders responded in time', 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() {
+      it('should NOT emit BID_TIMEOUT when all bidders responded in time', function () {
+        const pm = runAuction().then(() => {
           assert.ok(eventsEmitSpy.withArgs(CONSTANTS.EVENTS.BID_TIMEOUT).notCalled, 'did not emit event BID_TIMEOUT');
-          done();
-        }
-        auction = auctionModule.newAuction({adUnits, adUnitCodes, callback: auctionCallback, cbTimeout: 20});
-        setupBids(auction.getAuctionId());
-        auction.callBids();
+        });
         respondToRequest(0);
         respondToRequest(1);
+        return pm;
       });
-      it('should NOT emit BID_TIMEOUT for bidders which responded in time but with an empty bid', function (done) {
-        const spec1 = mockBidder(BIDDER_CODE, []);
-        registerBidder(spec1);
-        const spec2 = mockBidder(BIDDER_CODE1, []);
-        registerBidder(spec2);
 
-        function auctionCallback() {
+      it('should NOT emit BID_TIMEOUT for bidders which responded in time but with an empty bid', function () {
+        const pm = runAuction().then(() => {
           const bidTimeoutCall = eventsEmitSpy.withArgs(CONSTANTS.EVENTS.BID_TIMEOUT).getCalls()[0];
           const timedOutBids = bidTimeoutCall.args[1];
           assert.equal(timedOutBids.length, 1);
           assert.equal(timedOutBids[0].bidder, BIDDER_CODE1);
-          done();
-        }
-        auction = auctionModule.newAuction({adUnits, adUnitCodes, callback: auctionCallback, cbTimeout: 20});
-        setupBids(auction.getAuctionId());
-        auction.callBids();
+        });
         respondToRequest(0);
+        return pm;
       });
+
+      it('should NOT emit BID_TIMEOUT for bidders that replied through S2S', () => {
+        adapterManager.registerBidAdapter(new PrebidServer(), 'pbs');
+        config.setConfig({
+          s2sConfig: [{
+            accountId: '1',
+            enabled: true,
+            defaultVendor: 'appnexus',
+            bidders: ['mock-s2s-1'],
+            adapter: 'pbs'
+          }, {
+            accountId: '1',
+            enabled: true,
+            defaultVendor: 'rubicon',
+            bidders: ['mock-s2s-2'],
+            adapter: 'pbs'
+          }]
+        })
+        adUnits[0].bids.push({bidder: 'mock-s2s-1'}, {bidder: 'mock-s2s-2'})
+        const s2sAdUnits = deepClone(adUnits);
+        bids.unshift(
+          mockBid({bidderCode: 'mock-s2s-1', src: CONSTANTS.S2S.SRC, adUnits: s2sAdUnits, uniquePbsTid: '1'}),
+          mockBid({bidderCode: 'mock-s2s-2', src: CONSTANTS.S2S.SRC, adUnits: s2sAdUnits, uniquePbsTid: '2'})
+        );
+        Object.assign(s2sAdUnits[0], {
+          mediaTypes: {
+            banner: {
+              sizes: [[300, 250], [300, 600]]
+            }
+          },
+          bids: [
+            {
+              bidder: 'mock-s2s-1',
+              bid_id: bids[0].requestId
+            },
+            {
+              bidder: 'mock-s2s-2',
+              bid_id: bids[1].requestId
+            }
+          ]
+        })
+
+        const pm = runAuction().then(() => {
+          const toBids = eventsEmitSpy.withArgs(CONSTANTS.EVENTS.BID_TIMEOUT).getCalls()[0].args[1]
+          expect(toBids.map(bid => bid.bidder)).to.eql([
+            'mock-s2s-2',
+            BIDDER_CODE,
+            BIDDER_CODE1,
+          ])
+        });
+        respondToRequest(1);
+        return pm;
+      })
     });
   });
 
diff --git a/test/spec/modules/adpod_spec.js b/test/spec/modules/adpod_spec.js
index a6164f919ef..14e530c1a9b 100644
--- a/test/spec/modules/adpod_spec.js
+++ b/test/spec/modules/adpod_spec.js
@@ -47,7 +47,6 @@ describe('adpod.js', function () {
       addBidToAuctionStub = sinon.stub(auction, 'addBidToAuction').callsFake(function (auctionInstance, bid) {
         auctionBids.push(bid);
       });
-      doCallbacksIfTimedoutStub = sinon.stub(auction, 'doCallbacksIfTimedout');
       clock = sinon.useFakeTimers();
       config.setConfig({
         cache: {
@@ -61,7 +60,6 @@ describe('adpod.js', function () {
       logWarnStub.restore();
       logInfoStub.restore();
       addBidToAuctionStub.restore();
-      doCallbacksIfTimedoutStub.restore();
       clock.restore();
       config.resetConfig();
       auctionBids = [];
@@ -633,7 +631,6 @@ describe('adpod.js', function () {
       callPrebidCacheHook(callbackFn, auctionInstance, bidResponse1, afterBidAddedSpy, videoMT);
       callPrebidCacheHook(callbackFn, auctionInstance, bidResponse2, afterBidAddedSpy, videoMT);
 
-      expect(doCallbacksIfTimedoutStub.calledTwice).to.equal(true);
       expect(logWarnStub.calledOnce).to.equal(true);
       expect(auctionBids.length).to.equal(0);
     });

From 9e4ed1cea73f246dedd5d40f06beb6f202d0f044 Mon Sep 17 00:00:00 2001
From: "Prebid.js automated release" <prebidjs-release@prebid.org>
Date: Thu, 14 Sep 2023 17:42:12 +0000
Subject: [PATCH 38/46] Prebid 8.14.0 release

---
 package-lock.json | 2 +-
 package.json      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index b0de52e2d6d..f47dff9abee 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "8.14.0-pre",
+  "version": "8.14.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
diff --git a/package.json b/package.json
index 577f10f4c17..049ff5298bd 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "8.14.0-pre",
+  "version": "8.14.0",
   "description": "Header Bidding Management Library",
   "main": "src/prebid.js",
   "scripts": {

From c3409af97c8988850d0b0236c25dcf6013cc77cf Mon Sep 17 00:00:00 2001
From: "Prebid.js automated release" <prebidjs-release@prebid.org>
Date: Thu, 14 Sep 2023 17:42:13 +0000
Subject: [PATCH 39/46] Increment version to 8.15.0-pre

---
 package-lock.json | 2 +-
 package.json      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index f47dff9abee..dffd7c0b837 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "8.14.0",
+  "version": "8.15.0-pre",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
diff --git a/package.json b/package.json
index 049ff5298bd..e2cc34a23ce 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "8.14.0",
+  "version": "8.15.0-pre",
   "description": "Header Bidding Management Library",
   "main": "src/prebid.js",
   "scripts": {

From 5fba72dc4d0497078be8d0eff52b08b7894031a1 Mon Sep 17 00:00:00 2001
From: Maksym Pavliv <73064267+PyjamaWarrior@users.noreply.github.com>
Date: Thu, 14 Sep 2023 20:43:18 +0300
Subject: [PATCH 40/46] Axis Bid Adapter : initial release (#9684)

* New Adapter: Axis

* minor improvements

* fixed coppa and tmax

* updated iabCat

---------

Co-authored-by: Maksym Pavliv <makspavliv@MacBook-Air-Maksym.local>
---
 modules/axisBidAdapter.js                | 210 ++++++++++++
 modules/axisBidAdapter.md                |  83 +++++
 test/spec/modules/axisBidAdapter_spec.js | 414 +++++++++++++++++++++++
 3 files changed, 707 insertions(+)
 create mode 100644 modules/axisBidAdapter.js
 create mode 100644 modules/axisBidAdapter.md
 create mode 100644 test/spec/modules/axisBidAdapter_spec.js

diff --git a/modules/axisBidAdapter.js b/modules/axisBidAdapter.js
new file mode 100644
index 00000000000..8d7f2dd04fd
--- /dev/null
+++ b/modules/axisBidAdapter.js
@@ -0,0 +1,210 @@
+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 = 'axis';
+const AD_URL = 'https://prebid.axis-marketplace.com/pbjs';
+const SYNC_URL = 'https://cs.axis-marketplace.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 { integration, token } = params;
+  const bidfloor = getBidFloor(bid);
+
+  const placement = {
+    integration,
+    token,
+    bidId,
+    schain,
+    bidfloor
+  };
+
+  if (mediaTypes && mediaTypes[BANNER]) {
+    placement.adFormat = BANNER;
+    placement.pos = mediaTypes[BANNER].pos;
+    placement.sizes = mediaTypes[BANNER].sizes;
+  } else if (mediaTypes && mediaTypes[VIDEO]) {
+    placement.adFormat = VIDEO;
+    placement.pos = mediaTypes[VIDEO].pos;
+    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;
+    placement.context = mediaTypes[VIDEO].context;
+  } 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 (e) {
+    logError(e);
+    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.integration && params.token);
+
+    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);
+    }
+
+    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,
+      iabCat: deepAccess(bidderRequest, 'ortb2.site.cat'),
+      coppa: deepAccess(bidderRequest, 'ortb2.regs.coppa') ? 1 : 0,
+      ccpa: bidderRequest.uspConsent || undefined,
+      gdpr: bidderRequest.gdprConsent || undefined,
+      tmax: bidderRequest.timeout || 3000,
+    };
+
+    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=${uspConsent.consentString}`;
+    }
+
+    const coppa = config.getConfig('coppa') ? 1 : 0;
+    syncUrl += `&coppa=${coppa}`;
+
+    return [{
+      type: syncType,
+      url: syncUrl
+    }];
+  }
+};
+
+registerBidder(spec);
diff --git a/modules/axisBidAdapter.md b/modules/axisBidAdapter.md
new file mode 100644
index 00000000000..d1625a56176
--- /dev/null
+++ b/modules/axisBidAdapter.md
@@ -0,0 +1,83 @@
+# Overview
+
+```
+Module Name: Axis Bidder Adapter
+Module Type: Axis Bidder Adapter
+Maintainer: help@axis-marketplace.com
+```
+
+# Description
+
+Connects to Axis exchange for bids.
+Axis 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] ],
+                            pos: 1
+                        }
+                    },
+                    bids: [
+                        {
+                            bidder: 'axis',
+                            params: {
+                                integration: '000000',
+                                token: '000000'
+                            }
+                        }
+                    ]
+                },
+                {
+                    code: 'addunit2',
+                    mediaTypes: {
+                        video: {
+                            playerSize: [ [640, 480] ],
+                            minduration: 5,
+                            maxduration: 60,
+                            pos: 1
+                        }
+                    },
+                    bids: [
+                        {
+                            bidder: 'axis',
+                            params: {
+                                integration: '000000',
+                                token: '000000'
+                            }
+                        }
+                    ]
+                },
+                {
+                    code: 'addunit3',
+                    mediaTypes: {
+                        native: {
+                            title: {
+                                required: true
+                            },
+                            body: {
+                                required: true
+                            },
+                            icon: {
+                                required: true,
+                                size: [64, 64]
+                            }
+                        }
+                    },
+                    bids: [
+                        {
+                            bidder: 'axis',
+                            params: {
+                                integration: '000000',
+                                token: '000000'
+                            }
+                        }
+                    ]
+                }
+            ];
+```
diff --git a/test/spec/modules/axisBidAdapter_spec.js b/test/spec/modules/axisBidAdapter_spec.js
new file mode 100644
index 00000000000..083f05f5c0a
--- /dev/null
+++ b/test/spec/modules/axisBidAdapter_spec.js
@@ -0,0 +1,414 @@
+import { expect } from 'chai';
+import { spec } from '../../../modules/axisBidAdapter.js';
+import { BANNER, VIDEO, NATIVE } from '../../../src/mediaTypes.js';
+import { getUniqueIdentifierStr } from '../../../src/utils.js';
+
+const bidder = 'axis'
+
+describe('AxisBidAdapter', function () {
+  const bids = [
+    {
+      bidId: getUniqueIdentifierStr(),
+      bidder: bidder,
+      mediaTypes: {
+        [BANNER]: {
+          sizes: [[300, 250]],
+          pos: 1
+        }
+      },
+      params: {
+        integration: '000000',
+        token: '000000'
+      }
+    },
+    {
+      bidId: getUniqueIdentifierStr(),
+      bidder: bidder,
+      mediaTypes: {
+        [VIDEO]: {
+          playerSize: [[300, 300]],
+          minduration: 5,
+          maxduration: 60,
+          pos: 1
+        }
+      },
+      params: {
+        integration: '000000',
+        token: '000000'
+      }
+    },
+    {
+      bidId: getUniqueIdentifierStr(),
+      bidder: bidder,
+      mediaTypes: {
+        [NATIVE]: {
+          native: {
+            title: {
+              required: true
+            },
+            body: {
+              required: true
+            },
+            icon: {
+              required: true,
+              size: [64, 64]
+            }
+          }
+        }
+      },
+      params: {
+        integration: '000000',
+        token: '000000'
+      }
+    }
+  ];
+
+  const invalidBid = {
+    bidId: getUniqueIdentifierStr(),
+    bidder: bidder,
+    mediaTypes: {
+      [BANNER]: {
+        sizes: [[300, 250]]
+      }
+    },
+    params: {
+
+    }
+  }
+
+  const bidderRequest = {
+    uspConsent: '1---',
+    gdprConsent: 'COvFyGBOvFyGBAbAAAENAPCAAOAAAAAAAAAAAEEUACCKAAA.IFoEUQQgAIQwgIwQABAEAAAAOIAACAIAAAAQAIAgEAACEAAAAAgAQBAAAAAAAGBAAgAAAAAAAFAAECAAAgAAQARAEQAAAAAJAAIAAgAAAYQEAAAQmAgBC3ZAYzUw',
+    refererInfo: {
+      referer: 'https://test.com'
+    },
+    ortb2: {
+      site: {
+        cat: ['IAB24']
+      }
+    }
+  };
+
+  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://prebid.axis-marketplace.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',
+        'iabCat',
+        '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.iabCat).to.have.lengthOf(1);
+      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.adFormat).to.be.oneOf([BANNER, VIDEO, NATIVE]);
+        expect(placement.bidId).to.be.a('string');
+        expect(placement.integration).to.be.a('string');
+        expect(placement.token).to.be.a('string');
+        expect(placement.schain).to.be.an('object');
+        expect(placement.bidfloor).to.exist.and.to.equal(0);
+
+        if (placement.adFormat === BANNER) {
+          expect(placement.sizes).to.be.an('array');
+        }
+        switch (placement.adFormat) {
+          case BANNER:
+            expect(placement.sizes).to.be.an('array');
+            expect(placement.pos).to.be.within(0, 7);
+            break;
+          case VIDEO:
+            expect(placement.playerSize).to.be.an('array');
+            expect(placement.minduration).to.be.an('number');
+            expect(placement.maxduration).to.be.an('number');
+            expect(placement.pos).to.be.within(0, 7);
+            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.property('advertiserDomains');
+    });
+    it('Should interpret video response', function () {
+      const video = {
+        body: [{
+          vastUrl: 'test.com',
+          mediaType: 'video',
+          cpm: 0.5,
+          requestId: '23fhj33i987f',
+          width: 300,
+          height: 250,
+          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', 'width', 'height');
+      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.property('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.property('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.axis-marketplace.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.axis-marketplace.com/image?pbjs=1&ccpa=1---&coppa=0')
+    });
+  });
+});

From 411844f5d895b56e26fe244c497495cd5c66aff8 Mon Sep 17 00:00:00 2001
From: ccorbo <ccorbo2013@gmail.com>
Date: Thu, 14 Sep 2023 14:01:17 -0400
Subject: [PATCH 41/46] feat:pass pairid [PB-1815] (#10487)

Co-authored-by: Chris Corbo <chris.corbo@indexexchange.com>
---
 modules/ixBidAdapter.js                |  4 +++-
 test/spec/modules/ixBidAdapter_spec.js | 16 +++++++++++-----
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/modules/ixBidAdapter.js b/modules/ixBidAdapter.js
index d083fb46798..50595152b23 100644
--- a/modules/ixBidAdapter.js
+++ b/modules/ixBidAdapter.js
@@ -79,6 +79,7 @@ const SOURCE_RTI_MAPPING = {
   'intimatemerger.com': '',
   '33across.com': '',
   'liveintent.indexexchange.com': '',
+  'google.com': ''
 };
 const PROVIDERS = [
   'britepoolid',
@@ -89,7 +90,8 @@ const PROVIDERS = [
   'connectid',
   'tapadId',
   'quantcastId',
-  'pubProvidedId'
+  'pubProvidedId',
+  'pairId'
 ];
 const REQUIRED_VIDEO_PARAMS = ['mimes', 'minduration', 'maxduration']; // note: protocol/protocols is also reqd
 const VIDEO_PARAMS_ALLOW_LIST = [
diff --git a/test/spec/modules/ixBidAdapter_spec.js b/test/spec/modules/ixBidAdapter_spec.js
index eee0335524d..853215d95ad 100644
--- a/test/spec/modules/ixBidAdapter_spec.js
+++ b/test/spec/modules/ixBidAdapter_spec.js
@@ -759,7 +759,8 @@ describe('IndexexchangeAdapter', function () {
     // similar to uid2, but id5's getValue takes .uid
     id5id: { uid: 'testid5id' }, // ID5
     imuid: 'testimuid',
-    '33acrossId': { envelope: 'v1.5fs.1000.fjdiosmclds' }
+    '33acrossId': { envelope: 'v1.5fs.1000.fjdiosmclds' },
+    pairId: {envelope: 'testpairId'}
   };
 
   const DEFAULT_USERID_PAYLOAD = [
@@ -818,6 +819,11 @@ describe('IndexexchangeAdapter', function () {
       uids: [{
         id: DEFAULT_USERID_DATA['33acrossId'].envelope
       }]
+    }, {
+      source: 'google.com',
+      uids: [{
+        id: DEFAULT_USERID_DATA['pairId'].envelope
+      }]
     }
   ];
 
@@ -1224,7 +1230,7 @@ describe('IndexexchangeAdapter', function () {
         const payload = extractPayload(request[0]);
         expect(request).to.be.an('array');
         expect(request).to.have.lengthOf.above(0); // should be 1 or more
-        expect(payload.user.eids).to.have.lengthOf(8);
+        expect(payload.user.eids).to.have.lengthOf(9);
         expect(payload.user.eids).to.deep.include(DEFAULT_USERID_PAYLOAD[0]);
       });
     });
@@ -1412,7 +1418,7 @@ describe('IndexexchangeAdapter', function () {
       cloneValidBid[0].userIdAsEids = utils.deepClone(DEFAULT_USERIDASEIDS_DATA);
       const request = spec.buildRequests(cloneValidBid, DEFAULT_OPTION)[0];
       const payload = extractPayload(request);
-      expect(payload.user.eids).to.have.lengthOf(8);
+      expect(payload.user.eids).to.have.lengthOf(9);
       expect(payload.user.eids).to.have.deep.members(DEFAULT_USERID_PAYLOAD);
     });
 
@@ -1545,7 +1551,7 @@ describe('IndexexchangeAdapter', function () {
       })
 
       expect(payload.user).to.exist;
-      expect(payload.user.eids).to.have.lengthOf(10);
+      expect(payload.user.eids).to.have.lengthOf(11);
 
       expect(payload.user.eids).to.have.deep.members(validUserIdPayload);
     });
@@ -1587,7 +1593,7 @@ describe('IndexexchangeAdapter', function () {
       });
 
       const payload = extractPayload(request);
-      expect(payload.user.eids).to.have.lengthOf(9);
+      expect(payload.user.eids).to.have.lengthOf(10);
       expect(payload.user.eids).to.have.deep.members(validUserIdPayload);
     });
   });

From ca555d334117abe97a6082291a873ac171147174 Mon Sep 17 00:00:00 2001
From: Cadent Aperture MX <43830380+EMXDigital@users.noreply.github.com>
Date: Thu, 14 Sep 2023 14:02:34 -0400
Subject: [PATCH 42/46] Cadent Aperture MX Bid Adapter: address
 auctionId/transactionId leak (#10485)

---
 modules/cadentApertureMXBidAdapter.js           |  4 ++--
 .../modules/cadentApertureMXBidAdapter_spec.js  | 17 ++++++++++++++++-
 2 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/modules/cadentApertureMXBidAdapter.js b/modules/cadentApertureMXBidAdapter.js
index 32c0a4e4643..079ca592160 100644
--- a/modules/cadentApertureMXBidAdapter.js
+++ b/modules/cadentApertureMXBidAdapter.js
@@ -277,7 +277,7 @@ export const spec = {
       let isVideo = !!bid.mediaTypes.video;
       let data = {
         id: bid.bidId,
-        tid: bid.transactionId,
+        tid: bid.ortb2Imp?.ext?.tid,
         tagid,
         secure
       };
@@ -297,7 +297,7 @@ export const spec = {
     });
 
     let cadentData = {
-      id: bidderRequest.auctionId,
+      id: bidderRequest.auctionId ?? bidderRequest.bidderRequestId,
       imp: cadentImps,
       device,
       site,
diff --git a/test/spec/modules/cadentApertureMXBidAdapter_spec.js b/test/spec/modules/cadentApertureMXBidAdapter_spec.js
index 202659641f9..3ccb5405552 100644
--- a/test/spec/modules/cadentApertureMXBidAdapter_spec.js
+++ b/test/spec/modules/cadentApertureMXBidAdapter_spec.js
@@ -237,6 +237,11 @@ describe('cadent_aperture_mx Adapter', function () {
         'bidId': '30b31c2501de1e',
         'auctionId': 'e19f1eff-8b27-42a6-888d-9674e5a6130c',
         'transactionId': 'd7b773de-ceaa-484d-89ca-d9f51b8d61ec',
+        'ortb2Imp': {
+          'ext': {
+            'tid': 'd7b773de-ceaa-484d-89ca-d9f51b8d61ed',
+          },
+        },
       }]
     };
     let request = spec.buildRequests(bidderRequest.bids, bidderRequest);
@@ -297,12 +302,22 @@ describe('cadent_aperture_mx Adapter', function () {
         expect(data.id).to.equal(bidderRequest.auctionId);
         expect(data.imp.length).to.equal(1);
         expect(data.imp[0].id).to.equal('30b31c2501de1e');
-        expect(data.imp[0].tid).to.equal('d7b773de-ceaa-484d-89ca-d9f51b8d61ec');
+        expect(data.imp[0].tid).to.equal('d7b773de-ceaa-484d-89ca-d9f51b8d61ed');
         expect(data.imp[0].tagid).to.equal('25251');
         expect(data.imp[0].secure).to.equal(0);
         expect(data.imp[0].vastXml).to.equal(undefined);
       });
 
+      it('populates id even when auctionId is not available', function () {
+        // addressing https://github.com/prebid/Prebid.js/issues/9781
+        bidderRequest.auctionId = null;
+        request = spec.buildRequests(bidderRequest.bids, bidderRequest);
+
+        const data = JSON.parse(request.data);
+        expect(data.id).not.to.be.null;
+        expect(data.id).not.to.equal(bidderRequest.auctionId);
+      });
+
       it('properly sends site information and protocol', function () {
         request = spec.buildRequests(bidderRequest.bids, bidderRequest);
         request = JSON.parse(request.data);

From 7764e5380befe7967a367fc7cf725ef5fea6c4ae Mon Sep 17 00:00:00 2001
From: Demetrio Girardi <dgirardi@prebid.org>
Date: Thu, 14 Sep 2023 11:09:41 -0700
Subject: [PATCH 43/46] fledgeForGpt: provide `bidfloor` in auction signals
 (#10393)

* fledgeForGpt: delay slot config to end of auction

* currency utils

* reducers

* Set `prebid.bidfloor` and `prebid.bidfloorcur` in fledge auction signals

---------

Co-authored-by: Patrick McCann <patmmccann@gmail.com>
---
 libraries/currencyUtils/currency.js           |   31 +
 modules/fledgeForGpt.js                       |   73 +-
 modules/prebidServerBidAdapter/index.js       |    2 +-
 .../prebidServerBidAdapter/ortbConverter.js   |   12 +-
 modules/priceFloors.js                        |    6 +-
 src/adapters/bidderFactory.js                 |    5 +-
 src/prebid.js                                 |    2 +-
 src/targeting.js                              |    3 +-
 src/utils.js                                  |   20 -
 src/utils/currency.js                         |   16 -
 src/utils/reducers.js                         |   44 +
 test/spec/libraries/currencyUtils_spec.js     |  113 +
 test/spec/modules/fledgeForGpt_spec.js        |  429 +++
 test/spec/modules/fledge_spec.js              |  282 --
 test/spec/modules/multibid_spec.js            |   21 +-
 .../modules/prebidServerBidAdapter_spec.js    |    8 +-
 test/spec/unit/core/bidderFactory_spec.js     | 2311 +++++++++--------
 test/spec/unit/core/targeting_spec.js         |   20 +-
 test/spec/unit/utils/reducers_spec.js         |  124 +
 test/spec/utils_spec.js                       |   67 +-
 20 files changed, 2000 insertions(+), 1589 deletions(-)
 create mode 100644 libraries/currencyUtils/currency.js
 delete mode 100644 src/utils/currency.js
 create mode 100644 src/utils/reducers.js
 create mode 100644 test/spec/libraries/currencyUtils_spec.js
 create mode 100644 test/spec/modules/fledgeForGpt_spec.js
 delete mode 100644 test/spec/modules/fledge_spec.js
 create mode 100644 test/spec/unit/utils/reducers_spec.js

diff --git a/libraries/currencyUtils/currency.js b/libraries/currencyUtils/currency.js
new file mode 100644
index 00000000000..924f8f200d8
--- /dev/null
+++ b/libraries/currencyUtils/currency.js
@@ -0,0 +1,31 @@
+import {getGlobal} from '../../src/prebidGlobal.js';
+import {keyCompare} from '../../src/utils/reducers.js';
+
+/**
+ * Attempt to convert `amount` from the currency `fromCur` to the currency `toCur`.
+ *
+ * By default, when the conversion is not possible (currency module not present or
+ * throwing errors), the amount is returned unchanged. This behavior can be
+ * toggled off with bestEffort = false.
+ */
+export function convertCurrency(amount, fromCur, toCur, bestEffort = true) {
+  if (fromCur === toCur) return amount;
+  let result = amount;
+  try {
+    result = getGlobal().convertCurrency(amount, fromCur, toCur);
+  } catch (e) {
+    if (!bestEffort) throw e;
+  }
+  return result;
+}
+
+export function currencyNormalizer(toCurrency = null, bestEffort = true, convert = convertCurrency) {
+  return function (amount, currency) {
+    if (toCurrency == null) toCurrency = currency;
+    return convert(amount, currency, toCurrency, bestEffort);
+  }
+}
+
+export function currencyCompare(get = (obj) => [obj.cpm, obj.currency], normalize = currencyNormalizer()) {
+  return keyCompare(obj => normalize.apply(null, get(obj)))
+}
diff --git a/modules/fledgeForGpt.js b/modules/fledgeForGpt.js
index e592cd38044..eddb7424f92 100644
--- a/modules/fledgeForGpt.js
+++ b/modules/fledgeForGpt.js
@@ -4,10 +4,15 @@
  */
 import { config } from '../src/config.js';
 import { getHook } from '../src/hook.js';
-import { getGptSlotForAdUnitCode, logInfo, logWarn } from '../src/utils.js';
+import {deepSetValue, getGptSlotForAdUnitCode, logInfo, logWarn, mergeDeep} from '../src/utils.js';
 import {IMP, PBS, registerOrtbProcessor, RESPONSE} from '../src/pbjsORTB.js';
+import * as events from '../src/events.js'
+import CONSTANTS from '../src/constants.json';
+import {currencyCompare} from '../libraries/currencyUtils/currency.js';
+import {maximum, minimum} from '../src/utils/reducers.js';
 
 const MODULE = 'fledgeForGpt'
+const PENDING = {};
 
 export let isEnabled = false;
 
@@ -21,6 +26,8 @@ export function init(cfg) {
     if (!isEnabled) {
       getHook('addComponentAuction').before(addComponentAuctionHook);
       getHook('makeBidRequests').after(markForFledge);
+      events.on(CONSTANTS.EVENTS.AUCTION_INIT, onAuctionInit);
+      events.on(CONSTANTS.EVENTS.AUCTION_END, onAuctionEnd);
       isEnabled = true;
     }
     logInfo(`${MODULE} enabled (browser ${isFledgeSupported() ? 'supports' : 'does NOT support'} fledge)`, cfg);
@@ -28,28 +35,74 @@ export function init(cfg) {
     if (isEnabled) {
       getHook('addComponentAuction').getHooks({hook: addComponentAuctionHook}).remove();
       getHook('makeBidRequests').getHooks({hook: markForFledge}).remove()
+      events.off(CONSTANTS.EVENTS.AUCTION_INIT, onAuctionInit);
+      events.off(CONSTANTS.EVENTS.AUCTION_END, onAuctionEnd);
       isEnabled = false;
     }
     logInfo(`${MODULE} disabled`, cfg);
   }
 }
 
-export function addComponentAuctionHook(next, adUnitCode, componentAuctionConfig) {
-  const seller = componentAuctionConfig.seller;
+function setComponentAuction(adUnitCode, auctionConfigs) {
   const gptSlot = getGptSlotForAdUnitCode(adUnitCode);
   if (gptSlot && gptSlot.setConfig) {
     gptSlot.setConfig({
-      componentAuction: [{
-        configKey: seller,
-        auctionConfig: componentAuctionConfig
-      }]
+      componentAuction: auctionConfigs.map(cfg => ({
+        configKey: cfg.seller,
+        auctionConfig: cfg
+      }))
     });
-    logInfo(MODULE, `register component auction config for: ${adUnitCode} x ${seller}: ${gptSlot.getAdUnitPath()}`, componentAuctionConfig);
+    logInfo(MODULE, `register component auction configs for: ${adUnitCode}: ${gptSlot.getAdUnitPath()}`, auctionConfigs);
   } else {
-    logWarn(MODULE, `unable to register component auction config for: ${adUnitCode} x ${seller}.`);
+    logWarn(MODULE, `unable to register component auction config for ${adUnitCode}`, auctionConfigs);
   }
+}
+
+function onAuctionInit({auctionId}) {
+  PENDING[auctionId] = {};
+}
+
+function getSlotSignals(bidsReceived = [], bidRequests = []) {
+  let bidfloor, bidfloorcur;
+  if (bidsReceived.length > 0) {
+    const bestBid = bidsReceived.reduce(maximum(currencyCompare(bid => [bid.cpm, bid.currency])));
+    bidfloor = bestBid.cpm;
+    bidfloorcur = bestBid.currency;
+  } else {
+    const floors = bidRequests.map(bid => typeof bid.getFloor === 'function' && bid.getFloor()).filter(f => f);
+    const minFloor = floors.length && floors.reduce(minimum(currencyCompare(floor => [floor.floor, floor.currency])))
+    bidfloor = minFloor?.floor;
+    bidfloorcur = minFloor?.currency;
+  }
+  const cfg = {};
+  if (bidfloor) {
+    deepSetValue(cfg, 'auctionSignals.prebid.bidfloor', bidfloor);
+    bidfloorcur && deepSetValue(cfg, 'auctionSignals.prebid.bidfloorcur', bidfloorcur);
+  }
+  return cfg;
+}
 
-  next(adUnitCode, componentAuctionConfig);
+function onAuctionEnd({auctionId, bidsReceived, bidderRequests}) {
+  try {
+    const allReqs = bidderRequests?.flatMap(br => br.bids);
+    Object.entries(PENDING[auctionId]).forEach(([adUnitCode, auctionConfigs]) => {
+      const forThisAdUnit = (bid) => bid.adUnitCode === adUnitCode;
+      const slotSignals = getSlotSignals(bidsReceived?.filter(forThisAdUnit), allReqs?.filter(forThisAdUnit));
+      setComponentAuction(adUnitCode, auctionConfigs.map(cfg => mergeDeep({}, slotSignals, cfg)))
+    })
+  } finally {
+    delete PENDING[auctionId];
+  }
+}
+
+export function addComponentAuctionHook(next, auctionId, adUnitCode, componentAuctionConfig) {
+  if (PENDING.hasOwnProperty(auctionId)) {
+    !PENDING[auctionId].hasOwnProperty(adUnitCode) && (PENDING[auctionId][adUnitCode] = []);
+    PENDING[auctionId][adUnitCode].push(componentAuctionConfig);
+  } else {
+    logWarn(MODULE, `Received component auction config for auction that has closed (auction '${auctionId}', adUnit '${adUnitCode}')`, componentAuctionConfig)
+  }
+  next(auctionId, adUnitCode, componentAuctionConfig);
 }
 
 function isFledgeSupported() {
diff --git a/modules/prebidServerBidAdapter/index.js b/modules/prebidServerBidAdapter/index.js
index 776ad99fa25..e49dfec2f1c 100644
--- a/modules/prebidServerBidAdapter/index.js
+++ b/modules/prebidServerBidAdapter/index.js
@@ -506,7 +506,7 @@ export function PrebidServer() {
           }
         },
         onFledge: ({adUnitCode, config}) => {
-          addComponentAuction(adUnitCode, config);
+          addComponentAuction(bidRequests[0].auctionId, adUnitCode, config);
         }
       })
     }
diff --git a/modules/prebidServerBidAdapter/ortbConverter.js b/modules/prebidServerBidAdapter/ortbConverter.js
index 7d3a6137d40..54f71c7dc3e 100644
--- a/modules/prebidServerBidAdapter/ortbConverter.js
+++ b/modules/prebidServerBidAdapter/ortbConverter.js
@@ -17,13 +17,14 @@ import {pbsExtensions} from '../../libraries/pbsExtensions/pbsExtensions.js';
 import {setImpBidParams} from '../../libraries/pbsExtensions/processors/params.js';
 import {SUPPORTED_MEDIA_TYPES} from '../../libraries/pbsExtensions/processors/mediaType.js';
 import {IMP, REQUEST, RESPONSE} from '../../src/pbjsORTB.js';
-import {beConvertCurrency} from '../../src/utils/currency.js';
 import {redactor} from '../../src/activities/redactor.js';
 import {s2sActivityParams} from '../../src/adapterManager.js';
 import {activityParams} from '../../src/activities/activityParams.js';
 import {MODULE_TYPE_BIDDER} from '../../src/activities/modules.js';
 import {isActivityAllowed} from '../../src/activities/rules.js';
 import {ACTIVITY_TRANSMIT_TID} from '../../src/activities/activities.js';
+import {currencyCompare} from '../../libraries/currencyUtils/currency.js';
+import {minimum} from '../../src/utils/reducers.js';
 
 const DEFAULT_S2S_TTL = 60;
 const DEFAULT_S2S_CURRENCY = 'USD';
@@ -141,6 +142,7 @@ const PBS_CONVERTER = ortbConverter({
       bidfloor(orig, imp, proxyBidRequest, context) {
         // for bid floors, we pass each bidRequest associated with this imp through normal bidfloor processing,
         // and aggregate all of them into a single, minimum floor to put in the request
+        const getMin = minimum(currencyCompare(floor => [floor.bidfloor, floor.bidfloorcur]));
         let min;
         for (const req of context.actualBidRequests.values()) {
           const floor = {};
@@ -149,14 +151,8 @@ const PBS_CONVERTER = ortbConverter({
           if (floor.bidfloorcur == null || floor.bidfloor == null) {
             min = null;
             break;
-          } else if (min == null) {
-            min = floor;
-          } else {
-            const value = beConvertCurrency(floor.bidfloor, floor.bidfloorcur, min.bidfloorcur);
-            if (value != null && value < min.bidfloor) {
-              min = floor;
-            }
           }
+          min = min == null ? floor : getMin(min, floor);
         }
         if (min != null) {
           Object.assign(imp, min);
diff --git a/modules/priceFloors.js b/modules/priceFloors.js
index 37167fff691..a72a79c2b40 100644
--- a/modules/priceFloors.js
+++ b/modules/priceFloors.js
@@ -27,8 +27,8 @@ import {bidderSettings} from '../src/bidderSettings.js';
 import {auctionManager} from '../src/auctionManager.js';
 import {IMP, PBS, registerOrtbProcessor, REQUEST} from '../src/pbjsORTB.js';
 import {timedAuctionHook, timedBidResponseHook} from '../src/utils/perfMetrics.js';
-import {beConvertCurrency} from '../src/utils/currency.js';
 import {adjustCpm} from '../src/utils/cpm.js';
+import {convertCurrency} from '../libraries/currencyUtils/currency.js';
 
 /**
  * @summary This Module is intended to provide users with the ability to dynamically set and enforce price floors on a per auction basis.
@@ -794,8 +794,8 @@ export function setImpExtPrebidFloors(imp, bidRequest, context) {
     if (floorMinCur == null) { floorMinCur = imp.bidfloorcur }
     const ortb2ImpFloorCur = imp.ext?.prebid?.floors?.floorMinCur || imp.ext?.prebid?.floorMinCur || floorMinCur;
     const ortb2ImpFloorMin = imp.ext?.prebid?.floors?.floorMin || imp.ext?.prebid?.floorMin;
-    const convertedFloorMinValue = beConvertCurrency(imp.bidfloor, imp.bidfloorcur, floorMinCur);
-    const convertedOrtb2ImpFloorMinValue = ortb2ImpFloorMin && ortb2ImpFloorCur ? beConvertCurrency(ortb2ImpFloorMin, ortb2ImpFloorCur, floorMinCur) : false;
+    const convertedFloorMinValue = convertCurrency(imp.bidfloor, imp.bidfloorcur, floorMinCur);
+    const convertedOrtb2ImpFloorMinValue = ortb2ImpFloorMin && ortb2ImpFloorCur ? convertCurrency(ortb2ImpFloorMin, ortb2ImpFloorCur, floorMinCur) : false;
 
     const lowestImpFloorMin = convertedOrtb2ImpFloorMinValue && convertedOrtb2ImpFloorMinValue < convertedFloorMinValue
       ? convertedOrtb2ImpFloorMinValue
diff --git a/src/adapters/bidderFactory.js b/src/adapters/bidderFactory.js
index b31019a6d79..df97d820c96 100644
--- a/src/adapters/bidderFactory.js
+++ b/src/adapters/bidderFactory.js
@@ -288,14 +288,11 @@ export function newBidder(spec) {
           onTimelyResponse(spec.code);
           responses.push(resp)
         },
-        /** Process eventual BidderAuctionResponse.fledgeAuctionConfig field in response.
-         * @param {Array<FledgeAuctionConfig>} fledgeAuctionConfigs
-         */
         onFledgeAuctionConfigs: (fledgeAuctionConfigs) => {
           fledgeAuctionConfigs.forEach((fledgeAuctionConfig) => {
             const bidRequest = bidRequestMap[fledgeAuctionConfig.bidId];
             if (bidRequest) {
-              addComponentAuction(bidRequest.adUnitCode, fledgeAuctionConfig.config);
+              addComponentAuction(bidRequest.auctionId, bidRequest.adUnitCode, fledgeAuctionConfig.config);
             } else {
               logWarn('Received fledge auction configuration for an unknown bidId', fledgeAuctionConfig);
             }
diff --git a/src/prebid.js b/src/prebid.js
index 5c5f66d6028..decc2a7cef6 100644
--- a/src/prebid.js
+++ b/src/prebid.js
@@ -12,7 +12,6 @@ import {
   deepSetValue,
   flatten,
   generateUUID,
-  getHighestCpm,
   inIframe,
   insertElement,
   isArray,
@@ -52,6 +51,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 {getHighestCpm} from './utils/reducers.js';
 import {fillVideoDefaults} from './video.js';
 
 const pbjsInstance = getGlobal();
diff --git a/src/targeting.js b/src/targeting.js
index ed313c55684..0aa395aa9a3 100644
--- a/src/targeting.js
+++ b/src/targeting.js
@@ -1,8 +1,6 @@
 import {
   deepAccess,
   deepClone,
-  getHighestCpm,
-  getOldestHighestCpmBid,
   groupBy,
   isAdUnitCodeMatchingSlot,
   isArray,
@@ -24,6 +22,7 @@ import {hook} from './hook.js';
 import {bidderSettings} from './bidderSettings.js';
 import {find, includes} from './polyfill.js';
 import CONSTANTS from './constants.json';
+import {getHighestCpm, getOldestHighestCpmBid} from './utils/reducers.js';
 import {getTTL} from './bidTTL.js';
 
 var pbTargetingKeys = [];
diff --git a/src/utils.js b/src/utils.js
index 5ad8b5031bd..c436b6385e7 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -729,26 +729,6 @@ export function isApnGetTagDefined() {
   }
 }
 
-// This function will get highest cpm value bid, in case of tie it will return the bid with lowest timeToRespond
-export const getHighestCpm = getHighestCpmCallback('timeToRespond', (previous, current) => previous > current);
-
-// This function will get the oldest hightest cpm value bid, in case of tie it will return the bid which came in first
-// Use case for tie: https://github.com/prebid/Prebid.js/issues/2448
-export const getOldestHighestCpmBid = getHighestCpmCallback('responseTimestamp', (previous, current) => previous > current);
-
-// This function will get the latest hightest cpm value bid, in case of tie it will return the bid which came in last
-// Use case for tie: https://github.com/prebid/Prebid.js/issues/2539
-export const getLatestHighestCpmBid = getHighestCpmCallback('responseTimestamp', (previous, current) => previous < current);
-
-function getHighestCpmCallback(useTieBreakerProperty, tieBreakerCallback) {
-  return (previous, current) => {
-    if (previous.cpm === current.cpm) {
-      return tieBreakerCallback(previous[useTieBreakerProperty], current[useTieBreakerProperty]) ? current : previous;
-    }
-    return previous.cpm < current.cpm ? current : previous;
-  }
-}
-
 /**
  * Fisher–Yates shuffle
  * http://stackoverflow.com/a/6274398
diff --git a/src/utils/currency.js b/src/utils/currency.js
deleted file mode 100644
index ab7e5faa1ea..00000000000
--- a/src/utils/currency.js
+++ /dev/null
@@ -1,16 +0,0 @@
-import {getGlobal} from '../prebidGlobal.js';
-
-/**
- * "best effort" wrapper around currency conversion; always returns an amount that may or may not be correct.
- */
-export function beConvertCurrency(amount, from, to) {
-  if (from === to) return amount;
-  let result = amount;
-  if (typeof getGlobal().convertCurrency === 'function') {
-    try {
-      result = getGlobal().convertCurrency(amount, from, to);
-    } catch (e) {
-    }
-  }
-  return result;
-}
diff --git a/src/utils/reducers.js b/src/utils/reducers.js
new file mode 100644
index 00000000000..28851be8aaa
--- /dev/null
+++ b/src/utils/reducers.js
@@ -0,0 +1,44 @@
+export function simpleCompare(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+
+export function keyCompare(key = (item) => item) {
+  return (a, b) => simpleCompare(key(a), key(b))
+}
+
+export function reverseCompare(compare = simpleCompare) {
+  return (a, b) => -compare(a, b) || 0;
+}
+
+export function tiebreakCompare(...compares) {
+  return function (a, b) {
+    for (const cmp of compares) {
+      const val = cmp(a, b);
+      if (val !== 0) return val;
+    }
+    return 0;
+  }
+}
+
+export function minimum(compare = simpleCompare) {
+  return (min, item) => compare(item, min) < 0 ? item : min;
+}
+
+export function maximum(compare = simpleCompare) {
+  return minimum(reverseCompare(compare));
+}
+
+const cpmCompare = keyCompare((bid) => bid.cpm);
+const timestampCompare = keyCompare((bid) => bid.responseTimestamp);
+
+// This function will get highest cpm value bid, in case of tie it will return the bid with lowest timeToRespond
+export const getHighestCpm = maximum(tiebreakCompare(cpmCompare, reverseCompare(keyCompare((bid) => bid.timeToRespond))))
+
+// This function will get the oldest hightest cpm value bid, in case of tie it will return the bid which came in first
+// Use case for tie: https://github.com/prebid/Prebid.js/issues/2448
+export const getOldestHighestCpmBid = maximum(tiebreakCompare(cpmCompare, reverseCompare(timestampCompare)))
+
+// This function will get the latest hightest cpm value bid, in case of tie it will return the bid which came in last
+// Use case for tie: https://github.com/prebid/Prebid.js/issues/2539
+export const getLatestHighestCpmBid = maximum(tiebreakCompare(cpmCompare, timestampCompare))
diff --git a/test/spec/libraries/currencyUtils_spec.js b/test/spec/libraries/currencyUtils_spec.js
new file mode 100644
index 00000000000..9d3d73e6a5f
--- /dev/null
+++ b/test/spec/libraries/currencyUtils_spec.js
@@ -0,0 +1,113 @@
+import {getGlobal} from 'src/prebidGlobal.js';
+import {convertCurrency, currencyCompare, currencyNormalizer} from 'libraries/currencyUtils/currency.js';
+
+describe('currency utils', () => {
+  let sandbox;
+  before(() => {
+    if (!getGlobal().convertCurrency) {
+      getGlobal().convertCurrency = () => null;
+      getGlobal().convertCurrency.mock = true;
+    }
+  });
+
+  after(() => {
+    if (getGlobal().convertCurrency.mock) {
+      delete getGlobal().convertCurrency;
+    }
+  })
+
+  beforeEach(() => {
+    sandbox = sinon.sandbox.create();
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('convertCurrency', () => {
+    Object.entries({
+      'not available': () => sandbox.stub(getGlobal(), 'convertCurrency').value(undefined),
+      'throwing errors': () => sandbox.stub(getGlobal(), 'convertCurrency').callsFake(() => { throw new Error(); }),
+    }).forEach(([t, setup]) => {
+      describe(`when currency module is ${t}`, () => {
+        beforeEach(setup);
+
+        it('should "convert" to the same currency', () => {
+          expect(convertCurrency(123, 'mock', 'mock', false)).to.eql(123);
+        });
+
+        it('should throw when suppressErrors = false', () => {
+          expect(() => convertCurrency(123, 'c1', 'c2', false)).to.throw();
+        });
+
+        it('should return input value when suppressErrors = true', () => {
+          expect(convertCurrency(123, 'c1', 'c2', true)).to.eql(123);
+        })
+      })
+    });
+
+    describe('when currency module is working', () => {
+      beforeEach(() => {
+        sandbox.stub(getGlobal(), 'convertCurrency').callsFake((amt) => amt * 10)
+      });
+
+      it('should be used for actual conversions', () => {
+        expect(convertCurrency(123, 'c1', 'c2')).to.eql(1230);
+        sinon.assert.calledWith(getGlobal().convertCurrency, 123, 'c1', 'c2');
+      });
+
+      it('should NOT be used when no conversion is necessary', () => {
+        expect(convertCurrency(123, 'cur', 'cur')).to.eql(123);
+        sinon.assert.notCalled(getGlobal().convertCurrency);
+      })
+    })
+  });
+
+  describe('Currency normalization', () => {
+    let mockConvert;
+    beforeEach(() => {
+      mockConvert = sinon.stub().callsFake((amt, from, to) => {
+        if (from === to) return amt;
+        return amt / from * to
+      })
+    });
+
+    describe('currencyNormalizer', () => {
+      it('converts to toCurrency if set', () => {
+        const normalize = currencyNormalizer(10, true, mockConvert);
+        expect(normalize(1, 1)).to.eql(10);
+        expect(normalize(10, 100)).to.eql(1);
+      });
+
+      it('converts to first currency if toCurrency is not set', () => {
+        const normalize = currencyNormalizer(null, true, mockConvert);
+        expect(normalize(1, 1)).to.eql(1);
+        expect(normalize(1, 10)).to.eql(0.1);
+      });
+
+      [true, false].forEach(bestEffort => {
+        it(`passes bestEffort = ${bestEffort} to convert`, () => {
+          currencyNormalizer(null, bestEffort, mockConvert)(1, 1);
+          sinon.assert.calledWith(mockConvert, 1, 1, 1, bestEffort);
+        })
+      })
+    });
+
+    describe('currencyCompare', () => {
+      let compare
+      beforeEach(() => {
+        compare = currencyCompare((val) => [val.amount, val.cur], currencyNormalizer(null, false, mockConvert))
+      });
+      [
+        [{amount: 1, cur: 1}, {amount: 1, cur: 10}, 1],
+        [{amount: 10, cur: 1}, {amount: 0.1, cur: 100}, 1],
+        [{amount: 1, cur: 1}, {amount: 10, cur: 10}, 0],
+      ].forEach(([a, b, expected]) => {
+        it(`should compare ${a.amount}/${a.cur} and ${b.amount}/${b.cur}`, () => {
+          expect(compare(a, b)).to.equal(expected);
+          expect(compare(b, a)).to.equal(-expected);
+        });
+      });
+    })
+  })
+})
diff --git a/test/spec/modules/fledgeForGpt_spec.js b/test/spec/modules/fledgeForGpt_spec.js
new file mode 100644
index 00000000000..0bcd7753e55
--- /dev/null
+++ b/test/spec/modules/fledgeForGpt_spec.js
@@ -0,0 +1,429 @@
+import {
+  expect
+} from 'chai';
+import * as fledge from 'modules/fledgeForGpt.js';
+import {config} from '../../../src/config.js';
+import adapterManager from '../../../src/adapterManager.js';
+import * as utils from '../../../src/utils.js';
+import {hook} from '../../../src/hook.js';
+import 'modules/appnexusBidAdapter.js';
+import 'modules/rubiconBidAdapter.js';
+import {parseExtPrebidFledge, setImpExtAe, setResponseFledgeConfigs} from 'modules/fledgeForGpt.js';
+import * as events from 'src/events.js';
+import CONSTANTS from 'src/constants.json';
+import {getGlobal} from '../../../src/prebidGlobal.js';
+
+describe('fledgeForGpt module', () => {
+  let sandbox;
+
+  beforeEach(() => {
+    sandbox = sinon.sandbox.create();
+  });
+  afterEach(() => {
+    sandbox.restore();
+  });
+  describe('addComponentAuction', function () {
+    before(() => {
+      fledge.init({enabled: true});
+    });
+
+    const fledgeAuctionConfig = {
+      seller: 'bidder',
+      mock: 'config'
+    };
+
+    describe('addComponentAuctionHook', function () {
+      let nextFnSpy, mockGptSlot;
+      beforeEach(function () {
+        nextFnSpy = sinon.spy();
+        mockGptSlot = {
+          setConfig: sinon.stub(),
+          getAdUnitPath: () => 'mock/gpt/au'
+        };
+        sandbox.stub(utils, 'getGptSlotForAdUnitCode').callsFake(() => mockGptSlot);
+      });
+
+      it('should call next()', function () {
+        fledge.addComponentAuctionHook(nextFnSpy, 'aid', 'auc', fledgeAuctionConfig);
+        sinon.assert.calledWith(nextFnSpy, 'aid', 'auc', fledgeAuctionConfig);
+      });
+
+      it('should collect auction configs and route them to GPT at end of auction', () => {
+        events.emit(CONSTANTS.EVENTS.AUCTION_INIT, {auctionId: 'aid'});
+        const cf1 = {...fledgeAuctionConfig, id: 1, seller: 'b1'};
+        const cf2 = {...fledgeAuctionConfig, id: 2, seller: 'b2'};
+        fledge.addComponentAuctionHook(nextFnSpy, 'aid', 'au1', cf1);
+        fledge.addComponentAuctionHook(nextFnSpy, 'aid', 'au2', cf2);
+        events.emit(CONSTANTS.EVENTS.AUCTION_END, {auctionId: 'aid'});
+        sinon.assert.calledWith(utils.getGptSlotForAdUnitCode, 'au1');
+        sinon.assert.calledWith(utils.getGptSlotForAdUnitCode, 'au2');
+        sinon.assert.calledWith(mockGptSlot.setConfig, {
+          componentAuction: [{
+            configKey: 'b1',
+            auctionConfig: cf1,
+          }]
+        });
+        sinon.assert.calledWith(mockGptSlot.setConfig, {
+          componentAuction: [{
+            configKey: 'b2',
+            auctionConfig: cf2,
+          }]
+        });
+      });
+
+      it('should drop auction configs after end of auction', () => {
+        events.emit(CONSTANTS.EVENTS.AUCTION_INIT, {auctionId: 'aid'});
+        events.emit(CONSTANTS.EVENTS.AUCTION_END, {auctionId: 'aid'});
+        fledge.addComponentAuctionHook(nextFnSpy, 'aid', 'au', fledgeAuctionConfig);
+        events.emit(CONSTANTS.EVENTS.AUCTION_END, {auctionId: 'aid'});
+        sinon.assert.notCalled(mockGptSlot.setConfig);
+      });
+
+      describe('floor signal', () => {
+        before(() => {
+          if (!getGlobal().convertCurrency) {
+            getGlobal().convertCurrency = () => null;
+            getGlobal().convertCurrency.mock = true;
+          }
+        });
+        after(() => {
+          if (getGlobal().convertCurrency.mock) {
+            delete getGlobal().convertCurrency;
+          }
+        });
+
+        beforeEach(() => {
+          sandbox.stub(getGlobal(), 'convertCurrency').callsFake((amount, from, to) => {
+            if (from === to) return amount;
+            if (from === 'USD' && to === 'JPY') return amount * 100;
+            if (from === 'JPY' && to === 'USD') return amount / 100;
+            throw new Error('unexpected currency conversion');
+          });
+        });
+
+        Object.entries({
+          'bids': (payload, values) => {
+            payload.bidsReceived = values
+              .map((val) => ({adUnitCode: 'au', cpm: val.amount, currency: val.cur}))
+              .concat([{adUnitCode: 'other', cpm: 10000, currency: 'EUR'}])
+          },
+          'no bids': (payload, values) => {
+            payload.bidderRequests = values
+              .map((val) => ({bids: [{adUnitCode: 'au', getFloor: () => ({floor: val.amount, currency: val.cur})}]}))
+              .concat([{bids: {adUnitCode: 'other', getFloor: () => ({floor: -10000, currency: 'EUR'})}}])
+          }
+        }).forEach(([tcase, setup]) => {
+          describe(`when auction has ${tcase}`, () => {
+            Object.entries({
+              'no currencies': {
+                values: [{amount: 1}, {amount: 100}, {amount: 10}, {amount: 100}],
+                'bids': {
+                  bidfloor: 100,
+                  bidfloorcur: undefined
+                },
+                'no bids': {
+                  bidfloor: 1,
+                  bidfloorcur: undefined,
+                }
+              },
+              'only zero values': {
+                values: [{amount: 0, cur: 'USD'}, {amount: 0, cur: 'JPY'}],
+                'bids': {
+                  bidfloor: undefined,
+                  bidfloorcur: undefined,
+                },
+                'no bids': {
+                  bidfloor: undefined,
+                  bidfloorcur: undefined,
+                }
+              },
+              'matching currencies': {
+                values: [{amount: 10, cur: 'JPY'}, {amount: 100, cur: 'JPY'}],
+                'bids': {
+                  bidfloor: 100,
+                  bidfloorcur: 'JPY',
+                },
+                'no bids': {
+                  bidfloor: 10,
+                  bidfloorcur: 'JPY',
+                }
+              },
+              'mixed currencies': {
+                values: [{amount: 10, cur: 'USD'}, {amount: 10, cur: 'JPY'}],
+                'bids': {
+                  bidfloor: 10,
+                  bidfloorcur: 'USD'
+                },
+                'no bids': {
+                  bidfloor: 10,
+                  bidfloorcur: 'JPY',
+                }
+              }
+            }).forEach(([t, testConfig]) => {
+              const values = testConfig.values;
+              const {bidfloor, bidfloorcur} = testConfig[tcase];
+
+              describe(`with ${t}`, () => {
+                let payload;
+                beforeEach(() => {
+                  payload = {auctionId: 'aid'};
+                  setup(payload, values);
+                });
+
+                it('should populate bidfloor/bidfloorcur', () => {
+                  events.emit(CONSTANTS.EVENTS.AUCTION_INIT, {auctionId: 'aid'});
+                  fledge.addComponentAuctionHook(nextFnSpy, 'aid', 'au', fledgeAuctionConfig);
+                  events.emit(CONSTANTS.EVENTS.AUCTION_END, payload);
+                  sinon.assert.calledWith(mockGptSlot.setConfig, sinon.match(arg => {
+                    return arg.componentAuction.some(au => au.auctionConfig.auctionSignals?.prebid?.bidfloor === bidfloor && au.auctionConfig.auctionSignals?.prebid?.bidfloorcur === bidfloorcur)
+                  }))
+                })
+              });
+            });
+          })
+        })
+      });
+    });
+  });
+
+  describe('fledgeEnabled', function () {
+    const navProps = Object.fromEntries(['runAdAuction', 'joinAdInterestGroup'].map(p => [p, navigator[p]]));
+
+    before(function () {
+      // navigator.runAdAuction & co may not exist, so we can't stub it normally with
+      // sinon.stub(navigator, 'runAdAuction') or something
+      Object.keys(navProps).forEach(p => {
+        navigator[p] = sinon.stub();
+      });
+      hook.ready();
+    });
+
+    after(function () {
+      Object.entries(navProps).forEach(([p, orig]) => navigator[p] = orig);
+    });
+
+    afterEach(function () {
+      config.resetConfig();
+    });
+
+    const adUnits = [{
+      'code': '/19968336/header-bid-tag1',
+      'mediaTypes': {
+        'banner': {
+          'sizes': [[728, 90]]
+        },
+      },
+      'bids': [
+        {
+          'bidder': 'appnexus',
+        },
+        {
+          'bidder': 'rubicon',
+        },
+      ]
+    }];
+
+    describe('with setBidderConfig()', () => {
+      it('should set fledgeEnabled correctly per bidder', function () {
+        config.setConfig({bidderSequence: 'fixed'});
+        config.setBidderConfig({
+          bidders: ['appnexus'],
+          config: {
+            fledgeEnabled: true,
+            defaultForSlots: 1,
+          }
+        });
+
+        const bidRequests = adapterManager.makeBidRequests(
+          adUnits,
+          Date.now(),
+          utils.getUniqueIdentifierStr(),
+          function callback() {
+          },
+          []
+        );
+
+        expect(bidRequests[0].bids[0].bidder).equals('appnexus');
+        expect(bidRequests[0].fledgeEnabled).to.be.true;
+        expect(bidRequests[0].defaultForSlots).to.equal(1);
+
+        expect(bidRequests[1].bids[0].bidder).equals('rubicon');
+        expect(bidRequests[1].fledgeEnabled).to.be.undefined;
+        expect(bidRequests[1].defaultForSlots).to.be.undefined;
+      });
+    });
+
+    describe('with setConfig()', () => {
+      it('should set fledgeEnabled correctly per bidder', function () {
+        config.setConfig({
+          bidderSequence: 'fixed',
+          fledgeForGpt: {
+            enabled: true,
+            bidders: ['appnexus'],
+            defaultForSlots: 1,
+          }
+        });
+
+        const bidRequests = adapterManager.makeBidRequests(
+          adUnits,
+          Date.now(),
+          utils.getUniqueIdentifierStr(),
+          function callback() {
+          },
+          []
+        );
+
+        expect(bidRequests[0].bids[0].bidder).equals('appnexus');
+        expect(bidRequests[0].fledgeEnabled).to.be.true;
+        expect(bidRequests[0].defaultForSlots).to.equal(1);
+
+        expect(bidRequests[1].bids[0].bidder).equals('rubicon');
+        expect(bidRequests[1].fledgeEnabled).to.be.undefined;
+        expect(bidRequests[1].defaultForSlots).to.be.undefined;
+      });
+
+      it('should set fledgeEnabled correctly for all bidders', function () {
+        config.setConfig({
+          bidderSequence: 'fixed',
+          fledgeForGpt: {
+            enabled: true,
+            defaultForSlots: 1,
+          }
+        });
+
+        const bidRequests = adapterManager.makeBidRequests(
+          adUnits,
+          Date.now(),
+          utils.getUniqueIdentifierStr(),
+          function callback() {
+          },
+          []
+        );
+
+        expect(bidRequests[0].bids[0].bidder).equals('appnexus');
+        expect(bidRequests[0].fledgeEnabled).to.be.true;
+        expect(bidRequests[0].defaultForSlots).to.equal(1);
+
+        expect(bidRequests[1].bids[0].bidder).equals('rubicon');
+        expect(bidRequests[0].fledgeEnabled).to.be.true;
+        expect(bidRequests[0].defaultForSlots).to.equal(1);
+      });
+    });
+  });
+
+  describe('ortb processors for fledge', () => {
+    describe('when defaultForSlots is set', () => {
+      it('imp.ext.ae should be set if fledge is enabled', () => {
+        const imp = {};
+        setImpExtAe(imp, {}, {bidderRequest: {fledgeEnabled: true, defaultForSlots: 1}});
+        expect(imp.ext.ae).to.equal(1);
+      });
+      it('imp.ext.ae should be left intact if set on adunit and fledge is enabled', () => {
+        const imp = {ext: {ae: 2}};
+        setImpExtAe(imp, {}, {bidderRequest: {fledgeEnabled: true, defaultForSlots: 1}});
+        expect(imp.ext.ae).to.equal(2);
+      });
+    });
+    describe('when defaultForSlots is not defined', () => {
+      it('imp.ext.ae should be removed if fledge is not enabled', () => {
+        const imp = {ext: {ae: 1}};
+        setImpExtAe(imp, {}, {bidderRequest: {}});
+        expect(imp.ext.ae).to.not.exist;
+      });
+      it('imp.ext.ae should be left intact if fledge is enabled', () => {
+        const imp = {ext: {ae: 2}};
+        setImpExtAe(imp, {}, {bidderRequest: {fledgeEnabled: true}});
+        expect(imp.ext.ae).to.equal(2);
+      });
+    });
+    describe('parseExtPrebidFledge', () => {
+      function packageConfigs(configs) {
+        return {
+          ext: {
+            prebid: {
+              fledge: {
+                auctionconfigs: configs
+              }
+            }
+          }
+        };
+      }
+
+      function generateImpCtx(fledgeFlags) {
+        return Object.fromEntries(Object.entries(fledgeFlags).map(([impid, fledgeEnabled]) => [impid, {imp: {ext: {ae: fledgeEnabled}}}]));
+      }
+
+      function generateCfg(impid, ...ids) {
+        return ids.map((id) => ({impid, config: {id}}));
+      }
+
+      function extractResult(ctx) {
+        return Object.fromEntries(
+          Object.entries(ctx)
+            .map(([impid, ctx]) => [impid, ctx.fledgeConfigs?.map(cfg => cfg.config.id)])
+            .filter(([_, val]) => val != null)
+        );
+      }
+
+      it('should collect fledge configs by imp', () => {
+        const ctx = {
+          impContext: generateImpCtx({e1: 1, e2: 1, d1: 0})
+        };
+        const resp = packageConfigs(
+          generateCfg('e1', 1, 2, 3)
+            .concat(generateCfg('e2', 4)
+              .concat(generateCfg('d1', 5, 6)))
+        );
+        parseExtPrebidFledge({}, resp, ctx);
+        expect(extractResult(ctx.impContext)).to.eql({
+          e1: [1, 2, 3],
+          e2: [4],
+        });
+      });
+      it('should not choke if fledge config references unknown imp', () => {
+        const ctx = {impContext: generateImpCtx({i: 1})};
+        const resp = packageConfigs(generateCfg('unknown', 1));
+        parseExtPrebidFledge({}, resp, ctx);
+        expect(extractResult(ctx.impContext)).to.eql({});
+      });
+    });
+    describe('setResponseFledgeConfigs', () => {
+      it('should set fledgeAuctionConfigs paired with their corresponding bid id', () => {
+        const ctx = {
+          impContext: {
+            1: {
+              bidRequest: {bidId: 'bid1'},
+              fledgeConfigs: [{config: {id: 1}}, {config: {id: 2}}]
+            },
+            2: {
+              bidRequest: {bidId: 'bid2'},
+              fledgeConfigs: [{config: {id: 3}}]
+            },
+            3: {
+              bidRequest: {bidId: 'bid3'}
+            }
+          }
+        };
+        const resp = {};
+        setResponseFledgeConfigs(resp, {}, ctx);
+        expect(resp.fledgeAuctionConfigs).to.eql([
+          {bidId: 'bid1', config: {id: 1}},
+          {bidId: 'bid1', config: {id: 2}},
+          {bidId: 'bid2', config: {id: 3}},
+        ]);
+      });
+      it('should not set fledgeAuctionConfigs if none exist', () => {
+        const resp = {};
+        setResponseFledgeConfigs(resp, {}, {
+          impContext: {
+            1: {
+              fledgeConfigs: []
+            },
+            2: {}
+          }
+        });
+        expect(resp).to.eql({});
+      });
+    });
+  });
+});
diff --git a/test/spec/modules/fledge_spec.js b/test/spec/modules/fledge_spec.js
deleted file mode 100644
index 7a670fa2381..00000000000
--- a/test/spec/modules/fledge_spec.js
+++ /dev/null
@@ -1,282 +0,0 @@
-import {
-  expect
-} from 'chai';
-import * as fledge from 'modules/fledgeForGpt.js';
-import {config} from '../../../src/config.js';
-import adapterManager from '../../../src/adapterManager.js';
-import * as utils from '../../../src/utils.js';
-import {hook} from '../../../src/hook.js';
-import 'modules/appnexusBidAdapter.js';
-import 'modules/rubiconBidAdapter.js';
-import {parseExtPrebidFledge, setImpExtAe, setResponseFledgeConfigs} from 'modules/fledgeForGpt.js';
-
-const CODE = 'sampleBidder';
-const AD_UNIT_CODE = 'mock/placement';
-
-describe('fledgeForGpt module', function() {
-  let nextFnSpy;
-  before(() => {
-    fledge.init({enabled: true})
-  });
-
-  const bidRequest = {
-    adUnitCode: AD_UNIT_CODE,
-    bids: [{
-      bidId: '1',
-      bidder: CODE,
-      auctionId: 'first-bid-id',
-      adUnitCode: AD_UNIT_CODE,
-      transactionId: 'au',
-    }]
-  };
-  const fledgeAuctionConfig = {
-    bidId: '1',
-  }
-
-  describe('addComponentAuctionHook', function() {
-    beforeEach(function() {
-      nextFnSpy = sinon.spy();
-    });
-
-    it('should call next() when a proper adUnitCode and fledgeAuctionConfig are provided', function() {
-      fledge.addComponentAuctionHook(nextFnSpy, bidRequest.adUnitCode, fledgeAuctionConfig);
-      expect(nextFnSpy.called).to.be.true;
-    });
-  });
-});
-
-describe('fledgeEnabled', function () {
-  const navProps = Object.fromEntries(['runAdAuction', 'joinAdInterestGroup'].map(p => [p, navigator[p]]))
-
-  before(function () {
-    // navigator.runAdAuction & co may not exist, so we can't stub it normally with
-    // sinon.stub(navigator, 'runAdAuction') or something
-    Object.keys(navProps).forEach(p => { navigator[p] = sinon.stub() });
-    hook.ready();
-  });
-
-  after(function() {
-    Object.entries(navProps).forEach(([p, orig]) => navigator[p] = orig);
-  })
-
-  afterEach(function () {
-    config.resetConfig();
-  });
-
-  const adUnits = [{
-    'code': '/19968336/header-bid-tag1',
-    'mediaTypes': {
-      'banner': {
-        'sizes': [[728, 90]]
-      },
-    },
-    'bids': [
-      {
-        'bidder': 'appnexus',
-      },
-      {
-        'bidder': 'rubicon',
-      },
-    ]
-  }];
-
-  describe('with setBidderConfig()', () => {
-    it('should set fledgeEnabled correctly per bidder', function () {
-      config.setConfig({bidderSequence: 'fixed'})
-      config.setBidderConfig({
-        bidders: ['appnexus'],
-        config: {
-          fledgeEnabled: true,
-          defaultForSlots: 1,
-        }
-      });
-
-      const bidRequests = adapterManager.makeBidRequests(
-        adUnits,
-        Date.now(),
-        utils.getUniqueIdentifierStr(),
-        function callback() {},
-        []
-      );
-
-      expect(bidRequests[0].bids[0].bidder).equals('appnexus');
-      expect(bidRequests[0].fledgeEnabled).to.be.true;
-      expect(bidRequests[0].defaultForSlots).to.equal(1);
-
-      expect(bidRequests[1].bids[0].bidder).equals('rubicon');
-      expect(bidRequests[1].fledgeEnabled).to.be.undefined;
-      expect(bidRequests[1].defaultForSlots).to.be.undefined;
-    });
-  });
-
-  describe('with setConfig()', () => {
-    it('should set fledgeEnabled correctly per bidder', function () {
-      config.setConfig({
-        bidderSequence: 'fixed',
-        fledgeForGpt: {
-          enabled: true,
-          bidders: ['appnexus'],
-          defaultForSlots: 1,
-        }
-      });
-
-      const bidRequests = adapterManager.makeBidRequests(
-        adUnits,
-        Date.now(),
-        utils.getUniqueIdentifierStr(),
-        function callback() {},
-        []
-      );
-
-      expect(bidRequests[0].bids[0].bidder).equals('appnexus');
-      expect(bidRequests[0].fledgeEnabled).to.be.true;
-      expect(bidRequests[0].defaultForSlots).to.equal(1);
-
-      expect(bidRequests[1].bids[0].bidder).equals('rubicon');
-      expect(bidRequests[1].fledgeEnabled).to.be.undefined;
-      expect(bidRequests[1].defaultForSlots).to.be.undefined;
-    });
-
-    it('should set fledgeEnabled correctly for all bidders', function () {
-      config.setConfig({
-        bidderSequence: 'fixed',
-        fledgeForGpt: {
-          enabled: true,
-          defaultForSlots: 1,
-        }
-      });
-
-      const bidRequests = adapterManager.makeBidRequests(
-        adUnits,
-        Date.now(),
-        utils.getUniqueIdentifierStr(),
-        function callback() {},
-        []
-      );
-
-      expect(bidRequests[0].bids[0].bidder).equals('appnexus');
-      expect(bidRequests[0].fledgeEnabled).to.be.true;
-      expect(bidRequests[0].defaultForSlots).to.equal(1);
-
-      expect(bidRequests[1].bids[0].bidder).equals('rubicon');
-      expect(bidRequests[0].fledgeEnabled).to.be.true;
-      expect(bidRequests[0].defaultForSlots).to.equal(1);
-    });
-  });
-});
-
-describe('ortb processors for fledge', () => {
-  describe('when defaultForSlots is set', () => {
-    it('imp.ext.ae should be set if fledge is enabled', () => {
-      const imp = {};
-      setImpExtAe(imp, {}, {bidderRequest: {fledgeEnabled: true, defaultForSlots: 1}});
-      expect(imp.ext.ae).to.equal(1);
-    });
-    it('imp.ext.ae should be left intact if set on adunit and fledge is enabled', () => {
-      const imp = {ext: {ae: 2}};
-      setImpExtAe(imp, {}, {bidderRequest: {fledgeEnabled: true, defaultForSlots: 1}});
-      expect(imp.ext.ae).to.equal(2);
-    });
-  });
-  describe('when defaultForSlots is not defined', () => {
-    it('imp.ext.ae should be removed if fledge is not enabled', () => {
-      const imp = {ext: {ae: 1}};
-      setImpExtAe(imp, {}, {bidderRequest: {}});
-      expect(imp.ext.ae).to.not.exist;
-    })
-    it('imp.ext.ae should be left intact if fledge is enabled', () => {
-      const imp = {ext: {ae: 2}};
-      setImpExtAe(imp, {}, {bidderRequest: {fledgeEnabled: true}});
-      expect(imp.ext.ae).to.equal(2);
-    });
-  });
-  describe('parseExtPrebidFledge', () => {
-    function packageConfigs(configs) {
-      return {
-        ext: {
-          prebid: {
-            fledge: {
-              auctionconfigs: configs
-            }
-          }
-        }
-      }
-    }
-
-    function generateImpCtx(fledgeFlags) {
-      return Object.fromEntries(Object.entries(fledgeFlags).map(([impid, fledgeEnabled]) => [impid, {imp: {ext: {ae: fledgeEnabled}}}]));
-    }
-
-    function generateCfg(impid, ...ids) {
-      return ids.map((id) => ({impid, config: {id}}));
-    }
-
-    function extractResult(ctx) {
-      return Object.fromEntries(
-        Object.entries(ctx)
-          .map(([impid, ctx]) => [impid, ctx.fledgeConfigs?.map(cfg => cfg.config.id)])
-          .filter(([_, val]) => val != null)
-      );
-    }
-
-    it('should collect fledge configs by imp', () => {
-      const ctx = {
-        impContext: generateImpCtx({e1: 1, e2: 1, d1: 0})
-      };
-      const resp = packageConfigs(
-        generateCfg('e1', 1, 2, 3)
-          .concat(generateCfg('e2', 4)
-            .concat(generateCfg('d1', 5, 6)))
-      );
-      parseExtPrebidFledge({}, resp, ctx);
-      expect(extractResult(ctx.impContext)).to.eql({
-        e1: [1, 2, 3],
-        e2: [4],
-      });
-    });
-    it('should not choke if fledge config references unknown imp', () => {
-      const ctx = {impContext: generateImpCtx({i: 1})};
-      const resp = packageConfigs(generateCfg('unknown', 1));
-      parseExtPrebidFledge({}, resp, ctx);
-      expect(extractResult(ctx.impContext)).to.eql({});
-    });
-  });
-  describe('setResponseFledgeConfigs', () => {
-    it('should set fledgeAuctionConfigs paired with their corresponding bid id', () => {
-      const ctx = {
-        impContext: {
-          1: {
-            bidRequest: {bidId: 'bid1'},
-            fledgeConfigs: [{config: {id: 1}}, {config: {id: 2}}]
-          },
-          2: {
-            bidRequest: {bidId: 'bid2'},
-            fledgeConfigs: [{config: {id: 3}}]
-          },
-          3: {
-            bidRequest: {bidId: 'bid3'}
-          }
-        }
-      };
-      const resp = {};
-      setResponseFledgeConfigs(resp, {}, ctx);
-      expect(resp.fledgeAuctionConfigs).to.eql([
-        {bidId: 'bid1', config: {id: 1}},
-        {bidId: 'bid1', config: {id: 2}},
-        {bidId: 'bid2', config: {id: 3}},
-      ]);
-    });
-    it('should not set fledgeAuctionConfigs if none exist', () => {
-      const resp = {};
-      setResponseFledgeConfigs(resp, {}, {
-        impContext: {
-          1: {
-            fledgeConfigs: []
-          },
-          2: {}
-        }
-      });
-      expect(resp).to.eql({});
-    });
-  });
-});
diff --git a/test/spec/modules/multibid_spec.js b/test/spec/modules/multibid_spec.js
index eaf8fa33a66..c11113473ce 100644
--- a/test/spec/modules/multibid_spec.js
+++ b/test/spec/modules/multibid_spec.js
@@ -1,16 +1,15 @@
 import {expect} from 'chai';
 import {
-  validateMultibid,
-  adjustBidderRequestsHook,
   addBidResponseHook,
+  adjustBidderRequestsHook,
   resetMultibidUnits,
+  resetMultiConfig,
   sortByMultibid,
   targetBidPoolHook,
-  resetMultiConfig
+  validateMultibid
 } from 'modules/multibid/index.js';
-import {parse as parseQuery} from 'querystring';
 import {config} from 'src/config.js';
-import * as utils from 'src/utils.js';
+import {getHighestCpm} from '../../../src/utils/reducers.js';
 
 describe('multibid adapter', function () {
   let bidArray = [{
@@ -545,7 +544,7 @@ describe('multibid adapter', function () {
 
     it('it does not run filter on bidsReceived if no multibid configuration found', function () {
       let bids = [{...bidArray[0]}, {...bidArray[1]}];
-      targetBidPoolHook(callbackFn, bids, utils.getHighestCpm);
+      targetBidPoolHook(callbackFn, bids, getHighestCpm);
 
       expect(result).to.not.equal(null);
       expect(result.bidsReceived).to.not.equal(null);
@@ -562,7 +561,7 @@ describe('multibid adapter', function () {
 
       config.setConfig({multibid: [{bidder: 'bidderA', maxBids: 2}]});
 
-      targetBidPoolHook(callbackFn, bids, utils.getHighestCpm);
+      targetBidPoolHook(callbackFn, bids, getHighestCpm);
       bids.pop();
 
       expect(result).to.not.equal(null);
@@ -584,7 +583,7 @@ describe('multibid adapter', function () {
 
       config.setConfig({multibid: [{bidder: 'bidderA', maxBids: 2, targetBiddercodePrefix: 'bidA'}]});
 
-      targetBidPoolHook(callbackFn, modifiedBids, utils.getHighestCpm);
+      targetBidPoolHook(callbackFn, modifiedBids, getHighestCpm);
 
       expect(result).to.not.equal(null);
       expect(result.bidsReceived).to.not.equal(null);
@@ -609,7 +608,7 @@ describe('multibid adapter', function () {
 
       config.setConfig({multibid: [{bidder: 'bidderA', maxBids: 2, targetBiddercodePrefix: 'bidA'}]});
 
-      targetBidPoolHook(callbackFn, modifiedBids, utils.getHighestCpm);
+      targetBidPoolHook(callbackFn, modifiedBids, getHighestCpm);
 
       expect(result).to.not.equal(null);
       expect(result.bidsReceived).to.not.equal(null);
@@ -642,7 +641,7 @@ describe('multibid adapter', function () {
 
       config.setConfig({ multibid: [{bidder: 'bidderA', maxBids: 2, targetBiddercodePrefix: 'bidA'}] });
 
-      targetBidPoolHook(callbackFn, modifiedBids, utils.getHighestCpm, 3);
+      targetBidPoolHook(callbackFn, modifiedBids, getHighestCpm, 3);
 
       expect(result).to.not.equal(null);
       expect(result.bidsReceived).to.not.equal(null);
@@ -670,7 +669,7 @@ describe('multibid adapter', function () {
 
       expect(bidPool.length).to.equal(6);
 
-      targetBidPoolHook(callbackFn, bidPool, utils.getHighestCpm);
+      targetBidPoolHook(callbackFn, bidPool, getHighestCpm);
 
       expect(result).to.not.equal(null);
       expect(result.bidsReceived).to.not.equal(null);
diff --git a/test/spec/modules/prebidServerBidAdapter_spec.js b/test/spec/modules/prebidServerBidAdapter_spec.js
index 4b783803507..717a5cd6c6d 100644
--- a/test/spec/modules/prebidServerBidAdapter_spec.js
+++ b/test/spec/modules/prebidServerBidAdapter_spec.js
@@ -3476,16 +3476,16 @@ describe('S2S Adapter', function () {
         adapter.callBids(request, bidderRequests, addBidResponse, done, ajax);
         server.requests[0].respond(200, {}, JSON.stringify(mergeDeep({}, RESPONSE_OPENRTB, FLEDGE_RESP)));
         expect(addBidResponse.called).to.be.true;
-        sinon.assert.calledWith(fledgeStub, AU, {id: 1});
-        sinon.assert.calledWith(fledgeStub, AU, {id: 2});
+        sinon.assert.calledWith(fledgeStub, bidderRequests[0].auctionId, AU, {id: 1});
+        sinon.assert.calledWith(fledgeStub, bidderRequests[0].auctionId, AU, {id: 2});
       });
 
       it('calls addComponentAuction when there is no bid in the response', () => {
         adapter.callBids(request, bidderRequests, addBidResponse, done, ajax);
         server.requests[0].respond(200, {}, JSON.stringify(FLEDGE_RESP));
         expect(addBidResponse.called).to.be.false;
-        sinon.assert.calledWith(fledgeStub, AU, {id: 1});
-        sinon.assert.calledWith(fledgeStub, AU, {id: 2});
+        sinon.assert.calledWith(fledgeStub, bidderRequests[0].auctionId, AU, {id: 1});
+        sinon.assert.calledWith(fledgeStub, bidderRequests[0].auctionId, AU, {id: 2});
       })
     });
   });
diff --git a/test/spec/unit/core/bidderFactory_spec.js b/test/spec/unit/core/bidderFactory_spec.js
index 0360679ca52..4c13d830206 100644
--- a/test/spec/unit/core/bidderFactory_spec.js
+++ b/test/spec/unit/core/bidderFactory_spec.js
@@ -48,1040 +48,1121 @@ before(() => {
 
 let wrappedCallback = config.callbackWithBidder(CODE);
 
-describe('bidders created by newBidder', function () {
-  let spec;
-  let bidder;
-  let addBidResponseStub;
-  let doneStub;
-
-  beforeEach(function () {
-    spec = {
-      code: CODE,
-      isBidRequestValid: sinon.stub(),
-      buildRequests: sinon.stub(),
-      interpretResponse: sinon.stub(),
-      getUserSyncs: sinon.stub()
-    };
-
-    addBidResponseStub = sinon.stub();
-    addBidResponseStub.reject = sinon.stub();
-    doneStub = sinon.stub();
-  });
-
-  describe('when the ajax response is irrelevant', function () {
-    let sandbox;
-    let ajaxStub;
-    let getConfigSpy;
-    let aliasRegistryStub, aliasRegistry;
+describe('bidderFactory', () => {
+  describe('bidders created by newBidder', function () {
+    let spec;
+    let bidder;
+    let addBidResponseStub;
+    let doneStub;
 
     beforeEach(function () {
-      sandbox = sinon.sandbox.create();
-      sandbox.stub(activityRules, 'isActivityAllowed').callsFake(() => true);
-      ajaxStub = sandbox.stub(ajax, 'ajax');
-      addBidResponseStub.reset();
-      getConfigSpy = sandbox.spy(config, 'getConfig');
-      doneStub.reset();
-      aliasRegistry = {};
-      aliasRegistryStub = sandbox.stub(adapterManager, 'aliasRegistry');
-      aliasRegistryStub.get(() => aliasRegistry);
-    });
+      spec = {
+        code: CODE,
+        isBidRequestValid: sinon.stub(),
+        buildRequests: sinon.stub(),
+        interpretResponse: sinon.stub(),
+        getUserSyncs: sinon.stub()
+      };
 
-    afterEach(function () {
-      sandbox.restore();
+      addBidResponseStub = sinon.stub();
+      addBidResponseStub.reject = sinon.stub();
+      doneStub = sinon.stub();
     });
 
-    it('should let registerSyncs run with invalid alias and aliasSync enabled', function () {
-      config.setConfig({
-        userSync: {
-          aliasSyncEnabled: true
-        }
+    describe('when the ajax response is irrelevant', function () {
+      let sandbox;
+      let ajaxStub;
+      let getConfigSpy;
+      let aliasRegistryStub, aliasRegistry;
+
+      beforeEach(function () {
+        sandbox = sinon.sandbox.create();
+        sandbox.stub(activityRules, 'isActivityAllowed').callsFake(() => true);
+        ajaxStub = sandbox.stub(ajax, 'ajax');
+        addBidResponseStub.reset();
+        getConfigSpy = sandbox.spy(config, 'getConfig');
+        doneStub.reset();
+        aliasRegistry = {};
+        aliasRegistryStub = sandbox.stub(adapterManager, 'aliasRegistry');
+        aliasRegistryStub.get(() => aliasRegistry);
       });
-      spec.code = 'fakeBidder';
-      const bidder = newBidder(spec);
-      bidder.callBids({ bids: [] }, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-      expect(getConfigSpy.withArgs('userSync.filterSettings').calledOnce).to.equal(true);
-    });
 
-    it('should let registerSyncs run with valid alias and aliasSync enabled', function () {
-      config.setConfig({
-        userSync: {
-          aliasSyncEnabled: true
-        }
+      afterEach(function () {
+        sandbox.restore();
       });
-      spec.code = 'aliasBidder';
-      const bidder = newBidder(spec);
-      bidder.callBids({ bids: [] }, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-      expect(getConfigSpy.withArgs('userSync.filterSettings').calledOnce).to.equal(true);
-    });
 
-    it('should let registerSyncs run with invalid alias and aliasSync disabled', function () {
-      config.setConfig({
-        userSync: {
-          aliasSyncEnabled: false
-        }
+      it('should let registerSyncs run with invalid alias and aliasSync enabled', function () {
+        config.setConfig({
+          userSync: {
+            aliasSyncEnabled: true
+          }
+        });
+        spec.code = 'fakeBidder';
+        const bidder = newBidder(spec);
+        bidder.callBids({ bids: [] }, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        expect(getConfigSpy.withArgs('userSync.filterSettings').calledOnce).to.equal(true);
       });
-      spec.code = 'fakeBidder';
-      const bidder = newBidder(spec);
-      bidder.callBids({ bids: [] }, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-      expect(getConfigSpy.withArgs('userSync.filterSettings').calledOnce).to.equal(true);
-    });
 
-    it('should not let registerSyncs run with valid alias and aliasSync disabled', function () {
-      config.setConfig({
-        userSync: {
-          aliasSyncEnabled: false
-        }
+      it('should let registerSyncs run with valid alias and aliasSync enabled', function () {
+        config.setConfig({
+          userSync: {
+            aliasSyncEnabled: true
+          }
+        });
+        spec.code = 'aliasBidder';
+        const bidder = newBidder(spec);
+        bidder.callBids({ bids: [] }, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        expect(getConfigSpy.withArgs('userSync.filterSettings').calledOnce).to.equal(true);
       });
-      spec.code = 'aliasBidder';
-      const bidder = newBidder(spec);
-      aliasRegistry = {[spec.code]: CODE};
-      bidder.callBids({ bids: [] }, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-      expect(getConfigSpy.withArgs('userSync.filterSettings').calledOnce).to.equal(false);
-    });
 
-    describe('transaction IDs', () => {
-      beforeEach(() => {
-        activityRules.isActivityAllowed.reset();
-        ajaxStub.callsFake((_, callback) => callback.success(null, {getResponseHeader: sinon.stub()}));
-        spec.interpretResponse.callsFake(() => [
-          {
-            requestId: 'bid',
-            cpm: 123,
-            ttl: 300,
-            creativeId: 'crid',
-            netRevenue: true,
-            currency: 'USD'
+      it('should let registerSyncs run with invalid alias and aliasSync disabled', function () {
+        config.setConfig({
+          userSync: {
+            aliasSyncEnabled: false
+          }
+        });
+        spec.code = 'fakeBidder';
+        const bidder = newBidder(spec);
+        bidder.callBids({ bids: [] }, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        expect(getConfigSpy.withArgs('userSync.filterSettings').calledOnce).to.equal(true);
+      });
+
+      it('should not let registerSyncs run with valid alias and aliasSync disabled', function () {
+        config.setConfig({
+          userSync: {
+            aliasSyncEnabled: false
           }
-        ])
+        });
+        spec.code = 'aliasBidder';
+        const bidder = newBidder(spec);
+        aliasRegistry = {[spec.code]: CODE};
+        bidder.callBids({ bids: [] }, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        expect(getConfigSpy.withArgs('userSync.filterSettings').calledOnce).to.equal(false);
       });
 
-      Object.entries({
-        'be hidden': false,
-        'not be hidden': true,
-      }).forEach(([t, allowed]) => {
-        const expectation = allowed ? (val) => expect(val).to.exist : (val) => expect(val).to.not.exist;
+      describe('transaction IDs', () => {
+        beforeEach(() => {
+          activityRules.isActivityAllowed.reset();
+          ajaxStub.callsFake((_, callback) => callback.success(null, {getResponseHeader: sinon.stub()}));
+          spec.interpretResponse.callsFake(() => [
+            {
+              requestId: 'bid',
+              cpm: 123,
+              ttl: 300,
+              creativeId: 'crid',
+              netRevenue: true,
+              currency: 'USD'
+            }
+          ])
+        });
 
-        function checkBidRequest(br) {
-          ['auctionId', 'transactionId'].forEach((prop) => expectation(br[prop]));
-        }
+        Object.entries({
+          'be hidden': false,
+          'not be hidden': true,
+        }).forEach(([t, allowed]) => {
+          const expectation = allowed ? (val) => expect(val).to.exist : (val) => expect(val).to.not.exist;
 
-        function checkBidderRequest(br) {
-          expectation(br.auctionId);
-          br.bids.forEach(checkBidRequest);
-        }
+          function checkBidRequest(br) {
+            ['auctionId', 'transactionId'].forEach((prop) => expectation(br[prop]));
+          }
 
-        it(`should ${t} from the spec logic when the transmitTid activity is${allowed ? '' : ' not'} allowed`, () => {
-          spec.isBidRequestValid.callsFake(br => {
-            checkBidRequest(br);
-            return true;
-          });
-          spec.buildRequests.callsFake((bidReqs, bidderReq) => {
-            checkBidderRequest(bidderReq);
-            bidReqs.forEach(checkBidRequest);
-            return {method: 'POST'};
-          });
-          activityRules.isActivityAllowed.callsFake(() => allowed);
+          function checkBidderRequest(br) {
+            expectation(br.auctionId);
+            br.bids.forEach(checkBidRequest);
+          }
 
-          const bidder = newBidder(spec);
+          it(`should ${t} from the spec logic when the transmitTid activity is${allowed ? '' : ' not'} allowed`, () => {
+            spec.isBidRequestValid.callsFake(br => {
+              checkBidRequest(br);
+              return true;
+            });
+            spec.buildRequests.callsFake((bidReqs, bidderReq) => {
+              checkBidderRequest(bidderReq);
+              bidReqs.forEach(checkBidRequest);
+              return {method: 'POST'};
+            });
+            activityRules.isActivityAllowed.callsFake(() => allowed);
+
+            const bidder = newBidder(spec);
+
+            bidder.callBids({
+              bidderCode: 'mockBidder',
+              auctionId: 'aid',
+              bids: [
+                {
+                  adUnitCode: 'mockAU',
+                  bidId: 'bid',
+                  transactionId: 'tid',
+                  auctionId: 'aid'
+                }
+              ]
+            }, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+            sinon.assert.calledWithMatch(activityRules.isActivityAllowed, ACTIVITY_TRANSMIT_TID, {
+              componentType: MODULE_TYPE_BIDDER,
+              componentName: 'mockBidder'
+            });
+            sinon.assert.calledWithMatch(addBidResponseStub, sinon.match.any, {
+              transactionId: 'tid',
+              auctionId: 'aid'
+            })
+          });
+        });
 
-          bidder.callBids({
+        it('should not be hidden from request methods', (done) => {
+          const bidderRequest = {
             bidderCode: 'mockBidder',
             auctionId: 'aid',
+            getAID() { return this.auctionId },
             bids: [
               {
                 adUnitCode: 'mockAU',
                 bidId: 'bid',
                 transactionId: 'tid',
-                auctionId: 'aid'
+                auctionId: 'aid',
+                getTIDs() {
+                  return [this.auctionId, this.transactionId]
+                }
               }
             ]
-          }, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-
-          sinon.assert.calledWithMatch(activityRules.isActivityAllowed, ACTIVITY_TRANSMIT_TID, {
-            componentType: MODULE_TYPE_BIDDER,
-            componentName: 'mockBidder'
+          };
+          activityRules.isActivityAllowed.callsFake(() => false);
+          spec.isBidRequestValid.returns(true);
+          spec.buildRequests.callsFake((reqs, bidderReq) => {
+            expect(bidderReq.getAID()).to.eql('aid');
+            expect(reqs[0].getTIDs()).to.eql(['aid', 'tid']);
+            done();
           });
-          sinon.assert.calledWithMatch(addBidResponseStub, sinon.match.any, {
-            transactionId: 'tid',
-            auctionId: 'aid'
-          })
-        });
+          newBidder(spec).callBids(bidderRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        })
       });
 
-      it('should not be hidden from request methods', (done) => {
-        const bidderRequest = {
-          bidderCode: 'mockBidder',
-          auctionId: 'aid',
-          getAID() { return this.auctionId },
-          bids: [
-            {
-              adUnitCode: 'mockAU',
-              bidId: 'bid',
-              transactionId: 'tid',
-              auctionId: 'aid',
-              getTIDs() {
-                return [this.auctionId, this.transactionId]
-              }
-            }
-          ]
-        };
-        activityRules.isActivityAllowed.callsFake(() => false);
-        spec.isBidRequestValid.returns(true);
-        spec.buildRequests.callsFake((reqs, bidderReq) => {
-          expect(bidderReq.getAID()).to.eql('aid');
-          expect(reqs[0].getTIDs()).to.eql(['aid', 'tid']);
-          done();
-        });
-        newBidder(spec).callBids(bidderRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-      })
-    });
-
-    it('should handle bad bid requests gracefully', function () {
-      const bidder = newBidder(spec);
-
-      spec.getUserSyncs.returns([]);
+      it('should handle bad bid requests gracefully', function () {
+        const bidder = newBidder(spec);
 
-      bidder.callBids({});
-      bidder.callBids({ bids: 'nothing useful' }, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        spec.getUserSyncs.returns([]);
 
-      expect(ajaxStub.called).to.equal(false);
-      expect(spec.isBidRequestValid.called).to.equal(false);
-      expect(spec.buildRequests.called).to.equal(false);
-      expect(spec.interpretResponse.called).to.equal(false);
-    });
+        bidder.callBids({});
+        bidder.callBids({ bids: 'nothing useful' }, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-    it('should call buildRequests(bidRequest) the params are valid', function () {
-      const bidder = newBidder(spec);
+        expect(ajaxStub.called).to.equal(false);
+        expect(spec.isBidRequestValid.called).to.equal(false);
+        expect(spec.buildRequests.called).to.equal(false);
+        expect(spec.interpretResponse.called).to.equal(false);
+      });
 
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns([]);
+      it('should call buildRequests(bidRequest) the params are valid', function () {
+        const bidder = newBidder(spec);
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns([]);
 
-      expect(ajaxStub.called).to.equal(false);
-      expect(spec.isBidRequestValid.calledTwice).to.equal(true);
-      expect(spec.buildRequests.calledOnce).to.equal(true);
-      expect(spec.buildRequests.firstCall.args[0]).to.deep.equal(MOCK_BIDS_REQUEST.bids);
-    });
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-    it('should not call buildRequests the params are invalid', function () {
-      const bidder = newBidder(spec);
+        expect(ajaxStub.called).to.equal(false);
+        expect(spec.isBidRequestValid.calledTwice).to.equal(true);
+        expect(spec.buildRequests.calledOnce).to.equal(true);
+        expect(spec.buildRequests.firstCall.args[0]).to.deep.equal(MOCK_BIDS_REQUEST.bids);
+      });
 
-      spec.isBidRequestValid.returns(false);
-      spec.buildRequests.returns([]);
+      it('should not call buildRequests the params are invalid', function () {
+        const bidder = newBidder(spec);
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        spec.isBidRequestValid.returns(false);
+        spec.buildRequests.returns([]);
 
-      expect(ajaxStub.called).to.equal(false);
-      expect(spec.isBidRequestValid.calledTwice).to.equal(true);
-      expect(spec.buildRequests.called).to.equal(false);
-    });
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-    it('should filter out invalid bids before calling buildRequests', function () {
-      const bidder = newBidder(spec);
+        expect(ajaxStub.called).to.equal(false);
+        expect(spec.isBidRequestValid.calledTwice).to.equal(true);
+        expect(spec.buildRequests.called).to.equal(false);
+      });
 
-      spec.isBidRequestValid.onFirstCall().returns(true);
-      spec.isBidRequestValid.onSecondCall().returns(false);
-      spec.buildRequests.returns([]);
+      it('should filter out invalid bids before calling buildRequests', function () {
+        const bidder = newBidder(spec);
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        spec.isBidRequestValid.onFirstCall().returns(true);
+        spec.isBidRequestValid.onSecondCall().returns(false);
+        spec.buildRequests.returns([]);
 
-      expect(ajaxStub.called).to.equal(false);
-      expect(spec.isBidRequestValid.calledTwice).to.equal(true);
-      expect(spec.buildRequests.calledOnce).to.equal(true);
-      expect(spec.buildRequests.firstCall.args[0]).to.deep.equal([MOCK_BIDS_REQUEST.bids[0]]);
-    });
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-    it('should make no server requests if the spec doesn\'t return any', function () {
-      const bidder = newBidder(spec);
+        expect(ajaxStub.called).to.equal(false);
+        expect(spec.isBidRequestValid.calledTwice).to.equal(true);
+        expect(spec.buildRequests.calledOnce).to.equal(true);
+        expect(spec.buildRequests.firstCall.args[0]).to.deep.equal([MOCK_BIDS_REQUEST.bids[0]]);
+      });
 
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns([]);
+      it('should make no server requests if the spec doesn\'t return any', function () {
+        const bidder = newBidder(spec);
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns([]);
 
-      expect(ajaxStub.called).to.equal(false);
-    });
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-    it('should make the appropriate POST request', function () {
-      const bidder = newBidder(spec);
-      const url = 'test.url.com';
-      const data = { arg: 2 };
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns({
-        method: 'POST',
-        url: url,
-        data: data
+        expect(ajaxStub.called).to.equal(false);
       });
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+      it('should make the appropriate POST request', function () {
+        const bidder = newBidder(spec);
+        const url = 'test.url.com';
+        const data = { arg: 2 };
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns({
+          method: 'POST',
+          url: url,
+          data: data
+        });
 
-      expect(ajaxStub.calledOnce).to.equal(true);
-      expect(ajaxStub.firstCall.args[0]).to.equal(url);
-      expect(ajaxStub.firstCall.args[2]).to.equal(JSON.stringify(data));
-      sinon.assert.match(ajaxStub.firstCall.args[3], {
-        method: 'POST',
-        contentType: 'text/plain',
-        withCredentials: true
-      });
-    });
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-    it('should make the appropriate POST request when options are passed', function () {
-      const bidder = newBidder(spec);
-      const url = 'test.url.com';
-      const data = { arg: 2 };
-      const options = { contentType: 'application/json' };
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns({
-        method: 'POST',
-        url: url,
-        data: data,
-        options: options
+        expect(ajaxStub.calledOnce).to.equal(true);
+        expect(ajaxStub.firstCall.args[0]).to.equal(url);
+        expect(ajaxStub.firstCall.args[2]).to.equal(JSON.stringify(data));
+        sinon.assert.match(ajaxStub.firstCall.args[3], {
+          method: 'POST',
+          contentType: 'text/plain',
+          withCredentials: true
+        });
       });
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+      it('should make the appropriate POST request when options are passed', function () {
+        const bidder = newBidder(spec);
+        const url = 'test.url.com';
+        const data = { arg: 2 };
+        const options = { contentType: 'application/json' };
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns({
+          method: 'POST',
+          url: url,
+          data: data,
+          options: options
+        });
 
-      expect(ajaxStub.calledOnce).to.equal(true);
-      expect(ajaxStub.firstCall.args[0]).to.equal(url);
-      expect(ajaxStub.firstCall.args[2]).to.equal(JSON.stringify(data));
-      sinon.assert.match(ajaxStub.firstCall.args[3], {
-        method: 'POST',
-        contentType: 'application/json',
-        withCredentials: true
-      })
-    });
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-    it('should make the appropriate GET request', function () {
-      const bidder = newBidder(spec);
-      const url = 'test.url.com';
-      const data = { arg: 2 };
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns({
-        method: 'GET',
-        url: url,
-        data: data
+        expect(ajaxStub.calledOnce).to.equal(true);
+        expect(ajaxStub.firstCall.args[0]).to.equal(url);
+        expect(ajaxStub.firstCall.args[2]).to.equal(JSON.stringify(data));
+        sinon.assert.match(ajaxStub.firstCall.args[3], {
+          method: 'POST',
+          contentType: 'application/json',
+          withCredentials: true
+        })
       });
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+      it('should make the appropriate GET request', function () {
+        const bidder = newBidder(spec);
+        const url = 'test.url.com';
+        const data = { arg: 2 };
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns({
+          method: 'GET',
+          url: url,
+          data: data
+        });
 
-      expect(ajaxStub.calledOnce).to.equal(true);
-      expect(ajaxStub.firstCall.args[0]).to.equal(`${url}?arg=2`);
-      expect(ajaxStub.firstCall.args[2]).to.be.undefined;
-      sinon.assert.match(ajaxStub.firstCall.args[3], {
-        method: 'GET',
-        withCredentials: true
-      })
-    });
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-    it('should make the appropriate GET request when options are passed', function () {
-      const bidder = newBidder(spec);
-      const url = 'test.url.com';
-      const data = { arg: 2 };
-      const opt = { withCredentials: false }
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns({
-        method: 'GET',
-        url: url,
-        data: data,
-        options: opt
+        expect(ajaxStub.calledOnce).to.equal(true);
+        expect(ajaxStub.firstCall.args[0]).to.equal(`${url}?arg=2`);
+        expect(ajaxStub.firstCall.args[2]).to.be.undefined;
+        sinon.assert.match(ajaxStub.firstCall.args[3], {
+          method: 'GET',
+          withCredentials: true
+        })
       });
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-
-      expect(ajaxStub.calledOnce).to.equal(true);
-      expect(ajaxStub.firstCall.args[0]).to.equal(`${url}?arg=2`);
-      expect(ajaxStub.firstCall.args[2]).to.be.undefined;
-      sinon.assert.match(ajaxStub.firstCall.args[3], {
-        method: 'GET',
-        withCredentials: false
-      })
-    });
-
-    it('should make multiple calls if the spec returns them', function () {
-      const bidder = newBidder(spec);
-      const url = 'test.url.com';
-      const data = { arg: 2 };
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns([
-        {
-          method: 'POST',
-          url: url,
-          data: data
-        },
-        {
+      it('should make the appropriate GET request when options are passed', function () {
+        const bidder = newBidder(spec);
+        const url = 'test.url.com';
+        const data = { arg: 2 };
+        const opt = { withCredentials: false }
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns({
           method: 'GET',
           url: url,
-          data: data
-        }
-      ]);
-
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+          data: data,
+          options: opt
+        });
 
-      expect(ajaxStub.calledTwice).to.equal(true);
-    });
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-    describe('browsingTopics ajax option', () => {
-      let transmitUfpdAllowed, bidder;
-      beforeEach(() => {
-        activityRules.isActivityAllowed.reset();
-        activityRules.isActivityAllowed.callsFake((activity) => activity === ACTIVITY_TRANSMIT_UFPD ? transmitUfpdAllowed : true);
-        bidder = newBidder(spec);
-        spec.isBidRequestValid.returns(true);
+        expect(ajaxStub.calledOnce).to.equal(true);
+        expect(ajaxStub.firstCall.args[0]).to.equal(`${url}?arg=2`);
+        expect(ajaxStub.firstCall.args[2]).to.be.undefined;
+        sinon.assert.match(ajaxStub.firstCall.args[3], {
+          method: 'GET',
+          withCredentials: false
+        })
       });
 
-      it(`should be set to false when adapter sets browsingTopics = false`, () => {
-        transmitUfpdAllowed = true;
+      it('should make multiple calls if the spec returns them', function () {
+        const bidder = newBidder(spec);
+        const url = 'test.url.com';
+        const data = { arg: 2 };
+        spec.isBidRequestValid.returns(true);
         spec.buildRequests.returns([
+          {
+            method: 'POST',
+            url: url,
+            data: data
+          },
           {
             method: 'GET',
-            url: 'url',
-            options: {
-              browsingTopics: false
-            }
+            url: url,
+            data: data
           }
         ]);
+
         bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-        sinon.assert.calledWith(ajaxStub, 'url', sinon.match.any, sinon.match.any, sinon.match({
-          browsingTopics: false
-        }));
+
+        expect(ajaxStub.calledTwice).to.equal(true);
       });
 
-      Object.entries({
-        'allowed': true,
-        'not allowed': false
-      }).forEach(([t, allow]) => {
-        it(`should be set to ${allow} when transmitUfpd is ${t}`, () => {
-          transmitUfpdAllowed = allow;
+      describe('browsingTopics ajax option', () => {
+        let transmitUfpdAllowed, bidder;
+        beforeEach(() => {
+          activityRules.isActivityAllowed.reset();
+          activityRules.isActivityAllowed.callsFake((activity) => activity === ACTIVITY_TRANSMIT_UFPD ? transmitUfpdAllowed : true);
+          bidder = newBidder(spec);
+          spec.isBidRequestValid.returns(true);
+        });
+
+        it(`should be set to false when adapter sets browsingTopics = false`, () => {
+          transmitUfpdAllowed = true;
           spec.buildRequests.returns([
             {
               method: 'GET',
-              url: '1',
-            },
-            {
-              method: 'POST',
-              url: '2',
-              data: {}
-            },
-            {
-              method: 'GET',
-              url: '3',
-              options: {
-                browsingTopics: true
-              }
-            },
-            {
-              method: 'POST',
-              url: '4',
-              data: {},
+              url: 'url',
               options: {
-                browsingTopics: true
+                browsingTopics: false
               }
             }
           ]);
           bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-          ['1', '2', '3', '4'].forEach(url => {
-            sinon.assert.calledWith(
-              ajaxStub,
-              url,
-              sinon.match.any,
-              sinon.match.any,
-              sinon.match({browsingTopics: allow})
-            );
+          sinon.assert.calledWith(ajaxStub, 'url', sinon.match.any, sinon.match.any, sinon.match({
+            browsingTopics: false
+          }));
+        });
+
+        Object.entries({
+          'allowed': true,
+          'not allowed': false
+        }).forEach(([t, allow]) => {
+          it(`should be set to ${allow} when transmitUfpd is ${t}`, () => {
+            transmitUfpdAllowed = allow;
+            spec.buildRequests.returns([
+              {
+                method: 'GET',
+                url: '1',
+              },
+              {
+                method: 'POST',
+                url: '2',
+                data: {}
+              },
+              {
+                method: 'GET',
+                url: '3',
+                options: {
+                  browsingTopics: true
+                }
+              },
+              {
+                method: 'POST',
+                url: '4',
+                data: {},
+                options: {
+                  browsingTopics: true
+                }
+              }
+            ]);
+            bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+            ['1', '2', '3', '4'].forEach(url => {
+              sinon.assert.calledWith(
+                ajaxStub,
+                url,
+                sinon.match.any,
+                sinon.match.any,
+                sinon.match({browsingTopics: allow})
+              );
+            });
           });
         });
       });
-    });
 
-    it('should not add bids for each placement code if no requests are given', function () {
-      const bidder = newBidder(spec);
+      it('should not add bids for each placement code if no requests are given', function () {
+        const bidder = newBidder(spec);
 
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns([]);
-      spec.interpretResponse.returns([]);
-      spec.getUserSyncs.returns([]);
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns([]);
+        spec.interpretResponse.returns([]);
+        spec.getUserSyncs.returns([]);
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-      expect(addBidResponseStub.callCount).to.equal(0);
-    });
+        expect(addBidResponseStub.callCount).to.equal(0);
+      });
 
-    it('should emit BEFORE_BIDDER_HTTP events before network requests', function () {
-      const bidder = newBidder(spec);
-      const req = {
-        method: 'POST',
-        url: 'test.url.com',
-        data: { arg: 2 }
-      };
+      it('should emit BEFORE_BIDDER_HTTP events before network requests', function () {
+        const bidder = newBidder(spec);
+        const req = {
+          method: 'POST',
+          url: 'test.url.com',
+          data: { arg: 2 }
+        };
 
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns([req, req]);
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns([req, req]);
 
-      const eventEmitterSpy = sinon.spy(events, 'emit');
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        const eventEmitterSpy = sinon.spy(events, 'emit');
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-      expect(ajaxStub.calledTwice).to.equal(true);
-      expect(eventEmitterSpy.getCalls()
-        .filter(call => call.args[0] === CONSTANTS.EVENTS.BEFORE_BIDDER_HTTP)
-      ).to.length(2);
+        expect(ajaxStub.calledTwice).to.equal(true);
+        expect(eventEmitterSpy.getCalls()
+          .filter(call => call.args[0] === CONSTANTS.EVENTS.BEFORE_BIDDER_HTTP)
+        ).to.length(2);
 
-      eventEmitterSpy.restore();
+        eventEmitterSpy.restore();
+      });
     });
-  });
 
-  describe('when the ajax call succeeds', function () {
-    let ajaxStub;
-    let userSyncStub;
-    let logErrorSpy;
+    describe('when the ajax call succeeds', function () {
+      let ajaxStub;
+      let userSyncStub;
+      let logErrorSpy;
 
-    beforeEach(function () {
-      ajaxStub = sinon.stub(ajax, 'ajax').callsFake(function(url, callbacks) {
-        const fakeResponse = sinon.stub();
-        fakeResponse.returns('headerContent');
-        callbacks.success('response body', { getResponseHeader: fakeResponse });
+      beforeEach(function () {
+        ajaxStub = sinon.stub(ajax, 'ajax').callsFake(function(url, callbacks) {
+          const fakeResponse = sinon.stub();
+          fakeResponse.returns('headerContent');
+          callbacks.success('response body', { getResponseHeader: fakeResponse });
+        });
+        addBidResponseStub.reset();
+        doneStub.resetBehavior();
+        userSyncStub = sinon.stub(userSync, 'registerSync')
+        logErrorSpy = sinon.spy(utils, 'logError');
       });
-      addBidResponseStub.reset();
-      doneStub.resetBehavior();
-      userSyncStub = sinon.stub(userSync, 'registerSync')
-      logErrorSpy = sinon.spy(utils, 'logError');
-    });
 
-    afterEach(function () {
-      ajaxStub.restore();
-      userSyncStub.restore();
-      utils.logError.restore();
-    });
+      afterEach(function () {
+        ajaxStub.restore();
+        userSyncStub.restore();
+        utils.logError.restore();
+      });
 
-    it('should call spec.interpretResponse() with the response content', function () {
-      const bidder = newBidder(spec);
+      it('should call spec.interpretResponse() with the response content', function () {
+        const bidder = newBidder(spec);
 
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns({
-        method: 'POST',
-        url: 'test.url.com',
-        data: {}
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns({
+          method: 'POST',
+          url: 'test.url.com',
+          data: {}
+        });
+        spec.getUserSyncs.returns([]);
+
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+        expect(spec.interpretResponse.calledOnce).to.equal(true);
+        const response = spec.interpretResponse.firstCall.args[0]
+        expect(response.body).to.equal('response body')
+        expect(response.headers.get('some-header')).to.equal('headerContent');
+        expect(spec.interpretResponse.firstCall.args[1]).to.deep.equal({
+          method: 'POST',
+          url: 'test.url.com',
+          data: {}
+        });
+        expect(doneStub.calledOnce).to.equal(true);
       });
-      spec.getUserSyncs.returns([]);
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+      it('should call spec.interpretResponse() once for each request made', function () {
+        const bidder = newBidder(spec);
 
-      expect(spec.interpretResponse.calledOnce).to.equal(true);
-      const response = spec.interpretResponse.firstCall.args[0]
-      expect(response.body).to.equal('response body')
-      expect(response.headers.get('some-header')).to.equal('headerContent');
-      expect(spec.interpretResponse.firstCall.args[1]).to.deep.equal({
-        method: 'POST',
-        url: 'test.url.com',
-        data: {}
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns([
+          {
+            method: 'POST',
+            url: 'test.url.com',
+            data: {}
+          },
+          {
+            method: 'POST',
+            url: 'test.url.com',
+            data: {}
+          },
+        ]);
+        spec.getUserSyncs.returns([]);
+
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+        expect(spec.interpretResponse.calledTwice).to.equal(true);
+        expect(doneStub.calledOnce).to.equal(true);
       });
-      expect(doneStub.calledOnce).to.equal(true);
-    });
 
-    it('should call spec.interpretResponse() once for each request made', function () {
-      const bidder = newBidder(spec);
+      it('should only add bids for valid adUnit code into the auction, even if the bidder doesn\'t bid on all of them', function () {
+        const bidder = newBidder(spec);
 
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns([
-        {
+        const bid = {
+          creativeId: 'creative-id',
+          requestId: '1',
+          ad: 'ad-url.com',
+          cpm: 0.5,
+          height: 200,
+          width: 300,
+          adUnitCode: 'mock/placement',
+          currency: 'USD',
+          netRevenue: true,
+          ttl: 300,
+          bidderCode: 'sampleBidder',
+          sampleBidder: {advertiserId: '12345', networkId: '111222'}
+        };
+        const bidderRequest = Object.assign({}, MOCK_BIDS_REQUEST);
+        bidderRequest.bids[0].bidder = 'sampleBidder';
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns({
           method: 'POST',
           url: 'test.url.com',
           data: {}
-        },
-        {
+        });
+        spec.getUserSyncs.returns([]);
+
+        spec.interpretResponse.returns(bid);
+
+        bidder.callBids(bidderRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+        expect(addBidResponseStub.calledOnce).to.equal(true);
+        expect(addBidResponseStub.firstCall.args[0]).to.equal('mock/placement');
+        let bidObject = addBidResponseStub.firstCall.args[1];
+        // checking the fields added by our code
+        expect(bidObject.originalCpm).to.equal(bid.cpm);
+        expect(bidObject.originalCurrency).to.equal(bid.currency);
+        expect(doneStub.calledOnce).to.equal(true);
+        expect(logErrorSpy.callCount).to.equal(0);
+        expect(bidObject.meta).to.exist;
+        expect(bidObject.meta).to.deep.equal({advertiserId: '12345', networkId: '111222'});
+      });
+
+      it('should call spec.getUserSyncs() with the response', function () {
+        const bidder = newBidder(spec);
+
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns({
           method: 'POST',
           url: 'test.url.com',
           data: {}
-        },
-      ]);
-      spec.getUserSyncs.returns([]);
+        });
+        spec.getUserSyncs.returns([]);
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-      expect(spec.interpretResponse.calledTwice).to.equal(true);
-      expect(doneStub.calledOnce).to.equal(true);
-    });
+        expect(spec.getUserSyncs.calledOnce).to.equal(true);
+        expect(spec.getUserSyncs.firstCall.args[1].length).to.equal(1);
+        expect(spec.getUserSyncs.firstCall.args[1][0].body).to.equal('response body');
+        expect(spec.getUserSyncs.firstCall.args[1][0].headers).to.have.property('get');
+        expect(spec.getUserSyncs.firstCall.args[1][0].headers.get).to.be.a('function');
+      });
 
-    it('should only add bids for valid adUnit code into the auction, even if the bidder doesn\'t bid on all of them', function () {
-      const bidder = newBidder(spec);
+      it('should register usersync pixels', function () {
+        const bidder = newBidder(spec);
 
-      const bid = {
-        creativeId: 'creative-id',
-        requestId: '1',
-        ad: 'ad-url.com',
-        cpm: 0.5,
-        height: 200,
-        width: 300,
-        adUnitCode: 'mock/placement',
-        currency: 'USD',
-        netRevenue: true,
-        ttl: 300,
-        bidderCode: 'sampleBidder',
-        sampleBidder: {advertiserId: '12345', networkId: '111222'}
-      };
-      const bidderRequest = Object.assign({}, MOCK_BIDS_REQUEST);
-      bidderRequest.bids[0].bidder = 'sampleBidder';
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns({
-        method: 'POST',
-        url: 'test.url.com',
-        data: {}
+        spec.isBidRequestValid.returns(false);
+        spec.buildRequests.returns([]);
+        spec.getUserSyncs.returns([{
+          type: 'iframe',
+          url: 'usersync.com'
+        }]);
+
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+        expect(userSyncStub.called).to.equal(true);
+        expect(userSyncStub.firstCall.args[0]).to.equal('iframe');
+        expect(userSyncStub.firstCall.args[1]).to.equal(spec.code);
+        expect(userSyncStub.firstCall.args[2]).to.equal('usersync.com');
       });
-      spec.getUserSyncs.returns([]);
 
-      spec.interpretResponse.returns(bid);
+      it('should logError and reject bid when required bid response params are missing', function () {
+        const bidder = newBidder(spec);
 
-      bidder.callBids(bidderRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        const bid = {
+          requestId: '1',
+          ad: 'ad-url.com',
+          cpm: 0.5,
+          height: 200,
+          width: 300,
+          placementCode: 'mock/placement'
+        };
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns({
+          method: 'POST',
+          url: 'test.url.com',
+          data: {}
+        });
+        spec.getUserSyncs.returns([]);
 
-      expect(addBidResponseStub.calledOnce).to.equal(true);
-      expect(addBidResponseStub.firstCall.args[0]).to.equal('mock/placement');
-      let bidObject = addBidResponseStub.firstCall.args[1];
-      // checking the fields added by our code
-      expect(bidObject.originalCpm).to.equal(bid.cpm);
-      expect(bidObject.originalCurrency).to.equal(bid.currency);
-      expect(doneStub.calledOnce).to.equal(true);
-      expect(logErrorSpy.callCount).to.equal(0);
-      expect(bidObject.meta).to.exist;
-      expect(bidObject.meta).to.deep.equal({advertiserId: '12345', networkId: '111222'});
-    });
+        spec.interpretResponse.returns(bid);
 
-    it('should call spec.getUserSyncs() with the response', function () {
-      const bidder = newBidder(spec);
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns({
-        method: 'POST',
-        url: 'test.url.com',
-        data: {}
+        expect(logErrorSpy.calledOnce).to.equal(true);
+        expect(addBidResponseStub.reject.calledOnce).to.be.true;
       });
-      spec.getUserSyncs.returns([]);
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+      it('should logError and reject bid when required response params are undefined', function () {
+        const bidder = newBidder(spec);
 
-      expect(spec.getUserSyncs.calledOnce).to.equal(true);
-      expect(spec.getUserSyncs.firstCall.args[1].length).to.equal(1);
-      expect(spec.getUserSyncs.firstCall.args[1][0].body).to.equal('response body');
-      expect(spec.getUserSyncs.firstCall.args[1][0].headers).to.have.property('get');
-      expect(spec.getUserSyncs.firstCall.args[1][0].headers.get).to.be.a('function');
-    });
+        const bid = {
+          'ad': 'creative',
+          'cpm': '1.99',
+          'width': 300,
+          'height': 250,
+          'requestId': '1',
+          'creativeId': 'some-id',
+          'currency': undefined,
+          'netRevenue': true,
+          'ttl': 360
+        };
 
-    it('should register usersync pixels', function () {
-      const bidder = newBidder(spec);
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns({
+          method: 'POST',
+          url: 'test.url.com',
+          data: {}
+        });
+        spec.getUserSyncs.returns([]);
 
-      spec.isBidRequestValid.returns(false);
-      spec.buildRequests.returns([]);
-      spec.getUserSyncs.returns([{
-        type: 'iframe',
-        url: 'usersync.com'
-      }]);
+        spec.interpretResponse.returns(bid);
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-      expect(userSyncStub.called).to.equal(true);
-      expect(userSyncStub.firstCall.args[0]).to.equal('iframe');
-      expect(userSyncStub.firstCall.args[1]).to.equal(spec.code);
-      expect(userSyncStub.firstCall.args[2]).to.equal('usersync.com');
-    });
+        expect(logErrorSpy.calledOnce).to.equal(true);
+        expect(addBidResponseStub.reject.calledOnce).to.be.true;
+      });
 
-    it('should logError and reject bid when required bid response params are missing', function () {
-      const bidder = newBidder(spec);
+      it('should require requestId from interpretResponse', () => {
+        const bidder = newBidder(spec);
+        const bid = {
+          'ad': 'creative',
+          'cpm': '1.99',
+          'creativeId': 'some-id',
+          'currency': 'USD',
+          'netRevenue': true,
+          'ttl': 360
+        };
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns({
+          method: 'POST',
+          url: 'test.url.com',
+          data: {}
+        });
+        spec.getUserSyncs.returns([]);
+        spec.interpretResponse.returns(bid);
 
-      const bid = {
-        requestId: '1',
-        ad: 'ad-url.com',
-        cpm: 0.5,
-        height: 200,
-        width: 300,
-        placementCode: 'mock/placement'
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+        expect(addBidResponseStub.called).to.be.false;
+        expect(addBidResponseStub.reject.calledOnce).to.be.true;
+      });
+    });
+
+    describe('when the ajax call fails', function () {
+      let ajaxStub;
+      let callBidderErrorStub;
+      let eventEmitterStub;
+      let xhrErrorMock = {
+        status: 500,
+        statusText: 'Internal Server Error'
       };
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns({
-        method: 'POST',
-        url: 'test.url.com',
-        data: {}
+
+      beforeEach(function () {
+        ajaxStub = sinon.stub(ajax, 'ajax').callsFake(function(url, callbacks) {
+          callbacks.error('ajax call failed.', xhrErrorMock);
+        });
+        callBidderErrorStub = sinon.stub(adapterManager, 'callBidderError');
+        eventEmitterStub = sinon.stub(events, 'emit');
+        addBidResponseStub.reset();
+        doneStub.reset();
       });
-      spec.getUserSyncs.returns([]);
 
-      spec.interpretResponse.returns(bid);
+      afterEach(function () {
+        ajaxStub.restore();
+        callBidderErrorStub.restore();
+        eventEmitterStub.restore();
+      });
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+      it('should not spec.interpretResponse()', function () {
+        const bidder = newBidder(spec);
 
-      expect(logErrorSpy.calledOnce).to.equal(true);
-      expect(addBidResponseStub.reject.calledOnce).to.be.true;
-    });
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns({
+          method: 'POST',
+          url: 'test.url.com',
+          data: {}
+        });
+        spec.getUserSyncs.returns([]);
 
-    it('should logError and reject bid when required response params are undefined', function () {
-      const bidder = newBidder(spec);
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-      const bid = {
-        'ad': 'creative',
-        'cpm': '1.99',
-        'width': 300,
-        'height': 250,
-        'requestId': '1',
-        'creativeId': 'some-id',
-        'currency': undefined,
-        'netRevenue': true,
-        'ttl': 360
-      };
+        expect(spec.interpretResponse.called).to.equal(false);
+        expect(doneStub.calledOnce).to.equal(true);
+        expect(callBidderErrorStub.calledOnce).to.equal(true);
+        expect(callBidderErrorStub.firstCall.args[0]).to.equal(CODE);
+        expect(callBidderErrorStub.firstCall.args[1]).to.equal(xhrErrorMock);
+        expect(callBidderErrorStub.firstCall.args[2]).to.equal(MOCK_BIDS_REQUEST);
+        sinon.assert.calledWith(eventEmitterStub, CONSTANTS.EVENTS.BIDDER_ERROR, {
+          error: xhrErrorMock,
+          bidderRequest: MOCK_BIDS_REQUEST
+        });
+      });
 
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns({
-        method: 'POST',
-        url: 'test.url.com',
-        data: {}
+      it('should not add bids for each adunit code into the auction', function () {
+        const bidder = newBidder(spec);
+
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns({
+          method: 'POST',
+          url: 'test.url.com',
+          data: {}
+        });
+        spec.interpretResponse.returns([]);
+        spec.getUserSyncs.returns([]);
+
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+        expect(addBidResponseStub.callCount).to.equal(0);
+        expect(doneStub.calledOnce).to.equal(true);
+        expect(callBidderErrorStub.calledOnce).to.equal(true);
+        expect(callBidderErrorStub.firstCall.args[0]).to.equal(CODE);
+        expect(callBidderErrorStub.firstCall.args[1]).to.equal(xhrErrorMock);
+        expect(callBidderErrorStub.firstCall.args[2]).to.equal(MOCK_BIDS_REQUEST);
+        sinon.assert.calledWith(eventEmitterStub, CONSTANTS.EVENTS.BIDDER_ERROR, {
+          error: xhrErrorMock,
+          bidderRequest: MOCK_BIDS_REQUEST
+        });
       });
-      spec.getUserSyncs.returns([]);
 
-      spec.interpretResponse.returns(bid);
+      it('should call spec.getUserSyncs() with no responses', function () {
+        const bidder = newBidder(spec);
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns({
+          method: 'POST',
+          url: 'test.url.com',
+          data: {}
+        });
+        spec.getUserSyncs.returns([]);
 
-      expect(logErrorSpy.calledOnce).to.equal(true);
-      expect(addBidResponseStub.reject.calledOnce).to.be.true;
-    });
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-    it('should require requestId from interpretResponse', () => {
-      const bidder = newBidder(spec);
-      const bid = {
-        'ad': 'creative',
-        'cpm': '1.99',
-        'creativeId': 'some-id',
-        'currency': 'USD',
-        'netRevenue': true,
-        'ttl': 360
-      };
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns({
-        method: 'POST',
-        url: 'test.url.com',
-        data: {}
+        expect(spec.getUserSyncs.calledOnce).to.equal(true);
+        expect(spec.getUserSyncs.firstCall.args[1]).to.deep.equal([]);
+        expect(doneStub.calledOnce).to.equal(true);
+        expect(callBidderErrorStub.calledOnce).to.equal(true);
+        expect(callBidderErrorStub.firstCall.args[0]).to.equal(CODE);
+        expect(callBidderErrorStub.firstCall.args[1]).to.equal(xhrErrorMock);
+        expect(callBidderErrorStub.firstCall.args[2]).to.equal(MOCK_BIDS_REQUEST);
+        sinon.assert.calledWith(eventEmitterStub, CONSTANTS.EVENTS.BIDDER_ERROR, {
+          error: xhrErrorMock,
+          bidderRequest: MOCK_BIDS_REQUEST
+        });
       });
-      spec.getUserSyncs.returns([]);
-      spec.interpretResponse.returns(bid);
 
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+      it('should call spec.getUserSyncs() with no responses', function () {
+        const bidder = newBidder(spec);
 
-      expect(addBidResponseStub.called).to.be.false;
-      expect(addBidResponseStub.reject.calledOnce).to.be.true;
+        spec.isBidRequestValid.returns(true);
+        spec.buildRequests.returns({
+          method: 'POST',
+          url: 'test.url.com',
+          data: {}
+        });
+        spec.getUserSyncs.returns([]);
+
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+        expect(spec.getUserSyncs.calledOnce).to.equal(true);
+        expect(spec.getUserSyncs.firstCall.args[1]).to.deep.equal([]);
+        expect(doneStub.calledOnce).to.equal(true);
+        expect(callBidderErrorStub.calledOnce).to.equal(true);
+        expect(callBidderErrorStub.firstCall.args[0]).to.equal(CODE);
+        expect(callBidderErrorStub.firstCall.args[1]).to.equal(xhrErrorMock);
+        expect(callBidderErrorStub.firstCall.args[2]).to.equal(MOCK_BIDS_REQUEST);
+        sinon.assert.calledWith(eventEmitterStub, CONSTANTS.EVENTS.BIDDER_ERROR, {
+          error: xhrErrorMock,
+          bidderRequest: MOCK_BIDS_REQUEST
+        });
+      });
     });
   });
 
-  describe('when the ajax call fails', function () {
-    let ajaxStub;
-    let callBidderErrorStub;
-    let eventEmitterStub;
-    let xhrErrorMock = {
-      status: 500,
-      statusText: 'Internal Server Error'
-    };
+  describe('registerBidder', function () {
+    let registerBidAdapterStub;
+    let aliasBidAdapterStub;
 
     beforeEach(function () {
-      ajaxStub = sinon.stub(ajax, 'ajax').callsFake(function(url, callbacks) {
-        callbacks.error('ajax call failed.', xhrErrorMock);
-      });
-      callBidderErrorStub = sinon.stub(adapterManager, 'callBidderError');
-      eventEmitterStub = sinon.stub(events, 'emit');
-      addBidResponseStub.reset();
-      doneStub.reset();
+      registerBidAdapterStub = sinon.stub(adapterManager, 'registerBidAdapter');
+      aliasBidAdapterStub = sinon.stub(adapterManager, 'aliasBidAdapter');
     });
 
     afterEach(function () {
-      ajaxStub.restore();
-      callBidderErrorStub.restore();
-      eventEmitterStub.restore();
+      registerBidAdapterStub.restore();
+      aliasBidAdapterStub.restore();
     });
 
-    it('should not spec.interpretResponse()', function () {
-      const bidder = newBidder(spec);
+    function newEmptySpec() {
+      return {
+        code: CODE,
+        isBidRequestValid: function() { },
+        buildRequests: function() { },
+        interpretResponse: function() { },
+      };
+    }
 
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns({
-        method: 'POST',
-        url: 'test.url.com',
-        data: {}
-      });
-      spec.getUserSyncs.returns([]);
-
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-
-      expect(spec.interpretResponse.called).to.equal(false);
-      expect(doneStub.calledOnce).to.equal(true);
-      expect(callBidderErrorStub.calledOnce).to.equal(true);
-      expect(callBidderErrorStub.firstCall.args[0]).to.equal(CODE);
-      expect(callBidderErrorStub.firstCall.args[1]).to.equal(xhrErrorMock);
-      expect(callBidderErrorStub.firstCall.args[2]).to.equal(MOCK_BIDS_REQUEST);
-      sinon.assert.calledWith(eventEmitterStub, CONSTANTS.EVENTS.BIDDER_ERROR, {
-        error: xhrErrorMock,
-        bidderRequest: MOCK_BIDS_REQUEST
-      });
-    });
+    it('should register a bidder with the adapterManager', function () {
+      registerBidder(newEmptySpec());
+      expect(registerBidAdapterStub.calledOnce).to.equal(true);
+      expect(registerBidAdapterStub.firstCall.args[0]).to.have.property('callBids');
+      expect(registerBidAdapterStub.firstCall.args[0].callBids).to.be.a('function');
 
-    it('should not add bids for each adunit code into the auction', function () {
-      const bidder = newBidder(spec);
+      expect(registerBidAdapterStub.firstCall.args[1]).to.equal(CODE);
+      expect(registerBidAdapterStub.firstCall.args[2]).to.be.undefined;
+    });
 
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns({
-        method: 'POST',
-        url: 'test.url.com',
-        data: {}
-      });
-      spec.interpretResponse.returns([]);
-      spec.getUserSyncs.returns([]);
-
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-
-      expect(addBidResponseStub.callCount).to.equal(0);
-      expect(doneStub.calledOnce).to.equal(true);
-      expect(callBidderErrorStub.calledOnce).to.equal(true);
-      expect(callBidderErrorStub.firstCall.args[0]).to.equal(CODE);
-      expect(callBidderErrorStub.firstCall.args[1]).to.equal(xhrErrorMock);
-      expect(callBidderErrorStub.firstCall.args[2]).to.equal(MOCK_BIDS_REQUEST);
-      sinon.assert.calledWith(eventEmitterStub, CONSTANTS.EVENTS.BIDDER_ERROR, {
-        error: xhrErrorMock,
-        bidderRequest: MOCK_BIDS_REQUEST
-      });
+    it('should register a bidder with the appropriate mediaTypes', function () {
+      const thisSpec = Object.assign(newEmptySpec(), { supportedMediaTypes: ['video'] });
+      registerBidder(thisSpec);
+      expect(registerBidAdapterStub.calledOnce).to.equal(true);
+      expect(registerBidAdapterStub.firstCall.args[2]).to.deep.equal({supportedMediaTypes: ['video']});
     });
 
-    it('should call spec.getUserSyncs() with no responses', function () {
-      const bidder = newBidder(spec);
+    it('should register bidders with the appropriate aliases', function () {
+      const thisSpec = Object.assign(newEmptySpec(), { aliases: ['foo', 'bar'] });
+      registerBidder(thisSpec);
 
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns({
-        method: 'POST',
-        url: 'test.url.com',
-        data: {}
-      });
-      spec.getUserSyncs.returns([]);
-
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-
-      expect(spec.getUserSyncs.calledOnce).to.equal(true);
-      expect(spec.getUserSyncs.firstCall.args[1]).to.deep.equal([]);
-      expect(doneStub.calledOnce).to.equal(true);
-      expect(callBidderErrorStub.calledOnce).to.equal(true);
-      expect(callBidderErrorStub.firstCall.args[0]).to.equal(CODE);
-      expect(callBidderErrorStub.firstCall.args[1]).to.equal(xhrErrorMock);
-      expect(callBidderErrorStub.firstCall.args[2]).to.equal(MOCK_BIDS_REQUEST);
-      sinon.assert.calledWith(eventEmitterStub, CONSTANTS.EVENTS.BIDDER_ERROR, {
-        error: xhrErrorMock,
-        bidderRequest: MOCK_BIDS_REQUEST
-      });
-    });
+      expect(registerBidAdapterStub.calledThrice).to.equal(true);
 
-    it('should call spec.getUserSyncs() with no responses', function () {
-      const bidder = newBidder(spec);
+      // Make sure our later calls don't override the bidder code from previous calls.
+      expect(registerBidAdapterStub.firstCall.args[0].getBidderCode()).to.equal(CODE);
+      expect(registerBidAdapterStub.secondCall.args[0].getBidderCode()).to.equal('foo')
+      expect(registerBidAdapterStub.thirdCall.args[0].getBidderCode()).to.equal('bar')
 
-      spec.isBidRequestValid.returns(true);
-      spec.buildRequests.returns({
-        method: 'POST',
-        url: 'test.url.com',
-        data: {}
-      });
-      spec.getUserSyncs.returns([]);
-
-      bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-
-      expect(spec.getUserSyncs.calledOnce).to.equal(true);
-      expect(spec.getUserSyncs.firstCall.args[1]).to.deep.equal([]);
-      expect(doneStub.calledOnce).to.equal(true);
-      expect(callBidderErrorStub.calledOnce).to.equal(true);
-      expect(callBidderErrorStub.firstCall.args[0]).to.equal(CODE);
-      expect(callBidderErrorStub.firstCall.args[1]).to.equal(xhrErrorMock);
-      expect(callBidderErrorStub.firstCall.args[2]).to.equal(MOCK_BIDS_REQUEST);
-      sinon.assert.calledWith(eventEmitterStub, CONSTANTS.EVENTS.BIDDER_ERROR, {
-        error: xhrErrorMock,
-        bidderRequest: MOCK_BIDS_REQUEST
-      });
+      expect(registerBidAdapterStub.firstCall.args[1]).to.equal(CODE);
+      expect(registerBidAdapterStub.secondCall.args[1]).to.equal('foo')
+      expect(registerBidAdapterStub.thirdCall.args[1]).to.equal('bar')
     });
-  });
-});
 
-describe('registerBidder', function () {
-  let registerBidAdapterStub;
-  let aliasBidAdapterStub;
+    it('should register alias with their gvlid', function() {
+      const aliases = [
+        {
+          code: 'foo',
+          gvlid: 1
+        },
+        {
+          code: 'bar',
+          gvlid: 2
+        },
+        {
+          code: 'baz'
+        }
+      ]
+      const thisSpec = Object.assign(newEmptySpec(), { aliases: aliases });
+      registerBidder(thisSpec);
 
-  beforeEach(function () {
-    registerBidAdapterStub = sinon.stub(adapterManager, 'registerBidAdapter');
-    aliasBidAdapterStub = sinon.stub(adapterManager, 'aliasBidAdapter');
-  });
+      expect(registerBidAdapterStub.getCall(1).args[0].getSpec().gvlid).to.equal(1);
+      expect(registerBidAdapterStub.getCall(2).args[0].getSpec().gvlid).to.equal(2);
+      expect(registerBidAdapterStub.getCall(3).args[0].getSpec().gvlid).to.equal(undefined);
+    })
 
-  afterEach(function () {
-    registerBidAdapterStub.restore();
-    aliasBidAdapterStub.restore();
-  });
+    it('should register alias with skipPbsAliasing', function() {
+      const aliases = [
+        {
+          code: 'foo',
+          skipPbsAliasing: true
+        },
+        {
+          code: 'bar',
+          skipPbsAliasing: false
+        },
+        {
+          code: 'baz'
+        }
+      ]
+      const thisSpec = Object.assign(newEmptySpec(), { aliases: aliases });
+      registerBidder(thisSpec);
 
-  function newEmptySpec() {
-    return {
-      code: CODE,
-      isBidRequestValid: function() { },
-      buildRequests: function() { },
-      interpretResponse: function() { },
-    };
-  }
-
-  it('should register a bidder with the adapterManager', function () {
-    registerBidder(newEmptySpec());
-    expect(registerBidAdapterStub.calledOnce).to.equal(true);
-    expect(registerBidAdapterStub.firstCall.args[0]).to.have.property('callBids');
-    expect(registerBidAdapterStub.firstCall.args[0].callBids).to.be.a('function');
-
-    expect(registerBidAdapterStub.firstCall.args[1]).to.equal(CODE);
-    expect(registerBidAdapterStub.firstCall.args[2]).to.be.undefined;
-  });
+      expect(registerBidAdapterStub.getCall(1).args[0].getSpec().skipPbsAliasing).to.equal(true);
+      expect(registerBidAdapterStub.getCall(2).args[0].getSpec().skipPbsAliasing).to.equal(false);
+      expect(registerBidAdapterStub.getCall(3).args[0].getSpec().skipPbsAliasing).to.equal(undefined);
+    })
+  })
 
-  it('should register a bidder with the appropriate mediaTypes', function () {
-    const thisSpec = Object.assign(newEmptySpec(), { supportedMediaTypes: ['video'] });
-    registerBidder(thisSpec);
-    expect(registerBidAdapterStub.calledOnce).to.equal(true);
-    expect(registerBidAdapterStub.firstCall.args[2]).to.deep.equal({supportedMediaTypes: ['video']});
-  });
+  describe('validate bid response: ', function () {
+    let spec;
+    let indexStub, adUnits, bidderRequests;
+    let addBidResponseStub;
+    let doneStub;
+    let ajaxStub;
+    let logErrorSpy;
+
+    let bids = [{
+      'ad': 'creative',
+      'cpm': '1.99',
+      'width': 300,
+      'height': 250,
+      'requestId': '1',
+      'creativeId': 'some-id',
+      'currency': 'USD',
+      'netRevenue': true,
+      'ttl': 360
+    }];
+
+    beforeEach(function () {
+      spec = {
+        code: CODE,
+        isBidRequestValid: sinon.stub(),
+        buildRequests: sinon.stub(),
+        interpretResponse: sinon.stub(),
+      };
 
-  it('should register bidders with the appropriate aliases', function () {
-    const thisSpec = Object.assign(newEmptySpec(), { aliases: ['foo', 'bar'] });
-    registerBidder(thisSpec);
+      spec.isBidRequestValid.returns(true);
+      spec.buildRequests.returns({
+        method: 'POST',
+        url: 'test.url.com',
+        data: {}
+      });
 
-    expect(registerBidAdapterStub.calledThrice).to.equal(true);
+      addBidResponseStub = sinon.stub();
+      addBidResponseStub.reject = sinon.stub();
+      doneStub = sinon.stub();
+      ajaxStub = sinon.stub(ajax, 'ajax').callsFake(function(url, callbacks) {
+        const fakeResponse = sinon.stub();
+        fakeResponse.returns('headerContent');
+        callbacks.success('response body', { getResponseHeader: fakeResponse });
+      });
+      logErrorSpy = sinon.spy(utils, 'logError');
+      indexStub = sinon.stub(auctionManager, 'index');
+      adUnits = [];
+      bidderRequests = [];
+      indexStub.get(() => stubAuctionIndex({adUnits: adUnits, bidderRequests: bidderRequests}))
+    });
 
-    // Make sure our later calls don't override the bidder code from previous calls.
-    expect(registerBidAdapterStub.firstCall.args[0].getBidderCode()).to.equal(CODE);
-    expect(registerBidAdapterStub.secondCall.args[0].getBidderCode()).to.equal('foo')
-    expect(registerBidAdapterStub.thirdCall.args[0].getBidderCode()).to.equal('bar')
+    afterEach(function () {
+      ajaxStub.restore();
+      logErrorSpy.restore();
+      indexStub.restore;
+    });
 
-    expect(registerBidAdapterStub.firstCall.args[1]).to.equal(CODE);
-    expect(registerBidAdapterStub.secondCall.args[1]).to.equal('foo')
-    expect(registerBidAdapterStub.thirdCall.args[1]).to.equal('bar')
-  });
+    if (FEATURES.NATIVE) {
+      it('should add native bids that do have required assets', function () {
+        adUnits = [{
+          transactionId: 'au',
+          nativeParams: {
+            title: {'required': true},
+          }
+        }]
+        decorateAdUnitsWithNativeParams(adUnits);
+        let bidRequest = {
+          bids: [{
+            bidId: '1',
+            auctionId: 'first-bid-id',
+            adUnitCode: 'mock/placement',
+            transactionId: 'au',
+            params: {
+              param: 5
+            },
+            mediaType: 'native',
+          }]
+        };
 
-  it('should register alias with their gvlid', function() {
-    const aliases = [
-      {
-        code: 'foo',
-        gvlid: 1
-      },
-      {
-        code: 'bar',
-        gvlid: 2
-      },
-      {
-        code: 'baz'
-      }
-    ]
-    const thisSpec = Object.assign(newEmptySpec(), { aliases: aliases });
-    registerBidder(thisSpec);
+        let bids1 = Object.assign({},
+          bids[0],
+          {
+            'mediaType': 'native',
+            'native': {
+              'title': 'Native Creative',
+              'clickUrl': 'https://www.link.example',
+            }
+          }
+        );
 
-    expect(registerBidAdapterStub.getCall(1).args[0].getSpec().gvlid).to.equal(1);
-    expect(registerBidAdapterStub.getCall(2).args[0].getSpec().gvlid).to.equal(2);
-    expect(registerBidAdapterStub.getCall(3).args[0].getSpec().gvlid).to.equal(undefined);
-  })
+        const bidder = newBidder(spec);
 
-  it('should register alias with skipPbsAliasing', function() {
-    const aliases = [
-      {
-        code: 'foo',
-        skipPbsAliasing: true
-      },
-      {
-        code: 'bar',
-        skipPbsAliasing: false
-      },
-      {
-        code: 'baz'
-      }
-    ]
-    const thisSpec = Object.assign(newEmptySpec(), { aliases: aliases });
-    registerBidder(thisSpec);
+        spec.interpretResponse.returns(bids1);
+        bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-    expect(registerBidAdapterStub.getCall(1).args[0].getSpec().skipPbsAliasing).to.equal(true);
-    expect(registerBidAdapterStub.getCall(2).args[0].getSpec().skipPbsAliasing).to.equal(false);
-    expect(registerBidAdapterStub.getCall(3).args[0].getSpec().skipPbsAliasing).to.equal(undefined);
-  })
-})
+        expect(addBidResponseStub.calledOnce).to.equal(true);
+        expect(addBidResponseStub.firstCall.args[0]).to.equal('mock/placement');
+        expect(logErrorSpy.callCount).to.equal(0);
+      });
 
-describe('validate bid response: ', function () {
-  let spec;
-  let indexStub, adUnits, bidderRequests;
-  let addBidResponseStub;
-  let doneStub;
-  let ajaxStub;
-  let logErrorSpy;
-
-  let bids = [{
-    'ad': 'creative',
-    'cpm': '1.99',
-    'width': 300,
-    'height': 250,
-    'requestId': '1',
-    'creativeId': 'some-id',
-    'currency': 'USD',
-    'netRevenue': true,
-    'ttl': 360
-  }];
-
-  beforeEach(function () {
-    spec = {
-      code: CODE,
-      isBidRequestValid: sinon.stub(),
-      buildRequests: sinon.stub(),
-      interpretResponse: sinon.stub(),
-    };
-
-    spec.isBidRequestValid.returns(true);
-    spec.buildRequests.returns({
-      method: 'POST',
-      url: 'test.url.com',
-      data: {}
-    });
+      it('should not add native bids that do not have required assets', function () {
+        adUnits = [{
+          transactionId: 'au',
+          nativeParams: {
+            title: {'required': true},
+          },
+        }];
+        decorateAdUnitsWithNativeParams(adUnits);
+        let bidRequest = {
+          bids: [{
+            bidId: '1',
+            auctionId: 'first-bid-id',
+            adUnitCode: 'mock/placement',
+            transactionId: 'au',
+            params: {
+              param: 5
+            },
+            mediaType: 'native',
+          }]
+        };
+        let bids1 = Object.assign({},
+          bids[0],
+          {
+            bidderCode: CODE,
+            mediaType: 'native',
+            native: {
+              title: undefined,
+              clickUrl: 'https://www.link.example',
+            }
+          }
+        );
 
-    addBidResponseStub = sinon.stub();
-    addBidResponseStub.reject = sinon.stub();
-    doneStub = sinon.stub();
-    ajaxStub = sinon.stub(ajax, 'ajax').callsFake(function(url, callbacks) {
-      const fakeResponse = sinon.stub();
-      fakeResponse.returns('headerContent');
-      callbacks.success('response body', { getResponseHeader: fakeResponse });
-    });
-    logErrorSpy = sinon.spy(utils, 'logError');
-    indexStub = sinon.stub(auctionManager, 'index');
-    adUnits = [];
-    bidderRequests = [];
-    indexStub.get(() => stubAuctionIndex({adUnits: adUnits, bidderRequests: bidderRequests}))
-  });
+        const bidder = newBidder(spec);
+        spec.interpretResponse.returns(bids1);
+        bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-  afterEach(function () {
-    ajaxStub.restore();
-    logErrorSpy.restore();
-    indexStub.restore;
-  });
+        expect(addBidResponseStub.called).to.equal(false);
+        expect(addBidResponseStub.reject.calledOnce).to.be.true;
+        expect(logErrorSpy.calledWithMatch('Ignoring bid: Native bid missing some required properties.')).to.equal(true);
+      });
+    }
 
-  if (FEATURES.NATIVE) {
-    it('should add native bids that do have required assets', function () {
+    it('should add bid when renderer is present on outstream bids', function () {
       adUnits = [{
         transactionId: 'au',
-        nativeParams: {
-          title: {'required': true},
+        mediaTypes: {
+          video: {context: 'outstream'}
         }
       }]
-      decorateAdUnitsWithNativeParams(adUnits);
       let bidRequest = {
         bids: [{
           bidId: '1',
           auctionId: 'first-bid-id',
-          adUnitCode: 'mock/placement',
           transactionId: 'au',
+          adUnitCode: 'mock/placement',
           params: {
             param: 5
           },
-          mediaType: 'native',
         }]
       };
 
       let bids1 = Object.assign({},
         bids[0],
         {
-          'mediaType': 'native',
-          'native': {
-            'title': 'Native Creative',
-            'clickUrl': 'https://www.link.example',
-          }
+          bidderCode: CODE,
+          mediaType: 'video',
+          renderer: {render: () => true, url: 'render.js'},
         }
       );
 
@@ -1095,413 +1176,335 @@ describe('validate bid response: ', function () {
       expect(logErrorSpy.callCount).to.equal(0);
     });
 
-    it('should not add native bids that do not have required assets', function () {
-      adUnits = [{
-        transactionId: 'au',
-        nativeParams: {
-          title: {'required': true},
-        },
-      }];
-      decorateAdUnitsWithNativeParams(adUnits);
+    it('should add banner bids that have no width or height but single adunit size', function () {
       let bidRequest = {
         bids: [{
+          bidder: CODE,
           bidId: '1',
           auctionId: 'first-bid-id',
           adUnitCode: 'mock/placement',
-          transactionId: 'au',
           params: {
             param: 5
           },
-          mediaType: 'native',
+          sizes: [[300, 250]],
         }]
       };
+      bidderRequests = [bidRequest];
       let bids1 = Object.assign({},
         bids[0],
         {
-          bidderCode: CODE,
-          mediaType: 'native',
-          native: {
-            title: undefined,
-            clickUrl: 'https://www.link.example',
-          }
+          width: undefined,
+          height: undefined
         }
       );
 
       const bidder = newBidder(spec);
+
       spec.interpretResponse.returns(bids1);
       bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-      expect(addBidResponseStub.called).to.equal(false);
-      expect(addBidResponseStub.reject.calledOnce).to.be.true;
-      expect(logErrorSpy.calledWithMatch('Ignoring bid: Native bid missing some required properties.')).to.equal(true);
+      expect(addBidResponseStub.calledOnce).to.equal(true);
+      expect(addBidResponseStub.firstCall.args[0]).to.equal('mock/placement');
+      expect(logErrorSpy.callCount).to.equal(0);
     });
-  }
-
-  it('should add bid when renderer is present on outstream bids', function () {
-    adUnits = [{
-      transactionId: 'au',
-      mediaTypes: {
-        video: {context: 'outstream'}
-      }
-    }]
-    let bidRequest = {
-      bids: [{
-        bidId: '1',
-        auctionId: 'first-bid-id',
-        transactionId: 'au',
-        adUnitCode: 'mock/placement',
-        params: {
-          param: 5
-        },
-      }]
-    };
-
-    let bids1 = Object.assign({},
-      bids[0],
-      {
-        bidderCode: CODE,
-        mediaType: 'video',
-        renderer: {render: () => true, url: 'render.js'},
-      }
-    );
-
-    const bidder = newBidder(spec);
-
-    spec.interpretResponse.returns(bids1);
-    bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-
-    expect(addBidResponseStub.calledOnce).to.equal(true);
-    expect(addBidResponseStub.firstCall.args[0]).to.equal('mock/placement');
-    expect(logErrorSpy.callCount).to.equal(0);
-  });
-
-  it('should add banner bids that have no width or height but single adunit size', function () {
-    let bidRequest = {
-      bids: [{
-        bidder: CODE,
-        bidId: '1',
-        auctionId: 'first-bid-id',
-        adUnitCode: 'mock/placement',
-        params: {
-          param: 5
-        },
-        sizes: [[300, 250]],
-      }]
-    };
-    bidderRequests = [bidRequest];
-    let bids1 = Object.assign({},
-      bids[0],
-      {
-        width: undefined,
-        height: undefined
-      }
-    );
-
-    const bidder = newBidder(spec);
-
-    spec.interpretResponse.returns(bids1);
-    bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-
-    expect(addBidResponseStub.calledOnce).to.equal(true);
-    expect(addBidResponseStub.firstCall.args[0]).to.equal('mock/placement');
-    expect(logErrorSpy.callCount).to.equal(0);
-  });
-
-  it('should disregard auctionId/transactionId set by the adapter', () => {
-    let bidderRequest = {
-      bids: [{
-        bidder: CODE,
-        bidId: '1',
-        auctionId: 'aid',
-        transactionId: 'tid',
-        adUnitCode: 'au',
-      }]
-    };
-    const bidder = newBidder(spec);
-    spec.interpretResponse.returns(Object.assign({}, bids[0], {transactionId: 'ignored', auctionId: 'ignored'}));
-    bidder.callBids(bidderRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-    sinon.assert.calledWith(addBidResponseStub, sinon.match.any, sinon.match({
-      transactionId: 'tid',
-      auctionId: 'aid'
-    }));
-  })
-
-  describe(' Check for alternateBiddersList ', function() {
-    let bidRequest;
-    let bids1;
-    let logWarnSpy;
-    let bidderSettingStub, aliasRegistryStub;
-    let aliasRegistry;
 
-    beforeEach(function () {
-      bidRequest = {
+    it('should disregard auctionId/transactionId set by the adapter', () => {
+      let bidderRequest = {
         bids: [{
-          bidId: '1',
           bidder: CODE,
-          auctionId: 'first-bid-id',
-          adUnitCode: 'mock/placement',
-          transactionId: 'au',
+          bidId: '1',
+          auctionId: 'aid',
+          transactionId: 'tid',
+          adUnitCode: 'au',
         }]
       };
+      const bidder = newBidder(spec);
+      spec.interpretResponse.returns(Object.assign({}, bids[0], {transactionId: 'ignored', auctionId: 'ignored'}));
+      bidder.callBids(bidderRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+      sinon.assert.calledWith(addBidResponseStub, sinon.match.any, sinon.match({
+        transactionId: 'tid',
+        auctionId: 'aid'
+      }));
+    })
 
-      bids1 = Object.assign({},
-        bids[0],
-        {
-          bidderCode: 'validalternatebidder',
-          adapterCode: 'knownadapter1'
-        }
-      );
-      logWarnSpy = sinon.spy(utils, 'logWarn');
-      bidderSettingStub = sinon.stub(bidderSettings, 'get');
-      aliasRegistry = {};
-      aliasRegistryStub = sinon.stub(adapterManager, 'aliasRegistry');
-      aliasRegistryStub.get(() => aliasRegistry);
-    });
+    describe(' Check for alternateBiddersList ', function() {
+      let bidRequest;
+      let bids1;
+      let logWarnSpy;
+      let bidderSettingStub, aliasRegistryStub;
+      let aliasRegistry;
 
-    afterEach(function () {
-      logWarnSpy.restore();
-      bidderSettingStub.restore();
-      aliasRegistryStub.restore();
-    });
+      beforeEach(function () {
+        bidRequest = {
+          bids: [{
+            bidId: '1',
+            bidder: CODE,
+            auctionId: 'first-bid-id',
+            adUnitCode: 'mock/placement',
+            transactionId: 'au',
+          }]
+        };
 
-    it('should log warning when bidder is unknown and allowAlternateBidderCodes flag is false', function () {
-      bidderSettingStub.returns(false);
+        bids1 = Object.assign({},
+          bids[0],
+          {
+            bidderCode: 'validalternatebidder',
+            adapterCode: 'knownadapter1'
+          }
+        );
+        logWarnSpy = sinon.spy(utils, 'logWarn');
+        bidderSettingStub = sinon.stub(bidderSettings, 'get');
+        aliasRegistry = {};
+        aliasRegistryStub = sinon.stub(adapterManager, 'aliasRegistry');
+        aliasRegistryStub.get(() => aliasRegistry);
+      });
 
-      const bidder = newBidder(spec);
-      spec.interpretResponse.returns(bids1);
-      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+      afterEach(function () {
+        logWarnSpy.restore();
+        bidderSettingStub.restore();
+        aliasRegistryStub.restore();
+      });
 
-      expect(addBidResponseStub.called).to.equal(false);
-      expect(addBidResponseStub.reject.calledOnce).to.be.true;
-      expect(logWarnSpy.callCount).to.equal(1);
-    });
+      it('should log warning when bidder is unknown and allowAlternateBidderCodes flag is false', function () {
+        bidderSettingStub.returns(false);
 
-    it('should reject the bid, when allowAlternateBidderCodes flag is undefined (default should be false)', function () {
-      bidderSettingStub.returns(undefined);
+        const bidder = newBidder(spec);
+        spec.interpretResponse.returns(bids1);
+        bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-      const bidder = newBidder(spec);
-      spec.interpretResponse.returns(bids1);
-      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        expect(addBidResponseStub.called).to.equal(false);
+        expect(addBidResponseStub.reject.calledOnce).to.be.true;
+        expect(logWarnSpy.callCount).to.equal(1);
+      });
 
-      expect(addBidResponseStub.called).to.equal(false);
-      expect(addBidResponseStub.reject.calledOnce).to.be.true;
-    });
+      it('should reject the bid, when allowAlternateBidderCodes flag is undefined (default should be false)', function () {
+        bidderSettingStub.returns(undefined);
 
-    it('should log warning when the particular bidder is not specified in allowedAlternateBidderCodes and allowAlternateBidderCodes flag is true', function () {
-      bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
-      bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns(['invalidAlternateBidder02']);
+        const bidder = newBidder(spec);
+        spec.interpretResponse.returns(bids1);
+        bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-      const bidder = newBidder(spec);
-      spec.interpretResponse.returns(bids1);
-      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        expect(addBidResponseStub.called).to.equal(false);
+        expect(addBidResponseStub.reject.calledOnce).to.be.true;
+      });
 
-      expect(addBidResponseStub.called).to.equal(false);
-      expect(addBidResponseStub.reject.calledOnce).to.be.true;
-      expect(logWarnSpy.callCount).to.equal(1);
-    });
+      it('should log warning when the particular bidder is not specified in allowedAlternateBidderCodes and allowAlternateBidderCodes flag is true', function () {
+        bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
+        bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns(['invalidAlternateBidder02']);
 
-    it('should accept the bid, when allowedAlternateBidderCodes is empty and allowAlternateBidderCodes flag is true', function () {
-      bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
-      bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns();
+        const bidder = newBidder(spec);
+        spec.interpretResponse.returns(bids1);
+        bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-      const bidder = newBidder(spec);
-      spec.interpretResponse.returns(bids1);
-      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        expect(addBidResponseStub.called).to.equal(false);
+        expect(addBidResponseStub.reject.calledOnce).to.be.true;
+        expect(logWarnSpy.callCount).to.equal(1);
+      });
 
-      expect(addBidResponseStub.calledOnce).to.equal(true);
-      expect(logWarnSpy.callCount).to.equal(0);
-      expect(logErrorSpy.callCount).to.equal(0);
-    });
+      it('should accept the bid, when allowedAlternateBidderCodes is empty and allowAlternateBidderCodes flag is true', function () {
+        bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
+        bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns();
 
-    it('should accept the bid, when allowedAlternateBidderCodes is marked as * and allowAlternateBidderCodes flag is true', function () {
-      bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
-      bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns(['*']);
+        const bidder = newBidder(spec);
+        spec.interpretResponse.returns(bids1);
+        bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-      const bidder = newBidder(spec);
-      spec.interpretResponse.returns(bids1);
-      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        expect(addBidResponseStub.calledOnce).to.equal(true);
+        expect(logWarnSpy.callCount).to.equal(0);
+        expect(logErrorSpy.callCount).to.equal(0);
+      });
 
-      expect(addBidResponseStub.calledOnce).to.equal(true);
-      expect(logWarnSpy.callCount).to.equal(0);
-      expect(logErrorSpy.callCount).to.equal(0);
-    });
+      it('should accept the bid, when allowedAlternateBidderCodes is marked as * and allowAlternateBidderCodes flag is true', function () {
+        bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
+        bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns(['*']);
 
-    it('should accept the bid, when allowedAlternateBidderCodes is marked as * (with space) and allowAlternateBidderCodes flag is true', function () {
-      bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
-      bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns([' * ']);
+        const bidder = newBidder(spec);
+        spec.interpretResponse.returns(bids1);
+        bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-      const bidder = newBidder(spec);
-      spec.interpretResponse.returns(bids1);
-      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        expect(addBidResponseStub.calledOnce).to.equal(true);
+        expect(logWarnSpy.callCount).to.equal(0);
+        expect(logErrorSpy.callCount).to.equal(0);
+      });
 
-      expect(addBidResponseStub.calledOnce).to.equal(true);
-      expect(logWarnSpy.callCount).to.equal(0);
-      expect(logErrorSpy.callCount).to.equal(0);
-    });
+      it('should accept the bid, when allowedAlternateBidderCodes is marked as * (with space) and allowAlternateBidderCodes flag is true', function () {
+        bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
+        bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns([' * ']);
+
+        const bidder = newBidder(spec);
+        spec.interpretResponse.returns(bids1);
+        bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-    it('should not accept the bid, when allowedAlternateBidderCodes is marked as empty array and allowAlternateBidderCodes flag is true', function () {
-      bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
-      bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns([]);
+        expect(addBidResponseStub.calledOnce).to.equal(true);
+        expect(logWarnSpy.callCount).to.equal(0);
+        expect(logErrorSpy.callCount).to.equal(0);
+      });
 
-      const bidder = newBidder(spec);
-      spec.interpretResponse.returns(bids1);
-      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+      it('should not accept the bid, when allowedAlternateBidderCodes is marked as empty array and allowAlternateBidderCodes flag is true', function () {
+        bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
+        bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns([]);
 
-      expect(addBidResponseStub.called).to.equal(false);
-      expect(addBidResponseStub.reject.calledOnce).to.be.true;
-      expect(logWarnSpy.callCount).to.equal(1);
-    });
+        const bidder = newBidder(spec);
+        spec.interpretResponse.returns(bids1);
+        bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-    it('should accept the bid, when allowedAlternateBidderCodes contains bidder name and allowAlternateBidderCodes flag is true', function () {
-      bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
-      bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns(['validAlternateBidder']);
+        expect(addBidResponseStub.called).to.equal(false);
+        expect(addBidResponseStub.reject.calledOnce).to.be.true;
+        expect(logWarnSpy.callCount).to.equal(1);
+      });
 
-      const bidder = newBidder(spec);
-      spec.interpretResponse.returns(bids1);
-      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+      it('should accept the bid, when allowedAlternateBidderCodes contains bidder name and allowAlternateBidderCodes flag is true', function () {
+        bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
+        bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns(['validAlternateBidder']);
 
-      expect(addBidResponseStub.called).to.equal(true);
-      expect(logWarnSpy.callCount).to.equal(0);
-      expect(logErrorSpy.callCount).to.equal(0);
-    });
+        const bidder = newBidder(spec);
+        spec.interpretResponse.returns(bids1);
+        bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-    it('should not accept the bid, when bidder is an alias but bidderSetting is missing for the bidder. It should fallback to standard setting and reject the bid', function () {
-      bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(false);
-      aliasRegistry = {'validAlternateBidder': CODE};
+        expect(addBidResponseStub.called).to.equal(true);
+        expect(logWarnSpy.callCount).to.equal(0);
+        expect(logErrorSpy.callCount).to.equal(0);
+      });
 
-      const bidder = newBidder(spec);
-      spec.interpretResponse.returns(bids1);
-      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+      it('should not accept the bid, when bidder is an alias but bidderSetting is missing for the bidder. It should fallback to standard setting and reject the bid', function () {
+        bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(false);
+        aliasRegistry = {'validAlternateBidder': CODE};
 
-      expect(addBidResponseStub.called).to.equal(false);
-      expect(logWarnSpy.callCount).to.equal(1);
-      expect(addBidResponseStub.reject.calledOnce).to.be.true;
-    });
+        const bidder = newBidder(spec);
+        spec.interpretResponse.returns(bids1);
+        bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-    it('should not accept the bid, when bidderSetting is missing for the bidder. It should fallback to standard setting and reject the bid', function () {
-      bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(false);
+        expect(addBidResponseStub.called).to.equal(false);
+        expect(logWarnSpy.callCount).to.equal(1);
+        expect(addBidResponseStub.reject.calledOnce).to.be.true;
+      });
 
-      const bidder = newBidder(spec);
-      spec.interpretResponse.returns(bids1);
-      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+      it('should not accept the bid, when bidderSetting is missing for the bidder. It should fallback to standard setting and reject the bid', function () {
+        bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(false);
+
+        const bidder = newBidder(spec);
+        spec.interpretResponse.returns(bids1);
+        bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-      expect(addBidResponseStub.called).to.equal(false);
-      expect(addBidResponseStub.reject.calledOnce).to.be.true;
-      expect(logWarnSpy.callCount).to.equal(1);
+        expect(addBidResponseStub.called).to.equal(false);
+        expect(addBidResponseStub.reject.calledOnce).to.be.true;
+        expect(logWarnSpy.callCount).to.equal(1);
+      });
     });
-  });
 
-  describe('when interpretResponse returns BidderAuctionResponse', function() {
-    const bidRequest = {
-      bids: [{
+    describe('when interpretResponse returns BidderAuctionResponse', function() {
+      const bidRequest = {
+        auctionId: 'aid',
+        bids: [{
+          bidId: '1',
+          bidder: CODE,
+          auctionId: 'aid',
+          adUnitCode: 'mock/placement',
+          transactionId: 'au',
+        }]
+      };
+      const fledgeAuctionConfig = {
         bidId: '1',
-        bidder: CODE,
-        auctionId: 'first-bid-id',
-        adUnitCode: 'mock/placement',
-        transactionId: 'au',
-      }]
-    };
-    const fledgeAuctionConfig = {
-      bidId: '1',
-      config: {
-        foo: 'bar'
-      }
-    }
-    describe('when response has FLEDGE auction config', function() {
-      let fledgeStub;
-
-      function fledgeHook(next, ...args) {
-        fledgeStub(...args);
+        config: {
+          foo: 'bar'
+        }
       }
+      describe('when response has FLEDGE auction config', function() {
+        let fledgeStub;
 
-      before(() => {
-        addComponentAuction.before(fledgeHook);
-      });
+        function fledgeHook(next, ...args) {
+          fledgeStub(...args);
+        }
 
-      after(() => {
-        addComponentAuction.getHooks({hook: fledgeHook}).remove();
-      })
+        before(() => {
+          addComponentAuction.before(fledgeHook);
+        });
 
-      beforeEach(function () {
-        fledgeStub = sinon.stub();
-      });
+        after(() => {
+          addComponentAuction.getHooks({hook: fledgeHook}).remove();
+        })
 
-      it('should unwrap bids', function() {
-        const bidder = newBidder(spec);
-        spec.interpretResponse.returns({
-          bids: bids,
-          fledgeAuctionConfigs: []
+        beforeEach(function () {
+          fledgeStub = sinon.stub();
         });
-        bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
-        expect(addBidResponseStub.calledOnce).to.equal(true);
-        expect(addBidResponseStub.firstCall.args[0]).to.equal('mock/placement');
-      });
 
-      it('should call fledgeManager with FLEDGE configs', function() {
-        const bidder = newBidder(spec);
-        spec.interpretResponse.returns({
-          bids: bids,
-          fledgeAuctionConfigs: [fledgeAuctionConfig]
+        it('should unwrap bids', function() {
+          const bidder = newBidder(spec);
+          spec.interpretResponse.returns({
+            bids: bids,
+            fledgeAuctionConfigs: []
+          });
+          bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+          expect(addBidResponseStub.calledOnce).to.equal(true);
+          expect(addBidResponseStub.firstCall.args[0]).to.equal('mock/placement');
         });
-        bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-        expect(fledgeStub.calledOnce).to.equal(true);
-        sinon.assert.calledWith(fledgeStub, 'mock/placement', fledgeAuctionConfig.config);
-        expect(addBidResponseStub.calledOnce).to.equal(true);
-        expect(addBidResponseStub.firstCall.args[0]).to.equal('mock/placement');
-      })
+        it('should call fledgeManager with FLEDGE configs', function() {
+          const bidder = newBidder(spec);
+          spec.interpretResponse.returns({
+            bids: bids,
+            fledgeAuctionConfigs: [fledgeAuctionConfig]
+          });
+          bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-      it('should call fledgeManager with FLEDGE configs even if no bids returned', function() {
-        const bidder = newBidder(spec);
-        spec.interpretResponse.returns({
-          bids: [],
-          fledgeAuctionConfigs: [fledgeAuctionConfig]
-        });
-        bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+          expect(fledgeStub.calledOnce).to.equal(true);
+          sinon.assert.calledWith(fledgeStub, bidRequest.auctionId, 'mock/placement', fledgeAuctionConfig.config);
+          expect(addBidResponseStub.calledOnce).to.equal(true);
+          expect(addBidResponseStub.firstCall.args[0]).to.equal('mock/placement');
+        })
 
-        expect(fledgeStub.calledOnce).to.be.true;
-        sinon.assert.calledWith(fledgeStub, 'mock/placement', fledgeAuctionConfig.config);
-        expect(addBidResponseStub.calledOnce).to.equal(false);
+        it('should call fledgeManager with FLEDGE configs even if no bids returned', function() {
+          const bidder = newBidder(spec);
+          spec.interpretResponse.returns({
+            bids: [],
+            fledgeAuctionConfigs: [fledgeAuctionConfig]
+          });
+          bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+          expect(fledgeStub.calledOnce).to.be.true;
+          sinon.assert.calledWith(fledgeStub, bidRequest.auctionId, 'mock/placement', fledgeAuctionConfig.config);
+          expect(addBidResponseStub.calledOnce).to.equal(false);
+        })
       })
     })
-  })
-});
+  });
 
-describe('bid response isValid', () => {
-  describe('size check', () => {
-    let req, index;
+  describe('bid response isValid', () => {
+    describe('size check', () => {
+      let req, index;
 
-    beforeEach(() => {
-      req = {
-        ...MOCK_BIDS_REQUEST.bids[0],
-        mediaTypes: {
-          banner: {
-            sizes: [[1, 2], [3, 4]]
+      beforeEach(() => {
+        req = {
+          ...MOCK_BIDS_REQUEST.bids[0],
+          mediaTypes: {
+            banner: {
+              sizes: [[1, 2], [3, 4]]
+            }
           }
         }
-      }
-    });
+      });
 
-    function mkResponse(width, height) {
-      return {
-        requestId: req.bidId,
-        width,
-        height,
-        cpm: 1,
-        ttl: 60,
-        creativeId: '123',
-        netRevenue: true,
-        currency: 'USD',
-        mediaType: 'banner',
+      function mkResponse(width, height) {
+        return {
+          requestId: req.bidId,
+          width,
+          height,
+          cpm: 1,
+          ttl: 60,
+          creativeId: '123',
+          netRevenue: true,
+          currency: 'USD',
+          mediaType: 'banner',
+        }
       }
-    }
 
-    function checkValid(bid) {
-      return isValid('au', bid, {index: stubAuctionIndex({bidRequests: [req]})});
-    }
+      function checkValid(bid) {
+        return isValid('au', bid, {index: stubAuctionIndex({bidRequests: [req]})});
+      }
 
-    it('should succeed when response has a size that was in request', () => {
-      expect(checkValid(mkResponse(3, 4))).to.be.true;
-    });
-  })
-});
+      it('should succeed when response has a size that was in request', () => {
+        expect(checkValid(mkResponse(3, 4))).to.be.true;
+      });
+    })
+  });
+})
diff --git a/test/spec/unit/core/targeting_spec.js b/test/spec/unit/core/targeting_spec.js
index f16d6208087..4716e5749cb 100644
--- a/test/spec/unit/core/targeting_spec.js
+++ b/test/spec/unit/core/targeting_spec.js
@@ -1,13 +1,19 @@
-import { expect } from 'chai';
-import { targeting as targetingInstance, filters, getHighestCpmBidsFromBidPool, sortByDealAndPriceBucketOrCpm } from 'src/targeting.js';
-import { config } from 'src/config.js';
-import { createBidReceived } from 'test/fixtures/fixtures.js';
+import {expect} from 'chai';
+import {
+  filters,
+  getHighestCpmBidsFromBidPool,
+  sortByDealAndPriceBucketOrCpm,
+  targeting as targetingInstance
+} from 'src/targeting.js';
+import {config} from 'src/config.js';
+import {createBidReceived} from 'test/fixtures/fixtures.js';
 import CONSTANTS from 'src/constants.json';
-import { auctionManager } from 'src/auctionManager.js';
+import {auctionManager} from 'src/auctionManager.js';
 import * as utils from 'src/utils.js';
 import {deepClone} from 'src/utils.js';
 import {createBid} from '../../../../src/bidfactory.js';
 import {hook} from '../../../../src/hook.js';
+import {getHighestCpm} from '../../../../src/utils/reducers.js';
 
 function mkBid(bid, status = CONSTANTS.STATUS.GOOD) {
   return Object.assign(createBid(status), bid);
@@ -451,7 +457,7 @@ describe('targeting tests', function () {
           }
         });
 
-        const bids = getHighestCpmBidsFromBidPool(bidsReceived, utils.getHighestCpm, 2);
+        const bids = getHighestCpmBidsFromBidPool(bidsReceived, getHighestCpm, 2);
 
         expect(bids.length).to.equal(3);
         expect(bids[0].adId).to.equal('8383838');
@@ -467,7 +473,7 @@ describe('targeting tests', function () {
           }
         });
 
-        const bids = getHighestCpmBidsFromBidPool(bidsReceived, utils.getHighestCpm, 2);
+        const bids = getHighestCpmBidsFromBidPool(bidsReceived, getHighestCpm, 2);
 
         expect(bids.length).to.equal(3);
         expect(bids[0].adId).to.equal('8383838');
diff --git a/test/spec/unit/utils/reducers_spec.js b/test/spec/unit/utils/reducers_spec.js
new file mode 100644
index 00000000000..95bf3b74041
--- /dev/null
+++ b/test/spec/unit/utils/reducers_spec.js
@@ -0,0 +1,124 @@
+import {
+  tiebreakCompare,
+  keyCompare,
+  simpleCompare,
+  minimum,
+  maximum,
+  getHighestCpm,
+  getOldestHighestCpmBid, getLatestHighestCpmBid, reverseCompare
+} from '../../../../src/utils/reducers.js';
+import assert from 'assert';
+
+describe('reducers', () => {
+  describe('simpleCompare', () => {
+    Object.entries({
+      '<': [10, 20, -1],
+      '===': [123, 123, 0],
+      '>': [30, -10, 1]
+    }).forEach(([t, [a, b, expected]]) => {
+      it(`returns ${expected} when a ${t} b`, () => {
+        expect(simpleCompare(a, b)).to.equal(expected);
+      })
+    })
+  });
+
+  describe('keyCompare', () => {
+    Object.entries({
+      '<': [{k: -123}, {k: 0}, -1],
+      '===': [{k: 0}, {k: 0}, 0],
+      '>': [{k: 2}, {k: 1}, 1]
+    }).forEach(([t, [a, b, expected]]) => {
+      it(`returns ${expected} when key(a) ${t} key(b)`, () => {
+        expect(keyCompare(item => item.k)(a, b)).to.equal(expected);
+      })
+    })
+  });
+
+  describe('tiebreakCompare', () => {
+    Object.entries({
+      'first compare says a < b': [{main: 1, tie: 2}, {main: 2, tie: 1}, -1],
+      'first compare says a > b': [{main: 2, tie: 1}, {main: 1, tie: 2}, 1],
+      'first compare ties, second says a < b': [{main: 0, tie: 1}, {main: 0, tie: 2}, -1],
+      'first compare ties, second says a > b': [{main: 0, tie: 2}, {main: 0, tie: 1}, 1],
+      'all compares tie': [{main: 0, tie: 0}, {main: 0, tie: 0}, 0]
+    }).forEach(([t, [a, b, expected]]) => {
+      it(`should return ${expected} when ${t}`, () => {
+        const cmp = tiebreakCompare(keyCompare(item => item.main), keyCompare(item => item.tie));
+        expect(cmp(a, b)).to.equal(expected);
+      })
+    })
+  });
+
+  const SAMPLE_ARR = [-10, 20, 20, 123, 400];
+
+  Object.entries({
+    'minimum': [minimum, ['minimum', -10], ['maximum', 400]],
+    'maximum': [maximum, ['maximum', 400], ['minimum', -10]]
+  }).forEach(([t, [fn, simple, reversed]]) => {
+    describe(t, () => {
+      it(`should find ${simple[0]} using simple compare`, () => {
+        expect(SAMPLE_ARR.reduce(fn(simpleCompare))).to.equal(simple[1]);
+      });
+      it(`should find ${reversed[0]} using reverse compare`, () => {
+        expect(SAMPLE_ARR.reduce(fn(reverseCompare()))).to.equal(reversed[1]);
+      });
+    })
+  });
+
+  describe('getHighestCpm', function () {
+    it('should pick the highest cpm', function () {
+      let a = {
+        cpm: 2,
+        timeToRespond: 100
+      };
+      let b = {
+        cpm: 1,
+        timeToRespond: 100
+      };
+      expect(getHighestCpm(a, b)).to.eql(a);
+      expect(getHighestCpm(b, a)).to.eql(a);
+    });
+
+    it('should pick the lowest timeToRespond cpm in case of tie', function () {
+      let a = {
+        cpm: 1,
+        timeToRespond: 100
+      };
+      let b = {
+        cpm: 1,
+        timeToRespond: 50
+      };
+      expect(getHighestCpm(a, b)).to.eql(b);
+      expect(getHighestCpm(b, a)).to.eql(b);
+    });
+  });
+
+  describe('getOldestHighestCpmBid', () => {
+    it('should pick the oldest in case of tie using responseTimeStamp', function () {
+      let a = {
+        cpm: 1,
+        responseTimestamp: 1000
+      };
+      let b = {
+        cpm: 1,
+        responseTimestamp: 2000
+      };
+      expect(getOldestHighestCpmBid(a, b)).to.eql(a);
+      expect(getOldestHighestCpmBid(b, a)).to.eql(a);
+    });
+  });
+  describe('getLatestHighestCpmBid', () => {
+    it('should pick the latest in case of tie using responseTimeStamp', function () {
+      let a = {
+        cpm: 1,
+        responseTimestamp: 1000
+      };
+      let b = {
+        cpm: 1,
+        responseTimestamp: 2000
+      };
+      expect(getLatestHighestCpmBid(a, b)).to.eql(b);
+      expect(getLatestHighestCpmBid(b, a)).to.eql(b);
+    });
+  });
+})
diff --git a/test/spec/utils_spec.js b/test/spec/utils_spec.js
index 6e7f8ba0e8f..40126f7f20c 100644
--- a/test/spec/utils_spec.js
+++ b/test/spec/utils_spec.js
@@ -2,6 +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 {getHighestCpm, getLatestHighestCpmBid, getOldestHighestCpmBid} from '../../src/utils/reducers.js';
 import {binarySearch, deepEqual, memoize, waitForElementToLoad} from 'src/utils.js';
 
 var assert = require('assert');
@@ -538,72 +539,6 @@ describe('Utils', function () {
     });
   });
 
-  describe('getHighestCpm', function () {
-    it('should pick the existing highest cpm', function () {
-      let previous = {
-        cpm: 2,
-        timeToRespond: 100
-      };
-      let current = {
-        cpm: 1,
-        timeToRespond: 100
-      };
-      assert.equal(utils.getHighestCpm(previous, current), previous);
-    });
-
-    it('should pick the new highest cpm', function () {
-      let previous = {
-        cpm: 1,
-        timeToRespond: 100
-      };
-      let current = {
-        cpm: 2,
-        timeToRespond: 100
-      };
-      assert.equal(utils.getHighestCpm(previous, current), current);
-    });
-
-    it('should pick the fastest cpm in case of tie', function () {
-      let previous = {
-        cpm: 1,
-        timeToRespond: 100
-      };
-      let current = {
-        cpm: 1,
-        timeToRespond: 50
-      };
-      assert.equal(utils.getHighestCpm(previous, current), current);
-    });
-
-    it('should pick the oldest in case of tie using responseTimeStamp', function () {
-      let previous = {
-        cpm: 1,
-        timeToRespond: 100,
-        responseTimestamp: 1000
-      };
-      let current = {
-        cpm: 1,
-        timeToRespond: 50,
-        responseTimestamp: 2000
-      };
-      assert.equal(utils.getOldestHighestCpmBid(previous, current), previous);
-    });
-
-    it('should pick the latest in case of tie using responseTimeStamp', function () {
-      let previous = {
-        cpm: 1,
-        timeToRespond: 100,
-        responseTimestamp: 1000
-      };
-      let current = {
-        cpm: 1,
-        timeToRespond: 50,
-        responseTimestamp: 2000
-      };
-      assert.equal(utils.getLatestHighestCpmBid(previous, current), current);
-    });
-  });
-
   describe('polyfill test', function () {
     it('should not add polyfill to array', function() {
       var arr = ['hello', 'world'];

From 425cf20b55c8b1cccae5cc66157ce7154d091c94 Mon Sep 17 00:00:00 2001
From: Demetrio Girardi <dgirardi@prebid.org>
Date: Thu, 14 Sep 2023 12:01:42 -0700
Subject: [PATCH 44/46] userId: group UIDs by source when possible (#10488)

---
 modules/userId/eids.js           | 37 ++++++-----------
 test/spec/modules/userId_spec.js | 69 ++++++++++++++++++++++++++++++++
 2 files changed, 82 insertions(+), 24 deletions(-)

diff --git a/modules/userId/eids.js b/modules/userId/eids.js
index dc362b41136..aad570f20df 100644
--- a/modules/userId/eids.js
+++ b/modules/userId/eids.js
@@ -32,34 +32,23 @@ function createEidObject(userIdData, subModuleKey) {
   return null;
 }
 
-// this function will generate eids array for all available IDs in bidRequest.userId
-// this function will be called by userId module
-// if any adapter does not want any particular userId to be passed then adapter can use Array.filter(e => e.source != 'tdid')
 export function createEidsArray(bidRequestUserId) {
-  let eids = [];
-
-  for (const subModuleKey in bidRequestUserId) {
-    if (bidRequestUserId.hasOwnProperty(subModuleKey)) {
-      if (subModuleKey === 'pubProvidedId') {
-        eids = eids.concat(bidRequestUserId['pubProvidedId']);
-      } else if (Array.isArray(bidRequestUserId[subModuleKey])) {
-        bidRequestUserId[subModuleKey].forEach((config, index, arr) => {
-          const eid = createEidObject(config, subModuleKey);
-
-          if (eid) {
-            eids.push(eid);
-          }
-        })
-      } else {
-        const eid = createEidObject(bidRequestUserId[subModuleKey], subModuleKey);
-        if (eid) {
-          eids.push(eid);
-        }
-      }
+  const allEids = {};
+  function collect(eid) {
+    const key = JSON.stringify([eid.source?.toLowerCase(), eid.ext]);
+    if (allEids.hasOwnProperty(key)) {
+      allEids[key].uids.push(...eid.uids);
+    } else {
+      allEids[key] = eid;
     }
   }
 
-  return eids;
+  Object.entries(bidRequestUserId).forEach(([name, values]) => {
+    values = Array.isArray(values) ? values : [values];
+    const eids = name === 'pubProvidedId' ? values : values.map(value => createEidObject(value, name));
+    eids.filter(eid => eid != null).forEach(collect);
+  })
+  return Object.values(allEids);
 }
 
 /**
diff --git a/test/spec/modules/userId_spec.js b/test/spec/modules/userId_spec.js
index 6a2d259fdd7..17a865796a2 100644
--- a/test/spec/modules/userId_spec.js
+++ b/test/spec/modules/userId_spec.js
@@ -382,6 +382,75 @@ describe('User ID', function () {
       });
     });
 
+    describe('createEidsArray', () => {
+      beforeEach(() => {
+        init(config);
+        setSubmoduleRegistry([
+          createMockIdSubmodule('mockId1', null, null,
+            {'mockId1': {source: 'mock1source', atype: 1}}),
+          createMockIdSubmodule('mockId2v1', null, null,
+            {'mockId2v1': {source: 'mock2source', atype: 2, getEidExt: () => ({v: 1})}}),
+          createMockIdSubmodule('mockId2v2', null, null,
+            {'mockId2v2': {source: 'mock2source', atype: 2, getEidExt: () => ({v: 2})}}),
+        ]);
+      });
+
+      it('should group UIDs by source and ext', () => {
+        const eids = createEidsArray({
+          mockId1: ['mock-1-1', 'mock-1-2'],
+          mockId2v1: ['mock-2-1', 'mock-2-2'],
+          mockId2v2: ['mock-2-1', 'mock-2-2']
+        });
+        expect(eids).to.eql([
+          {
+            source: 'mock1source',
+            uids: [
+              {
+                id: 'mock-1-1',
+                atype: 1,
+              },
+              {
+                id: 'mock-1-2',
+                atype: 1,
+              }
+            ]
+          },
+          {
+            source: 'mock2source',
+            ext: {
+              v: 1
+            },
+            uids: [
+              {
+                id: 'mock-2-1',
+                atype: 2,
+              },
+              {
+                id: 'mock-2-2',
+                atype: 2,
+              }
+            ]
+          },
+          {
+            source: 'mock2source',
+            ext: {
+              v: 2
+            },
+            uids: [
+              {
+                id: 'mock-2-1',
+                atype: 2,
+              },
+              {
+                id: 'mock-2-2',
+                atype: 2,
+              }
+            ]
+          }
+        ])
+      })
+    })
+
     it('pbjs.getUserIds', function (done) {
       init(config);
       setSubmoduleRegistry([sharedIdSystemSubmodule]);

From 7810865a1841374e3495b134d14596da4418938d Mon Sep 17 00:00:00 2001
From: Demetrio Girardi <dgirardi@prebid.org>
Date: Fri, 15 Sep 2023 06:05:07 -0700
Subject: [PATCH 45/46] integration examples: add native example without
 adserver (#10490)

---
 .../gpt/prebidServer_native_example.html      |   2 +-
 .../noadserver/native_noadserver.html         | 173 ++++++++++++++++++
 2 files changed, 174 insertions(+), 1 deletion(-)
 create mode 100755 integrationExamples/noadserver/native_noadserver.html

diff --git a/integrationExamples/gpt/prebidServer_native_example.html b/integrationExamples/gpt/prebidServer_native_example.html
index c590f0bcee5..a5fb0ffa894 100644
--- a/integrationExamples/gpt/prebidServer_native_example.html
+++ b/integrationExamples/gpt/prebidServer_native_example.html
@@ -114,7 +114,7 @@
         s2sConfig: {
           accountId: '1',
           enabled: true, //default value set to false
-          bidders: ['appnexus'],
+          bidders: ['appnexuspsp'],
           timeout: 1000, //default value is 1000
           adapter: 'prebidServer', //if we have any other s2s adapter, default value is s2s
           endpoint: 'https://prebid.adnxs.com/pbs/v1/openrtb2/auction'
diff --git a/integrationExamples/noadserver/native_noadserver.html b/integrationExamples/noadserver/native_noadserver.html
new file mode 100755
index 00000000000..81c71d2acfd
--- /dev/null
+++ b/integrationExamples/noadserver/native_noadserver.html
@@ -0,0 +1,173 @@
+<html>
+
+<head>
+    <script type="text/javascript" src="../../build/dev/prebid.js" async></script>
+
+    <script>
+        var pbjs = pbjs || {};
+        pbjs.que = pbjs.que || [];
+
+        pbjs.que.push(function () {
+            const adUnits = [{
+                code: 'native-div',
+                mediaTypes: {
+                    native: {
+                        adTemplate: document.getElementById('native-template').innerHTML,
+                        title: {
+                            required: true,
+                            len: 800
+                        },
+                        image: {
+                            required: true,
+                            sizes: [989, 742],
+                        },
+                        sponsoredBy: {
+                            required: true
+                        }
+                    }
+                },
+                bids: [{
+                    bidder: 'appnexus',
+                    params: {
+                        placementId: 13232354,
+                        allowSmallerSizes: true
+                    }
+
+                }]
+            }];
+
+            pbjs.setConfig({
+                debug: true,
+                s2sConfig: {
+                    accountId: '1',
+                    enabled: true,
+                    bidders: ['appnexuspsp'],
+                    timeout: 1000,
+                    adapter: 'prebidServer',
+                    endpoint: 'https://ib.adnxs.com/openrtb2/prebid',
+                }
+            });
+
+            pbjs.requestBids({
+                adUnits,
+                bidsBackHandler: function (bidResponses) {
+                    Object.entries(bidResponses).forEach(([slot, {bids}]) => {
+                        bids?.length && renderNative(slot, bids[0]);
+                    });
+                }
+            });
+
+            function renderNative(divId, bid) {
+                const slot = document.getElementById(divId);
+                const content = `
+                    <!DOCTYPE html>
+                    <html>
+                        <body>
+                            <script src="https://cdn.jsdelivr.net/npm/prebid-universal-creative@latest/dist/native-render.js"> <\/script>
+                            <script>
+                                window.pbNativeData = {
+                                    pubUrl: '${encodeURI(document.location)}',
+                                    adId: '${bid.adId}',
+                                    requestAllAssets: true
+                                };
+                                pbNativeTag.renderNativeAd(pbNativeData);
+                            <\/script>
+                        </body>
+                    </html>
+                `;
+
+                const iframe = document.createElement('iframe');
+                slot.appendChild(iframe);
+                Object.entries({
+                    frameBorder: 0,
+                    marginWidth: 0,
+                    marginHeight: 0,
+                    srcdoc: content
+                }).forEach(([prop, val]) => iframe.setAttribute(prop, val));
+            }
+        });
+
+    </script>
+
+</head>
+
+<body>
+
+<template id="native-template">
+    <style>
+        body {
+            display: inline-block;
+        }
+
+        .container {
+            display: inline-block;
+            font-family: "Helvetica Neue",Helvetica,Arial,sans-serif;
+            font-size: 14px;
+            line-height: 1.42857143;
+            color: #333;
+            background: #fff url(##hb_native_image##) no-repeat center;
+            background-size: cover;
+        }
+
+
+        .card {
+            border: 4px solid #ffd724;
+            display: inline-block;
+            padding: 20px;
+            height: 300px;
+            width: 320px;
+        }
+
+
+        h1 a:link, a:active, a:visited, a:hover, a:focus {
+            text-decoration: none;
+            color: #fff;
+        }
+
+        h1 {
+            line-height: 1.3;
+            color: #fff;
+            font-size: 26px;
+            background-color: rgba(0, 0, 0, 0.7);
+            display: inline;
+            font-family: Roboto, serif;
+            font-weight: 100;
+        }
+
+        .attribution {
+            color: #fff;
+            display: inline-block;
+            letter-spacing: 2px;
+            background-color: #ffd724;
+            font-size: 12px;
+            line-height: 1;
+            padding: 6px 6px 0 6px;
+            height: 24px;
+            margin: 5px 0 10px 0;
+            border-radius: 4px;
+        }
+    </style>
+    <div class="container">
+        <div class="card">
+            <div class="title">
+                <h1>
+                    <a href="##hb_native_linkurl##">##hb_native_title##</a>
+                </h1>
+            </div>
+            <div class="attribution">
+                ##hb_native_brand##
+            </div>
+        </div>
+    </div>
+</template>
+
+<h2>Prebid Native</h2>
+<div id='native-div'>
+</div>
+
+<br>
+<br>
+
+</body>
+
+</html>

From 5fc475ed7423dcc295dafc6a552097b191f049d5 Mon Sep 17 00:00:00 2001
From: Demetrio Girardi <dgirardi@prebid.org>
Date: Fri, 15 Sep 2023 06:43:23 -0700
Subject: [PATCH 46/46] priceFloors: fix bug where `default` does not work on
 adUnit-level floors (#10475)

* priceFloors: fix bug where `default` does not work on adUnit-level floors

* do not require adUnits to repeat the same schema

* Improve schema selection and validation for adUnit-level floors
---
 modules/priceFloors.js                |  49 +++++--
 test/spec/modules/priceFloors_spec.js | 183 ++++++++++++++++++++++++--
 2 files changed, 211 insertions(+), 21 deletions(-)

diff --git a/modules/priceFloors.js b/modules/priceFloors.js
index a72a79c2b40..e62e615ea86 100644
--- a/modules/priceFloors.js
+++ b/modules/priceFloors.js
@@ -13,7 +13,8 @@ import {
   mergeDeep,
   parseGPTSingleSizeArray,
   parseUrl,
-  pick
+  pick,
+  deepEqual
 } from '../src/utils.js';
 import {getGlobal} from '../src/prebidGlobal.js';
 import {config} from '../src/config.js';
@@ -40,10 +41,13 @@ const MODULE_NAME = 'Price Floors';
  */
 const ajax = ajaxBuilder(10000);
 
+// eslint-disable-next-line symbol-description
+const SYN_FIELD = Symbol();
+
 /**
  * @summary Allowed fields for rules to have
  */
-export let allowedFields = ['gptSlot', 'adUnitCode', 'size', 'domain', 'mediaType'];
+export let allowedFields = [SYN_FIELD, 'gptSlot', 'adUnitCode', 'size', 'domain', 'mediaType'];
 
 /**
  * @summary This is a flag to indicate if a AJAX call is processing for a floors request
@@ -104,6 +108,7 @@ function getAdUnitCode(request, response, {index = auctionManager.index} = {}) {
  * @summary floor field types with their matching functions to resolve the actual matched value
  */
 export let fieldMatchingFunctions = {
+  [SYN_FIELD]: () => '*',
   'size': (bidRequest, bidResponse) => parseGPTSingleSizeArray(bidResponse.size) || '*',
   'mediaType': (bidRequest, bidResponse) => bidResponse.mediaType || 'banner',
   'gptSlot': (bidRequest, bidResponse) => getGptSlotFromAdUnit((bidRequest || bidResponse).transactionId) || getGptSlotInfoForAdUnitCode(getAdUnitCode(bidRequest, bidResponse)).gptSlot,
@@ -117,6 +122,7 @@ export let fieldMatchingFunctions = {
  * Returns array of Tuple [exact match, catch all] for each field in rules file
  */
 function enumeratePossibleFieldValues(floorFields, bidObject, responseObject) {
+  if (!floorFields.length) return [];
   // generate combination of all exact matches and catch all for each field type
   return floorFields.reduce((accum, field) => {
     let exactMatch = fieldMatchingFunctions[field](bidObject, responseObject) || '*';
@@ -132,7 +138,9 @@ function enumeratePossibleFieldValues(floorFields, bidObject, responseObject) {
  */
 export function getFirstMatchingFloor(floorData, bidObject, responseObject = {}) {
   let fieldValues = enumeratePossibleFieldValues(deepAccess(floorData, 'schema.fields') || [], bidObject, responseObject);
-  if (!fieldValues.length) return { matchingFloor: floorData.default };
+  if (!fieldValues.length) {
+    return {matchingFloor: undefined}
+  }
 
   // look to see if a request for this context was made already
   let matchingInput = fieldValues.map(field => field[0]).join('-');
@@ -146,9 +154,9 @@ export function getFirstMatchingFloor(floorData, bidObject, responseObject = {})
 
   let matchingData = {
     floorMin: floorData.floorMin || 0,
-    floorRuleValue: isNaN(floorData.values[matchingRule]) ? floorData.default : floorData.values[matchingRule],
+    floorRuleValue: floorData.values[matchingRule],
     matchingData: allPossibleMatches[0], // the first possible match is an "exact" so contains all data relevant for anlaytics adapters
-    matchingRule
+    matchingRule: matchingRule === floorData.meta?.defaultRule ? undefined : matchingRule
   };
   // use adUnit floorMin as priority!
   const floorMin = deepAccess(bidObject, 'ortb2Imp.ext.prebid.floors.floorMin');
@@ -300,14 +308,20 @@ function normalizeRulesForAuction(floorData, adUnitCode) {
  * Only called if no set config or fetch level data has returned
  */
 export function getFloorDataFromAdUnits(adUnits) {
+  const schemaAu = adUnits.find(au => au.floors?.schema != null);
   return adUnits.reduce((accum, adUnit) => {
-    if (isFloorsDataValid(adUnit.floors)) {
+    if (adUnit.floors?.schema != null && !deepEqual(adUnit.floors.schema, schemaAu?.floors?.schema)) {
+      logError(`${MODULE_NAME}: adUnit '${adUnit.code}' declares a different schema from one previously declared by adUnit '${schemaAu.code}'. Floor config for '${adUnit.code}' will be ignored.`)
+      return accum;
+    }
+    const floors = Object.assign({}, schemaAu?.floors, {values: undefined}, adUnit.floors)
+    if (isFloorsDataValid(floors)) {
       // if values already exist we want to not overwrite them
       if (!accum.values) {
-        accum = getFloorsDataForAuction(adUnit.floors, adUnit.code);
+        accum = getFloorsDataForAuction(floors, adUnit.code);
         accum.location = 'adUnit';
       } else {
-        let newRules = getFloorsDataForAuction(adUnit.floors, adUnit.code).values;
+        let newRules = getFloorsDataForAuction(floors, adUnit.code).values;
         // copy over the new rules into our values object
         Object.assign(accum.values, newRules);
       }
@@ -443,7 +457,26 @@ function validateRules(floorsData, numFields, delimiter) {
   return Object.keys(floorsData.values).length > 0;
 }
 
+export function normalizeDefault(model) {
+  if (isNumber(model.default)) {
+    let defaultRule = '*';
+    const numFields = (model.schema?.fields || []).length;
+    if (!numFields) {
+      deepSetValue(model, 'schema.fields', [SYN_FIELD]);
+    } else {
+      defaultRule = Array(numFields).fill('*').join(model.schema?.delimiter || '|');
+    }
+    model.values = model.values || {};
+    if (model.values[defaultRule] == null) {
+      model.values[defaultRule] = model.default;
+      model.meta = {defaultRule};
+    }
+  }
+  return model;
+}
+
 function modelIsValid(model) {
+  model = normalizeDefault(model);
   // schema.fields has only allowed attributes
   if (!validateSchemaFields(deepAccess(model, 'schema.fields'))) {
     return false;
diff --git a/test/spec/modules/priceFloors_spec.js b/test/spec/modules/priceFloors_spec.js
index e2b8ca38792..950e039491d 100644
--- a/test/spec/modules/priceFloors_spec.js
+++ b/test/spec/modules/priceFloors_spec.js
@@ -12,7 +12,7 @@ import {
   isFloorsDataValid,
   addBidResponseHook,
   fieldMatchingFunctions,
-  allowedFields
+  allowedFields, parseFloorData, normalizeDefault, getFloorDataFromAdUnits
 } from 'modules/priceFloors.js';
 import * as events from 'src/events.js';
 import * as mockGpt from '../integration/faker/googletag.js';
@@ -123,7 +123,7 @@ describe('the price floors module', function () {
     return {
       code,
       mediaTypes: {banner: { sizes: [[300, 200], [300, 600]] }, native: {}},
-      bids: [{bidder: 'someBidder'}, {bidder: 'someOtherBidder'}]
+      bids: [{bidder: 'someBidder', adUnitCode: code}, {bidder: 'someOtherBidder', adUnitCode: code}]
     };
   }
   beforeEach(function() {
@@ -143,6 +143,76 @@ describe('the price floors module', function () {
     getGlobal().bidderSettings = {};
   });
 
+  describe('parseFloorData', () => {
+    it('should accept just a default floor', () => {
+      const fd = parseFloorData({
+        default: 1.23
+      });
+      expect(getFirstMatchingFloor(fd, {}, {}).matchingFloor).to.eql(1.23);
+    });
+  });
+
+  describe('getFloorDataFromAdUnits', () => {
+    let adUnits;
+
+    function setFloorValues(rule) {
+      adUnits.forEach((au, i) => {
+        au.floors = {
+          values: {
+            [rule]: i + 1
+          }
+        }
+      })
+    }
+
+    beforeEach(() => {
+      adUnits = ['au1', 'au2', 'au3'].map(getAdUnitMock);
+    })
+
+    it('should use one schema for all adUnits', () => {
+      setFloorValues('*;*')
+      adUnits[1].floors.schema = {
+        fields: ['mediaType', 'gptSlot'],
+        delimiter: ';'
+      }
+      sinon.assert.match(getFloorDataFromAdUnits(adUnits), {
+        schema: {
+          fields: ['adUnitCode', 'mediaType', 'gptSlot'],
+          delimiter: ';'
+        },
+        values: {
+          'au1;*;*': 1,
+          'au2;*;*': 2,
+          'au3;*;*': 3
+        }
+      })
+    });
+    it('should ignore adUnits that declare different schema', () => {
+      setFloorValues('*|*');
+      adUnits[0].floors.schema = {
+        fields: ['mediaType', 'gptSlot']
+      };
+      adUnits[2].floors.schema = {
+        fields: ['gptSlot', 'mediaType']
+      };
+      expect(getFloorDataFromAdUnits(adUnits).values).to.eql({
+        'au1|*|*': 1,
+        'au2|*|*': 2
+      })
+    });
+    it('should ignore adUnits that declare no values', () => {
+      setFloorValues('*');
+      adUnits[0].floors.schema = {
+        fields: ['mediaType']
+      };
+      delete adUnits[2].floors.values;
+      expect(getFloorDataFromAdUnits(adUnits).values).to.eql({
+        'au1|*': 1,
+        'au2|*': 2,
+      })
+    })
+  })
+
   describe('getFloorsDataForAuction', function () {
     it('converts basic input floor data into a floorData map for the auction correctly', function () {
       // basic input where nothing needs to be updated
@@ -233,8 +303,8 @@ describe('the price floors module', function () {
   });
 
   describe('getFirstMatchingFloor', function () {
-    it('uses a 0 floor as overrite', function () {
-      let inputFloorData = {
+    it('uses a 0 floor as override', function () {
+      let inputFloorData = normalizeDefault({
         currency: 'USD',
         schema: {
           delimiter: '|',
@@ -245,7 +315,7 @@ describe('the price floors module', function () {
           'test_div_2': 2
         },
         default: 0.5
-      };
+      });
 
       expect(getFirstMatchingFloor(inputFloorData, basicBidRequest, {mediaType: 'banner', size: '*'})).to.deep.equal({
         floorMin: 0,
@@ -434,7 +504,7 @@ describe('the price floors module', function () {
       });
     });
     it('selects the right floor for more complex rules', function () {
-      let inputFloorData = {
+      let inputFloorData = normalizeDefault({
         currency: 'USD',
         schema: {
           delimiter: '^',
@@ -448,7 +518,7 @@ describe('the price floors module', function () {
           'weird_div^*^300x250': 5.5
         },
         default: 0.5
-      };
+      });
       // banner with 300x250 size
       expect(getFirstMatchingFloor(inputFloorData, basicBidRequest, {mediaType: 'banner', size: [300, 250]})).to.deep.equal({
         floorMin: 0,
@@ -490,10 +560,8 @@ describe('the price floors module', function () {
         matchingFloor: undefined
       });
       // if default is there use it
-      inputFloorData = { default: 5.0 };
-      expect(getFirstMatchingFloor(inputFloorData, basicBidRequest, {mediaType: 'banner', size: '*'})).to.deep.equal({
-        matchingFloor: 5.0
-      });
+      inputFloorData = normalizeDefault({ default: 5.0 });
+      expect(getFirstMatchingFloor(inputFloorData, basicBidRequest, {mediaType: 'banner', size: '*'}).matchingFloor).to.equal(5.0);
     });
     describe('with gpt enabled', function () {
       let gptFloorData;
@@ -693,6 +761,95 @@ describe('the price floors module', function () {
         floorProvider: undefined
       });
     });
+    describe('default floor', () => {
+      let adUnits;
+      beforeEach(() => {
+        adUnits = ['au1', 'au2'].map(getAdUnitMock);
+      })
+      function expectFloors(floors) {
+        runStandardAuction(adUnits);
+        adUnits.forEach((au, i) => {
+          au.bids.forEach(bid => {
+            expect(bid.getFloor().floor).to.eql(floors[i]);
+          })
+        })
+      }
+      describe('should be sufficient by itself', () => {
+        it('globally', () => {
+          handleSetFloorsConfig({
+            ...basicFloorConfig,
+            data: {
+              default: 1.23
+            }
+          });
+          expectFloors([1.23, 1.23])
+        });
+        it('on adUnits', () => {
+          handleSetFloorsConfig({
+            ...basicFloorConfig,
+            data: undefined
+          });
+          adUnits[0].floors = {default: 1};
+          adUnits[1].floors = {default: 2};
+          expectFloors([1, 2])
+        });
+        it('on an adUnit with hidden schema', () => {
+          handleSetFloorsConfig({
+            ...basicFloorConfig,
+            data: undefined
+          });
+          adUnits[0].floors = {
+            schema: {
+              fields: ['mediaType', 'gptSlot'],
+            },
+            default: 1
+          }
+          adUnits[1].floors = {
+            default: 2
+          }
+          expectFloors([1, 2]);
+        })
+      });
+      describe('should NOT be used when a star rule exists', () => {
+        it('globally', () => {
+          handleSetFloorsConfig({
+            ...basicFloorConfig,
+            data: {
+              schema: {
+                fields: ['mediaType', 'gptSlot'],
+              },
+              values: {
+                '*|*': 2
+              },
+              default: 3,
+            }
+          });
+          expectFloors([2, 2]);
+        });
+        it('on adUnits', () => {
+          handleSetFloorsConfig({
+            ...basicFloorConfig,
+            data: undefined
+          });
+          adUnits[0].floors = {
+            schema: {
+              fields: ['mediaType', 'gptSlot'],
+            },
+            values: {
+              '*|*': 1
+            },
+            default: 3
+          };
+          adUnits[1].floors = {
+            values: {
+              '*|*': 2
+            },
+            default: 4
+          }
+          expectFloors([1, 2]);
+        })
+      });
+    })
     it('bidRequests should have getFloor function and flooring meta data when setConfig occurs', function () {
       handleSetFloorsConfig({...basicFloorConfig, floorProvider: 'floorprovider'});
       runStandardAuction();
@@ -1382,7 +1539,7 @@ describe('the price floors module', function () {
       it('picks the right rule with more complex rules', function () {
         _floorDataForAuction[bidRequest.auctionId] = {
           ...basicFloorConfig,
-          data: {
+          data: normalizeDefault({
             currency: 'USD',
             schema: { fields: ['mediaType', 'size'], delimiter: '|' },
             values: {
@@ -1394,7 +1551,7 @@ describe('the price floors module', function () {
               'video|*': 5.5
             },
             default: 10.0
-          }
+          })
         };
 
         // assumes banner *